@prisma-next/target-sqlite 0.5.0-dev.67 → 0.5.0-dev.68

package/src/core/migrations/runner.ts

@@ -1,6 +1,7 @@
 import type { ContractMarkerRecord } from '@prisma-next/contract/types';
 import type {
   MigrationOperationPolicy,
+  MultiSpaceRunnerResult,
   SqlControlFamilyInstance,
   SqlMigrationPlanContractInfo,
   SqlMigrationPlanOperation,
@@ -9,13 +10,16 @@ import type {
   SqlMigrationRunnerExecuteOptions,
   SqlMigrationRunnerFailure,
   SqlMigrationRunnerResult,
+  SqlMigrationRunnerSuccessValue,
 } from '@prisma-next/family-sql/control';
 import { runnerFailure, runnerSuccess } from '@prisma-next/family-sql/control';
 import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
 import { type ContractMarkerRow, parseContractMarkerRow } from '@prisma-next/family-sql/verify';
+import type { ControlDriverInstance } from '@prisma-next/framework-components/control';
+import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { Result } from '@prisma-next/utils/result';
-import { ok, okVoid } from '@prisma-next/utils/result';
+import { notOk, ok, okVoid } from '@prisma-next/utils/result';
 import { parseSqliteDefault } from '../default-normalizer';
 import { normalizeSqliteNativeType } from '../native-type-normalizer';
 import type { SqlitePlanTargetDetails } from './planner-target-details';
@@ -47,14 +51,10 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
       options.plan.destination,
       options.destinationContract,
     );
-    if (!destinationCheck.ok) {
-      return destinationCheck;
-    }
+    if (!destinationCheck.ok) return destinationCheck;
 
     const policyCheck = this.enforcePolicyCompatibility(options.policy, options.plan.operations);
-    if (!policyCheck.ok) {
-      return policyCheck;
-    }
+    if (!policyCheck.ok) return policyCheck;
 
     // SQLite recreate-table drops and rebuilds the table. If foreign_keys is ON,
     // dropping a referenced parent cascade-deletes child rows; we must disable FK
@@ -70,92 +70,180 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
       await this.beginExclusiveTransaction(driver);
       let committed = false;
       try {
-        const ensureResult = await this.ensureControlTables(driver);
-        if (!ensureResult.ok) {
-          return ensureResult;
-        }
-        const existingMarker = await this.readMarker(driver, options.plan.spaceId);
+        const result = await this.executeOnConnection(options);
+        if (!result.ok) return result;
 
-        const markerCheck = this.ensureMarkerCompatibility(existingMarker, options.plan);
-        if (!markerCheck.ok) {
-          return markerCheck;
+        if (fkWasEnabled) {
+          const fkIntegrityCheck = await this.verifyForeignKeyIntegrity(driver);
+          if (!fkIntegrityCheck.ok) return fkIntegrityCheck;
         }
 
-        const markerAtDestination = this.markerMatchesDestination(existingMarker, options.plan);
-        const isSelfEdge =
-          options.plan.origin?.storageHash === options.plan.destination.storageHash;
-        const skipOperations = markerAtDestination && options.plan.origin != null && !isSelfEdge;
-
-        let operationsExecuted: number;
-        let executedOperations: readonly SqlMigrationPlanOperation<SqlitePlanTargetDetails>[];
-
-        if (skipOperations) {
-          operationsExecuted = 0;
-          executedOperations = [];
-        } else {
-          const applyResult = await this.applyPlan(driver, options);
-          if (!applyResult.ok) {
-            return applyResult;
-          }
-          operationsExecuted = applyResult.value.operationsExecuted;
-          executedOperations = applyResult.value.executedOperations;
+        await this.commitTransaction(driver);
+        committed = true;
+        return result;
+      } finally {
+        if (!committed) {
+          await this.rollbackTransaction(driver);
         }
+      }
+    } finally {
+      if (fkWasEnabled) {
+        await driver.query('PRAGMA foreign_keys = ON');
+      }
+    }
+  }
 
