@prisma-next/target-sqlite 0.13.0-dev.2 → 0.13.0-dev.20

package/src/core/migrations/op-factory-call.ts

@@ -2,13 +2,11 @@
  * SQLite migration IR: one concrete `*Call` class per pure factory under
  * `operations/`, plus a shared `SqliteOpFactoryCallNode` abstract base.
  *
- * Each call class carries fully-resolved literal arguments (flat
- * `SqliteColumnSpec` / `SqliteTableSpec` etc.) — codec / `typeRef` / default
- * expansion happens upstream in the issue-planner / strategies, mirroring
- * the Postgres `ColumnSpec` pattern. As a result, `toOp()` and
- * `renderTypeScript()` both pass the same flat data through; the rendered
- * TypeScript scaffold is fully self-contained and does not need access to a
- * `storageTypes` map at runtime.
+ * Each call class carries fully-resolved literal arguments. `CreateTableCall`
+ * holds structured `DdlColumn[]` + `DdlTableConstraint[]` and lowers via the
+ * adapter's DDL path; other call classes carry flat SQL fragments. Codec /
+ * `typeRef` / default expansion happens upstream in the issue-planner /
+ * strategies, mirroring the Postgres `ColumnSpec` pattern.
  */
 
 import { errorUnfilledPlaceholder } from '@prisma-next/errors/migration';
@@ -16,13 +14,24 @@ import type {
   MigrationOperationClass,
   SqlMigrationPlanOperation,
 } from '@prisma-next/family-sql/control';
+import type { ExecuteRequestLowerer, Lowerer } from '@prisma-next/family-sql/control-adapter';
 import type { OpFactoryCall as FrameworkOpFactoryCall } from '@prisma-next/framework-components/control';
+import type {
+  AnyDdlColumnDefault,
+  DdlColumn,
+  DdlTableConstraint,
+} from '@prisma-next/sql-relational-core/ast';
 import { type ImportRequirement, jsonToTsSource, TsExpression } from '@prisma-next/ts-render';
+import { ifDefined } from '@prisma-next/utils/defined';
+import * as contractFreeDdl from '../../contract-free/ddl';
+import { escapeLiteral } from '../sql-utils';
 import { addColumn, dropColumn } from './operations/columns';
 import { createIndex, dropIndex } from './operations/indexes';
 import type { SqliteColumnSpec, SqliteIndexSpec, SqliteTableSpec } from './operations/shared';
-import { createTable, dropTable, recreateTable } from './operations/tables';
+import { step } from './operations/shared';
+import { dropTable, recreateTable } from './operations/tables';
 import type { SqlitePlanTargetDetails } from './planner-target-details';
+import { buildTargetDetails } from './planner-target-details';
 
 type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
 
@@ -32,7 +41,7 @@ abstract class SqliteOpFactoryCallNode extends TsExpression implements Framework
   abstract readonly factoryName: string;
   abstract readonly operationClass: MigrationOperationClass;
   abstract readonly label: string;
