@prisma-next/target-sqlite 0.5.0-dev.8 → 0.5.0-dev.80

package/dist/descriptor-meta-CE2Kbn9b.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-CE2Kbn9b.mjs","names":[],"sources":["../src/core/authoring.ts","../src/core/descriptor-meta.ts"],"sourcesContent":["import { temporalAuthoringPresets } from '@prisma-next/family-sql/control';\nimport type { AuthoringFieldNamespace } from '@prisma-next/framework-components/authoring';\n\nexport const sqliteAuthoringFieldPresets = {\n  temporal: temporalAuthoringPresets({\n    codecId: 'sqlite/datetime@1',\n    nativeType: 'text',\n  }),\n} as const satisfies AuthoringFieldNamespace;\n","import type { CodecTypes } from '../exports/codec-types';\nimport { sqliteAuthoringFieldPresets } from './authoring';\n\nconst sqliteTargetDescriptorMetaBase = {\n  kind: 'target',\n  familyId: 'sql',\n  targetId: 'sqlite',\n  id: 'sqlite',\n  version: '0.0.1',\n  capabilities: {},\n  authoring: {\n    field: sqliteAuthoringFieldPresets,\n  },\n} as const;\n\nexport const sqliteTargetDescriptorMeta: typeof sqliteTargetDescriptorMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n} = sqliteTargetDescriptorMetaBase;\n"],"mappings":";ACeA,MAAa,6BAET;CAbF,MAAM;CACN,UAAU;CACV,UAAU;CACV,IAAI;CACJ,SAAS;CACT,cAAc,EAAE;CAChB,WAAW,EACT,OAAO,EDPT,UAAU,yBAAyB;EACjC,SAAS;EACT,YAAY;EACb,CAAC,ECIO,EACR;CAKC"}

package/dist/migration.d.mts

@@ -0,0 +1,85 @@
+import { i as SqliteTableSpec, n as SqliteColumnSpec, r as SqliteIndexSpec, t as Op } from "./shared-qLsgTOZs.mjs";
+import { t as SqliteMigration } from "./sqlite-migration-DAb2NEX6.mjs";
+import { MigrationOperationClass } from "@prisma-next/family-sql/control";
+import { placeholder } from "@prisma-next/errors/migration";
+import { MigrationCLI } from "@prisma-next/cli/migration-cli";
+
+//#region src/core/migrations/operations/columns.d.ts
+declare function addColumn(tableName: string, column: SqliteColumnSpec): Op;
+declare function dropColumn(tableName: string, columnName: string): Op;
+//#endregion
+//#region src/core/migrations/operations/data-transform.d.ts
+interface DataTransformOptions {
+  /** Stable id used in the ledger / for runner idempotency tracking. */
+  readonly id: string;
+  /** Human-readable label surfaced in CLI output. */
+  readonly label: string;
+  /** Table the backfill targets; informs `target.details`. */
+  readonly table: string;
+  /**
+   * Short description of the step (shown by the runner on execute). The
+   * planner leaves this as `placeholder(...)` for users to replace.
+   */
+  readonly description: string;
+  /**
+   * Producer of the SQL string to execute. Invoked eagerly by
+   * `dataTransform(...)`, mirroring the Postgres factory — by the time the
+   * user calls this factory in `migration.ts`, the SQL is expected to be
+   * ready. Planner-emitted stubs that need to defer until the user fills
+   * in the SQL go through `DataTransformCall.renderTypeScript()` instead;
+   * this factory is only for the post-fill, runnable form.
+   */
+  readonly run: () => string;
+}
+declare function dataTransform(opts: DataTransformOptions): Op;
+//#endregion
+//#region src/core/migrations/operations/indexes.d.ts
+declare function createIndex(tableName: string, indexName: string, columns: readonly string[]): Op;
+declare function dropIndex(tableName: string, indexName: string): Op;
+//#endregion
+//#region src/core/migrations/operations/raw.d.ts
+/**
+ * Identity factory for an already-materialized
+ * `SqlMigrationPlanOperation<SqlitePlanTargetDetails>`. Mirrors the Postgres
+ * `rawSql` factory: the planner uses this to carry ops produced by SQL-family
+ * paths (codec lifecycle hooks, raw-SQL escape hatches) alongside structured
+ * call IR without reverse-engineering their shape.
+ */
+declare function rawSql(op: Op): Op;
+//#endregion
+//#region src/core/migrations/operations/tables.d.ts
+declare function createTable(tableName: string, spec: SqliteTableSpec): Op;
+declare function dropTable(tableName: string): Op;
+interface RecreateTableArgs {
+  readonly tableName: string;
+  /** New (post-recreate) shape of the table. Same flat spec as `createTable`. */
+  readonly contractTable: SqliteTableSpec;
+  /**
+   * Names of columns that exist in the live (pre-recreate) schema. Used to
+   * compute the `INSERT INTO temp ... SELECT ... FROM old` column list — only
+   * shared columns are copied, so dropped columns are left behind and added
+   * columns come from defaults.
+   */
+  readonly schemaColumnNames: readonly string[];
+  /**
+   * Indexes (declared + FK-backing, deduped by column-set) to recreate after
+   * the table has been replaced. The planner pre-merges these.
+   */
+  readonly indexes: readonly SqliteIndexSpec[];
+  /** Human-readable summary of the change, built by the planner from issues. */
+  readonly summary: string;
+  /**
+   * Per-issue postcheck steps appended after the structural postchecks. The
+   * planner pre-builds these via `buildRecreatePostchecks` so the call IR
+   * carries flat, serializable data only — no `SchemaIssue` references.
+   */
+  readonly postchecks: readonly {
+    readonly description: string;
+    readonly sql: string;
+  }[];
+  readonly operationClass: MigrationOperationClass;
+}
+declare function recreateTable(args: RecreateTableArgs): Op;
+//#endregion
+export { type DataTransformOptions, SqliteMigration as Migration, MigrationCLI, addColumn, createIndex, createTable, dataTransform, dropColumn, dropIndex, dropTable, placeholder, rawSql, recreateTable };
+//# sourceMappingURL=migration.d.mts.map

