@prisma/orm-target-sqlite 8.0.0-rc.14-dev.11 → 8.0.0-rc.14-dev.13

package/dist/planner-rTeVmEl6-EkIM6GZa.mjs

@@ -0,0 +1,191 @@
+import { m as renameTableSteps, u as RenameTableCall } from "./op-factory-call-DFDt6p_b-CN07t9pu.mjs";
+import { c as pairIndexReplacements, d as sqlitePlannerStrategies, i as conflictForDisallowedCall, l as planIssues, n as buildSqlitePlanDiff, o as indexNameCaseChange, r as coalesceSubtreeIssues, s as issueNode } from "./sqlite-migration-D1Zk_YEy-BRKDlY8h.mjs";
+import { t as TypeScriptRenderableSqliteMigration } from "./planner-produced-sqlite-migration-v5i-Qz6p-D2ezVWv0.mjs";
+import { issueOutcome } from "@prisma/orm-framework/components/control";
+import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
+import { RelationalSchemaNodeKind, SqlTableIR } from "@prisma/orm-family-sql/schema-ir/types";
+import { detectTableNameCaseChanges, extractCodecControlHooks, planFieldEventOperations, plannerFailure } from "@prisma/orm-family-sql/family/control";
+//#region ../../../3-targets/3-targets/sqlite/dist/planner-rTeVmEl6.mjs
+function createSqliteMigrationPlanner(lowerer) {
+	return new SqliteMigrationPlanner(lowerer);
+}
+/**
+* SQLite migration planner — a thin wrapper over `planIssues`.
+*
+* `plan()` diffs the live schema against the target contract via the one
+* differ (`buildSqlitePlanDiff`, producing node-typed `SchemaDiffIssue[]`)
+* 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 `mapNodeIssueToCall` in
+* the issue planner as a one-off call.
+*
+* FK-backing indexes are already merged into the expected table node's
+* `indexes` at derivation (`contractToSchemaIR`'s `convertTable`), so
+* `mapNodeIssueToCall` handles them uniformly alongside user-declared
+* indexes — no separate expansion step in the planner.
+*/
+var SqliteMigrationPlanner = class {
+	#lowerer;
+	constructor(lowerer) {
+		this.#lowerer = lowerer;
+	}
+	plan(options) {
+		return this.planSql(options);
+	}
+	emptyMigration(context, spaceId) {
+		return new TypeScriptRenderableSqliteMigration([], {
+			from: context.fromHash,
+			to: context.toHash
+		}, spaceId, context.snapshotsImportPath, void 0, this.#lowerer);
+	}
+	planSql(options) {
+		const policyResult = this.ensureAdditivePolicy(options.policy);
+		if (policyResult) return policyResult;
+		const { expected, actual, issues: diffIssues } = this.collectSchemaIssues(options);
+		const replacedIndexes = pairIndexReplacements(diffIssues, indexNameCaseChange);
+		const disallowedIndexCalls = replacedIndexes.calls.filter((call) => !options.policy.allowedOperationClasses.includes(call.operationClass));
+		if (disallowedIndexCalls.length > 0) return plannerFailure(disallowedIndexCalls.map((call) => conflictForDisallowedCall(call, options.policy.allowedOperationClasses)));
+		const issues = diffIssues.filter((issue) => !replacedIndexes.consumed.has(issue));
+		const caseChangeConflicts = detectTableNameCaseChanges({
+			issues,
+			tableOf: (issue) => {
+				const node = issueNode(issue);
+				return node instanceof SqlTableIR ? node : void 0;
+			},
+			namespaceIdOf: () => UNBOUND_NAMESPACE_ID,
+			renameByHandStatements: (rename) => renameTableSteps(rename.from, rename.to).map((renameStep) => renameStep.sql),
+			renameTableCall: (rename) => new RenameTableCall(rename.from, rename.to).renderTypeScript(),
+			contract: options.contract,
+			defaultNamespaceId: UNBOUND_NAMESPACE_ID
+		});
+		if (caseChangeConflicts.length > 0) return plannerFailure(caseChangeConflicts);
+		const codecHooks = extractCodecControlHooks(options.frameworkComponents);
+		const result = planIssues({
+			issues,
+			expected,
+			actual,
+			policy: options.policy,
+			frameworkComponents: options.frameworkComponents,
+			strategies: sqlitePlannerStrategies
+		});
+		if (!result.ok) return plannerFailure(result.failure);
+		const fieldEventOps = planFieldEventOperations({
+			priorContract: options.fromContract,
+			newContract: options.contract,
+			codecHooks
+		});
+		const calls = [
+			...replacedIndexes.calls,
+			...result.value.calls,
+			...fieldEventOps
+		];
+		const destination = {
+			storageHash: options.contract.storage.storageHash,
+			...options.contract.profileHash !== void 0 ? { profileHash: options.contract.profileHash } : {}
+		};
+		return {
+			kind: "success",
+			plan: new TypeScriptRenderableSqliteMigration(calls, {
+				from: options.fromContract?.storage.storageHash ?? null,
+				to: options.contract.storage.storageHash
+			}, options.spaceId, options.snapshotsImportPath, destination, this.#lowerer)
+		};
+	}
+	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;
+	}
+	/**
+	* Diffs the target contract against the live schema via the one differ
+	* (the same tree-building `diffSqliteSchema` uses, plus the
+	* op-render stamper) and prepares the issue list `planIssues` consumes.
+	*
+	* Three passes, in order:
+	* 1. Subtree coalescing — the differ is total (a missing/extra table also
+	*    emits an issue for every column/constraint under it); those nested
+	*    issues are redundant once the table-level `CreateTable`/`DropTable`
+	*    call already accounts for the whole subtree. Runs FIRST, over the
+	*    complete diff: a sibling-owned extra table's column issues must
+	*    collapse into its one table-level issue before the ownership pass,
+	*    because a bare column node carries no table reference — if coalescing
+	*    ran after ownership dropped the table-level issue, the orphaned column
+	*    issues would survive and the planner would emit drops against a
+	*    sibling space's table.
+	* 2. Ownership — a live extra is only this plan's to drop when no contract
+	*    space owns it. The differ ran against THIS space's contract, so a
+	*    table a sibling owns surfaces here as `not-expected`; the planner asks
+	*    the ownership oracle (the passive aggregate) whether any space declares
+	*    it and, if so, leaves it alone. A table no space owns stays a genuine
+	*    extra. Ownership lives in the aggregate; the planner only asks. No
+	*    oracle (single-space) keeps every extra.
+	* 3. Strict-mode extras gating — `not-expected` (extra table/column/
+	*    constraint) issues are dropped entirely outside strict mode, mirroring
+	*    the retired coordinate walk's `if (strict) { ...extra_* } }` guards:
+	*    an additive-only plan must never even consider dropping an unclaimed
+	*    object, not just refuse to emit the drop.
+	*/
+	collectSchemaIssues(options) {
+		const allowed = options.policy.allowedOperationClasses;
+		const strict = allowed.includes("widening") || allowed.includes("destructive");
+		const { expected, actual, issues: rawIssues } = buildSqlitePlanDiff({
+			contract: options.contract,
+			actualSchema: options.schema,
+			frameworkComponents: options.frameworkComponents
+		});
+		const owned = retainUnownedExtras(coalesceSubtreeIssues(rawIssues), options.ownership);
+		return {
+			expected,
+			actual,
+			issues: strict ? owned : owned.filter((issue) => issueOutcome(issue) !== "not-expected")
+		};
+	}
+};
+/**
+* Drops a `not-expected` issue when it is a whole extra TABLE that some
+* contract space owns, asking the ownership oracle per node.
+*
+* The consultation applies ONLY to table-level extras — a live table this
+* space's contract lacks — identified by asking the issue's own node
+* (`nodeKind === table`), never by counting path segments. SQLite is a
+* single-namespace target, so every coordinate is qualified with the shared
+* `UNBOUND_NAMESPACE_ID` sentinel (the same one the aggregate's declared
+* entities carry for this target). `entityKind` is the literal `'table'`:
+* this function only ever asks about a node already confirmed to be
+* `RelationalSchemaNodeKind.table` (checked just above), and that's a
+* diff-tree `nodeKind` spelling (`'sql-table'`) distinct from the storage
+* `entries` vocabulary `elementCoordinates` walks (`'table'`) — the literal
+* is that storage-entries spelling. `declaresEntity` answers over the whole
+* composition (self included), so a positive answer on such a table means
+* another space owns it (a table this space owned would be in its expected
+* tree, never an extra): leave it. A negative answer means no space owns
+* it — a genuine orphan to drop.
+*
+* A DEEPER extra (an extra column/constraint on a table this space DOES own —
+* only the child drifted, so the table is in the expected tree) is this
+* space's own drift and is always kept for dropping; asking the oracle there
+* would wrongly suppress it, because the owned table answers `true`. No oracle
+* ⇒ every extra is kept (single-space plan).
+*/
+function retainUnownedExtras(issues, ownership) {
+	if (ownership === void 0) return issues;
+	return issues.filter((issue) => {
+		if (issueOutcome(issue) !== "not-expected") return true;
+		const node = issueNode(issue);
+		if (node === void 0 || node.nodeKind !== RelationalSchemaNodeKind.table) return true;
+		const tableName = issue.path[1];
+		return tableName === void 0 || !ownership.declaresEntity({
+			namespaceId: UNBOUND_NAMESPACE_ID,
+			entityKind: "table",
+			entityName: tableName
+		});
+	});
+}
+//#endregion
+export { createSqliteMigrationPlanner as n, SqliteMigrationPlanner as t };
+
+//# sourceMappingURL=planner-rTeVmEl6-EkIM6GZa.mjs.map

package/dist/planner-rTeVmEl6-EkIM6GZa.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-rTeVmEl6-EkIM6GZa.mjs","names":["#lowerer"],"sources":["../../../../3-targets/3-targets/sqlite/dist/planner-rTeVmEl6.mjs"],"sourcesContent":["import { p as renameTableSteps, u as RenameTableCall } from \"./op-factory-call-DFDt6p_b.mjs\";\nimport { a as conflictForDisallowedCall, c as sqlitePlannerStrategies, i as coalesceSubtreeIssues, l as buildSqlitePlanDiff, n as indexNameCaseChange, o as issueNode, r as pairIndexReplacements, s as planIssues } from \"./sqlite-migration-D1Zk_YEy.mjs\";\nimport { t as TypeScriptRenderableSqliteMigration } from \"./planner-produced-sqlite-migration-v5i-Qz6p.mjs\";\nimport { issueOutcome } from \"@internal/framework-components/control\";\nimport { detectTableNameCaseChanges, extractCodecControlHooks, planFieldEventOperations, plannerFailure } from \"@internal/family-sql/control\";\nimport { RelationalSchemaNodeKind, SqlTableIR } from \"@internal/sql-schema-ir/types\";\nimport { UNBOUND_NAMESPACE_ID } from \"@internal/framework-components/ir\";\n//#region src/core/migrations/planner.ts\nfunction createSqliteMigrationPlanner(lowerer) {\n\treturn new SqliteMigrationPlanner(lowerer);\n}\n/**\n* SQLite migration planner — a thin wrapper over `planIssues`.\n*\n* `plan()` diffs the live schema against the target contract via the one\n* differ (`buildSqlitePlanDiff`, producing node-typed `SchemaDiffIssue[]`)\n* and delegates to `planIssues` with the registered strategies. Strategies\n* absorb groups of related issues into composite recipes (e.g. recreating a\n* table to apply type/nullability/default/constraint changes at once);\n* anything not absorbed by a strategy flows through `mapNodeIssueToCall` in\n* the issue planner as a one-off call.\n*\n* FK-backing indexes are already merged into the expected table node's\n* `indexes` at derivation (`contractToSchemaIR`'s `convertTable`), so\n* `mapNodeIssueToCall` handles them uniformly alongside user-declared\n* indexes — no separate expansion step in the planner.\n*/\nvar SqliteMigrationPlanner = class {\n\t#lowerer;\n\tconstructor(lowerer) {\n\t\tthis.#lowerer = lowerer;\n\t}\n\tplan(options) {\n\t\treturn this.planSql(options);\n\t}\n\temptyMigration(context, spaceId) {\n\t\treturn new TypeScriptRenderableSqliteMigration([], {\n\t\t\tfrom: context.fromHash,\n\t\t\tto: context.toHash\n\t\t}, spaceId, context.snapshotsImportPath, void 0, this.#lowerer);\n\t}\n\tplanSql(options) {\n\t\tconst policyResult = this.ensureAdditivePolicy(options.policy);\n\t\tif (policyResult) return policyResult;\n\t\tconst { expected, actual, issues: diffIssues } = this.collectSchemaIssues(options);\n\t\tconst replacedIndexes = pairIndexReplacements(diffIssues, indexNameCaseChange);\n\t\tconst disallowedIndexCalls = replacedIndexes.calls.filter((call) => !options.policy.allowedOperationClasses.includes(call.operationClass));\n\t\tif (disallowedIndexCalls.length > 0) return plannerFailure(disallowedIndexCalls.map((call) => conflictForDisallowedCall(call, options.policy.allowedOperationClasses)));\n\t\tconst issues = diffIssues.filter((issue) => !replacedIndexes.consumed.has(issue));\n\t\tconst caseChangeConflicts = detectTableNameCaseChanges({\n\t\t\tissues,\n\t\t\ttableOf: (issue) => {\n\t\t\t\tconst node = issueNode(issue);\n\t\t\t\treturn node instanceof SqlTableIR ? node : void 0;\n\t\t\t},\n\t\t\tnamespaceIdOf: () => UNBOUND_NAMESPACE_ID,\n\t\t\trenameByHandStatements: (rename) => renameTableSteps(rename.from, rename.to).map((renameStep) => renameStep.sql),\n\t\t\trenameTableCall: (rename) => new RenameTableCall(rename.from, rename.to).renderTypeScript(),\n\t\t\tcontract: options.contract,\n\t\t\tdefaultNamespaceId: UNBOUND_NAMESPACE_ID\n\t\t});\n\t\tif (caseChangeConflicts.length > 0) return plannerFailure(caseChangeConflicts);\n\t\tconst codecHooks = extractCodecControlHooks(options.frameworkComponents);\n\t\tconst result = planIssues({\n\t\t\tissues,\n\t\t\texpected,\n\t\t\tactual,\n\t\t\tpolicy: options.policy,\n\t\t\tframeworkComponents: options.frameworkComponents,\n\t\t\tstrategies: sqlitePlannerStrategies\n\t\t});\n\t\tif (!result.ok) return plannerFailure(result.failure);\n\t\tconst fieldEventOps = planFieldEventOperations({\n\t\t\tpriorContract: options.fromContract,\n\t\t\tnewContract: options.contract,\n\t\t\tcodecHooks\n\t\t});\n\t\tconst calls = [\n\t\t\t...replacedIndexes.calls,\n\t\t\t...result.value.calls,\n\t\t\t...fieldEventOps\n\t\t];\n\t\tconst destination = {\n\t\t\tstorageHash: options.contract.storage.storageHash,\n\t\t\t...options.contract.profileHash !== void 0 ? { profileHash: options.contract.profileHash } : {}\n\t\t};\n\t\treturn {\n\t\t\tkind: \"success\",\n\t\t\tplan: new TypeScriptRenderableSqliteMigration(calls, {\n\t\t\t\tfrom: options.fromContract?.storage.storageHash ?? null,\n\t\t\t\tto: options.contract.storage.storageHash\n\t\t\t}, options.spaceId, options.snapshotsImportPath, destination, this.#lowerer)\n\t\t};\n\t}\n\tensureAdditivePolicy(policy) {\n\t\tif (!policy.allowedOperationClasses.includes(\"additive\")) return plannerFailure([{\n\t\t\tkind: \"unsupportedOperation\",\n\t\t\tsummary: \"Migration planner requires additive operations be allowed\",\n\t\t\twhy: \"The planner requires the \\\"additive\\\" operation class to be allowed in the policy.\"\n\t\t}]);\n\t\treturn null;\n\t}\n\t/**\n\t* Diffs the target contract against the live schema via the one differ\n\t* (the same tree-building `diffSqliteSchema` uses, plus the\n\t* op-render stamper) and prepares the issue list `planIssues` consumes.\n\t*\n\t* Three passes, in order:\n\t* 1. Subtree coalescing — the differ is total (a missing/extra table also\n\t*    emits an issue for every column/constraint under it); those nested\n\t*    issues are redundant once the table-level `CreateTable`/`DropTable`\n\t*    call already accounts for the whole subtree. Runs FIRST, over the\n\t*    complete diff: a sibling-owned extra table's column issues must\n\t*    collapse into its one table-level issue before the ownership pass,\n\t*    because a bare column node carries no table reference — if coalescing\n\t*    ran after ownership dropped the table-level issue, the orphaned column\n\t*    issues would survive and the planner would emit drops against a\n\t*    sibling space's table.\n\t* 2. Ownership — a live extra is only this plan's to drop when no contract\n\t*    space owns it. The differ ran against THIS space's contract, so a\n\t*    table a sibling owns surfaces here as `not-expected`; the planner asks\n\t*    the ownership oracle (the passive aggregate) whether any space declares\n\t*    it and, if so, leaves it alone. A table no space owns stays a genuine\n\t*    extra. Ownership lives in the aggregate; the planner only asks. No\n\t*    oracle (single-space) keeps every extra.\n\t* 3. Strict-mode extras gating — `not-expected` (extra table/column/\n\t*    constraint) issues are dropped entirely outside strict mode, mirroring\n\t*    the retired coordinate walk's `if (strict) { ...extra_* } }` guards:\n\t*    an additive-only plan must never even consider dropping an unclaimed\n\t*    object, not just refuse to emit the drop.\n\t*/\n\tcollectSchemaIssues(options) {\n\t\tconst allowed = options.policy.allowedOperationClasses;\n\t\tconst strict = allowed.includes(\"widening\") || allowed.includes(\"destructive\");\n\t\tconst { expected, actual, issues: rawIssues } = buildSqlitePlanDiff({\n\t\t\tcontract: options.contract,\n\t\t\tactualSchema: options.schema,\n\t\t\tframeworkComponents: options.frameworkComponents\n\t\t});\n\t\tconst owned = retainUnownedExtras(coalesceSubtreeIssues(rawIssues), options.ownership);\n\t\treturn {\n\t\t\texpected,\n\t\t\tactual,\n\t\t\tissues: strict ? owned : owned.filter((issue) => issueOutcome(issue) !== \"not-expected\")\n\t\t};\n\t}\n};\n/**\n* Drops a `not-expected` issue when it is a whole extra TABLE that some\n* contract space owns, asking the ownership oracle per node.\n*\n* The consultation applies ONLY to table-level extras — a live table this\n* space's contract lacks — identified by asking the issue's own node\n* (`nodeKind === table`), never by counting path segments. SQLite is a\n* single-namespace target, so every coordinate is qualified with the shared\n* `UNBOUND_NAMESPACE_ID` sentinel (the same one the aggregate's declared\n* entities carry for this target). `entityKind` is the literal `'table'`:\n* this function only ever asks about a node already confirmed to be\n* `RelationalSchemaNodeKind.table` (checked just above), and that's a\n* diff-tree `nodeKind` spelling (`'sql-table'`) distinct from the storage\n* `entries` vocabulary `elementCoordinates` walks (`'table'`) — the literal\n* is that storage-entries spelling. `declaresEntity` answers over the whole\n* composition (self included), so a positive answer on such a table means\n* another space owns it (a table this space owned would be in its expected\n* tree, never an extra): leave it. A negative answer means no space owns\n* it — a genuine orphan to drop.\n*\n* A DEEPER extra (an extra column/constraint on a table this space DOES own —\n* only the child drifted, so the table is in the expected tree) is this\n* space's own drift and is always kept for dropping; asking the oracle there\n* would wrongly suppress it, because the owned table answers `true`. No oracle\n* ⇒ every extra is kept (single-space plan).\n*/\nfunction retainUnownedExtras(issues, ownership) {\n\tif (ownership === void 0) return issues;\n\treturn issues.filter((issue) => {\n\t\tif (issueOutcome(issue) !== \"not-expected\") return true;\n\t\tconst node = issueNode(issue);\n\t\tif (node === void 0 || node.nodeKind !== RelationalSchemaNodeKind.table) return true;\n\t\tconst tableName = issue.path[1];\n\t\treturn tableName === void 0 || !ownership.declaresEntity({\n\t\t\tnamespaceId: UNBOUND_NAMESPACE_ID,\n\t\t\tentityKind: \"table\",\n\t\t\tentityName: tableName\n\t\t});\n\t});\n}\n//#endregion\nexport { createSqliteMigrationPlanner as n, SqliteMigrationPlanner as t };\n\n//# sourceMappingURL=planner-rTeVmEl6.mjs.map"],"mappings":"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"}

package/dist/{sqlite-migration-Du67NG7r-CqcA5XBz.d.mts → sqlite-migration-2IEGvjRm-BQfd6NLr.d.mts}

@@ -4,11 +4,11 @@ import { t as SqliteContractView } from "./sqlite-contract-view-BpNMaU2m-COMDaGa
 import { DdlColumn, DdlTableConstraint } from "@prisma/orm-family-sql/relational-core/ast";
 import { ControlStack } from "@prisma/orm-framework/components/control";
 import { SqlStorage } from "@prisma/orm-family-sql/contract/types";
-import { Migration } from "@prisma/orm-family-sql/family/migration";
 import { MigrationOperationClass, SqlMigrationPlanOperation } from "@prisma/orm-family-sql/family/control";
+import { Migration } from "@prisma/orm-family-sql/family/migration";
 import { Contract } from "@prisma/orm-framework/contract/types";
 import { SqlControlAdapter } from "@prisma/orm-family-sql/family/control-adapter";
-//#region ../../../3-targets/3-targets/sqlite/dist/sqlite-migration-Du67NG7r.d.mts
+//#region ../../../3-targets/3-targets/sqlite/dist/sqlite-migration-2IEGvjRm.d.mts
 //#region src/core/migrations/sqlite-migration.d.ts
 type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
 /**
@@ -44,6 +44,7 @@ declare abstract class SqliteMigration<Start extends Contract<SqlStorage> = Cont
    */
   protected readonly controlAdapter: SqlControlAdapter<'sqlite'> | undefined;
   constructor(stack?: ControlStack<'sql', 'sqlite'>);
+  private frameworkComponents;
   /**
    * Returns the materialized control adapter, or throws a MIGRATION.SQLITE_CONTROL_STACK_MISSING naming
    * `operation` when the migration was constructed without a `ControlStack`.
@@ -70,6 +71,13 @@ declare abstract class SqliteMigration<Start extends Contract<SqlStorage> = Cont
   protected dropTable(options: {
     readonly table: string;
   }): Promise<Op>;
+  /**
+   * Emit the operations that rename a table: the table rename, then a drop and a create under the new name of each index whose name was derived from the old table name, read from this migration's start and end contracts. Spread the result into `operations`: `...this.renameTable({ table: 'userProfile', to: 'UserProfile' })`. Throws `MIGRATION.TABLE_RENAME_UNMATCHED` when the start contract lacks the table or the end contract lacks the new name.
+   */
+  protected renameTable(options: {
+    readonly table: string;
+    readonly to: string;
+  }): readonly Promise<Op>[];
   protected addColumn(options: {
     readonly table: string;
     readonly column: SqliteColumnSpec;
@@ -99,4 +107,4 @@ declare abstract class SqliteMigration<Start extends Contract<SqlStorage> = Cont
 }
 //#endregion
 export { SqliteMigration as t };
-//# sourceMappingURL=sqlite-migration-Du67NG7r-CqcA5XBz.d.mts.map
+//# sourceMappingURL=sqlite-migration-2IEGvjRm-BQfd6NLr.d.mts.map

package/dist/sqlite-migration-2IEGvjRm-BQfd6NLr.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-migration-2IEGvjRm-BQfd6NLr.d.mts","names":[],"sources":["../../../../3-targets/3-targets/sqlite/dist/sqlite-migration-2IEGvjRm.d.mts"],"mappings":";;;;;;;;;;;;KAWK,KAAK,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;uBAuBb,gBAAgB,cAAc,SAAS,cAAc,SAAS,aAAa,YAAY,SAAS,cAAc,SAAS,qBAAqB,UAAU,mCAAmC,OAAO;;WAE5M;;;;;;;qBAOU,gBAAgB;EACnC,YAAY,QAAQ;UACZ;;;;;;UAMA;;;;;;MAMJ,eAAe,mBAAmB;;;;;MAKlC,iBAAiB,mBAAmB;YAC9B,YAAY;aACX;aACA;aACA,kBAAkB;aAClB,uBAAuB;MAC9B,QAAQ;YACF,UAAU;aACT;MACP,QAAQ;;;;YAIF,YAAY;aACX;aACA;eACE,QAAQ;YACX,UAAU;aACT;aACA,QAAQ;MACf,QAAQ;YACF,WAAW;aACV;aACA;MACP,QAAQ;YACF,YAAY;aACX;aACA;aACA;MACP,QAAQ;YACF,UAAU;aACT;aACA;MACP,QAAQ;YACF,cAAc;aACb;aACA,eAAe;aACf;aACA,kBAAkB;aAClB;aACA,qBAAqB;aACrB,gBAAgB;MACvB,QAAQ"}

package/dist/{planner-CWfPzOwZ-DVj6Tm5a.mjs → sqlite-migration-D1Zk_YEy-BRKDlY8h.mjs}

@@ -1,19 +1,22 @@
-import { n as sqliteError } from "./errors-DnR-sMHS-KkMLIP2U.mjs";
+import { n as sqliteError, t as errorSqliteMigrationStackMissing } from "./errors-DnR-sMHS-KkMLIP2U.mjs";
 import { n as sqliteResolveDefault } from "./default-normalizer-Bbo6WzxJ-MgaICRCQ.mjs";
-import { a as DropColumnCall, d as buildRecreatePostchecks, f as buildRecreateSummary, i as DataTransformCall, l as RecreateTableCall, m as sqliteDefaultToDdlColumnDefault, n as CreateIndexCall, o as DropIndexCall, p as renderDefaultLiteral, r as CreateTableCall, s as DropTableCall, t as AddColumnCall, u as buildColumnTypeSql } from "./op-factory-call-Dv_ma_mw-BtLqNmZI.mjs";
+import { _ as sqliteIdentifiersCollide, a as DropColumnCall, d as buildColumnTypeSql, f as buildRecreatePostchecks, g as sqliteDefaultToDdlColumnDefault, h as renderDefaultLiteral, i as DataTransformCall, l as RecreateTableCall, n as CreateIndexCall, o as DropIndexCall, p as buildRecreateSummary, r as CreateTableCall, s as DropTableCall, t as AddColumnCall, u as RenameTableCall } from "./op-factory-call-DFDt6p_b-CN07t9pu.mjs";
 import { t as CONTROL_TABLE_NAMES } from "./control-tables-D_o8dKRB-BXi43noL.mjs";
-import { t as TypeScriptRenderableSqliteMigration } from "./planner-produced-sqlite-migration-D1iuFT1l-BSFCXgJD.mjs";
+import { n as SqliteContractView } from "./sqlite-contract-view-BYR10usg-BteDAUZr.mjs";
 import { DdlColumn, ForeignKeyConstraint, PrimaryKeyConstraint, UniqueConstraint } from "@prisma/orm-family-sql/relational-core/ast";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { diffSchemas, issueOutcome, orderIssuesByDependencies } from "@prisma/orm-framework/components/control";
-import { UNBOUND_NAMESPACE_ID, entityAt } from "@prisma/orm-framework/components/ir";
-import { RelationalSchemaNodeKind, SqlSchemaIR, SqlTableIR, contractDefaultRefusal, relationalNodeGranularity } from "@prisma/orm-family-sql/schema-ir/types";
+import { entityAt } from "@prisma/orm-framework/components/ir";
+import { RelationalSchemaNodeKind, SqlIndexIR, SqlSchemaIR, contractDefaultRefusal, relationalNodeGranularity } from "@prisma/orm-family-sql/schema-ir/types";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
-import { buildDataTypeResolver, buildNativeTypeExpander, contractToSchemaIR, detectTableNameCaseChanges, extractCodecControlHooks, planFieldEventOperations, plannerFailure } from "@prisma/orm-family-sql/family/control";
+import { applyTableRename, buildDataTypeResolver, buildNativeTypeExpander, contractToSchemaIR } from "@prisma/orm-family-sql/family/control";
 import { verifySqlSchemaByDiff } from "@prisma/orm-family-sql/family/diff";
+import { parseWireName } from "@prisma/orm-family-sql/schema-ir/naming";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
-//#region ../../../3-targets/3-targets/sqlite/dist/planner-CWfPzOwZ.mjs
+import { Migration } from "@prisma/orm-family-sql/family/migration";
+import { MigrationContractViews } from "@prisma/orm-toolchain/migration-tools/migration";
+//#region ../../../3-targets/3-targets/sqlite/dist/sqlite-migration-D1Zk_YEy.mjs
 /** Renders a column default for the SQLite dialect. */
 function sqliteRenderDefault(def, column) {
 	if (def.kind === "function") {
@@ -672,174 +675,179 @@ function locationForCall(call) {
 	if ("indexName" in call) location.index = call.indexName;
 	return Object.keys(location).length > 0 ? location : void 0;
 }
-function createSqliteMigrationPlanner(lowerer) {
-	return new SqliteMigrationPlanner(lowerer);
+function indexFindings(issues, outcome) {
+	return issues.flatMap((issue) => {
+		const node = issueNode(issue);
+		const tableName = issue.path[1];
+		if (node === void 0 || !SqlIndexIR.is(node) || tableName === void 0) return [];
+		return issueOutcome(issue) === outcome ? [{
+			issue,
+			index: node,
+			tableName
+		}] : [];
+	});
+}
+/**
+* An index on a renamed table whose wire name derives from the table name: the old and the new index share their content hash and differ in name.
+*/
+function renamedTableIndex(renamedTables) {
+	return (old, replacement) => {
+		const oldWire = parseWireName(old.index.name);
+		const replacementWire = parseWireName(replacement.index.name);
+		return renamedTables.has(old.tableName) && old.tableName === replacement.tableName && oldWire !== void 0 && oldWire.hash === replacementWire?.hash && old.index.name !== replacement.index.name;
+	};
+}
+/**
+* An index on the same table whose new name SQLite takes for the old one, as after a table renamed by hand. Its content is not compared: the old index must be dropped before the new one can be created whatever either defines, and the new one is created from its own definition.
+*/
+const indexNameCaseChange = (old, replacement) => old.tableName === replacement.tableName && old.index.name !== replacement.index.name && sqliteIdentifiersCollide(old.index.name, replacement.index.name);
+/**
+* Pairs each index the plan drops with the index that replaces it, and plans every paired drop before every paired create. SQLite cannot rename an index, and it compares index names without regard to the case of ASCII letters, so a replacement whose name differs from the old one only in that case would otherwise collide with it. The paired issues are returned as consumed so the ordinary diff does not plan them again.
+*/
+function pairIndexReplacements(issues, matches) {
+	const missing = indexFindings(issues, "not-found");
+	const pairs = indexFindings(issues, "not-expected").flatMap((old) => {
+		const replacement = missing.find((candidate) => matches(old, candidate));
+		if (replacement === void 0) return [];
+		missing.splice(missing.indexOf(replacement), 1);
+		return [{
+			old,
+			replacement
+		}];
+	});
+	return {
+		calls: [...pairs.map(({ old }) => new DropIndexCall(old.tableName, old.index.name)), ...pairs.map(({ replacement }) => new CreateIndexCall(replacement.tableName, replacement.index.name, replacement.index.columns ?? []))],
+		consumed: new Set(pairs.flatMap(({ old, replacement }) => [old.issue, replacement.issue]))
+	};
 }
 /**
-* SQLite migration planner — a thin wrapper over `planIssues`.
+* The calls a migration's `renameTable` emits: the table rename, then a drop of each wire-named index whose prefix derives from the old table name and a create of it under the new name, since SQLite cannot rename an index. SQLite names no primary key, unique constraint or foreign key the contract leaves unnamed, so those need nothing. Throws `MIGRATION.TABLE_RENAME_UNMATCHED` when the start contract lacks the table or the end contract lacks the new name.
+*/
+function sqliteTableRenameCalls(input) {
+	const applied = applyTableRename({
+		startContract: input.startContract,
+		endContract: input.endContract,
+		rename: input.rename,
+		renameTableReferences: void 0
+	});
+	if (!applied.ok) throw applied.failure;
+	const { rename } = applied.value;
+	const { issues } = buildSqlitePlanDiff({
+		contract: input.endContract,
+		actualSchema: sqliteContractToSchema(applied.value.contract),
+		frameworkComponents: input.frameworkComponents
+	});
+	return [new RenameTableCall(rename.from, rename.to), ...pairIndexReplacements(coalesceSubtreeIssues(issues), renamedTableIndex(/* @__PURE__ */ new Set([rename.to]))).calls];
+}
+/**
+* Target-owned base class for SQLite migrations. Fixes the `SqlMigration`
+* generic to `SqlitePlanTargetDetails` and the abstract `targetId` to the
+* SQLite literal, so both user-authored migrations and renderer-generated
+* scaffolds can extend `SqliteMigration` directly without redeclaring
+* target-local identity.
 *
-* `plan()` diffs the live schema against the target contract via the one
-* differ (`buildSqlitePlanDiff`, producing node-typed `SchemaDiffIssue[]`)
-* 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 `mapNodeIssueToCall` in
-* the issue planner as a one-off call.
+* The constructor materializes a single SQLite `SqlControlAdapter` from
+* `stack.adapter.create(stack)` and stores it; the protected instance methods
+* forward to the corresponding `*Call` with that stored adapter, so user
+* migrations can write `this.createTable({...})` without threading the adapter
+* through every call.
 *
-* FK-backing indexes are already merged into the expected table node's
-* `indexes` at derivation (`contractToSchemaIR`'s `convertTable`), so
-* `mapNodeIssueToCall` handles them uniformly alongside user-declared
-* indexes — no separate expansion step in the planner.
+* Binds the framework base's `Start` / `End` contract generics so a subclass
+* that assigns its snapshot-store `contract.json` imports to
+* `startContractJson` / `endContractJson` gets fully-typed view accessors:
+* `this.endContract` is a `SqliteContractView<End>`
+* (sole namespace unwrapped to the root — `this.endContract.table.<name>`),
+* built lazily from the JSON fields via the shared `MigrationContractViews`
+* helper. Mirrors `MongoMigration`'s view getters; the framework base derives
+* `describe()` from the same JSON.
 */
-var SqliteMigrationPlanner = class {
-	#lowerer;
-	constructor(lowerer) {
-		this.#lowerer = lowerer;
-	}
-	plan(options) {
-		return this.planSql(options);
-	}
-	emptyMigration(context, spaceId) {
-		return new TypeScriptRenderableSqliteMigration([], {
-			from: context.fromHash,
-			to: context.toHash
-		}, spaceId, context.snapshotsImportPath, void 0, this.#lowerer);
-	}
-	planSql(options) {
-		const policyResult = this.ensureAdditivePolicy(options.policy);
-		if (policyResult) return policyResult;
-		const { expected, actual, issues } = this.collectSchemaIssues(options);
-		const caseChangeConflicts = detectTableNameCaseChanges({
-			issues,
-			tableOf: (issue) => {
-				const node = issueNode(issue);
-				return node instanceof SqlTableIR ? node : void 0;
-			},
-			namespaceIdOf: () => UNBOUND_NAMESPACE_ID
-		});
-		if (caseChangeConflicts.length > 0) return plannerFailure(caseChangeConflicts);
-		const codecHooks = extractCodecControlHooks(options.frameworkComponents);
-		const result = planIssues({
-			issues,
-			expected,
-			actual,
-			policy: options.policy,
-			frameworkComponents: options.frameworkComponents,
-			strategies: sqlitePlannerStrategies
-		});
-		if (!result.ok) return plannerFailure(result.failure);
-		const fieldEventOps = planFieldEventOperations({
-			priorContract: options.fromContract,
-			newContract: options.contract,
-			codecHooks
-		});
-		const calls = [...result.value.calls, ...fieldEventOps];
-		const destination = {
-			storageHash: options.contract.storage.storageHash,
-			...options.contract.profileHash !== void 0 ? { profileHash: options.contract.profileHash } : {}
-		};
-		return {
-			kind: "success",
-			plan: new TypeScriptRenderableSqliteMigration(calls, {
-				from: options.fromContract?.storage.storageHash ?? null,
-				to: options.contract.storage.storageHash
-			}, options.spaceId, options.snapshotsImportPath, destination, this.#lowerer)
-		};
+var SqliteMigration = class extends Migration {
+	targetId = "sqlite";
+	/**
+	* Materialized SQLite control adapter, created once per migration
+	* instance from the injected stack. `undefined` only when the migration
+	* was instantiated without a stack (test fixtures); `controlAdapterFor`
+	* throws a MIGRATION.SQLITE_CONTROL_STACK_MISSING in that case to surface the misuse.
+	*/
+	controlAdapter;
+	#endView = new MigrationContractViews(this, "SqliteMigration", (json) => SqliteContractView.fromJson(json));
+	#startView = new MigrationContractViews(this, "SqliteMigration", (json) => SqliteContractView.fromJson(json));
+	constructor(stack) {
+		super(stack);
+		this.controlAdapter = stack?.adapter ? blindCast(stack.adapter.create(stack)) : void 0;
 	}
-	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;
+	frameworkComponents() {
+		const stack = this.stack;
+		if (stack === void 0) return [];
+		return [
+			stack.target,
+			...stack.adapter === void 0 ? [] : [stack.adapter],
+			...stack.extensions
+		];
 	}
 	/**
-	* Diffs the target contract against the live schema via the one differ
-	* (the same tree-building `diffSqliteSchema` uses, plus the
-	* op-render stamper) and prepares the issue list `planIssues` consumes.
-	*
-	* Three passes, in order:
-	* 1. Subtree coalescing — the differ is total (a missing/extra table also
-	*    emits an issue for every column/constraint under it); those nested
-	*    issues are redundant once the table-level `CreateTable`/`DropTable`
-	*    call already accounts for the whole subtree. Runs FIRST, over the
-	*    complete diff: a sibling-owned extra table's column issues must
-	*    collapse into its one table-level issue before the ownership pass,
-	*    because a bare column node carries no table reference — if coalescing
-	*    ran after ownership dropped the table-level issue, the orphaned column
-	*    issues would survive and the planner would emit drops against a
-	*    sibling space's table.
-	* 2. Ownership — a live extra is only this plan's to drop when no contract
-	*    space owns it. The differ ran against THIS space's contract, so a
-	*    table a sibling owns surfaces here as `not-expected`; the planner asks
-	*    the ownership oracle (the passive aggregate) whether any space declares
-	*    it and, if so, leaves it alone. A table no space owns stays a genuine
-	*    extra. Ownership lives in the aggregate; the planner only asks. No
-	*    oracle (single-space) keeps every extra.
-	* 3. Strict-mode extras gating — `not-expected` (extra table/column/
-	*    constraint) issues are dropped entirely outside strict mode, mirroring
-	*    the retired coordinate walk's `if (strict) { ...extra_* } }` guards:
-	*    an additive-only plan must never even consider dropping an unclaimed
-	*    object, not just refuse to emit the drop.
+	* Returns the materialized control adapter, or throws a MIGRATION.SQLITE_CONTROL_STACK_MISSING naming
+	* `operation` when the migration was constructed without a `ControlStack`.
+	* Single home for the null-check that every DDL/DML method shares.
 	*/
-	collectSchemaIssues(options) {
-		const allowed = options.policy.allowedOperationClasses;
-		const strict = allowed.includes("widening") || allowed.includes("destructive");
-		const { expected, actual, issues: rawIssues } = buildSqlitePlanDiff({
-			contract: options.contract,
-			actualSchema: options.schema,
-			frameworkComponents: options.frameworkComponents
-		});
-		const owned = retainUnownedExtras(coalesceSubtreeIssues(rawIssues), options.ownership);
-		return {
-			expected,
-			actual,
-			issues: strict ? owned : owned.filter((issue) => issueOutcome(issue) !== "not-expected")
-		};
+	controlAdapterFor(operation) {
+		if (!this.controlAdapter) throw errorSqliteMigrationStackMissing(operation);
+		return this.controlAdapter;
+	}
+	/**
+	* The typed SQLite view over this migration's end-state contract — sole
+	* namespace unwrapped to the root, so `this.endContract.table.<name>` etc.
+	* Throws if no `endContractJson` was provided.
+	*/
+	get endContract() {
+		return this.#endView.endContract;
+	}
+	/**
+	* The typed SQLite view over this migration's start-state contract, or
+	* `null` for a baseline migration (no `startContractJson`).
+	*/
+	get startContract() {
+		return this.#startView.startContract;
+	}
+	createTable(options) {
+		return new CreateTableCall(options.table, options.columns, options.constraints).toOp(this.controlAdapterFor("createTable"));
+	}
+	dropTable(options) {
+		return new DropTableCall(options.table).toOp(this.controlAdapterFor("dropTable"));
+	}
+	/**
+	* Emit the operations that rename a table: the table rename, then a drop and a create under the new name of each index whose name was derived from the old table name, read from this migration's start and end contracts. Spread the result into `operations`: `...this.renameTable({ table: 'userProfile', to: 'UserProfile' })`. Throws `MIGRATION.TABLE_RENAME_UNMATCHED` when the start contract lacks the table or the end contract lacks the new name.
+	*/
+	renameTable(options) {
+		const adapter = this.controlAdapterFor("renameTable");
+		return sqliteTableRenameCalls({
+			startContract: this.startContract,
+			endContract: this.endContract,
+			rename: {
+				namespaceId: void 0,
+				from: options.table,
+				to: options.to
+			},
+			frameworkComponents: this.frameworkComponents()
+		}).map(async (call) => call.toOp(adapter));
+	}
+	addColumn(options) {
+		return new AddColumnCall(options.table, options.column).toOp(this.controlAdapterFor("addColumn"));
+	}
+	dropColumn(options) {
+		return new DropColumnCall(options.table, options.column).toOp(this.controlAdapterFor("dropColumn"));
+	}
+	createIndex(options) {
+		return new CreateIndexCall(options.table, options.index, options.columns).toOp(this.controlAdapterFor("createIndex"));
+	}
+	dropIndex(options) {
+		return new DropIndexCall(options.table, options.index).toOp(this.controlAdapterFor("dropIndex"));
+	}
+	recreateTable(options) {
+		return new RecreateTableCall(options).toOp(this.controlAdapterFor("recreateTable"));
 	}
 };
-/**
-* Drops a `not-expected` issue when it is a whole extra TABLE that some
-* contract space owns, asking the ownership oracle per node.
-*
-* The consultation applies ONLY to table-level extras — a live table this
-* space's contract lacks — identified by asking the issue's own node
-* (`nodeKind === table`), never by counting path segments. SQLite is a
-* single-namespace target, so every coordinate is qualified with the shared
-* `UNBOUND_NAMESPACE_ID` sentinel (the same one the aggregate's declared
-* entities carry for this target). `entityKind` is the literal `'table'`:
-* this function only ever asks about a node already confirmed to be
-* `RelationalSchemaNodeKind.table` (checked just above), and that's a
-* diff-tree `nodeKind` spelling (`'sql-table'`) distinct from the storage
-* `entries` vocabulary `elementCoordinates` walks (`'table'`) — the literal
-* is that storage-entries spelling. `declaresEntity` answers over the whole
-* composition (self included), so a positive answer on such a table means
-* another space owns it (a table this space owned would be in its expected
-* tree, never an extra): leave it. A negative answer means no space owns
-* it — a genuine orphan to drop.
-*
-* A DEEPER extra (an extra column/constraint on a table this space DOES own —
-* only the child drifted, so the table is in the expected tree) is this
-* space's own drift and is always kept for dropping; asking the oracle there
-* would wrongly suppress it, because the owned table answers `true`. No oracle
-* ⇒ every extra is kept (single-space plan).
-*/
-function retainUnownedExtras(issues, ownership) {
-	if (ownership === void 0) return issues;
-	return issues.filter((issue) => {
-		if (issueOutcome(issue) !== "not-expected") return true;
-		const node = issueNode(issue);
-		if (node === void 0 || node.nodeKind !== RelationalSchemaNodeKind.table) return true;
-		const tableName = issue.path[1];
-		return tableName === void 0 || !ownership.declaresEntity({
-			namespaceId: UNBOUND_NAMESPACE_ID,
-			entityKind: "table",
-			entityName: tableName
-		});
-	});
-}
 //#endregion
-export { verifySqliteDatabaseSchema as a, sqliteContractToSchema as i, createSqliteMigrationPlanner as n, diffSqliteSchema as r, SqliteMigrationPlanner as t };
+export { diffSqliteSchema as a, pairIndexReplacements as c, sqlitePlannerStrategies as d, verifySqliteDatabaseSchema as f, conflictForDisallowedCall as i, planIssues as l, buildSqlitePlanDiff as n, indexNameCaseChange as o, coalesceSubtreeIssues as r, issueNode as s, SqliteMigration as t, sqliteContractToSchema as u };
 
-//# sourceMappingURL=planner-CWfPzOwZ-DVj6Tm5a.mjs.map
+//# sourceMappingURL=sqlite-migration-D1Zk_YEy-BRKDlY8h.mjs.map