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

package/src/core/migrations/operations/shared.ts

@@ -1,13 +1,21 @@
-import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
+import type {
+  SqlMigrationPlanOperation,
+  SqlMigrationPlanOperationStep,
+} from '@prisma-next/family-sql/control';
 import { REFERENTIAL_ACTION_SQL } from '@prisma-next/sql-contract/referential-action-sql';
 import type { ReferentialAction } from '@prisma-next/sql-contract/types';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { quoteIdentifier } from '../../sql-utils';
 import type { SqlitePlanTargetDetails } from '../planner-target-details';
 
 export type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
 
-export function step(description: string, sql: string): { description: string; sql: string } {
-  return { description, sql };
+export function step(
+  description: string,
+  sql: string,
+  params?: readonly unknown[],
+): SqlMigrationPlanOperationStep {
+  return { description, sql, ...ifDefined('params', params) };
 }
 
 /**

package/src/core/migrations/operations/tables.ts

@@ -1,5 +1,7 @@
 import type { MigrationOperationClass } from '@prisma-next/family-sql/control';
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
 import type { SchemaIssue } from '@prisma-next/framework-components/control';
+import { tableExistsAst } from '../../../contract-free/checks';
 import { stripOuterParens } from '../../default-normalizer';
 import { escapeLiteral, quoteIdentifier } from '../../sql-utils';
 import { buildCreateIndexSql } from '../planner-ddl-builders';
@@ -13,6 +15,18 @@ import {
   step,
 } from './shared';
 
+type CheckStep = { sql: string; params?: readonly unknown[] };
+
+async function tableExistsSteps(
+  lowerer: ExecuteRequestLowerer,
+  tableName: string,
+): Promise<{ present: CheckStep; absent: CheckStep }> {
+  const checks = tableExistsAst(tableName);
+  const present = await lowerer.lowerToExecuteRequest(checks.tablePresent());
+  const absent = await lowerer.lowerToExecuteRequest(checks.tableAbsent());
+  return { present, absent };
+}
+
 /**
  * Renders the body of a `CREATE TABLE <name> ( … )` statement from a flat
  * `SqliteTableSpec`. SQLite's `INTEGER PRIMARY KEY AUTOINCREMENT` form is
@@ -42,49 +56,35 @@ function renderCreateTableSql(tableName: string, spec: SqliteTableSpec): string
   return `CREATE TABLE ${quoteIdentifier(tableName)} (\n  ${allDefs.join(',\n  ')}\n)`;
 }
 
-export function createTable(tableName: string, spec: SqliteTableSpec): Op {
+export async function createTable(
+  tableName: string,
+  spec: SqliteTableSpec,
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
+  const { present, absent } = await tableExistsSteps(lowerer, tableName);
   return {
     id: `table.${tableName}`,
     label: `Create table ${tableName}`,
     summary: `Creates table ${tableName} with required columns`,
     operationClass: 'additive',
     target: { id: 'sqlite', details: buildTargetDetails('table', tableName) },
-    precheck: [
-      step(
-        `ensure table "${tableName}" does not exist`,
-        `SELECT COUNT(*) = 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}'`,
-      ),
-    ],
+    precheck: [step(`ensure table "${tableName}" does not exist`, absent.sql, absent.params)],
     execute: [step(`create table "${tableName}"`, renderCreateTableSql(tableName, spec))],
-    postcheck: [
-      step(
-        `verify table "${tableName}" exists`,
-        `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}'`,
-      ),
-    ],
+    postcheck: [step(`verify table "${tableName}" exists`, present.sql, present.params)],
   };
 }
 
-export function dropTable(tableName: string): Op {
+export async function dropTable(tableName: string, lowerer: ExecuteRequestLowerer): Promise<Op> {
+  const { present, absent } = await tableExistsSteps(lowerer, tableName);
   return {
     id: `dropTable.${tableName}`,
     label: `Drop table ${tableName}`,
     summary: `Drops table ${tableName} which is not in the contract`,
     operationClass: 'destructive',
     target: { id: 'sqlite', details: buildTargetDetails('table', tableName) },
-    precheck: [
-      step(
-        `ensure table "${tableName}" exists`,
-        `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}'`,
-      ),
-    ],
+    precheck: [step(`ensure table "${tableName}" exists`, present.sql, present.params)],
     execute: [step(`drop table "${tableName}"`, `DROP TABLE ${quoteIdentifier(tableName)}`)],
-    postcheck: [
-      step(
-        `verify table "${tableName}" is gone`,
-        `SELECT COUNT(*) = 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}'`,
-      ),
-    ],
+    postcheck: [step(`verify table "${tableName}" is gone`, absent.sql, absent.params)],
   };
 }
 
@@ -115,7 +115,10 @@ export interface RecreateTableArgs {
   readonly operationClass: MigrationOperationClass;
 }
 
-export function recreateTable(args: RecreateTableArgs): Op {
+export async function recreateTable(
+  args: RecreateTableArgs,
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
   const {
     tableName,
     contractTable,
@@ -149,6 +152,9 @@ export function recreateTable(args: RecreateTableArgs): Op {
         ]
       : [];
 
+  const tableSteps = await tableExistsSteps(lowerer, tableName);
+  const tempSteps = await tableExistsSteps(lowerer, tempName);
+
   return {
     id: `recreateTable.${tableName}`,
     label: `Recreate table ${tableName}`,
@@ -156,13 +162,11 @@ export function recreateTable(args: RecreateTableArgs): Op {
     operationClass,
     target: { id: 'sqlite', details: buildTargetDetails('table', tableName) },
     precheck: [
-      step(
-        `ensure table "${tableName}" exists`,
-        `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}'`,
-      ),
+      step(`ensure table "${tableName}" exists`, tableSteps.present.sql, tableSteps.present.params),
       step(
         `ensure temp table "${tempName}" does not exist`,
-        `SELECT COUNT(*) = 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tempName)}'`,
+        tempSteps.absent.sql,
+        tempSteps.absent.params,
       ),
     ],
     execute: [
@@ -179,13 +183,11 @@ export function recreateTable(args: RecreateTableArgs): Op {
       ...indexStatements,
     ],
     postcheck: [
-      step(
-        `verify table "${tableName}" exists`,
-        `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}'`,
-      ),
+      step(`verify table "${tableName}" exists`, tableSteps.present.sql, tableSteps.present.params),
       step(
         `verify temp table "${tempName}" is gone`,
-        `SELECT COUNT(*) = 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tempName)}'`,
+        tempSteps.absent.sql,
+        tempSteps.absent.params,
       ),
       ...postchecks,
     ],

package/src/core/migrations/planner-ddl-builders.ts

@@ -8,12 +8,10 @@
  * see `StorageColumn` or `storageTypes`.
  */
 
-import {
-  isPostgresEnumStorageEntry,
-  type PostgresEnumStorageEntry,
-  type StorageColumn,
-  type StorageTable,
-  type StorageTypeInstance,
+import type {
+  StorageColumn,
+  StorageTable,
+  StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
 import { escapeLiteral, quoteIdentifier } from '../sql-utils';
 
@@ -46,7 +44,7 @@ function assertSafeDefaultExpression(expression: string): void {
  */
 export function buildColumnTypeSql(
   column: StorageColumn,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},
+  storageTypes: Record<string, StorageTypeInstance> = {},
 ): string {
   const resolved = resolveColumnTypeMetadata(column, storageTypes);
   assertSafeNativeType(resolved.nativeType);
@@ -123,9 +121,9 @@ export function isInlineAutoincrementPrimaryKey(table: StorageTable, columnName:
 
 type ResolvedColumnTypeMetadata = Pick<StorageColumn, 'nativeType' | 'codecId' | 'typeParams'>;
 
-function resolveColumnTypeMetadata(
+export function resolveColumnTypeMetadata(
   column: StorageColumn,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+  storageTypes: Record<string, StorageTypeInstance>,
 ): ResolvedColumnTypeMetadata {
   if (!column.typeRef) {
     return column;
@@ -136,13 +134,6 @@ function resolveColumnTypeMetadata(
       `Storage type "${column.typeRef}" referenced by column is not defined in storage.types.`,
     );
   }
-  if (isPostgresEnumStorageEntry(referencedType)) {
-    return {
-      codecId: referencedType.codecId,
-      nativeType: referencedType.nativeType,
-      typeParams: { values: referencedType.values } as Record<string, unknown>,
-    };
-  }
   return {
     codecId: referencedType.codecId,
     nativeType: referencedType.nativeType,

package/src/core/migrations/planner-produced-sqlite-migration.ts

@@ -1,4 +1,5 @@
 import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
 import type {
   MigrationPlanWithAuthoringSurface,
   OpFactoryCall,
@@ -24,22 +25,27 @@ export class TypeScriptRenderableSqliteMigration
   readonly #meta: MigrationMeta;
   readonly #destination: SqliteMigrationDestinationInfo;
   readonly #spaceId: string;
+  readonly #lowerer: ExecuteRequestLowerer | undefined;
+  #operationsCache: readonly (Op | Promise<Op>)[] | undefined;
 
   constructor(
     calls: readonly OpFactoryCall[],
     meta: MigrationMeta,
     spaceId: string,
     destination?: SqliteMigrationDestinationInfo,
+    lowerer?: ExecuteRequestLowerer,
   ) {
     super();
     this.#calls = calls;
     this.#meta = meta;
     this.#spaceId = spaceId;
     this.#destination = destination ?? { storageHash: meta.to };
+    this.#lowerer = lowerer;
   }
 
-  override get operations(): readonly Op[] {
-    return renderOps(this.#calls);
+  override get operations(): readonly (Op | Promise<Op>)[] {
+    this.#operationsCache ??= renderOps(this.#calls, this.#lowerer);
+    return this.#operationsCache;
   }
 
   override describe(): MigrationMeta {

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

@@ -23,7 +23,6 @@ import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-comp
 import type { SchemaIssue } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type {
-  PostgresEnumStorageEntry,
   SqlStorage,
   StorageTable,
   StorageTypeInstance,
@@ -39,7 +38,7 @@ export interface StrategyContext {
   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>>;
@@ -61,7 +60,8 @@ export function tableAt(
   namespaceId: string,
   tableName: string,
 ): StorageTable | undefined {
-  return storage.namespaces[namespaceId]?.entries.table[tableName] as StorageTable | undefined;
+  const ns = storage.namespaces[namespaceId];
+  return ns !== undefined ? ns.entries.table?.[tableName] : undefined;
 }
 
 /**

package/src/core/migrations/planner.ts

@@ -10,6 +10,7 @@ import {
   planFieldEventOperations,
   plannerFailure,
 } from '@prisma-next/family-sql/control';
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
 import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type {
@@ -27,8 +28,10 @@ import {
 import { sqlitePlannerStrategies } from './planner-strategies';
 import type { SqlitePlanTargetDetails } from './planner-target-details';
 
-export function createSqliteMigrationPlanner(): SqliteMigrationPlanner {
-  return new SqliteMigrationPlanner();
+export function createSqliteMigrationPlanner(
+  lowerer: ExecuteRequestLowerer,
+): SqliteMigrationPlanner {
+  return new SqliteMigrationPlanner(lowerer);
 }
 
 export type SqlitePlanResult =
@@ -52,6 +55,12 @@ export type SqlitePlanResult =
 export class SqliteMigrationPlanner
   implements SqlMigrationPlanner<SqlitePlanTargetDetails>, MigrationPlanner<'sql', 'sqlite'>
 {
+  readonly #lowerer: ExecuteRequestLowerer;
+
+  constructor(lowerer: ExecuteRequestLowerer) {
+    this.#lowerer = lowerer;
+  }
+
   plan(options: {
     readonly contract: unknown;
     readonly schema: unknown;
@@ -89,6 +98,8 @@ export class SqliteMigrationPlanner
         to: context.toHash,
       },
       spaceId,
+      undefined,
+      this.#lowerer,
     );
   }
 
@@ -149,6 +160,7 @@ export class SqliteMigrationPlanner
         },
         options.spaceId,
         destination,
+        this.#lowerer,
       ),
     };
   }

package/src/core/migrations/render-ops.ts

@@ -1,15 +1,43 @@
 import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
-import type { OpFactoryCall } from '@prisma-next/framework-components/control';
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
+import type {
+  MigrationPlanOperation,
+  OpFactoryCall,
+} from '@prisma-next/framework-components/control';
+import { blindCast } from '@prisma-next/utils/casts';
+import { isThenable } from '@prisma-next/utils/promise';
 import type { SqlitePlanTargetDetails } from './planner-target-details';
 
 type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
 
-export function renderOps(calls: readonly OpFactoryCall[]): Op[] {
-  // Each call's `toOp()` is typed as the framework `MigrationPlanOperation`;
-  // every concrete Call class on the sqlite planner path produces an op
-  // whose `target.details` is `SqlitePlanTargetDetails`-shaped (or whose
-  // `target.details` is absent, which is structurally compatible). The
-  // narrowing cast happens at this single integration boundary instead of
-  // poisoning every caller's type.
-  return calls.map((c) => c.toOp() as Op);
+function assertSqliteOp(op: MigrationPlanOperation, callFactoryName: string): asserts op is Op {
+  const targetId = blindCast<
+    { target?: { id?: string } },
+    'op.target is present on concrete SqlMigrationPlanOperation but absent on the framework MigrationPlanOperation base'
+  >(op).target?.id;
+  if (targetId !== 'sqlite') {
+    throw new Error(
+      `renderOps: expected sqlite op but got target.id="${String(targetId)}" for op.id="${op.id}" (factoryName="${callFactoryName}"). An OpFactoryCall produced an op for a different target on the sqlite planner path; check the call's target binding.`,
+    );
+  }
+}
+
+export function renderOps(
+  calls: readonly OpFactoryCall[],
+  lowerer?: ExecuteRequestLowerer,
+): (Op | Promise<Op>)[] {
+  return calls.map((c) => {
+    const opOrPromise = blindCast<
+      { toOp(lowerer?: ExecuteRequestLowerer): Op | Promise<Op> },
+      'SQLite OpFactoryCall.toOp accepts an optional ExecuteRequestLowerer; the framework interface omits it because not all targets need a lowerer — the SQLite target overrides with this extended signature'
+    >(c).toOp(lowerer);
+    if (isThenable(opOrPromise)) {
+      return opOrPromise.then((op) => {
+        assertSqliteOp(op, c.factoryName);
+        return op;
+      });
+    }
+    assertSqliteOp(opOrPromise, c.factoryName);
+    return opOrPromise;
+  });
 }

package/src/core/migrations/runner.ts

@@ -16,7 +16,8 @@ import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
 import type { MigrationRunnerResult } from '@prisma-next/framework-components/control';
 import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
 import type { SqlControlDriverInstance, SqlStorage } from '@prisma-next/sql-contract/types';
-import type { LoweredStatement } from '@prisma-next/sql-relational-core/ast';
+import type { SqlExecuteRequest } from '@prisma-next/sql-relational-core/ast';
+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, okVoid } from '@prisma-next/utils/result';
@@ -51,13 +52,19 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
     }
     const space = options.plan.spaceId;
 
+    // Materialize any async ops before running checks or executing.
+    const planOps = blindCast<
+      readonly SqlMigrationPlanOperation<SqlitePlanTargetDetails>[],
+      'ops were produced by the SQLite planner and are SqlMigrationPlanOperation<SqlitePlanTargetDetails>; MigrationPlan.operations uses the wider framework type to accommodate Promise covariance'
+    >(await Promise.all(options.plan.operations));
+
     const destinationCheck = this.ensurePlanMatchesDestinationContract(
       options.plan.destination,
       options.destinationContract,
     );
     if (!destinationCheck.ok) return destinationCheck;
 
-    const policyCheck = this.enforcePolicyCompatibility(options.policy, options.plan.operations);
+    const policyCheck = this.enforcePolicyCompatibility(options.policy, planOps);
     if (!policyCheck.ok) return policyCheck;
 
     const ensureResult = await this.ensureControlTables(driver, options.destinationContract);
@@ -78,7 +85,7 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
       operationsExecuted = 0;
       executedOperations = [];
     } else {
-      const applyResult = await this.applyPlan(driver, options);
+      const applyResult = await this.applyPlan(driver, options, planOps);
       if (!applyResult.ok) return applyResult;
       operationsExecuted = applyResult.value.operationsExecuted;
       executedOperations = applyResult.value.executedOperations;
@@ -122,7 +129,7 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
     }
 
     return runnerSuccess({
-      operationsPlanned: options.plan.operations.length,
+      operationsPlanned: planOps.length,
       operationsExecuted,
     });
   }
@@ -226,6 +233,7 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
   private async applyPlan(
     driver: SqlMigrationRunnerExecuteOptions<SqlitePlanTargetDetails>['driver'],
     options: SqlMigrationRunnerExecuteOptions<SqlitePlanTargetDetails>,
+    ops: readonly SqlMigrationPlanOperation<SqlitePlanTargetDetails>[],
   ): Promise<
     Result<
       {
@@ -243,7 +251,7 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
     let operationsExecuted = 0;
     const executedOperations: Array<SqlMigrationPlanOperation<SqlitePlanTargetDetails>> = [];
 
-    for (const operation of options.plan.operations) {
+    for (const operation of ops) {
       options.callbacks?.onOperationStart?.(operation);
       try {
         if (runPostchecks && runIdempotency) {
@@ -305,7 +313,7 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
     }
     const lowererContext = { contract };
     for (const query of this.family.bootstrapControlTableQueries()) {
-      await this.executeStatement(driver, this.family.lowerAst(query, lowererContext));
+      await this.executeStatement(driver, await this.family.lowerAst(query, lowererContext));
     }
     return okVoid();
   }
@@ -659,12 +667,8 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
 
   private async executeStatement(
     driver: SqlMigrationRunnerExecuteOptions<SqlitePlanTargetDetails>['driver'],
-    statement: LoweredStatement,
+    statement: SqlExecuteRequest,
   ): Promise<void> {
-    if (statement.params.length > 0) {
-      await driver.query(statement.sql, statement.params);
-      return;
-    }
-    await driver.query(statement.sql);
+    await driver.query(statement.sql, statement.params);
   }
 }

package/src/core/migrations/sqlite-migration.ts

@@ -1,13 +1,131 @@
+import type {
+  MigrationOperationClass,
+  SqlMigrationPlanOperation,
+} from '@prisma-next/family-sql/control';
+import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
 import { Migration as SqlMigration } from '@prisma-next/family-sql/migration';
+import type { ControlStack } from '@prisma-next/framework-components/control';
+import type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';
+import { blindCast } from '@prisma-next/utils/casts';
+import { errorSqliteMigrationStackMissing } from '../errors';
+import {
+  AddColumnCall,
+  CreateIndexCall,
+  CreateTableCall,
+  DropColumnCall,
+  DropIndexCall,
+  DropTableCall,
+  RecreateTableCall,
+} from './op-factory-call';
+import type { SqliteColumnSpec, SqliteIndexSpec, SqliteTableSpec } from './operations/shared';
 import type { SqlitePlanTargetDetails } from './planner-target-details';
 
+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.
  */
-export abstract class SqliteMigration extends SqlMigration<SqlitePlanTargetDetails> {
+export abstract class SqliteMigration extends SqlMigration<SqlitePlanTargetDetails, 'sqlite'> {
   readonly targetId = 'sqlite' as const;
+
+  /**
+   * 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'>) {
+    super(stack);
+    this.controlAdapter = stack?.adapter
+      ? blindCast<
+          SqlControlAdapter<'sqlite'>,
+          'The SQLite descriptor create() returns SqlControlAdapter<sqlite>; typed as wider ControlAdapterInstance at the framework boundary'
+        >(stack.adapter.create(stack))
+      : undefined;
+  }
+
+  protected createTable(options: {
+    readonly table: string;
+    readonly ifNotExists?: boolean;
+    readonly columns: readonly DdlColumn[];
+    readonly constraints?: readonly DdlTableConstraint[];
+  }): Promise<Op> {
+    if (!this.controlAdapter) {
+      throw errorSqliteMigrationStackMissing();
+    }
+    return new CreateTableCall(options.table, options.columns, options.constraints).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected dropTable(options: { readonly table: string }): Promise<Op> {
+    if (!this.controlAdapter) {
+      throw errorSqliteMigrationStackMissing();
+    }
+    return new DropTableCall(options.table).toOp(this.controlAdapter);
+  }
+
+  protected addColumn(options: {
+    readonly table: string;
+    readonly column: SqliteColumnSpec;
+  }): Promise<Op> {
+    if (!this.controlAdapter) {
+      throw errorSqliteMigrationStackMissing();
+    }
+    return new AddColumnCall(options.table, options.column).toOp(this.controlAdapter);
+  }
+
+  protected dropColumn(options: { readonly table: string; readonly column: string }): Promise<Op> {
+    if (!this.controlAdapter) {
+      throw errorSqliteMigrationStackMissing();
+    }
+    return new DropColumnCall(options.table, options.column).toOp(this.controlAdapter);
+  }
+
+  protected createIndex(options: {
+    readonly table: string;
+    readonly index: string;
+    readonly columns: readonly string[];
+  }): Promise<Op> {
+    if (!this.controlAdapter) {
+      throw errorSqliteMigrationStackMissing();
+    }
+    return new CreateIndexCall(options.table, options.index, options.columns).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected dropIndex(options: { readonly table: string; readonly index: string }): Promise<Op> {
+    if (!this.controlAdapter) {
+      throw errorSqliteMigrationStackMissing();
+    }
+    return new DropIndexCall(options.table, options.index).toOp(this.controlAdapter);
+  }
+
+  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> {
+    if (!this.controlAdapter) {
+      throw errorSqliteMigrationStackMissing();
+    }
+    return new RecreateTableCall(options).toOp(this.controlAdapter);
+  }
 }

package/src/core/sqlite-contract-serializer.ts

@@ -3,6 +3,7 @@ import { SqlContractSerializerBase } from '@prisma-next/family-sql/ir';
 import { type Namespace, NamespaceBase } from '@prisma-next/framework-components/ir';
 import type { SqlNamespaceTablesInput, SqlStorage } from '@prisma-next/sql-contract/types';
 import { blindCast } from '@prisma-next/utils/casts';
+import { sqliteTargetDescriptorMeta } from './descriptor-meta';
 import { buildSqliteNamespace } from './sqlite-unbound-database';
 
 /**
@@ -16,6 +17,10 @@ export class SqliteContractSerializer extends SqlContractSerializerBase<Contract
     super(new Map());
   }
 
+  protected override get defaultNamespaceId(): string {
+    return sqliteTargetDescriptorMeta.defaultNamespaceId;
+  }
+
   protected override hydrateSqlNamespaceEntry(
     nsId: string,
     raw: Namespace | Record<string, unknown>,