package/dist/migration.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration.d.mts","names":[],"sources":["../src/core/migrations/operations/columns.ts","../src/core/migrations/operations/data-transform.ts","../src/core/migrations/operations/indexes.ts","../src/core/migrations/operations/raw.ts","../src/core/migrations/operations/tables.ts"],"mappings":";;;;;;;iBAIgB,SAAA,CAAU,SAAA,UAAmB,MAAA,EAAQ,gBAAA,GAAmB,EAAA;AAAA,iBA+BxD,UAAA,CAAW,SAAA,UAAmB,UAAA,WAAqB,EAAA;;;UCnBlD,oBAAA;EDZ4B;EAAA,SCclC,EAAA;EDd+D;EAAA,SCgB/D,KAAA;EDeK;EAAA,SCbL,KAAA;;;;;WAKA,WAAA;EDQ0D;;;;;ACnBrE;;;EDmBqE,SCC1D,GAAA;AAAA;AAAA,iBAGK,aAAA,CAAc,IAAA,EAAM,oBAAA,GAAuB,EAAA;;;iBClC3C,WAAA,CAAY,SAAA,UAAmB,SAAA,UAAmB,OAAA,sBAA6B,EAAA;AAAA,iBAyB/E,SAAA,CAAU,SAAA,UAAmB,SAAA,WAAoB,EAAA;;;;;;;;;;iBCrBjD,MAAA,CAAO,EAAA,EAAI,EAAA,GAAK,EAAA;;;iBCmChB,WAAA,CAAY,SAAA,UAAmB,IAAA,EAAM,eAAA,GAAkB,EAAA;AAAA,iBAuBvD,SAAA,CAAU,SAAA,WAAoB,EAAA;AAAA,UAuB7B,iBAAA;EAAA,SACN,SAAA;;WAEA,aAAA,EAAe,eAAA;EJzFD;;;;;;EAAA,SIgGd,iBAAA;EJhG+D;;AA+B1E;;EA/B0E,SIqG/D,OAAA,WAAkB,eAAA;EJtEwC;EAAA,SIwE1D,OAAA;EJxEmC;;;;;EAAA,SI8EnC,UAAA;IAAA,SAAgC,WAAA;IAAA,SAA8B,GAAA;EAAA;EAAA,SAC9D,cAAA,EAAgB,uBAAA;AAAA;AAAA,iBAGX,aAAA,CAAc,IAAA,EAAM,iBAAA,GAAoB,EAAA"}

package/dist/migration.mjs

@@ -0,0 +1,49 @@
+import { t as buildTargetDetails } from "./planner-target-details-Bm71XPKb.mjs";
+import { a as recreateTable, f as addColumn, i as dropTable, m as step, o as createIndex, p as dropColumn, r as createTable, s as dropIndex } from "./tables-D84zfPZI.mjs";
+import { t as SqliteMigration } from "./sqlite-migration-BBJktVVw.mjs";
+import { placeholder } from "@prisma-next/errors/migration";
+import { MigrationCLI } from "@prisma-next/cli/migration-cli";
+//#region src/core/migrations/operations/data-transform.ts
+/**
+* User-facing `dataTransform` factory for the SQLite migration authoring
+* surface. Invoked directly inside a `migration.ts` file to supply a
+* user-authored SQL statement that runs with operation class `'data'`.
+*
+* Typical use: the planner emits a `DataTransformCall` stub when a NOT NULL
+* tightening requires a backfill. The rendered `migration.ts` exposes the
+* backfill as a `placeholder("…")` slot the user fills in with an
+* `UPDATE … WHERE col IS NULL` statement. The filled-in `dataTransform(...)`
+* invocation returns a runnable operation the runner executes before the
+* subsequent recreate-table op copies data into the tightened schema.
+*/
+function dataTransform(opts) {
+	return {
+		id: opts.id,
+		label: opts.label,
+		summary: opts.description,
+		operationClass: "data",
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("table", opts.table)
+		},
+		precheck: [],
+		execute: [step(opts.description, opts.run())],
+		postcheck: []
+	};
+}
+//#endregion
+//#region src/core/migrations/operations/raw.ts
+/**
+* Identity factory for an already-materialized
+* `SqlMigrationPlanOperation<SqlitePlanTargetDetails>`. Mirrors the Postgres
+* `rawSql` factory: the planner uses this to carry ops produced by SQL-family
+* paths (codec lifecycle hooks, raw-SQL escape hatches) alongside structured
+* call IR without reverse-engineering their shape.
+*/
+function rawSql(op) {
+	return op;
+}
+//#endregion
+export { SqliteMigration as Migration, MigrationCLI, addColumn, createIndex, createTable, dataTransform, dropColumn, dropIndex, dropTable, placeholder, rawSql, recreateTable };
+
+//# sourceMappingURL=migration.mjs.map

