@prisma-next/adapter-sqlite 0.5.0-dev.9 → 0.5.0

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@prisma-next/adapter-sqlite",
-  "version": "0.5.0-dev.9",
+  "version": "0.5.0",
+  "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "files": [
@@ -8,29 +9,33 @@
     "src"
   ],
   "dependencies": {
-    "arktype": "^2.0.0",
-    "@prisma-next/contract": "0.5.0-dev.9",
-    "@prisma-next/cli": "0.5.0-dev.9",
-    "@prisma-next/framework-components": "0.5.0-dev.9",
-    "@prisma-next/contract-authoring": "0.5.0-dev.9",
-    "@prisma-next/ids": "0.5.0-dev.9",
-    "@prisma-next/family-sql": "0.5.0-dev.9",
-    "@prisma-next/sql-contract": "0.5.0-dev.9",
-    "@prisma-next/sql-contract-psl": "0.5.0-dev.9",
-    "@prisma-next/sql-contract-ts": "0.5.0-dev.9",
-    "@prisma-next/sql-operations": "0.5.0-dev.9",
-    "@prisma-next/sql-runtime": "0.5.0-dev.9",
-    "@prisma-next/sql-relational-core": "0.5.0-dev.9",
-    "@prisma-next/sql-schema-ir": "0.5.0-dev.9",
-    "@prisma-next/utils": "0.5.0-dev.9"
+    "arktype": "^2.1.29",
+    "@prisma-next/cli": "0.5.0",
+    "@prisma-next/contract-authoring": "0.5.0",
+    "@prisma-next/framework-components": "0.5.0",
+    "@prisma-next/ids": "0.5.0",
+    "@prisma-next/contract": "0.5.0",
+    "@prisma-next/sql-contract": "0.5.0",
+    "@prisma-next/family-sql": "0.5.0",
+    "@prisma-next/sql-operations": "0.5.0",
+    "@prisma-next/sql-contract-psl": "0.5.0",
+    "@prisma-next/sql-relational-core": "0.5.0",
+    "@prisma-next/sql-runtime": "0.5.0",
+    "@prisma-next/sql-schema-ir": "0.5.0",
+    "@prisma-next/target-sqlite": "0.5.0",
+    "@prisma-next/utils": "0.5.0",
+    "@prisma-next/sql-contract-ts": "0.5.0"
   },
   "devDependencies": {
-    "tsdown": "0.18.4",
+    "pathe": "^2.0.3",
+    "tsdown": "0.22.0",
     "typescript": "5.9.3",
-    "vitest": "4.0.17",
-    "@prisma-next/tsconfig": "0.0.0",
+    "vitest": "4.1.5",
+    "@prisma-next/driver-sqlite": "0.5.0",
     "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/tsdown": "0.0.0"
+    "@prisma-next/tsdown": "0.0.0",
+    "@prisma-next/tsconfig": "0.0.0",
+    "@prisma-next/migration-tools": "0.5.0"
   },
   "exports": {
     "./adapter": "./dist/adapter.mjs",

package/src/core/adapter.ts

@@ -1,34 +1,35 @@
-import {
-  type Adapter,
-  type AdapterProfile,
-  type AggregateExpr,
-  type AnyExpression,
-  type AnyFromSource,
-  type AnyQueryAst,
-  type BinaryExpr,
-  type CodecParamsDescriptor,
-  type ColumnRef,
-  createCodecRegistry,
-  type DeleteAst,
-  type InsertAst,
-  type InsertValue,
-  type JoinAst,
-  type JoinOnExpr,
-  type JsonArrayAggExpr,
-  type JsonObjectExpr,
-  type ListExpression,
-  type LiteralExpr,
-  type LowererContext,
-  type NullCheckExpr,
-  type OperationExpr,
-  type OrderByItem,
-  type ProjectionItem,
-  type SelectAst,
-  type SubqueryExpr,
-  type UpdateAst,
+import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
+import type {
+  Adapter,
+  AdapterProfile,
+  AggregateExpr,
+  AnyExpression,
+  AnyFromSource,
+  AnyQueryAst,
+  BinaryExpr,
+  ColumnRef,
+  DeleteAst,
+  InsertAst,
+  InsertValue,
+  JoinAst,
+  JoinOnExpr,
+  JsonArrayAggExpr,
+  JsonObjectExpr,
+  ListExpression,
+  LiteralExpr,
+  LowererContext,
+  MarkerReadResult,
+  NullCheckExpr,
+  OperationExpr,
+  OrderByItem,
+  ProjectionItem,
+  SelectAst,
+  SqlQueryable,
+  SubqueryExpr,
+  UpdateAst,
 } from '@prisma-next/sql-relational-core/ast';
-import { codecDefinitions } from './codecs';
-import { escapeLiteral, quoteIdentifier } from './sql-utils';
+import { parseContractMarkerRow } from '@prisma-next/sql-runtime';
+import { escapeLiteral, quoteIdentifier } from '@prisma-next/target-sqlite/sql-utils';
 import type { SqliteAdapterOptions, SqliteContract, SqliteLoweredStatement } from './types';
 
 const defaultCapabilities = Object.freeze({
@@ -47,60 +48,57 @@ class SqliteAdapterImpl implements Adapter<AnyQueryAst, SqliteContract, SqliteLo
   readonly targetId = 'sqlite' as const;
 
   readonly profile: AdapterProfile<'sqlite'>;
-  private readonly codecRegistry = (() => {
-    const registry = createCodecRegistry();
-    for (const definition of Object.values(codecDefinitions)) {
-      registry.register(definition.codec);
-    }
-    return registry;
-  })();
 
   constructor(options?: SqliteAdapterOptions) {
     this.profile = Object.freeze({
       id: options?.profileId ?? 'sqlite/default@1',
       target: 'sqlite',
       capabilities: defaultCapabilities,
-      codecs: () => this.codecRegistry,
-      readMarkerStatement: () => ({
-        sql: 'select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta from prisma_contract_marker where id = ?',
-        params: [1],
-      }),
+      readMarker: (queryable: SqlQueryable) => readSqliteMarker(queryable),
     });
   }
 
-  parameterizedCodecs(): ReadonlyArray<CodecParamsDescriptor> {
-    return [];
-  }
-
   lower(ast: AnyQueryAst, context: LowererContext<SqliteContract>): SqliteLoweredStatement {
-    const collectedParamRefs = ast.collectParamRefs();
-    const params: unknown[] = [];
-    for (const ref of collectedParamRefs) {
-      params.push(ref.value);
-    }
+    return renderLoweredSql(ast, context.contract);
+  }
+}
 
-    let sql: string;
+/**
+ * Lower a SQL query AST into a SQLite-flavored `{ sql, params }` payload.
+ *
+ * Shared between the runtime adapter (`SqliteAdapterImpl.lower`) and the control adapter (`SqliteControlAdapter.lower`) so both produce byte-identical SQL for the same AST and contract.
+ */
+export function renderLoweredSql(
+  ast: AnyQueryAst,
+  contract: SqliteContract,
+): SqliteLoweredStatement {
+  const collectedParamRefs = ast.collectParamRefs();
+  const params: unknown[] = [];
+  for (const ref of collectedParamRefs) {
+    params.push(ref.value);
+  }
 
-    const node = ast;
-    switch (node.kind) {
-      case 'select':
-        sql = renderSelect(node, context.contract);
-        break;
-      case 'insert':
-        sql = renderInsert(node);
-        break;
-      case 'update':
-        sql = renderUpdate(node, context.contract);
-        break;
-      case 'delete':
-        sql = renderDelete(node);
-        break;
-      default:
-        throw new Error(`Unsupported AST node kind: ${(node as { kind: string }).kind}`);
-    }
+  let sql: string;
 
-    return Object.freeze({ sql, params });
+  const node = ast;
+  switch (node.kind) {
+    case 'select':
+      sql = renderSelect(node, contract);
+      break;
+    case 'insert':
+      sql = renderInsert(node);
+      break;
+    case 'update':
+      sql = renderUpdate(node, contract);
+      break;
+    case 'delete':
+      sql = renderDelete(node);
+      break;
+    default:
+      throw new Error(`Unsupported AST node kind: ${(node as { kind: string }).kind}`);
   }
+
+  return Object.freeze({ sql, params });
 }
 
 function renderSelect(ast: SelectAst, contract?: SqliteContract): string {
@@ -222,8 +220,7 @@ function renderExpr(expr: AnyExpression, contract?: SqliteContract): string {
   }
 }
 
-// `excluded` is a pseudo-table in ON CONFLICT DO UPDATE that references the
-// row proposed for insertion. It is not quoted because it's a keyword.
+// `excluded` is a pseudo-table in ON CONFLICT DO UPDATE that references the row proposed for insertion. It is not quoted because it's a keyword.
 function renderColumn(ref: ColumnRef): string {
   if (ref.table === 'excluded') {
     return `excluded.${quoteIdentifier(ref.column)}`;
@@ -506,11 +503,47 @@ function renderDelete(ast: DeleteAst): string {
   return `DELETE FROM ${table}${whereClause}${returningClause}`;
 }
 
-function renderReturning(returning: ReadonlyArray<ColumnRef> | undefined): string {
+function renderReturning(returning: ReadonlyArray<ProjectionItem> | undefined): string {
   if (!returning?.length) {
     return '';
   }
-  return ` RETURNING ${returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(', ')}`;
+  return ` RETURNING ${returning
+    .map((item) => {
+      if (item.expr.kind === 'column-ref') {
+        const rendered = `${quoteIdentifier(item.expr.table)}.${quoteIdentifier(item.expr.column)}`;
+        return item.expr.column === item.alias
+          ? rendered
+          : `${rendered} AS ${quoteIdentifier(item.alias)}`;
+      }
+      return `${renderExpr(item.expr)} AS ${quoteIdentifier(item.alias)}`;
+    })
+    .join(', ')}`;
+}
+
+async function readSqliteMarker(queryable: SqlQueryable): Promise<MarkerReadResult> {
+  const exists = await queryable.query(
+    "select 1 from sqlite_master where type = 'table' and name = ?",
+    ['_prisma_marker'],
+  );
+  if (exists.rows.length === 0) {
+    return { kind: 'no-table' };
+  }
+
+  const result = await queryable.query(
+    'select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta, invariants from _prisma_marker where space = ?',
+    [APP_SPACE_ID],
+  );
+  const row = result.rows[0];
+  if (!row) {
+    return { kind: 'absent' };
+  }
+  // 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[]`.
+  const raw = row as Record<string, unknown>;
+  const invariants =
+    typeof raw['invariants'] === 'string'
+      ? (JSON.parse(raw['invariants']) as unknown)
+      : raw['invariants'];
+  return { kind: 'present', record: parseContractMarkerRow({ ...raw, invariants }) };
 }
 
 export function createSqliteAdapter(options?: SqliteAdapterOptions) {

package/src/core/column-types.ts

@@ -1,13 +1,12 @@
 import {
   SQLITE_BIGINT_CODEC_ID,
   SQLITE_BLOB_CODEC_ID,
-  SQLITE_BOOLEAN_CODEC_ID,
   SQLITE_DATETIME_CODEC_ID,
   SQLITE_INTEGER_CODEC_ID,
   SQLITE_JSON_CODEC_ID,
   SQLITE_REAL_CODEC_ID,
   SQLITE_TEXT_CODEC_ID,
-} from './codec-ids';
+} from '@prisma-next/target-sqlite/codec-ids';
 
 export const textColumn = {
   codecId: SQLITE_TEXT_CODEC_ID,
@@ -29,11 +28,6 @@ export const blobColumn = {
   nativeType: 'blob',
 } as const;
 
-export const booleanColumn = {
-  codecId: SQLITE_BOOLEAN_CODEC_ID,
-  nativeType: 'integer',
-} as const;
-
 export const datetimeColumn = {
   codecId: SQLITE_DATETIME_CODEC_ID,
   nativeType: 'text',

package/src/core/control-adapter.ts

@@ -1,18 +1,334 @@
+import type { ContractMarkerRecord } from '@prisma-next/contract/types';
+import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
+import { parseContractMarkerRow } from '@prisma-next/family-sql/verify';
+import type { ControlDriverInstance } from '@prisma-next/framework-components/control';
 import type {
-  ControlAdapterDescriptor,
-  ControlAdapterInstance,
-} from '@prisma-next/framework-components/control';
-import { sqliteAdapterDescriptorMeta } from './descriptor-meta';
-
-const sqliteControlAdapterDescriptor: ControlAdapterDescriptor<
-  'sql',
-  'sqlite',
-  ControlAdapterInstance<'sql', 'sqlite'>
-> = {
-  ...sqliteAdapterDescriptorMeta,
-  create(_stack): ControlAdapterInstance<'sql', 'sqlite'> {
-    return { familyId: 'sql', targetId: 'sqlite' };
-  },
+  AnyQueryAst,
+  LoweredStatement,
+  LowererContext,
+} from '@prisma-next/sql-relational-core/ast';
+import type {
+  PrimaryKey,
+  SqlColumnIR,
+  SqlForeignKeyIR,
+  SqlIndexIR,
+  SqlReferentialAction,
+  SqlSchemaIR,
+  SqlTableIR,
+  SqlUniqueIR,
+} from '@prisma-next/sql-schema-ir/types';
+import { parseSqliteDefault } from '@prisma-next/target-sqlite/default-normalizer';
+import { normalizeSqliteNativeType } from '@prisma-next/target-sqlite/native-type-normalizer';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { renderLoweredSql } from './adapter';
+import type { SqliteContract } from './types';
+
+// PRAGMA result row types
+type PragmaTableInfoRow = {
+  cid: number;
+  name: string;
+  type: string;
+  notnull: number;
+  dflt_value: string | null;
+  pk: number;
+};
+
+type PragmaForeignKeyRow = {
+  id: number;
+  seq: number;
+  table: string;
+  from: string;
+  to: string;
+  on_update: string;
+  on_delete: string;
+};
+
+type PragmaIndexListRow = {
+  seq: number;
+  name: string;
+  unique: number;
+  origin: string;
+  partial: number;
+};
+
+type PragmaIndexInfoRow = {
+  seqno: number;
+  cid: number;
+  name: string;
+};
+
+type FkAccumulator = {
+  columns: string[];
+  referencedTable: string;
+  referencedColumns: string[];
+  onDelete: string;
+  onUpdate: string;
+};
+
+export class SqliteControlAdapter implements SqlControlAdapter<'sqlite'> {
+  readonly familyId = 'sql' as const;
+  readonly targetId = 'sqlite' as const;
+
+  readonly normalizeDefault = parseSqliteDefault;
+  readonly normalizeNativeType = normalizeSqliteNativeType;
+
+  /**
+   * Lower a SQL query AST into a SQLite-flavored `{ sql, params }` payload.
+   *
+   * Delegates to the shared `renderLoweredSql` renderer so the control adapter
+   * emits byte-identical SQL to `SqliteAdapterImpl.lower()` for the same AST
+   * and contract. Used at migration plan/emit time (e.g. by `dataTransform`)
+   * without instantiating the runtime adapter.
+   */
+  lower(ast: AnyQueryAst, context: LowererContext<unknown>): LoweredStatement {
+    return renderLoweredSql(ast, context.contract as SqliteContract);
+  }
+
+  /**
+   * Reads the contract marker from `_prisma_marker`. Probes `sqlite_master`
+   * first so a fresh database (no marker table) returns `null` instead of a
+   * "no such table" error.
+   */
+  async readMarker(
+    driver: ControlDriverInstance<'sql', 'sqlite'>,
+    space: string,
+  ): Promise<ContractMarkerRecord | null> {
+    const exists = await driver.query(
+      `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?`,
+      ['_prisma_marker'],
+    );
+    if (exists.rows.length === 0) {
+      return null;
+    }
+
+    const result = await 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],
+    );
+
+    const row = result.rows[0];
+    if (!row) return null;
+    // 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[]`.
+    const invariants =
+      typeof row.invariants === 'string' ? (JSON.parse(row.invariants) as unknown) : row.invariants;
+    return parseContractMarkerRow({ ...row, invariants });
+  }
+
+  /**
+   * Reads every row from `_prisma_marker` and returns them keyed by
+   * `space`. Mirrors the existence probe in {@link readMarker}: a
+   * fresh database without the marker table returns an empty map.
+   */
+  async readAllMarkers(
+    driver: ControlDriverInstance<'sql', 'sqlite'>,
+  ): Promise<ReadonlyMap<string, ContractMarkerRecord>> {
+    const exists = await driver.query(
+      `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?`,
+      ['_prisma_marker'],
+    );
+    if (exists.rows.length === 0) {
+      return new Map();
+    }
+
+    const result = await 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`,
+    );
+
+    const rows = new Map<string, ContractMarkerRecord>();
+    for (const row of result.rows) {
+      const invariants =
+        typeof row.invariants === 'string'
+          ? (JSON.parse(row.invariants) as unknown)
+          : row.invariants;
+      rows.set(row.space, parseContractMarkerRow({ ...row, invariants }));
+    }
+    return rows;
+  }
+
+  async introspect(
+    driver: ControlDriverInstance<'sql', 'sqlite'>,
+    _contract?: unknown,
+  ): Promise<SqlSchemaIR> {
+    // Filter out runner-managed control tables (`_prisma_marker`,
+    // `_prisma_ledger`) — they're an implementation detail of the migration
+    // runner, not part of the user-authored contract, so they must not
+    // appear in introspection output (otherwise strict schema verification
+    // flags them as `extra_table`).
+    const tablesResult = await driver.query<{ name: string }>(
+      `SELECT name FROM sqlite_master
+       WHERE type = 'table'
+         AND name NOT LIKE 'sqlite_%'
+         AND name NOT IN ('_prisma_marker', '_prisma_ledger')
+       ORDER BY name`,
+    );
+
+    const tables: Record<string, SqlTableIR> = {};
+
+    for (const tableRow of tablesResult.rows) {
+      const tableName = tableRow.name;
+
+      // SQLite's synchronous driver serializes reads — no benefit from Promise.all
+      const columnsResult = await driver.query<PragmaTableInfoRow>(
+        `PRAGMA table_info("${escapePragmaArg(tableName)}")`,
+      );
+      const fkResult = await driver.query<PragmaForeignKeyRow>(
+        `PRAGMA foreign_key_list("${escapePragmaArg(tableName)}")`,
+      );
+      const indexListResult = await driver.query<PragmaIndexListRow>(
+        `PRAGMA index_list("${escapePragmaArg(tableName)}")`,
+      );
+
+      const columns: Record<string, SqlColumnIR> = {};
+      const pkColumns: Array<{ name: string; pk: number }> = [];
+
+      for (const col of columnsResult.rows) {
+        columns[col.name] = {
+          name: col.name,
+          nativeType: col.type.toLowerCase(),
+          nullable: col.notnull === 0 && col.pk === 0,
+          ...ifDefined('default', col.dflt_value ?? undefined),
+        };
+        if (col.pk > 0) {
+          pkColumns.push({ name: col.name, pk: col.pk });
+        }
+      }
+
+      pkColumns.sort((a, b) => a.pk - b.pk);
+      const primaryKey: PrimaryKey | undefined =
+        pkColumns.length > 0 ? { columns: pkColumns.map((c) => c.name) } : undefined;
+
+      const fkMap = new Map<number, FkAccumulator>();
+      for (const fk of fkResult.rows) {
+        const existing = fkMap.get(fk.id);
+        if (existing) {
+          existing.columns.push(fk.from);
+          existing.referencedColumns.push(fk.to);
+        } else {
+          fkMap.set(fk.id, {
+            columns: [fk.from],
+            referencedTable: fk.table,
+            referencedColumns: [fk.to],
+            onDelete: fk.on_delete,
+            onUpdate: fk.on_update,
+          });
+        }
+      }
+      const foreignKeys: readonly SqlForeignKeyIR[] = Array.from(fkMap.values()).map((fk) => ({
+        columns: Object.freeze([...fk.columns]) as readonly string[],
+        referencedTable: fk.referencedTable,
+        referencedColumns: Object.freeze([...fk.referencedColumns]) as readonly string[],
+        ...ifDefined('onDelete', mapSqliteReferentialAction(fk.onDelete)),
+        ...ifDefined('onUpdate', mapSqliteReferentialAction(fk.onUpdate)),
+      }));
+
+      const uniques: SqlUniqueIR[] = [];
+      const indexes: SqlIndexIR[] = [];
+
+      for (const idx of indexListResult.rows) {
+        // origin: 'c' = CREATE INDEX, 'u' = UNIQUE constraint, 'pk' = PRIMARY KEY
+        const idxInfoResult = await driver.query<PragmaIndexInfoRow>(
+          `PRAGMA index_info("${escapePragmaArg(idx.name)}")`,
+        );
+
+        const idxColumns = idxInfoResult.rows.sort((a, b) => a.seqno - b.seqno).map((r) => r.name);
+
+        if (idx.origin === 'u') {
+          uniques.push({
+            columns: Object.freeze([...idxColumns]) as readonly string[],
+            name: idx.name,
+          });
+        } else if (idx.origin === 'c') {
+          indexes.push({
+            columns: Object.freeze([...idxColumns]) as readonly string[],
+            name: idx.name,
+            unique: idx.unique === 1,
+          });
+        }
+        // Skip 'pk' origin — already captured in primaryKey
+      }
+
+      tables[tableName] = {
+        name: tableName,
+        columns,
+        ...ifDefined('primaryKey', primaryKey),
+        foreignKeys,
+        uniques,
+        indexes,
+      };
+    }
+
+    return {
+      tables,
+      dependencies: [],
+    };
+  }
+}
+
+// PRAGMA queries use the function-argument form (`PRAGMA table_info("name")`)
+// which doesn't support `?` placeholders — the argument is part of the
+// statement name, not a bound parameter. We quote-escape the table name instead.
+function escapePragmaArg(name: string): string {
+  return name.replace(/"/g, '""');
+}
+
+const SQLITE_REFERENTIAL_ACTION_MAP: Record<string, SqlReferentialAction> = {
+  'NO ACTION': 'noAction',
+  RESTRICT: 'restrict',
+  CASCADE: 'cascade',
+  'SET NULL': 'setNull',
+  'SET DEFAULT': 'setDefault',
 };
 
-export default sqliteControlAdapterDescriptor;
+function mapSqliteReferentialAction(rule: string): SqlReferentialAction | undefined {
+  const normalized = rule.toUpperCase();
+  const mapped = SQLITE_REFERENTIAL_ACTION_MAP[normalized];
+  if (mapped === undefined) {
+    throw new Error(
+      `Unknown SQLite referential action rule: "${rule}". ` +
+        'Expected one of: NO ACTION, RESTRICT, CASCADE, SET NULL, SET DEFAULT.',
+    );
+  }
+  if (mapped === 'noAction') return undefined;
+  return mapped;
+}