@prisma-next/target-sqlite 0.5.0-dev.4 → 0.5.0-dev.41

package/dist/planner-CuchCrpN.mjs

@@ -0,0 +1,522 @@
+import { t as parseSqliteDefault } from "./default-normalizer-R-sQXAYt.mjs";
+import { t as normalizeSqliteNativeType } from "./native-type-normalizer-BMovohPm.mjs";
+import { c as buildColumnDefaultSql, l as buildColumnTypeSql, n as buildRecreateSummary, t as buildRecreatePostchecks, u as isInlineAutoincrementPrimaryKey } from "./tables-sKIg_lWE.mjs";
+import { a as DropColumnCall, c as RecreateTableCall, i as DataTransformCall, n as CreateIndexCall, o as DropIndexCall, r as CreateTableCall, s as DropTableCall, t as AddColumnCall } from "./op-factory-call-BUVV-W9F.mjs";
+import { t as CONTROL_TABLE_NAMES } from "./statement-builders-B3OGOp7n.mjs";
+import { t as TypeScriptRenderableSqliteMigration } from "./planner-produced-sqlite-migration-C3AAaQoW.mjs";
+import { extractCodecControlHooks, plannerFailure } from "@prisma-next/family-sql/control";
+import { verifySqlSchema } from "@prisma-next/family-sql/schema-verify";
+import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
+import { notOk, ok } from "@prisma-next/utils/result";
+
+//#region src/core/migrations/planner-strategies.ts
+const WIDENING_ISSUE_KINDS = new Set(["default_mismatch", "default_missing"]);
+const DESTRUCTIVE_ISSUE_KINDS = new Set([
+	"extra_default",
+	"type_mismatch",
+	"primary_key_mismatch",
+	"foreign_key_mismatch",
+	"unique_constraint_mismatch",
+	"extra_foreign_key",
+	"extra_unique_constraint",
+	"extra_primary_key"
+]);
+function classifyIssue(issue) {
+	if (issue.kind === "enum_values_changed") return null;
+	if (!issue.table) return null;
+	if (issue.kind === "nullability_mismatch") return issue.expected === "true" ? "widening" : "destructive";
+	if (WIDENING_ISSUE_KINDS.has(issue.kind)) return "widening";
+	if (DESTRUCTIVE_ISSUE_KINDS.has(issue.kind)) return "destructive";
+	return null;
+}
+/**
+* Groups recreate-eligible issues by table, decides per-table operation class
+* (destructive wins over widening), and emits one `RecreateTableCall` per
+* table. Returns unchanged-or-smaller issue list — issues the strategy
+* consumed are removed so `mapIssueToCall` doesn't double-handle them.
+*/
+const recreateTableStrategy = (issues, ctx) => {
+	const byTable = /* @__PURE__ */ new Map();
+	const consumed = /* @__PURE__ */ new Set();
+	for (const issue of issues) {
+		const cls = classifyIssue(issue);
+		if (!cls) continue;
+		if (issue.kind === "enum_values_changed") continue;
+		if (!issue.table) continue;
+		const table = issue.table;
+		const entry = byTable.get(table);
+		if (entry) {
+			entry.issues.push(issue);
+			if (cls === "destructive") entry.hasDestructive = true;
+		} else byTable.set(table, {
+			issues: [issue],
+			hasDestructive: cls === "destructive"
+		});
+		consumed.add(issue);
+	}
+	if (byTable.size === 0) return { kind: "no_match" };
+	const calls = [];
+	for (const [tableName, entry] of byTable) {
+		const contractTable = ctx.toContract.storage.tables[tableName];
+		const schemaTable = ctx.schema.tables[tableName];
+		if (!contractTable || !schemaTable) continue;
+		const operationClass = entry.hasDestructive ? "destructive" : "widening";
+		const tableSpec = toTableSpec(contractTable, ctx.storageTypes);
+		const seenIndexColumnKeys = /* @__PURE__ */ new Set();
+		const indexes = [];
+		for (const idx of contractTable.indexes) {
+			const key = idx.columns.join(",");
+			if (seenIndexColumnKeys.has(key)) continue;
+			seenIndexColumnKeys.add(key);
+			indexes.push({
+				name: idx.name ?? defaultIndexName(tableName, idx.columns),
+				columns: idx.columns
+			});
+		}
+		for (const fk of contractTable.foreignKeys) {
+			if (fk.index === false) continue;
+			const key = fk.columns.join(",");
+			if (seenIndexColumnKeys.has(key)) continue;
+			seenIndexColumnKeys.add(key);
+			indexes.push({
+				name: defaultIndexName(tableName, fk.columns),
+				columns: fk.columns
+			});
+		}
+		calls.push(new RecreateTableCall({
+			tableName,
+			contractTable: tableSpec,
+			schemaColumnNames: Object.keys(schemaTable.columns),
+			indexes,
+			summary: buildRecreateSummary(tableName, entry.issues),
+			postchecks: buildRecreatePostchecks(tableName, entry.issues, tableSpec),
+			operationClass
+		}));
+	}
+	return {
+		kind: "match",
+		issues: issues.filter((i) => !consumed.has(i)),
+		calls,
+		recipe: true
+	};
+};
+/**
+* When the policy allows `'data'` and the contract tightens one or more
+* columns from nullable to NOT NULL, emit a `DataTransformCall` stub per
+* tightened column. The user fills the backfill `UPDATE` in the rendered
+* `migration.ts` before the subsequent `RecreateTableCall` copies data into
+* the tightened schema (whose `INSERT INTO temp SELECT … FROM old` would
+* otherwise fail at runtime if any `NULL`s remain).
+*
+* Does NOT consume the tightening issue — `recreateTableStrategy` still
+* needs it to produce the actual recreate that enforces the NOT NULL at
+* the schema level. The backfill op and the recreate op end up in the
+* recipe slot in strategy order (backfill first, recreate second), which
+* matches the required execution order.
+*
+* Mirrors Postgres's `nullableTighteningCallStrategy` / `'data'`-class
+* gating. When `'data'` is not in the policy (the default `db update` /
+* `db init` path), the strategy short-circuits and the recreate alone
+* runs with its current destructive-class gating — preserving today's
+* behavior where a tightening blows up at runtime if NULLs are present.
+*/
+const nullabilityTighteningBackfillStrategy = (issues, ctx) => {
+	if (!ctx.policy.allowedOperationClasses.includes("data")) return { kind: "no_match" };
+	const calls = [];
+	for (const issue of issues) {
+		if (issue.kind !== "nullability_mismatch") continue;
+		if (!issue.table || !issue.column) continue;
+		if (issue.expected === "true") continue;
+		const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+		if (!column || column.nullable === true) continue;
+		calls.push(new DataTransformCall(`data_migration.backfill-${issue.table}-${issue.column}`, `Backfill NULLs in "${issue.table}"."${issue.column}" before NOT NULL tightening`, issue.table, issue.column));
+	}
+	if (calls.length === 0) return { kind: "no_match" };
+	return {
+		kind: "match",
+		issues,
+		calls,
+		recipe: true
+	};
+};
+const sqlitePlannerStrategies = [nullabilityTighteningBackfillStrategy, recreateTableStrategy];
+
+//#endregion
+//#region src/core/migrations/issue-planner.ts
+const ISSUE_KIND_ORDER = {
+	extra_foreign_key: 10,
+	extra_unique_constraint: 11,
+	extra_primary_key: 12,
+	extra_index: 13,
+	extra_default: 14,
+	extra_column: 15,
+	extra_table: 16,
+	missing_table: 20,
+	missing_column: 30,
+	type_mismatch: 40,
+	nullability_mismatch: 41,
+	default_missing: 42,
+	default_mismatch: 43,
+	primary_key_mismatch: 50,
+	unique_constraint_mismatch: 51,
+	index_mismatch: 52,
+	foreign_key_mismatch: 60
+};
+function issueOrder(issue) {
+	return ISSUE_KIND_ORDER[issue.kind] ?? 99;
+}
+function issueKey(issue) {
+	return `${"table" in issue && typeof issue.table === "string" ? issue.table : ""}\u0000${"column" in issue && typeof issue.column === "string" ? issue.column : ""}\u0000${"indexOrConstraint" in issue && typeof issue.indexOrConstraint === "string" ? issue.indexOrConstraint : ""}`;
+}
+function issueConflict(kind, summary, location) {
+	return {
+		kind,
+		summary,
+		why: "Use `migration new` to author a custom migration for this change.",
+		...location ? { location } : {}
+	};
+}
+function conflictKindForIssue(issue) {
+	switch (issue.kind) {
+		case "type_mismatch": return "typeMismatch";
+		case "nullability_mismatch": return "nullabilityConflict";
+		case "primary_key_mismatch":
+		case "unique_constraint_mismatch":
+		case "index_mismatch":
+		case "extra_primary_key":
+		case "extra_unique_constraint": return "indexIncompatible";
+		case "foreign_key_mismatch":
+		case "extra_foreign_key": return "foreignKeyConflict";
+		default: return "missingButNonAdditive";
+	}
+}
+function issueLocation(issue) {
+	if (issue.kind === "enum_values_changed") return void 0;
+	const location = {};
+	if (issue.table) location.table = issue.table;
+	if (issue.column) location.column = issue.column;
+	if (issue.indexOrConstraint) location.constraint = issue.indexOrConstraint;
+	return Object.keys(location).length > 0 ? location : void 0;
+}
+function conflictForDisallowedCall(call, allowed) {
+	const summary = `Operation "${call.label}" requires class "${call.operationClass}", but policy allows only: ${allowed.join(", ")}`;
+	const location = locationForCall(call);
+	return {
+		kind: conflictKindForCall(call),
+		summary,
+		why: "Use `migration new` to author a custom migration for this change.",
+		...location ? { location } : {}
+	};
+}
+function conflictKindForCall(call) {
+	switch (call.factoryName) {
+		case "createIndex":
+		case "dropIndex": return "indexIncompatible";
+		default: return "missingButNonAdditive";
+	}
+}
+function locationForCall(call) {
+	const location = {};
+	if ("tableName" in call) location.table = call.tableName;
+	if ("columnName" in call) location.column = call.columnName;
+	if ("indexName" in call) location.index = call.indexName;
+	return Object.keys(location).length > 0 ? location : void 0;
+}
+function isMissing(issue) {
+	if (issue.kind === "enum_values_changed") return false;
+	return issue.actual === void 0;
+}
+/**
+* Resolves codec / `typeRef` / default rendering into a flat
+* `SqliteColumnSpec`. Mirrors Postgres's `toColumnSpec`. Once a column is
+* flattened, downstream Calls and operation factories never see
+* `StorageColumn` again — they deal in pre-rendered SQL fragments.
+*/
+function toColumnSpec(name, column, storageTypes, inlineAutoincrementPrimaryKey = false) {
+	return {
+		name,
+		typeSql: buildColumnTypeSql(column, storageTypes),
+		defaultSql: buildColumnDefaultSql(column.default),
+		nullable: column.nullable,
+		...inlineAutoincrementPrimaryKey ? { inlineAutoincrementPrimaryKey: true } : {}
+	};
+}
+/**
+* Flattens a `StorageTable` into a `SqliteTableSpec` ready for
+* `CreateTableCall` / `RecreateTableCall`. Sole-column AUTOINCREMENT
+* primary keys are detected here and marked on the column spec so the
+* renderer emits `INTEGER PRIMARY KEY AUTOINCREMENT` inline.
+*/
+function toTableSpec(table, storageTypes) {
+	const columns = Object.entries(table.columns).map(([name, column]) => toColumnSpec(name, column, storageTypes, isInlineAutoincrementPrimaryKey(table, name)));
+	const uniques = table.uniques.map((u) => ({
+		columns: u.columns,
+		...u.name !== void 0 ? { name: u.name } : {}
+	}));
+	const foreignKeys = table.foreignKeys.map((fk) => ({
+		columns: fk.columns,
+		references: {
+			table: fk.references.table,
+			columns: fk.references.columns
+		},
+		constraint: fk.constraint !== false,
+		...fk.name !== void 0 ? { name: fk.name } : {},
+		...fk.onDelete !== void 0 ? { onDelete: fk.onDelete } : {},
+		...fk.onUpdate !== void 0 ? { onUpdate: fk.onUpdate } : {}
+	}));
+	return {
+		columns,
+		...table.primaryKey ? { primaryKey: { columns: table.primaryKey.columns } } : {},
+		uniques,
+		foreignKeys
+	};
+}
+const DEFAULT_POLICY = { allowedOperationClasses: [
+	"additive",
+	"widening",
+	"destructive",
+	"data"
+] };
+function emptySchemaIR() {
+	return {
+		tables: {},
+		dependencies: []
+	};
+}
+function mapIssueToCall(issue, ctx) {
+	switch (issue.kind) {
+		case "missing_table": {
+			if (!issue.table) return notOk(issueConflict("unsupportedOperation", "Missing table issue has no table name"));
+			const contractTable = ctx.toContract.storage.tables[issue.table];
+			if (!contractTable) return notOk(issueConflict("unsupportedOperation", `Table "${issue.table}" reported missing but not found in destination contract`));
+			const tableSpec = toTableSpec(contractTable, ctx.storageTypes);
+			const calls = [new CreateTableCall(issue.table, tableSpec)];
+			const declaredIndexColumnKeys = /* @__PURE__ */ new Set();
+			for (const index of contractTable.indexes) {
+				const indexName = index.name ?? defaultIndexName(issue.table, index.columns);
+				declaredIndexColumnKeys.add(index.columns.join(","));
+				calls.push(new CreateIndexCall(issue.table, indexName, index.columns));
+			}
+			for (const fk of contractTable.foreignKeys) {
+				if (fk.index === false) continue;
+				if (declaredIndexColumnKeys.has(fk.columns.join(","))) continue;
+				const indexName = defaultIndexName(issue.table, fk.columns);
+				calls.push(new CreateIndexCall(issue.table, indexName, fk.columns));
+			}
+			return ok(calls);
+		}
+		case "missing_column": {
+			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Missing column issue has no table/column name"));
+			const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+			if (!column) return notOk(issueConflict("unsupportedOperation", `Column "${issue.table}"."${issue.column}" not in destination contract`));
+			const contractTable = ctx.toContract.storage.tables[issue.table];
+			const columnSpec = toColumnSpec(issue.column, column, ctx.storageTypes, contractTable ? isInlineAutoincrementPrimaryKey(contractTable, issue.column) : false);
+			return ok([new AddColumnCall(issue.table, columnSpec)]);
+		}
+		case "index_mismatch": {
+			if (!issue.table) return notOk(issueConflict("indexIncompatible", "Index issue has no table name"));
+			if (!isMissing(issue) || !issue.expected) return notOk(issueConflict("indexIncompatible", `Index on "${issue.table}" differs (expected: ${issue.expected}, actual: ${issue.actual})`, { table: issue.table }));
+			const columns = issue.expected.split(", ");
+			const contractTable = ctx.toContract.storage.tables[issue.table];
+			if (!contractTable) return notOk(issueConflict("unsupportedOperation", `Table "${issue.table}" not found in destination contract`));
+			const indexName = contractTable.indexes.find((idx) => idx.columns.join(",") === columns.join(","))?.name ?? defaultIndexName(issue.table, columns);
+			return ok([new CreateIndexCall(issue.table, indexName, columns)]);
+		}
+		case "extra_table":
+			if (!issue.table) return notOk(issueConflict("unsupportedOperation", "Extra table issue has no table name"));
+			if (CONTROL_TABLE_NAMES.has(issue.table)) return ok([]);
+			return ok([new DropTableCall(issue.table)]);
+		case "extra_column":
+			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Extra column issue has no table/column name"));
+			return ok([new DropColumnCall(issue.table, issue.column)]);
+		case "extra_index":
+			if (!issue.table || !issue.indexOrConstraint) return notOk(issueConflict("unsupportedOperation", "Extra index issue has no table/index name"));
+			return ok([new DropIndexCall(issue.table, issue.indexOrConstraint)]);
+		case "enum_values_changed": return notOk(issueConflict("unsupportedOperation", "Received enum_values_changed against a SQLite schema (sql.enums: false) — verifier bug"));
+		case "type_mismatch":
+		case "nullability_mismatch":
+		case "default_mismatch":
+		case "default_missing":
+		case "extra_default":
+		case "primary_key_mismatch":
+		case "unique_constraint_mismatch":
+		case "foreign_key_mismatch":
+		case "extra_foreign_key":
+		case "extra_unique_constraint":
+		case "extra_primary_key": return notOk(issueConflict(conflictKindForIssue(issue), issue.message, issueLocation(issue)));
+		default: return notOk(issueConflict("unsupportedOperation", `Unhandled issue kind: ${issue.kind}`));
+	}
+}
+function classifyCall(call) {
+	switch (call.factoryName) {
+		case "createTable": return "create-table";
+		case "addColumn": return "add-column";
+		case "createIndex": return "create-index";
+		case "dropColumn": return "drop-column";
+		case "dropIndex": return "drop-index";
+		case "dropTable": return "drop-table";
+		case "recreateTable": return null;
+		default: return null;
+	}
+}
+function planIssues(options) {
+	const policyProvided = options.policy !== void 0;
+	const policy = options.policy ?? DEFAULT_POLICY;
+	const schema = options.schema ?? emptySchemaIR();
+	const frameworkComponents = options.frameworkComponents ?? [];
+	const context = {
+		toContract: options.toContract,
+		fromContract: options.fromContract,
+		codecHooks: options.codecHooks,
+		storageTypes: options.storageTypes,
+		schema,
+		policy,
+		frameworkComponents
+	};
+	const strategies = options.strategies ?? sqlitePlannerStrategies;
+	let remaining = options.issues;
+	const recipeCalls = [];
+	const bucketableCalls = [];
+	for (const strategy of strategies) {
+		const result = strategy(remaining, context);
+		if (result.kind === "match") {
+			remaining = result.issues;
+			if (result.recipe) recipeCalls.push(...result.calls);
+			else bucketableCalls.push(...result.calls);
+		}
+	}
+	const sorted = [...remaining].sort((a, b) => {
+		const kindDelta = issueOrder(a) - issueOrder(b);
+		if (kindDelta !== 0) return kindDelta;
+		const keyA = issueKey(a);
+		const keyB = issueKey(b);
+		return keyA < keyB ? -1 : keyA > keyB ? 1 : 0;
+	});
+	const defaultCalls = [];
+	const conflicts = [];
+	for (const issue of sorted) {
+		const result = mapIssueToCall(issue, context);
+		if (result.ok) defaultCalls.push(...result.value);
+		else conflicts.push(result.failure);
+	}
+	const allowed = policy.allowedOperationClasses;
+	let gatedRecipe = recipeCalls;
+	let gatedBucketable = bucketableCalls;
+	let gatedDefault = defaultCalls;
+	if (policyProvided) {
+		const sink = (acc) => (call) => {
+			if (allowed.includes(call.operationClass)) {
+				acc.push(call);
+				return;
+			}
+			conflicts.push(conflictForDisallowedCall(call, allowed));
+		};
+		const gatedRecipeBucket = [];
+		const gatedBucketableBucket = [];
+		const gatedDefaultBucket = [];
+		recipeCalls.forEach(sink(gatedRecipeBucket));
+		bucketableCalls.forEach(sink(gatedBucketableBucket));
+		defaultCalls.forEach(sink(gatedDefaultBucket));
+		gatedRecipe = gatedRecipeBucket;
+		gatedBucketable = gatedBucketableBucket;
+		gatedDefault = gatedDefaultBucket;
+	}
+	if (conflicts.length > 0) return notOk(conflicts);
+	const combined = [...gatedDefault, ...gatedBucketable];
+	const byCategory = (cat) => combined.filter((c) => classifyCall(c) === cat);
+	return ok({ calls: [
+		...byCategory("create-table"),
+		...byCategory("add-column"),
+		...byCategory("create-index"),
+		...gatedRecipe,
+		...byCategory("drop-column"),
+		...byCategory("drop-index"),
+		...byCategory("drop-table")
+	] });
+}
+
+//#endregion
+//#region src/core/migrations/planner.ts
+function createSqliteMigrationPlanner() {
+	return new SqliteMigrationPlanner();
+}
+/**
+* SQLite migration planner — a thin wrapper over `planIssues`.
+*
+* `plan()` verifies the live schema against the target contract (producing
+* `SchemaIssue[]`) and delegates to `planIssues` with the registered
+* strategies. Strategies absorb groups of related issues into composite
+* recipes (e.g. recreating a table to apply type/nullability/default/
+* constraint changes at once); anything not absorbed by a strategy flows
+* through `mapIssueToCall` in the issue planner as a one-off call.
+*
+* FK-backing indexes are surfaced by `verifySqlSchema`'s index expansion
+* (see `verify-sql-schema.ts:459-469`), so `mapIssueToCall` handles them
+* uniformly alongside user-declared indexes.
+*/
+var SqliteMigrationPlanner = class {
+	plan(options) {
+		return this.planSql(options);
+	}
+	emptyMigration(context) {
+		return new TypeScriptRenderableSqliteMigration([], {
+			from: context.fromHash,
+			to: context.toHash
+		});
+	}
+	planSql(options) {
+		const policyResult = this.ensureAdditivePolicy(options.policy);
+		if (policyResult) return policyResult;
+		const schemaIssues = this.collectSchemaIssues(options);
+		const codecHooks = extractCodecControlHooks(options.frameworkComponents);
+		const storageTypes = options.contract.storage.types ?? {};
+		const result = planIssues({
+			issues: schemaIssues,
+			toContract: options.contract,
+			fromContract: options.fromContract,
+			codecHooks,
+			storageTypes,
+			schema: options.schema,
+			policy: options.policy,
+			frameworkComponents: options.frameworkComponents,
+			strategies: sqlitePlannerStrategies
+		});
+		if (!result.ok) return plannerFailure(result.failure);
+		const destination = {
+			storageHash: options.contract.storage.storageHash,
+			...options.contract.profileHash !== void 0 ? { profileHash: options.contract.profileHash } : {}
+		};
+		return {
+			kind: "success",
+			plan: new TypeScriptRenderableSqliteMigration(result.value.calls, {
+				from: options.fromContract?.storage.storageHash ?? null,
+				to: options.contract.storage.storageHash
+			}, destination)
+		};
+	}
+	ensureAdditivePolicy(policy) {
+		if (!policy.allowedOperationClasses.includes("additive")) return plannerFailure([{
+			kind: "unsupportedOperation",
+			summary: "Migration planner requires additive operations be allowed",
+			why: "The planner requires the \"additive\" operation class to be allowed in the policy."
+		}]);
+		return null;
+	}
+	collectSchemaIssues(options) {
+		const allowed = options.policy.allowedOperationClasses;
+		const strict = allowed.includes("widening") || allowed.includes("destructive");
+		return verifySqlSchema({
+			contract: options.contract,
+			schema: options.schema,
+			strict,
+			typeMetadataRegistry: /* @__PURE__ */ new Map(),
+			frameworkComponents: options.frameworkComponents,
+			normalizeDefault: parseSqliteDefault,
+			normalizeNativeType: normalizeSqliteNativeType
+		}).schema.issues;
+	}
+};
+
+//#endregion
+export { createSqliteMigrationPlanner as n, SqliteMigrationPlanner as t };
+//# sourceMappingURL=planner-CuchCrpN.mjs.map