package/dist/migration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration.mjs","names":[],"sources":["../src/core/migrations/operations/data-transform.ts","../src/core/migrations/operations/raw.ts"],"sourcesContent":["/**\n * User-facing `dataTransform` factory for the SQLite migration authoring\n * surface. Invoked directly inside a `migration.ts` file to supply a\n * user-authored SQL statement that runs with operation class `'data'`.\n *\n * Typical use: the planner emits a `DataTransformCall` stub when a NOT NULL\n * tightening requires a backfill. The rendered `migration.ts` exposes the\n * backfill as a `placeholder(\"…\")` slot the user fills in with an\n * `UPDATE … WHERE col IS NULL` statement. The filled-in `dataTransform(...)`\n * invocation returns a runnable operation the runner executes before the\n * subsequent recreate-table op copies data into the tightened schema.\n */\n\nimport { buildTargetDetails } from '../planner-target-details';\nimport { type Op, step } from './shared';\n\nexport interface DataTransformOptions {\n  /** Stable id used in the ledger / for runner idempotency tracking. */\n  readonly id: string;\n  /** Human-readable label surfaced in CLI output. */\n  readonly label: string;\n  /** Table the backfill targets; informs `target.details`. */\n  readonly table: string;\n  /**\n   * Short description of the step (shown by the runner on execute). The\n   * planner leaves this as `placeholder(...)` for users to replace.\n   */\n  readonly description: string;\n  /**\n   * Producer of the SQL string to execute. Invoked eagerly by\n   * `dataTransform(...)`, mirroring the Postgres factory — by the time the\n   * user calls this factory in `migration.ts`, the SQL is expected to be\n   * ready. Planner-emitted stubs that need to defer until the user fills\n   * in the SQL go through `DataTransformCall.renderTypeScript()` instead;\n   * this factory is only for the post-fill, runnable form.\n   */\n  readonly run: () => string;\n}\n\nexport function dataTransform(opts: DataTransformOptions): Op {\n  return {\n    id: opts.id,\n    label: opts.label,\n    summary: opts.description,\n    operationClass: 'data',\n    target: { id: 'sqlite', details: buildTargetDetails('table', opts.table) },\n    precheck: [],\n    execute: [step(opts.description, opts.run())],\n    postcheck: [],\n  };\n}\n","import type { Op } from './shared';\n\n/**\n * Identity factory for an already-materialized\n * `SqlMigrationPlanOperation<SqlitePlanTargetDetails>`. Mirrors the Postgres\n * `rawSql` factory: the planner uses this to carry ops produced by SQL-family\n * paths (codec lifecycle hooks, raw-SQL escape hatches) alongside structured\n * call IR without reverse-engineering their shape.\n */\nexport function rawSql(op: Op): Op {\n  return op;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAuCA,SAAgB,cAAc,MAAgC;CAC5D,OAAO;EACL,IAAI,KAAK;EACT,OAAO,KAAK;EACZ,SAAS,KAAK;EACd,gBAAgB;EAChB,QAAQ;GAAE,IAAI;GAAU,SAAS,mBAAmB,SAAS,KAAK,MAAM;GAAE;EAC1E,UAAU,EAAE;EACZ,SAAS,CAAC,KAAK,KAAK,aAAa,KAAK,KAAK,CAAC,CAAC;EAC7C,WAAW,EAAE;EACd;;;;;;;;;;;ACxCH,SAAgB,OAAO,IAAY;CACjC,OAAO"}

package/dist/native-type-normalizer-BlN5XfD-.mjs

@@ -0,0 +1,14 @@
+//#region src/core/native-type-normalizer.ts
+/**
+* Canonicalizes SQLite native-type tokens for verifier comparison.
+* Lives target-side so the planner / runner / adapter all share the same
+* normalization without crossing the `target-sqlite` ↔ `adapter-sqlite`
+* boundary.
+*/
+function normalizeSqliteNativeType(nativeType) {
+	return nativeType.trim().toLowerCase();
+}
+//#endregion
+export { normalizeSqliteNativeType as t };
+
+//# sourceMappingURL=native-type-normalizer-BlN5XfD-.mjs.map

package/dist/native-type-normalizer-BlN5XfD-.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-type-normalizer-BlN5XfD-.mjs","names":[],"sources":["../src/core/native-type-normalizer.ts"],"sourcesContent":["/**\n * Canonicalizes SQLite native-type tokens for verifier comparison.\n * Lives target-side so the planner / runner / adapter all share the same\n * normalization without crossing the `target-sqlite` ↔ `adapter-sqlite`\n * boundary.\n */\nexport function normalizeSqliteNativeType(nativeType: string): string {\n  return nativeType.trim().toLowerCase();\n}\n"],"mappings":";;;;;;;AAMA,SAAgB,0BAA0B,YAA4B;CACpE,OAAO,WAAW,MAAM,CAAC,aAAa"}

package/dist/native-type-normalizer.d.mts

@@ -0,0 +1,11 @@
+//#region src/core/native-type-normalizer.d.ts
+/**
+ * Canonicalizes SQLite native-type tokens for verifier comparison.
+ * Lives target-side so the planner / runner / adapter all share the same
+ * normalization without crossing the `target-sqlite` ↔ `adapter-sqlite`
+ * boundary.
+ */
+declare function normalizeSqliteNativeType(nativeType: string): string;
+//#endregion
+export { normalizeSqliteNativeType };
+//# sourceMappingURL=native-type-normalizer.d.mts.map

package/dist/native-type-normalizer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-type-normalizer.d.mts","names":[],"sources":["../src/core/native-type-normalizer.ts"],"mappings":";;AAMA;;;;;iBAAgB,yBAAA,CAA0B,UAAA"}

package/dist/native-type-normalizer.mjs

@@ -0,0 +1,2 @@
+import { t as normalizeSqliteNativeType } from "./native-type-normalizer-BlN5XfD-.mjs";
+export { normalizeSqliteNativeType };

package/dist/op-factory-call-DRKKURAO.mjs

@@ -0,0 +1,279 @@
+import { a as recreateTable, f as addColumn, i as dropTable, o as createIndex, p as dropColumn, r as createTable, s as dropIndex } from "./tables-D84zfPZI.mjs";
+import { errorUnfilledPlaceholder } from "@prisma-next/errors/migration";
+import { TsExpression, jsonToTsSource } from "@prisma-next/ts-render";
+//#region src/core/migrations/op-factory-call.ts
+/**
+* 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.
+*/
+const TARGET_MIGRATION_MODULE = "@prisma-next/target-sqlite/migration";
+var SqliteOpFactoryCallNode = class extends TsExpression {
+	importRequirements() {
+		return [{
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol: this.factoryName
+		}];
+	}
+	freeze() {
+		Object.freeze(this);
+	}
+};
+var CreateTableCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "createTable";
+	operationClass = "additive";
+	tableName;
+	spec;
+	label;
+	constructor(tableName, spec) {
+		super();
+		this.tableName = tableName;
+		this.spec = spec;
+		this.label = `Create table ${tableName}`;
+		this.freeze();
+	}
+	toOp() {
+		return createTable(this.tableName, this.spec);
+	}
+	renderTypeScript() {
+		return `createTable(${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.spec)})`;
+	}
+};
+var DropTableCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "dropTable";
+	operationClass = "destructive";
+	tableName;
+	label;
+	constructor(tableName) {
+		super();
+		this.tableName = tableName;
+		this.label = `Drop table ${tableName}`;
+		this.freeze();
+	}
+	toOp() {
+		return dropTable(this.tableName);
+	}
+	renderTypeScript() {
+		return `dropTable(${jsonToTsSource(this.tableName)})`;
+	}
+};
+var RecreateTableCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "recreateTable";
+	operationClass;
+	tableName;
+	contractTable;
+	schemaColumnNames;
+	indexes;
+	summary;
+	postchecks;
+	label;
+	constructor(args) {
+		super();
+		this.tableName = args.tableName;
+		this.contractTable = args.contractTable;
+		this.schemaColumnNames = args.schemaColumnNames;
+		this.indexes = args.indexes;
+		this.summary = args.summary;
+		this.postchecks = args.postchecks;
+		this.operationClass = args.operationClass;
+		this.label = `Recreate table ${args.tableName}`;
+		this.freeze();
+	}
+	toOp() {
+		return recreateTable({
+			tableName: this.tableName,
+			contractTable: this.contractTable,
+			schemaColumnNames: this.schemaColumnNames,
+			indexes: this.indexes,
+			summary: this.summary,
+			postchecks: this.postchecks,
+			operationClass: this.operationClass
+		});
+	}
+	renderTypeScript() {
+		return `recreateTable(${jsonToTsSource({
+			tableName: this.tableName,
+			contractTable: this.contractTable,
+			schemaColumnNames: this.schemaColumnNames,
+			indexes: this.indexes,
+			summary: this.summary,
+			postchecks: this.postchecks,
+			operationClass: this.operationClass
+		})})`;
+	}
+};
+var AddColumnCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "addColumn";
+	operationClass = "additive";
+	tableName;
+	columnName;
+	column;
+	label;
+	constructor(tableName, column) {
+		super();
+		this.tableName = tableName;
+		this.columnName = column.name;
+		this.column = column;
+		this.label = `Add column ${column.name} on ${tableName}`;
+		this.freeze();
+	}
+	toOp() {
+		return addColumn(this.tableName, this.column);
+	}
+	renderTypeScript() {
+		return `addColumn(${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.column)})`;
+	}
+};
+var DropColumnCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "dropColumn";
+	operationClass = "destructive";
+	tableName;
+	columnName;
+	label;
+	constructor(tableName, columnName) {
+		super();
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.label = `Drop column ${columnName} on ${tableName}`;
+		this.freeze();
+	}
+	toOp() {
+		return dropColumn(this.tableName, this.columnName);
+	}
+	renderTypeScript() {
+		return `dropColumn(${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)})`;
+	}
+};
+var CreateIndexCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "createIndex";
+	operationClass = "additive";
+	tableName;
+	indexName;
+	columns;
+	label;
+	constructor(tableName, indexName, columns) {
+		super();
+		this.tableName = tableName;
+		this.indexName = indexName;
+		this.columns = columns;
+		this.label = `Create index ${indexName} on ${tableName}`;
+		this.freeze();
+	}
+	toOp() {
+		return createIndex(this.tableName, this.indexName, this.columns);
+	}
+	renderTypeScript() {
+		return `createIndex(${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.indexName)}, ${jsonToTsSource(this.columns)})`;
+	}
+};
+var DropIndexCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "dropIndex";
+	operationClass = "destructive";
+	tableName;
+	indexName;
+	label;
+	constructor(tableName, indexName) {
+		super();
+		this.tableName = tableName;
+		this.indexName = indexName;
+		this.label = `Drop index ${indexName} on ${tableName}`;
+		this.freeze();
+	}
+	toOp() {
+		return dropIndex(this.tableName, this.indexName);
+	}
+	renderTypeScript() {
+		return `dropIndex(${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.indexName)})`;
+	}
+};
+/**
+* A planner-generated data-transform stub. The current default strategy
+* (`nullabilityTighteningBackfillStrategy`) emits one of these with a
+* backfill-flavored `id`/`label` when the policy allows `'data'` and the
+* contract tightens a column's nullability, but the op itself is generic —
+* any future strategy that needs a placeholder data step can construct one
+* with its own id/label.
+*
+* `toOp()` always throws `PN-MIG-2001`: the planner cannot lower a stubbed
+* transform to a runtime op — the user must edit the rendered
+* `migration.ts` and re-emit.
+*/
+var DataTransformCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "dataTransform";
+	operationClass = "data";
+	id;
+	label;
+	tableName;
+	columnName;
+	constructor(id, label, tableName, columnName) {
+		super();
+		this.id = id;
+		this.label = label;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.freeze();
+	}
+	toOp() {
+		throw errorUnfilledPlaceholder(this.label);
+	}
+	renderTypeScript() {
+		const slot = `${this.tableName}-${this.columnName}-backfill-sql`;
+		return [
+			"dataTransform({",
+			`  id: ${jsonToTsSource(this.id)},`,
+			`  label: ${jsonToTsSource(this.label)},`,
+			`  table: ${jsonToTsSource(this.tableName)},`,
+			`  description: ${jsonToTsSource(`Backfill NULL ${this.columnName} values in ${this.tableName}`)},`,
+			`  run: () => placeholder(${jsonToTsSource(slot)}),`,
+			"})"
+		].join("\n");
+	}
+	importRequirements() {
+		return [{
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol: this.factoryName
+		}, {
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol: "placeholder"
+		}];
+	}
+};
+/**
+* Laundered pre-built operation. Mirrors Postgres's `RawSqlCall`: wraps an
+* already-materialized `SqlMigrationPlanOperation` (typically produced by a
+* SQL-family helper or a codec lifecycle hook) so the planner can carry it
+* alongside structured call IR. `toOp()` returns the stored op unchanged;
+* `renderTypeScript()` emits `rawSql({...})` with the op serialized as a
+* JSON literal — round-tripping requires every field on the op to be
+* JSON-serializable (no closures).
+*/
+var RawSqlCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "rawSql";
+	operationClass;
+	label;
+	op;
+	constructor(op) {
+		super();
+		this.op = op;
+		this.label = op.label;
+		this.operationClass = op.operationClass;
+		this.freeze();
+	}
+	toOp() {
+		return this.op;
+	}
+	renderTypeScript() {
+		return `rawSql(${jsonToTsSource(this.op)})`;
+	}
+};
+//#endregion
+export { DropColumnCall as a, RawSqlCall as c, DataTransformCall as i, RecreateTableCall as l, CreateIndexCall as n, DropIndexCall as o, CreateTableCall as r, DropTableCall as s, AddColumnCall as t };
+
+//# sourceMappingURL=op-factory-call-DRKKURAO.mjs.map

