@prisma-next/target-sqlite 0.5.0-dev.6 → 0.5.0-dev.60

package/dist/planner-produced-sqlite-migration-C3AAaQoW.mjs

@@ -0,0 +1,107 @@
+import { t as renderOps } from "./render-ops-CXOv7SRC.mjs";
+import { t as SqliteMigration } from "./sqlite-migration-CnLhIrJF.mjs";
+import { jsonToTsSource, renderImports } from "@prisma-next/ts-render";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { detectScaffoldRuntime, shebangLineFor } from "@prisma-next/migration-tools/migration-ts";
+
+//#region src/core/migrations/render-typescript.ts
+/**
+* Polymorphic TypeScript emitter for the SQLite migration IR. Mirrors the
+* Postgres `render-typescript.ts` — different base-class + factory module
+* specifier, same overall shape.
+*/
+/**
+* Always-present base imports for the rendered scaffold. Both come from
+* `@prisma-next/target-sqlite/migration` so an authored SQLite
+* `migration.ts` only needs a single dependency for its base class and
+* its CLI entrypoint. Mirrors Postgres's `BASE_IMPORTS`.
+*
+* - `Migration` — the target-owned re-export fixes the `SqlMigration`
+*   generic to `SqlitePlanTargetDetails` and the abstract `targetId` to
+*   `'sqlite'`.
+* - `MigrationCLI` — the migration-file CLI entrypoint, re-exported from
+*   `@prisma-next/cli/migration-cli`. Loads `prisma-next.config.ts`,
+*   assembles a `ControlStack`, and instantiates the migration class.
+*/
+const BASE_IMPORTS = [{
+	moduleSpecifier: "@prisma-next/target-sqlite/migration",
+	symbol: "Migration"
+}, {
+	moduleSpecifier: "@prisma-next/target-sqlite/migration",
+	symbol: "MigrationCLI"
+}];
+function renderCallsToTypeScript(calls, meta) {
+	const imports = buildImports(calls);
+	const operationsBody = calls.map((c) => c.renderTypeScript()).join(",\n");
+	return [
+		shebangLineFor(detectScaffoldRuntime()),
+		imports,
+		"",
+		"export default class M extends Migration {",
+		buildDescribeMethod(meta),
+		"  override get operations() {",
+		"    return [",
+		indent(operationsBody, 6),
+		"    ];",
+		"  }",
+		"}",
+		"",
+		"MigrationCLI.run(import.meta.url, M);",
+		""
+	].join("\n");
+}
+function buildImports(calls) {
+	const requirements = [...BASE_IMPORTS];
+	for (const call of calls) for (const req of call.importRequirements()) requirements.push(req);
+	return renderImports(requirements);
+}
+function buildDescribeMethod(meta) {
+	const lines = [];
+	lines.push("  override describe() {");
+	lines.push("    return {");
+	lines.push(`      from: ${JSON.stringify(meta.from)},`);
+	lines.push(`      to: ${JSON.stringify(meta.to)},`);
+	if (meta.labels && meta.labels.length > 0) lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);
+	lines.push("    };");
+	lines.push("  }");
+	lines.push("");
+	return lines.join("\n");
+}
+function indent(text, spaces) {
+	const pad = " ".repeat(spaces);
+	return text.split("\n").map((line) => line.trim() ? `${pad}${line}` : line).join("\n");
+}
+
+//#endregion
+//#region src/core/migrations/planner-produced-sqlite-migration.ts
+var TypeScriptRenderableSqliteMigration = class extends SqliteMigration {
+	#calls;
+	#meta;
+	#destination;
+	constructor(calls, meta, destination) {
+		super();
+		this.#calls = calls;
+		this.#meta = meta;
+		this.#destination = destination ?? { storageHash: meta.to };
+	}
+	get operations() {
+		return renderOps(this.#calls);
+	}
+	describe() {
+		return this.#meta;
+	}
+	get destination() {
+		return this.#destination;
+	}
+	renderTypeScript() {
+		return renderCallsToTypeScript(this.#calls, {
+			from: this.#meta.from,
+			to: this.#meta.to,
+			...ifDefined("labels", this.#meta.labels)
+		});
+	}
+};
+
+//#endregion
+export { TypeScriptRenderableSqliteMigration as t };
+//# sourceMappingURL=planner-produced-sqlite-migration-C3AAaQoW.mjs.map

package/dist/planner-produced-sqlite-migration-C3AAaQoW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-produced-sqlite-migration-C3AAaQoW.mjs","names":["BASE_IMPORTS: readonly ImportRequirement[]","requirements: ImportRequirement[]","lines: string[]","#calls","#meta","#destination"],"sources":["../src/core/migrations/render-typescript.ts","../src/core/migrations/planner-produced-sqlite-migration.ts"],"sourcesContent":["/**\n * Polymorphic TypeScript emitter for the SQLite migration IR. Mirrors the\n * Postgres `render-typescript.ts` — different base-class + factory module\n * specifier, same overall shape.\n */\n\nimport { detectScaffoldRuntime, shebangLineFor } from '@prisma-next/migration-tools/migration-ts';\nimport { type ImportRequirement, jsonToTsSource, renderImports } from '@prisma-next/ts-render';\nimport type { SqliteOpFactoryCall } from './op-factory-call';\n\nexport interface RenderMigrationMeta {\n  readonly from: string | null;\n  readonly to: string;\n  readonly labels?: readonly string[];\n}\n\n/**\n * Always-present base imports for the rendered scaffold. Both come from\n * `@prisma-next/target-sqlite/migration` so an authored SQLite\n * `migration.ts` only needs a single dependency for its base class and\n * its CLI entrypoint. Mirrors Postgres's `BASE_IMPORTS`.\n *\n * - `Migration` — the target-owned re-export fixes the `SqlMigration`\n *   generic to `SqlitePlanTargetDetails` and the abstract `targetId` to\n *   `'sqlite'`.\n * - `MigrationCLI` — the migration-file CLI entrypoint, re-exported from\n *   `@prisma-next/cli/migration-cli`. Loads `prisma-next.config.ts`,\n *   assembles a `ControlStack`, and instantiates the migration class.\n */\nconst BASE_IMPORTS: readonly ImportRequirement[] = [\n  { moduleSpecifier: '@prisma-next/target-sqlite/migration', symbol: 'Migration' },\n  { moduleSpecifier: '@prisma-next/target-sqlite/migration', symbol: 'MigrationCLI' },\n];\n\nexport function renderCallsToTypeScript(\n  calls: ReadonlyArray<SqliteOpFactoryCall>,\n  meta: RenderMigrationMeta,\n): string {\n  const imports = buildImports(calls);\n  const operationsBody = calls.map((c) => c.renderTypeScript()).join(',\\n');\n\n  return [\n    shebangLineFor(detectScaffoldRuntime()),\n    imports,\n    '',\n    'export default class M extends Migration {',\n    buildDescribeMethod(meta),\n    '  override get operations() {',\n    '    return [',\n    indent(operationsBody, 6),\n    '    ];',\n    '  }',\n    '}',\n    '',\n    'MigrationCLI.run(import.meta.url, M);',\n    '',\n  ].join('\\n');\n}\n\nfunction buildImports(calls: ReadonlyArray<SqliteOpFactoryCall>): string {\n  const requirements: ImportRequirement[] = [...BASE_IMPORTS];\n  for (const call of calls) {\n    for (const req of call.importRequirements()) {\n      requirements.push(req);\n    }\n  }\n  return renderImports(requirements);\n}\n\nfunction buildDescribeMethod(meta: RenderMigrationMeta): string {\n  const lines: string[] = [];\n  lines.push('  override describe() {');\n  lines.push('    return {');\n  lines.push(`      from: ${JSON.stringify(meta.from)},`);\n  lines.push(`      to: ${JSON.stringify(meta.to)},`);\n  if (meta.labels && meta.labels.length > 0) {\n    lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);\n  }\n  lines.push('    };');\n  lines.push('  }');\n  lines.push('');\n  return lines.join('\\n');\n}\n\nfunction indent(text: string, spaces: number): string {\n  const pad = ' '.repeat(spaces);\n  return text\n    .split('\\n')\n    .map((line) => (line.trim() ? `${pad}${line}` : line))\n    .join('\\n');\n}\n","import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { MigrationPlanWithAuthoringSurface } from '@prisma-next/framework-components/control';\nimport type { MigrationMeta } from '@prisma-next/migration-tools/migration';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { SqliteOpFactoryCall } from './op-factory-call';\nimport type { SqlitePlanTargetDetails } from './planner-target-details';\nimport { renderOps } from './render-ops';\nimport { renderCallsToTypeScript } from './render-typescript';\nimport { SqliteMigration } from './sqlite-migration';\n\ntype Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;\n\nexport interface SqliteMigrationDestinationInfo {\n  readonly storageHash: string;\n  readonly profileHash?: string;\n}\n\nexport class TypeScriptRenderableSqliteMigration\n  extends SqliteMigration\n  implements MigrationPlanWithAuthoringSurface\n{\n  readonly #calls: readonly SqliteOpFactoryCall[];\n  readonly #meta: MigrationMeta;\n  readonly #destination: SqliteMigrationDestinationInfo;\n\n  constructor(\n    calls: readonly SqliteOpFactoryCall[],\n    meta: MigrationMeta,\n    destination?: SqliteMigrationDestinationInfo,\n  ) {\n    super();\n    this.#calls = calls;\n    this.#meta = meta;\n    this.#destination = destination ?? { storageHash: meta.to };\n  }\n\n  override get operations(): readonly Op[] {\n    return renderOps(this.#calls);\n  }\n\n  override describe(): MigrationMeta {\n    return this.#meta;\n  }\n\n  override get destination(): SqliteMigrationDestinationInfo {\n    return this.#destination;\n  }\n\n  renderTypeScript(): string {\n    return renderCallsToTypeScript(this.#calls, {\n      from: this.#meta.from,\n      to: this.#meta.to,\n      ...ifDefined('labels', this.#meta.labels),\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAMA,eAA6C,CACjD;CAAE,iBAAiB;CAAwC,QAAQ;CAAa,EAChF;CAAE,iBAAiB;CAAwC,QAAQ;CAAgB,CACpF;AAED,SAAgB,wBACd,OACA,MACQ;CACR,MAAM,UAAU,aAAa,MAAM;CACnC,MAAM,iBAAiB,MAAM,KAAK,MAAM,EAAE,kBAAkB,CAAC,CAAC,KAAK,MAAM;AAEzE,QAAO;EACL,eAAe,uBAAuB,CAAC;EACvC;EACA;EACA;EACA,oBAAoB,KAAK;EACzB;EACA;EACA,OAAO,gBAAgB,EAAE;EACzB;EACA;EACA;EACA;EACA;EACA;EACD,CAAC,KAAK,KAAK;;AAGd,SAAS,aAAa,OAAmD;CACvE,MAAMC,eAAoC,CAAC,GAAG,aAAa;AAC3D,MAAK,MAAM,QAAQ,MACjB,MAAK,MAAM,OAAO,KAAK,oBAAoB,CACzC,cAAa,KAAK,IAAI;AAG1B,QAAO,cAAc,aAAa;;AAGpC,SAAS,oBAAoB,MAAmC;CAC9D,MAAMC,QAAkB,EAAE;AAC1B,OAAM,KAAK,0BAA0B;AACrC,OAAM,KAAK,eAAe;AAC1B,OAAM,KAAK,eAAe,KAAK,UAAU,KAAK,KAAK,CAAC,GAAG;AACvD,OAAM,KAAK,aAAa,KAAK,UAAU,KAAK,GAAG,CAAC,GAAG;AACnD,KAAI,KAAK,UAAU,KAAK,OAAO,SAAS,EACtC,OAAM,KAAK,iBAAiB,eAAe,KAAK,OAAO,CAAC,GAAG;AAE7D,OAAM,KAAK,SAAS;AACpB,OAAM,KAAK,MAAM;AACjB,OAAM,KAAK,GAAG;AACd,QAAO,MAAM,KAAK,KAAK;;AAGzB,SAAS,OAAO,MAAc,QAAwB;CACpD,MAAM,MAAM,IAAI,OAAO,OAAO;AAC9B,QAAO,KACJ,MAAM,KAAK,CACX,KAAK,SAAU,KAAK,MAAM,GAAG,GAAG,MAAM,SAAS,KAAM,CACrD,KAAK,KAAK;;;;;ACxEf,IAAa,sCAAb,cACU,gBAEV;CACE,CAASC;CACT,CAASC;CACT,CAASC;CAET,YACE,OACA,MACA,aACA;AACA,SAAO;AACP,QAAKF,QAAS;AACd,QAAKC,OAAQ;AACb,QAAKC,cAAe,eAAe,EAAE,aAAa,KAAK,IAAI;;CAG7D,IAAa,aAA4B;AACvC,SAAO,UAAU,MAAKF,MAAO;;CAG/B,AAAS,WAA0B;AACjC,SAAO,MAAKC;;CAGd,IAAa,cAA8C;AACzD,SAAO,MAAKC;;CAGd,mBAA2B;AACzB,SAAO,wBAAwB,MAAKF,OAAQ;GAC1C,MAAM,MAAKC,KAAM;GACjB,IAAI,MAAKA,KAAM;GACf,GAAG,UAAU,UAAU,MAAKA,KAAM,OAAO;GAC1C,CAAC"}

package/dist/planner-produced-sqlite-migration-RVneETNy.d.mts

@@ -0,0 +1,24 @@
+import { t as SqlitePlanTargetDetails } from "./planner-target-details-DTIFFx4L.mjs";
+import { t as SqliteMigration } from "./sqlite-migration-BYgrMZdR.mjs";
+import { l as SqliteOpFactoryCall } from "./op-factory-call-BPPSCdTB.mjs";
+import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
+import { MigrationPlanWithAuthoringSurface } from "@prisma-next/framework-components/control";
+import { MigrationMeta } from "@prisma-next/migration-tools/migration";
+
+//#region src/core/migrations/planner-produced-sqlite-migration.d.ts
+type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
+interface SqliteMigrationDestinationInfo {
+  readonly storageHash: string;
+  readonly profileHash?: string;
+}
+declare class TypeScriptRenderableSqliteMigration extends SqliteMigration implements MigrationPlanWithAuthoringSurface {
+  #private;
+  constructor(calls: readonly SqliteOpFactoryCall[], meta: MigrationMeta, destination?: SqliteMigrationDestinationInfo);
+  get operations(): readonly Op[];
+  describe(): MigrationMeta;
+  get destination(): SqliteMigrationDestinationInfo;
+  renderTypeScript(): string;
+}
+//#endregion
+export { TypeScriptRenderableSqliteMigration as n, SqliteMigrationDestinationInfo as t };
+//# sourceMappingURL=planner-produced-sqlite-migration-RVneETNy.d.mts.map

package/dist/planner-produced-sqlite-migration-RVneETNy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-produced-sqlite-migration-RVneETNy.d.mts","names":[],"sources":["../src/core/migrations/planner-produced-sqlite-migration.ts"],"sourcesContent":[],"mappings":";;;;;;;;KAUK,EAAA,GAAK,0BAA0B;UAEnB,8BAAA;EAFZ,SAAE,WAA6B,EAAA,MAAA;EAEnB,SAAA,WAAA,CAAA,EAAA,MAAA;AAKjB;AASoB,cATP,mCAAA,SACH,eAAA,YACG,iCAOO,CAAA;EACV,CAAA,OAAA;EACQ,WAAA,CAAA,KAAA,EAAA,SAFE,mBAEF,EAAA,EAAA,IAAA,EADR,aACQ,EAAA,WAAA,CAAA,EAAA,8BAAA;EAQoB,IAAA,UAAA,CAAA,CAAA,EAAA,SAAA,EAAA,EAAA;EAIf,QAAA,CAAA,CAAA,EAAA,aAAA;EAIO,IAAA,WAAA,CAAA,CAAA,EAAA,8BAAA;EA1BpB,gBAAA,CAAA,CAAA,EAAA,MAAA"}

package/dist/planner-produced-sqlite-migration.d.mts

@@ -0,0 +1,5 @@
+import "./shared-BNtoZqdo.mjs";
+import "./sqlite-migration-BYgrMZdR.mjs";
+import "./op-factory-call-BPPSCdTB.mjs";
+import { n as TypeScriptRenderableSqliteMigration, t as SqliteMigrationDestinationInfo } from "./planner-produced-sqlite-migration-RVneETNy.mjs";
+export { type SqliteMigrationDestinationInfo, TypeScriptRenderableSqliteMigration };

package/dist/planner-produced-sqlite-migration.mjs

@@ -0,0 +1,3 @@
+import { t as TypeScriptRenderableSqliteMigration } from "./planner-produced-sqlite-migration-C3AAaQoW.mjs";
+
+export { TypeScriptRenderableSqliteMigration };

package/dist/planner-target-details-BQIWQlBu.mjs

@@ -0,0 +1,16 @@
+import { ifDefined } from "@prisma-next/utils/defined";
+
+//#region src/core/migrations/planner-target-details.ts
+const DEFAULT_SCHEMA = "main";
+function buildTargetDetails(objectType, name, table) {
+	return {
+		schema: DEFAULT_SCHEMA,
+		objectType,
+		name,
+		...ifDefined("table", table)
+	};
+}
+
+//#endregion
+export { buildTargetDetails as t };
+//# sourceMappingURL=planner-target-details-BQIWQlBu.mjs.map

package/dist/planner-target-details-BQIWQlBu.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-target-details-BQIWQlBu.mjs","names":[],"sources":["../src/core/migrations/planner-target-details.ts"],"sourcesContent":["import { ifDefined } from '@prisma-next/utils/defined';\n\nexport type OperationClass = 'table' | 'column' | 'primaryKey' | 'unique' | 'index' | 'foreignKey';\n\n// SQLite's default (and only) schema name; keeps `SqlitePlanTargetDetails`\n// conformant with `SqlPlanTargetDetails`, which mandates a `schema` field.\nconst DEFAULT_SCHEMA = 'main';\n\nexport interface SqlitePlanTargetDetails {\n  readonly schema: string;\n  readonly objectType: OperationClass;\n  readonly name: string;\n  readonly table?: string;\n}\n\nexport interface PlanningMode {\n  readonly includeExtraObjects: boolean;\n  readonly allowWidening: boolean;\n  readonly allowDestructive: boolean;\n}\n\nexport function buildTargetDetails(\n  objectType: OperationClass,\n  name: string,\n  table?: string,\n): SqlitePlanTargetDetails {\n  return {\n    schema: DEFAULT_SCHEMA,\n    objectType,\n    name,\n    ...ifDefined('table', table),\n  };\n}\n"],"mappings":";;;AAMA,MAAM,iBAAiB;AAevB,SAAgB,mBACd,YACA,MACA,OACyB;AACzB,QAAO;EACL,QAAQ;EACR;EACA;EACA,GAAG,UAAU,SAAS,MAAM;EAC7B"}

package/dist/planner-target-details-DTIFFx4L.d.mts

@@ -0,0 +1,12 @@
+//#region src/core/migrations/planner-target-details.d.ts
+type OperationClass = 'table' | 'column' | 'primaryKey' | 'unique' | 'index' | 'foreignKey';
+interface SqlitePlanTargetDetails {
+  readonly schema: string;
+  readonly objectType: OperationClass;
+  readonly name: string;
+  readonly table?: string;
+}
+declare function buildTargetDetails(objectType: OperationClass, name: string, table?: string): SqlitePlanTargetDetails;
+//#endregion
+export { buildTargetDetails as n, SqlitePlanTargetDetails as t };
+//# sourceMappingURL=planner-target-details-DTIFFx4L.d.mts.map

package/dist/planner-target-details-DTIFFx4L.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-target-details-DTIFFx4L.d.mts","names":[],"sources":["../src/core/migrations/planner-target-details.ts"],"sourcesContent":[],"mappings":";KAEY,cAAA;AAAA,UAMK,uBAAA,CANS;EAMT,SAAA,MAAA,EAAA,MAAA;EAaD,SAAA,UAAA,EAXO,cAYT;;;;iBADE,kBAAA,aACF,+CAGX"}

package/dist/planner-target-details.d.mts

@@ -0,0 +1,2 @@
+import { n as buildTargetDetails, t as SqlitePlanTargetDetails } from "./planner-target-details-DTIFFx4L.mjs";
+export { type SqlitePlanTargetDetails, buildTargetDetails };

package/dist/planner-target-details.mjs

@@ -0,0 +1,3 @@
+import { t as buildTargetDetails } from "./planner-target-details-BQIWQlBu.mjs";
+
+export { buildTargetDetails };

package/dist/planner.d.mts

@@ -0,0 +1,56 @@
+import { t as SqlitePlanTargetDetails } from "./planner-target-details-DTIFFx4L.mjs";
+import "./shared-BNtoZqdo.mjs";
+import "./sqlite-migration-BYgrMZdR.mjs";
+import "./op-factory-call-BPPSCdTB.mjs";
+import { n as TypeScriptRenderableSqliteMigration } from "./planner-produced-sqlite-migration-RVneETNy.mjs";
+import { MigrationOperationPolicy, SqlMigrationPlanner, SqlPlannerFailureResult } from "@prisma-next/family-sql/control";
+import { Contract } from "@prisma-next/contract/types";
+import { MigrationPlanner, MigrationScaffoldContext } from "@prisma-next/framework-components/control";
+import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
+
+//#region src/core/migrations/planner.d.ts
+declare function createSqliteMigrationPlanner(): SqliteMigrationPlanner;
+type SqlitePlanResult = {
+  readonly kind: 'success';
+  readonly plan: TypeScriptRenderableSqliteMigration;
+} | SqlPlannerFailureResult;
+/**
+ * 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.
+ */
+declare class SqliteMigrationPlanner implements SqlMigrationPlanner<SqlitePlanTargetDetails>, MigrationPlanner<'sql', 'sqlite'> {
+  plan(options: {
+    readonly contract: unknown;
+    readonly schema: unknown;
+    readonly policy: MigrationOperationPolicy;
+    /**
+     * The "from" contract (state the planner assumes the database starts at),
+     * or `null` for reconciliation flows.
+     *
+     * Typed as the framework `Contract | null` to satisfy the
+     * `MigrationPlanner` interface contract; `planSql` narrows to the SQL
+     * shape via `SqlMigrationPlannerPlanOptions`. Used to populate
+     * `describe().from` on the produced plan as
+     * `fromContract?.storage.storageHash ?? null`.
+     */
+    readonly fromContract: Contract | null;
+    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+  }): SqlitePlanResult;
+  emptyMigration(context: MigrationScaffoldContext): TypeScriptRenderableSqliteMigration;
+  private planSql;
+  private ensureAdditivePolicy;
+  private collectSchemaIssues;
+}
+//#endregion
+export { SqliteMigrationPlanner, type SqlitePlanResult, createSqliteMigrationPlanner };
+//# sourceMappingURL=planner.d.mts.map

package/dist/planner.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner.d.mts","names":[],"sources":["../src/core/migrations/planner.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;iBAyBgB,4BAAA,CAAA,GAAgC;KAIpC,gBAAA;;iBACmC;IAC3C;AANJ;AAIA;AAkBA;;;;;;;;;;;;cAAa,sBAAA,YACA,oBAAoB,0BAA0B;;;;qBAKtC;;;;;;;;;;;2BAWM;kCACO,cAAc;MAC1C;0BAIoB,2BAA2B"}

package/dist/planner.mjs

@@ -0,0 +1,3 @@
+import { n as createSqliteMigrationPlanner, t as SqliteMigrationPlanner } from "./planner-CuchCrpN.mjs";
+
+export { SqliteMigrationPlanner, createSqliteMigrationPlanner };

package/dist/render-ops-CXOv7SRC.mjs

@@ -0,0 +1,8 @@
+//#region src/core/migrations/render-ops.ts
+function renderOps(calls) {
+	return calls.map((c) => c.toOp());
+}
+
+//#endregion
+export { renderOps as t };
+//# sourceMappingURL=render-ops-CXOv7SRC.mjs.map

package/dist/render-ops-CXOv7SRC.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-ops-CXOv7SRC.mjs","names":[],"sources":["../src/core/migrations/render-ops.ts"],"sourcesContent":["import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { SqliteOpFactoryCall } from './op-factory-call';\nimport type { SqlitePlanTargetDetails } from './planner-target-details';\n\ntype Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;\n\nexport function renderOps(calls: readonly SqliteOpFactoryCall[]): Op[] {\n  return calls.map((c) => c.toOp());\n}\n"],"mappings":";AAMA,SAAgB,UAAU,OAA6C;AACrE,QAAO,MAAM,KAAK,MAAM,EAAE,MAAM,CAAC"}

package/dist/render-ops.d.mts

@@ -0,0 +1,11 @@
+import { t as SqlitePlanTargetDetails } from "./planner-target-details-DTIFFx4L.mjs";
+import "./shared-BNtoZqdo.mjs";
+import { l as SqliteOpFactoryCall } from "./op-factory-call-BPPSCdTB.mjs";
+import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
+
+//#region src/core/migrations/render-ops.d.ts
+type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
+declare function renderOps(calls: readonly SqliteOpFactoryCall[]): Op[];
+//#endregion
+export { renderOps };
+//# sourceMappingURL=render-ops.d.mts.map

package/dist/render-ops.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-ops.d.mts","names":[],"sources":["../src/core/migrations/render-ops.ts"],"sourcesContent":[],"mappings":";;;;;;KAIK,EAAA,GAAK,0BAA0B;iBAEpB,SAAA,iBAA0B,wBAAwB"}

package/dist/render-ops.mjs

@@ -0,0 +1,3 @@
+import { t as renderOps } from "./render-ops-CXOv7SRC.mjs";
+
+export { renderOps };

package/dist/runtime.mjs

@@ -1,4 +1,4 @@
-import { t as sqliteTargetDescriptorMeta } from "./descriptor-meta-DbuuziYA.mjs";
+import { t as sqliteTargetDescriptorMeta } from "./descriptor-meta-BA2YAFQq.mjs";
 import { createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
 
 //#region src/core/runtime-target.ts

package/dist/shared-BNtoZqdo.d.mts

@@ -0,0 +1,69 @@
+import { t as SqlitePlanTargetDetails } from "./planner-target-details-DTIFFx4L.mjs";
+import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
+import { ReferentialAction } from "@prisma-next/sql-contract/types";
+
+//#region src/core/migrations/operations/shared.d.ts
+type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
+/**
+ * Flat, fully-resolved column shape consumed by `createTable`, `addColumn`,
+ * and `recreateTable`. Codec / `typeRef` / default expansion happens at the
+ * call-construction site (in the issue-planner / strategies) so the
+ * operation factories deal only in pre-rendered SQL fragments — mirrors the
+ * Postgres `ColumnSpec` pattern.
+ *
+ * - `typeSql` is the column's DDL type token (e.g. `"INTEGER"`, `"TEXT"`).
+ * - `defaultSql` is the full `DEFAULT …` clause (or empty when there is no
+ *   default and when the column is rendered as `INTEGER PRIMARY KEY
+ *   AUTOINCREMENT`, since SQLite forbids a default on an autoincrement PK).
+ * - `inlineAutoincrementPrimaryKey` directs the renderer to emit
+ *   `INTEGER PRIMARY KEY AUTOINCREMENT` inline and to skip the table-level
+ *   primary-key constraint for this column. SQLite-specific: the column
+ *   becomes an alias for `rowid` only when this exact form is used.
+ */
+interface SqliteColumnSpec {
+  readonly name: string;
+  readonly typeSql: string;
+  readonly defaultSql: string;
+  readonly nullable: boolean;
+  readonly inlineAutoincrementPrimaryKey?: boolean;
+}
+interface SqlitePrimaryKeySpec {
+  readonly columns: readonly string[];
+}
+interface SqliteUniqueSpec {
+  readonly columns: readonly string[];
+  readonly name?: string;
+}
+interface SqliteForeignKeySpec {
+  readonly columns: readonly string[];
+  readonly references: {
+    readonly table: string;
+    readonly columns: readonly string[];
+  };
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+  readonly constraint: boolean;
+}
+/**
+ * Flat shape of a contract table for DDL emission. Used by both
+ * `createTable` (additive) and `recreateTable` (widening/destructive).
+ */
+interface SqliteTableSpec {
+  readonly columns: readonly SqliteColumnSpec[];
+  readonly primaryKey?: SqlitePrimaryKeySpec;
+  readonly uniques?: readonly SqliteUniqueSpec[];
+  readonly foreignKeys?: readonly SqliteForeignKeySpec[];
+}
+/**
+ * Index recreation spec for `recreateTable`. Both declared indexes and
+ * FK-backing indexes flatten to the same shape; the planner dedupes by
+ * column-set before constructing the call.
+ */
+interface SqliteIndexSpec {
+  readonly name: string;
+  readonly columns: readonly string[];
+}
+//#endregion
+export { SqliteTableSpec as i, SqliteColumnSpec as n, SqliteIndexSpec as r, Op as t };
+//# sourceMappingURL=shared-BNtoZqdo.d.mts.map

package/dist/shared-BNtoZqdo.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-BNtoZqdo.d.mts","names":[],"sources":["../src/core/migrations/operations/shared.ts"],"sourcesContent":[],"mappings":";;;;;KAKY,EAAA,GAAK,0BAA0B;AAkC3C;AAKA;AAgBA;;;;;;AAYA;;;;;;;;UA7CiB,gBAAA;;;;;;;UAQA,oBAAA;;;UAIA,gBAAA;;;;UAKA,oBAAA;;;;;;;sBAOK;sBACA;;;;;;;UAQL,eAAA;6BACY;wBACL;8BACM;kCACI;;;;;;;UAQjB,eAAA"}

package/dist/sql-utils-D3SMPFDD.mjs

@@ -0,0 +1,33 @@
+//#region src/core/sql-utils.ts
+/**
+* Shared SQL utility functions for the SQLite target.
+*
+* These functions handle safe SQL identifier and literal escaping. They
+* live in `target-sqlite` (mirroring `target-postgres/src/core/sql-utils.ts`)
+* so both the control adapter (used at emit time) and the runtime adapter
+* (used at execute time) can depend on them through a single one-way edge:
+* `adapter-sqlite → target-sqlite`. Hosting them target-side avoids the
+* cyclic workspace dependency that would arise if `target-sqlite` reached
+* back into `adapter-sqlite` for these primitives.
+*/
+var SqlEscapeError = class extends Error {
+	constructor(message, value, kind) {
+		super(message);
+		this.value = value;
+		this.kind = kind;
+		this.name = "SqlEscapeError";
+	}
+};
+function quoteIdentifier(identifier) {
+	if (identifier.length === 0) throw new SqlEscapeError("Identifier cannot be empty", identifier, "identifier");
+	if (identifier.includes("\0")) throw new SqlEscapeError("Identifier cannot contain null bytes", identifier.replace(/\0/g, "\\0"), "identifier");
+	return `"${identifier.replace(/"/g, "\"\"")}"`;
+}
+function escapeLiteral(value) {
+	if (value.includes("\0")) throw new SqlEscapeError("Literal value cannot contain null bytes", value.replace(/\0/g, "\\0"), "literal");
+	return value.replace(/'/g, "''");
+}
+
+//#endregion
+export { escapeLiteral as n, quoteIdentifier as r, SqlEscapeError as t };
+//# sourceMappingURL=sql-utils-D3SMPFDD.mjs.map

package/dist/sql-utils-D3SMPFDD.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-utils-D3SMPFDD.mjs","names":["value: string","kind: 'identifier' | 'literal'"],"sources":["../src/core/sql-utils.ts"],"sourcesContent":["/**\n * Shared SQL utility functions for the SQLite target.\n *\n * These functions handle safe SQL identifier and literal escaping. They\n * live in `target-sqlite` (mirroring `target-postgres/src/core/sql-utils.ts`)\n * so both the control adapter (used at emit time) and the runtime adapter\n * (used at execute time) can depend on them through a single one-way edge:\n * `adapter-sqlite → target-sqlite`. Hosting them target-side avoids the\n * cyclic workspace dependency that would arise if `target-sqlite` reached\n * back into `adapter-sqlite` for these primitives.\n */\n\nexport class SqlEscapeError extends Error {\n  constructor(\n    message: string,\n    public readonly value: string,\n    public readonly kind: 'identifier' | 'literal',\n  ) {\n    super(message);\n    this.name = 'SqlEscapeError';\n  }\n}\n\nexport function quoteIdentifier(identifier: string): string {\n  if (identifier.length === 0) {\n    throw new SqlEscapeError('Identifier cannot be empty', identifier, 'identifier');\n  }\n  if (identifier.includes('\\0')) {\n    throw new SqlEscapeError(\n      'Identifier cannot contain null bytes',\n      identifier.replace(/\\0/g, '\\\\0'),\n      'identifier',\n    );\n  }\n  return `\"${identifier.replace(/\"/g, '\"\"')}\"`;\n}\n\nexport function escapeLiteral(value: string): string {\n  if (value.includes('\\0')) {\n    throw new SqlEscapeError(\n      'Literal value cannot contain null bytes',\n      value.replace(/\\0/g, '\\\\0'),\n      'literal',\n    );\n  }\n  return value.replace(/'/g, \"''\");\n}\n"],"mappings":";;;;;;;;;;;;AAYA,IAAa,iBAAb,cAAoC,MAAM;CACxC,YACE,SACA,AAAgBA,OAChB,AAAgBC,MAChB;AACA,QAAM,QAAQ;EAHE;EACA;AAGhB,OAAK,OAAO;;;AAIhB,SAAgB,gBAAgB,YAA4B;AAC1D,KAAI,WAAW,WAAW,EACxB,OAAM,IAAI,eAAe,8BAA8B,YAAY,aAAa;AAElF,KAAI,WAAW,SAAS,KAAK,CAC3B,OAAM,IAAI,eACR,wCACA,WAAW,QAAQ,OAAO,MAAM,EAChC,aACD;AAEH,QAAO,IAAI,WAAW,QAAQ,MAAM,OAAK,CAAC;;AAG5C,SAAgB,cAAc,OAAuB;AACnD,KAAI,MAAM,SAAS,KAAK,CACtB,OAAM,IAAI,eACR,2CACA,MAAM,QAAQ,OAAO,MAAM,EAC3B,UACD;AAEH,QAAO,MAAM,QAAQ,MAAM,KAAK"}

package/dist/sql-utils.d.mts

@@ -0,0 +1,22 @@
+//#region src/core/sql-utils.d.ts
+/**
+ * Shared SQL utility functions for the SQLite target.
+ *
+ * These functions handle safe SQL identifier and literal escaping. They
+ * live in `target-sqlite` (mirroring `target-postgres/src/core/sql-utils.ts`)
+ * so both the control adapter (used at emit time) and the runtime adapter
+ * (used at execute time) can depend on them through a single one-way edge:
+ * `adapter-sqlite → target-sqlite`. Hosting them target-side avoids the
+ * cyclic workspace dependency that would arise if `target-sqlite` reached
+ * back into `adapter-sqlite` for these primitives.
+ */
+declare class SqlEscapeError extends Error {
+  readonly value: string;
+  readonly kind: 'identifier' | 'literal';
+  constructor(message: string, value: string, kind: 'identifier' | 'literal');
+}
+declare function quoteIdentifier(identifier: string): string;
+declare function escapeLiteral(value: string): string;
+//#endregion
+export { SqlEscapeError, escapeLiteral, quoteIdentifier };
+//# sourceMappingURL=sql-utils.d.mts.map

package/dist/sql-utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-utils.d.mts","names":[],"sources":["../src/core/sql-utils.ts"],"sourcesContent":[],"mappings":";;AAYA;AAWA;AAcA;;;;;;;;cAzBa,cAAA,SAAuB,KAAA;;;;;iBAWpB,eAAA;iBAcA,aAAA"}

package/dist/sql-utils.mjs

@@ -0,0 +1,3 @@
+import { n as escapeLiteral, r as quoteIdentifier, t as SqlEscapeError } from "./sql-utils-D3SMPFDD.mjs";
+
+export { SqlEscapeError, escapeLiteral, quoteIdentifier };

package/dist/sqlite-migration-BYgrMZdR.d.mts

@@ -0,0 +1,18 @@
+import { t as SqlitePlanTargetDetails } from "./planner-target-details-DTIFFx4L.mjs";
+import { Migration } from "@prisma-next/family-sql/migration";
+
+//#region src/core/migrations/sqlite-migration.d.ts
+
+/**
+ * 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.
+ */
+declare abstract class SqliteMigration extends Migration<SqlitePlanTargetDetails> {
+  readonly targetId: "sqlite";
+}
+//#endregion
+export { SqliteMigration as t };
+//# sourceMappingURL=sqlite-migration-BYgrMZdR.d.mts.map

package/dist/sqlite-migration-BYgrMZdR.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-migration-BYgrMZdR.d.mts","names":[],"sources":["../src/core/migrations/sqlite-migration.ts"],"sourcesContent":[],"mappings":";;;;;;;AAUA;;;;;uBAAsB,eAAA,SAAwB,UAAa"}

package/dist/sqlite-migration-CnLhIrJF.mjs

@@ -0,0 +1,17 @@
+import { Migration } from "@prisma-next/family-sql/migration";
+
+//#region src/core/migrations/sqlite-migration.ts
+/**
+* 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.
+*/
+var SqliteMigration = class extends Migration {
+	targetId = "sqlite";
+};
+
+//#endregion
+export { SqliteMigration as t };
+//# sourceMappingURL=sqlite-migration-CnLhIrJF.mjs.map

package/dist/sqlite-migration-CnLhIrJF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-migration-CnLhIrJF.mjs","names":["SqlMigration"],"sources":["../src/core/migrations/sqlite-migration.ts"],"sourcesContent":["import { Migration as SqlMigration } from '@prisma-next/family-sql/migration';\nimport type { SqlitePlanTargetDetails } from './planner-target-details';\n\n/**\n * Target-owned base class for SQLite migrations. Fixes the `SqlMigration`\n * generic to `SqlitePlanTargetDetails` and the abstract `targetId` to the\n * SQLite literal, so both user-authored migrations and renderer-generated\n * scaffolds can extend `SqliteMigration` directly without redeclaring\n * target-local identity.\n */\nexport abstract class SqliteMigration extends SqlMigration<SqlitePlanTargetDetails> {\n  readonly targetId = 'sqlite' as const;\n}\n"],"mappings":";;;;;;;;;;AAUA,IAAsB,kBAAtB,cAA8CA,UAAsC;CAClF,AAAS,WAAW"}