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

package/dist/statement-builders-B3OGOp7n.mjs

@@ -0,0 +1,148 @@
+//#region src/core/migrations/statement-builders.ts
+const MARKER_TABLE_NAME = "_prisma_marker";
+const LEDGER_TABLE_NAME = "_prisma_ledger";
+/**
+* Control tables the runner creates/manages. The planner must not drop these
+* when reconciling "extra" tables against the contract.
+*/
+const CONTROL_TABLE_NAMES = new Set([MARKER_TABLE_NAME, LEDGER_TABLE_NAME]);
+const ensureMarkerTableStatement = {
+	sql: `CREATE TABLE IF NOT EXISTS _prisma_marker (
+    id INTEGER PRIMARY KEY CHECK (id = 1),
+    core_hash TEXT NOT NULL,
+    profile_hash TEXT NOT NULL,
+    contract_json TEXT,
+    canonical_version INTEGER,
+    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    app_tag TEXT,
+    meta TEXT NOT NULL DEFAULT '{}',
+    invariants TEXT NOT NULL DEFAULT '[]'
+  )`,
+	params: []
+};
+const ensureLedgerTableStatement = {
+	sql: `CREATE TABLE IF NOT EXISTS _prisma_ledger (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    origin_core_hash TEXT,
+    origin_profile_hash TEXT,
+    destination_core_hash TEXT NOT NULL,
+    destination_profile_hash TEXT,
+    contract_json_before TEXT,
+    contract_json_after TEXT,
+    operations TEXT NOT NULL
+  )`,
+	params: []
+};
+function readMarkerStatement() {
+	return {
+		sql: `SELECT
+      core_hash,
+      profile_hash,
+      contract_json,
+      canonical_version,
+      updated_at,
+      app_tag,
+      meta,
+      invariants
+    FROM _prisma_marker
+    WHERE id = ?`,
+		params: [1]
+	};
+}
+function buildWriteMarkerStatements(input) {
+	return {
+		insert: {
+			sql: `INSERT INTO _prisma_marker (
+        id,
+        core_hash,
+        profile_hash,
+        contract_json,
+        canonical_version,
+        updated_at,
+        app_tag,
+        meta,
+        invariants
+      ) VALUES (
+        ?,
+        ?,
+        ?,
+        ?,
+        ?,
+        datetime('now'),
+        ?,
+        ?,
+        ?
+      )`,
+			params: [
+				1,
+				input.storageHash,
+				input.profileHash,
+				jsonParam(input.contractJson),
+				input.canonicalVersion ?? null,
+				input.appTag ?? null,
+				jsonParam(input.meta ?? {}),
+				jsonParam(input.invariants)
+			]
+		},
+		update: {
+			sql: `UPDATE _prisma_marker SET
+        core_hash = ?,
+        profile_hash = ?,
+        contract_json = ?,
+        canonical_version = ?,
+        updated_at = datetime('now'),
+        app_tag = ?,
+        meta = ?,
+        invariants = ?
+      WHERE id = ?`,
+			params: [
+				input.storageHash,
+				input.profileHash,
+				jsonParam(input.contractJson),
+				input.canonicalVersion ?? null,
+				input.appTag ?? null,
+				jsonParam(input.meta ?? {}),
+				jsonParam(input.invariants),
+				1
+			]
+		}
+	};
+}
+function buildLedgerInsertStatement(input) {
+	return {
+		sql: `INSERT INTO _prisma_ledger (
+      origin_core_hash,
+      origin_profile_hash,
+      destination_core_hash,
+      destination_profile_hash,
+      contract_json_before,
+      contract_json_after,
+      operations
+    ) VALUES (
+      ?,
+      ?,
+      ?,
+      ?,
+      ?,
+      ?,
+      ?
+    )`,
+		params: [
+			input.originStorageHash ?? null,
+			input.originProfileHash ?? null,
+			input.destinationStorageHash,
+			input.destinationProfileHash ?? null,
+			jsonParam(input.contractJsonBefore),
+			jsonParam(input.contractJsonAfter),
+			jsonParam(input.operations)
+		]
+	};
+}
+function jsonParam(value) {
+	return JSON.stringify(value ?? null);
+}
+
+//#endregion
+export { buildWriteMarkerStatements as a, readMarkerStatement as c, buildLedgerInsertStatement as i, LEDGER_TABLE_NAME as n, ensureLedgerTableStatement as o, MARKER_TABLE_NAME as r, ensureMarkerTableStatement as s, CONTROL_TABLE_NAMES as t };
+//# sourceMappingURL=statement-builders-B3OGOp7n.mjs.map

