@prisma-next/target-sqlite 0.13.0-dev.4 → 0.13.0-dev.40

package/dist/sqlite-migration-DVfhQwN_.d.mts

@@ -0,0 +1,75 @@
+import { t as SqlitePlanTargetDetails } from "./planner-target-details-xR6UfIcz.mjs";
+import { i as SqliteTableSpec, n as SqliteColumnSpec, r as SqliteIndexSpec } from "./shared-Dhc8mLK1.mjs";
+import { DdlColumn, DdlTableConstraint } from "@prisma-next/sql-relational-core/ast";
+import { MigrationOperationClass, SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
+import { Migration } from "@prisma-next/family-sql/migration";
+import { ControlStack } from "@prisma-next/framework-components/control";
+import { SqlControlAdapter } from "@prisma-next/family-sql/control-adapter";
+
+//#region src/core/migrations/sqlite-migration.d.ts
+type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
+/**
+ * Target-owned base class for SQLite migrations. Fixes the `SqlMigration`
+ * generic to `SqlitePlanTargetDetails` and the abstract `targetId` to the
+ * SQLite literal, so both user-authored migrations and renderer-generated
+ * scaffolds can extend `SqliteMigration` directly without redeclaring
+ * target-local identity.
+ *
+ * The constructor materializes a single SQLite `SqlControlAdapter` from
+ * `stack.adapter.create(stack)` and stores it; the protected instance methods
+ * forward to the corresponding `*Call` with that stored adapter, so user
+ * migrations can write `this.createTable({...})` without threading the adapter
+ * through every call.
+ */
+declare abstract class SqliteMigration extends Migration<SqlitePlanTargetDetails, 'sqlite'> {
+  readonly targetId: "sqlite";
+  /**
+   * Materialized SQLite control adapter, created once per migration
+   * instance from the injected stack. `undefined` only when the migration
+   * was instantiated without a stack (test fixtures); the operation methods
+   * throw in that case to surface the misuse.
+   */
+  protected readonly controlAdapter: SqlControlAdapter<'sqlite'> | undefined;
+  constructor(stack?: ControlStack<'sql', 'sqlite'>);
+  protected createTable(options: {
+    readonly table: string;
+    readonly ifNotExists?: boolean;
+    readonly columns: readonly DdlColumn[];
+    readonly constraints?: readonly DdlTableConstraint[];
+  }): Promise<Op>;
+  protected dropTable(options: {
+    readonly table: string;
+  }): Promise<Op>;
+  protected addColumn(options: {
+    readonly table: string;
+    readonly column: SqliteColumnSpec;
+  }): Promise<Op>;
+  protected dropColumn(options: {
+    readonly table: string;
+    readonly column: string;
+  }): Promise<Op>;
+  protected createIndex(options: {
+    readonly table: string;
+    readonly index: string;
+    readonly columns: readonly string[];
+  }): Promise<Op>;
+  protected dropIndex(options: {
+    readonly table: string;
+    readonly index: string;
+  }): Promise<Op>;
+  protected recreateTable(options: {
+    readonly tableName: string;
+    readonly contractTable: SqliteTableSpec;
+    readonly schemaColumnNames: readonly string[];
+    readonly indexes: readonly SqliteIndexSpec[];
+    readonly summary: string;
+    readonly postchecks: readonly {
+      readonly description: string;
+      readonly sql: string;
+    }[];
+    readonly operationClass: MigrationOperationClass;
+  }): Promise<Op>;
+}
+//#endregion
+export { SqliteMigration as t };
+//# sourceMappingURL=sqlite-migration-DVfhQwN_.d.mts.map

package/dist/sqlite-migration-DVfhQwN_.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-migration-DVfhQwN_.d.mts","names":[],"sources":["../src/core/migrations/sqlite-migration.ts"],"mappings":";;;;;;;;;KAsBK,EAAA,GAAK,yBAAyB,CAAC,uBAAA;;AAFoC;;;;AAEb;AAe3D;;;;;;;uBAAsB,eAAA,SAAwB,SAAA,CAAa,uBAAA;EAAA,SAChD,QAAA;EAyBL;;;;;;EAAA,mBAjBe,cAAA,EAAgB,iBAAA;cAEvB,KAAA,GAAQ,YAAA;EAAA,UAUV,WAAA,CAAY,OAAA;IAAA,SACX,KAAA;IAAA,SACA,WAAA;IAAA,SACA,OAAA,WAAkB,SAAA;IAAA,SAClB,WAAA,YAAuB,kBAAA;EAAA,IAC9B,OAAA,CAAQ,EAAA;EAAA,UASF,SAAA,CAAU,OAAA;IAAA,SAAoB,KAAA;EAAA,IAAkB,OAAA,CAAQ,EAAA;EAAA,UAOxD,SAAA,CAAU,OAAA;IAAA,SACT,KAAA;IAAA,SACA,MAAA,EAAQ,gBAAA;EAAA,IACf,OAAA,CAAQ,EAAA;EAAA,UAOF,UAAA,CAAW,OAAA;IAAA,SAAoB,KAAA;IAAA,SAAwB,MAAA;EAAA,IAAmB,OAAA,CAAQ,EAAA;EAAA,UAOlF,WAAA,CAAY,OAAA;IAAA,SACX,KAAA;IAAA,SACA,KAAA;IAAA,SACA,OAAA;EAAA,IACP,OAAA,CAAQ,EAAA;EAAA,UASF,SAAA,CAAU,OAAA;IAAA,SAAoB,KAAA;IAAA,SAAwB,KAAA;EAAA,IAAkB,OAAA,CAAQ,EAAA;EAAA,UAOhF,aAAA,CAAc,OAAA;IAAA,SACb,SAAA;IAAA,SACA,aAAA,EAAe,eAAA;IAAA,SACf,iBAAA;IAAA,SACA,OAAA,WAAkB,eAAA;IAAA,SAClB,OAAA;IAAA,SACA,UAAA;MAAA,SAAgC,WAAA;MAAA,SAA8B,GAAA;IAAA;IAAA,SAC9D,cAAA,EAAgB,uBAAA;EAAA,IACvB,OAAA,CAAQ,EAAA;AAAA"}

package/package.json

@@ -1,30 +1,30 @@
 {
   "name": "@prisma-next/target-sqlite",
-  "version": "0.13.0-dev.4",
+  "version": "0.13.0-dev.40",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@prisma-next/cli": "0.13.0-dev.4",
-    "@prisma-next/contract": "0.13.0-dev.4",
-    "@prisma-next/errors": "0.13.0-dev.4",
-    "@prisma-next/family-sql": "0.13.0-dev.4",
-    "@prisma-next/framework-components": "0.13.0-dev.4",
-    "@prisma-next/migration-tools": "0.13.0-dev.4",
-    "@prisma-next/sql-contract": "0.13.0-dev.4",
-    "@prisma-next/sql-errors": "0.13.0-dev.4",
-    "@prisma-next/sql-relational-core": "0.13.0-dev.4",
-    "@prisma-next/sql-runtime": "0.13.0-dev.4",
-    "@prisma-next/sql-schema-ir": "0.13.0-dev.4",
-    "@prisma-next/ts-render": "0.13.0-dev.4",
-    "@prisma-next/utils": "0.13.0-dev.4",
+    "@prisma-next/cli": "0.13.0-dev.40",
+    "@prisma-next/contract": "0.13.0-dev.40",
+    "@prisma-next/errors": "0.13.0-dev.40",
+    "@prisma-next/family-sql": "0.13.0-dev.40",
+    "@prisma-next/framework-components": "0.13.0-dev.40",
+    "@prisma-next/migration-tools": "0.13.0-dev.40",
+    "@prisma-next/sql-contract": "0.13.0-dev.40",
+    "@prisma-next/sql-errors": "0.13.0-dev.40",
+    "@prisma-next/sql-relational-core": "0.13.0-dev.40",
+    "@prisma-next/sql-runtime": "0.13.0-dev.40",
+    "@prisma-next/sql-schema-ir": "0.13.0-dev.40",
+    "@prisma-next/ts-render": "0.13.0-dev.40",
+    "@prisma-next/utils": "0.13.0-dev.40",
     "@standard-schema/spec": "1.1.0"
   },
   "devDependencies": {
-    "@prisma-next/driver-sqlite": "0.13.0-dev.4",
-    "@prisma-next/test-utils": "0.13.0-dev.4",
-    "@prisma-next/tsconfig": "0.13.0-dev.4",
-    "@prisma-next/tsdown": "0.13.0-dev.4",
+    "@prisma-next/driver-sqlite": "0.13.0-dev.40",
+    "@prisma-next/test-utils": "0.13.0-dev.40",
+    "@prisma-next/tsconfig": "0.13.0-dev.40",
+    "@prisma-next/tsdown": "0.13.0-dev.40",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"

package/src/contract-free/checks.ts

@@ -0,0 +1,75 @@
+import { FunctionSource, type SelectAst } from '@prisma-next/sql-relational-core/ast';
+import { cfExpr, cfTable, exprSelect } from '@prisma-next/sql-relational-core/contract-free';
+import { SQLITE_TEXT_CODEC_ID } from '../core/codec-ids';
+
+export interface ColumnExistsCheckBuilder {
+  columnAbsent(): SelectAst;
+  columnPresent(): SelectAst;
+}
+
+/**
+ * Typed builder for the migration planner's column-existence checks. Produces
+ * `SELECT COUNT(*) {=|>} 0 AS "result" FROM pragma_table_info(?) WHERE "name" = ?`
+ * ASTs with the table and column names bound as text parameters — never
+ * inlined into the SQL.
+ */
+export function columnExistsAst(table: string, column: string): ColumnExistsCheckBuilder {
+  const source = FunctionSource.of('pragma_table_info', [
+    cfExpr.param(table, SQLITE_TEXT_CODEC_ID).ast,
+  ]);
+  const where = cfExpr.identifierRef('name').eqParam(column, SQLITE_TEXT_CODEC_ID);
+  return {
+    columnAbsent: () =>
+      exprSelect().from(source).project('result', cfExpr.countStar().eqLit(0)).where(where).build(),
+    columnPresent: () =>
+      exprSelect().from(source).project('result', cfExpr.countStar().gtLit(0)).where(where).build(),
+  };
+}
+
+export interface TableExistsCheckBuilder {
+  tableAbsent(): SelectAst;
+  tablePresent(): SelectAst;
+}
+
+/**
+ * Typed builder for table-existence checks over `sqlite_master`.
+ * Produces `SELECT COUNT(*) {=|>} 0 AS "result" FROM "sqlite_master" WHERE "type" = ? AND "name" = ?`
+ * with the table name and the literal `'table'` bound as text parameters.
+ */
+export function tableExistsAst(tableName: string): TableExistsCheckBuilder {
+  const source = cfTable('sqlite_master');
+  const where = cfExpr.allOf([
+    cfExpr.identifierRef('type').eqParam('table', SQLITE_TEXT_CODEC_ID),
+    cfExpr.identifierRef('name').eqParam(tableName, SQLITE_TEXT_CODEC_ID),
+  ]);
+  return {
+    tableAbsent: () =>
+      exprSelect().from(source).project('result', cfExpr.countStar().eqLit(0)).where(where).build(),
+    tablePresent: () =>
+      exprSelect().from(source).project('result', cfExpr.countStar().gtLit(0)).where(where).build(),
+  };
+}
+
+export interface IndexExistsCheckBuilder {
+  indexAbsent(): SelectAst;
+  indexPresent(): SelectAst;
+}
+
+/**
+ * Typed builder for index-existence checks over `sqlite_master`.
+ * Produces `SELECT COUNT(*) {=|>} 0 AS "result" FROM "sqlite_master" WHERE "type" = ? AND "name" = ?`
+ * with the index name and the literal `'index'` bound as text parameters.
+ */
+export function indexExistsAst(indexName: string): IndexExistsCheckBuilder {
+  const source = cfTable('sqlite_master');
+  const where = cfExpr.allOf([
+    cfExpr.identifierRef('type').eqParam('index', SQLITE_TEXT_CODEC_ID),
+    cfExpr.identifierRef('name').eqParam(indexName, SQLITE_TEXT_CODEC_ID),
+  ]);
+  return {
+    indexAbsent: () =>
+      exprSelect().from(source).project('result', cfExpr.countStar().eqLit(0)).where(where).build(),
+    indexPresent: () =>
+      exprSelect().from(source).project('result', cfExpr.countStar().gtLit(0)).where(where).build(),
+  };
+}

package/src/core/control-target.ts

@@ -36,8 +36,8 @@ const sqliteControlTargetDescriptor: SqlControlTargetDescriptor<'sqlite', Sqlite
     contractSerializer: new SqliteContractSerializer(),
     schemaVerifier: new SqliteSchemaVerifier(),
     migrations: {
-      createPlanner(_adapter: SqlControlAdapter<'sqlite'>): MigrationPlanner<'sql', 'sqlite'> {
-        return createSqliteMigrationPlanner();
+      createPlanner(adapter: SqlControlAdapter<'sqlite'>): MigrationPlanner<'sql', 'sqlite'> {
+        return createSqliteMigrationPlanner(adapter);
       },
       createRunner(family) {
         return createSqliteMigrationRunner(family) as MigrationRunner<'sql', 'sqlite'>;
@@ -67,8 +67,8 @@ const sqliteControlTargetDescriptor: SqlControlTargetDescriptor<'sqlite', Sqlite
         targetId: 'sqlite',
       };
     },
-    createPlanner(_adapter: SqlControlAdapter<'sqlite'>) {
-      return createSqliteMigrationPlanner();
+    createPlanner(adapter: SqlControlAdapter<'sqlite'>) {
+      return createSqliteMigrationPlanner(adapter);
     },
     createRunner(family) {
       return createSqliteMigrationRunner(family);

package/src/core/errors.ts

@@ -0,0 +1,28 @@
+import { CliStructuredError } from '@prisma-next/errors/control';
+
+/**
+ * A `SqliteMigration` instance method that needs the materialized control
+ * adapter (currently only `this.createTable(...)`) was invoked, but the
+ * migration was constructed without a `ControlStack`. Concrete authoring
+ * usage always goes through the migration CLI entrypoint, which assembles
+ * a stack from the loaded `prisma-next.config.ts`; reaching this error
+ * means a test fixture or ad-hoc consumer instantiated `SqliteMigration`
+ * with the no-arg form (legal for `operations` / `describe` introspection
+ * only).
+ *
+ * Distinct from `PN-MIG-2001` (placeholder not filled) because the missing
+ * input is the stack itself, not the per-operation contract.
+ *
+ * Lives in `@prisma-next/target-sqlite/errors` rather than the shared
+ * framework migration errors module because the failure is target-specific:
+ * the contract it talks about (`SqliteMigration`, the SQLite control
+ * adapter, the SQLite-target stack) only exists in this package.
+ */
+export function errorSqliteMigrationStackMissing(): CliStructuredError {
+  return new CliStructuredError('2008', 'SqliteMigration.createTable requires a control adapter', {
+    domain: 'MIG',
+    why: 'SqliteMigration.createTable was invoked on an instance constructed without a ControlStack. The stored controlAdapter is undefined, so createTable cannot lower its DDL node.',
+    fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a SQLite adapter to the migration constructor in test fixtures.',
+    meta: {},
+  });
+}

package/src/core/migrations/issue-planner.ts

@@ -8,7 +8,7 @@
  * remaining issues flow through `mapIssueToCall` for the default case.
  */
 
-import type { Contract } from '@prisma-next/contract/types';
+import type { Contract, JsonValue } from '@prisma-next/contract/types';
 import type {
   CodecControlHooks,
   MigrationOperationPolicy,
@@ -18,14 +18,24 @@ import type {
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type { SchemaIssue } from '@prisma-next/framework-components/control';
 import type {
-  PostgresEnumStorageEntry,
   SqlStorage,
   StorageColumn,
   StorageTable,
   StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
+import type { CodecRef, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';
+import {
+  DdlColumn,
+  ForeignKeyConstraint,
+  FunctionColumnDefault,
+  LiteralColumnDefault,
+  PrimaryKeyConstraint,
+  UniqueConstraint,
+} from '@prisma-next/sql-relational-core/ast';
 import { defaultIndexName } from '@prisma-next/sql-schema-ir/naming';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
+import { blindCast } from '@prisma-next/utils/casts';
+import { ifDefined } from '@prisma-next/utils/defined';
 import type { Result } from '@prisma-next/utils/result';
 import { notOk, ok } from '@prisma-next/utils/result';
 import { CONTROL_TABLE_NAMES } from '../control-tables';
@@ -48,6 +58,7 @@ import {
   buildColumnDefaultSql,
   buildColumnTypeSql,
   isInlineAutoincrementPrimaryKey,
+  resolveColumnTypeMetadata,
 } from './planner-ddl-builders';
 import {
   type CallMigrationStrategy,
@@ -206,12 +217,15 @@ function isMissing(issue: SchemaIssue): boolean {
 export function toColumnSpec(
   name: string,
   column: StorageColumn,
-  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>,
+  storageTypes: Readonly<Record<string, StorageTypeInstance>>,
   inlineAutoincrementPrimaryKey = false,
 ): SqliteColumnSpec {
   const typeSql = buildColumnTypeSql(
     column,
-    storageTypes as Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+    blindCast<
+      Record<string, StorageTypeInstance>,
+      'buildColumnTypeSql declares its storageTypes parameter as mutable Record while the planner stores it readonly; the helper does not mutate, so the readonly→mutable narrowing is sound'
+    >(storageTypes),
   );
   const defaultSql = buildColumnDefaultSql(column.default);
   return {
@@ -231,7 +245,7 @@ export function toColumnSpec(
  */
 export function toTableSpec(
   table: StorageTable,
-  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>,
+  storageTypes: Readonly<Record<string, StorageTypeInstance>>,
 ): SqliteTableSpec {
   const columns: SqliteColumnSpec[] = Object.entries(table.columns).map(([name, column]) =>
     toColumnSpec(name, column, storageTypes, isInlineAutoincrementPrimaryKey(table, name)),
@@ -256,6 +270,126 @@ export function toTableSpec(
   };
 }
 
+// ============================================================================
+// StorageTable / StorageColumn → DdlColumn[] + DdlTableConstraint[] (for CreateTableCall)
+// ============================================================================
+
+function sqliteDefaultToDdlColumnDefault(
+  columnDefault: StorageColumn['default'],
+): DdlColumn['default'] {
+  if (!columnDefault) return undefined;
+  switch (columnDefault.kind) {
+    case 'literal':
+      return new LiteralColumnDefault(columnDefault.value);
+    case 'function':
+      // `autoincrement()` is not a DEFAULT clause — SQLite encodes it as
+      // `INTEGER PRIMARY KEY AUTOINCREMENT` inline on the column. Skip it
+      // here; the renderer also has a defensive guard for the same case.
+      if (columnDefault.expression === 'autoincrement()') return undefined;
+      return new FunctionColumnDefault(columnDefault.expression);
+    default: {
+      const exhaustive: never = columnDefault;
+      throw new Error(
+        `sqliteDefaultToDdlColumnDefault: unhandled kind "${blindCast<{ kind: string }, 'exhaustiveness: surface the unhandled default kind'>(exhaustive).kind}"`,
+      );
+    }
+  }
+}
+
+/**
+ * Converts a `StorageTable` to the `DdlColumn[]` + `DdlTableConstraint[]`
+ * pair used by `CreateTableCall`. This is the structured form consumed by
+ * the DDL lowering path; `toTableSpec` / `toColumnSpec` remain in use for
+ * `RecreateTableCall` and `AddColumnCall` (Phase 2).
+ */
+export function tableToDdlParts(
+  table: StorageTable,
+  storageTypes: Record<string, StorageTypeInstance>,
+): { columns: DdlColumn[]; constraints: DdlTableConstraint[] } {
+  const columns: DdlColumn[] = Object.entries(table.columns).map(([name, column]) => {
+    const inlineAutoincrement = isInlineAutoincrementPrimaryKey(table, name);
+    const typeSql = buildColumnTypeSql(
+      column,
+      blindCast<
+        Record<string, StorageTypeInstance>,
+        'buildColumnTypeSql declares its storageTypes parameter as mutable Record while the planner stores it readonly; the helper does not mutate, so the readonly→mutable narrowing is sound'
+      >(storageTypes),
+    );
+
+    if (inlineAutoincrement) {
+      // `DdlColumn` has no SQLite-specific autoincrement flag, so the full
+      // `PRIMARY KEY AUTOINCREMENT` clause is embedded in the `type` string.
+      // The DDL renderer (`ddl-renderer.ts`) substring-detects `AUTOINCREMENT`
+      // to suppress the normal NOT NULL / PRIMARY KEY / DEFAULT clause rendering
+      // and emit the entire type string verbatim. Both sites must stay in sync.
+      // The structural fix (a SQLite-specific column option) is tracked in TML-2866.
+      return new DdlColumn({ name, type: `${typeSql} PRIMARY KEY AUTOINCREMENT` });
+    }
+    const colDefault = sqliteDefaultToDdlColumnDefault(column.default);
+    const resolved = resolveColumnTypeMetadata(
+      column,
+      blindCast<
+        Record<string, StorageTypeInstance>,
+        'resolveColumnTypeMetadata declares its storageTypes parameter as mutable Record while the planner stores it readonly; the helper does not mutate, so the readonly→mutable narrowing is sound'
+      >(storageTypes),
+    );
+    const codecRef: CodecRef | undefined = resolved.codecId
+      ? {
+          codecId: resolved.codecId,
+          ...(resolved.typeParams !== undefined
+            ? {
+                typeParams: blindCast<
+                  JsonValue,
+                  'resolved.typeParams is JsonValue-shaped storage metadata; the narrowed (non-undefined) value lands in CodecRef.typeParams which is JsonValue'
+                >(resolved.typeParams),
+              }
+            : {}),
+        }
+      : undefined;
+    return new DdlColumn({
+      name,
+      type: typeSql,
+      ...(!column.nullable ? { notNull: true } : {}),
+      ...(colDefault !== undefined ? { default: colDefault } : {}),
+      ...(codecRef !== undefined ? { codecRef } : {}),
+    });
+  });
+
+  const constraints: DdlTableConstraint[] = [];
+
+  const hasInlinePk = Object.entries(table.columns).some(([name]) =>
+    isInlineAutoincrementPrimaryKey(table, name),
+  );
+  if (table.primaryKey && !hasInlinePk) {
+    constraints.push(new PrimaryKeyConstraint({ columns: table.primaryKey.columns }));
+  }
+
+  for (const u of table.uniques) {
+    constraints.push(
+      new UniqueConstraint({
+        columns: u.columns,
+        ...(u.name !== undefined ? { name: u.name } : {}),
+      }),
+    );
+  }
+
+  for (const fk of table.foreignKeys) {
+    if (fk.constraint === false) continue;
+    constraints.push(
+      new ForeignKeyConstraint({
+        columns: fk.source.columns,
+        refTable: fk.target.tableName,
+        refColumns: fk.target.columns,
+        ...ifDefined('name', fk.name),
+        ...ifDefined('onDelete', fk.onDelete),
+        ...ifDefined('onUpdate', fk.onUpdate),
+      }),
+    );
+  }
+
+  return { columns, constraints };
+}
+
 // ============================================================================
 // Issue planner
 // ============================================================================
@@ -265,7 +399,7 @@ export interface IssuePlannerOptions {
   readonly toContract: Contract<SqlStorage>;
   readonly fromContract: Contract<SqlStorage> | null;
   readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;
-  readonly storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>;
+  readonly storageTypes: Readonly<Record<string, StorageTypeInstance>>;
   readonly schema?: SqlSchemaIR;
   readonly policy?: MigrationOperationPolicy;
   readonly frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
@@ -309,8 +443,17 @@ function mapIssueToCall(
           ),
         );
       }
-      const tableSpec = toTableSpec(contractTable, ctx.storageTypes);
-      const calls: SqliteOpFactoryCall[] = [new CreateTableCall(issue.table, tableSpec)];
+      const { columns: ddlColumns, constraints: ddlConstraints } = tableToDdlParts(
+        contractTable,
+        ctx.storageTypes,
+      );
+      const calls: SqliteOpFactoryCall[] = [
+        new CreateTableCall(
+          issue.table,
+          ddlColumns,
+          ddlConstraints.length > 0 ? ddlConstraints : undefined,
+        ),
+      ];
       const declaredIndexColumnKeys = new Set<string>();
       for (const index of contractTable.indexes) {
         const indexName = index.name ?? defaultIndexName(issue.table, index.columns);