package/dist/op-factory-call-DRKKURAO.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"op-factory-call-DRKKURAO.mjs","names":[],"sources":["../src/core/migrations/op-factory-call.ts"],"sourcesContent":["/**\n * SQLite migration IR: one concrete `*Call` class per pure factory under\n * `operations/`, plus a shared `SqliteOpFactoryCallNode` abstract base.\n *\n * Each call class carries fully-resolved literal arguments (flat\n * `SqliteColumnSpec` / `SqliteTableSpec` etc.) — codec / `typeRef` / default\n * expansion happens upstream in the issue-planner / strategies, mirroring\n * the Postgres `ColumnSpec` pattern. As a result, `toOp()` and\n * `renderTypeScript()` both pass the same flat data through; the rendered\n * TypeScript scaffold is fully self-contained and does not need access to a\n * `storageTypes` map at runtime.\n */\n\nimport { errorUnfilledPlaceholder } from '@prisma-next/errors/migration';\nimport type {\n  MigrationOperationClass,\n  SqlMigrationPlanOperation,\n} from '@prisma-next/family-sql/control';\nimport type { OpFactoryCall as FrameworkOpFactoryCall } from '@prisma-next/framework-components/control';\nimport { type ImportRequirement, jsonToTsSource, TsExpression } from '@prisma-next/ts-render';\nimport { addColumn, dropColumn } from './operations/columns';\nimport { createIndex, dropIndex } from './operations/indexes';\nimport type { SqliteColumnSpec, SqliteIndexSpec, SqliteTableSpec } from './operations/shared';\nimport { createTable, dropTable, recreateTable } from './operations/tables';\nimport type { SqlitePlanTargetDetails } from './planner-target-details';\n\ntype Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;\n\nconst TARGET_MIGRATION_MODULE = '@prisma-next/target-sqlite/migration';\n\nabstract class SqliteOpFactoryCallNode extends TsExpression implements FrameworkOpFactoryCall {\n  abstract readonly factoryName: string;\n  abstract readonly operationClass: MigrationOperationClass;\n  abstract readonly label: string;\n  abstract toOp(): Op;\n\n  importRequirements(): readonly ImportRequirement[] {\n    return [{ moduleSpecifier: TARGET_MIGRATION_MODULE, symbol: this.factoryName }];\n  }\n\n  protected freeze(): void {\n    Object.freeze(this);\n  }\n}\n\n// ============================================================================\n// Table\n// ============================================================================\n\nexport class CreateTableCall extends SqliteOpFactoryCallNode {\n  readonly factoryName = 'createTable' as const;\n  readonly operationClass = 'additive' as const;\n  readonly tableName: string;\n  readonly spec: SqliteTableSpec;\n  readonly label: string;\n\n  constructor(tableName: string, spec: SqliteTableSpec) {\n    super();\n    this.tableName = tableName;\n    this.spec = spec;\n    this.label = `Create table ${tableName}`;\n    this.freeze();\n  }\n\n  toOp(): Op {\n    return createTable(this.tableName, this.spec);\n  }\n\n  renderTypeScript(): string {\n    return `createTable(${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.spec)})`;\n  }\n}\n\nexport class DropTableCall extends SqliteOpFactoryCallNode {\n  readonly factoryName = 'dropTable' as const;\n  readonly operationClass = 'destructive' as const;\n  readonly tableName: string;\n  readonly label: string;\n\n  constructor(tableName: string) {\n    super();\n    this.tableName = tableName;\n    this.label = `Drop table ${tableName}`;\n    this.freeze();\n  }\n\n  toOp(): Op {\n    return dropTable(this.tableName);\n  }\n\n  renderTypeScript(): string {\n    return `dropTable(${jsonToTsSource(this.tableName)})`;\n  }\n}\n\nexport class RecreateTableCall extends SqliteOpFactoryCallNode {\n  readonly factoryName = 'recreateTable' as const;\n  readonly operationClass: MigrationOperationClass;\n  readonly tableName: string;\n  readonly contractTable: SqliteTableSpec;\n  readonly schemaColumnNames: readonly string[];\n  readonly indexes: readonly SqliteIndexSpec[];\n  readonly summary: string;\n  readonly postchecks: readonly { readonly description: string; readonly sql: string }[];\n  readonly label: string;\n\n  constructor(args: {\n    tableName: string;\n    contractTable: SqliteTableSpec;\n    schemaColumnNames: readonly string[];\n    indexes: readonly SqliteIndexSpec[];\n    summary: string;\n    postchecks: readonly { readonly description: string; readonly sql: string }[];\n    operationClass: MigrationOperationClass;\n  }) {\n    super();\n    this.tableName = args.tableName;\n    this.contractTable = args.contractTable;\n    this.schemaColumnNames = args.schemaColumnNames;\n    this.indexes = args.indexes;\n    this.summary = args.summary;\n    this.postchecks = args.postchecks;\n    this.operationClass = args.operationClass;\n    this.label = `Recreate table ${args.tableName}`;\n    this.freeze();\n  }\n\n  toOp(): Op {\n    return recreateTable({\n      tableName: this.tableName,\n      contractTable: this.contractTable,\n      schemaColumnNames: this.schemaColumnNames,\n      indexes: this.indexes,\n      summary: this.summary,\n      postchecks: this.postchecks,\n      operationClass: this.operationClass,\n    });\n  }\n\n  renderTypeScript(): string {\n    const args = {\n      tableName: this.tableName,\n      contractTable: this.contractTable,\n      schemaColumnNames: this.schemaColumnNames,\n      indexes: this.indexes,\n      summary: this.summary,\n      postchecks: this.postchecks,\n      operationClass: this.operationClass,\n    };\n    return `recreateTable(${jsonToTsSource(args)})`;\n  }\n}\n\n// ============================================================================\n// Column\n// ============================================================================\n\nexport class AddColumnCall extends SqliteOpFactoryCallNode {\n  readonly factoryName = 'addColumn' as const;\n  readonly operationClass = 'additive' as const;\n  readonly tableName: string;\n  readonly columnName: string;\n  readonly column: SqliteColumnSpec;\n  readonly label: string;\n\n  constructor(tableName: string, column: SqliteColumnSpec) {\n    super();\n    this.tableName = tableName;\n    this.columnName = column.name;\n    this.column = column;\n    this.label = `Add column ${column.name} on ${tableName}`;\n    this.freeze();\n  }\n\n  toOp(): Op {\n    return addColumn(this.tableName, this.column);\n  }\n\n  renderTypeScript(): string {\n    return `addColumn(${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.column)})`;\n  }\n}\n\nexport class DropColumnCall extends SqliteOpFactoryCallNode {\n  readonly factoryName = 'dropColumn' as const;\n  readonly operationClass = 'destructive' as const;\n  readonly tableName: string;\n  readonly columnName: string;\n  readonly label: string;\n\n  constructor(tableName: string, columnName: string) {\n    super();\n    this.tableName = tableName;\n    this.columnName = columnName;\n    this.label = `Drop column ${columnName} on ${tableName}`;\n    this.freeze();\n  }\n\n  toOp(): Op {\n    return dropColumn(this.tableName, this.columnName);\n  }\n\n  renderTypeScript(): string {\n    return `dropColumn(${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)})`;\n  }\n}\n\n// ============================================================================\n// Index\n// ============================================================================\n\nexport class CreateIndexCall extends SqliteOpFactoryCallNode {\n  readonly factoryName = 'createIndex' as const;\n  readonly operationClass = 'additive' as const;\n  readonly tableName: string;\n  readonly indexName: string;\n  readonly columns: readonly string[];\n  readonly label: string;\n\n  constructor(tableName: string, indexName: string, columns: readonly string[]) {\n    super();\n    this.tableName = tableName;\n    this.indexName = indexName;\n    this.columns = columns;\n    this.label = `Create index ${indexName} on ${tableName}`;\n    this.freeze();\n  }\n\n  toOp(): Op {\n    return createIndex(this.tableName, this.indexName, this.columns);\n  }\n\n  renderTypeScript(): string {\n    return `createIndex(${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.indexName)}, ${jsonToTsSource(this.columns)})`;\n  }\n}\n\nexport class DropIndexCall extends SqliteOpFactoryCallNode {\n  readonly factoryName = 'dropIndex' as const;\n  readonly operationClass = 'destructive' as const;\n  readonly tableName: string;\n  readonly indexName: string;\n  readonly label: string;\n\n  constructor(tableName: string, indexName: string) {\n    super();\n    this.tableName = tableName;\n    this.indexName = indexName;\n    this.label = `Drop index ${indexName} on ${tableName}`;\n    this.freeze();\n  }\n\n  toOp(): Op {\n    return dropIndex(this.tableName, this.indexName);\n  }\n\n  renderTypeScript(): string {\n    return `dropIndex(${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.indexName)})`;\n  }\n}\n\n// ============================================================================\n// Data transform\n// ============================================================================\n\n/**\n * A planner-generated data-transform stub. The current default strategy\n * (`nullabilityTighteningBackfillStrategy`) emits one of these with a\n * backfill-flavored `id`/`label` when the policy allows `'data'` and the\n * contract tightens a column's nullability, but the op itself is generic —\n * any future strategy that needs a placeholder data step can construct one\n * with its own id/label.\n *\n * `toOp()` always throws `PN-MIG-2001`: the planner cannot lower a stubbed\n * transform to a runtime op — the user must edit the rendered\n * `migration.ts` and re-emit.\n */\nexport class DataTransformCall extends SqliteOpFactoryCallNode {\n  readonly factoryName = 'dataTransform' as const;\n  readonly operationClass = 'data' as const;\n  readonly id: string;\n  readonly label: string;\n  readonly tableName: string;\n  readonly columnName: string;\n\n  constructor(id: string, label: string, tableName: string, columnName: string) {\n    super();\n    this.id = id;\n    this.label = label;\n    this.tableName = tableName;\n    this.columnName = columnName;\n    this.freeze();\n  }\n\n  toOp(): Op {\n    throw errorUnfilledPlaceholder(this.label);\n  }\n\n  renderTypeScript(): string {\n    const slot = `${this.tableName}-${this.columnName}-backfill-sql`;\n    return [\n      'dataTransform({',\n      `  id: ${jsonToTsSource(this.id)},`,\n      `  label: ${jsonToTsSource(this.label)},`,\n      `  table: ${jsonToTsSource(this.tableName)},`,\n      `  description: ${jsonToTsSource(`Backfill NULL ${this.columnName} values in ${this.tableName}`)},`,\n      `  run: () => placeholder(${jsonToTsSource(slot)}),`,\n      '})',\n    ].join('\\n');\n  }\n\n  override importRequirements(): readonly ImportRequirement[] {\n    return [\n      { moduleSpecifier: TARGET_MIGRATION_MODULE, symbol: this.factoryName },\n      { moduleSpecifier: TARGET_MIGRATION_MODULE, symbol: 'placeholder' },\n    ];\n  }\n}\n\n// ============================================================================\n// Raw SQL\n// ============================================================================\n\n/**\n * Laundered pre-built operation. Mirrors Postgres's `RawSqlCall`: wraps an\n * already-materialized `SqlMigrationPlanOperation` (typically produced by a\n * SQL-family helper or a codec lifecycle hook) so the planner can carry it\n * alongside structured call IR. `toOp()` returns the stored op unchanged;\n * `renderTypeScript()` emits `rawSql({...})` with the op serialized as a\n * JSON literal — round-tripping requires every field on the op to be\n * JSON-serializable (no closures).\n */\nexport class RawSqlCall extends SqliteOpFactoryCallNode {\n  readonly factoryName = 'rawSql' as const;\n  readonly operationClass: MigrationOperationClass;\n  readonly label: string;\n  readonly op: Op;\n\n  constructor(op: Op) {\n    super();\n    this.op = op;\n    this.label = op.label;\n    this.operationClass = op.operationClass;\n    this.freeze();\n  }\n\n  toOp(): Op {\n    return this.op;\n  }\n\n  renderTypeScript(): string {\n    return `rawSql(${jsonToTsSource(this.op)})`;\n  }\n}\n\n// ============================================================================\n// Union\n// ============================================================================\n\nexport type SqliteOpFactoryCall =\n  | CreateTableCall\n  | DropTableCall\n  | RecreateTableCall\n  | AddColumnCall\n  | DropColumnCall\n  | CreateIndexCall\n  | DropIndexCall\n  | DataTransformCall\n  | RawSqlCall;\n"],"mappings":"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"}