package/dist/statement-builders-B3OGOp7n.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"statement-builders-B3OGOp7n.mjs","names":["CONTROL_TABLE_NAMES: ReadonlySet<string>","ensureMarkerTableStatement: SqlStatement","ensureLedgerTableStatement: SqlStatement"],"sources":["../src/core/migrations/statement-builders.ts"],"sourcesContent":["export interface SqlStatement {\n  readonly sql: string;\n  readonly params: readonly unknown[];\n}\n\nexport const MARKER_TABLE_NAME = '_prisma_marker';\nexport const LEDGER_TABLE_NAME = '_prisma_ledger';\n\n/**\n * Control tables the runner creates/manages. The planner must not drop these\n * when reconciling \"extra\" tables against the contract.\n */\nexport const CONTROL_TABLE_NAMES: ReadonlySet<string> = new Set([\n  MARKER_TABLE_NAME,\n  LEDGER_TABLE_NAME,\n]);\n\nexport const ensureMarkerTableStatement: SqlStatement = {\n  sql: `CREATE TABLE IF NOT EXISTS _prisma_marker (\n    id INTEGER PRIMARY KEY CHECK (id = 1),\n    core_hash TEXT NOT NULL,\n    profile_hash TEXT NOT NULL,\n    contract_json TEXT,\n    canonical_version INTEGER,\n    updated_at TEXT NOT NULL DEFAULT (datetime('now')),\n    app_tag TEXT,\n    meta TEXT NOT NULL DEFAULT '{}',\n    invariants TEXT NOT NULL DEFAULT '[]'\n  )`,\n  params: [],\n};\n\nexport const ensureLedgerTableStatement: SqlStatement = {\n  sql: `CREATE TABLE IF NOT EXISTS _prisma_ledger (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    created_at TEXT NOT NULL DEFAULT (datetime('now')),\n    origin_core_hash TEXT,\n    origin_profile_hash TEXT,\n    destination_core_hash TEXT NOT NULL,\n    destination_profile_hash TEXT,\n    contract_json_before TEXT,\n    contract_json_after TEXT,\n    operations TEXT NOT NULL\n  )`,\n  params: [],\n};\n\nexport function readMarkerStatement(): SqlStatement {\n  return {\n    sql: `SELECT\n      core_hash,\n      profile_hash,\n      contract_json,\n      canonical_version,\n      updated_at,\n      app_tag,\n      meta,\n      invariants\n    FROM _prisma_marker\n    WHERE id = ?`,\n    params: [1],\n  };\n}\n\nexport interface WriteMarkerInput {\n  readonly storageHash: string;\n  readonly profileHash: string;\n  readonly contractJson?: unknown;\n  readonly canonicalVersion?: number | null;\n  readonly appTag?: string | null;\n  readonly meta?: Record<string, unknown>;\n  /**\n   * Invariants to write into `marker.invariants`. Stored as a JSON-encoded\n   * TEXT array — SQLite has no native array type. The runner is responsible\n   * for merging with the existing column (no SQL-side merge here, unlike\n   * Postgres) before passing them in: BEGIN EXCLUSIVE on the migration\n   * transaction makes the read-then-merge-then-write sequence safe.\n   */\n  readonly invariants: readonly string[];\n}\n\nexport function buildWriteMarkerStatements(input: WriteMarkerInput): {\n  readonly insert: SqlStatement;\n  readonly update: SqlStatement;\n} {\n  const params: readonly unknown[] = [\n    1,\n    input.storageHash,\n    input.profileHash,\n    jsonParam(input.contractJson),\n    input.canonicalVersion ?? null,\n    input.appTag ?? null,\n    jsonParam(input.meta ?? {}),\n    jsonParam(input.invariants),\n  ];\n\n  return {\n    insert: {\n      sql: `INSERT INTO _prisma_marker (\n        id,\n        core_hash,\n        profile_hash,\n        contract_json,\n        canonical_version,\n        updated_at,\n        app_tag,\n        meta,\n        invariants\n      ) VALUES (\n        ?,\n        ?,\n        ?,\n        ?,\n        ?,\n        datetime('now'),\n        ?,\n        ?,\n        ?\n      )`,\n      params,\n    },\n    update: {\n      sql: `UPDATE _prisma_marker SET\n        core_hash = ?,\n        profile_hash = ?,\n        contract_json = ?,\n        canonical_version = ?,\n        updated_at = datetime('now'),\n        app_tag = ?,\n        meta = ?,\n        invariants = ?\n      WHERE id = ?`,\n      params: [\n        input.storageHash,\n        input.profileHash,\n        jsonParam(input.contractJson),\n        input.canonicalVersion ?? null,\n        input.appTag ?? null,\n        jsonParam(input.meta ?? {}),\n        jsonParam(input.invariants),\n        1,\n      ],\n    },\n  };\n}\n\nexport interface LedgerInsertInput {\n  readonly originStorageHash?: string | null;\n  readonly originProfileHash?: string | null;\n  readonly destinationStorageHash: string;\n  readonly destinationProfileHash?: string | null;\n  readonly contractJsonBefore?: unknown;\n  readonly contractJsonAfter?: unknown;\n  readonly operations: unknown;\n}\n\nexport function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStatement {\n  return {\n    sql: `INSERT INTO _prisma_ledger (\n      origin_core_hash,\n      origin_profile_hash,\n      destination_core_hash,\n      destination_profile_hash,\n      contract_json_before,\n      contract_json_after,\n      operations\n    ) VALUES (\n      ?,\n      ?,\n      ?,\n      ?,\n      ?,\n      ?,\n      ?\n    )`,\n    params: [\n      input.originStorageHash ?? null,\n      input.originProfileHash ?? null,\n      input.destinationStorageHash,\n      input.destinationProfileHash ?? null,\n      jsonParam(input.contractJsonBefore),\n      jsonParam(input.contractJsonAfter),\n      jsonParam(input.operations),\n    ],\n  };\n}\n\nfunction jsonParam(value: unknown): string {\n  return JSON.stringify(value ?? null);\n}\n"],"mappings":";AAKA,MAAa,oBAAoB;AACjC,MAAa,oBAAoB;;;;;AAMjC,MAAaA,sBAA2C,IAAI,IAAI,CAC9D,mBACA,kBACD,CAAC;AAEF,MAAaC,6BAA2C;CACtD,KAAK;;;;;;;;;;;CAWL,QAAQ,EAAE;CACX;AAED,MAAaC,6BAA2C;CACtD,KAAK;;;;;;;;;;;CAWL,QAAQ,EAAE;CACX;AAED,SAAgB,sBAAoC;AAClD,QAAO;EACL,KAAK;;;;;;;;;;;EAWL,QAAQ,CAAC,EAAE;EACZ;;AAoBH,SAAgB,2BAA2B,OAGzC;AAYA,QAAO;EACL,QAAQ;GACN,KAAK;;;;;;;;;;;;;;;;;;;;;GAqBL,QAlC+B;IACjC;IACA,MAAM;IACN,MAAM;IACN,UAAU,MAAM,aAAa;IAC7B,MAAM,oBAAoB;IAC1B,MAAM,UAAU;IAChB,UAAU,MAAM,QAAQ,EAAE,CAAC;IAC3B,UAAU,MAAM,WAAW;IAC5B;GA0BE;EACD,QAAQ;GACN,KAAK;;;;;;;;;;GAUL,QAAQ;IACN,MAAM;IACN,MAAM;IACN,UAAU,MAAM,aAAa;IAC7B,MAAM,oBAAoB;IAC1B,MAAM,UAAU;IAChB,UAAU,MAAM,QAAQ,EAAE,CAAC;IAC3B,UAAU,MAAM,WAAW;IAC3B;IACD;GACF;EACF;;AAaH,SAAgB,2BAA2B,OAAwC;AACjF,QAAO;EACL,KAAK;;;;;;;;;;;;;;;;;EAiBL,QAAQ;GACN,MAAM,qBAAqB;GAC3B,MAAM,qBAAqB;GAC3B,MAAM;GACN,MAAM,0BAA0B;GAChC,UAAU,MAAM,mBAAmB;GACnC,UAAU,MAAM,kBAAkB;GAClC,UAAU,MAAM,WAAW;GAC5B;EACF;;AAGH,SAAS,UAAU,OAAwB;AACzC,QAAO,KAAK,UAAU,SAAS,KAAK"}