-  abstract toOp(): Op;
+  abstract toOp(lowerer?: Lowerer): Op | Promise<Op>;
 
   importRequirements(): readonly ImportRequirement[] {
     return [{ moduleSpecifier: TARGET_MIGRATION_MODULE, symbol: this.factoryName }];
@@ -47,27 +56,157 @@ abstract class SqliteOpFactoryCallNode extends TsExpression implements Framework
 // Table
 // ============================================================================
 
+// ---------------------------------------------------------------------------
+// TypeScript rendering helpers for DdlColumn / DdlTableConstraint
+// ---------------------------------------------------------------------------
+
+function renderDdlColumnDefault(def: AnyDdlColumnDefault | undefined): string {
+  if (!def) return '';
+  if (def.kind === 'literal') {
+    return `lit(${jsonToTsSource(def.value)})`;
+  }
+  return `fn(${jsonToTsSource(def.expression)})`;
+}
+
+function renderDdlColumnAsTsCall(column: DdlColumn): string {
+  const opts: string[] = [];
+  if (column.notNull) opts.push('notNull: true');
+  if (column.primaryKey) opts.push('primaryKey: true');
+  if (column.default) opts.push(`default: ${renderDdlColumnDefault(column.default)}`);
+  const optsStr = opts.length > 0 ? `, { ${opts.join(', ')} }` : '';
+  return `col(${jsonToTsSource(column.name)}, ${jsonToTsSource(column.type)}${optsStr})`;
+}
+
+function renderDdlConstraintAsTsCall(constraint: DdlTableConstraint): string {
+  switch (constraint.kind) {
+    case 'primary-key': {
+      const nameOpt = constraint.name ? `, { name: ${jsonToTsSource(constraint.name)} }` : '';
+      return `primaryKey(${jsonToTsSource(constraint.columns)}${nameOpt})`;
+    }
+    case 'foreign-key': {
+      const opts: string[] = [];
+      if (constraint.name) opts.push(`name: ${jsonToTsSource(constraint.name)}`);
+      if (constraint.onDelete) opts.push(`onDelete: ${jsonToTsSource(constraint.onDelete)}`);
+      if (constraint.onUpdate) opts.push(`onUpdate: ${jsonToTsSource(constraint.onUpdate)}`);
+      const optsStr = opts.length > 0 ? `, { ${opts.join(', ')} }` : '';
+      return `foreignKey(${jsonToTsSource(constraint.columns)}, ${jsonToTsSource(constraint.refTable)}, ${jsonToTsSource(constraint.refColumns)}${optsStr})`;
+    }
+    case 'unique': {
+      const nameOpt = constraint.name ? `, { name: ${jsonToTsSource(constraint.name)} }` : '';
+      return `unique(${jsonToTsSource(constraint.columns)}${nameOpt})`;
+    }
+  }
+}
+
+function constraintImportSymbols(constraints: readonly DdlTableConstraint[] | undefined): string[] {
+  if (!constraints || constraints.length === 0) return [];
+  const symbols = new Set<string>();
+  for (const c of constraints) {
+    if (c.kind === 'primary-key') symbols.add('primaryKey');
+    else if (c.kind === 'foreign-key') symbols.add('foreignKey');
+    else if (c.kind === 'unique') symbols.add('unique');
+  }
+  return [...symbols];
+}
+
+function defaultImportSymbols(columns: readonly DdlColumn[]): string[] {
+  const symbols = new Set<string>();
+  for (const col of columns) {
+    if (col.default?.kind === 'literal') symbols.add('lit');
+    else if (col.default?.kind === 'function') symbols.add('fn');
+  }
+  return [...symbols];
+}
+
 export class CreateTableCall extends SqliteOpFactoryCallNode {
   readonly factoryName = 'createTable' as const;
   readonly operationClass = 'additive' as const;
   readonly tableName: string;
-  readonly spec: SqliteTableSpec;
+  readonly columns: readonly DdlColumn[];
+  readonly constraints: readonly DdlTableConstraint[] | undefined;
   readonly label: string;
 
-  constructor(tableName: string, spec: SqliteTableSpec) {
+  constructor(
+    tableName: string,
+    columns: readonly DdlColumn[],
+    constraints?: readonly DdlTableConstraint[],
+  ) {
     super();
     this.tableName = tableName;
-    this.spec = spec;
+    this.columns = Object.freeze([...columns]);
+    this.constraints = constraints ? Object.freeze([...constraints]) : undefined;
     this.label = `Create table ${tableName}`;
     this.freeze();
   }
 
-  toOp(): Op {
-    return createTable(this.tableName, this.spec);
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `CreateTableCall.toOp: a DDL lowerer is required on the SQLite planner path (table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`,
+      );
+    }
+    const ddlNode = contractFreeDdl.createTable({
+      table: this.tableName,
+      columns: this.columns,
+      ...ifDefined('constraints', this.constraints),
+    });
+    const statement = await lowerer.lowerToExecuteRequest(ddlNode);
+    const tableName = this.tableName;
+    const escapedName = escapeLiteral(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 = '${escapedName}'`,
+        ),
+      ],
+      execute: [
+        {
+          description: `create table "${tableName}"`,
+          sql: statement.sql,
+          params: statement.params ?? [],
+        },
+      ],
+      postcheck: [
+        step(
+          `verify table "${tableName}" exists`,
+          `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapedName}'`,
+        ),
+      ],
+    };
   }
 
   renderTypeScript(): string {
-    return `createTable(${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.spec)})`;
+    const columnsList = this.columns.map(renderDdlColumnAsTsCall).join(', ');
+    const constraintsList = this.constraints
+      ? this.constraints.map(renderDdlConstraintAsTsCall).join(', ')
+      : undefined;
+
+    const opts: string[] = [];
+    opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+    opts.push(`columns: [${columnsList}]`);
+    if (constraintsList) opts.push(`constraints: [${constraintsList}]`);
+
+    return `this.createTable({ ${opts.join(', ')} })`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    const req: ImportRequirement[] = [];
+    if (this.columns.length > 0) {
+      req.push({ moduleSpecifier: TARGET_MIGRATION_MODULE, symbol: 'col' });
+      for (const sym of defaultImportSymbols(this.columns)) {
+        req.push({ moduleSpecifier: TARGET_MIGRATION_MODULE, symbol: sym });
+      }
+    }
+    for (const sym of constraintImportSymbols(this.constraints)) {
+      req.push({ moduleSpecifier: TARGET_MIGRATION_MODULE, symbol: sym });
+    }
+    return req;
   }
 }
 
