@prisma-next/adapter-sqlite 0.12.0-dev.4 → 0.12.0-dev.40

package/src/core/control-adapter.ts

@@ -1,4 +1,4 @@
-import type { ContractMarkerRecord } from '@prisma-next/contract/types';
+import type { ContractMarkerRecord, LedgerEntryRecord } from '@prisma-next/contract/types';
 import { parseMarkerRowSafely, withMarkerReadErrorHandling } from '@prisma-next/errors/execution';
 import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
 import { parseContractMarkerRow } from '@prisma-next/family-sql/verify';
@@ -6,11 +6,15 @@ import {
   APP_SPACE_ID,
   type ControlDriverInstance,
 } from '@prisma-next/framework-components/control';
+import { ledgerOriginFromStored } from '@prisma-next/migration-tools/ledger-origin';
 import type {
   AnyQueryAst,
+  DdlNode,
   LoweredStatement,
   LowererContext,
+  MarkerReadResult,
 } from '@prisma-next/sql-relational-core/ast';
+import { isDdlNode } from '@prisma-next/sql-relational-core/ast';
 import type {
   PrimaryKey,
   SqlColumnIR,
@@ -21,36 +25,42 @@ import type {
   SqlTableIR,
   SqlUniqueIR,
 } from '@prisma-next/sql-schema-ir/types';
+import {
+  buildControlTableBootstrapQueries,
+  buildSignMarkerBootstrapQueries,
+} from '@prisma-next/target-sqlite/contract-free';
+import type { SqliteDdlNode } from '@prisma-next/target-sqlite/ddl';
 import { parseSqliteDefault } from '@prisma-next/target-sqlite/default-normalizer';
 import { normalizeSqliteNativeType } from '@prisma-next/target-sqlite/native-type-normalizer';
+import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { renderLoweredSql } from './adapter';
+import { renderLoweredDdl } from './ddl-renderer';
+import { coerceLedgerAppliedAt, operationCountFromStored } from './ledger-decode';
+import {
+  decodeSqliteMarkerRow,
+  execute,
+  ledger,
+  ledgerReadShape,
+  marker,
+  mergeInvariants,
+  NOW,
+  sqliteCatalog,
+} from './marker-ledger';
 import type { SqliteContract } from './types';
 
 const SQLITE_MARKER_TABLE = '_prisma_marker';
-
-/**
- * SQLite stores arrays as JSON-encoded TEXT (no native array type), so the
- * driver returns `invariants` as a string. Decode before delegating to the
- * shared row schema, which expects `string[]`. A non-JSON value here is a
- * corrupt row and surfaces as `Invalid contract marker row: …` via the
- * typed-envelope wrapper.
- */
-function decodeSqliteMarkerRow(row: unknown): unknown {
-  if (typeof row !== 'object' || row === null || !('invariants' in row)) {
-    return row;
-  }
-  const record = row as { invariants: unknown };
-  if (typeof record.invariants !== 'string') return row;
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(record.invariants);
-  } catch (err) {
-    const detail = err instanceof Error ? err.message : String(err);
-    throw new Error(`Invalid contract marker row: invariants is not valid JSON: ${detail}`);
-  }
-  return { ...record, invariants: parsed };
-}
+const SQLITE_LEDGER_TABLE = '_prisma_ledger';
+
+type SqliteLedgerRow = {
+  readonly space: string;
+  readonly migration_name: string;
+  readonly migration_hash: string;
+  readonly origin_core_hash: string | null;
+  readonly destination_core_hash: string;
+  readonly operations: unknown;
+  readonly created_at: Date | string;
+};
 
 // PRAGMA result row types
 type PragmaTableInfoRow = {
@@ -101,6 +111,14 @@ export class SqliteControlAdapter implements SqlControlAdapter<'sqlite'> {
   readonly normalizeDefault = parseSqliteDefault;
   readonly normalizeNativeType = normalizeSqliteNativeType;
 
+  bootstrapControlTableQueries(): readonly DdlNode[] {
+    return buildControlTableBootstrapQueries();
+  }
+
+  bootstrapSignMarkerQueries(): readonly DdlNode[] {
+    return buildSignMarkerBootstrapQueries();
+  }
+
   /**
    * Lower a SQL query AST into a SQLite-flavored `{ sql, params }` payload.
    *
@@ -109,7 +127,10 @@ export class SqliteControlAdapter implements SqlControlAdapter<'sqlite'> {
    * and contract. Used at migration plan/emit time (e.g. by `dataTransform`)
    * without instantiating the runtime adapter.
    */
-  lower(ast: AnyQueryAst, context: LowererContext<unknown>): LoweredStatement {
+  lower(ast: AnyQueryAst | SqliteDdlNode, context: LowererContext<unknown>): LoweredStatement {
+    if (isDdlNode(ast)) {
+      return renderLoweredDdl(ast);
+    }
     return renderLoweredSql(ast, context.contract as SqliteContract);
   }
 
@@ -122,53 +143,16 @@ export class SqliteControlAdapter implements SqlControlAdapter<'sqlite'> {
     driver: ControlDriverInstance<'sql', 'sqlite'>,
     space: string,
   ): Promise<ContractMarkerRecord | null> {
-    const markerContext = { space, markerLocation: SQLITE_MARKER_TABLE };
-    const exists = await withMarkerReadErrorHandling(
-      () =>
-        driver.query(`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?`, [
-          '_prisma_marker',
-        ]),
-      markerContext,
-    );
-    if (exists.rows.length === 0) {
-      return null;
-    }
-
-    const result = await withMarkerReadErrorHandling(
-      () =>
-        driver.query<{
-          core_hash: string;
-          profile_hash: string;
-          contract_json: unknown | null;
-          canonical_version: number | null;
-          updated_at: Date | string;
-          app_tag: string | null;
-          meta: unknown | null;
-          invariants: unknown;
-        }>(
-          `SELECT
-         core_hash,
-         profile_hash,
-         contract_json,
-         canonical_version,
-         updated_at,
-         app_tag,
-         meta,
-         invariants
-       FROM _prisma_marker
-       WHERE space = ?`,
-          [space],
-        ),
-      markerContext,
-    );
+    const result = await this.readMarkerDiscriminated(driver, space);
+    return result.kind === 'present' ? result.record : null;
+  }
 
-    const row = result.rows[0];
-    if (!row) return null;
-    return parseMarkerRowSafely(
-      row,
-      (raw) => parseContractMarkerRow(decodeSqliteMarkerRow(raw)),
-      markerContext,
-    );
+  async readMarkerDiscriminated(
+    driver: ControlDriverInstance<'sql', 'sqlite'>,
+    space: string,
+  ): Promise<MarkerReadResult> {
+    const markerContext = { space, markerLocation: SQLITE_MARKER_TABLE };
+    return withMarkerReadErrorHandling(() => this.readMarkerResult(driver, space), markerContext);
   }
 
   /**
@@ -180,48 +164,44 @@ export class SqliteControlAdapter implements SqlControlAdapter<'sqlite'> {
     driver: ControlDriverInstance<'sql', 'sqlite'>,
   ): Promise<ReadonlyMap<string, ContractMarkerRecord>> {
     const markerContext = { space: APP_SPACE_ID, markerLocation: SQLITE_MARKER_TABLE };
-    const exists = await withMarkerReadErrorHandling(
-      () =>
-        driver.query(`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?`, [
-          '_prisma_marker',
-        ]),
-      markerContext,
-    );
-    if (exists.rows.length === 0) {
+    return withMarkerReadErrorHandling(() => this.readAllMarkersResult(driver), markerContext);
+  }
+
+  private async readAllMarkersResult(
+    driver: ControlDriverInstance<'sql', 'sqlite'>,
+  ): Promise<ReadonlyMap<string, ContractMarkerRecord>> {
+    const lower = (query: AnyQueryAst) => this.lower(query, { contract: undefined });
+    const probe = sqliteCatalog
+      .select(sqliteCatalog.name)
+      .where(sqliteCatalog.type.eq('table').and(sqliteCatalog.name.eq('_prisma_marker')))
+      .build();
+    const exists = await execute(lower, driver, probe);
+    if (exists.length === 0) {
       return new Map();
     }
 
-    const result = await withMarkerReadErrorHandling(
-      () =>
-        driver.query<{
-          space: string;
-          core_hash: string;
-          profile_hash: string;
-          contract_json: unknown | null;
-          canonical_version: number | null;
-          updated_at: Date | string;
-          app_tag: string | null;
-          meta: unknown | null;
-          invariants: unknown;
-        }>(
-          `SELECT
-         space,
-         core_hash,
-         profile_hash,
-         contract_json,
-         canonical_version,
-         updated_at,
-         app_tag,
-         meta,
-         invariants
-       FROM _prisma_marker`,
-        ),
-      markerContext,
-    );
-
-    const rows = new Map<string, ContractMarkerRecord>();
-    for (const row of result.rows) {
-      rows.set(
+    const fetch = marker
+      .select(
+        marker.space,
+        marker.core_hash,
+        marker.profile_hash,
+        marker.contract_json,
+        marker.canonical_version,
+        marker.updated_at,
+        marker.app_tag,
+        marker.meta,
+        marker.invariants,
+      )
+      .build();
+    const rawRows = await execute(lower, driver, fetch);
+    const rows = blindCast<
+      ReadonlyArray<{ space: string } & Record<string, unknown>>,
+      'Driver returns rows shaped by SELECT'
+    >(rawRows);
+
+    const out = new Map<string, ContractMarkerRecord>();
+    for (const row of rows) {
+      out.set(
         row.space,
         parseMarkerRowSafely(row, (raw) => parseContractMarkerRow(decodeSqliteMarkerRow(raw)), {
           space: row.space,
@@ -229,7 +209,234 @@ export class SqliteControlAdapter implements SqlControlAdapter<'sqlite'> {
         }),
       );
     }
-    return rows;
+    return out;
+  }
+
+  /**
+   * Reads per-migration ledger rows from `_prisma_ledger` in apply order.
+   * Probes `sqlite_master` first so a fresh database without the ledger
+   * table returns `[]` instead of raising "no such table".
+   */
+  async readLedger(
+    driver: ControlDriverInstance<'sql', 'sqlite'>,
+    space?: string,
+  ): Promise<readonly LedgerEntryRecord[]> {
+    const ledgerContext = { space: space ?? '*', markerLocation: SQLITE_LEDGER_TABLE };
+    return withMarkerReadErrorHandling(() => this.readLedgerResult(driver, space), ledgerContext);
+  }
+
+  private async readLedgerResult(
+    driver: ControlDriverInstance<'sql', 'sqlite'>,
+    space: string | undefined,
+  ): Promise<readonly LedgerEntryRecord[]> {
+    const lower = (query: AnyQueryAst) => this.lower(query, { contract: undefined });
+    const probe = sqliteCatalog
+      .select(sqliteCatalog.name)
+      .where(sqliteCatalog.type.eq('table').and(sqliteCatalog.name.eq('_prisma_ledger')))
+      .build();
+    const exists = await execute(lower, driver, probe);
+    if (exists.length === 0) {
+      return [];
+    }
+
+    const base = ledgerReadShape.select(
+      ledgerReadShape.space,
+      ledgerReadShape.migration_name,
+      ledgerReadShape.migration_hash,
+      ledgerReadShape.origin_core_hash,
+      ledgerReadShape.destination_core_hash,
+      ledgerReadShape.operations,
+      ledgerReadShape.created_at,
+    );
+    const filtered = space !== undefined ? base.where(ledgerReadShape.space.eq(space)) : base;
+    const rawRows = await execute(lower, driver, filtered.orderBy(ledgerReadShape.id).build());
+    const rows = blindCast<readonly SqliteLedgerRow[], 'Driver returns rows shaped by SELECT'>(
+      rawRows,
+    );
+
+    return rows.map((row) => ({
+      space: row.space,
+      migrationName: row.migration_name,
+      migrationHash: row.migration_hash,
+      from: ledgerOriginFromStored(row.origin_core_hash),
+      to: row.destination_core_hash,
+      appliedAt: coerceLedgerAppliedAt(row.created_at),
+      operationCount: operationCountFromStored(row.operations),
+    }));
+  }
+
+  /**
+   * Stamps the initial marker row for `space` via the shared contract-free DML
+   * builder, lowered through {@link lower} and executed on the driver. See the
+   * `SqlControlAdapter.initMarker` contract.
+   */
+  async insertMarker(
+    driver: ControlDriverInstance<'sql', 'sqlite'>,
+    space: string,
+    destination: {
+      readonly storageHash: string;
+      readonly profileHash: string;
+      readonly invariants?: readonly string[];
+    },
+  ): Promise<void> {
+    await execute(
+      (query) => this.lower(query, { contract: undefined }),
+      driver,
+      marker
+        .insert({
+          space,
+          core_hash: destination.storageHash,
+          profile_hash: destination.profileHash,
+          contract_json: null,
+          canonical_version: null,
+          updated_at: NOW,
+          app_tag: null,
+          meta: {},
+          invariants: destination.invariants ?? [],
+        })
+        .build(),
+    );
+  }
+
+  async initMarker(
+    driver: ControlDriverInstance<'sql', 'sqlite'>,
+    space: string,
+    destination: {
+      readonly storageHash: string;
+      readonly profileHash: string;
+      readonly invariants?: readonly string[];
+    },
+  ): Promise<void> {
+    await execute(
+      (query) => this.lower(query, { contract: undefined }),
+      driver,
+      marker
+        .upsert({
+          space,
+          core_hash: destination.storageHash,
+          profile_hash: destination.profileHash,
+          contract_json: null,
+          canonical_version: null,
+          updated_at: NOW,
+          app_tag: null,
+          meta: {},
+          invariants: destination.invariants ?? [],
+        })
+        .onConflict(marker.space)
+        .doUpdate((excluded) => ({
+          core_hash: excluded.core_hash,
+          profile_hash: excluded.profile_hash,
+          contract_json: excluded.contract_json,
+          canonical_version: excluded.canonical_version,
+          updated_at: NOW,
+          app_tag: excluded.app_tag,
+          meta: excluded.meta,
+          invariants: excluded.invariants,
+        }))
+        .build(),
+    );
+  }
+
+  /**
+   * Compare-and-swap advance of the marker row for `space`. See the
+   * `SqlControlAdapter.updateMarker` contract.
+   */
+  async updateMarker(
+    driver: ControlDriverInstance<'sql', 'sqlite'>,
+    space: string,
+    expectedFrom: string,
+    destination: {
+      readonly storageHash: string;
+      readonly profileHash: string;
+      readonly invariants?: readonly string[];
+    },
+  ): Promise<boolean> {
+    const currentInvariants =
+      destination.invariants === undefined
+        ? []
+        : ((await this.readMarker(driver, space))?.invariants ?? []);
+    const mergedInvariants =
+      destination.invariants === undefined
+        ? undefined
+        : mergeInvariants(currentInvariants, destination.invariants);
+
+    const query = marker
+      .update()
+      .set({
+        core_hash: destination.storageHash,
+        profile_hash: destination.profileHash,
+        updated_at: NOW,
+        ...(mergedInvariants !== undefined ? { invariants: mergedInvariants } : {}),
+      })
+      .where(marker.space.eq(space).and(marker.core_hash.eq(expectedFrom)))
+      .returning(marker.space)
+      .build();
+
+    const rows = await execute((q) => this.lower(q, { contract: undefined }), driver, query);
+    return rows.length > 0;
+  }
+
+  /**
+   * Appends a ledger entry for `space`. See the
+   * `SqlControlAdapter.writeLedgerEntry` contract.
+   */
+  async writeLedgerEntry(
+    driver: ControlDriverInstance<'sql', 'sqlite'>,
+    space: string,
+    entry: {
+      readonly edgeId: string;
+      readonly from: string;
+      readonly to: string;
+      readonly migrationName: string;
+      readonly migrationHash: string;
+      readonly operations: readonly unknown[];
+    },
+  ): Promise<void> {
+    await execute(
+      (query) => this.lower(query, { contract: undefined }),
+      driver,
+      ledger
+        .insert({
+          space,
+          migration_name: entry.migrationName,
+          migration_hash: entry.migrationHash,
+          origin_core_hash: entry.from,
+          destination_core_hash: entry.to,
+          operations: entry.operations,
+        })
+        .build(),
+    );
+  }
+
+  private async readMarkerResult(driver: ControlDriverInstance<'sql', 'sqlite'>, space: string) {
+    const lower = (query: AnyQueryAst) => this.lower(query, { contract: undefined });
+    const probe = sqliteCatalog
+      .select(sqliteCatalog.name)
+      .where(sqliteCatalog.type.eq('table').and(sqliteCatalog.name.eq('_prisma_marker')))
+      .build();
+    const exists = await execute(lower, driver, probe);
+    if (exists.length === 0) return { kind: 'no-table' as const };
+
+    const fetch = marker
+      .select(
+        marker.core_hash,
+        marker.profile_hash,
+        marker.contract_json,
+        marker.canonical_version,
+        marker.updated_at,
+        marker.app_tag,
+        marker.meta,
+        marker.invariants,
+      )
+      .where(marker.space.eq(space))
+      .build();
+    const result = await execute(lower, driver, fetch);
+    const row = result[0];
+    if (!row) return { kind: 'absent' as const };
+    return {
+      kind: 'present' as const,
+      record: parseContractMarkerRow(decodeSqliteMarkerRow(row)),
+    };
   }
 
   async introspect(

package/src/core/ddl-renderer.ts

@@ -0,0 +1,67 @@
+import type {
+  DdlColumn,
+  DdlColumnDefaultVisitor,
+  FunctionColumnDefault,
+  LiteralColumnDefault,
+} from '@prisma-next/sql-relational-core/ast';
+import type {
+  SqliteCreateTable,
+  SqliteDdlNode,
+  SqliteDdlVisitor,
+} from '@prisma-next/target-sqlite/ddl';
+import { escapeLiteral } from '@prisma-next/target-sqlite/sql-utils';
+import type { SqliteLoweredStatement } from './types';
+
+class SqliteDdlVisitorImpl implements SqliteDdlVisitor<string> {
+  createTable(node: SqliteCreateTable): string {
+    const ifNotExists = node.ifNotExists ? 'IF NOT EXISTS ' : '';
+    const tableRef = node.table;
+    const columnDefs = node.columns.map((column) => renderColumn(column)).join(',\n    ');
+    return `CREATE TABLE ${ifNotExists}${tableRef} (\n    ${columnDefs}\n  )`;
+  }
+}
+
+const defaultVisitor: DdlColumnDefaultVisitor<string> = {
+  literal(node: LiteralColumnDefault): string {
+    const { value } = node;
+    if (typeof value === 'string') {
+      return `DEFAULT '${escapeLiteral(value)}'`;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+      return `DEFAULT ${String(value)}`;
+    }
+    if (value === null) {
+      return 'DEFAULT NULL';
+    }
+    return `DEFAULT '${JSON.stringify(value)}'`;
+  },
+  function(node: FunctionColumnDefault): string {
+    if (node.expression === 'autoincrement()') {
+      return '';
+    }
+    return `DEFAULT (${node.expression})`;
+  },
+};
+
+function renderColumn(column: DdlColumn): string {
+  if (column.type.includes('AUTOINCREMENT')) {
+    return `${column.name} ${column.type}`;
+  }
+  const parts = [column.name, column.type];
+  if (column.notNull) {
+    parts.push('NOT NULL');
+  }
+  if (column.primaryKey) {
+    parts.push('PRIMARY KEY');
+  }
+  const defaultClause = column.default ? column.default.accept(defaultVisitor) : '';
+  if (defaultClause.length > 0) {
+    parts.push(defaultClause);
+  }
+  return parts.join(' ');
+}
+
+export function renderLoweredDdl(ast: SqliteDdlNode): SqliteLoweredStatement {
+  const sql = ast.accept(new SqliteDdlVisitorImpl());
+  return Object.freeze({ sql, params: Object.freeze([]) });
+}

package/src/core/ledger-decode.ts

@@ -0,0 +1,26 @@
+const DESIGNATOR_LESS_UTC_DATETIME = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(\.\d+)?$/;
+
+export function coerceLedgerAppliedAt(value: Date | string): Date {
+  if (value instanceof Date) {
+    return value;
+  }
+  if (DESIGNATOR_LESS_UTC_DATETIME.test(value)) {
+    return new Date(`${value.replace(' ', 'T')}Z`);
+  }
+  return new Date(value);
+}
+
+export function operationCountFromStored(operations: unknown): number {
+  if (Array.isArray(operations)) {
+    return operations.length;
+  }
+  if (typeof operations === 'string') {
+    try {
+      const parsed: unknown = JSON.parse(operations);
+      return Array.isArray(parsed) ? parsed.length : 0;
+    } catch {
+      return 0;
+    }
+  }
+  return 0;
+}