@voltro/database 0.84.0 → 0.86.0

package/dist/migrations/fileBased.js

@@ -0,0 +1,57 @@
+import { Effect as e } from "effect";
+//#region src/migrations/fileBased.ts
+var t = ["before-schema", "after-schema"], n = (e) => {
+	if (!e.id || e.id.length === 0) throw Error("migration: `id` is required + must be non-empty");
+	if (!e.up || !e.down) throw Error(`migration ${e.id}: both \`up\` and \`down\` must be functions`);
+	if (!t.includes(e.phase)) throw Error(`migration ${e.id}: \`phase\` is required and must be one of ${t.map((e) => `'${e}'`).join(" | ")} — 'before-schema' runs before the declarative apply (a shape change the planner must not compute against), 'after-schema' runs after it (a body that needs the new shape, such as a back-fill into a table this deploy creates)`);
+	return e;
+}, r = Symbol.for("voltro.migration.irreversible"), i = class extends Error {
+	migrationId;
+	reason;
+	_tag = "IrreversibleMigrationError";
+	constructor(e, t) {
+		super(`migration ${e} cannot be rolled back: ${t}`), this.migrationId = e, this.reason = t, this.name = "IrreversibleMigrationError";
+	}
+}, a = (t) => {
+	if (!t || t.trim().length === 0) throw Error("irreversible(): a reason is required");
+	return Object.assign(() => e.fail(new i("<unknown>", t)), { [r]: t });
+}, o = (e) => {
+	let t = e[r];
+	return typeof t == "string" ? t : void 0;
+}, s = class {
+	reason;
+	_tag = "MigrationSkipped";
+	constructor(e) {
+		this.reason = e;
+	}
+}, c = class extends Error {
+	migrationId;
+	failed;
+	_tag = "MigrationExpectationFailed";
+	constructor(e, t) {
+		super(`migration ${e}: ${t.length} post-condition(s) did not hold after up():\n` + t.map((e) => `  - ${e}`).join("\n") + "\n  The migration is NOT recorded; the next run applies it again."), this.migrationId = e, this.failed = t, this.name = "MigrationExpectationFailed";
+	}
+}, l = class extends Error {
+	migrationId;
+	dialect;
+	_tag = "TransactionBrokenByBodyError";
+	constructor(e, t) {
+		super(`migration ${e} is transactional, and its body COMMITTED the transaction from inside — on ${t} a DDL statement commits everything before it. The work is in the database and the migration is recorded; it will not run again. What did not hold is the all-or-nothing guarantee. Either mark it \`transactional: false\` (per-statement, resumable through your own idempotency) or move the schema change into \`ctx.schema\` in a migration of its own and keep this one to data.`), this.migrationId = e, this.dialect = t, this.name = "TransactionBrokenByBodyError";
+	}
+}, u = class extends Error {
+	migrationId;
+	operation;
+	_tag = "MigrationNeedsSqlClient";
+	constructor(e, t, n) {
+		super(`migration ${e}: ${t} — ${n}`), this.migrationId = e, this.operation = t, this.name = "MigrationNeedsSqlClient";
+	}
+}, d = class extends Error {
+	table;
+	report;
+	_tag = "RewriteUnstableError";
+	constructor(e, t) {
+		super(`rewrite of ${e} did not stabilise after ${t.passes} pass(es): ${t.rewritten} rewritten, ${t.contended} contended on the last pass. Check for concurrent writes and guard values that cannot round-trip exactly before raising maxPasses.`), this.table = e, this.report = t, this.name = "RewriteUnstableError";
+	}
+}, f = /^\d{8}_\d{6}_[a-z0-9_]+\.ts$/, p = (e) => typeof e == "object" && !!e && "id" in e && "up" in e && "down" in e && typeof e.id == "string" && typeof e.up == "function" && typeof e.down == "function";
+//#endregion
+export { f as FILE_MIGRATION_PATTERN, i as IrreversibleMigrationError, t as MIGRATION_PHASES, c as MigrationExpectationFailed, u as MigrationNeedsSqlClient, s as MigrationSkipped, d as RewriteUnstableError, l as TransactionBrokenByBodyError, a as irreversible, o as irreversibleReason, p as isFileMigration, n as migration };

package/dist/migrations/fileContext.js