package/dist/statement-builders.d.mts

@@ -0,0 +1,48 @@
+//#region src/core/migrations/statement-builders.d.ts
+interface SqlStatement {
+  readonly sql: string;
+  readonly params: readonly unknown[];
+}
+declare const MARKER_TABLE_NAME = "_prisma_marker";
+declare const LEDGER_TABLE_NAME = "_prisma_ledger";
+/**
+ * Control tables the runner creates/manages. The planner must not drop these
+ * when reconciling "extra" tables against the contract.
+ */
+declare const CONTROL_TABLE_NAMES: ReadonlySet<string>;
+declare const ensureMarkerTableStatement: SqlStatement;
+declare const ensureLedgerTableStatement: SqlStatement;
+declare function readMarkerStatement(): SqlStatement;
+interface WriteMarkerInput {
+  readonly storageHash: string;
+  readonly profileHash: string;
+  readonly contractJson?: unknown;
+  readonly canonicalVersion?: number | null;
+  readonly appTag?: string | null;
+  readonly meta?: Record<string, unknown>;
+  /**
+   * Invariants to write into `marker.invariants`. Stored as a JSON-encoded
+   * TEXT array — SQLite has no native array type. The runner is responsible
+   * for merging with the existing column (no SQL-side merge here, unlike
+   * Postgres) before passing them in: BEGIN EXCLUSIVE on the migration
+   * transaction makes the read-then-merge-then-write sequence safe.
+   */
+  readonly invariants: readonly string[];
+}
+declare function buildWriteMarkerStatements(input: WriteMarkerInput): {
+  readonly insert: SqlStatement;
+  readonly update: SqlStatement;
+};
+interface LedgerInsertInput {
+  readonly originStorageHash?: string | null;
+  readonly originProfileHash?: string | null;
+  readonly destinationStorageHash: string;
+  readonly destinationProfileHash?: string | null;
+  readonly contractJsonBefore?: unknown;
+  readonly contractJsonAfter?: unknown;
+  readonly operations: unknown;
+}
+declare function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStatement;
+//#endregion
+export { CONTROL_TABLE_NAMES, LEDGER_TABLE_NAME, MARKER_TABLE_NAME, type SqlStatement, buildLedgerInsertStatement, buildWriteMarkerStatements, ensureLedgerTableStatement, ensureMarkerTableStatement, readMarkerStatement };
+//# sourceMappingURL=statement-builders.d.mts.map

