@prisma/orm-target-sqlite 0.16.0-dev.36

package/dist/op-factory-call-C_or6163-B_LDzC37.mjs

@@ -0,0 +1,829 @@
+import { n as sqliteError } from "./errors-CKsaaSnD-BeB4JS8h.mjs";
+import { i as tableExistsAst, n as createTable, r as indexExistsAst, t as columnExistsAst } from "./ddl-CW34JvfE-rd1ZIxOn.mjs";
+import { n as quoteIdentifier, t as escapeLiteral } from "./sql-utils-DqPXZBMA-Mm27NNjs.mjs";
+import { t as buildTargetDetails } from "./planner-target-details-CIQ789Gc-C5U4yVY9.mjs";
+import { n as stripOuterParens } from "./default-normalizer-DuoHj9-O-DsK7lJZn.mjs";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { issueOutcome } from "@prisma/orm-framework/components/control";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { RelationalSchemaNodeKind } from "@prisma/orm-family-sql/schema-ir/types";
+import { errorUnfilledPlaceholder } from "@prisma/orm-framework/errors/migration";
+import { TsExpression, jsonToTsSource } from "@prisma/orm-framework/ts-render";
+import { REFERENTIAL_ACTION_SQL } from "@prisma/orm-family-sql/contract/referential-action-sql";
+//#region ../../../3-targets/3-targets/sqlite/dist/op-factory-call-C_or6163.mjs
+const SAFE_NATIVE_TYPE_PATTERN = /^[a-zA-Z][a-zA-Z0-9_ ]*$/;
+function assertSafeNativeType(nativeType) {
+	if (!SAFE_NATIVE_TYPE_PATTERN.test(nativeType)) throw sqliteError("CONTRACT.NATIVE_TYPE_INVALID", `Unsafe native type name in contract: "${nativeType}". Native type names must match /^[a-zA-Z][a-zA-Z0-9_ ]*\$/`, { meta: { nativeType } });
+}
+function assertSafeDefaultExpression(expression) {
+	if (expression.includes(";") || /--|\/\*|\bSELECT\b/i.test(expression)) throw sqliteError("CONTRACT.DEFAULT_INVALID", `Unsafe default expression in contract: "${expression}". Default expressions must not contain semicolons, SQL comment tokens, or subqueries.`, { meta: { expression } });
+}
+/**
+* Renders the column's DDL type token (e.g. `"INTEGER"`, `"TEXT"`).
+* Resolves `typeRef` against `storageTypes` and validates the resulting
+* native type against a safe-identifier pattern.
+*/
+function buildColumnTypeSql(column, storageTypes = {}) {
+	const resolved = resolveColumnTypeMetadata(column, storageTypes);
+	assertSafeNativeType(resolved.nativeType);
+	return resolved.nativeType.toUpperCase();
+}
+/**
+* Renders the column's `DEFAULT …` clause. Returns the empty string when
+* there is no default, and also when the default is `autoincrement()` —
+* SQLite encodes that as `INTEGER PRIMARY KEY AUTOINCREMENT` inline on the
+* column definition, not as a separate DEFAULT.
+*/
+function buildColumnDefaultSql(columnDefault) {
+	if (!columnDefault) return "";
+	switch (columnDefault.kind) {
+		case "literal": return `DEFAULT ${renderDefaultLiteral(columnDefault.value)}`;
+		case "function":
+			if (columnDefault.expression === "autoincrement()") return "";
+			if (columnDefault.expression === "now()") return "DEFAULT (datetime('now'))";
+			assertSafeDefaultExpression(columnDefault.expression);
+			return `DEFAULT (${columnDefault.expression})`;
+	}
+}
+function renderDefaultLiteral(value) {
+	if (value instanceof Date) return `'${escapeLiteral(value.toISOString())}'`;
+	if (typeof value === "string") return `'${escapeLiteral(value)}'`;
+	if (typeof value === "number" || typeof value === "bigint") return String(value);
+	if (typeof value === "boolean") return value ? "1" : "0";
+	if (value === null) return "NULL";
+	return `'${escapeLiteral(JSON.stringify(value))}'`;
+}
+function buildCreateIndexSql(tableName, indexName, columns, unique = false) {
+	return `CREATE ${unique ? "UNIQUE " : ""}INDEX ${quoteIdentifier(indexName)} ON ${quoteIdentifier(tableName)} (${columns.map(quoteIdentifier).join(", ")})`;
+}
+function buildDropIndexSql(indexName) {
+	return `DROP INDEX IF EXISTS ${quoteIdentifier(indexName)}`;
+}
+function resolveColumnTypeMetadata(column, storageTypes) {
+	if (!column.typeRef) return column;
+	const referencedType = storageTypes[column.typeRef];
+	if (!referencedType) throw sqliteError("CONTRACT.TYPE_UNKNOWN", `Storage type "${column.typeRef}" referenced by column is not defined in storage.types.`, { meta: { typeRef: column.typeRef } });
+	return {
+		codecId: referencedType.codecId,
+		nativeType: referencedType.nativeType,
+		typeParams: referencedType.typeParams
+	};
+}
+function step(description, sql, params) {
+	return {
+		description,
+		sql,
+		...ifDefined("params", params)
+	};
+}
+/**
+* Renders a single column's inline DDL fragment within a `CREATE TABLE`
+* statement. Honours the `inlineAutoincrementPrimaryKey` flag — SQLite
+* treats `INTEGER PRIMARY KEY AUTOINCREMENT` as a special form that aliases
+* `rowid`, and the column must not carry a `DEFAULT` or repeat `NOT NULL`.
+*/
+function renderColumnDefinition(column) {
+	const parts = [quoteIdentifier(column.name), column.typeSql];
+	if (column.inlineAutoincrementPrimaryKey) parts.push("PRIMARY KEY AUTOINCREMENT");
+	else {
+		if (column.defaultSql) parts.push(column.defaultSql);
+		if (!column.nullable) parts.push("NOT NULL");
+	}
+	return parts.join(" ");
+}
+/**
+* Renders an inline FOREIGN KEY constraint clause for a `CREATE TABLE`
+* body. Every `SqliteForeignKeySpec` is constraint-bearing by construction
+* (`tableSpecFromNode` only ever builds specs from schema-IR FK nodes, which
+* are themselves constraint-only — a non-constraint FK contributes no node).
+*/
+function renderForeignKeyClause(fk) {
+	let sql = `${fk.name ? `CONSTRAINT ${quoteIdentifier(fk.name)} ` : ""}FOREIGN KEY (${fk.columns.map(quoteIdentifier).join(", ")}) REFERENCES ${quoteIdentifier(fk.references.table)} (${fk.references.columns.map(quoteIdentifier).join(", ")})`;
+	if (fk.onDelete !== void 0) sql += ` ON DELETE ${REFERENTIAL_ACTION_SQL[fk.onDelete]}`;
+	if (fk.onUpdate !== void 0) sql += ` ON UPDATE ${REFERENTIAL_ACTION_SQL[fk.onUpdate]}`;
+	return sql;
+}
+function addColumnExecuteSql(tableName, column) {
+	return [
+		`ALTER TABLE ${quoteIdentifier(tableName)}`,
+		`ADD COLUMN ${quoteIdentifier(column.name)} ${column.typeSql}`,
+		column.defaultSql,
+		column.nullable ? "" : "NOT NULL"
+	].filter(Boolean).join(" ");
+}
+function dropColumnExecuteSql(tableName, columnName) {
+	return `ALTER TABLE ${quoteIdentifier(tableName)} DROP COLUMN ${quoteIdentifier(columnName)}`;
+}
+async function tableExistsSteps(lowerer, tableName) {
+	const checks = tableExistsAst(tableName);
+	return {
+		present: await lowerer.lowerToExecuteRequest(checks.tablePresent()),
+		absent: await lowerer.lowerToExecuteRequest(checks.tableAbsent())
+	};
+}
+/**
+* Renders the body of a `CREATE TABLE <name> ( … )` statement from a flat
+* `SqliteTableSpec`. SQLite's `INTEGER PRIMARY KEY AUTOINCREMENT` form is
+* inline on the column; the table-level PRIMARY KEY clause is emitted only
+* when no column carries `inlineAutoincrementPrimaryKey`.
+*/
+function renderCreateTableSql(tableName, spec) {
+	const columnDefs = spec.columns.map(renderColumnDefinition);
+	const constraintDefs = [];
+	const hasInlinePk = spec.columns.some((c) => c.inlineAutoincrementPrimaryKey);
+	if (spec.primaryKey && !hasInlinePk) constraintDefs.push(`PRIMARY KEY (${spec.primaryKey.columns.map(quoteIdentifier).join(", ")})`);
+	for (const u of spec.uniques ?? []) {
+		const name = u.name ? `CONSTRAINT ${quoteIdentifier(u.name)} ` : "";
+		constraintDefs.push(`${name}UNIQUE (${u.columns.map(quoteIdentifier).join(", ")})`);
+	}
+	for (const fk of spec.foreignKeys ?? []) {
+		const clause = renderForeignKeyClause(fk);
+		if (clause) constraintDefs.push(clause);
+	}
+	const allDefs = [...columnDefs, ...constraintDefs];
+	return `CREATE TABLE ${quoteIdentifier(tableName)} (\n  ${allDefs.join(",\n  ")}\n)`;
+}
+async function recreateTable(args, lowerer) {
+	const { tableName, contractTable, schemaColumnNames, indexes, summary, postchecks, operationClass } = args;
+	const tempName = `_prisma_new_${tableName}`;
+	const liveSet = new Set(schemaColumnNames);
+	const sharedColumns = contractTable.columns.filter((c) => liveSet.has(c.name)).map((c) => c.name);
+	const columnList = sharedColumns.map(quoteIdentifier).join(", ");
+	const indexStatements = indexes.map((idx) => ({
+		description: `recreate index "${idx.name}" on "${tableName}"`,
+		sql: buildCreateIndexSql(tableName, idx.name, idx.columns)
+	}));
+	const copyStep = sharedColumns.length > 0 ? [step(`copy data from "${tableName}" to "${tempName}"`, `INSERT INTO ${quoteIdentifier(tempName)} (${columnList}) SELECT ${columnList} FROM ${quoteIdentifier(tableName)}`)] : [];
+	const tableSteps = await tableExistsSteps(lowerer, tableName);
+	const tempSteps = await tableExistsSteps(lowerer, tempName);
+	return {
+		id: `recreateTable.${tableName}`,
+		label: `Recreate table ${tableName}`,
+		summary,
+		operationClass,
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("table", tableName)
+		},
+		precheck: [step(`ensure table "${tableName}" exists`, tableSteps.present.sql, tableSteps.present.params), step(`ensure temp table "${tempName}" does not exist`, tempSteps.absent.sql, tempSteps.absent.params)],
+		execute: [
+			step(`create new table "${tempName}" with desired schema`, renderCreateTableSql(tempName, contractTable)),
+			...copyStep,
+			step(`drop old table "${tableName}"`, `DROP TABLE ${quoteIdentifier(tableName)}`),
+			step(`rename "${tempName}" to "${tableName}"`, `ALTER TABLE ${quoteIdentifier(tempName)} RENAME TO ${quoteIdentifier(tableName)}`),
+			...indexStatements
+		],
+		postcheck: [
+			step(`verify table "${tableName}" exists`, tableSteps.present.sql, tableSteps.present.params),
+			step(`verify temp table "${tempName}" is gone`, tempSteps.absent.sql, tempSteps.absent.params),
+			...postchecks
+		]
+	};
+}
+/**
+* Build a one-line summary of a recreate-table operation from the schema-diff
+* issues that triggered it. Lives next to `recreateTable` so the planner
+* (which has the issues) can produce the same description the factory
+* used to build inline. Keeping the formatting target-side keeps
+* `RecreateTableCall` issue-free at the IR layer. `SchemaDiffIssue` carries
+* no rendered message, so this renders one from each issue's path.
+*/
+function buildRecreateSummary(tableName, issues) {
+	return `Recreates table ${tableName} to apply schema changes: ${issues.map((i) => i.path.join("/")).join("; ")}`;
+}
+function nodeKindOf(issue) {
+	const node = issue.expected ?? issue.actual;
+	if (node === void 0) return void 0;
+	return blindCast(node).nodeKind;
+}
+/** Mirrors `SqlColumnIR.isEqualTo`'s type comparison, isolated so a `not-equal` column issue's postcheck can target type drift and nullability drift independently. */
+function columnTypeChanged(expected, actual) {
+	if (expected.resolvedNativeType !== void 0 && actual.resolvedNativeType !== void 0) return expected.resolvedNativeType !== actual.resolvedNativeType;
+	return expected.nativeType !== actual.nativeType || Boolean(expected.many) !== Boolean(actual.many);
+}
+/**
+* Returns the columns the contract expects as the table's primary key. Picks
+* up SQLite's inline `INTEGER PRIMARY KEY AUTOINCREMENT` form when no
+* explicit `primaryKey` clause is set on the spec.
+*/
+function expectedPrimaryKeyColumns(spec) {
+	if (spec.primaryKey) return spec.primaryKey.columns;
+	const inlinePk = spec.columns.find((c) => c.inlineAutoincrementPrimaryKey);
+	return inlinePk ? [inlinePk.name] : [];
+}
+function quoteSqlList(values) {
+	return values.map((v) => `'${escapeLiteral(v)}'`).join(", ");
+}
+function columnNameFromNode(issue) {
+	const node = issue.expected ?? issue.actual;
+	if (node === void 0) return void 0;
+	return blindCast(node).name;
+}
+/**
+* A column-default issue's own node has no back-reference to its owning
+* column — it's a transient child built by `SqlColumnIR.children()`. The
+* column's id (`column:<name>`) is always the diff path's second-to-last
+* segment for a default issue (`[..., tableId, columnId, 'default']`), so
+* the name is recovered from the path rather than the node.
+*/
+function columnNameFromDefaultIssuePath(issue) {
+	const columnId = issue.path[issue.path.length - 2];
+	if (columnId === void 0) return void 0;
+	return columnId.startsWith("column:") ? columnId.slice(7) : columnId;
+}
+/**
+* Per-issue postchecks verifying the recreated table's shape against the
+* expected spec. Column-level issues (`sql-column` `not-equal`,
+* `sql-column-default` any reason) emit one targeted check each;
+* constraint-level issues (`sql-primary-key`, `sql-unique`, `sql-foreign-key`,
+* any reason) emit one `pragma_*`-driven check per declared constraint in the
+* expected spec, so a recreated table with the right columns but the wrong
+* PK / unique / FK shape fails the postcheck instead of passing silently.
+* Exported so the planner can pre-build the list at construction time and
+* `RecreateTableCall` doesn't have to carry `SchemaDiffIssue` objects through
+* to render time.
+*/
+function buildRecreatePostchecks(tableName, issues, spec) {
+	const checks = [];
+	const t = escapeLiteral(tableName);
+	const byName = new Map(spec.columns.map((c) => [c.name, c]));
+	let hasPkIssue = false;
+	let hasUniqueIssue = false;
+	let hasFkIssue = false;
+	for (const issue of issues) {
+		const nodeKind = nodeKindOf(issue);
+		if (nodeKind === RelationalSchemaNodeKind.column && issueOutcome(issue) === "not-equal") {
+			const columnName = columnNameFromNode(issue);
+			if (columnName === void 0) continue;
+			const c = escapeLiteral(columnName);
+			const expected = blindCast(issue.expected);
+			const actual = blindCast(issue.actual);
+			if (expected.nullable !== actual.nullable) checks.push({
+				description: `verify "${columnName}" nullability on "${tableName}"`,
+				sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND "notnull" = ${expected.nullable ? 0 : 1}`
+			});
+			if (columnTypeChanged(expected, actual)) {
+				const colSpec = byName.get(columnName);
+				if (colSpec) checks.push({
+					description: `verify "${columnName}" type on "${tableName}"`,
+					sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND LOWER(type) = '${escapeLiteral(colSpec.typeSql.toLowerCase())}'`
+				});
+			}
+			continue;
+		}
+		if (nodeKind === RelationalSchemaNodeKind.columnDefault) {
+			const columnName = columnNameFromDefaultIssuePath(issue);
+			if (columnName === void 0) continue;
+			const c = escapeLiteral(columnName);
+			if (issueOutcome(issue) === "not-expected") {
+				checks.push({
+					description: `verify "${columnName}" has no default on "${tableName}"`,
+					sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND dflt_value IS NULL`
+				});
+				continue;
+			}
+			const colSpec = byName.get(columnName);
+			const expectedRaw = colSpec?.defaultSql.startsWith("DEFAULT ") ? stripOuterParens(colSpec.defaultSql.slice(8)) : null;
+			if (expectedRaw) checks.push({
+				description: `verify "${columnName}" default on "${tableName}"`,
+				sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND dflt_value = '${escapeLiteral(expectedRaw)}'`
+			});
+			continue;
+		}
+		if (nodeKind === RelationalSchemaNodeKind.primaryKey) hasPkIssue = true;
+		if (nodeKind === RelationalSchemaNodeKind.unique) hasUniqueIssue = true;
+		if (nodeKind === RelationalSchemaNodeKind.foreignKey) hasFkIssue = true;
+	}
+	if (hasPkIssue) {
+		const pkColumns = expectedPrimaryKeyColumns(spec);
+		const colCount = pkColumns.length;
+		if (colCount === 0) checks.push({
+			description: `verify "${tableName}" has no primary key`,
+			sql: `SELECT (SELECT COUNT(*) FROM pragma_table_info('${t}') WHERE pk > 0) = 0`
+		});
+		else checks.push({
+			description: `verify primary key on "${tableName}"`,
+			sql: `SELECT (SELECT COUNT(*) FROM pragma_table_info('${t}') WHERE pk > 0) = ${colCount} AND (SELECT COUNT(*) FROM pragma_table_info('${t}') WHERE pk > 0 AND name IN (${quoteSqlList(pkColumns)})) = ${colCount}`
+		});
+	}
+	if (hasUniqueIssue) for (const u of spec.uniques ?? []) {
+		const colCount = u.columns.length;
+		const description = u.name ? `verify unique constraint "${u.name}" on "${tableName}"` : `verify unique constraint (${u.columns.join(", ")}) on "${tableName}"`;
+		checks.push({
+			description,
+			sql: `SELECT EXISTS (SELECT 1 FROM pragma_index_list('${t}') l WHERE l."unique" = 1 AND (SELECT COUNT(*) FROM pragma_index_info(l.name)) = ${colCount} AND (SELECT COUNT(*) FROM pragma_index_info(l.name) WHERE name IN (${quoteSqlList(u.columns)})) = ${colCount})`
+		});
+	}
+	if (hasFkIssue) for (const fk of spec.foreignKeys ?? []) {
+		const refTable = escapeLiteral(fk.references.table);
+		const colCount = fk.columns.length;
+		const tuples = fk.columns.map((from, i) => {
+			const to = fk.references.columns[i] ?? from;
+			return `('${escapeLiteral(from)}', '${escapeLiteral(to)}')`;
+		}).join(", ");
+		const description = `verify foreign key (${fk.columns.join(", ")}) → ${fk.references.table}(${fk.references.columns.join(", ")}) on "${tableName}"`;
+		checks.push({
+			description,
+			sql: `SELECT EXISTS (SELECT 1 FROM pragma_foreign_key_list('${t}') f WHERE f."table" = '${refTable}' GROUP BY f.id HAVING COUNT(*) = ${colCount} AND SUM(CASE WHEN (f."from", f."to") IN (${tuples}) THEN 1 ELSE 0 END) = ${colCount})`
+		});
+	}
+	return checks;
+}
+/**
+* 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. `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.
+*/
+const TARGET_MIGRATION_MODULE = "@internal/sqlite/migration";
+var SqliteOpFactoryCallNode = class extends TsExpression {
+	importRequirements() {
+		return [{
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol: this.factoryName
+		}];
+	}
+	freeze() {
+		Object.freeze(this);
+	}
+};
+function renderDdlColumnDefault(def) {
+	if (!def) return "";
+	if (def.kind === "literal") return `lit(${jsonToTsSource(def.value)})`;
+	return `fn(${jsonToTsSource(def.expression)})`;
+}
+function renderDdlColumnAsTsCall(column) {
+	const opts = [];
+	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) {
+	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 = [];
+			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})`;
+		}
+		case "check-expression": throw sqliteError("CONTRACT.CONSTRAINT_INVALID", `SQLite does not support expression CHECK constraints (constraint "${constraint.name}"). Scalar-array columns and their element-non-null checks are Postgres-only.`, { meta: { constraintName: constraint.name } });
+	}
+}
+function constraintImportSymbols(constraints) {
+	if (!constraints || constraints.length === 0) return [];
+	const symbols = /* @__PURE__ */ new Set();
+	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) {
+	const symbols = /* @__PURE__ */ new Set();
+	for (const col of columns) if (col.default?.kind === "literal") symbols.add("lit");
+	else if (col.default?.kind === "function") symbols.add("fn");
+	return [...symbols];
+}
+var CreateTableCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "createTable";
+	operationClass = "additive";
+	tableName;
+	columns;
+	constraints;
+	label;
+	constructor(tableName, columns, constraints) {
+		super();
+		this.tableName = tableName;
+		this.columns = Object.freeze([...columns]);
+		this.constraints = constraints ? Object.freeze([...constraints]) : void 0;
+		this.label = `Create table ${tableName}`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw sqliteError("MIGRATION.SQLITE_CONTROL_STACK_MISSING", `CreateTableCall.toOp: a DDL lowerer is required on the SQLite planner path (table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`, { meta: {
+			factory: this.factoryName,
+			tableName: this.tableName
+		} });
+		const ddlNode = createTable({
+			table: this.tableName,
+			columns: this.columns,
+			...ifDefined("constraints", this.constraints)
+		});
+		const statement = await lowerer.lowerToExecuteRequest(ddlNode);
+		const tableName = this.tableName;
+		const tableChecks = tableExistsAst(tableName);
+		const absent = await lowerer.lowerToExecuteRequest(tableChecks.tableAbsent());
+		const present = await lowerer.lowerToExecuteRequest(tableChecks.tablePresent());
+		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`, absent.sql, absent.params)],
+			execute: [{
+				description: `create table "${tableName}"`,
+				sql: statement.sql,
+				params: statement.params ?? []
+			}],
+			postcheck: [step(`verify table "${tableName}" exists`, present.sql, present.params)]
+		};
+	}
+	renderTypeScript() {
+		const columnsList = this.columns.map(renderDdlColumnAsTsCall).join(", ");
+		const constraintsList = this.constraints ? this.constraints.map(renderDdlConstraintAsTsCall).join(", ") : void 0;
+		const opts = [];
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		opts.push(`columns: [${columnsList}]`);
+		if (constraintsList) opts.push(`constraints: [${constraintsList}]`);
+		return `this.createTable({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		const req = [];
+		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;
+	}
+};
+var DropTableCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "dropTable";
+	operationClass = "destructive";
+	tableName;
+	label;
+	constructor(tableName) {
+		super();
+		this.tableName = tableName;
+		this.label = `Drop table ${tableName}`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw sqliteError("MIGRATION.SQLITE_CONTROL_STACK_MISSING", `DropTableCall.toOp: a lowerer is required on the SQLite planner path (table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`, { meta: {
+			factory: this.factoryName,
+			tableName: this.tableName
+		} });
+		const checks = tableExistsAst(this.tableName);
+		const present = await lowerer.lowerToExecuteRequest(checks.tablePresent());
+		const absent = await lowerer.lowerToExecuteRequest(checks.tableAbsent());
+		return {
+			id: `dropTable.${this.tableName}`,
+			label: `Drop table ${this.tableName}`,
+			summary: `Drops table ${this.tableName} which is not in the contract`,
+			operationClass: "destructive",
+			target: {
+				id: "sqlite",
+				details: buildTargetDetails("table", this.tableName)
+			},
+			precheck: [step(`ensure table "${this.tableName}" exists`, present.sql, present.params)],
+			execute: [step(`drop table "${this.tableName}"`, `DROP TABLE ${quoteIdentifier(this.tableName)}`)],
+			postcheck: [step(`verify table "${this.tableName}" is gone`, absent.sql, absent.params)]
+		};
+	}
+	renderTypeScript() {
+		return `this.dropTable({ table: ${jsonToTsSource(this.tableName)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+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();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw sqliteError("MIGRATION.SQLITE_CONTROL_STACK_MISSING", `RecreateTableCall.toOp: a lowerer is required on the SQLite planner path (table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`, { meta: {
+			factory: this.factoryName,
+			tableName: this.tableName
+		} });
+		return recreateTable({
+			tableName: this.tableName,
+			contractTable: this.contractTable,
+			schemaColumnNames: this.schemaColumnNames,
+			indexes: this.indexes,
+			summary: this.summary,
+			postchecks: this.postchecks,
+			operationClass: this.operationClass
+		}, lowerer);
+	}
+	renderTypeScript() {
+		return `this.recreateTable(${jsonToTsSource({
+			tableName: this.tableName,
+			contractTable: this.contractTable,
+			schemaColumnNames: this.schemaColumnNames,
+			indexes: this.indexes,
+			summary: this.summary,
+			postchecks: this.postchecks,
+			operationClass: this.operationClass
+		})})`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+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();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw sqliteError("MIGRATION.SQLITE_CONTROL_STACK_MISSING", `AddColumnCall.toOp: a lowerer is required on the SQLite planner path (column "${this.column.name}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`, { meta: {
+			factory: this.factoryName,
+			tableName: this.tableName,
+			columnName: this.column.name
+		} });
+		const checks = columnExistsAst(this.tableName, this.column.name);
+		const absent = await lowerer.lowerToExecuteRequest(checks.columnAbsent());
+		const present = await lowerer.lowerToExecuteRequest(checks.columnPresent());
+		return {
+			id: `column.${this.tableName}.${this.column.name}`,
+			label: `Add column ${this.column.name} on ${this.tableName}`,
+			summary: `Adds column ${this.column.name} on ${this.tableName}`,
+			operationClass: "additive",
+			target: {
+				id: "sqlite",
+				details: buildTargetDetails("column", this.column.name, this.tableName)
+			},
+			precheck: [step(`ensure column "${this.column.name}" is missing`, absent.sql, absent.params)],
+			execute: [step(`add column "${this.column.name}"`, addColumnExecuteSql(this.tableName, this.column))],
+			postcheck: [step(`verify column "${this.column.name}" exists`, present.sql, present.params)]
+		};
+	}
+	renderTypeScript() {
+		return `this.addColumn({ table: ${jsonToTsSource(this.tableName)}, column: ${jsonToTsSource(this.column)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+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();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw sqliteError("MIGRATION.SQLITE_CONTROL_STACK_MISSING", `DropColumnCall.toOp: a lowerer is required on the SQLite planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`, { meta: {
+			factory: this.factoryName,
+			tableName: this.tableName,
+			columnName: this.columnName
+		} });
+		const checks = columnExistsAst(this.tableName, this.columnName);
+		const present = await lowerer.lowerToExecuteRequest(checks.columnPresent());
+		const absent = await lowerer.lowerToExecuteRequest(checks.columnAbsent());
+		return {
+			id: `dropColumn.${this.tableName}.${this.columnName}`,
+			label: `Drop column ${this.columnName} on ${this.tableName}`,
+			summary: `Drops column ${this.columnName} on ${this.tableName} which is not in the contract`,
+			operationClass: "destructive",
+			target: {
+				id: "sqlite",
+				details: buildTargetDetails("column", this.columnName, this.tableName)
+			},
+			precheck: [step(`ensure column "${this.columnName}" exists on "${this.tableName}"`, present.sql, present.params)],
+			execute: [step(`drop column "${this.columnName}" from "${this.tableName}"`, dropColumnExecuteSql(this.tableName, this.columnName))],
+			postcheck: [step(`verify column "${this.columnName}" is gone from "${this.tableName}"`, absent.sql, absent.params)]
+		};
+	}
+	renderTypeScript() {
+		return `this.dropColumn({ table: ${jsonToTsSource(this.tableName)}, column: ${jsonToTsSource(this.columnName)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+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();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw sqliteError("MIGRATION.SQLITE_CONTROL_STACK_MISSING", `CreateIndexCall.toOp: a lowerer is required on the SQLite planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`, { meta: {
+			factory: this.factoryName,
+			tableName: this.tableName,
+			indexName: this.indexName
+		} });
+		const checks = indexExistsAst(this.indexName);
+		const absent = await lowerer.lowerToExecuteRequest(checks.indexAbsent());
+		const present = await lowerer.lowerToExecuteRequest(checks.indexPresent());
+		return {
+			id: `index.${this.tableName}.${this.indexName}`,
+			label: `Create index ${this.indexName} on ${this.tableName}`,
+			summary: `Creates index ${this.indexName} on ${this.tableName}`,
+			operationClass: "additive",
+			target: {
+				id: "sqlite",
+				details: buildTargetDetails("index", this.indexName, this.tableName)
+			},
+			precheck: [step(`ensure index "${this.indexName}" is missing`, absent.sql, absent.params)],
+			execute: [step(`create index "${this.indexName}"`, buildCreateIndexSql(this.tableName, this.indexName, this.columns))],
+			postcheck: [step(`verify index "${this.indexName}" exists`, present.sql, present.params)]
+		};
+	}
+	renderTypeScript() {
+		return `this.createIndex({ table: ${jsonToTsSource(this.tableName)}, index: ${jsonToTsSource(this.indexName)}, columns: ${jsonToTsSource(this.columns)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+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();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw sqliteError("MIGRATION.SQLITE_CONTROL_STACK_MISSING", `DropIndexCall.toOp: a lowerer is required on the SQLite planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`, { meta: {
+			factory: this.factoryName,
+			tableName: this.tableName,
+			indexName: this.indexName
+		} });
+		const checks = indexExistsAst(this.indexName);
+		const present = await lowerer.lowerToExecuteRequest(checks.indexPresent());
+		const absent = await lowerer.lowerToExecuteRequest(checks.indexAbsent());
+		return {
+			id: `dropIndex.${this.tableName}.${this.indexName}`,
+			label: `Drop index ${this.indexName} on ${this.tableName}`,
+			summary: `Drops index ${this.indexName} on ${this.tableName} which is not in the contract`,
+			operationClass: "destructive",
+			target: {
+				id: "sqlite",
+				details: buildTargetDetails("index", this.indexName, this.tableName)
+			},
+			precheck: [step(`ensure index "${this.indexName}" exists`, present.sql, present.params)],
+			execute: [step(`drop index "${this.indexName}"`, buildDropIndexSql(this.indexName))],
+			postcheck: [step(`verify index "${this.indexName}" is gone`, absent.sql, absent.params)]
+		};
+	}
+	renderTypeScript() {
+		return `this.dropIndex({ table: ${jsonToTsSource(this.tableName)}, index: ${jsonToTsSource(this.indexName)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+/**
+* 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 `MIGRATION.UNFILLED_PLACEHOLDER`: 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(_lowerer) {
+		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(_lowerer) {
+		return this.op;
+	}
+	renderTypeScript() {
+		return `rawSql(${jsonToTsSource(this.op)})`;
+	}
+};
+//#endregion
+export { DropColumnCall as a, RawSqlCall as c, buildColumnTypeSql as d, buildRecreatePostchecks as f, step as h, DataTransformCall as i, RecreateTableCall as l, renderDefaultLiteral as m, CreateIndexCall as n, DropIndexCall as o, buildRecreateSummary as p, CreateTableCall as r, DropTableCall as s, AddColumnCall as t, buildColumnDefaultSql as u };
+
+//# sourceMappingURL=op-factory-call-C_or6163-B_LDzC37.mjs.map