@voltro/database 0.85.0 → 0.86.0

package/dist/migrate.js

@@ -0,0 +1,624 @@
+import { persistedColumns as e } from "./columns.js";
+import { extractDbCause as t } from "./dbCause.js";
+import { getEnumRenames as n } from "./enumRenames.js";
+import { resolveGinOpclass as r } from "./ginIndex.js";
+import { isMysqlFamily as i, isSqliteFamily as a, quoteIdent as o } from "./dialect.js";
+import { isView as s, viewSql as c } from "./view.js";
+import { encodeSqliteDecimalDefault as l, sqliteDecimalStorageCheck as u, sqliteDecimalStorageShape as d, sqliteDecimalStorageType as f } from "./sqliteDecimalStorage.js";
+import { jsonPathSql as p } from "./jsonPath.js";
+import { fireTenantCreateSeeds as m } from "./seed.js";
+import { pgIndexClauses as h } from "./indexStorage.js";
+import { formatDdlError as g } from "./migrations/ddlError.js";
+import { lowerUniqueActive as _ } from "./migrations/uniqueActiveLowering.js";
+import { findCyclicFkBackEdges as v, fkEdgeKey as y } from "./migrations/fkCycles.js";
+import { withMigrationLock as b } from "./migrations/lock.js";
+import { migrationAtomicityFor as ee } from "./migrations/resumeLedger.js";
+import { mssqlJsonValueCheck as te } from "./mssqlJsonValueCheck.js";
+import { DEFAULT_CDC_CHANNEL as x, NOTIFY_BODY_MARKER as ne, notifyFunctionName as S, reactiveTriggerName as re } from "./migrations/reactiveTriggerName.js";
+import { mssqlTextStorageLength as ie } from "./mssqlTextStorage.js";
+import { Effect as C, Schedule as w } from "effect";
+import { SqlClient as T } from "effect/sql";
+import { createLogger as ae } from "@voltro/logger";
+//#region src/migrate.ts
+var E = ae({ scope: "voltro:migrate" }), D = (e) => {
+	E.warn(e.replace(/^\[voltro:migrate\]\s*/, ""));
+}, O = (e, t) => {
+	let n = a(t) ? d(e) : void 0;
+	if (n !== void 0) return f(n);
+	let r = e.type;
+	if (e.spatial) {
+		if (t === "postgres") return `${e.spatial.kind}(${e.spatial.geomKind},${e.spatial.srid})`;
+		throw Error(`@voltro/plugin-postgis: ${e.spatial.kind}('${e.spatial.geomKind}', ${e.spatial.srid}) is postgres-only — the active dialect is '${t}'. PostGIS has no portable equivalent; use store: 'postgres' (or DB_DIALECT=postgres) for spatial columns, or model the value as plain text/json.`);
+	}
+	if (r === "raw") {
+		if (e.rawDdl === void 0) throw Error("raw() column is missing its DDL fragment — this is a framework bug.");
+		return e.rawDdl;
+	}
+	if (r === "array" && e.arrayElement) {
+		if (t === "postgres") return `${O({
+			...e,
+			type: e.arrayElement,
+			arrayElement: void 0
+		}, t)}[]`;
+		if (t === "mysql" || t === "mariadb") return "JSON";
+		if (t === "mssql") return "NVARCHAR(MAX)";
+		if (a(t)) return "TEXT";
+	}
+	if (r === "vector") {
+		let n = e.vectorDim;
+		if (n === void 0) throw Error("vector column is missing its dimension — this is a framework bug.");
+		let r = e.vectorPrecision === "half";
+		if (t === "postgres") return r ? `HALFVEC(${n})` : `VECTOR(${n})`;
+		if (t === "mysql" || t === "mariadb") return `VECTOR(${n})`;
+		if (t === "mssql") return "VARBINARY(MAX)";
+		if (a(t)) return "BLOB";
+	}
+	if (r === "interval") {
+		if (t === "postgres") return "INTERVAL";
+		if (t === "mysql" || t === "mariadb" || t === "mssql") return "BIGINT";
+		if (a(t)) return "INTEGER";
+	}
+	if (r === "decimal") {
+		let n = e.precision, r = e.scale ?? 0;
+		if (n === void 0) throw Error("decimal column is missing its precision — this is a framework bug.");
+		return a(t) ? "NUMERIC" : t === "postgres" ? `NUMERIC(${n}, ${r})` : `DECIMAL(${n}, ${r})`;
+	}
+	if (r === "bigint") return a(t) ? "INTEGER" : "BIGINT";
+	if (r === "enum") {
+		if (t === "postgres") return e.enumName ?? "TEXT";
+		if (t === "mysql" || t === "mariadb") return `ENUM(${(e.enumValues ?? []).map((e) => `'${e.replace(/'/g, "''")}'`).join(", ")})`;
+		if (t === "mssql") return "NVARCHAR(255)";
+		if (a(t)) return "TEXT";
+	}
+	if (r === "text" && e.maxLength !== void 0 && e.generatedAs === void 0) return t === "mssql" ? `NVARCHAR(${e.maxLength})` : a(t) ? "TEXT" : `VARCHAR(${e.maxLength})`;
+	if (a(t)) switch (r) {
+		case "id": return "TEXT";
+		case "text": return "TEXT";
+		case "integer": return "INTEGER";
+		case "real": return "REAL";
+		case "boolean": return "INTEGER";
+		case "timestamp": return "TEXT";
+		case "date": return "TEXT";
+		case "json": return "TEXT";
+		case "bytes": return "BLOB";
+		case "reference": return e.referenceStorage === "numeric" ? "INTEGER" : "TEXT";
+		case "vector": return "BLOB";
+		case "enum": return "TEXT";
+		case "array": return "TEXT";
+		case "interval": return "INTEGER";
+	}
+	if (t === "mysql" || t === "mariadb") switch (r) {
+		case "id": return "VARCHAR(64)";
+		case "text": return e.hasDefault && e.defaultFactory === void 0 || e.oneOf && e.oneOf.length > 0 ? "VARCHAR(255)" : e.generatedAs ? "TEXT" : "LONGTEXT";
+		case "integer": return "INT";
+		case "real": return "DOUBLE";
+		case "boolean": return "TINYINT(1)";
+		case "timestamp": return "DATETIME(6)";
+		case "date": return "DATE";
+		case "json": return "JSON";
+		case "bytes": return "LONGBLOB";
+		case "reference": return e.referenceStorage === "numeric" ? "BIGINT" : "VARCHAR(64)";
+		case "vector": return "VECTOR(0)";
+		case "enum": return "TEXT";
+		case "array": return "JSON";
+		case "interval": return "BIGINT";
+	}
+	if (t === "mssql") switch (r) {
+		case "id": return "NVARCHAR(64)";
+		case "text": {
+			let t = ie(e, !1);
+			return t === void 0 ? "NVARCHAR(MAX)" : `NVARCHAR(${t})`;
+		}
+		case "integer": return "INT";
+		case "real": return "FLOAT";
+		case "boolean": return "BIT";
+		case "timestamp": return "DATETIME2(6)";
+		case "date": return "DATE";
+		case "json": return "NVARCHAR(MAX)";
+		case "bytes": return "VARBINARY(MAX)";
+		case "reference": return e.referenceStorage === "numeric" ? "BIGINT" : "NVARCHAR(64)";
+		case "vector": return "VARBINARY(MAX)";
+		case "enum": return "NVARCHAR(255)";
+		case "array": return "NVARCHAR(MAX)";
+		case "interval": return "BIGINT";
+	}
+	switch (r) {
+		case "id": return "TEXT";
+		case "text": return "TEXT";
+		case "integer": return "INTEGER";
+		case "real": return "DOUBLE PRECISION";
+		case "boolean": return "BOOLEAN";
+		case "timestamp": return "TIMESTAMPTZ";
+		case "date": return "DATE";
+		case "json": return "JSONB";
+		case "bytes": return "BYTEA";
+		case "reference": return e.referenceStorage === "numeric" ? "BIGINT" : "TEXT";
+		case "vector": return "VECTOR";
+		case "enum": return e.enumName ?? "TEXT";
+		case "array": return "TEXT[]";
+		case "interval": return "INTERVAL";
+	}
+}, k = (e, t) => {
+	if (!e.hasDefault || e.defaultFactory !== void 0) return null;
+	let n = a(t) ? d(e) : void 0, r = n ? l(e.defaultValue, n) : e.defaultValue;
+	return r === "now" ? a(t) ? "DEFAULT CURRENT_TIMESTAMP" : t === "mssql" ? "DEFAULT SYSUTCDATETIME()" : t === "mysql" || t === "mariadb" ? "DEFAULT CURRENT_TIMESTAMP(6)" : "DEFAULT now()" : typeof r == "boolean" ? t === "postgres" ? `DEFAULT ${r}` : `DEFAULT ${+!!r}` : typeof r == "number" ? `DEFAULT ${r}` : typeof r == "string" ? `DEFAULT '${r.replace(/'/g, "''")}'` : Array.isArray(r) ? A(r, e, t) : typeof r == "object" && r ? j(r, t) : null;
+}, A = (e, t, n) => {
+	if (n !== "postgres" || t.type !== "array" || t.arrayElement === void 0) return j(e, n);
+	let r = O({
+		...t,
+		type: t.arrayElement,
+		arrayElement: void 0
+	}, n);
+	return `DEFAULT '{${e.map((e) => typeof e == "number" || typeof e == "boolean" ? String(e) : `"${String(e).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`).join(",").replace(/'/g, "''")}}'::${r}[]`;
+}, j = (e, t) => {
+	let n = JSON.stringify(e).replace(/'/g, "''");
+	return t === "postgres" ? `DEFAULT '${n}'::jsonb` : t === "mysql" || t === "mariadb" ? `DEFAULT (CONVERT('${n}' USING utf8mb4))` : `DEFAULT '${n}'`;
+}, M = (e, t) => {
+	switch (t) {
+		case "postgres": return `"${e}" BIGSERIAL PRIMARY KEY`;
+		case "mysql":
+		case "mariadb": return `\`${e}\` BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY`;
+		case "mssql": return `[${e}] BIGINT IDENTITY(1,1) PRIMARY KEY`;
+		case "sqlite": return `"${e}" INTEGER PRIMARY KEY AUTOINCREMENT`;
+		case "turso": return `"${e}" INTEGER PRIMARY KEY`;
+	}
+}, N = (e, t) => {
+	if (e === "restrict" && t === "mssql") return "NO ACTION";
+	switch (e) {
+		case "cascade": return "CASCADE";
+		case "restrict": return "RESTRICT";
+		case "setNull": return "SET NULL";
+		case "noAction": return "NO ACTION";
+	}
+}, P = (e, t, n) => n === null ? o(e, t) : `${o(n, t)}.${o(e, t)}`, oe = 191, se = (e, t) => {
+	if (!e || t !== "mysql" && t !== "mariadb") return !1;
+	let n = O(e, t).toUpperCase();
+	return n.endsWith("TEXT") || n.endsWith("BLOB");
+}, F = (e, t, n) => {
+	let r = o(e, n);
+	if (n !== "mysql" && n !== "mariadb") return r;
+	let i = t[e];
+	if (!i) return r;
+	let a = O(i, n).toUpperCase();
+	return a.endsWith("TEXT") || a.endsWith("BLOB") ? `${r}(${oe})` : r;
+}, ce = (e, t) => {
+	if (!e.generatedAs) return null;
+	let { expr: n, stored: r } = e.generatedAs;
+	return t === "postgres" ? (r || D("[voltro:migrate] generated column requested as VIRTUAL but postgres only supports STORED — promoting"), `GENERATED ALWAYS AS (${n}) STORED`) : t === "mysql" || t === "mariadb" ? `GENERATED ALWAYS AS (${n}) ${r ? "STORED" : "VIRTUAL"}` : t === "mssql" ? `AS (${n})${r ? " PERSISTED" : ""}` : `GENERATED ALWAYS AS (${n}) ${r ? "STORED" : "VIRTUAL"}`;
+}, le = (e, t, n, r, s = !1, c = !1) => {
+	if (t.type === "id" && t.idScheme?.kind === "numeric") return M(e, n);
+	let l = n === "mssql" ? ie(t, r?.has(e) ?? !1) : void 0, f = l === void 0 ? O(t, n) : `NVARCHAR(${l})`, p = [o(e, n), f], m = a(n) ? d(t) : void 0;
+	m !== void 0 && p.push(`CHECK (${u(o(e, n), m)})`), t.type === "id" && !c && p.push("PRIMARY KEY");
+	let h = ce(t, n);
+	if (h) p.push(h);
+	else {
+		t.nullable || p.push("NOT NULL"), t.unique && t.type !== "id" && !se(t, n) && p.push("UNIQUE");
+		let e = k(t, n);
+		e && p.push(e);
+	}
+	if (t.type === "reference" && t.references && !s && !i(n)) {
+		let e = t.references();
+		p.push(`REFERENCES ${o(e.tableName, n)} (${o(t.referenceColumn ?? "id", n)})`);
+		let r = N(t.onDelete ?? "restrict", n);
+		p.push(`ON DELETE ${r}`);
+		let i = N(t.refOnUpdate ?? "noAction", n);
+		i !== "NO ACTION" && p.push(`ON UPDATE ${i}`);
+	}
+	if (t.oneOf && t.oneOf.length > 0) {
+		let r = t.oneOf.map((e) => `'${e.replace(/'/g, "''")}'`).join(", ");
+		p.push(`CHECK (${o(e, n)} IN (${r}))`);
+	}
+	if (t.checks && t.checks.length > 0) for (let e of t.checks) p.push(`CHECK (${e})`);
+	if (t.type === "enum" && t.enumValues && t.enumValues.length > 0 && (n === "mssql" || a(n))) {
+		let r = t.enumValues.map((e) => `'${e.replace(/'/g, "''")}'`).join(", ");
+		p.push(`CHECK (${o(e, n)} IN (${r}))`);
+	}
+	if (t.type === "json" || t.type === "array") {
+		let r = o(e, n);
+		a(n) ? p.push(`CHECK (${r} IS NULL OR json_valid(${r}))`) : n === "mssql" && p.push(t.type === "json" ? `CHECK ${te(r)}` : `CHECK (${r} IS NULL OR ISJSON(${r}) = 1)`);
+	}
+	return p.join(" ");
+}, I = (e, t) => {
+	if (t.charset !== void 0) {
+		if (!i(e)) throw Error(`store charset '${t.charset}' is declared for a ${e} store — a character set is a MySQL / MariaDB setting. Remove \`charset\` from \`store\` in app.config.ts, or declare \`store: { dialect: 'mysql' | 'mariadb', charset }\`.`);
+		return t.charset;
+	}
+}, L = (t, n, r = null, a, s) => {
+	let c = /* @__PURE__ */ new Set();
+	for (let e of t.appliedIndexes ?? []) for (let t of e.fields) typeof t == "string" && c.add(t);
+	for (let e of t.appliedUniques ?? []) for (let t of e.fields) typeof t == "string" && c.add(t);
+	for (let [e, n] of Object.entries(t.fields)) n.unique && c.add(e);
+	let l = t.appliedPrimaryKey ?? [];
+	for (let e of l) c.add(e);
+	let u = l.length > 0, d = e(t).map((e) => [e, t.fields[e]]).map(([e, t]) => `  ${le(e, t, n, c, a?.has(e) ?? !1, u)}`).join(",\n"), f = (t.appliedUniques ?? []).map((e) => {
+		let r = e.fields.map((e) => F(e, t.fields, n)).join(", ");
+		return `  CONSTRAINT ${o(e.name, n)} UNIQUE (${r})`;
+	}), p = (t.appliedChecks ?? []).map((e) => `  CONSTRAINT ${o(e.name, n)} CHECK (${e.expr})`), m = u ? [`  PRIMARY KEY (${l.map((e) => F(e, t.fields, n)).join(", ")})`] : [], h = i(n) ? Object.entries(t.fields).flatMap(([e, i]) => {
+		if (i.type !== "reference" || !i.references || (a?.has(e) ?? !1)) return [];
+		let s = i.references(), c = N(i.onDelete ?? "restrict", n), l = N(i.refOnUpdate ?? "noAction", n);
+		return [`  CONSTRAINT ${o(`${t.tableName}_${e}_fkey`, n)} FOREIGN KEY (${o(e, n)}) REFERENCES ${P(s.tableName, n, r)} (${o(i.referenceColumn ?? "id", n)}) ON DELETE ${c}${l === "NO ACTION" ? "" : ` ON UPDATE ${l}`}`];
+	}) : [], g = [
+		...m,
+		...f,
+		...p,
+		...h
+	], _ = g.length > 0 ? `${d},\n${g.join(",\n")}` : d, v = P(t.tableName, n, r);
+	if (n === "mssql") {
+		let e = r === null ? t.tableName : `${r}.${t.tableName}`, n = `CREATE TABLE ${v} (\n${_}\n)`;
+		return `IF OBJECT_ID('${e.replace(/'/g, "''")}', 'U') IS NULL EXEC(N'${n.replace(/'/g, "''")}');`;
+	}
+	return [
+		`CREATE TABLE IF NOT EXISTS ${v} (`,
+		_,
+		`)${s !== void 0 && i(n) ? ` DEFAULT CHARACTER SET ${s}` : ""};`
+	].join("\n");
+}, ue = (e, t, n) => {
+	let r = `${e}_${t.name}_fts`, i = (e) => o(e, n), a = t.columns.map(i).join(", "), s = t.columns.map((e) => `new.${i(e)}`).join(", "), c = [];
+	return c.push(`CREATE VIRTUAL TABLE IF NOT EXISTS ${i(r)} USING fts5(${a}, row_id UNINDEXED, tokenize='porter');`), c.push(`CREATE TRIGGER IF NOT EXISTS ${i(`${r}_ai`)} AFTER INSERT ON ${i(e)} BEGIN\n  INSERT INTO ${i(r)} (${a}, row_id) VALUES (${s}, new.${i("id")});\nEND;`), c.push(`CREATE TRIGGER IF NOT EXISTS ${i(`${r}_ad`)} AFTER DELETE ON ${i(e)} BEGIN\n  DELETE FROM ${i(r)} WHERE row_id = old.${i("id")};\nEND;`), c.push(`CREATE TRIGGER IF NOT EXISTS ${i(`${r}_au`)} AFTER UPDATE ON ${i(e)} BEGIN\n  DELETE FROM ${i(r)} WHERE row_id = old.${i("id")};\n  INSERT INTO ${i(r)} (${a}, row_id) VALUES (${s}, new.${i("id")});\nEND;`), c;
+}, R = (e) => e.appliedFullText ?? [], z = (e, t) => {
+	let n = [];
+	for (let r of R(e)) if (t === "postgres") {
+		let i = r.config ?? "english", a = `${r.name}_tsv`, s = r.columns.map((e) => {
+			let n = r.weights?.[e] ?? "A";
+			return `setweight(to_tsvector('${i}', coalesce(${o(e, t)}, '')), '${n}')`;
+		}).join(" || ");
+		n.push(`ALTER TABLE ${o(e.tableName, t)} ADD COLUMN IF NOT EXISTS ${o(a, t)} tsvector GENERATED ALWAYS AS (${s}) STORED;`), n.push(`CREATE INDEX IF NOT EXISTS ${o(r.name, t)} ON ${o(e.tableName, t)} USING GIN (${o(a, t)});`);
+	} else if (t === "mysql" || t === "mariadb") {
+		let i = r.columns.map((e) => o(e, t)).join(", ");
+		n.push(`CREATE FULLTEXT INDEX ${o(r.name, t)} ON ${o(e.tableName, t)} (${i});`);
+	} else t === "turso" || t === "sqlite" && n.push(...ue(e.tableName, r, t));
+	return n;
+}, B = (e, t, n = null) => {
+	let r = [], i = /* @__PURE__ */ new Set(), s = (e) => e.join("\0"), c = (e, n, r, i, a) => {
+		if (t === "postgres") return h(r, i, a);
+		let o = {
+			using: "",
+			withSuffix: "",
+			skip: !1
+		};
+		return r === void 0 || r === "btree" ? o : r === "gist" ? (D(`[voltro:migrate] index '${e}' on '${n}': ${t} doesn't support GiST — falling back to btree. Spatial queries on this column will fall back to sequential scan.`), o) : r === "gin" ? t === "mysql" || t === "mariadb" ? (D(`[voltro:migrate] gin index '${e}' on '${n}': ${t} has no GIN access method — skipping (a btree on a JSON/array column can't serve containment/membership queries). Add a generated column for the specific path you query, then index that with .expressionIndex(...).`), {
+			using: "",
+			withSuffix: "",
+			skip: !0
+		}) : (D(`[voltro:migrate] gin index '${e}' on '${n}': ${t} has no GIN access method — falling back to btree. Containment/membership queries won't use this index efficiently.`), o) : r === "brin" ? (D(`[voltro:migrate] brin index '${e}' on '${n}': ${t} has no BRIN access method — falling back to btree (larger on disk, but the range scan still works).`), o) : r === "hnsw" ? (D(`[voltro:migrate] hnsw index '${e}' on '${n}': ${t} has no pgvector / HNSW access method — skipping. Nearest-neighbour queries on this column fall back to a sequential scan.`), {
+			using: "",
+			withSuffix: "",
+			skip: !0
+		}) : o;
+	}, l = (n, r) => {
+		let i = n.map((n) => {
+			if (typeof n == "string") return F(n, e.fields, t);
+			if ("jsonPath" in n) {
+				let { column: e, path: r, numeric: i } = n.jsonPath;
+				return `(${p(e, r, t, { numeric: i })})`;
+			}
+			return `(${n.expr})`;
+		});
+		return r !== void 0 && i.length === 1 ? `${i[0]} ${r}` : i.join(", ");
+	}, u = (r, i, s, u, d, f = "", p = !1) => {
+		let m = s[0], h = typeof m == "string" ? e.fields[m]?.vectorPrecision : void 0, g = c(r, i, u, d, h);
+		if (g.skip) return "";
+		let _ = l(s, g.opclass), v = `${g.withSuffix}${f}`, y = P(i, t, n), b = p ? "UNIQUE " : "";
+		return a(t) && n !== null ? `CREATE ${b}INDEX IF NOT EXISTS ${P(r, t, n)} ON ${o(i, t)} (${_})${v};` : t === "mssql" ? `IF NOT EXISTS (SELECT 1 FROM sys.indexes WHERE name = '${r}') CREATE ${b}INDEX ${o(r, t)} ON ${y}${g.using} (${_})${v};` : t === "mysql" ? `CREATE ${b}INDEX ${o(r, t)} ON ${y}${g.using} (${_})${v};` : `CREATE ${b}INDEX IF NOT EXISTS ${o(r, t)} ON ${y}${g.using} (${_})${v};`;
+	};
+	if (t === "mysql" || t === "mariadb") for (let [n, i] of Object.entries(e.fields)) {
+		if (!i.unique || i.type === "id" || !se(i, t)) continue;
+		let a = u(`${e.tableName}_${n}_key`, e.tableName, [n], void 0, void 0, "", !0);
+		a && r.push(a);
+	}
+	if (r.push(...z(e, t)), t === "mssql") for (let n of R(e)) D(`[voltro:migrate] full-text index '${n.name}' on '${e.tableName}': ${t} uses a ranked LIKE search at query time (no native FTS catalog required).`);
+	for (let n of e.appliedIndexes) {
+		if ((t === "mariadb" || t === "mssql") && n.fields.some((e) => typeof e != "string" && "jsonPath" in e)) {
+			D(`[voltro:migrate] json-path index '${n.name}' on '${e.tableName}': ${t} cannot index a JSON expression directly — skipping. For an indexed JSON path on ${t}, add a generated column for the path (text().generatedAs(...) / .stored()) and .index([...]) it, then filter on that column instead of jsonField(...).`);
+			continue;
+		}
+		if (n.unique && n.where !== void 0 && n.where.length > 0 && (t === "mysql" || t === "mariadb")) throw Error(`@voltro/migrate: uniqueActive index '${n.name}' on '${e.tableName}' cannot be expressed on ${t} — it has no partial (WHERE) index support, and a full UNIQUE index would forbid re-creating a soft-deleted row. Use a generated STORED column (text().generatedAs("CASE WHEN \`deletedAt\` IS NULL THEN <key> ELSE NULL END", { stored: true })) + .unique([...]) on ${t}, or move this table to postgres/sqlite/mssql.`);
+		let a = "";
+		n.where !== void 0 && n.where.length > 0 && (t === "mysql" || t === "mariadb" ? D(`[voltro:migrate] partial index '${n.name}' on '${e.tableName}': ${t} does not support WHERE clauses on indexes — emitting a full index`) : a = ` WHERE ${n.where}`);
+		let o = u(n.name, e.tableName, n.fields, n.kind, n.kindOptions, a, n.unique === !0);
+		o !== "" && r.push(o), n.fields.every((e) => typeof e == "string") && i.add(s(n.fields));
+	}
+	for (let [t, n] of Object.entries(e.fields)) {
+		if (n.type !== "reference" || n.fkAutoIndex === !1 || i.has(s([t]))) continue;
+		let a = `${e.tableName}_${t}_idx`;
+		r.push(u(a, e.tableName, [t])), i.add(s([t]));
+	}
+	return r.join("\n");
+}, V = (e, t, n = x) => {
+	if (t !== "postgres") return [];
+	let r = e.filter((e) => e.isReactive !== !1);
+	return r.length === 0 ? [] : [H(n), ...r.map((e) => de(e, n))];
+}, H = (e) => `
+CREATE OR REPLACE FUNCTION ${S(e)}() RETURNS trigger AS $$
+DECLARE
+  payload TEXT;
+  pk JSONB;
+BEGIN
+  -- ${ne}
+  payload := json_build_object(
+    'table',  TG_TABLE_NAME,
+    -- The schema the write landed in. Under namespace isolation this is
+    -- the tenant schema (tenant_<id>); the CDC consumer uses it so a
+    -- write in tenant A namespace does not spuriously wake tenant B
+    -- subscriptions on the same-named table. public/absent = shared.
+    'schema', TG_TABLE_SCHEMA,
+    'op',     lower(TG_OP),
+    'old',    CASE WHEN TG_OP = 'INSERT' THEN NULL ELSE row_to_json(OLD) END,
+    'new',    CASE WHEN TG_OP = 'DELETE' THEN NULL ELSE row_to_json(NEW) END
+  )::text;
+  -- pg_notify hard-caps the payload at 8000 bytes; a wide reactive row
+  -- (big text / json column) would otherwise abort the write itself. So the
+  -- images are dropped — but the PRIMARY KEY is kept, and that is the whole
+  -- difference between a slow path and data loss. A subscription re-queries on
+  -- an image-less event and is fine either way; a TAP (search index, analytics
+  -- mirror, cdc-out, row history) has nothing to apply and used to drop the
+  -- change silently and forever. With the key, the CDC consumer re-reads the
+  -- row before anyone sees the event (sql-postgres/src/cdcRehydrate.ts).
+  --
+  -- to_jsonb(REC) -> 'id' rather than REC.id: a reactive table with no id
+  -- column would make the field reference a runtime error inside the trigger,
+  -- which aborts the user's WRITE. The json operator answers NULL instead.
+  IF octet_length(payload) >= 7999 THEN
+    pk := CASE WHEN TG_OP = 'DELETE' THEN to_jsonb(OLD) -> 'id' ELSE to_jsonb(NEW) -> 'id' END;
+    payload := json_build_object(
+      'table',     TG_TABLE_NAME,
+      'schema',    TG_TABLE_SCHEMA,
+      'op',        lower(TG_OP),
+      'old',       NULL,
+      'new',       NULL,
+      'id',        pk,
+      'oversized', true
+    )::text;
+    -- A key can itself be oversized (a pathological text primary key). Carrying
+    -- it would put us back where the cap check started: pg_notify raises, and
+    -- the trigger takes the user's write down with it. Dropping it costs the
+    -- re-read and is counted as unrecovered — never the write.
+    IF octet_length(payload) >= 7999 THEN
+      payload := json_build_object(
+        'table',     TG_TABLE_NAME,
+        'schema',    TG_TABLE_SCHEMA,
+        'op',        lower(TG_OP),
+        'old',       NULL,
+        'new',       NULL,
+        'oversized', true
+      )::text;
+    END IF;
+  END IF;
+  PERFORM pg_notify('${e}', payload);
+  RETURN COALESCE(NEW, OLD);
+END;
+$$ LANGUAGE plpgsql;
+`.trim(), U = (e, t) => {
+	let n = re(e.tableName, t);
+	return [
+		`ALTER TABLE "${e.tableName}" REPLICA IDENTITY FULL`,
+		`DROP TRIGGER IF EXISTS ${n} ON "${e.tableName}"`,
+		`CREATE TRIGGER ${n}\nAFTER INSERT OR UPDATE OR DELETE ON "${e.tableName}"\nFOR EACH ROW EXECUTE FUNCTION ${S(t)}()`
+	];
+}, de = (e, t) => U(e, t).map((e) => `${e};`).join("\n"), fe = (e) => {
+	if (e.dialect !== "postgres") return [];
+	let t = e.channel ?? "framework_changes", n = new Map(e.tables.map((e) => [e.tableName, e])), r = [], i = e.missing.filter((e) => n.has(e));
+	(i.length > 0 || e.functionOutdated === !0) && r.push(H(t));
+	for (let e of i) r.push(...U(n.get(e), t));
+	for (let n of e.stale) r.push(`DROP TRIGGER IF EXISTS ${re(n, t)} ON "${n}"`), r.push(`ALTER TABLE "${n}" REPLICA IDENTITY DEFAULT`);
+	return r;
+}, W = (e, t) => {
+	if (t !== "postgres") return;
+	let n = [];
+	return pe(e) && n.push("CREATE EXTENSION IF NOT EXISTS vector;"), me(e) && n.push("CREATE EXTENSION IF NOT EXISTS postgis;"), e.some((e) => e.appliedIndexes?.some((e) => e.kind === "gin" && r(e.kindOptions)?.split(".").at(-1) === "gin_trgm_ops")) && n.push("CREATE EXTENSION IF NOT EXISTS pg_trgm;"), n.length === 0 ? void 0 : n.join("\n");
+}, pe = (e) => e.some((e) => Object.values(e.fields).some((e) => e.type === "vector")), me = (e) => e.some((e) => Object.values(e.fields).some((e) => e.spatial !== void 0)), G = (e) => {
+	let t = new Map(e.map((e) => [e.tableName, e])), n = v(e.map((e) => e.tableName), (e) => {
+		let n = t.get(e);
+		return n ? Object.entries(n.fields).flatMap(([e, n]) => {
+			if (n.type !== "reference" || !n.references) return [];
+			let r = n.references().tableName;
+			return t.has(r) ? [{
+				column: e,
+				target: r
+			}] : [];
+		}) : [];
+	}), r = [];
+	for (let t of e) for (let [e, i] of Object.entries(t.fields)) i.type === "reference" && i.references && n.has(y(t.tableName, e)) && r.push({
+		table: t.tableName,
+		column: e,
+		targetTable: i.references().tableName,
+		targetColumn: i.referenceColumn ?? "id",
+		onDelete: i.onDelete ?? "restrict",
+		onUpdate: i.refOnUpdate ?? "noAction"
+	});
+	let i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), o = [], s = (e) => {
+		if (!(i.has(e.tableName) || a.has(e.tableName))) {
+			a.add(e.tableName);
+			for (let [r, i] of Object.entries(e.fields)) {
+				if (i.type !== "reference" || !i.references || n.has(y(e.tableName, r))) continue;
+				let a = i.references();
+				if (a.tableName === e.tableName) continue;
+				let o = t.get(a.tableName);
+				o && s(o);
+			}
+			a.delete(e.tableName), i.add(e.tableName), o.push(e);
+		}
+	};
+	for (let t of e) s(t);
+	return {
+		sorted: o,
+		cyclic: r
+	};
+}, K = (e, t, n = null) => {
+	let r = (e) => n ? `${o(n, t)}.${o(e, t)}` : o(e, t), i = `${e.table}_${e.column}_fkey`, a = N(e.onDelete, t), s = N(e.onUpdate, t), c = ` ON DELETE ${a}${s === "NO ACTION" ? "" : ` ON UPDATE ${s}`}`, l = (n) => `ADD CONSTRAINT ${o(i, t)} FOREIGN KEY ${n ? "IF NOT EXISTS " : ""}(${o(e.column, t)}) REFERENCES ${r(e.targetTable)} (${o(e.targetColumn, t)})${c}`;
+	switch (t) {
+		case "postgres": return [
+			"DO $$ BEGIN",
+			"  IF NOT EXISTS (SELECT 1 FROM pg_constraint",
+			`    WHERE conname = '${i}' AND conrelid = '${n ? `${n}.` : ""}${e.table}'::regclass) THEN`,
+			`    ALTER TABLE ${r(e.table)} ${l(!1)};`,
+			"  END IF;",
+			"END $$;"
+		].join("\n");
+		case "mssql": return `IF NOT EXISTS (SELECT 1 FROM sys.foreign_keys WHERE name = '${i}') ALTER TABLE ${r(e.table)} ${l(!1)};`;
+		case "mariadb": return `ALTER TABLE ${r(e.table)} ${l(!0)};`;
+		default: return `ALTER TABLE ${r(e.table)} ${l(!1)};`;
+	}
+}, q = (e, t) => {
+	let n = /* @__PURE__ */ new Map();
+	if (a(t)) return n;
+	for (let t of e) {
+		let e = n.get(t.table) ?? /* @__PURE__ */ new Set();
+		e.add(t.column), n.set(t.table, e);
+	}
+	return n;
+}, J = (e, t) => {
+	if (t !== "postgres") return "";
+	let n = /* @__PURE__ */ new Map();
+	for (let t of e) for (let e of Object.values(t.fields)) {
+		if (e.type !== "enum" || !e.enumName || !e.enumValues) continue;
+		let t = n.get(e.enumName);
+		if (t && t.length !== e.enumValues.length) throw Error(`dbEnum '${e.enumName}' declared with conflicting value sets across tables. Define it once and re-use the handle.`);
+		n.set(e.enumName, e.enumValues);
+	}
+	if (n.size === 0) return "";
+	let r = [];
+	for (let [e, t] of n) {
+		let n = t.map((e) => `'${e.replace(/'/g, "''")}'`).join(", ");
+		r.push(`DO $$ BEGIN\n  IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = '${e.replace(/'/g, "''")}') THEN\n    CREATE TYPE "${e}" AS ENUM (${n});\n  END IF;\nEND $$;`);
+	}
+	return r.join("\n\n");
+}, Y = (e, t) => {
+	if (t !== "postgres") return "";
+	let r = /* @__PURE__ */ new Set();
+	for (let t of e) for (let e of Object.values(t.fields)) e.type === "enum" && e.enumName && r.add(e.enumName);
+	let i = [];
+	for (let e of r) for (let { from: t, to: r } of n(e)) {
+		let n = e.replace(/'/g, "''"), a = t.replace(/'/g, "''"), o = r.replace(/'/g, "''");
+		i.push(`DO \$\$
+DECLARE
+  type_oid oid;
+BEGIN
+  SELECT oid INTO type_oid FROM pg_type WHERE typname = '${n}';\n  IF type_oid IS NOT NULL\n     AND EXISTS (SELECT 1 FROM pg_enum WHERE enumtypid = type_oid AND enumlabel = '${a}')\n     AND NOT EXISTS (SELECT 1 FROM pg_enum WHERE enumtypid = type_oid AND enumlabel = '${o}') THEN\n    IF current_setting('server_version_num')::int >= 140000 THEN\n      EXECUTE format('ALTER TYPE %I RENAME VALUE %L TO %L', '${n}', '${a}', '${o}');\n    ELSE\n      UPDATE pg_enum SET enumlabel = '${o}' WHERE enumtypid = type_oid AND enumlabel = '${a}';\n    END IF;\n  END IF;\nEND $$;`);
+	}
+	return i.join("\n\n");
+}, he = (e) => {
+	let t = [], n = [];
+	for (let r of e) s(r) ? n.push(r) : t.push(r);
+	return {
+		tables: t,
+		views: n
+	};
+}, X = (e, t, n = x, r = {}) => {
+	let i = I(t, r), { tables: o, views: s } = he(e), { sorted: l, cyclic: u } = G(o.map((e) => _(e, t))), d = q(u, t), f = [], p = W(l, t);
+	p && f.push(p);
+	let m = Y(l, t);
+	m && f.push(m);
+	let h = J(l, t);
+	h && f.push(h);
+	for (let e of l) f.push(L(e, t, null, d.get(e.tableName), i));
+	if (!a(t)) for (let e of u) f.push(K(e, t));
+	for (let e of l) {
+		let n = B(e, t);
+		n && f.push(n);
+	}
+	f.push(...V(l, t, n));
+	for (let e of s) f.push(c(e, t));
+	return f.join("\n\n") + "\n";
+}, ge = (e, t, n, r) => {
+	let i = o(e, t);
+	switch (t) {
+		case "postgres": return `CREATE SCHEMA IF NOT EXISTS ${i};`;
+		case "mysql":
+		case "mariadb": return `CREATE DATABASE IF NOT EXISTS ${i}${r === void 0 ? "" : ` CHARACTER SET ${r}`};`;
+		case "mssql": return `IF SCHEMA_ID('${e.replace(/'/g, "''")}') IS NULL EXEC(N'CREATE SCHEMA ${i.replace(/'/g, "''")}');`;
+		case "turso":
+		case "sqlite": return `ATTACH DATABASE '${(n ?? `${e}.db`).replace(/'/g, "''")}' AS ${i};`;
+	}
+}, _e = (e, t, n, r, i = {}) => {
+	let s = I(t, i), c = ge(n, t, r, s), l = o(n, t);
+	if (t === "postgres") return `${c}\n\nSET search_path TO ${l};\n\n${X(e, t)}`;
+	let { sorted: u, cyclic: d } = G(e), f = q(d, t), p = [c];
+	for (let e of u) p.push(L(e, t, n, f.get(e.tableName), s));
+	if (!a(t)) for (let e of d) p.push(K(e, t, n));
+	for (let e of u) {
+		let r = B(e, t, n);
+		r && p.push(r);
+	}
+	return p.join("\n\n") + "\n";
+}, ve = (e, t, n = x) => {
+	let { sorted: r, cyclic: i } = G(e), a = q(i, t), o = [], s = Y(r, t);
+	s && o.push(s);
+	let c = J(r, t);
+	c && o.push(c);
+	for (let e of r) o.push(L(e, t, null, a.get(e.tableName)));
+	for (let e of i) o.push(K(e, t));
+	return o.push(...V(r, t, n)), o.join("\n\n") + "\n";
+}, ye = (e, t = "postgres", n = x, r = {}) => C.gen(function* () {
+	let i = yield* T.SqlClient, a = X(e, t, n, { charset: r.charset });
+	yield* b(i, Q(i, a, t, r.retryFilter), { schema: r.lockSchema }).pipe(C.orDie);
+}), be = (e, n) => {
+	let r = t(n);
+	return (r.dbErrno === 1061 || r.dbCode === "ER_DUP_KEYNAME") && /^\s*CREATE\s+(UNIQUE\s+|FULLTEXT\s+)?INDEX\b/i.test(e);
+}, xe = (e, t) => C.gen(function* () {
+	let n = yield* T.SqlClient, r = e.flatMap((e) => z(e, t));
+	for (let e of r) yield* n.unsafe(e).pipe(C.catchIf((t) => be(e, t), () => C.succeed([])));
+	return r.length;
+}), Se = (e, t) => {
+	let n = e.trimStart();
+	return !!(/\bIF NOT EXISTS\b/i.test(n) || /^CREATE OR REPLACE\b/i.test(n) || /^DROP\s[\s\S]*?\bIF EXISTS\b/i.test(n) || /^SET search_path\b/i.test(n) || /^USE[\s`"[]/i.test(n) || /^IF\s/i.test(n) || (t === "mysql" || t === "mariadb") && /^CREATE\s+(UNIQUE\s+|FULLTEXT\s+)?INDEX\b/i.test(n));
+}, Ce = () => {
+	let e = Number(process.env.VOLTRO_MIGRATION_DDL_RETRIES);
+	return Number.isInteger(e) && e >= 0 ? e : 4;
+}, we = (e) => ({
+	while: e,
+	times: Ce(),
+	schedule: w.jittered(w.exponential("50 millis"))
+}), Z = class {
+	statement;
+	error;
+	_tag = "DdlStatementFailed";
+	constructor(e, t) {
+		this.statement = e, this.error = t;
+	}
+}, Te = (e, t, n) => C.gen(function* () {
+	let r = yield* T.SqlClient, i = n !== void 0 && ee(t) === "per-operation";
+	for (let a of Ee(e)) {
+		process.env.VOLTRO_MIGRATE_DEBUG === "1" && E.debug(`EXEC: ${a.replace(/\s+/g, " ").slice(0, 180)}`);
+		let e = r.unsafe(a).pipe(C.catchIf((e) => be(a, e), () => C.succeed([])), C.tapError((e) => C.sync(() => {
+			E.error(g("migrate: statement failed", a, e, 200));
+		})));
+		yield* (i && n !== void 0 && Se(a, t) ? e.pipe(C.retry(we((e) => n(e) === "retry"))) : e).pipe(C.mapError((e) => new Z(a, e)));
+	}
+}), Q = (e, t, n, r) => {
+	let i = n === "turso" ? Te(t, n, r) : e.withTransaction(Te(t, n, r)), a = (e) => e instanceof Z ? e.error : e;
+	return (r !== void 0 && ee(n) === "plan-transactional" ? i.pipe(C.retry(we((e) => r(a(e)) === "retry"))) : i).pipe(C.catch((e) => C.die(e instanceof Z ? Error(g("migrate: statement failed", e.statement, e.error, 400).trim()) : e)));
+}, Ee = (e) => {
+	let t = [], n = "", r = !1;
+	for (let i = 0; i < e.length; i++) {
+		if (e.slice(i, i + 2) === "$$") {
+			r = !r, n += "$$", i += 1;
+			continue;
+		}
+		let a = e[i], o = /^\s*CREATE\s+(?:TEMP(?:ORARY)?\s+)?TRIGGER\b[\s\S]*\bBEGIN\b/i.test(n) && !/\bEND\s*$/i.test(n);
+		if (a === ";" && !r && o) n += a;
+		else if (a === ";" && !r) {
+			let e = n.trim();
+			e.length > 0 && t.push(e), n = "";
+		} else n += a;
+	}
+	let i = n.trim();
+	return i.length > 0 && t.push(i), t;
+}, De = async (e, t, n = "postgres", r = {}) => {
+	await C.runPromise(ye(e, n, void 0, r).pipe(C.provide(t)));
+}, $ = (e, t, n = "postgres", r = {}) => C.gen(function* () {
+	let i = _e(e, n, t, void 0, { charset: r.charset }), a = yield* T.SqlClient;
+	yield* b(a, Q(a, i, n, r.retryFilter), { schema: r.lockSchema }).pipe(C.orDie);
+}), Oe = async (e, t, n, r = "postgres", i = {}) => {
+	await C.runPromise($(e, t, r, i).pipe(C.provide(n))), await m({
+		namespace: t,
+		dialect: r
+	});
+}, ke = async (e, t, n = "postgres", r = {}) => {
+	await C.runPromise(C.gen(function* () {
+		let t = ve(e, n), i = yield* T.SqlClient;
+		yield* b(i, Q(i, t, n, r.retryFilter), { schema: r.lockSchema }).pipe(C.orDie);
+	}).pipe(C.provide(t)));
+};
+//#endregion
+export { x as DEFAULT_CDC_CHANNEL, $ as applyNamespacedSchema, ye as applySchema, A as defaultArrayClause, k as defaultClause, j as defaultJsonClause, ve as emitFrameworkBootstrapSql, ge as emitNamespaceProvisionDdl, _e as emitNamespacedSchemaSql, X as emitSchemaSql, xe as ensureFullTextIndexes, Y as enumRenameBlocks, J as enumTypeBlocks, W as extensionBlocks, z as fullTextIndexSql, Se as isReRunSafeDdl, M as numericIdSql, Oe as provisionTenantNamespace, fe as reactiveTriggerRepairSql, ke as runFrameworkBootstrap, De as runMigrate, Ee as splitStatements, O as sqlType };

package/dist/migration.js

@@ -0,0 +1,18 @@
+//#region src/migration.ts
+var e = (e, { apply: t, undo: n }) => ({
+	name: e,
+	apply: t,
+	undo: n
+}), t = (t) => {
+	if (!/^\d{14}_/.test(t.id)) throw Error(`migration "${t.id}": id must start with a 14-digit timestamp followed by "_" (convention: <YYYYMMDDHHMMSS>_<slug>)`);
+	let n = t.steps({ step: e });
+	if (n.length === 0) throw Error(`migration "${t.id}": at least one step is required`);
+	return {
+		__migration: !0,
+		id: t.id,
+		name: t.name,
+		steps: n
+	};
+}, n = (e) => typeof e == "object" && !!e && "__migration" in e && e.__migration === !0;
+//#endregion
+export { t as defineMigration, n as isMigrationDefinition };

package/dist/migrations/appliedAtValue.js

@@ -0,0 +1,8 @@
+import { Effect as e } from "effect";
+//#region src/migrations/appliedAtValue.ts
+var t = (t, n) => t.onDialectOrElse({
+	mysql: () => e.succeed(n.replace("T", " ").replace("Z", "")),
+	orElse: () => e.succeed(n)
+});
+//#endregion
+export { t as appliedAtValue };