@thomasfosterau/effect-drizzle-ext-pg 0.0.0 → 0.1.0

package/dist/tooling/index.js

@@ -0,0 +1,479 @@
+import * as Effect from "effect/Effect";
+import * as Arr from "effect/Array";
+import * as FileSystem from "effect/FileSystem";
+import * as Order from "effect/Order";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import * as HashSet from "effect/HashSet";
+import * as Predicate from "effect/Predicate";
+import * as R from "effect/Record";
+import { generateDrizzleJson, generateMigration, reconstruct } from "drizzle-kit/api-postgres";
+import * as Option from "effect/Option";
+import { ChildProcess } from "effect/process";
+import { ChildProcessSpawner } from "effect/process/ChildProcessSpawner";
+// src/tooling/migration-drift.ts
+/**
+* @copyright Thomas Foster
+*
+* **The migration-drift gate**: fails when a committed Drizzle schema and its
+* committed drizzle-kit `migrations/` snapshots disagree, without a database
+* or a deployed stage. Ported from the applications'
+* `packages/database/scripts/check-migration-drift.ts` (website #1200,
+* #1471; preferenceflow's copy is the reference), as a bin-less Effect an
+* application's `db:migration-drift` task runs with its own schema module.
+*
+* Three checks, each guarding "snapshot history is a DAG, not a chain" from a
+* different side:
+*
+* 1. **DAG integrity.** drizzle-kit 1.0's snapshots chain via `prevIds`
+*    (plural — a migration generated after two branches merge names both
+*    tips), so history is a DAG. Divergence is normal while unmerged; it is
+*    broken when two branches both land without a later migration's
+*    `prevIds` reconverging them. Every snapshot id must be unique, every
+*    `prevIds` entry must resolve, and the lineage must have exactly one head
+*    from which everything is reachable, with no cycle.
+* 2. **Zero drift.** The exact drizzle-kit calls a deploy-time regeneration
+*    makes (`generateDrizzleJson` / `generateMigration` from
+*    `drizzle-kit/api-postgres`) against the schema module and the
+*    **lexicographically-latest** migration directory's snapshot — the same
+*    "latest by directory name" selection alchemy's
+*    `Drizzle.Schema.regenerate` uses, NOT a DAG-aware pick — must produce
+*    zero statements. A diff drizzle-kit can only resolve interactively
+*    (rename-or-recreate) is drift too.
+* 3. **Base ancestry (pull requests only).** A migration must be generated on
+*    a checkout whose snapshot chain descends from the base branch's CURRENT
+*    head; checks 1–2 are internal to the checkout, so a branch forked from
+*    week-old `trunk` passes both while carrying a migration whose regenerated
+*    constraints silently omit everything the base added since. Runs only
+*    when a base is supplied ({@link resolveBaseRef} reads one from
+*    `MIGRATION_BASE_REF` / `GITHUB_BASE_REF`), and only when the branch adds
+*    migration directories.
+*
+* Zero drift runs only on a structurally sound DAG (and a base-descended
+* one): with two heads the latest-by-name snapshot is an arbitrary pick of
+* one fork, so its diff would be noise next to the real report.
+*
+* @module tooling/migration-drift
+*/
+/**
+* drizzle-kit's sentinel for "no real parent" (its `originUUID`): the genesis
+* migration's `prevIds` names this instead of being empty.
+*/
+const ROOT_SENTINEL_ID = "00000000-0000-0000-0000-000000000000";
+const SnapshotIdentity = Schema.Struct({
+	id: Schema.String,
+	prevIds: Schema.optionalKey(Schema.Array(Schema.String))
+});
+/**
+* A **full** (version `"8"`) snapshot, which earlier drizzle-kit 1.0
+* prereleases wrote: the members the zero-drift diff relies on beyond the
+* identity, checked, not decoded, since the snapshot is handed to
+* `generateMigration` unchanged.
+*/
+const PostgresSnapshotContract = Schema.Struct({
+	version: Schema.Literal("8"),
+	dialect: Schema.Literal("postgres"),
+	ddl: Schema.Array(Schema.Unknown)
+});
+const isPostgresSnapshot = (raw) => Schema.is(PostgresSnapshotContract)(raw);
+/**
+* A version `"9"` snapshot, which drizzle-kit 1.0.0-rc.5 writes (and
+* `drizzle-kit up` upgrades a v8 chain to): a `base` or a `diff` over its
+* parents, so the state at one is rebuilt from the whole chain with
+* drizzle-kit's own `reconstruct`.
+*/
+const ChainSnapshotContract = Schema.Struct({
+	version: Schema.Literal("9"),
+	dialect: Schema.Literal("postgres"),
+	type: Schema.Literals(["base", "diff"])
+});
+const isChainSnapshot = Schema.is(ChainSnapshotContract);
+/** A snapshot.json could not be read as a drizzle-kit snapshot. */
+var MalformedSnapshot = class extends Schema.TaggedError()("MalformedSnapshot", {
+	file: Schema.String,
+	cause: Schema.Defect()
+}) {
+	get message() {
+		return `${this.file} is not a drizzle-kit snapshot (malformed JSON, or no string \`id\` / string[] \`prevIds\`) — never hand-edit migrations/.`;
+	}
+};
+/**
+* drizzle-kit itself failed while generating or diffing a snapshot — broken
+* input (a schema module drizzle-kit cannot read) rather than drift.
+*/
+var SchemaDiffError = class extends Schema.TaggedError()("SchemaDiffError", { cause: Schema.Defect() }) {
+	get message() {
+		return "drizzle-kit failed to generate or diff the schema snapshot";
+	}
+};
+/** Run one drizzle-kit API call, its rejection a {@link SchemaDiffError}. */
+const drizzleKit = (run) => Effect.tryPromise({
+	try: run,
+	catch: (cause) => new SchemaDiffError({ cause })
+});
+/** The gate found problems; `issues` holds one human-readable report per violation. */
+var MigrationDriftError = class extends Schema.TaggedError()("MigrationDriftError", { issues: Schema.Array(Schema.String) }) {
+	get message() {
+		return `Migration snapshot drift check failed (${this.issues.length} issue(s)):\n\n${this.issues.join("\n\n")}`;
+	}
+};
+/** Snapshots not named in any other snapshot's `prevIds` — the DAG's tips. */
+const findHeads = (entries) => {
+	const referenced = HashSet.fromIterable(entries.flatMap((entry) => entry.snapshot.prevIds));
+	return entries.filter((entry) => !HashSet.has(referenced, entry.snapshot.id));
+};
+const findDuplicateIds = (entries) => entries.filter((entry, index) => entries.findIndex((other) => other.snapshot.id === entry.snapshot.id) !== index);
+const findDanglingParents = (entries) => {
+	const ids = HashSet.fromIterable(entries.map((entry) => entry.snapshot.id));
+	return entries.flatMap((entry) => entry.snapshot.prevIds.filter((prevId) => prevId !== "00000000-0000-0000-0000-000000000000" && !HashSet.has(ids, prevId)).map((prevId) => ({
+		dir: entry.dir,
+		prevId
+	})));
+};
+/**
+* DFS from `starts` backward through `prevIds`, three-state (visiting /
+* done) so a back-edge (a cycle) is told apart from ordinary convergence.
+* Returns everything reached and the first cycle found, as directory labels.
+*/
+const traverse = (starts, entries) => {
+	const byId = new Map(entries.map((entry) => [entry.snapshot.id, entry]));
+	const state = /* @__PURE__ */ new Map();
+	const reachable = /* @__PURE__ */ new Set();
+	const label = (id) => byId.get(id)?.dir ?? id;
+	const visit = (id, path) => {
+		if (state.get(id) === "visiting") return Option.some([...path, label(id)]);
+		if (state.get(id) === "done") return Option.none();
+		state.set(id, "visiting");
+		reachable.add(id);
+		const next = [...path, label(id)];
+		for (const prevId of byId.get(id)?.snapshot.prevIds ?? []) {
+			const cycle = visit(prevId, next);
+			if (Option.isSome(cycle)) return cycle;
+		}
+		state.set(id, "done");
+		return Option.none();
+	};
+	for (const start of starts) {
+		const cycle = visit(start.snapshot.id, []);
+		if (Option.isSome(cycle)) return {
+			reachable,
+			cycle
+		};
+	}
+	return {
+		reachable,
+		cycle: Option.none()
+	};
+};
+/**
+* Every snapshot id is unique, every `prevIds` reference resolves (or is
+* {@link ROOT_SENTINEL_ID}), the lineage has exactly one head and no cycle,
+* and every snapshot is reachable from that head. One human-readable report
+* per violation; empty when clean.
+*/
+const checkDagIntegrity = (entries) => {
+	const issues = [];
+	const duplicates = findDuplicateIds(entries);
+	if (Arr.isReadonlyArrayNonEmpty(duplicates)) issues.push(`${duplicates.length} migration snapshot(s) share an \`id\` with an earlier snapshot — every snapshot must have a unique id: ${duplicates.map((d) => d.dir).join(", ")}.\n\`drizzle-kit generate\` never produces this; check for a copied or hand-edited snapshot.json.`);
+	const dangling = findDanglingParents(entries);
+	if (Arr.isReadonlyArrayNonEmpty(dangling)) issues.push(`${dangling.length} \`prevIds\` entry(ies) name a parent snapshot id that no committed snapshot has: ${dangling.map((d) => `${d.dir} -> ${d.prevId}`).join(", ")}.\nThe migrations directory may be missing a file, or a snapshot.json was hand-edited.`);
+	const heads = findHeads(entries);
+	if (heads.length !== 1) issues.push(`Expected exactly 1 head in the migration snapshot DAG, found ${heads.length}` + (Arr.isReadonlyArrayNonEmpty(heads) ? `: ${heads.map((h) => h.dir).join(", ")}` : "") + ".\n" + (Arr.isReadonlyArrayNonEmpty(heads) ? "Two or more migrations were generated from the same parent snapshot and both merged without a later migration's `prevIds` reconverging them (a snapshot-chain fork). Fix: rebase and regenerate, so the new migration's `prevIds` lists every outstanding head." : "Every snapshot is named as some other snapshot's parent: the lineage has no real root (see any reported cycle)."));
+	const { reachable } = traverse(heads, entries);
+	const { cycle } = traverse(entries, entries);
+	if (Option.isSome(cycle)) issues.push(`The migration snapshot DAG contains a cycle in its \`prevIds\` lineage: ${cycle.value.join(" -> ")}.\nHistory can never legitimately cycle back to an ancestor — this means corrupted or hand-edited snapshot.json files.`);
+	const orphaned = entries.filter((entry) => !reachable.has(entry.snapshot.id));
+	if (Arr.isReadonlyArrayNonEmpty(orphaned)) issues.push(`${orphaned.length} migration snapshot(s) are not reachable from the DAG head(s) via \`prevIds\`: ${orphaned.map((o) => o.dir).join(", ")}.\nA deploy that regenerates against the lexicographically-latest snapshot would silently drop these branches' schema changes.`);
+	return issues;
+};
+/**
+* Every migration this branch ADDS must descend from the base's current
+* head. Presence of the base head's snapshot id in this checkout's entries is
+* sufficient: {@link checkDagIntegrity} separately proves the local DAG has a
+* single head from which everything is reachable, so containing the base head
+* means the new tail grew on top of it. A branch that adds no migration
+* directory passes.
+*/
+const checkBaseAncestry = (entries, base) => {
+	const baseDirs = HashSet.fromIterable(base.dirs);
+	const added = entries.filter((entry) => !HashSet.has(baseDirs, entry.dir));
+	if (Arr.isReadonlyArrayEmpty(added) || Option.isNone(base.head)) return [];
+	const head = base.head.value;
+	if (entries.some((entry) => entry.snapshot.id === head.snapshot.id)) return [];
+	return [`New migration(s) ${added.map((entry) => entry.dir).join(", ")} were generated on a checkout that predates ${base.ref}'s current migration head (${head.dir}, snapshot id ${head.snapshot.id}) — the base head is not an ancestor of this branch's snapshot chain, so the generated DDL was computed from a stale schema (a regenerated CHECK constraint silently reverting members the base added since the fork). Fix: rebase onto ${base.ref}, delete the stale migration directory, and regenerate it.`];
+};
+/**
+* The base ref for the ancestry check, when one is knowable: an explicit
+* `MIGRATION_BASE_REF` wins (local use: `MIGRATION_BASE_REF=origin/trunk`),
+* else `origin/$GITHUB_BASE_REF` — which GitHub Actions sets only on
+* `pull_request` events, so pushes and local runs skip the check.
+*/
+const resolveBaseRef = (env) => {
+	const explicit = env.MIGRATION_BASE_REF ?? "";
+	if (explicit !== "") return Option.some(explicit);
+	const base = env.GITHUB_BASE_REF ?? "";
+	return base === "" ? Option.none() : Option.some(`origin/${base}`);
+};
+/** A migration directory name: drizzle-kit's all-digit prefix and a slug. */
+const MIGRATION_DIR = /^\d+_/;
+const parseSnapshot = (file, text) => Schema.decodeEffect(Schema.fromJsonString(Schema.Unknown))(text).pipe(Effect.filterOrFail(Schema.is(SnapshotIdentity), (raw) => raw), Effect.mapError((cause) => new MalformedSnapshot({
+	file,
+	cause
+})));
+const toEntry = (dir, raw) => ({
+	dir,
+	raw,
+	snapshot: {
+		id: raw.id,
+		prevIds: raw.prevIds ?? []
+	}
+});
+/**
+* Every migration directory under `migrationsDir` (sorted by name) and the
+* snapshot of each that has one. A directory without a snapshot (a
+* hand-written bootstrap) is listed but carries no entry — exactly like
+* alchemy's `readLatestSnapshot`.
+*/
+const readLocal = (migrationsDir) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const names = Arr.sort((yield* fs.readDirectory(migrationsDir)).filter((name) => MIGRATION_DIR.test(name)), Order.String);
+	const dirs = yield* Effect.filter(names, (name) => Effect.map(fs.stat(path.join(migrationsDir, name)), (info) => info.type === "Directory"));
+	return {
+		dirs,
+		entries: (yield* Effect.forEach(dirs, (dir) => Effect.gen(function* () {
+			const file = path.join(migrationsDir, dir, "snapshot.json");
+			if (!(yield* fs.exists(file))) return [];
+			const raw = yield* parseSnapshot(file, yield* fs.readFileString(file));
+			return [toEntry(dir, raw)];
+		}), { concurrency: 1 })).flat()
+	};
+});
+const git = (base, args) => Effect.gen(function* () {
+	return yield* (yield* ChildProcessSpawner).string(ChildProcess.make("git", [...args], { cwd: base.cwd }));
+});
+/**
+* The latest-by-name base directory carrying a readable snapshot — the same
+* selection the zero-drift check makes locally. A directory without one (a
+* hand-written bootstrap) is passed over.
+*/
+const findBaseHead = (base, dirs) => Effect.findFirstFilter(dirs.toReversed(), (dir) => Effect.result(Effect.flatMap(git(base, ["show", `${base.ref}:${base.migrationsPath}/${dir}/snapshot.json`]), (text) => Effect.map(parseSnapshot(dir, text), (raw) => toEntry(dir, raw)))));
+/**
+* The base branch's migration state, read with `git ls-tree` / `git show` so
+* it reflects the base's CURRENT tip. Fetches the base first when the
+* checkout lacks it (a shallow pull-request checkout does).
+*/
+const readBaseMigrations = (base) => Effect.gen(function* () {
+	if ((yield* (yield* ChildProcessSpawner).exitCode(ChildProcess.make("git", [
+		"rev-parse",
+		"--verify",
+		"--quiet",
+		`${base.ref}^{commit}`
+	], { cwd: base.cwd }))) !== 0) yield* git(base, [
+		"fetch",
+		"--depth=1",
+		"origin",
+		base.ref.replace(/^origin\//, "")
+	]);
+	const listing = yield* git(base, [
+		"ls-tree",
+		"--name-only",
+		base.ref,
+		`${base.migrationsPath}/`
+	]);
+	const dirs = Arr.sort(listing.split("\n").map((line) => line.trim().split("/").at(-1) ?? "").filter((name) => MIGRATION_DIR.test(name)), Order.String);
+	return {
+		ref: base.ref,
+		dirs,
+		head: yield* findBaseHead(base, dirs)
+	};
+});
+/**
+* drizzle-kit's resolvers throw `… was called without a HintsHandler` when
+* the diff holds a created+deleted pair it would interactively ask about
+* (rename or recreate). That is proof of a non-empty diff, reported as drift;
+* every other failure is broken input and stays a defect.
+*/
+const isAmbiguousDiff = (cause) => Predicate.isError(cause) && cause.message.includes("was called without a HintsHandler");
+const checkZeroDrift = (schema, entries, latest, label) => Effect.gen(function* () {
+	const where = Option.match(latest, {
+		onNone: () => `${label} (no snapshot yet)`,
+		onSome: (entry) => `${label}/${entry.dir}/snapshot.json`
+	});
+	const stateOf = (entry) => isPostgresSnapshot(entry.raw) ? Option.some(Effect.succeed(entry.raw)) : isChainSnapshot(entry.raw) ? Option.some(drizzleKit(() => reconstruct(R.fromEntries(Arr.map(entries, (each) => [each.dir, each.raw])), entry.snapshot.id))) : Option.none();
+	const prevState = Option.match(latest, {
+		onNone: () => Option.some(drizzleKit(() => generateDrizzleJson({}))),
+		onSome: stateOf
+	});
+	if (Option.isNone(prevState)) return [`${where} doesn't match a drizzle-kit snapshot contract \`generateMigration\` reads (\`version: "8"\` with a \`ddl\` array, or \`version: "9"\` with \`type\` \`base\` / \`diff\`; \`dialect: "postgres"\`): a stale (pre-v8) or hand-edited snapshot.`];
+	const cur = yield* drizzleKit(() => generateDrizzleJson(schema, Option.getOrUndefined(Option.map(latest, (entry) => entry.snapshot.id))));
+	const prev = yield* prevState.value;
+	return yield* drizzleKit(() => generateMigration(prev, cur)).pipe(Effect.map((statements) => Arr.isReadonlyArrayNonEmpty(statements) ? [`Schema drift detected against the latest committed migration snapshot (${where}): ${statements.length} statement(s) would be generated:\n\n` + statements.map((statement) => `  ${statement}`).join("\n") + "\n\nFix: generate a migration (`drizzle-kit generate --name <slug>`) and commit it with its snapshot."] : []), Effect.catchTag("SchemaDiffError", ({ cause }) => isAmbiguousDiff(cause) ? Effect.succeed([`Schema drift detected against the latest committed migration snapshot (${where}), and the diff is ambiguous: drizzle-kit found a created+deleted pair it would interactively ask to resolve as rename-or-recreate. An ambiguous diff is still a non-empty diff.
+Fix: generate a migration (\`drizzle-kit generate --name <slug>\`) and commit it with its snapshot.`]) : Effect.fail(new SchemaDiffError({ cause }))));
+});
+/**
+* Run the three checks. Succeeds with a {@link MigrationDriftReport};
+* fails with a {@link MigrationDriftError} carrying every issue found.
+*
+* @example
+* ```ts
+* // An application's `db:migration-drift` task, run with `NodeRuntime.runMain`.
+* import * as NodeServices from "@effect/platform-node/NodeServices";
+* import { checkMigrationDrift, resolveBaseRef } from "@thomasfosterau/effect-drizzle-ext-pg/tooling";
+* import { integer, pgTable } from "drizzle-orm/pg-core";
+* import * as Effect from "effect/Effect";
+* import * as Option from "effect/Option";
+* import * as path from "node:path";
+*
+* const schema = { widget: pgTable("widget", { id: integer().primaryKey() }) };
+* const repoRoot = process.cwd();
+* const base = Option.map(resolveBaseRef(process.env), (ref) => ({
+*   ref,
+*   migrationsPath: "packages/database/migrations",
+*   cwd: repoRoot,
+* }));
+* export const program = checkMigrationDrift({
+*   schema,
+*   migrationsDir: path.join(repoRoot, "packages/database/migrations"),
+*   base,
+* }).pipe(Effect.provide(NodeServices.layer));
+* ```
+*/
+const checkMigrationDrift = (options) => Effect.gen(function* () {
+	const { dirs, entries } = yield* readLocal(options.migrationsDir);
+	const base = yield* Effect.transposeOption(Option.map(options.base ?? Option.none(), readBaseMigrations));
+	const structural = [...checkDagIntegrity(entries), ...Option.match(base, {
+		onNone: () => [],
+		onSome: (b) => checkBaseAncestry(entries, b)
+	})];
+	const latest = Arr.findFirst(entries.toReversed(), (entry) => dirs.includes(entry.dir));
+	const issues = Arr.isReadonlyArrayNonEmpty(structural) ? structural : yield* checkZeroDrift(options.schema, entries, latest, options.migrationsDir);
+	if (Arr.isReadonlyArrayNonEmpty(issues)) return yield* new MigrationDriftError({ issues });
+	return {
+		snapshots: entries.length,
+		baseRef: Option.map(base, (b) => b.ref)
+	};
+});
+// src/tooling/view-dependencies.ts
+/**
+* @copyright Thomas Foster
+*
+* **The view-on-view gate** (`DB-VIEW-001`, website #1228): fails when any
+* database view in a Drizzle schema selects from another database view.
+* Ported from the website and gardeneria applications'
+* `packages/database/scripts/check-view-dependencies.ts`.
+*
+* drizzle-kit derives migrations from a schema diff, and for views that diff
+* is only ever `DROP VIEW` + `CREATE VIEW`, emitted as two flat blocks in one
+* shared order with **no topological sort** and **no cascade**. A
+* view-on-view edge is then unmigratable two ways:
+*
+* 1. **Both ends change.** The drops come out in the create order, so a drop
+*    runs dependency-first and PostgreSQL rejects it.
+* 2. **Only the dependency changes.** The dependent view is not in the diff
+*    at all, the dependency's `DROP VIEW` still fails, and no reordering of
+*    the emitted statements can help: the one that would have to run first
+*    was never emitted.
+*
+* The only remedy once such a migration exists is hand-editing it, so the
+* constraint is pushed up into the schema: **no view may reference another
+* view**. The graph is read from drizzle-kit's own DDL — the whole schema
+* generated from an empty snapshot, one `CREATE VIEW` per view carrying the
+* exact SQL a migration would — so the gate needs no database.
+*
+* @module tooling/view-dependencies
+*/
+/**
+* `CREATE [MATERIALIZED] VIEW "<schema>"."<name>"` — drizzle-kit omits the
+* schema qualifier for `public`, so the schema group is optional.
+*/
+const CREATE_VIEW = /^CREATE\s+(?:MATERIALIZED\s+)?VIEW\s+(?:"([^"]+)"\.)?"([^"]+)"/i;
+/** `schema.name`, the identity used in messages and in reference matching. */
+const viewKey = (view) => `${view.schema}.${view.name}`;
+/** Every `CREATE VIEW` in a statement list, as {@link ViewDefinition}s. */
+const parseViewDefinitions = (statements) => statements.flatMap((statement) => {
+	const match = CREATE_VIEW.exec(statement.trim());
+	const name = match?.[2];
+	return name === void 0 ? [] : [{
+		schema: match?.[1] ?? "public",
+		name,
+		sql: statement
+	}];
+});
+/**
+* Names come out of quoted identifiers, so they may contain regex
+* metacharacters; escape them rather than let one change the pattern.
+*/
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+* Whether `definition` selects from `target`.
+*
+* Matches both spellings a definition can carry: the quoted,
+* schema-qualified form Drizzle's query builder emits (`"app"."work_view"`),
+* and the bare form a hand-written `sql.raw` FROM clause may use
+* (`app.work_view`), guarded so it cannot fire on a longer identifier ending
+* the same way. A derived table aliased with a view's *unqualified* name is
+* deliberately not a match — it names no schema, so references no view.
+* The one blind spot that leaves: a hand-written FROM naming a view
+* unqualified and leaning on `search_path`.
+*/
+const referencesView = (definition, target) => {
+	if (viewKey(definition) === viewKey(target)) return false;
+	if (definition.sql.includes(`"${target.schema}"."${target.name}"`)) return true;
+	const qualified = `${escapeRegExp(target.schema)}\\.${escapeRegExp(target.name)}`;
+	return new RegExp(`(^|[^\\w."])${qualified}\\b`).test(definition.sql);
+};
+/** Every view-on-view edge among `views`. Empty is the passing state. */
+const findViewEdges = (views) => views.flatMap((from) => views.filter((to) => referencesView(from, to)).map((to) => ({
+	from,
+	to
+})));
+/** The schema has at least one view-on-view edge. */
+var ViewDependencyError = class extends Schema.TaggedError()("ViewDependencyError", { edges: Schema.Array(Schema.Struct({
+	from: Schema.String,
+	to: Schema.String
+})) }) {
+	get message() {
+		const grouped = Arr.groupBy(this.edges, (edge) => edge.from);
+		const listed = Arr.sort(R.toEntries(grouped).map(([from, group]) => `  ${from} selects from ${Arr.sort(group.map((edge) => edge.to), Order.String).join(", ")}`), Order.String).join("\n");
+		return `${this.edges.length} view-on-view dependency(ies) in the schema:\n\n${listed}\n\ndrizzle-kit emits DROP VIEW / CREATE VIEW with no topological ordering and no cascade to unchanged dependents, so a migration touching either end of one of these edges produces a drop order PostgreSQL rejects, fixable only by hand-editing the migration.
+Fix: resolve the dependency against the underlying tables instead of the sibling view.`;
+	}
+};
+/**
+* Generate the whole schema from an empty snapshot — every view exactly as a
+* migration would create it — and assert no definition references another
+* view. Succeeds with the number of views checked.
+*
+* @example
+* ```ts
+* // An application's `db:view-dependencies` task passes its own schema module.
+* import { checkViewDependencies } from "@thomasfosterau/effect-drizzle-ext-pg/tooling";
+* import { integer, pgTable, pgView, text } from "drizzle-orm/pg-core";
+* import * as Effect from "effect/Effect";
+*
+* const article = pgTable("article", { id: integer().primaryKey(), title: text().notNull() });
+* const articleTitles = pgView("article_titles").as((qb) =>
+*   qb.select({ title: article.title }).from(article),
+* );
+*
+* const { viewCount } = await Effect.runPromise(
+*   checkViewDependencies({ schema: { article, articleTitles } }),
+* );
+* console.log(viewCount); // 1
+* ```
+*/
+const checkViewDependencies = (options) => Effect.gen(function* () {
+	const cur = yield* drizzleKit(() => generateDrizzleJson(options.schema));
+	const empty = yield* drizzleKit(() => generateDrizzleJson({}));
+	const views = parseViewDefinitions(yield* drizzleKit(() => generateMigration(empty, cur)));
+	const edges = findViewEdges(views);
+	if (Arr.isReadonlyArrayNonEmpty(edges)) return yield* new ViewDependencyError({ edges: edges.map((edge) => ({
+		from: viewKey(edge.from),
+		to: viewKey(edge.to)
+	})) });
+	return { viewCount: views.length };
+});
+export { MalformedSnapshot, MigrationDriftError, ROOT_SENTINEL_ID, SchemaDiffError, ViewDependencyError, checkBaseAncestry, checkDagIntegrity, checkMigrationDrift, checkViewDependencies, findHeads, findViewEdges, parseViewDefinitions, readBaseMigrations, referencesView, resolveBaseRef, viewKey };
+
+//# sourceMappingURL=index.js.map

package/dist/tooling/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["Record"],"sources":["../../src/tooling/migration-drift.ts","../../src/tooling/view-dependencies.ts"],"mappings":"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"}

package/package.json

@@ -1,14 +1,86 @@
 {
   "name": "@thomasfosterau/effect-drizzle-ext-pg",
-  "version": "0.0.0",
-  "description": "Placeholder reserved for npm trusted publishing; the first real release of @thomasfosterau/effect-drizzle-ext-pg is 0.1.0.",
+  "version": "0.1.0",
+  "description": "The @effect/sql-pg binding for @thomasfosterau/effect-drizzle-ext: Database / CurrentTransaction services over drizzle-orm/effect-postgres, PgClient layers, a sentinel-rollback test runner with test-database provisioning, a fresh-database migration runner, and migration-drift / view-dependency guards.",
+  "keywords": [
+    "drizzle",
+    "drizzle-orm",
+    "effect",
+    "postgres",
+    "typescript"
+  ],
+  "homepage": "https://github.com/thomasfosterau/effect-drizzle-ext#readme",
+  "bugs": {
+    "url": "https://github.com/thomasfosterau/effect-drizzle-ext/issues"
+  },
   "license": "MIT",
+  "author": "Thomas Foster <me@thomasfoster.au>",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/thomasfosterau/effect-drizzle-ext.git",
+    "url": "https://github.com/thomasfosterau/effect-drizzle-ext.git",
     "directory": "packages/pg"
   },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./migrations": {
+      "types": "./dist/migrations.d.ts",
+      "default": "./dist/migrations.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "default": "./dist/testing.js"
+    },
+    "./tooling": {
+      "types": "./dist/tooling/index.d.ts",
+      "default": "./dist/tooling/index.js"
+    }
+  },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@thomasfosterau/effect-drizzle-ext": "^0.1.0"
+  },
+  "devDependencies": {
+    "@effect/language-service": "^0.87.5",
+    "@effect/platform-node": "4.1.2",
+    "@effect/sql-pg": "4.1.2",
+    "@testcontainers/postgresql": "^12.2.1",
+    "@types/node": "^26.6.6",
+    "@vitest/coverage-istanbul": "5.0.5",
+    "drizzle-kit": "1.0.0-rc.5",
+    "drizzle-orm": "1.0.0-rc.5",
+    "effect": "4.1.2",
+    "vitest": "5.0.5"
+  },
+  "peerDependencies": {
+    "@effect/sql-pg": "^4.0.0",
+    "@testcontainers/postgresql": ">=12",
+    "drizzle-kit": ">=1.0.0-rc.5",
+    "drizzle-orm": ">=1.0.0-rc.5",
+    "effect": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@testcontainers/postgresql": {
+      "optional": true
+    },
+    "drizzle-kit": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22"
   }
-}
+}