-        const schemaIR = await this.family.introspect({
-          driver,
-          contract: options.destinationContract,
-        });
+  /**
+   * Apply the plan against an already-open connection without managing
+   * the transaction lifecycle. The caller owns BEGIN/COMMIT/ROLLBACK
+   * and any connection-level setup (FK pragma toggle, FK integrity
+   * check). Used by the per-space runner orchestration to fan out
+   * across contract spaces inside one outer transaction.
+   */
+  async executeOnConnection(
+    options: SqlMigrationRunnerExecuteOptions<SqlitePlanTargetDetails>,
+  ): Promise<SqlMigrationRunnerResult> {
+    const driver = options.driver;
+    if (options.space !== undefined && options.space !== options.plan.spaceId) {
+      throw new Error(
+        `SqlMigrationRunner: options.space (${options.space}) does not match plan.spaceId (${options.plan.spaceId})`,
+      );
+    }
+    const space = options.plan.spaceId;
 
-        const schemaVerifyResult = verifySqlSchema({
-          contract: options.destinationContract,
-          schema: schemaIR,
-          strict: options.strictVerification ?? true,
-          context: options.context ?? {},
-          typeMetadataRegistry: this.family.typeMetadataRegistry,
-          frameworkComponents: options.frameworkComponents,
-          normalizeDefault: parseSqliteDefault,
-          normalizeNativeType: normalizeSqliteNativeType,
+    const destinationCheck = this.ensurePlanMatchesDestinationContract(
+      options.plan.destination,
+      options.destinationContract,
+    );
+    if (!destinationCheck.ok) return destinationCheck;
+
+    const policyCheck = this.enforcePolicyCompatibility(options.policy, options.plan.operations);
+    if (!policyCheck.ok) return policyCheck;
+
+    const ensureResult = await this.ensureControlTables(driver);
+    if (!ensureResult.ok) return ensureResult;
+    const existingMarker = await this.readMarker(driver, space);
+
+    const markerCheck = this.ensureMarkerCompatibility(existingMarker, options.plan);
+    if (!markerCheck.ok) return markerCheck;
+
+    const markerAtDestination = this.markerMatchesDestination(existingMarker, options.plan);
+    const isSelfEdge = options.plan.origin?.storageHash === options.plan.destination.storageHash;
+    const skipOperations = markerAtDestination && options.plan.origin != null && !isSelfEdge;
+
+    let operationsExecuted: number;
+    let executedOperations: readonly SqlMigrationPlanOperation<SqlitePlanTargetDetails>[];
+
+    if (skipOperations) {
+      operationsExecuted = 0;
+      executedOperations = [];
+    } else {
+      const applyResult = await this.applyPlan(driver, options);
+      if (!applyResult.ok) return applyResult;
+      operationsExecuted = applyResult.value.operationsExecuted;
+      executedOperations = applyResult.value.executedOperations;
+    }
+
+    if (space === APP_SPACE_ID) {
+      const schemaIR = await this.family.introspect({
+        driver,
+        contract: options.destinationContract,
+      });
+
+      const schemaVerifyResult = verifySqlSchema({
+        contract: options.destinationContract,
+        schema: schemaIR,
+        strict: options.strictVerification ?? true,
+        context: options.context ?? {},
+        typeMetadataRegistry: this.family.typeMetadataRegistry,
+        frameworkComponents: options.frameworkComponents,
+        normalizeDefault: parseSqliteDefault,
+        normalizeNativeType: normalizeSqliteNativeType,
+      });
+      if (!schemaVerifyResult.ok) {
+        return runnerFailure('SCHEMA_VERIFY_FAILED', schemaVerifyResult.summary, {
+          why: 'The resulting database schema does not satisfy the destination contract.',
+          meta: { issues: schemaVerifyResult.schema.issues },
         });
-        if (!schemaVerifyResult.ok) {
-          return runnerFailure('SCHEMA_VERIFY_FAILED', schemaVerifyResult.summary, {
-            why: 'The resulting database schema does not satisfy the destination contract.',
-            meta: {
-              issues: schemaVerifyResult.schema.issues,
-            },
-          });
-        }
+      }
+    }
 
-        // Self-edge no-op detection: a self-edge migration whose ops had no
-        // ops to begin with and brings no new invariants produced no
-        // observable change. Skip the marker + ledger writes so an idempotent
-        // re-apply of a self-edge data transform doesn't churn updatedAt or
-        // pile up empty ledger entries. db update no-ops still write a
-        // ledger entry as audit trail.
-        const incomingInvariants = options.plan.providedInvariants;
-        const existingInvariants = new Set(existingMarker?.invariants ?? []);
-        const incomingIsSubsetOfExisting = incomingInvariants.every((id) =>
-          existingInvariants.has(id),
-        );
-        const isSelfEdgeNoOp = isSelfEdge && operationsExecuted === 0 && incomingIsSubsetOfExisting;
+    // Self-edge no-op detection: see Postgres runner for the rationale
+    // (kept symmetric across both targets).
+    const incomingInvariants = options.plan.providedInvariants;
+    const existingInvariants = new Set(existingMarker?.invariants ?? []);
+    const incomingIsSubsetOfExisting = incomingInvariants.every((id) => existingInvariants.has(id));
+    const isSelfEdgeNoOp = isSelfEdge && operationsExecuted === 0 && incomingIsSubsetOfExisting;
+
+    if (!isSelfEdgeNoOp) {
+      await this.upsertMarker(driver, options, existingMarker, space);
+      await this.recordLedgerEntry(driver, options, existingMarker, executedOperations);
+    }
+
+    return runnerSuccess({
+      operationsPlanned: options.plan.operations.length,
+      operationsExecuted,
+    });
+  }
+
+  async executeAcrossSpaces(options: {
+    readonly driver: ControlDriverInstance<'sql', string>;
+    readonly perSpaceOptions: ReadonlyArray<
+      SqlMigrationRunnerExecuteOptions<SqlitePlanTargetDetails>
+    >;
+  }): Promise<MultiSpaceRunnerResult> {
+    const driver = options.driver;
+    const perSpaceOptions = options.perSpaceOptions;
 
-        if (!isSelfEdgeNoOp) {
-          await this.upsertMarker(driver, options, existingMarker);
-          await this.recordLedgerEntry(driver, options, existingMarker, executedOperations);
+    if (perSpaceOptions.length === 0) {
+      return ok({ perSpaceResults: [] });
+    }
+
+    // FK pragma toggle and the FK integrity check both span the outer
+    // transaction — see `execute(...)` for the full rationale.
+    const fkWasEnabled = await this.readForeignKeysEnabled(driver);
+    if (fkWasEnabled) {
+      await driver.query('PRAGMA foreign_keys = OFF');
+    }
+
+    try {
+      await this.beginExclusiveTransaction(driver);
+      let committed = false;
+      try {
+        const perSpaceResults: Array<{
+          space: string;
+          value: SqlMigrationRunnerSuccessValue;
+        }> = [];
+        let lastProcessedSpace: string | undefined;
+        for (const spaceOptions of perSpaceOptions) {
+          const space = spaceOptions.space ?? spaceOptions.plan.spaceId;
+          const result = await this.executeOnConnection({ ...spaceOptions, driver, space });
+          if (!result.ok) {
+            return notOk({ ...result.failure, failingSpace: space });
+          }
+          perSpaceResults.push({ space, value: result.value });
+          lastProcessedSpace = space;
         }
 
         if (fkWasEnabled) {
           const fkIntegrityCheck = await this.verifyForeignKeyIntegrity(driver);
           if (!fkIntegrityCheck.ok) {
-            return fkIntegrityCheck;
+            // Post-loop integrity violations cannot be attributed to a
+            // single per-space step (the cumulative effect of all
+            // applied plans was needed to reveal the broken
+            // reference). Surface the last successfully-applied space
+            // so operators can investigate from the most recent
+            // migration first.
+            return notOk({
+              ...fkIntegrityCheck.failure,
+              failingSpace: lastProcessedSpace ?? APP_SPACE_ID,
+            });
           }
         }
 
         await this.commitTransaction(driver);
         committed = true;
-        return runnerSuccess({
-          operationsPlanned: options.plan.operations.length,
-          operationsExecuted,
-        });
+        return ok({ perSpaceResults });
       } finally {
         if (!committed) {
           await this.rollbackTransaction(driver);
@@ -560,6 +648,7 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
     driver: SqlMigrationRunnerExecuteOptions<SqlitePlanTargetDetails>['driver'],
     options: SqlMigrationRunnerExecuteOptions<SqlitePlanTargetDetails>,
     existingMarker: ContractMarkerRecord | null,
+    space: string,
   ): Promise<void> {
     // SQLite has no native array type, so we can't merge invariants in SQL
     // the way Postgres does. Merge client-side under the runner's
@@ -568,7 +657,7 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
     for (const inv of options.plan.providedInvariants) merged.add(inv);
     const invariants = Array.from(merged).sort();
     const writeStatements = buildWriteMarkerStatements({
-      space: options.plan.spaceId,
+      space,
       storageHash: options.plan.destination.storageHash,
       profileHash:
         options.plan.destination.profileHash ??

package/src/exports/migration.ts

@@ -15,6 +15,7 @@ export {
   dataTransform,
 } from '../core/migrations/operations/data-transform';
 export { createIndex, dropIndex } from '../core/migrations/operations/indexes';
+export { rawSql } from '../core/migrations/operations/raw';
 export { createTable, dropTable, recreateTable } from '../core/migrations/operations/tables';
 // Target-owned base class for migrations. Aliased to `Migration` so
 // user-edited migration.ts files (and the renderer's scaffold) read as

package/src/exports/op-factory-call.ts

@@ -6,6 +6,7 @@ export {
   DropColumnCall,
   DropIndexCall,
   DropTableCall,
+  RawSqlCall,
   RecreateTableCall,
   type SqliteOpFactoryCall,
 } from '../core/migrations/op-factory-call';

package/dist/statement-builders-DMT4ltXR.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"statement-builders-DMT4ltXR.mjs","names":[],"sources":["../src/core/migrations/statement-builders.ts"],"sourcesContent":["import { APP_SPACE_ID } from '@prisma-next/framework-components/control';\n\nexport { APP_SPACE_ID };\n\nexport interface SqlStatement {\n  readonly sql: string;\n  readonly params: readonly unknown[];\n}\n\nexport const MARKER_TABLE_NAME = '_prisma_marker';\nexport const LEDGER_TABLE_NAME = '_prisma_ledger';\n\n/**\n * Control tables the runner creates/manages. The planner must not drop these\n * when reconciling \"extra\" tables against the contract.\n */\nexport const CONTROL_TABLE_NAMES: ReadonlySet<string> = new Set([\n  MARKER_TABLE_NAME,\n  LEDGER_TABLE_NAME,\n]);\n\n/**\n * Schema for `_prisma_marker`. The `space TEXT PRIMARY KEY` shape\n * supports one row per loaded contract space (`'app'`,\n * `'<extension-id>'`, …); brand-new databases create this shape\n * directly. The migration runner detects pre-1.0 single-row markers\n * (no `space` column) at boot and fails with a structured\n * `LEGACY_MARKER_SHAPE` error rather than auto-rebuilding the table —\n * see `specs/framework-mechanism.spec.md § 2`.\n */\nexport const ensureMarkerTableStatement: SqlStatement = {\n  sql: `CREATE TABLE IF NOT EXISTS _prisma_marker (\n    space TEXT NOT NULL PRIMARY KEY DEFAULT '${APP_SPACE_ID}',\n    core_hash TEXT NOT NULL,\n    profile_hash TEXT NOT NULL,\n    contract_json TEXT,\n    canonical_version INTEGER,\n    updated_at TEXT NOT NULL DEFAULT (datetime('now')),\n    app_tag TEXT,\n    meta TEXT NOT NULL DEFAULT '{}',\n    invariants TEXT NOT NULL DEFAULT '[]'\n  )`,\n  params: [],\n};\n\nexport const ensureLedgerTableStatement: SqlStatement = {\n  sql: `CREATE TABLE IF NOT EXISTS _prisma_ledger (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    created_at TEXT NOT NULL DEFAULT (datetime('now')),\n    origin_core_hash TEXT,\n    origin_profile_hash TEXT,\n    destination_core_hash TEXT NOT NULL,\n    destination_profile_hash TEXT,\n    contract_json_before TEXT,\n    contract_json_after TEXT,\n    operations TEXT NOT NULL\n  )`,\n  params: [],\n};\n\nexport function readMarkerStatement(space: string): SqlStatement {\n  return {\n    sql: `SELECT\n      core_hash,\n      profile_hash,\n      contract_json,\n      canonical_version,\n      updated_at,\n      app_tag,\n      meta,\n      invariants\n    FROM _prisma_marker\n    WHERE space = ?`,\n    params: [space],\n  };\n}\n\nexport interface WriteMarkerInput {\n  /**\n   * Logical space identifier for this marker row. Required at every\n   * call site so the type system surfaces every place that needs to\n   * thread the value (rather than letting an `?? APP_SPACE_ID`\n   * fall-through silently collapse multi-space markers onto the\n   * `'app'` row). App-plan callers pass {@link APP_SPACE_ID}\n   * (`'app'`); per-extension callers pass the extension's space id.\n   */\n  readonly space: string;\n  readonly storageHash: string;\n  readonly profileHash: string;\n  readonly contractJson?: unknown;\n  readonly canonicalVersion?: number | null;\n  readonly appTag?: string | null;\n  readonly meta?: Record<string, unknown>;\n  /**\n   * Invariants to write into `marker.invariants`. Stored as a JSON-encoded\n   * TEXT array — SQLite has no native array type. The runner is responsible\n   * for merging with the existing column (no SQL-side merge here, unlike\n   * Postgres) before passing them in: BEGIN EXCLUSIVE on the migration\n   * transaction makes the read-then-merge-then-write sequence safe.\n   */\n  readonly invariants: readonly string[];\n}\n\nexport function buildWriteMarkerStatements(input: WriteMarkerInput): {\n  readonly insert: SqlStatement;\n  readonly update: SqlStatement;\n} {\n  const params: readonly unknown[] = [\n    input.space,\n    input.storageHash,\n    input.profileHash,\n    jsonParam(input.contractJson),\n    input.canonicalVersion ?? null,\n    input.appTag ?? null,\n    jsonParam(input.meta ?? {}),\n    jsonParam(input.invariants),\n  ];\n\n  return {\n    insert: {\n      sql: `INSERT INTO _prisma_marker (\n        space,\n        core_hash,\n        profile_hash,\n        contract_json,\n        canonical_version,\n        updated_at,\n        app_tag,\n        meta,\n        invariants\n      ) VALUES (\n        ?,\n        ?,\n        ?,\n        ?,\n        ?,\n        datetime('now'),\n        ?,\n        ?,\n        ?\n      )`,\n      params,\n    },\n    update: {\n      sql: `UPDATE _prisma_marker SET\n        core_hash = ?,\n        profile_hash = ?,\n        contract_json = ?,\n        canonical_version = ?,\n        updated_at = datetime('now'),\n        app_tag = ?,\n        meta = ?,\n        invariants = ?\n      WHERE space = ?`,\n      params: [\n        input.storageHash,\n        input.profileHash,\n        jsonParam(input.contractJson),\n        input.canonicalVersion ?? null,\n        input.appTag ?? null,\n        jsonParam(input.meta ?? {}),\n        jsonParam(input.invariants),\n        input.space,\n      ],\n    },\n  };\n}\n\nexport interface LedgerInsertInput {\n  readonly originStorageHash?: string | null;\n  readonly originProfileHash?: string | null;\n  readonly destinationStorageHash: string;\n  readonly destinationProfileHash?: string | null;\n  readonly contractJsonBefore?: unknown;\n  readonly contractJsonAfter?: unknown;\n  readonly operations: unknown;\n}\n\nexport function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStatement {\n  return {\n    sql: `INSERT INTO _prisma_ledger (\n      origin_core_hash,\n      origin_profile_hash,\n      destination_core_hash,\n      destination_profile_hash,\n      contract_json_before,\n      contract_json_after,\n      operations\n    ) VALUES (\n      ?,\n      ?,\n      ?,\n      ?,\n      ?,\n      ?,\n      ?\n    )`,\n    params: [\n      input.originStorageHash ?? null,\n      input.originProfileHash ?? null,\n      input.destinationStorageHash,\n      input.destinationProfileHash ?? null,\n      jsonParam(input.contractJsonBefore),\n      jsonParam(input.contractJsonAfter),\n      jsonParam(input.operations),\n    ],\n  };\n}\n\nfunction jsonParam(value: unknown): string {\n  return JSON.stringify(value ?? null);\n}\n"],"mappings":";;AASA,MAAa,oBAAoB;AACjC,MAAa,oBAAoB;;;;;AAMjC,MAAa,sBAA2C,IAAI,IAAI,CAC9D,mBACA,kBACD,CAAC;;;;;;;;;;AAWF,MAAa,6BAA2C;CACtD,KAAK;+CACwC,aAAa;;;;;;;;;;CAU1D,QAAQ,EAAE;CACX;AAED,MAAa,6BAA2C;CACtD,KAAK;;;;;;;;;;;CAWL,QAAQ,EAAE;CACX;AAED,SAAgB,oBAAoB,OAA6B;CAC/D,OAAO;EACL,KAAK;;;;;;;;;;;EAWL,QAAQ,CAAC,MAAM;EAChB;;AA6BH,SAAgB,2BAA2B,OAGzC;CAYA,OAAO;EACL,QAAQ;GACN,KAAK;;;;;;;;;;;;;;;;;;;;;GAqBL,QAAA;IAjCF,MAAM;IACN,MAAM;IACN,MAAM;IACN,UAAU,MAAM,aAAa;IAC7B,MAAM,oBAAoB;IAC1B,MAAM,UAAU;IAChB,UAAU,MAAM,QAAQ,EAAE,CAAC;IAC3B,UAAU,MAAM,WAAW;IA0BnB;GACP;EACD,QAAQ;GACN,KAAK;;;;;;;;;;GAUL,QAAQ;IACN,MAAM;IACN,MAAM;IACN,UAAU,MAAM,aAAa;IAC7B,MAAM,oBAAoB;IAC1B,MAAM,UAAU;IAChB,UAAU,MAAM,QAAQ,EAAE,CAAC;IAC3B,UAAU,MAAM,WAAW;IAC3B,MAAM;IACP;GACF;EACF;;AAaH,SAAgB,2BAA2B,OAAwC;CACjF,OAAO;EACL,KAAK;;;;;;;;;;;;;;;;;EAiBL,QAAQ;GACN,MAAM,qBAAqB;GAC3B,MAAM,qBAAqB;GAC3B,MAAM;GACN,MAAM,0BAA0B;GAChC,UAAU,MAAM,mBAAmB;GACnC,UAAU,MAAM,kBAAkB;GAClC,UAAU,MAAM,WAAW;GAC5B;EACF;;AAGH,SAAS,UAAU,OAAwB;CACzC,OAAO,KAAK,UAAU,SAAS,KAAK"}