@prisma-next/target-sqlite 0.13.0-dev.13 → 0.13.0-dev.14

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,23 @@ import type {
   MigrationOperationClass,
   SqlMigrationPlanOperation,
 } from '@prisma-next/family-sql/control';
+import type { 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 * 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 +40,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;
 
   importRequirements(): readonly ImportRequirement[] {
     return [{ moduleSpecifier: TARGET_MIGRATION_MODULE, symbol: this.factoryName }];
@@ -47,27 +55,151 @@ 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);
+  toOp(lowerer?: Lowerer): 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,
+      ...(this.constraints ? { constraints: this.constraints } : {}),
+    });
+    const { sql } = lowerer.lower(ddlNode, { contract: {} });
+    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: [step(`create table "${tableName}"`, sql)],
+      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 +216,7 @@ export class DropTableCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     return dropTable(this.tableName);
   }
 
@@ -125,7 +257,7 @@ export class RecreateTableCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     return recreateTable({
       tableName: this.tableName,
       contractTable: this.contractTable,
@@ -172,7 +304,7 @@ export class AddColumnCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     return addColumn(this.tableName, this.column);
   }
 
@@ -196,7 +328,7 @@ export class DropColumnCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     return dropColumn(this.tableName, this.columnName);
   }
 
@@ -226,7 +358,7 @@ export class CreateIndexCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     return createIndex(this.tableName, this.indexName, this.columns);
   }
 
@@ -250,7 +382,7 @@ export class DropIndexCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     return dropIndex(this.tableName, this.indexName);
   }
 
@@ -292,7 +424,7 @@ export class DataTransformCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     throw errorUnfilledPlaceholder(this.label);
   }
 
@@ -344,7 +476,7 @@ export class RawSqlCall extends SqliteOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
+  toOp(_lowerer?: Lowerer): Op {
     return this.op;
   }
 

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

@@ -1,4 +1,5 @@
 import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
+import type { Lowerer } from '@prisma-next/family-sql/control-adapter';
 import type {
   MigrationPlanWithAuthoringSurface,
   OpFactoryCall,
@@ -24,22 +25,25 @@ export class TypeScriptRenderableSqliteMigration
   readonly #meta: MigrationMeta;
   readonly #destination: SqliteMigrationDestinationInfo;
   readonly #spaceId: string;
+  readonly #lowerer: Lowerer | undefined;
 
   constructor(
     calls: readonly OpFactoryCall[],
     meta: MigrationMeta,
     spaceId: string,
     destination?: SqliteMigrationDestinationInfo,
+    lowerer?: Lowerer,
   ) {
     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);
+    return renderOps(this.#calls, this.#lowerer);
   }
 
   override describe(): MigrationMeta {

package/src/core/migrations/planner.ts

@@ -10,6 +10,7 @@ import {
   planFieldEventOperations,
   plannerFailure,
 } from '@prisma-next/family-sql/control';
+import type { Lowerer } 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,8 @@ import {
 import { sqlitePlannerStrategies } from './planner-strategies';
 import type { SqlitePlanTargetDetails } from './planner-target-details';
 
-export function createSqliteMigrationPlanner(): SqliteMigrationPlanner {
-  return new SqliteMigrationPlanner();
+export function createSqliteMigrationPlanner(lowerer: Lowerer): SqliteMigrationPlanner {
+  return new SqliteMigrationPlanner(lowerer);
 }
 
 export type SqlitePlanResult =
@@ -52,6 +53,12 @@ export type SqlitePlanResult =
 export class SqliteMigrationPlanner
   implements SqlMigrationPlanner<SqlitePlanTargetDetails>, MigrationPlanner<'sql', 'sqlite'>
 {
+  readonly #lowerer: Lowerer;
+
+  constructor(lowerer: Lowerer) {
+    this.#lowerer = lowerer;
+  }
+
   plan(options: {
     readonly contract: unknown;
     readonly schema: unknown;
@@ -89,6 +96,8 @@ export class SqliteMigrationPlanner
         to: context.toHash,
       },
       spaceId,
+      undefined,
+      this.#lowerer,
     );
   }
 
@@ -149,6 +158,7 @@ export class SqliteMigrationPlanner
         },
         options.spaceId,
         destination,
+        this.#lowerer,
       ),
     };
   }

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

@@ -1,15 +1,23 @@
 import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
+import type { Lowerer } from '@prisma-next/family-sql/control-adapter';
 import type { OpFactoryCall } from '@prisma-next/framework-components/control';
+import { blindCast } from '@prisma-next/utils/casts';
 import type { SqlitePlanTargetDetails } from './planner-target-details';
 
 type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
 
-export function renderOps(calls: readonly OpFactoryCall[]): Op[] {
+export function renderOps(calls: readonly OpFactoryCall[], lowerer?: Lowerer): 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);
+  return calls.map(
+    (c) =>
+      blindCast<
+        { toOp(lowerer?: Lowerer): ReturnType<OpFactoryCall['toOp']> },
+        'SQLite OpFactoryCall.toOp accepts an optional Lowerer; the framework interface omits it because not all targets need a lowerer — the SQLite target overrides with this extended signature'
+      >(c).toOp(lowerer) as Op,
+  );
 }

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[];
+  }): 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