package/dist/statement-builders.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statement-builders.d.mts","names":[],"sources":["../src/core/migrations/statement-builders.ts"],"sourcesContent":[],"mappings":";UAAiB,YAAA;EAAA,SAAA,GAAA,EAAA,MAAY;EAKhB,SAAA,MAAA,EAAA,SAAiB,OAAA,EAAA;AAC9B;AAMa,cAPA,iBAAA,GAOqB,gBAAW;AAKhC,cAXA,iBAAA,GAwBZ,gBAbwC;AAezC;AAeA;AAiBA;AAiBA;AAAkD,cArErC,mBAqEqC,EArEhB,WAqEgB,CAAA,MAAA,CAAA;AAC/B,cAjEN,0BAiEM,EAjEsB,YAiEtB;AACA,cAnDN,0BAmDM,EAnDsB,YAmDtB;AAAY,iBApCf,mBAAA,CAAA,CAoCe,EApCQ,YAoCR;AA+Dd,UAlFA,gBAAA,CAkFiB;EAUlB,SAAA,WAAA,EAAA,MAAA;;;;;kBAtFE;;;;;;;;;;iBAWF,0BAAA,QAAkC;mBAC/B;mBACA;;UA+DF,iBAAA;;;;;;;;;iBAUD,0BAAA,QAAkC,oBAAoB"}

package/dist/statement-builders.mjs

@@ -0,0 +1,3 @@
+import { a as buildWriteMarkerStatements, c as readMarkerStatement, i as buildLedgerInsertStatement, n as LEDGER_TABLE_NAME, o as ensureLedgerTableStatement, r as MARKER_TABLE_NAME, s as ensureMarkerTableStatement, t as CONTROL_TABLE_NAMES } from "./statement-builders-B3OGOp7n.mjs";
+
+export { CONTROL_TABLE_NAMES, LEDGER_TABLE_NAME, MARKER_TABLE_NAME, buildLedgerInsertStatement, buildWriteMarkerStatements, ensureLedgerTableStatement, ensureMarkerTableStatement, readMarkerStatement };

package/dist/tables-sKIg_lWE.mjs