@@ -84,7 +223,7 @@ export class DropTableCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     return dropTable(this.tableName);
   }
 
@@ -125,7 +264,7 @@ export class RecreateTableCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     return recreateTable({
       tableName: this.tableName,
       contractTable: this.contractTable,
@@ -172,7 +311,7 @@ export class AddColumnCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     return addColumn(this.tableName, this.column);
   }
 
@@ -196,7 +335,7 @@ export class DropColumnCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     return dropColumn(this.tableName, this.columnName);
   }
 
@@ -226,7 +365,7 @@ export class CreateIndexCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     return createIndex(this.tableName, this.indexName, this.columns);
   }
 
@@ -250,7 +389,7 @@ export class DropIndexCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     return dropIndex(this.tableName, this.indexName);
   }
 
@@ -292,7 +431,7 @@ export class DataTransformCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     throw errorUnfilledPlaceholder(this.label);
   }
 
@@ -344,7 +483,7 @@ export class RawSqlCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     return this.op;
   }
 

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

@@ -123,7 +123,7 @@ 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>,
 ): ResolvedColumnTypeMetadata {

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.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,4 +1,11 @@
+import type { 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 { CreateTableCall } from './op-factory-call';
 import type { SqlitePlanTargetDetails } from './planner-target-details';
 
 /**
@@ -7,7 +14,50 @@ import type { SqlitePlanTargetDetails } from './planner-target-details';
  * 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 `createTable`
+ * instance method forwards to `CreateTableCall` 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); `createTable`
+   * throws 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;
+  }
+
+  /**
+   * Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from
+   * the supplied options and lowers it through the stored control adapter.
+   * Throws if no adapter is present (i.e. migration instantiated without a stack).
+   */
+  protected createTable(options: {
+    readonly table: string;
+    readonly ifNotExists?: boolean;
+    readonly columns: readonly DdlColumn[];
+    readonly constraints?: readonly DdlTableConstraint[];
+  }): Promise<SqlMigrationPlanOperation<SqlitePlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorSqliteMigrationStackMissing();
+    }
+    return new CreateTableCall(options.table, options.columns, options.constraints).toOp(
+      this.controlAdapter,
+    );
+  }
 }

package/src/exports/migration.ts

@@ -9,6 +9,14 @@ export { MigrationCLI } from '@prisma-next/cli/migration-cli';
 // `placeholder("…")` slots, instead of pulling in `@prisma-next/errors`
 // directly. The planner emits an import from this same module.
 export { placeholder } from '@prisma-next/errors/migration';
+export {
+  col,
+  fn,
+  foreignKey,
+  lit,
+  primaryKey,
+  unique,
+} from '@prisma-next/sql-relational-core/contract-free';
 export { addColumn, dropColumn } from '../core/migrations/operations/columns';
 export {
   type DataTransformOptions,
@@ -16,7 +24,7 @@ export {
 } 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';
+export { 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
 // `class M extends Migration { … }` without having to thread the