@prisma-next/target-sqlite 0.13.0 → 0.14.0

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

@@ -0,0 +1,794 @@
+import { n as stripOuterParens } from "./default-normalizer-DuoHj9-O.mjs";
+import { i as tableExistsAst, n as columnExistsAst, r as indexExistsAst, t as createTable } from "./ddl-DrtjQMFK.mjs";
+import { n as escapeLiteral, r as quoteIdentifier } from "./sql-utils-CV8Bdgtc.mjs";
+import { t as buildTargetDetails } from "./planner-target-details-H8z9TFDg.mjs";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { errorUnfilledPlaceholder } from "@prisma-next/errors/migration";
+import { TsExpression, jsonToTsSource } from "@prisma-next/ts-render";
+import { REFERENTIAL_ACTION_SQL } from "@prisma-next/sql-contract/referential-action-sql";
+//#region src/core/migrations/operations/shared.ts
+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. Returns the empty string when `constraint` is false (the FK is
+* tracked at the contract level for index-creation purposes only and must
+* not produce DDL).
+*/
+function renderForeignKeyClause(fk) {
+	if (!fk.constraint) return "";
+	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;
+}
+//#endregion
+//#region src/core/migrations/operations/columns.ts
+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)}`;
+}
+//#endregion
+//#region src/core/migrations/planner-ddl-builders.ts
+const SAFE_NATIVE_TYPE_PATTERN = /^[a-zA-Z][a-zA-Z0-9_ ]*$/;
+function assertSafeNativeType(nativeType) {
+	if (!SAFE_NATIVE_TYPE_PATTERN.test(nativeType)) throw new Error(`Unsafe native type name in contract: "${nativeType}". Native type names must match /^[a-zA-Z][a-zA-Z0-9_ ]*\$/`);
+}
+function assertSafeDefaultExpression(expression) {
+	if (expression.includes(";") || /--|\/\*|\bSELECT\b/i.test(expression)) throw new Error(`Unsafe default expression in contract: "${expression}". Default expressions must not contain semicolons, SQL comment tokens, or subqueries.`);
+}
+/**
+* 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)}`;
+}
+/**
+* True when the column is rendered inline as `INTEGER PRIMARY KEY
+* AUTOINCREMENT`. Requires the column's default to be `autoincrement()` and
+* the column to be the sole member of the table's primary key — anything
+* else falls back to a separate PRIMARY KEY constraint with a default
+* AUTOINCREMENT semantics expressed elsewhere.
+*/
+function isInlineAutoincrementPrimaryKey(table, columnName) {
+	if (table.primaryKey?.columns.length !== 1) return false;
+	if (table.primaryKey.columns[0] !== columnName) return false;
+	const column = table.columns[columnName];
+	return column?.default?.kind === "function" && column.default.expression === "autoincrement()";
+}
+function resolveColumnTypeMetadata(column, storageTypes) {
+	if (!column.typeRef) return column;
+	const referencedType = storageTypes[column.typeRef];
+	if (!referencedType) throw new Error(`Storage type "${column.typeRef}" referenced by column is not defined in storage.types.`);
+	return {
+		codecId: referencedType.codecId,
+		nativeType: referencedType.nativeType,
+		typeParams: referencedType.typeParams
+	};
+}
+//#endregion
+//#region src/core/migrations/operations/tables.ts
+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
+* 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.
+*/
+function buildRecreateSummary(tableName, issues) {
+	return `Recreates table ${tableName} to apply schema changes: ${issues.map((i) => i.message).join("; ")}`;
+}
+const COLUMN_LEVEL_ISSUE_KINDS = new Set([
+	"nullability_mismatch",
+	"default_mismatch",
+	"default_missing",
+	"extra_default",
+	"type_mismatch"
+]);
+const PK_ISSUE_KINDS = new Set(["primary_key_mismatch", "extra_primary_key"]);
+const UNIQUE_ISSUE_KINDS = new Set(["unique_constraint_mismatch", "extra_unique_constraint"]);
+const FK_ISSUE_KINDS = new Set(["foreign_key_mismatch", "extra_foreign_key"]);
+/**
+* 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(", ");
+}
+/**
+* Per-issue postchecks verifying the recreated table's shape against the
+* contract spec. Column-level issues (`nullability_mismatch`,
+* `default_mismatch`, …) emit one targeted check each; constraint-level
+* issues (`primary_key_mismatch`, `unique_constraint_mismatch`,
+* `foreign_key_mismatch`, plus their `extra_*` siblings) emit one
+* `pragma_*`-driven check per declared constraint in the contract 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 `SchemaIssue` 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]));
+	for (const issue of issues) {
+		if (issue.kind === "enum_values_changed") continue;
+		if (!COLUMN_LEVEL_ISSUE_KINDS.has(issue.kind)) continue;
+		if (!issue.column) continue;
+		const c = escapeLiteral(issue.column);
+		if (issue.kind === "nullability_mismatch") {
+			let wantNotNull;
+			if (issue.expected === "false") wantNotNull = true;
+			else if (issue.expected === "true") wantNotNull = false;
+			if (wantNotNull !== void 0) checks.push({
+				description: `verify "${issue.column}" nullability on "${tableName}"`,
+				sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND "notnull" = ${wantNotNull ? 1 : 0}`
+			});
+		}
+		if (issue.kind === "default_mismatch" || issue.kind === "default_missing") {
+			const colSpec = byName.get(issue.column);
+			const expectedRaw = colSpec?.defaultSql.startsWith("DEFAULT ") ? stripOuterParens(colSpec.defaultSql.slice(8)) : null;
+			if (expectedRaw) checks.push({
+				description: `verify "${issue.column}" default on "${tableName}"`,
+				sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND dflt_value = '${escapeLiteral(expectedRaw)}'`
+			});
+		}
+		if (issue.kind === "type_mismatch") {
+			const colSpec = byName.get(issue.column);
+			if (colSpec) checks.push({
+				description: `verify "${issue.column}" type on "${tableName}"`,
+				sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND LOWER(type) = '${escapeLiteral(colSpec.typeSql.toLowerCase())}'`
+			});
+		}
+		if (issue.kind === "extra_default") checks.push({
+			description: `verify "${issue.column}" has no default on "${tableName}"`,
+			sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND dflt_value IS NULL`
+		});
+	}
+	const hasPkIssue = issues.some((i) => PK_ISSUE_KINDS.has(i.kind));
+	const hasUniqueIssue = issues.some((i) => UNIQUE_ISSUE_KINDS.has(i.kind));
+	const hasFkIssue = issues.some((i) => FK_ISSUE_KINDS.has(i.kind));
+	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;
+}
+//#endregion
+//#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. `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 = "@prisma-next/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})`;
+		}
+	}
+}
+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 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 = 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 new Error(`DropTableCall.toOp: a lowerer is required on the SQLite planner path (table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`);
+		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 new Error(`RecreateTableCall.toOp: a lowerer is required on the SQLite planner path (table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`);
+		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 new Error(`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.`);
+		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 new Error(`DropColumnCall.toOp: a lowerer is required on the SQLite planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`);
+		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 new Error(`CreateIndexCall.toOp: a lowerer is required on the SQLite planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`);
+		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 new Error(`DropIndexCall.toOp: a lowerer is required on the SQLite planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`);
+		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 `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(_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 { step as _, DropColumnCall as a, RawSqlCall as c, buildRecreateSummary as d, buildColumnDefaultSql as f, resolveColumnTypeMetadata as g, renderDefaultLiteral as h, DataTransformCall as i, RecreateTableCall as l, isInlineAutoincrementPrimaryKey as m, CreateIndexCall as n, DropIndexCall as o, buildColumnTypeSql as p, CreateTableCall as r, DropTableCall as s, AddColumnCall as t, buildRecreatePostchecks as u };
+
+//# sourceMappingURL=op-factory-call-DmdfD1yd.mjs.map