@@ -0,0 +1,408 @@
+import { n as stripOuterParens } from "./default-normalizer-R-sQXAYt.mjs";
+import { n as escapeLiteral, r as quoteIdentifier } from "./sql-utils-D3SMPFDD.mjs";
+import { t as buildTargetDetails } from "./planner-target-details-BQIWQlBu.mjs";
+
+//#region src/core/migrations/operations/shared.ts
+function step(description, sql) {
+	return {
+		description,
+		sql
+	};
+}
+const REFERENTIAL_ACTION_SQL = {
+	noAction: "NO ACTION",
+	restrict: "RESTRICT",
+	cascade: "CASCADE",
+	setNull: "SET NULL",
+	setDefault: "SET DEFAULT"
+};
+/**
+* Renders a single column's inline DDL fragment within a `CREATE TABLE`
+* statement. Honours the `inlineAutoincrementPrimaryKey` flag — SQLite
+* treats `INTEGER PRIMARY KEY AUTOINCREMENT` as a special form that aliases
+* `rowid`, and the column must not carry a `DEFAULT` or repeat `NOT NULL`.
+*/
+function renderColumnDefinition(column) {
+	const parts = [quoteIdentifier(column.name), column.typeSql];
+	if (column.inlineAutoincrementPrimaryKey) parts.push("PRIMARY KEY AUTOINCREMENT");
+	else {
+		if (column.defaultSql) parts.push(column.defaultSql);
+		if (!column.nullable) parts.push("NOT NULL");
+	}
+	return parts.join(" ");
+}
+/**
+* Renders an inline FOREIGN KEY constraint clause for a `CREATE TABLE`
+* body. Returns the empty string when `constraint` is false (the FK is
+* tracked at the contract level for index-creation purposes only and must
+* not produce DDL).
+*/
+function renderForeignKeyClause(fk) {
+	if (!fk.constraint) return "";
+	let sql = `${fk.name ? `CONSTRAINT ${quoteIdentifier(fk.name)} ` : ""}FOREIGN KEY (${fk.columns.map(quoteIdentifier).join(", ")}) REFERENCES ${quoteIdentifier(fk.references.table)} (${fk.references.columns.map(quoteIdentifier).join(", ")})`;
+	if (fk.onDelete !== void 0) sql += ` ON DELETE ${REFERENTIAL_ACTION_SQL[fk.onDelete]}`;
+	if (fk.onUpdate !== void 0) sql += ` ON UPDATE ${REFERENTIAL_ACTION_SQL[fk.onUpdate]}`;
+	return sql;
+}
+
+//#endregion
+//#region src/core/migrations/operations/columns.ts
+function addColumn(tableName, column) {
+	const addSql = [
+		`ALTER TABLE ${quoteIdentifier(tableName)}`,
+		`ADD COLUMN ${quoteIdentifier(column.name)} ${column.typeSql}`,
+		column.defaultSql,
+		column.nullable ? "" : "NOT NULL"
+	].filter(Boolean).join(" ");
+	return {
+		id: `column.${tableName}.${column.name}`,
+		label: `Add column ${column.name} on ${tableName}`,
+		summary: `Adds column ${column.name} on ${tableName}`,
+		operationClass: "additive",
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("column", column.name, tableName)
+		},
+		precheck: [step(`ensure column "${column.name}" is missing`, `SELECT COUNT(*) = 0 FROM pragma_table_info('${escapeLiteral(tableName)}') WHERE name = '${escapeLiteral(column.name)}'`)],
+		execute: [step(`add column "${column.name}"`, addSql)],
+		postcheck: [step(`verify column "${column.name}" exists`, `SELECT COUNT(*) > 0 FROM pragma_table_info('${escapeLiteral(tableName)}') WHERE name = '${escapeLiteral(column.name)}'`)]
+	};
+}
+function dropColumn(tableName, columnName) {
+	return {
+		id: `dropColumn.${tableName}.${columnName}`,
+		label: `Drop column ${columnName} on ${tableName}`,
+		summary: `Drops column ${columnName} on ${tableName} which is not in the contract`,
+		operationClass: "destructive",
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("column", columnName, tableName)
+		},
+		precheck: [step(`ensure column "${columnName}" exists on "${tableName}"`, `SELECT COUNT(*) > 0 FROM pragma_table_info('${escapeLiteral(tableName)}') WHERE name = '${escapeLiteral(columnName)}'`)],
+		execute: [step(`drop column "${columnName}" from "${tableName}"`, `ALTER TABLE ${quoteIdentifier(tableName)} DROP COLUMN ${quoteIdentifier(columnName)}`)],
+		postcheck: [step(`verify column "${columnName}" is gone from "${tableName}"`, `SELECT COUNT(*) = 0 FROM pragma_table_info('${escapeLiteral(tableName)}') WHERE name = '${escapeLiteral(columnName)}'`)]
+	};
+}
+
+//#endregion
+//#region src/core/migrations/planner-ddl-builders.ts
+const SAFE_NATIVE_TYPE_PATTERN = /^[a-zA-Z][a-zA-Z0-9_ ]*$/;
+function assertSafeNativeType(nativeType) {
+	if (!SAFE_NATIVE_TYPE_PATTERN.test(nativeType)) throw new Error(`Unsafe native type name in contract: "${nativeType}". Native type names must match /^[a-zA-Z][a-zA-Z0-9_ ]*\$/`);
+}
+function assertSafeDefaultExpression(expression) {
+	if (expression.includes(";") || /--|\/\*|\bSELECT\b/i.test(expression)) throw new Error(`Unsafe default expression in contract: "${expression}". Default expressions must not contain semicolons, SQL comment tokens, or subqueries.`);
+}
+/**
+* Renders the column's DDL type token (e.g. `"INTEGER"`, `"TEXT"`).
+* Resolves `typeRef` against `storageTypes` and validates the resulting
+* native type against a safe-identifier pattern.
+*/
+function buildColumnTypeSql(column, storageTypes = {}) {
+	const resolved = resolveColumnTypeMetadata(column, storageTypes);
+	assertSafeNativeType(resolved.nativeType);
+	return resolved.nativeType.toUpperCase();
+}
+/**
+* Renders the column's `DEFAULT …` clause. Returns the empty string when
+* there is no default, and also when the default is `autoincrement()` —
+* SQLite encodes that as `INTEGER PRIMARY KEY AUTOINCREMENT` inline on the
+* column definition, not as a separate DEFAULT.
+*/
+function buildColumnDefaultSql(columnDefault) {
+	if (!columnDefault) return "";
+	switch (columnDefault.kind) {
+		case "literal": return `DEFAULT ${renderDefaultLiteral(columnDefault.value)}`;
+		case "function":
+			if (columnDefault.expression === "autoincrement()") return "";
+			if (columnDefault.expression === "now()") return "DEFAULT (datetime('now'))";
+			assertSafeDefaultExpression(columnDefault.expression);
+			return `DEFAULT (${columnDefault.expression})`;
+	}
+}
+function renderDefaultLiteral(value) {
+	if (value instanceof Date) return `'${escapeLiteral(value.toISOString())}'`;
+	if (typeof value === "string") return `'${escapeLiteral(value)}'`;
+	if (typeof value === "number" || typeof value === "bigint") return String(value);
+	if (typeof value === "boolean") return value ? "1" : "0";
+	if (value === null) return "NULL";
+	return `'${escapeLiteral(JSON.stringify(value))}'`;
+}
+function buildCreateIndexSql(tableName, indexName, columns, unique = false) {
+	return `CREATE ${unique ? "UNIQUE " : ""}INDEX ${quoteIdentifier(indexName)} ON ${quoteIdentifier(tableName)} (${columns.map(quoteIdentifier).join(", ")})`;
+}
+function buildDropIndexSql(indexName) {
+	return `DROP INDEX IF EXISTS ${quoteIdentifier(indexName)}`;
+}
+/**
+* True when the column is rendered inline as `INTEGER PRIMARY KEY
+* AUTOINCREMENT`. Requires the column's default to be `autoincrement()` and
+* the column to be the sole member of the table's primary key — anything
+* else falls back to a separate PRIMARY KEY constraint with a default
+* AUTOINCREMENT semantics expressed elsewhere.
+*/
+function isInlineAutoincrementPrimaryKey(table, columnName) {
+	if (table.primaryKey?.columns.length !== 1) return false;
+	if (table.primaryKey.columns[0] !== columnName) return false;
+	const column = table.columns[columnName];
+	return column?.default?.kind === "function" && column.default.expression === "autoincrement()";
+}
+function resolveColumnTypeMetadata(column, storageTypes) {
+	if (!column.typeRef) return column;
+	const referencedType = storageTypes[column.typeRef];
+	if (!referencedType) throw new Error(`Storage type "${column.typeRef}" referenced by column is not defined in storage.types.`);
+	return {
+		codecId: referencedType.codecId,
+		nativeType: referencedType.nativeType,
+		typeParams: referencedType.typeParams
+	};
+}
+
+//#endregion
+//#region src/core/migrations/operations/indexes.ts
+function createIndex(tableName, indexName, columns) {
+	return {
+		id: `index.${tableName}.${indexName}`,
+		label: `Create index ${indexName} on ${tableName}`,
+		summary: `Creates index ${indexName} on ${tableName}`,
+		operationClass: "additive",
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("index", indexName, tableName)
+		},
+		precheck: [step(`ensure index "${indexName}" is missing`, `SELECT COUNT(*) = 0 FROM sqlite_master WHERE type = 'index' AND name = '${escapeLiteral(indexName)}'`)],
+		execute: [step(`create index "${indexName}"`, buildCreateIndexSql(tableName, indexName, columns))],
+		postcheck: [step(`verify index "${indexName}" exists`, `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'index' AND name = '${escapeLiteral(indexName)}'`)]
+	};
+}
+function dropIndex(tableName, indexName) {
+	return {
+		id: `dropIndex.${tableName}.${indexName}`,
+		label: `Drop index ${indexName} on ${tableName}`,
+		summary: `Drops index ${indexName} on ${tableName} which is not in the contract`,
+		operationClass: "destructive",
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("index", indexName, tableName)
+		},
+		precheck: [step(`ensure index "${indexName}" exists`, `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'index' AND name = '${escapeLiteral(indexName)}'`)],
+		execute: [step(`drop index "${indexName}"`, buildDropIndexSql(indexName))],
+		postcheck: [step(`verify index "${indexName}" is gone`, `SELECT COUNT(*) = 0 FROM sqlite_master WHERE type = 'index' AND name = '${escapeLiteral(indexName)}'`)]
+	};
+}
+
+//#endregion
+//#region src/core/migrations/operations/tables.ts
+/**
+* Renders the body of a `CREATE TABLE <name> ( … )` statement from a flat
+* `SqliteTableSpec`. SQLite's `INTEGER PRIMARY KEY AUTOINCREMENT` form is
+* inline on the column; the table-level PRIMARY KEY clause is emitted only
+* when no column carries `inlineAutoincrementPrimaryKey`.
+*/
+function renderCreateTableSql(tableName, spec) {
+	const columnDefs = spec.columns.map(renderColumnDefinition);
+	const constraintDefs = [];
+	const hasInlinePk = spec.columns.some((c) => c.inlineAutoincrementPrimaryKey);
+	if (spec.primaryKey && !hasInlinePk) constraintDefs.push(`PRIMARY KEY (${spec.primaryKey.columns.map(quoteIdentifier).join(", ")})`);
+	for (const u of spec.uniques ?? []) {
+		const name = u.name ? `CONSTRAINT ${quoteIdentifier(u.name)} ` : "";
+		constraintDefs.push(`${name}UNIQUE (${u.columns.map(quoteIdentifier).join(", ")})`);
+	}
+	for (const fk of spec.foreignKeys ?? []) {
+		const clause = renderForeignKeyClause(fk);
+		if (clause) constraintDefs.push(clause);
+	}
+	const allDefs = [...columnDefs, ...constraintDefs];
+	return `CREATE TABLE ${quoteIdentifier(tableName)} (\n  ${allDefs.join(",\n  ")}\n)`;
+}
+function createTable(tableName, spec) {
+	return {
+		id: `table.${tableName}`,
+		label: `Create table ${tableName}`,
+		summary: `Creates table ${tableName} with required columns`,
+		operationClass: "additive",
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("table", tableName)
+		},
+		precheck: [step(`ensure table "${tableName}" does not exist`, `SELECT COUNT(*) = 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}'`)],
+		execute: [step(`create table "${tableName}"`, renderCreateTableSql(tableName, spec))],
+		postcheck: [step(`verify table "${tableName}" exists`, `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}'`)]
+	};
+}
+function dropTable(tableName) {
+	return {
+		id: `dropTable.${tableName}`,
+		label: `Drop table ${tableName}`,
+		summary: `Drops table ${tableName} which is not in the contract`,
+		operationClass: "destructive",
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("table", tableName)
+		},
+		precheck: [step(`ensure table "${tableName}" exists`, `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}'`)],
+		execute: [step(`drop table "${tableName}"`, `DROP TABLE ${quoteIdentifier(tableName)}`)],
+		postcheck: [step(`verify table "${tableName}" is gone`, `SELECT COUNT(*) = 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}'`)]
+	};
+}
+function recreateTable(args) {
+	const { tableName, contractTable, schemaColumnNames, indexes, summary, postchecks, operationClass } = args;
+	const tempName = `_prisma_new_${tableName}`;
+	const liveSet = new Set(schemaColumnNames);
+	const sharedColumns = contractTable.columns.filter((c) => liveSet.has(c.name)).map((c) => c.name);
+	const columnList = sharedColumns.map(quoteIdentifier).join(", ");
+	const indexStatements = indexes.map((idx) => ({
+		description: `recreate index "${idx.name}" on "${tableName}"`,
+		sql: buildCreateIndexSql(tableName, idx.name, idx.columns)
+	}));
+	const copyStep = sharedColumns.length > 0 ? [step(`copy data from "${tableName}" to "${tempName}"`, `INSERT INTO ${quoteIdentifier(tempName)} (${columnList}) SELECT ${columnList} FROM ${quoteIdentifier(tableName)}`)] : [];
+	return {
+		id: `recreateTable.${tableName}`,
+		label: `Recreate table ${tableName}`,
+		summary,
+		operationClass,
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("table", tableName)
+		},
+		precheck: [step(`ensure table "${tableName}" exists`, `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}'`), step(`ensure temp table "${tempName}" does not exist`, `SELECT COUNT(*) = 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tempName)}'`)],
+		execute: [
+			step(`create new table "${tempName}" with desired schema`, renderCreateTableSql(tempName, contractTable)),
+			...copyStep,
+			step(`drop old table "${tableName}"`, `DROP TABLE ${quoteIdentifier(tableName)}`),
+			step(`rename "${tempName}" to "${tableName}"`, `ALTER TABLE ${quoteIdentifier(tempName)} RENAME TO ${quoteIdentifier(tableName)}`),
+			...indexStatements
+		],
+		postcheck: [
+			step(`verify table "${tableName}" exists`, `SELECT COUNT(*) > 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tableName)}'`),
+			step(`verify temp table "${tempName}" is gone`, `SELECT COUNT(*) = 0 FROM sqlite_master WHERE type = 'table' AND name = '${escapeLiteral(tempName)}'`),
+			...postchecks
+		]
+	};
+}
+/**
+* Build a one-line summary of a recreate-table operation from the schema
+* issues that triggered it. Lives next to `recreateTable` so the planner
+* (which has the issues) can produce the same description the factory
+* used to build inline. Keeping the formatting target-side keeps
+* `RecreateTableCall` issue-free at the IR layer.
+*/
+function buildRecreateSummary(tableName, issues) {
+	return `Recreates table ${tableName} to apply schema changes: ${issues.map((i) => i.message).join("; ")}`;
+}
+const COLUMN_LEVEL_ISSUE_KINDS = new Set([
+	"nullability_mismatch",
+	"default_mismatch",
+	"default_missing",
+	"extra_default",
+	"type_mismatch"
+]);
+const PK_ISSUE_KINDS = new Set(["primary_key_mismatch", "extra_primary_key"]);
+const UNIQUE_ISSUE_KINDS = new Set(["unique_constraint_mismatch", "extra_unique_constraint"]);
+const FK_ISSUE_KINDS = new Set(["foreign_key_mismatch", "extra_foreign_key"]);
+/**
+* Returns the columns the contract expects as the table's primary key. Picks
+* up SQLite's inline `INTEGER PRIMARY KEY AUTOINCREMENT` form when no
+* explicit `primaryKey` clause is set on the spec.
+*/
+function expectedPrimaryKeyColumns(spec) {
+	if (spec.primaryKey) return spec.primaryKey.columns;
+	const inlinePk = spec.columns.find((c) => c.inlineAutoincrementPrimaryKey);
+	return inlinePk ? [inlinePk.name] : [];
+}
+function quoteSqlList(values) {
+	return values.map((v) => `'${escapeLiteral(v)}'`).join(", ");
+}
+/**
+* Per-issue postchecks verifying the recreated table's shape against the
+* contract spec. Column-level issues (`nullability_mismatch`,
+* `default_mismatch`, …) emit one targeted check each; constraint-level
+* issues (`primary_key_mismatch`, `unique_constraint_mismatch`,
+* `foreign_key_mismatch`, plus their `extra_*` siblings) emit one
+* `pragma_*`-driven check per declared constraint in the contract spec, so
+* a recreated table with the right columns but the wrong PK / unique / FK
+* shape fails the postcheck instead of passing silently. Exported so the
+* planner can pre-build the list at construction time and
+* `RecreateTableCall` doesn't have to carry `SchemaIssue` objects through
+* to render time.
+*/
+function buildRecreatePostchecks(tableName, issues, spec) {
+	const checks = [];
+	const t = escapeLiteral(tableName);
+	const byName = new Map(spec.columns.map((c) => [c.name, c]));
+	for (const issue of issues) {
+		if (issue.kind === "enum_values_changed") continue;
+		if (!COLUMN_LEVEL_ISSUE_KINDS.has(issue.kind)) continue;
+		if (!issue.column) continue;
+		const c = escapeLiteral(issue.column);
+		if (issue.kind === "nullability_mismatch") {
+			let wantNotNull;
+			if (issue.expected === "false") wantNotNull = true;
+			else if (issue.expected === "true") wantNotNull = false;
+			if (wantNotNull !== void 0) checks.push({
+				description: `verify "${issue.column}" nullability on "${tableName}"`,
+				sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND "notnull" = ${wantNotNull ? 1 : 0}`
+			});
+		}
+		if (issue.kind === "default_mismatch" || issue.kind === "default_missing") {
+			const colSpec = byName.get(issue.column);
+			const expectedRaw = colSpec?.defaultSql.startsWith("DEFAULT ") ? stripOuterParens(colSpec.defaultSql.slice(8)) : null;
+			if (expectedRaw) checks.push({
+				description: `verify "${issue.column}" default on "${tableName}"`,
+				sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND dflt_value = '${escapeLiteral(expectedRaw)}'`
+			});
+		}
+		if (issue.kind === "type_mismatch") {
+			const colSpec = byName.get(issue.column);
+			if (colSpec) checks.push({
+				description: `verify "${issue.column}" type on "${tableName}"`,
+				sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND LOWER(type) = '${escapeLiteral(colSpec.typeSql.toLowerCase())}'`
+			});
+		}
+		if (issue.kind === "extra_default") checks.push({
+			description: `verify "${issue.column}" has no default on "${tableName}"`,
+			sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND dflt_value IS NULL`
+		});
+	}
+	const hasPkIssue = issues.some((i) => PK_ISSUE_KINDS.has(i.kind));
+	const hasUniqueIssue = issues.some((i) => UNIQUE_ISSUE_KINDS.has(i.kind));
+	const hasFkIssue = issues.some((i) => FK_ISSUE_KINDS.has(i.kind));
+	if (hasPkIssue) {
+		const pkColumns = expectedPrimaryKeyColumns(spec);
+		const colCount = pkColumns.length;
+		if (colCount === 0) checks.push({
+			description: `verify "${tableName}" has no primary key`,
+			sql: `SELECT (SELECT COUNT(*) FROM pragma_table_info('${t}') WHERE pk > 0) = 0`
+		});
+		else checks.push({
+			description: `verify primary key on "${tableName}"`,
+			sql: `SELECT (SELECT COUNT(*) FROM pragma_table_info('${t}') WHERE pk > 0) = ${colCount} AND (SELECT COUNT(*) FROM pragma_table_info('${t}') WHERE pk > 0 AND name IN (${quoteSqlList(pkColumns)})) = ${colCount}`
+		});
+	}
+	if (hasUniqueIssue) for (const u of spec.uniques ?? []) {
+		const colCount = u.columns.length;
+		const description = u.name ? `verify unique constraint "${u.name}" on "${tableName}"` : `verify unique constraint (${u.columns.join(", ")}) on "${tableName}"`;
+		checks.push({
+			description,
+			sql: `SELECT EXISTS (SELECT 1 FROM pragma_index_list('${t}') l WHERE l."unique" = 1 AND (SELECT COUNT(*) FROM pragma_index_info(l.name)) = ${colCount} AND (SELECT COUNT(*) FROM pragma_index_info(l.name) WHERE name IN (${quoteSqlList(u.columns)})) = ${colCount})`
+		});
+	}
+	if (hasFkIssue) for (const fk of spec.foreignKeys ?? []) {
+		const refTable = escapeLiteral(fk.references.table);
+		const colCount = fk.columns.length;
+		const tuples = fk.columns.map((from, i) => {
+			const to = fk.references.columns[i] ?? from;
+			return `('${escapeLiteral(from)}', '${escapeLiteral(to)}')`;
+		}).join(", ");
+		const description = `verify foreign key (${fk.columns.join(", ")}) → ${fk.references.table}(${fk.references.columns.join(", ")}) on "${tableName}"`;
+		checks.push({
+			description,
+			sql: `SELECT EXISTS (SELECT 1 FROM pragma_foreign_key_list('${t}') f WHERE f."table" = '${refTable}' GROUP BY f.id HAVING COUNT(*) = ${colCount} AND SUM(CASE WHEN (f."from", f."to") IN (${tuples}) THEN 1 ELSE 0 END) = ${colCount})`
+		});
+	}
+	return checks;
+}
+
+//#endregion
+export { recreateTable as a, buildColumnDefaultSql as c, renderDefaultLiteral as d, addColumn as f, dropTable as i, buildColumnTypeSql as l, step as m, buildRecreateSummary as n, createIndex as o, dropColumn as p, createTable as r, dropIndex as s, buildRecreatePostchecks as t, isInlineAutoincrementPrimaryKey as u };
+//# sourceMappingURL=tables-sKIg_lWE.mjs.map