package/dist/planner-CuchCrpN.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-CuchCrpN.mjs","names":["recreateTableStrategy: CallMigrationStrategy","calls: SqliteOpFactoryCall[]","operationClass: MigrationOperationClass","indexes: SqliteIndexSpec[]","nullabilityTighteningBackfillStrategy: CallMigrationStrategy","sqlitePlannerStrategies: readonly CallMigrationStrategy[]","ISSUE_KIND_ORDER: Record<string, number>","location: {\n    table?: string;\n    column?: string;\n    constraint?: string;\n  }","location: { table?: string; column?: string; index?: string }","columns: SqliteColumnSpec[]","uniques: SqliteUniqueSpec[]","foreignKeys: SqliteForeignKeySpec[]","DEFAULT_POLICY: MigrationOperationPolicy","calls: SqliteOpFactoryCall[]","context: StrategyContext","recipeCalls: SqliteOpFactoryCall[]","bucketableCalls: SqliteOpFactoryCall[]","defaultCalls: SqliteOpFactoryCall[]","conflicts: SqlPlannerConflict[]","gatedRecipeBucket: SqliteOpFactoryCall[]","gatedBucketableBucket: SqliteOpFactoryCall[]","gatedDefaultBucket: SqliteOpFactoryCall[]","destination: SqliteMigrationDestinationInfo"],"sources":["../src/core/migrations/planner-strategies.ts","../src/core/migrations/issue-planner.ts","../src/core/migrations/planner.ts"],"sourcesContent":["/**\n * SQLite migration strategies.\n *\n * Each strategy examines the issue list, consumes issues it handles, and\n * returns the `SqliteOpFactoryCall[]` to address them. The issue planner\n * runs each strategy in order and routes whatever's left through\n * `mapIssueToCall`.\n *\n * SQLite has no enums, no data-safe backfill, and no component-declared\n * database dependencies. The only recipe that needs strategy-level\n * multi-issue consumption is `recreateTable` (added in a later phase), which\n * absorbs type/nullability/default/constraint mismatches for a given table\n * into a single recreate operation.\n */\n\nimport type { Contract } from '@prisma-next/contract/types';\nimport type {\n  CodecControlHooks,\n  MigrationOperationClass,\n  MigrationOperationPolicy,\n} from '@prisma-next/family-sql/control';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type { SchemaIssue } from '@prisma-next/framework-components/control';\nimport type { SqlStorage, StorageTypeInstance } from '@prisma-next/sql-contract/types';\nimport { defaultIndexName } from '@prisma-next/sql-schema-ir/naming';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\nimport { toTableSpec } from './issue-planner';\nimport { DataTransformCall, RecreateTableCall, type SqliteOpFactoryCall } from './op-factory-call';\nimport type { SqliteIndexSpec } from './operations/shared';\nimport { buildRecreatePostchecks, buildRecreateSummary } from './operations/tables';\n\nexport interface StrategyContext {\n  readonly toContract: Contract<SqlStorage>;\n  readonly fromContract: Contract<SqlStorage> | null;\n  readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;\n  readonly storageTypes: Readonly<Record<string, StorageTypeInstance>>;\n  readonly schema: SqlSchemaIR;\n  readonly policy: MigrationOperationPolicy;\n  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n}\n\nexport type CallMigrationStrategy = (\n  issues: readonly SchemaIssue[],\n  context: StrategyContext,\n) =>\n  | {\n      kind: 'match';\n      issues: readonly SchemaIssue[];\n      calls: readonly SqliteOpFactoryCall[];\n      recipe?: boolean;\n    }\n  | { kind: 'no_match' };\n\n// ============================================================================\n// Recreate-table strategy\n// ============================================================================\n\nconst WIDENING_ISSUE_KINDS = new Set<SchemaIssue['kind']>(['default_mismatch', 'default_missing']);\n\nconst DESTRUCTIVE_ISSUE_KINDS = new Set<SchemaIssue['kind']>([\n  'extra_default',\n  'type_mismatch',\n  'primary_key_mismatch',\n  'foreign_key_mismatch',\n  'unique_constraint_mismatch',\n  'extra_foreign_key',\n  'extra_unique_constraint',\n  'extra_primary_key',\n]);\n\nfunction classifyIssue(issue: SchemaIssue): 'widening' | 'destructive' | null {\n  if (issue.kind === 'enum_values_changed') return null;\n  if (!issue.table) return null;\n  if (issue.kind === 'nullability_mismatch') {\n    // Relaxing (NOT NULL → nullable) is widening; tightening is destructive.\n    return issue.expected === 'true' ? 'widening' : 'destructive';\n  }\n  if (WIDENING_ISSUE_KINDS.has(issue.kind)) return 'widening';\n  if (DESTRUCTIVE_ISSUE_KINDS.has(issue.kind)) return 'destructive';\n  return null;\n}\n\n/**\n * Groups recreate-eligible issues by table, decides per-table operation class\n * (destructive wins over widening), and emits one `RecreateTableCall` per\n * table. Returns unchanged-or-smaller issue list — issues the strategy\n * consumed are removed so `mapIssueToCall` doesn't double-handle them.\n */\nexport const recreateTableStrategy: CallMigrationStrategy = (issues, ctx) => {\n  const byTable = new Map<string, { issues: SchemaIssue[]; hasDestructive: boolean }>();\n  const consumed = new Set<SchemaIssue>();\n\n  for (const issue of issues) {\n    const cls = classifyIssue(issue);\n    if (!cls) continue;\n    if (issue.kind === 'enum_values_changed') continue;\n    if (!issue.table) continue;\n    const table = issue.table;\n    const entry = byTable.get(table);\n    if (entry) {\n      entry.issues.push(issue);\n      if (cls === 'destructive') entry.hasDestructive = true;\n    } else {\n      byTable.set(table, { issues: [issue], hasDestructive: cls === 'destructive' });\n    }\n    consumed.add(issue);\n  }\n\n  if (byTable.size === 0) return { kind: 'no_match' };\n\n  const calls: SqliteOpFactoryCall[] = [];\n  for (const [tableName, entry] of byTable) {\n    const contractTable = ctx.toContract.storage.tables[tableName];\n    const schemaTable = ctx.schema.tables[tableName];\n    if (!contractTable || !schemaTable) continue;\n    const operationClass: MigrationOperationClass = entry.hasDestructive\n      ? 'destructive'\n      : 'widening';\n\n    // Flatten the contract table to a self-contained spec — the Call holds\n    // pre-rendered SQL fragments only, no `StorageColumn` or `storageTypes`.\n    const tableSpec = toTableSpec(contractTable, ctx.storageTypes);\n\n    const seenIndexColumnKeys = new Set<string>();\n    const indexes: SqliteIndexSpec[] = [];\n    for (const idx of contractTable.indexes) {\n      const key = idx.columns.join(',');\n      if (seenIndexColumnKeys.has(key)) continue;\n      seenIndexColumnKeys.add(key);\n      indexes.push({\n        name: idx.name ?? defaultIndexName(tableName, idx.columns),\n        columns: idx.columns,\n      });\n    }\n    for (const fk of contractTable.foreignKeys) {\n      if (fk.index === false) continue;\n      const key = fk.columns.join(',');\n      if (seenIndexColumnKeys.has(key)) continue;\n      seenIndexColumnKeys.add(key);\n      indexes.push({\n        name: defaultIndexName(tableName, fk.columns),\n        columns: fk.columns,\n      });\n    }\n\n    calls.push(\n      new RecreateTableCall({\n        tableName,\n        contractTable: tableSpec,\n        schemaColumnNames: Object.keys(schemaTable.columns),\n        indexes,\n        summary: buildRecreateSummary(tableName, entry.issues),\n        postchecks: buildRecreatePostchecks(tableName, entry.issues, tableSpec),\n        operationClass,\n      }),\n    );\n  }\n\n  return {\n    kind: 'match',\n    issues: issues.filter((i) => !consumed.has(i)),\n    calls,\n    recipe: true,\n  };\n};\n\n// ============================================================================\n// Nullability-tightening backfill strategy\n// ============================================================================\n\n/**\n * When the policy allows `'data'` and the contract tightens one or more\n * columns from nullable to NOT NULL, emit a `DataTransformCall` stub per\n * tightened column. The user fills the backfill `UPDATE` in the rendered\n * `migration.ts` before the subsequent `RecreateTableCall` copies data into\n * the tightened schema (whose `INSERT INTO temp SELECT … FROM old` would\n * otherwise fail at runtime if any `NULL`s remain).\n *\n * Does NOT consume the tightening issue — `recreateTableStrategy` still\n * needs it to produce the actual recreate that enforces the NOT NULL at\n * the schema level. The backfill op and the recreate op end up in the\n * recipe slot in strategy order (backfill first, recreate second), which\n * matches the required execution order.\n *\n * Mirrors Postgres's `nullableTighteningCallStrategy` / `'data'`-class\n * gating. When `'data'` is not in the policy (the default `db update` /\n * `db init` path), the strategy short-circuits and the recreate alone\n * runs with its current destructive-class gating — preserving today's\n * behavior where a tightening blows up at runtime if NULLs are present.\n */\nexport const nullabilityTighteningBackfillStrategy: CallMigrationStrategy = (issues, ctx) => {\n  if (!ctx.policy.allowedOperationClasses.includes('data')) {\n    return { kind: 'no_match' };\n  }\n\n  const calls: SqliteOpFactoryCall[] = [];\n  for (const issue of issues) {\n    if (issue.kind !== 'nullability_mismatch') continue;\n    if (!issue.table || !issue.column) continue;\n    // Tightening only: `expected === 'true'` means the contract wants the\n    // column nullable (relaxing from NOT NULL → nullable), which is safe and\n    // needs no backfill.\n    if (issue.expected === 'true') continue;\n\n    const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];\n    if (!column || column.nullable === true) continue;\n\n    calls.push(\n      new DataTransformCall(\n        `data_migration.backfill-${issue.table}-${issue.column}`,\n        `Backfill NULLs in \"${issue.table}\".\"${issue.column}\" before NOT NULL tightening`,\n        issue.table,\n        issue.column,\n      ),\n    );\n  }\n\n  if (calls.length === 0) return { kind: 'no_match' };\n\n  return {\n    kind: 'match',\n    issues,\n    calls,\n    recipe: true,\n  };\n};\n\nexport const sqlitePlannerStrategies: readonly CallMigrationStrategy[] = [\n  nullabilityTighteningBackfillStrategy,\n  recreateTableStrategy,\n];\n","/**\n * SQLite migration issue planner.\n *\n * Takes schema issues (from `verifySqlSchema`) and emits migration IR\n * (`SqliteOpFactoryCall[]`). Strategies consume issues they recognize and\n * produce specialized call sequences (e.g. recreateTableStrategy absorbs\n * type/nullability/default/constraint mismatches into a single recreate op);\n * remaining issues flow through `mapIssueToCall` for the default case.\n */\n\nimport type { Contract } from '@prisma-next/contract/types';\nimport type {\n  CodecControlHooks,\n  MigrationOperationPolicy,\n  SqlPlannerConflict,\n  SqlPlannerConflictLocation,\n} from '@prisma-next/family-sql/control';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type { SchemaIssue } from '@prisma-next/framework-components/control';\nimport type {\n  SqlStorage,\n  StorageColumn,\n  StorageTable,\n  StorageTypeInstance,\n} from '@prisma-next/sql-contract/types';\nimport { defaultIndexName } from '@prisma-next/sql-schema-ir/naming';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\nimport type { Result } from '@prisma-next/utils/result';\nimport { notOk, ok } from '@prisma-next/utils/result';\nimport {\n  AddColumnCall,\n  CreateIndexCall,\n  CreateTableCall,\n  DropColumnCall,\n  DropIndexCall,\n  DropTableCall,\n  type SqliteOpFactoryCall,\n} from './op-factory-call';\nimport type {\n  SqliteColumnSpec,\n  SqliteForeignKeySpec,\n  SqliteTableSpec,\n  SqliteUniqueSpec,\n} from './operations/shared';\nimport {\n  buildColumnDefaultSql,\n  buildColumnTypeSql,\n  isInlineAutoincrementPrimaryKey,\n} from './planner-ddl-builders';\nimport {\n  type CallMigrationStrategy,\n  type StrategyContext,\n  sqlitePlannerStrategies,\n} from './planner-strategies';\nimport { CONTROL_TABLE_NAMES } from './statement-builders';\n\nexport type { CallMigrationStrategy, StrategyContext };\n\n// ============================================================================\n// Issue kind ordering (dependency order)\n// ============================================================================\n\nconst ISSUE_KIND_ORDER: Record<string, number> = {\n  // Drops (reconciliation — clear the way for creates)\n  extra_foreign_key: 10,\n  extra_unique_constraint: 11,\n  extra_primary_key: 12,\n  extra_index: 13,\n  extra_default: 14,\n  extra_column: 15,\n  extra_table: 16,\n\n  // Tables before columns\n  missing_table: 20,\n\n  // Columns before constraints\n  missing_column: 30,\n\n  // Reconciliation alters (on existing objects)\n  type_mismatch: 40,\n  nullability_mismatch: 41,\n  default_missing: 42,\n  default_mismatch: 43,\n\n  // Constraints after columns exist\n  primary_key_mismatch: 50,\n  unique_constraint_mismatch: 51,\n  index_mismatch: 52,\n  foreign_key_mismatch: 60,\n};\n\nfunction issueOrder(issue: SchemaIssue): number {\n  return ISSUE_KIND_ORDER[issue.kind] ?? 99;\n}\n\nfunction issueKey(issue: SchemaIssue): string {\n  const table = 'table' in issue && typeof issue.table === 'string' ? issue.table : '';\n  const column = 'column' in issue && typeof issue.column === 'string' ? issue.column : '';\n  const name =\n    'indexOrConstraint' in issue && typeof issue.indexOrConstraint === 'string'\n      ? issue.indexOrConstraint\n      : '';\n  return `${table}\\u0000${column}\\u0000${name}`;\n}\n\n// ============================================================================\n// Conflict helpers\n// ============================================================================\n\nfunction issueConflict(\n  kind: SqlPlannerConflict['kind'],\n  summary: string,\n  location?: SqlPlannerConflict['location'],\n): SqlPlannerConflict {\n  return {\n    kind,\n    summary,\n    why: 'Use `migration new` to author a custom migration for this change.',\n    ...(location ? { location } : {}),\n  };\n}\n\nfunction conflictKindForIssue(issue: SchemaIssue): SqlPlannerConflict['kind'] {\n  switch (issue.kind) {\n    case 'type_mismatch':\n      return 'typeMismatch';\n    case 'nullability_mismatch':\n      return 'nullabilityConflict';\n    case 'primary_key_mismatch':\n    case 'unique_constraint_mismatch':\n    case 'index_mismatch':\n    case 'extra_primary_key':\n    case 'extra_unique_constraint':\n      return 'indexIncompatible';\n    case 'foreign_key_mismatch':\n    case 'extra_foreign_key':\n      return 'foreignKeyConflict';\n    default:\n      return 'missingButNonAdditive';\n  }\n}\n\nfunction issueLocation(issue: SchemaIssue): SqlPlannerConflictLocation | undefined {\n  if (issue.kind === 'enum_values_changed') return undefined;\n  const location: {\n    table?: string;\n    column?: string;\n    constraint?: string;\n  } = {};\n  if (issue.table) location.table = issue.table;\n  if (issue.column) location.column = issue.column;\n  if (issue.indexOrConstraint) location.constraint = issue.indexOrConstraint;\n  return Object.keys(location).length > 0 ? (location as SqlPlannerConflictLocation) : undefined;\n}\n\nfunction conflictForDisallowedCall(\n  call: SqliteOpFactoryCall,\n  allowed: readonly string[],\n): SqlPlannerConflict {\n  const summary = `Operation \"${call.label}\" requires class \"${call.operationClass}\", but policy allows only: ${allowed.join(', ')}`;\n  const location = locationForCall(call);\n  return {\n    kind: conflictKindForCall(call),\n    summary,\n    why: 'Use `migration new` to author a custom migration for this change.',\n    ...(location ? { location } : {}),\n  };\n}\n\nfunction conflictKindForCall(call: SqliteOpFactoryCall): SqlPlannerConflict['kind'] {\n  switch (call.factoryName) {\n    case 'createIndex':\n    case 'dropIndex':\n      return 'indexIncompatible';\n    default:\n      return 'missingButNonAdditive';\n  }\n}\n\nfunction locationForCall(call: SqliteOpFactoryCall): SqlPlannerConflictLocation | undefined {\n  const location: { table?: string; column?: string; index?: string } = {};\n  if ('tableName' in call) location.table = call.tableName;\n  if ('columnName' in call) location.column = call.columnName;\n  if ('indexName' in call) location.index = call.indexName;\n  return Object.keys(location).length > 0 ? (location as SqlPlannerConflictLocation) : undefined;\n}\n\nfunction isMissing(issue: SchemaIssue): boolean {\n  if (issue.kind === 'enum_values_changed') return false;\n  return issue.actual === undefined;\n}\n\n// ============================================================================\n// StorageTable / StorageColumn → flat SqliteTableSpec\n// ============================================================================\n\n/**\n * Resolves codec / `typeRef` / default rendering into a flat\n * `SqliteColumnSpec`. Mirrors Postgres's `toColumnSpec`. Once a column is\n * flattened, downstream Calls and operation factories never see\n * `StorageColumn` again — they deal in pre-rendered SQL fragments.\n */\nexport function toColumnSpec(\n  name: string,\n  column: StorageColumn,\n  storageTypes: Readonly<Record<string, StorageTypeInstance>>,\n  inlineAutoincrementPrimaryKey = false,\n): SqliteColumnSpec {\n  const typeSql = buildColumnTypeSql(column, storageTypes as Record<string, StorageTypeInstance>);\n  const defaultSql = buildColumnDefaultSql(column.default);\n  return {\n    name,\n    typeSql,\n    defaultSql,\n    nullable: column.nullable,\n    ...(inlineAutoincrementPrimaryKey ? { inlineAutoincrementPrimaryKey: true } : {}),\n  };\n}\n\n/**\n * Flattens a `StorageTable` into a `SqliteTableSpec` ready for\n * `CreateTableCall` / `RecreateTableCall`. Sole-column AUTOINCREMENT\n * primary keys are detected here and marked on the column spec so the\n * renderer emits `INTEGER PRIMARY KEY AUTOINCREMENT` inline.\n */\nexport function toTableSpec(\n  table: StorageTable,\n  storageTypes: Readonly<Record<string, StorageTypeInstance>>,\n): SqliteTableSpec {\n  const columns: SqliteColumnSpec[] = Object.entries(table.columns).map(([name, column]) =>\n    toColumnSpec(name, column, storageTypes, isInlineAutoincrementPrimaryKey(table, name)),\n  );\n  const uniques: SqliteUniqueSpec[] = table.uniques.map((u) => ({\n    columns: u.columns,\n    ...(u.name !== undefined ? { name: u.name } : {}),\n  }));\n  const foreignKeys: SqliteForeignKeySpec[] = table.foreignKeys.map((fk) => ({\n    columns: fk.columns,\n    references: { table: fk.references.table, columns: fk.references.columns },\n    constraint: fk.constraint !== false,\n    ...(fk.name !== undefined ? { name: fk.name } : {}),\n    ...(fk.onDelete !== undefined ? { onDelete: fk.onDelete } : {}),\n    ...(fk.onUpdate !== undefined ? { onUpdate: fk.onUpdate } : {}),\n  }));\n  return {\n    columns,\n    ...(table.primaryKey ? { primaryKey: { columns: table.primaryKey.columns } } : {}),\n    uniques,\n    foreignKeys,\n  };\n}\n\n// ============================================================================\n// Issue planner\n// ============================================================================\n\nexport interface IssuePlannerOptions {\n  readonly issues: readonly SchemaIssue[];\n  readonly toContract: Contract<SqlStorage>;\n  readonly fromContract: Contract<SqlStorage> | null;\n  readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;\n  readonly storageTypes: Readonly<Record<string, StorageTypeInstance>>;\n  readonly schema?: SqlSchemaIR;\n  readonly policy?: MigrationOperationPolicy;\n  readonly frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n  readonly strategies?: readonly CallMigrationStrategy[];\n}\n\nexport interface IssuePlannerValue {\n  readonly calls: readonly SqliteOpFactoryCall[];\n}\n\nconst DEFAULT_POLICY: MigrationOperationPolicy = {\n  allowedOperationClasses: ['additive', 'widening', 'destructive', 'data'],\n};\n\nfunction emptySchemaIR(): SqlSchemaIR {\n  return { tables: {}, dependencies: [] };\n}\n\n// ============================================================================\n// Issue → Call mapping (per-issue default path)\n// ============================================================================\n\nfunction mapIssueToCall(\n  issue: SchemaIssue,\n  ctx: StrategyContext,\n): Result<readonly SqliteOpFactoryCall[], SqlPlannerConflict> {\n  switch (issue.kind) {\n    case 'missing_table': {\n      if (!issue.table) {\n        return notOk(\n          issueConflict('unsupportedOperation', 'Missing table issue has no table name'),\n        );\n      }\n      const contractTable = ctx.toContract.storage.tables[issue.table];\n      if (!contractTable) {\n        return notOk(\n          issueConflict(\n            'unsupportedOperation',\n            `Table \"${issue.table}\" reported missing but not found in destination contract`,\n          ),\n        );\n      }\n      const tableSpec = toTableSpec(contractTable, ctx.storageTypes);\n      const calls: SqliteOpFactoryCall[] = [new CreateTableCall(issue.table, tableSpec)];\n      const declaredIndexColumnKeys = new Set<string>();\n      for (const index of contractTable.indexes) {\n        const indexName = index.name ?? defaultIndexName(issue.table, index.columns);\n        declaredIndexColumnKeys.add(index.columns.join(','));\n        calls.push(new CreateIndexCall(issue.table, indexName, index.columns));\n      }\n      for (const fk of contractTable.foreignKeys) {\n        if (fk.index === false) continue;\n        if (declaredIndexColumnKeys.has(fk.columns.join(','))) continue;\n        const indexName = defaultIndexName(issue.table, fk.columns);\n        calls.push(new CreateIndexCall(issue.table, indexName, fk.columns));\n      }\n      return ok(calls);\n    }\n\n    case 'missing_column': {\n      if (!issue.table || !issue.column) {\n        return notOk(\n          issueConflict('unsupportedOperation', 'Missing column issue has no table/column name'),\n        );\n      }\n      const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];\n      if (!column) {\n        return notOk(\n          issueConflict(\n            'unsupportedOperation',\n            `Column \"${issue.table}\".\"${issue.column}\" not in destination contract`,\n          ),\n        );\n      }\n      const contractTable = ctx.toContract.storage.tables[issue.table];\n      const columnSpec = toColumnSpec(\n        issue.column,\n        column,\n        ctx.storageTypes,\n        contractTable ? isInlineAutoincrementPrimaryKey(contractTable, issue.column) : false,\n      );\n      return ok([new AddColumnCall(issue.table, columnSpec)]);\n    }\n\n    case 'index_mismatch': {\n      if (!issue.table) {\n        return notOk(issueConflict('indexIncompatible', 'Index issue has no table name'));\n      }\n      if (!isMissing(issue) || !issue.expected) {\n        return notOk(\n          issueConflict(\n            'indexIncompatible',\n            `Index on \"${issue.table}\" differs (expected: ${issue.expected}, actual: ${issue.actual})`,\n            { table: issue.table },\n          ),\n        );\n      }\n      const columns = issue.expected.split(', ');\n      const contractTable = ctx.toContract.storage.tables[issue.table];\n      if (!contractTable) {\n        return notOk(\n          issueConflict(\n            'unsupportedOperation',\n            `Table \"${issue.table}\" not found in destination contract`,\n          ),\n        );\n      }\n      // Use the explicit-index name if one is declared for these columns;\n      // otherwise fall back to `defaultIndexName` (which is also what\n      // `verifySqlSchema` synthesizes for FK-backing indexes). Whether the\n      // missing index originates from `contractTable.indexes` or from an FK\n      // with `index: true` doesn't change the emitted DDL.\n      const explicitIndex = contractTable.indexes.find(\n        (idx) => idx.columns.join(',') === columns.join(','),\n      );\n      const indexName = explicitIndex?.name ?? defaultIndexName(issue.table, columns);\n      return ok([new CreateIndexCall(issue.table, indexName, columns)]);\n    }\n\n    case 'extra_table': {\n      if (!issue.table) {\n        return notOk(issueConflict('unsupportedOperation', 'Extra table issue has no table name'));\n      }\n      // Runner-owned control tables must never be dropped.\n      if (CONTROL_TABLE_NAMES.has(issue.table)) return ok([]);\n      return ok([new DropTableCall(issue.table)]);\n    }\n\n    case 'extra_column': {\n      if (!issue.table || !issue.column) {\n        return notOk(\n          issueConflict('unsupportedOperation', 'Extra column issue has no table/column name'),\n        );\n      }\n      return ok([new DropColumnCall(issue.table, issue.column)]);\n    }\n\n    case 'extra_index': {\n      if (!issue.table || !issue.indexOrConstraint) {\n        return notOk(\n          issueConflict('unsupportedOperation', 'Extra index issue has no table/index name'),\n        );\n      }\n      return ok([new DropIndexCall(issue.table, issue.indexOrConstraint)]);\n    }\n\n    // SQLite has no enum types (capability `sql.enums: false`). The verifier\n    // should never emit `enum_values_changed` against a SQLite schema, so if\n    // we receive one it is a verifier bug — surface it as an explicit\n    // conflict rather than silently dropping it.\n    case 'enum_values_changed':\n      return notOk(\n        issueConflict(\n          'unsupportedOperation',\n          'Received enum_values_changed against a SQLite schema (sql.enums: false) — verifier bug',\n        ),\n      );\n\n    // Everything below is absorbed by recreateTableStrategy. If it falls\n    // through here, policy or context didn't allow the recreate — surface as\n    // a conflict.\n    case 'type_mismatch':\n    case 'nullability_mismatch':\n    case 'default_mismatch':\n    case 'default_missing':\n    case 'extra_default':\n    case 'primary_key_mismatch':\n    case 'unique_constraint_mismatch':\n    case 'foreign_key_mismatch':\n    case 'extra_foreign_key':\n    case 'extra_unique_constraint':\n    case 'extra_primary_key':\n      return notOk(issueConflict(conflictKindForIssue(issue), issue.message, issueLocation(issue)));\n\n    default:\n      return notOk(\n        issueConflict(\n          'unsupportedOperation',\n          `Unhandled issue kind: ${(issue as SchemaIssue).kind}`,\n        ),\n      );\n  }\n}\n\n// ============================================================================\n// Call categorization for final emission order\n// ============================================================================\n\ntype CallCategory =\n  | 'drop-column'\n  | 'drop-index'\n  | 'drop-table'\n  | 'create-table'\n  | 'add-column'\n  | 'create-index';\n\nfunction classifyCall(call: SqliteOpFactoryCall): CallCategory | null {\n  switch (call.factoryName) {\n    case 'createTable':\n      return 'create-table';\n    case 'addColumn':\n      return 'add-column';\n    case 'createIndex':\n      return 'create-index';\n    case 'dropColumn':\n      return 'drop-column';\n    case 'dropIndex':\n      return 'drop-index';\n    case 'dropTable':\n      return 'drop-table';\n    // recreateTable goes into the recipe slot; return null for bucketable.\n    case 'recreateTable':\n      return null;\n    default:\n      return null;\n  }\n}\n\n// ============================================================================\n// Top-level planIssues\n// ============================================================================\n\nexport function planIssues(\n  options: IssuePlannerOptions,\n): Result<IssuePlannerValue, readonly SqlPlannerConflict[]> {\n  const policyProvided = options.policy !== undefined;\n  const policy = options.policy ?? DEFAULT_POLICY;\n  const schema = options.schema ?? emptySchemaIR();\n  const frameworkComponents = options.frameworkComponents ?? [];\n\n  const context: StrategyContext = {\n    toContract: options.toContract,\n    fromContract: options.fromContract,\n    codecHooks: options.codecHooks,\n    storageTypes: options.storageTypes,\n    schema,\n    policy,\n    frameworkComponents,\n  };\n\n  const strategies = options.strategies ?? sqlitePlannerStrategies;\n\n  let remaining = options.issues;\n  const recipeCalls: SqliteOpFactoryCall[] = [];\n  const bucketableCalls: SqliteOpFactoryCall[] = [];\n\n  for (const strategy of strategies) {\n    const result = strategy(remaining, context);\n    if (result.kind === 'match') {\n      remaining = result.issues;\n      if (result.recipe) {\n        recipeCalls.push(...result.calls);\n      } else {\n        bucketableCalls.push(...result.calls);\n      }\n    }\n  }\n\n  const sorted = [...remaining].sort((a, b) => {\n    const kindDelta = issueOrder(a) - issueOrder(b);\n    if (kindDelta !== 0) return kindDelta;\n    const keyA = issueKey(a);\n    const keyB = issueKey(b);\n    return keyA < keyB ? -1 : keyA > keyB ? 1 : 0;\n  });\n\n  const defaultCalls: SqliteOpFactoryCall[] = [];\n  const conflicts: SqlPlannerConflict[] = [];\n\n  for (const issue of sorted) {\n    const result = mapIssueToCall(issue, context);\n    if (result.ok) {\n      defaultCalls.push(...result.value);\n    } else {\n      conflicts.push(result.failure);\n    }\n  }\n\n  // Policy gating for recipe + bucketable. Default-mapped calls for disallowed\n  // classes never get here (they're surfaced as per-issue conflicts above).\n  const allowed = policy.allowedOperationClasses;\n  let gatedRecipe = recipeCalls;\n  let gatedBucketable = bucketableCalls;\n  let gatedDefault = defaultCalls;\n  if (policyProvided) {\n    const sink = (acc: SqliteOpFactoryCall[]) => (call: SqliteOpFactoryCall) => {\n      if (allowed.includes(call.operationClass)) {\n        acc.push(call);\n        return;\n      }\n      conflicts.push(conflictForDisallowedCall(call, allowed));\n    };\n    const gatedRecipeBucket: SqliteOpFactoryCall[] = [];\n    const gatedBucketableBucket: SqliteOpFactoryCall[] = [];\n    const gatedDefaultBucket: SqliteOpFactoryCall[] = [];\n    recipeCalls.forEach(sink(gatedRecipeBucket));\n    bucketableCalls.forEach(sink(gatedBucketableBucket));\n    defaultCalls.forEach(sink(gatedDefaultBucket));\n    gatedRecipe = gatedRecipeBucket;\n    gatedBucketable = gatedBucketableBucket;\n    gatedDefault = gatedDefaultBucket;\n  }\n\n  if (conflicts.length > 0) {\n    return notOk(conflicts);\n  }\n\n  // Final emission order matches the current monolithic planner:\n  //   create-table → add-column → create-index → recreate → drop-column → drop-index → drop-table\n  const combined = [...gatedDefault, ...gatedBucketable];\n  const byCategory = (cat: CallCategory) => combined.filter((c) => classifyCall(c) === cat);\n\n  const calls: SqliteOpFactoryCall[] = [\n    ...byCategory('create-table'),\n    ...byCategory('add-column'),\n    ...byCategory('create-index'),\n    ...gatedRecipe,\n    ...byCategory('drop-column'),\n    ...byCategory('drop-index'),\n    ...byCategory('drop-table'),\n  ];\n\n  return ok({ calls });\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type {\n  MigrationOperationPolicy,\n  SqlMigrationPlanner,\n  SqlMigrationPlannerPlanOptions,\n  SqlPlannerFailureResult,\n} from '@prisma-next/family-sql/control';\nimport { extractCodecControlHooks, plannerFailure } from '@prisma-next/family-sql/control';\nimport { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type {\n  MigrationPlanner,\n  MigrationScaffoldContext,\n  SchemaIssue,\n} from '@prisma-next/framework-components/control';\nimport { parseSqliteDefault } from '../default-normalizer';\nimport { normalizeSqliteNativeType } from '../native-type-normalizer';\nimport { planIssues } from './issue-planner';\nimport {\n  type SqliteMigrationDestinationInfo,\n  TypeScriptRenderableSqliteMigration,\n} from './planner-produced-sqlite-migration';\nimport { sqlitePlannerStrategies } from './planner-strategies';\nimport type { SqlitePlanTargetDetails } from './planner-target-details';\n\nexport function createSqliteMigrationPlanner(): SqliteMigrationPlanner {\n  return new SqliteMigrationPlanner();\n}\n\nexport type SqlitePlanResult =\n  | { readonly kind: 'success'; readonly plan: TypeScriptRenderableSqliteMigration }\n  | SqlPlannerFailureResult;\n\n/**\n * SQLite migration planner — a thin wrapper over `planIssues`.\n *\n * `plan()` verifies the live schema against the target contract (producing\n * `SchemaIssue[]`) and delegates to `planIssues` with the registered\n * strategies. Strategies absorb groups of related issues into composite\n * recipes (e.g. recreating a table to apply type/nullability/default/\n * constraint changes at once); anything not absorbed by a strategy flows\n * through `mapIssueToCall` in the issue planner as a one-off call.\n *\n * FK-backing indexes are surfaced by `verifySqlSchema`'s index expansion\n * (see `verify-sql-schema.ts:459-469`), so `mapIssueToCall` handles them\n * uniformly alongside user-declared indexes.\n */\nexport class SqliteMigrationPlanner\n  implements SqlMigrationPlanner<SqlitePlanTargetDetails>, MigrationPlanner<'sql', 'sqlite'>\n{\n  plan(options: {\n    readonly contract: unknown;\n    readonly schema: unknown;\n    readonly policy: MigrationOperationPolicy;\n    /**\n     * The \"from\" contract (state the planner assumes the database starts at),\n     * or `null` for reconciliation flows.\n     *\n     * Typed as the framework `Contract | null` to satisfy the\n     * `MigrationPlanner` interface contract; `planSql` narrows to the SQL\n     * shape via `SqlMigrationPlannerPlanOptions`. Used to populate\n     * `describe().from` on the produced plan as\n     * `fromContract?.storage.storageHash ?? null`.\n     */\n    readonly fromContract: Contract | null;\n    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n  }): SqlitePlanResult {\n    return this.planSql(options as SqlMigrationPlannerPlanOptions);\n  }\n\n  emptyMigration(context: MigrationScaffoldContext): TypeScriptRenderableSqliteMigration {\n    return new TypeScriptRenderableSqliteMigration([], {\n      from: context.fromHash,\n      to: context.toHash,\n    });\n  }\n\n  private planSql(options: SqlMigrationPlannerPlanOptions): SqlitePlanResult {\n    const policyResult = this.ensureAdditivePolicy(options.policy);\n    if (policyResult) return policyResult;\n\n    const schemaIssues = this.collectSchemaIssues(options);\n    const codecHooks = extractCodecControlHooks(options.frameworkComponents);\n    const storageTypes = options.contract.storage.types ?? {};\n\n    const result = planIssues({\n      issues: schemaIssues,\n      toContract: options.contract,\n      fromContract: options.fromContract,\n      codecHooks,\n      storageTypes,\n      schema: options.schema,\n      policy: options.policy,\n      frameworkComponents: options.frameworkComponents,\n      strategies: sqlitePlannerStrategies,\n    });\n\n    if (!result.ok) {\n      return plannerFailure(result.failure);\n    }\n\n    const destination: SqliteMigrationDestinationInfo = {\n      storageHash: options.contract.storage.storageHash,\n      ...(options.contract.profileHash !== undefined\n        ? { profileHash: options.contract.profileHash }\n        : {}),\n    };\n\n    return {\n      kind: 'success' as const,\n      plan: new TypeScriptRenderableSqliteMigration(\n        result.value.calls,\n        {\n          from: options.fromContract?.storage.storageHash ?? null,\n          to: options.contract.storage.storageHash,\n        },\n        destination,\n      ),\n    };\n  }\n\n  private ensureAdditivePolicy(policy: MigrationOperationPolicy): SqlPlannerFailureResult | null {\n    if (!policy.allowedOperationClasses.includes('additive')) {\n      return plannerFailure([\n        {\n          kind: 'unsupportedOperation',\n          summary: 'Migration planner requires additive operations be allowed',\n          why: 'The planner requires the \"additive\" operation class to be allowed in the policy.',\n        },\n      ]);\n    }\n    return null;\n  }\n\n  private collectSchemaIssues(options: SqlMigrationPlannerPlanOptions): readonly SchemaIssue[] {\n    const allowed = options.policy.allowedOperationClasses;\n    const strict = allowed.includes('widening') || allowed.includes('destructive');\n    const verifyResult = verifySqlSchema({\n      contract: options.contract,\n      schema: options.schema,\n      strict,\n      typeMetadataRegistry: new Map(),\n      frameworkComponents: options.frameworkComponents,\n      normalizeDefault: parseSqliteDefault,\n      normalizeNativeType: normalizeSqliteNativeType,\n    });\n    return verifyResult.schema.issues;\n  }\n}\n"],"mappings":"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"}