fix: repair pagination_cursors composite PK and isolate test suites (#265)

## What

Two fixes found during post-merge testing of #262:

### CLI-72: `pagination_cursors` wrong primary key

Migration 4→5 used `CREATE TABLE IF NOT EXISTS`, so any DB that already
had `pagination_cursors` from an earlier code path kept a single-column
PK (`command_key TEXT PRIMARY KEY`) instead of the required composite PK
(`PRIMARY KEY (command_key, context)`). This caused a runtime crash on
the first `--cursor last` use:

```
SQLiteError: ON CONFLICT clause does not match any PRIMARY KEY or UNIQUE constraint
```

**Fix:**
- Schema version bumped to 6 with a migration that detects the wrong PK,
drops the table, and recreates it correctly. Cursor data loss is safe
(5-min TTL).
- `repairWrongPrimaryKeys()` added to `repairSchema()` so auto-repair
also catches this.
- `isSchemaError()` extended to recognise the ON CONFLICT error and
trigger auto-repair.
- New `wrong_primary_key` `SchemaIssue` variant surfaced in
`getSchemaIssues()` and `sentry cli fix`.

### Test isolation: `bun test` caused ~130 spurious failures locally

`"test": "bun test"` ran all files in one process.
`test/isolated/resolve-target.test.ts` uses `mock.module()` which leaks
global module state across files, poisoning `api-client.js`,
`db/defaults.js`, and others for all subsequent tests.

**Fix:** Change the `test` script to `bun run test:unit && bun run
test:isolated` so each suite runs in a separate Bun process. The split
was already documented in `AGENTS.md`; the top-level script just wasn't
using it.

## Result

`bun run test`: 1931 tests, 0 failures (was 130 failures).

Author: BYK

package.json

@@ -17,7 +17,7 @@
     "typecheck": "tsc --noEmit",
     "lint": "bunx ultracite check",
     "lint:fix": "bunx ultracite fix",
-    "test": "bun test",
+    "test": "bun run test:unit && bun run test:isolated",
     "test:unit": "bun test test/lib test/commands test/types --coverage --coverage-reporter=lcov",
     "test:isolated": "bun test test/isolated",
     "test:e2e": "bun test test/e2e",

src/commands/cli/fix.ts

@@ -24,7 +24,10 @@ function formatIssue(issue: SchemaIssue): string {
   if (issue.type === "missing_table") {
     return `Missing table: ${issue.table}`;
   }
-  return `Missing column: ${issue.table}.${issue.column}`;
+  if (issue.type === "missing_column") {
+    return `Missing column: ${issue.table}.${issue.column}`;
+  }
+  return `Wrong primary key: ${issue.table}`;
 }
 
 /** Expected permissions for the config directory (owner rwx) */

src/lib/db/schema.ts

@@ -14,7 +14,7 @@
 import type { Database } from "bun:sqlite";
 import { stringifyUnknown } from "../errors.js";
 
-export const CURRENT_SCHEMA_VERSION = 5;
+export const CURRENT_SCHEMA_VERSION = 6;
 
 /** Environment variable to disable auto-repair */
 const NO_AUTO_REPAIR_ENV = "SENTRY_CLI_NO_AUTO_REPAIR";
@@ -330,6 +330,31 @@ export function hasColumn(
   return result.count > 0;
 }
 
+/**
+ * Check if a table has the expected composite primary key.
+ *
+ * Inspects the CREATE TABLE DDL stored in sqlite_master to verify
+ * the table has a table-level PRIMARY KEY constraint matching the
+ * expected columns. Returns false if the table uses per-column
+ * PRIMARY KEY instead (e.g., `command_key TEXT PRIMARY KEY`).
+ */
+function hasCompositePrimaryKey(
+  db: Database,
+  table: string,
+  expectedColumns: string[]
+): boolean {
+  const row = db
+    .query("SELECT sql FROM sqlite_master WHERE type='table' AND name=?")
+    .get(table) as { sql: string } | undefined;
+
+  if (!row) {
+    return false;
+  }
+
+  const expectedPK = `PRIMARY KEY (${expectedColumns.join(", ")})`;
+  return row.sql.includes(expectedPK);
+}
+
 /** Add a column to a table if it doesn't exist */
 function addColumnIfMissing(
   db: Database,
@@ -345,7 +370,33 @@ function addColumnIfMissing(
 /** Schema issue types for diagnostics */
 export type SchemaIssue =
   | { type: "missing_table"; table: string }
-  | { type: "missing_column"; table: string; column: string };
+  | { type: "missing_column"; table: string; column: string }
+  | { type: "wrong_primary_key"; table: string };
+
+function findMissingColumns(db: Database, tableName: string): SchemaIssue[] {
+  const columns = EXPECTED_COLUMNS[tableName];
+  if (!columns) {
+    return [];
+  }
+  return columns
+    .filter((col) => !hasColumn(db, tableName, col.name))
+    .map((col) => ({
+      type: "missing_column" as const,
+      table: tableName,
+      column: col.name,
+    }));
+}
+
+function findPrimaryKeyIssues(db: Database, tableName: string): SchemaIssue[] {
+  const schema = TABLE_SCHEMAS[tableName];
+  if (
+    schema?.compositePrimaryKey &&
+    !hasCompositePrimaryKey(db, tableName, schema.compositePrimaryKey)
+  ) {
+    return [{ type: "wrong_primary_key", table: tableName }];
+  }
+  return [];
+}
 
 /**
  * Check schema and return list of issues.
@@ -360,18 +411,8 @@ export function getSchemaIssues(db: Database): SchemaIssue[] {
       continue;
     }
 
-    const columns = EXPECTED_COLUMNS[tableName];
-    if (columns) {
-      for (const col of columns) {
-        if (!hasColumn(db, tableName, col.name)) {
-          issues.push({
-            type: "missing_column",
-            table: tableName,
-            column: col.name,
-          });
-        }
-      }
-    }
+    issues.push(...findMissingColumns(db, tableName));
+    issues.push(...findPrimaryKeyIssues(db, tableName));
   }
 
   return issues;
@@ -421,8 +462,42 @@ function repairMissingColumns(db: Database, result: RepairResult): void {
 }
 
 /**
- * Repair schema issues by creating missing tables and adding missing columns.
- * This is a non-destructive operation that only adds missing schema elements.
+ * Drop and recreate tables that have incorrect primary key constraints.
+ *
+ * This fixes the CLI-72 bug where pagination_cursors was created with a
+ * single-column PK (`command_key TEXT PRIMARY KEY`) instead of the expected
+ * composite PK (`PRIMARY KEY (command_key, context)`). SQLite does not
+ * support ALTER TABLE to change primary keys, so the table must be dropped
+ * and recreated. The data loss is acceptable since pagination cursors are
+ * ephemeral (5-minute TTL).
+ */
+function repairWrongPrimaryKeys(db: Database, result: RepairResult): void {
+  for (const [tableName, schema] of Object.entries(TABLE_SCHEMAS)) {
+    if (!schema.compositePrimaryKey) {
+      continue;
+    }
+    if (!tableExists(db, tableName)) {
+      continue;
+    }
+    if (hasCompositePrimaryKey(db, tableName, schema.compositePrimaryKey)) {
+      continue;
+    }
+    try {
+      db.exec(`DROP TABLE ${tableName}`);
+      db.exec(EXPECTED_TABLES[tableName] as string);
+      result.fixed.push(
+        `Recreated table ${tableName} with correct primary key`
+      );
+    } catch (e) {
+      const msg = stringifyUnknown(e);
+      result.failed.push(`Failed to recreate table ${tableName}: ${msg}`);
+    }
+  }
+}
+
+/**
+ * Repair schema issues by creating missing tables, adding missing columns,
+ * and recreating tables with incorrect primary key constraints.
  *
  * @param db - The raw database connection (not the traced wrapper)
  * @returns Lists of fixed and failed repairs
@@ -432,6 +507,7 @@ export function repairSchema(db: Database): RepairResult {
 
   repairMissingTables(db, result);
   repairMissingColumns(db, result);
+  repairWrongPrimaryKeys(db, result);
 
   if (result.fixed.length > 0) {
     try {
@@ -458,7 +534,8 @@ function isSchemaError(error: unknown): boolean {
     return (
       msg.includes("no such column") ||
       msg.includes("no such table") ||
-      msg.includes("has no column named")
+      msg.includes("has no column named") ||
+      msg.includes("on conflict clause does not match")
     );
   }
   return false;
@@ -615,6 +692,22 @@ export function runMigrations(db: Database): void {
     db.exec(EXPECTED_TABLES.pagination_cursors as string);
   }
 
+  // Migration 5 -> 6: Repair pagination_cursors if created with wrong PK (CLI-72)
+  // Earlier versions could create the table with a single-column PK instead of
+  // the composite PK (command_key, context). DROP + CREATE is safe because
+  // pagination cursors are ephemeral (5-minute TTL).
+  if (
+    currentVersion < 6 &&
+    tableExists(db, "pagination_cursors") &&
+    !hasCompositePrimaryKey(db, "pagination_cursors", [
+      "command_key",
+      "context",
+    ])
+  ) {
+    db.exec("DROP TABLE pagination_cursors");
+    db.exec(EXPECTED_TABLES.pagination_cursors as string);
+  }
+
   if (currentVersion < CURRENT_SCHEMA_VERSION) {
     db.query("UPDATE schema_version SET version = ?").run(
       CURRENT_SCHEMA_VERSION

test/commands/cli/fix.test.ts

@@ -367,4 +367,59 @@ describe("sentry cli fix", () => {
     // Should NOT print "Could not open database" since permission issues explain it
     expect(stderr).not.toContain("Could not open database");
   });
+
+  test("detects and repairs wrong primary key on pagination_cursors (CLI-72)", async () => {
+    const dbPath = join(getTestDir(), "cli.db");
+    const db = new Database(dbPath);
+    // Create a full schema but with the buggy pagination_cursors table
+    initSchema(db);
+    db.exec("DROP TABLE pagination_cursors");
+    db.exec(
+      "CREATE TABLE pagination_cursors (command_key TEXT PRIMARY KEY, context TEXT NOT NULL, cursor TEXT NOT NULL, expires_at INTEGER NOT NULL)"
+    );
+    db.close();
+    chmodSync(dbPath, 0o600);
+
+    // Warm the DB cache so getRawDatabase() uses this pre-repaired DB
+    getDatabase();
+
+    const { stdout, exitCode } = await runFix(false);
+
+    expect(stdout).toContain("schema issue(s)");
+    expect(stdout).toContain("Wrong primary key");
+    expect(stdout).toContain("pagination_cursors");
+    expect(stdout).toContain("Repairing schema");
+    expect(stdout).toContain("repaired successfully");
+    expect(exitCode).toBe(0);
+  });
+
+  test("dry-run detects wrong primary key without repairing", async () => {
+    const dbPath = join(getTestDir(), "cli.db");
+    const db = new Database(dbPath);
+    initSchema(db);
+    db.exec("DROP TABLE pagination_cursors");
+    db.exec(
+      "CREATE TABLE pagination_cursors (command_key TEXT PRIMARY KEY, context TEXT NOT NULL, cursor TEXT NOT NULL, expires_at INTEGER NOT NULL)"
+    );
+    db.close();
+    chmodSync(dbPath, 0o600);
+
+    getDatabase();
+
+    const { stdout } = await runFix(true);
+
+    expect(stdout).toContain("Wrong primary key");
+    expect(stdout).toContain("pagination_cursors");
+    expect(stdout).toContain("Run 'sentry cli fix' to apply fixes");
+    // Table should still have the wrong PK
+    closeDatabase();
+    const verifyDb = new Database(dbPath);
+    const row = verifyDb
+      .query(
+        "SELECT sql FROM sqlite_master WHERE type='table' AND name='pagination_cursors'"
+      )
+      .get() as { sql: string };
+    expect(row.sql).not.toContain("PRIMARY KEY (command_key, context)");
+    verifyDb.close();
+  });
 });