@@ -0,0 +1,482 @@
+import { materializeFields as e } from "../columns.js";
+import { and as t, eq as n, gt as r, isNull as i } from "../predicate.js";
+import { getTable as a } from "../tableRegistry.js";
+import { decodeSqliteDecimal as o } from "../sqliteDecimal.js";
+import { sqliteDecimalStorageShape as s } from "../sqliteDecimalStorage.js";
+import { decodeRowsFromSchema as c } from "../rowDecoder.js";
+import { compileSelect as l } from "../sqlCompiler.js";
+import { MigrationNeedsSqlClient as u, MigrationSkipped as d, RewriteUnstableError as f } from "./fileBased.js";
+import { liveIdStorage as p } from "./columnEquivalence.js";
+import { planMigrations as m } from "./planner.js";
+import { introspectSchema as h } from "./introspect.js";
+import { runMigrationOp as g, runSchemaOp as _ } from "./applier.js";
+import { unblockLossy as v } from "./boot.js";
+import { Effect as y } from "effect";
+//#region src/migrations/fileContext.ts
+var b = (t) => typeof t.__definition == "function" ? e({ c: t }).c : t, x = (e) => {
+	if (typeof e != "string") return e;
+	let t = e.trim().replace(/::[a-zA-Z0-9_ "]+$/, "").trim();
+	if (/^current_timestamp(\(\d*\))?$/i.test(t) || /^now\(\)$/i.test(t)) return "now";
+	let n = /^'(.*)'$/s.exec(t);
+	return n === null ? e : n[1].replace(/''/g, "'");
+}, S = (e, t = /* @__PURE__ */ new Map()) => {
+	let n = {};
+	for (let r of e.columns) {
+		let e = x(r.defaultValue), i = s(r), a = i && e != null ? o(e, i) : e, c = r.references, l = c === void 0 ? void 0 : t.get(c.table);
+		n[r.name] = {
+			type: r.type,
+			...r.type === "id" && p(r) === "numeric" ? { idScheme: { kind: "numeric" } } : {},
+			nullable: r.nullable,
+			unique: r.unique,
+			hasDefault: r.hasDefault,
+			...r.hasDefault ? { defaultValue: a } : {},
+			...r.maxLength === void 0 ? {} : { maxLength: r.maxLength },
+			...r.precision === void 0 ? {} : { precision: r.precision },
+			...r.scale === void 0 ? {} : { scale: r.scale },
+			...r.sqliteDecimalEncoding === void 0 ? {} : { sqliteDecimalEncoding: r.sqliteDecimalEncoding },
+			...r.enumValues === void 0 ? {} : { enumValues: r.enumValues },
+			...r.enumName === void 0 ? {} : { enumName: r.enumName },
+			...r.arrayElement === void 0 ? {} : { arrayElement: r.arrayElement },
+			...r.oneOf === void 0 ? {} : { oneOf: r.oneOf },
+			...r.referenceStorage === void 0 ? {} : { referenceStorage: r.referenceStorage },
+			...r.vectorDim === void 0 ? {} : { vectorDim: r.vectorDim },
+			...r.vectorPrecision === void 0 ? {} : { vectorPrecision: r.vectorPrecision },
+			...r.generatedAs === void 0 ? {} : { generatedAs: r.generatedAs },
+			...r.spatial === void 0 ? {} : { spatial: r.spatial },
+			...c === void 0 ? {} : {
+				references: () => l === void 0 ? {
+					tableName: c.table,
+					fields: {}
+				} : S(l),
+				referenceColumn: c.column,
+				...c.onDelete === void 0 ? {} : { onDelete: c.onDelete },
+				...c.onUpdate === void 0 ? {} : { refOnUpdate: c.onUpdate },
+				fkAutoIndex: !1
+			}
+		};
+	}
+	let r = e.indexes.filter((t) => t.name !== `${e.name}_pkey`);
+	for (let e of r) e.unique && e.columns.length === 1 && n[e.columns[0]] !== void 0 && (n[e.columns[0]] = {
+		...n[e.columns[0]],
+		unique: !0
+	});
+	return {
+		tableName: e.name,
+		fields: n,
+		appliedUniques: r.filter((e) => e.unique && e.columns.length > 1).map((e) => ({
+			name: e.name,
+			fields: e.columns
+		})),
+		appliedIndexes: r.filter((e) => !e.unique).map((e) => ({
+			name: e.name,
+			fields: e.columns,
+			unique: !1
+		})),
+		...e.primaryKey === void 0 ? {} : { appliedPrimaryKey: e.primaryKey }
+	};
+}, C = (e) => {
+	let t = new Map(e.tables.map((e) => [e.name, e]));
+	return e.tables.map((e) => S(e, t));
+}, w = (e, t = "safe") => ({
+	op: e,
+	classification: t,
+	reason: "file migration schema operation"
+}), T = "this context was built over an in-memory store without a `sql` client, and this needs a live connection. Run the migration against a database (the runner supplies the client), or keep a database-free test to `each`, `rewrite`, `expect`, `skipUnless`, `store`, `log`, `schema.tableExists`, `schema.columnExists` and a Promise body under `transactional`.", E = {
+	snapshot: "the in-memory store holds rows, not a catalog — it has no column types, defaults, indexes or constraints to report. `schema.tableExists` and `schema.columnExists` answer from the rows it holds; a body that needs the whole shape needs a database.",
+	indexExists: "the in-memory store has no indexes — every read of it is a scan — so there is no honest answer to give, and `false` would claim an index is absent from a store that could never have had one. Run this migration against a database, or guard on `schema.tableExists` / `schema.columnExists`, which the store can answer.",
+	foreignKeyExists: "the in-memory store has no constraints, so there is no honest answer to give, and `false` would claim a foreign key is absent from a store that could never have had one. Run this migration against a database, or guard on `schema.tableExists` / `schema.columnExists`, which the store can answer.",
+	evolve: T,
+	createTable: T,
+	dropTable: T,
+	renameTable: T,
+	addColumn: T,
+	alterColumn: T,
+	addIndex: T,
+	addForeignKey: T,
+	dropForeignKey: T,
+	dropIndex: T,
+	dropColumn: T,
+	renameColumn: T,
+	truncate: T
+}, D = "this context was built over a store that cannot report the tables it holds (`DataStore.storedTables` is not implemented), so the question has no honest answer here. Use the in-memory store `@voltro/runtime` ships, or run the migration against a database.", O = (e, t) => {
+	let n = () => {
+		let e = t.storedTables;
+		if (e !== void 0) return new Map(e.call(t).map((e) => [e.table, e]));
+	}, r = (t, n) => y.fail(new u(e, t, n));
+	return {
+		tableExists: (e) => y.suspend(() => {
+			let t = n();
+			return t === void 0 ? r("schema.tableExists()", D) : y.succeed(t.has(e));
+		}),
+		columnExists: (e, t) => y.suspend(() => {
+			let i = n();
+			if (i === void 0) return r("schema.columnExists()", D);
+			let a = i.get(e);
+			return a === void 0 ? y.succeed(!1) : a.rowCount === 0 ? r(`schema.columnExists(${JSON.stringify(e)}, ${JSON.stringify(t)})`, `${e} is in this store and holds no rows, and a column exists in a store without a catalog only as a key on a row — so "no such column" and "no row has said yet" are the same observation, and answering either would be a guess. Seed ${e} with a row carrying the columns this migration guards on, or run the migration against a database.`) : y.succeed(a.columns.includes(t));
+		})
+	};
+}, k = (e, t) => {
+	let n = { ...O(e, t) };
+	for (let [t, r] of Object.entries(E)) n[t] = () => y.fail(new u(e, `schema.${t}()`, r));
+	return n;
+}, A = (e) => typeof e == "function" && typeof e.onDialectOrElse == "function", j = (e) => y.isEffect(e) ? e : y.tryPromise({
+	try: () => e,
+	catch: (e) => e
+}), M = (e, t, n) => t.run === void 0 ? Promise.reject(new u(e, "transactional() with an Effect body", "an Effect returned from `transactional` runs ON the transaction's connection, and this store has none. Return a Promise body that uses the transaction's `store`, or run the migration against a database.")) : t.run(n), N = (e, t) => {
+	let n = e.run;
+	if (n === void 0) return t;
+	let r = {};
+	for (let [i, a] of Object.entries(t)) {
+		let t = a;
+		r[i] = (...r) => y.tryPromise({
+			try: () => n.call(e, t(...r)),
+			catch: (e) => e
+		});
+	}
+	return r;
+}, P = (e, t, n) => {
+	let r = () => h(e), i = (e, t) => e.tables.find((e) => e.name === t), a = (e, t, n) => i(e, t)?.columns.find((e) => e.name === n), o = (e) => y.succeed(e), s = (e) => new Map(e.tables.map((e) => [e.name, e])), c = (e, t) => {
+		let n = i(e, t);
+		if (n === void 0) throw Error(`schema: table ${t} does not exist`);
+		return n;
+	}, l = (n) => y.gen(function* () {
+		let i = () => r().pipe(y.map((e) => ({ tables: e.tables.filter((e) => e.name === n.tableName) }))), a = v(m({
+			declared: [n],
+			live: yield* i(),
+			dialect: t
+		})), o = a.operations.filter((e) => e.blocked !== void 0);
+		if (o.length > 0) return yield* y.fail(/* @__PURE__ */ Error(`evolve(${n.tableName}): ${o.length} operation(s) cannot be planned:\n` + o.map((e) => `  - ${e.op.kind}: ${e.blocked?.fix ?? e.reason}`).join("\n")));
+		for (let t of a.operations) yield* g(e, t, [n]);
+		let s = m({
+			declared: [n],
+			live: yield* i(),
+			dialect: t
+		});
+		return s.operations.length > 0 ? yield* y.fail(/* @__PURE__ */ Error(`evolve(${n.tableName}): applied ${a.operations.length} operation(s) and the re-plan still finds ${s.operations.length}: ${s.operations.map((e) => e.op.kind).join(", ")} — the migration did not converge`)) : { applied: a.operations.length };
+	});
+	return {
+		snapshot: r,
+		evolve: l,
+		createTable: (e) => y.gen(function* () {
+			return (yield* r()).tables.some((t) => t.name === e.tableName) ? yield* o("already-present") : (yield* l(e), "applied");
+		}),
+		dropTable: (t) => y.gen(function* () {
+			return (yield* r()).tables.some((e) => e.name === t) ? (yield* g(e, w({
+				kind: "drop-table",
+				table: t
+			}, "lossy"), []), "applied") : yield* o("already-absent");
+		}),
+		renameTable: (t, n) => y.gen(function* () {
+			let a = yield* r(), s = i(a, t) !== void 0, l = i(a, n) !== void 0;
+			return !s && l ? yield* o("already-present") : s ? l ? yield* y.fail(/* @__PURE__ */ Error(`renameTable: ${n} already exists beside ${t}`)) : (yield* g(e, w({
+				kind: "rename-table",
+				from: t,
+				to: n
+			}), [S(c(a, t))]), "applied") : yield* y.fail(/* @__PURE__ */ Error(`renameTable: ${t} does not exist`));
+		}),
+		addColumn: (t, n, i) => y.gen(function* () {
+			let a = yield* r(), u = c(a, t);
+			if (u.columns.some((e) => e.name === n)) return yield* o("already-present");
+			let d = b(i);
+			if (!d.nullable && !d.hasDefault && d.backfill === void 0) {
+				let r = yield* e`SELECT COUNT(*) AS n FROM ${e(t)}`;
+				if (Number(r[0]?.n ?? 0) > 0) return yield* y.fail(/* @__PURE__ */ Error(`addColumn(${t}.${n}): a NOT NULL column without a default cannot be added to a table with rows on any dialect. Add it nullable or with a default, fill it (rewrite), then alterColumn(${JSON.stringify(t)}, ${JSON.stringify(n)}, { nullable: false }).`));
+			}
+			let f = S(u, s(a));
+			return yield* l({
+				...f,
+				fields: {
+					...f.fields,
+					[n]: d
+				}
+			}), "applied";
+		}),
+		alterColumn: (e, t, n) => y.gen(function* () {
+			let i = yield* r(), a = c(i, e), u = a.columns.find((e) => e.name === t);
+			if (u === void 0) return yield* y.fail(/* @__PURE__ */ Error(`alterColumn: ${e}.${t} does not exist`));
+			let d = n.default === void 0 || (n.default === null ? !u.hasDefault : u.hasDefault && String(u.defaultValue) === String(n.default));
+			if ((n.nullable === void 0 || n.nullable === u.nullable) && d) return yield* o("already-present");
+			let f = {
+				...u,
+				...n.nullable === void 0 ? {} : { nullable: n.nullable },
+				...n.default === void 0 ? {} : n.default === null ? {
+					hasDefault: !1,
+					defaultValue: void 0
+				} : {
+					hasDefault: !0,
+					defaultValue: n.default
+				}
+			};
+			return yield* l(S({
+				...a,
+				columns: a.columns.map((e) => e.name === t ? f : e)
+			}, s(i))), "applied";
+		}),
+		addIndex: (e, t, n = {}) => y.gen(function* () {
+			let i = yield* r(), a = c(i, e), u = n.unique === !0;
+			if (u && t.length === 1) {
+				let n = a.columns.find((e) => e.name === t[0]);
+				return n === void 0 ? yield* y.fail(/* @__PURE__ */ Error(`addIndex: ${e}.${t[0]} does not exist`)) : n.unique ? yield* o("already-present") : (yield* l(S({
+					...a,
+					columns: a.columns.map((e) => e.name === n.name ? {
+						...e,
+						unique: !0
+					} : e)
+				}, s(i))), "applied");
+			}
+			let d = n.name ?? `${e}_${t.join("_")}_idx`;
+			if (a.indexes.some((e) => e.name === d)) return yield* o("already-present");
+			let f = {
+				name: d,
+				table: e,
+				columns: t,
+				unique: u
+			};
+			return yield* l(S({
+				...a,
+				indexes: [...a.indexes, f]
+			}, s(i))), "applied";
+		}),
+		addForeignKey: (e, n, a, u = {}) => y.gen(function* () {
+			let d = yield* r(), f = c(d, e), p = f.columns.find((e) => e.name === n);
+			if (p === void 0) return yield* y.fail(/* @__PURE__ */ Error(`addForeignKey: ${e}.${n} does not exist`));
+			if (p.references !== void 0) return yield* o("already-present");
+			if (i(d, a.table) === void 0) return yield* y.fail(/* @__PURE__ */ Error(`addForeignKey: target table ${a.table} does not exist`));
+			let m = a.column ?? "id";
+			if ((t === "mysql" || t === "mariadb" || t === "mssql") && p.type === "text" && p.maxLength === void 0) return yield* y.fail(/* @__PURE__ */ Error(`addForeignKey(${e}.${n}): an unbounded text column cannot carry a FOREIGN KEY on ${t} — the referencing column must match the key's width. Add the column as \`reference(() => target)\` (addColumn), or give it \`text().maxLength(n)\` matching the key first.`));
+			let h = {
+				...p,
+				type: "reference",
+				references: {
+					table: a.table,
+					column: m,
+					onDelete: u.onDelete ?? "noAction",
+					onUpdate: u.onUpdate ?? "noAction"
+				}
+			};
+			return yield* l(S({
+				...f,
+				columns: f.columns.map((e) => e.name === n ? h : e)
+			}, s(d))), "applied";
+		}),
+		truncate: (t) => y.gen(function* () {
+			return (yield* r()).tables.some((e) => e.name === t) ? (yield* e`DELETE FROM ${e(t)}`, "applied") : yield* o("already-absent");
+		}),
+		tableExists: (e) => r().pipe(y.map((t) => i(t, e) !== void 0)),
+		columnExists: (e, t) => r().pipe(y.map((n) => a(n, e, t) !== void 0)),
+		indexExists: (e, t) => r().pipe(y.map((n) => i(n, e)?.indexes.some((e) => e.name === t) ?? !1)),
+		foreignKeyExists: (e, t) => r().pipe(y.map((n) => a(n, e, t)?.references !== void 0)),
+		dropForeignKey: (t, n) => y.gen(function* () {
+			let i = yield* r(), s = a(i, t, n);
+			return s?.references === void 0 ? yield* o("already-absent") : (yield* _(e, {
+				kind: "drop-foreign-key",
+				table: t,
+				column: n,
+				...s.references.constraintName === void 0 ? {} : { name: s.references.constraintName }
+			}, i), "applied");
+		}),
+		dropIndex: (t, n) => y.gen(function* () {
+			let a = yield* r();
+			return i(a, t)?.indexes.some((e) => e.name === n) ?? !1 ? (yield* _(e, {
+				kind: "drop-index",
+				table: t,
+				index: n
+			}, a), "applied") : yield* o("already-absent");
+		}),
+		dropColumn: (t, n) => y.gen(function* () {
+			let s = yield* r(), c = a(s, t, n);
+			if (c === void 0) return yield* o("already-absent");
+			c.references !== void 0 && (yield* _(e, {
+				kind: "drop-foreign-key",
+				table: t,
+				column: n,
+				...c.references.constraintName === void 0 ? {} : { name: c.references.constraintName }
+			}, s), s = yield* r());
+			for (let r of i(s, t)?.indexes ?? []) r.columns.includes(n) && r.name !== `${t}_pkey` && (yield* _(e, {
+				kind: "drop-index",
+				table: t,
+				index: r.name
+			}, s));
+			return i(s, t)?.indexes.some((e) => e.columns.includes(n) && e.name !== `${t}_pkey`) && (s = yield* r()), yield* _(e, {
+				kind: "drop-column",
+				table: t,
+				column: n
+			}, s), "applied";
+		}),
+		renameColumn: (t, n, i) => y.gen(function* () {
+			let s = yield* r(), c = a(s, t, n) !== void 0, l = a(s, t, i) !== void 0;
+			return !c && l ? yield* o("already-present") : c ? l ? yield* y.fail(/* @__PURE__ */ Error(`renameColumn: ${t}.${i} already exists beside ${n} — a rename cannot merge two columns`)) : (yield* _(e, {
+				kind: "rename-column",
+				table: t,
+				from: n,
+				to: i
+			}, s), "applied") : yield* y.fail(/* @__PURE__ */ Error(`renameColumn: ${t}.${n} does not exist`));
+		})
+	};
+}, F = (e, n, i, a) => {
+	let o;
+	return (async function* () {
+		for (;;) {
+			let s = [o === void 0 ? void 0 : r("id", o), a].filter((e) => e !== void 0), c = await e.query({
+				table: n,
+				predicate: s.length === 0 ? void 0 : s.length === 1 ? s[0] : t(...s),
+				order: [{
+					column: "id",
+					direction: "asc"
+				}],
+				take: i,
+				skip: void 0,
+				projection: void 0
+			});
+			if (c.length === 0) return;
+			let l = c[c.length - 1].id;
+			if (l == null) throw Error(`each/rewrite: ${n} rows carry no \`id\` — paging needs one`);
+			if (o !== void 0 && !(String(l) > String(o))) throw Error(`each/rewrite: paging ${n} did not advance past ${String(o)}`);
+			if (o = l, yield c, c.length < i) return;
+		}
+	})();
+}, I = (e) => e > 0 ? y.sleep(`${e} millis`) : y.void, L = (e) => (t, n, r = {}) => y.gen(function* () {
+	let i = r.batchSize ?? 1e3, a = 0, o = 0, s = F(e, t, i);
+	for (;;) {
+		let e = yield* y.tryPromise({
+			try: () => s.next(),
+			catch: (e) => e
+		});
+		if (e.done) break;
+		o++;
+		for (let t of e.value) yield* j(n(t)), a++;
+		yield* I(r.sleepMs ?? 0);
+	}
+	return {
+		scanned: a,
+		pages: o
+	};
+}), R = (e, t) => t == null ? i(e) : n(e, t), z = (e) => typeof e != "object" || !e || e instanceof Date, B = (e, t) => y.gen(function* () {
+	if (e === void 0) return [];
+	let n = (yield* h(e)).tables.find((e) => e.name === t)?.columns ?? [], r = new Set(n.map((e) => e.name)), i = a(t)?.fields;
+	return n.filter((e) => e.type === "timestamp" || e.type === "date" || i?.[e.name]?.type === "timestamp" || i?.[e.name]?.type === "date").map((e, t) => {
+		let n = `__voltro_rewrite_guard_${t}`;
+		for (; r.has(n);) n += "_";
+		return r.add(n), {
+			column: e.name,
+			alias: n
+		};
+	});
+}), V = (e, r, i, a) => (o, s, u = {}) => y.gen(function* () {
+	let d = u.batchSize ?? 1e3, p = u.maxPasses ?? 10, m = u.guard ?? [], h = yield* B(i, o), g = /* @__PURE__ */ new WeakMap(), _ = h.length === 0 || i === void 0 ? r : { query: async (t) => {
+		let n = l(t, i), s = h.map(({ column: e, alias: t }) => i`${i.onDialectOrElse({
+			mysql: () => i`CAST(${i(e)} AS CHAR)`,
+			mssql: () => i`CONVERT(VARCHAR(40), ${i(e)}, 127)`,
+			orElse: () => i`CAST(${i(e)} AS TEXT)`
+		})} AS ${i(t)}`);
+		return (await M(e, r, i`SELECT *, ${i.join(", ", !1)(s)} FROM (${n}) AS ${i("__voltro_rewrite_rows")} ORDER BY ${i("id")} ASC`)).map((e) => {
+			let t = { ...e }, n = /* @__PURE__ */ new Map();
+			for (let { column: e, alias: r } of h) n.set(e, t[r]), delete t[r];
+			let r = c([t], o, a)[0];
+			return g.set(r, n), r;
+		});
+	} }, v = {
+		passes: 0,
+		scanned: 0,
+		rewritten: 0,
+		contended: 0
+	}, b = v;
+	for (let e = 1; e <= p; e++) {
+		let i = 0, a = 0, c = 0, l = F(_, o, d);
+		for (;;) {
+			let e = yield* y.tryPromise({
+				try: () => l.next(),
+				catch: (e) => e
+			});
+			if (e.done) break;
+			for (let l of e.value) {
+				i++;
+				let e = yield* y.tryPromise({
+					try: async () => s(l),
+					catch: (e) => e
+				});
+				if (e === void 0) continue;
+				let u = Object.entries(e).filter(([e, t]) => !Object.is(l[e], t));
+				if (u.length === 0) continue;
+				let d = [n("id", l.id)], f = (e) => g.get(l)?.has(e) ? g.get(l).get(e) : l[e];
+				for (let [e] of u) z(l[e]) && d.push(R(e, f(e)));
+				for (let e of m) d.push(R(e, f(e)));
+				(yield* y.tryPromise({
+					try: () => r.updateMany(o, Object.fromEntries(u), { where: t(...d) }),
+					catch: (e) => e
+				})) === 1 ? a++ : c++;
+			}
+			yield* I(u.sleepMs ?? 0);
+		}
+		if (b = {
+			passes: e,
+			scanned: i,
+			rewritten: a,
+			contended: c
+		}, v = {
+			passes: e,
+			scanned: v.scanned + i,
+			rewritten: v.rewritten + a,
+			contended: v.contended + c
+		}, a === 0 && c === 0) return v;
+	}
+	return yield* y.fail(new f(o, b));
+}), H = (e) => {
+	let { migrationId: t } = e, n = `migrations:file:${t}`;
+	if (e.sql !== void 0 && !A(e.sql)) throw new u(t, "makeFileMigrationContext()", `\`sql\` is not an effect/sql client (got ${typeof e.sql}). Pass the client the store executes on, or omit \`sql\` to drive the body over an in-memory store.`);
+	if (e.sql === void 0 && e.store.run !== void 0) throw new u(t, "makeFileMigrationContext()", "a SQL-backed store was given without `sql`. Its migration context runs `raw()`, `schema` and the guarded rewrite on the client the store executes on; pass that client, or use an in-memory store for a database-free test.");
+	let r = e.sql, i = [], a = (e) => {
+		if (typeof e != "string" || e.trim().length < 12) throw Error(`raw(reason): say why this migration needs raw SQL — the reason is what a reviewer and \`voltro doctor\` read (got ${JSON.stringify(e)})`);
+		if (r === void 0) throw new u(t, `raw(${JSON.stringify(e)})`, T);
+		return r;
+	};
+	return {
+		ctx: {
+			...((o) => ({
+				raw: a,
+				store: o,
+				dialect: e.dialect,
+				appliedAt: e.appliedAt,
+				log: {
+					info: (e, t) => y.logInfo(e).pipe(y.annotateLogs({
+						scope: n,
+						...t ?? {}
+					})),
+					warn: (e, t) => y.logWarning(e).pipe(y.annotateLogs({
+						scope: n,
+						...t ?? {}
+					}))
+				},
+				schema: r === void 0 ? k(t, o) : N(o, P(r, e.dialect, o)),
+				each: L(o),
+				rewrite: V(t, o, r, e.dialect),
+				expect: (e, t) => {
+					i.push({
+						description: e,
+						check: t
+					});
+				},
+				skipUnless: (e, t) => y.gen(function* () {
+					if (!(typeof e == "boolean" ? e : yield* j(e))) return yield* y.fail(new d(t));
+				})
+			}))(e.store),
+			transactional: (n) => y.tryPromise({
+				try: () => e.store.transactional(async (e) => {
+					let r = n({
+						store: e,
+						raw: a
+					});
+					return y.isEffect(r) ? M(t, e, r) : r;
+				}),
+				catch: (e) => e
+			})
+		},
+		expectations: i
+	};
+}, U = (e) => y.gen(function* () {
+	let t = [];
+	for (let { description: n, check: r } of e) (yield* j(r())) || t.push(n);
+	return t;
+});
+//#endregion
+export { U as failedExpectations, H as makeFileMigrationContext, C as materialiseSnapshot };