package/dist/op-factory-call.d.mts

@@ -0,0 +1,151 @@
+import { t as SqlitePlanTargetDetails } from "./planner-target-details-vhvZDWK1.mjs";
+import { i as SqliteTableSpec, n as SqliteColumnSpec, r as SqliteIndexSpec } from "./shared-qLsgTOZs.mjs";
+import { MigrationOperationClass, SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
+import { ImportRequirement, TsExpression } from "@prisma-next/ts-render";
+import { OpFactoryCall } from "@prisma-next/framework-components/control";
+
+//#region src/core/migrations/op-factory-call.d.ts
+type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
+declare abstract class SqliteOpFactoryCallNode extends TsExpression implements OpFactoryCall {
+  abstract readonly factoryName: string;
+  abstract readonly operationClass: MigrationOperationClass;
+  abstract readonly label: string;
+  abstract toOp(): Op;
+  importRequirements(): readonly ImportRequirement[];
+  protected freeze(): void;
+}
+declare class CreateTableCall extends SqliteOpFactoryCallNode {
+  readonly factoryName: "createTable";
+  readonly operationClass: "additive";
+  readonly tableName: string;
+  readonly spec: SqliteTableSpec;
+  readonly label: string;
+  constructor(tableName: string, spec: SqliteTableSpec);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class DropTableCall extends SqliteOpFactoryCallNode {
+  readonly factoryName: "dropTable";
+  readonly operationClass: "destructive";
+  readonly tableName: string;
+  readonly label: string;
+  constructor(tableName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class RecreateTableCall extends SqliteOpFactoryCallNode {
+  readonly factoryName: "recreateTable";
+  readonly operationClass: MigrationOperationClass;
+  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 label: string;
+  constructor(args: {
+    tableName: string;
+    contractTable: SqliteTableSpec;
+    schemaColumnNames: readonly string[];
+    indexes: readonly SqliteIndexSpec[];
+    summary: string;
+    postchecks: readonly {
+      readonly description: string;
+      readonly sql: string;
+    }[];
+    operationClass: MigrationOperationClass;
+  });
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class AddColumnCall extends SqliteOpFactoryCallNode {
+  readonly factoryName: "addColumn";
+  readonly operationClass: "additive";
+  readonly tableName: string;
+  readonly columnName: string;
+  readonly column: SqliteColumnSpec;
+  readonly label: string;
+  constructor(tableName: string, column: SqliteColumnSpec);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class DropColumnCall extends SqliteOpFactoryCallNode {
+  readonly factoryName: "dropColumn";
+  readonly operationClass: "destructive";
+  readonly tableName: string;
+  readonly columnName: string;
+  readonly label: string;
+  constructor(tableName: string, columnName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class CreateIndexCall extends SqliteOpFactoryCallNode {
+  readonly factoryName: "createIndex";
+  readonly operationClass: "additive";
+  readonly tableName: string;
+  readonly indexName: string;
+  readonly columns: readonly string[];
+  readonly label: string;
+  constructor(tableName: string, indexName: string, columns: readonly string[]);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class DropIndexCall extends SqliteOpFactoryCallNode {
+  readonly factoryName: "dropIndex";
+  readonly operationClass: "destructive";
+  readonly tableName: string;
+  readonly indexName: string;
+  readonly label: string;
+  constructor(tableName: string, indexName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+/**
+ * A planner-generated data-transform stub. The current default strategy
+ * (`nullabilityTighteningBackfillStrategy`) emits one of these with a
+ * backfill-flavored `id`/`label` when the policy allows `'data'` and the
+ * contract tightens a column's nullability, but the op itself is generic —
+ * any future strategy that needs a placeholder data step can construct one
+ * with its own id/label.
+ *
+ * `toOp()` always throws `PN-MIG-2001`: the planner cannot lower a stubbed
+ * transform to a runtime op — the user must edit the rendered
+ * `migration.ts` and re-emit.
+ */
+declare class DataTransformCall extends SqliteOpFactoryCallNode {
+  readonly factoryName: "dataTransform";
+  readonly operationClass: "data";
+  readonly id: string;
+  readonly label: string;
+  readonly tableName: string;
+  readonly columnName: string;
+  constructor(id: string, label: string, tableName: string, columnName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+  importRequirements(): readonly ImportRequirement[];
+}
+/**
+ * Laundered pre-built operation. Mirrors Postgres's `RawSqlCall`: wraps an
+ * already-materialized `SqlMigrationPlanOperation` (typically produced by a
+ * SQL-family helper or a codec lifecycle hook) so the planner can carry it
+ * alongside structured call IR. `toOp()` returns the stored op unchanged;
+ * `renderTypeScript()` emits `rawSql({...})` with the op serialized as a
+ * JSON literal — round-tripping requires every field on the op to be
+ * JSON-serializable (no closures).
+ */
+declare class RawSqlCall extends SqliteOpFactoryCallNode {
+  readonly factoryName: "rawSql";
+  readonly operationClass: MigrationOperationClass;
+  readonly label: string;
+  readonly op: Op;
+  constructor(op: Op);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+type SqliteOpFactoryCall = CreateTableCall | DropTableCall | RecreateTableCall | AddColumnCall | DropColumnCall | CreateIndexCall | DropIndexCall | DataTransformCall | RawSqlCall;
+//#endregion
+export { AddColumnCall, CreateIndexCall, CreateTableCall, DataTransformCall, DropColumnCall, DropIndexCall, DropTableCall, RawSqlCall, RecreateTableCall, type SqliteOpFactoryCall };
+//# sourceMappingURL=op-factory-call.d.mts.map

package/dist/op-factory-call.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"op-factory-call.d.mts","names":[],"sources":["../src/core/migrations/op-factory-call.ts"],"mappings":"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"}