okmodel 0.5.0 → 0.6.0

package/dist/shared/09p049xa.js

@@ -0,0 +1,702 @@
+import {
+  parseCatalog2
+} from "./qq3899ht.js";
+import"./n442h54c.js";
+import"./wkme6tep.js";
+import {
+  watchReserved2
+} from "./q3j1tq7a.js";
+import {
+  ensureMigrationTables2
+} from "./nx9hh281.js";
+import {
+  sealViews,
+  catalogQuery2,
+  managedRoleOptions2
+} from "./f0f1n281.js";
+import {
+  assumeRole,
+  grantSchema,
+  assertSchemaUsageLanded,
+  catalogsEqual,
+  snapshotDifference
+} from "./p248q79y.js";
+import {
+  roleExists
+} from "./knmes2kh.js";
+import {
+  introspectSchema
+} from "./vjpnzwjz.js";
+import {
+  projectPath,
+  loadMigrations,
+  readMigrationPlan,
+  lintMigrationDirectory,
+  hasError,
+  lintRefusal,
+  openProject
+} from "./t3g0k88x.js";
+import {
+  sqlStatements,
+  transactionControl,
+  canonicalTypeName,
+  createdRoleName,
+  createRoleOnce,
+  classOf,
+  strictestClass,
+  planMigration,
+  sessionFailure,
+  finishQuiet,
+  assertDirectConnection,
+  assertStableBackend,
+  selectTarget
+} from "./ttmg09vd.js";
+import {
+  isConnectionLost
+} from "./gwn6v667.js";
+import {
+  quoteIdent
+} from "./9s0ypp87.js";
+import {
+  catalog,
+  isDomain
+} from "./ywspezzx.js";
+import {
+  identityKey2
+} from "./358zsv4r.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/tooling/migrate/check.ts
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// src/tooling/migrate/sandbox.ts
+import postgres from "postgres";
+async function replayCheckHistory(url, scratch, config, allowPooler, history) {
+  const skips = [];
+  let stop;
+  await inCheckTransaction(url, scratch, config, allowPooler, async (sql) => {
+    const connection = driverOf(sql);
+    const session = {};
+    for (let index = 0;index < history.length; index += 1) {
+      const migration = history[index];
+      if (migration === undefined)
+        continue;
+      await replayMigration(sql, connection, scratch, config, migration, session, skips);
+      await restoreSession(sql, session);
+      const runner = catalogQuery2(sql);
+      const live = await introspectSchema(runner, scratch, "public", managedRoleOptions2(config.roles));
+      const sealed = await sealViews(runner, migration.catalog);
+      const back = planMigration({ before: live, after: sealed, name: migration.id });
+      if (back.steps.length === 0)
+        continue;
+      stop = { index, back };
+      return;
+    }
+  });
+  return stop === undefined ? { skips } : { skips, stop };
+}
+async function proveCheckSnapshot(url, provided, replayed, config, allowPooler, history) {
+  const head = history.at(-1);
+  if (head === undefined)
+    return;
+  const installed = await inCheckTransaction(url, provided, config, allowPooler, async (sql) => {
+    const connection = driverOf(sql);
+    const session = {};
+    const planned = planMigration({
+      before: catalog([]),
+      after: head.catalog,
+      schema: provided,
+      name: "provision"
+    });
+    await runSteps(sql, connection, provided, config.roles?.migration, {
+      id: "snapshot",
+      catalog: head.catalog,
+      steps: retargetSteps(planned.steps, provided)
+    }, session, []);
+    await restoreSession(sql, session);
+    return introspectSchema(catalogQuery2(sql), provided, "public", managedRoleOptions2(config.roles));
+  });
+  const again = await inCheckTransaction(url, replayed, config, allowPooler, async (sql) => {
+    const connection = driverOf(sql);
+    const session = {};
+    for (const migration of history) {
+      await replayMigration(sql, connection, replayed, config, migration, session, []);
+    }
+    await restoreSession(sql, session);
+    return introspectSchema(catalogQuery2(sql), replayed, "public", managedRoleOptions2(config.roles));
+  });
+  return snapshotDifference(installed, again);
+}
+function retargetSteps(steps, schema) {
+  const from = `${quoteIdent("public")}.`;
+  const to = `${quoteIdent(schema)}.`;
+  const fromDefaults = `in schema ${quoteIdent("public")} `;
+  const toDefaults = `in schema ${quoteIdent(schema)} `;
+  const fromSchema = `on schema ${quoteIdent("public")}`;
+  const toSchema = `on schema ${quoteIdent(schema)}`;
+  return steps.map((step) => ({
+    ...step,
+    sql: step.sql.replaceAll(from, to).replaceAll(fromDefaults, toDefaults).replaceAll(fromSchema, toSchema),
+    ...step.backfill === undefined ? {} : { backfill: { ...step.backfill, table: step.backfill.table.replaceAll(from, to) } }
+  }));
+}
+async function inCheckTransaction(url, scratch, config, allowPooler, run) {
+  const sql = postgres(url, {
+    max: 1,
+    connect_timeout: 5,
+    idle_timeout: 1,
+    onnotice: () => {}
+  });
+  const reserved = await sql.reserve();
+  const lost = { on: false };
+  watchReserved2(reserved, lost);
+  refuseWhenLost(reserved, lost);
+  let open = false;
+  let failure;
+  let value;
+  try {
+    await assertStableBackend(async () => {
+      const rows = await reserved.unsafe("select pg_backend_pid()::text as pid");
+      const pid = cell(rows[0], "pid");
+      return pid ?? "";
+    }, allowPooler);
+    await reserved.unsafe("begin");
+    open = true;
+    const xid = await readXid(reserved);
+    await reserved.unsafe(`create schema ${quoteIdent(scratch)}`);
+    await reserved.unsafe(`set local search_path to ${quoteIdent(scratch)}`);
+    await setLocalTimeout(reserved, "lock_timeout", config.timeouts?.lock);
+    await setLocalTimeout(reserved, "statement_timeout", config.timeouts?.statement);
+    await ownScratch(reserved, scratch, config.roles?.migration);
+    await ensureMigrationTables2((text) => reserved.unsafe(text));
+    value = await run(reserved);
+    const after = await readXid(reserved).catch((error) => {
+      if (isConnectionLost(error))
+        lost.on = true;
+      return;
+    });
+    if (!lost.on && after !== xid)
+      throw xidChanged();
+    if (!lost.on)
+      await reserved.unsafe("rollback");
+    open = false;
+  } catch (error) {
+    if (isConnectionLost(error))
+      lost.on = true;
+    failure = error;
+  } finally {
+    if (open && !lost.on) {
+      await reserved.unsafe("rollback").catch((error) => {
+        if (isConnectionLost(error))
+          lost.on = true;
+      });
+    }
+    if (!lost.on)
+      await reserved.unsafe("reset role").catch(() => {
+        return;
+      });
+    if (!lost.on) {
+      try {
+        reserved.release();
+      } catch {
+        lost.on = true;
+      }
+    }
+    await finishQuiet(() => sql.end({ timeout: 5 }));
+  }
+  const left = await dropScratch(url, scratch);
+  if (left !== undefined) {
+    const note = `Scratch schema ${left} is still present.`;
+    failure = failure === undefined ? new OkmError2("unavailable", note, { kind: "unavailable", fix: UNAVAILABLE_FIX }) : noteOn(failure, note);
+  }
+  if (failure !== undefined)
+    throw sessionFailure(failure) ?? failure;
+  return value;
+}
+var UNAVAILABLE_FIX = {
+  summary: "The connection to Postgres closed. Run the command again when the database is reachable."
+};
+function refuseWhenLost(sql, lost) {
+  const unsafe = sql.unsafe.bind(sql);
+  sql.unsafe = (text, params, options) => {
+    if (lost.on)
+      return Promise.reject(closedError());
+    const pending = options !== undefined ? unsafe(text, params, options) : params !== undefined ? unsafe(text, params) : unsafe(text);
+    return pending.catch((error) => {
+      if (isConnectionLost(error))
+        lost.on = true;
+      throw error;
+    });
+  };
+}
+function closedError() {
+  return Object.assign(new Error("CONNECTION_CLOSED"), { code: "CONNECTION_CLOSED" });
+}
+async function dropScratch(url, scratch) {
+  const sql = postgres(url, {
+    max: 1,
+    connect_timeout: 5,
+    idle_timeout: 1,
+    onnotice: () => {}
+  });
+  try {
+    await sql.unsafe(`drop schema if exists ${quoteIdent(scratch)} cascade`);
+    const rows = await sql`
+      select nspname from pg_namespace where nspname = ${scratch}
+    `;
+    return rows.length > 0 ? scratch : undefined;
+  } catch {
+    return scratch;
+  } finally {
+    await finishQuiet(() => sql.end({ timeout: 5 }));
+  }
+}
+function noteOn(error, note) {
+  if (error instanceof Error) {
+    return new OkmError2("unavailable", `${error.message} ${note}`, {
+      kind: "unavailable",
+      cause: error,
+      fix: UNAVAILABLE_FIX
+    });
+  }
+  return new OkmError2("unavailable", note, { kind: "unavailable", fix: UNAVAILABLE_FIX });
+}
+async function restoreSession(sql, session) {
+  if (session.setRole === undefined)
+    return;
+  await sql.unsafe("reset role");
+  delete session.setRole;
+}
+async function replayMigration(sql, connection, scratch, config, migration, session, skips) {
+  await runSteps(sql, connection, scratch, config.roles?.migration, { ...migration, steps: retargetSteps(migration.steps, scratch) }, session, skips);
+}
+async function runSteps(sql, connection, scratch, migrationRole, migration, session, skips) {
+  for (let index = 0;index < migration.steps.length; index += 1) {
+    const step = migration.steps[index];
+    if (step === undefined)
+      continue;
+    const prepared = prepareCheckSql(step.sql);
+    if (prepared.skip !== undefined) {
+      skips.push(`${migration.id} step ${String(index + 1)}: ${prepared.skip}`);
+    }
+    if (prepared.sql.length === 0)
+      continue;
+    try {
+      const created = createdRoleName(step.sql);
+      const existed = created !== undefined && await roleExists(connection, created);
+      if (step.backfill !== undefined) {
+        await sql.unsafe(prepared.sql, [null, null]);
+      } else if (created === undefined) {
+        await sql.unsafe(prepared.sql);
+        await assertSchemaUsageLanded(connection, prepared.sql);
+      } else if (!existed) {
+        await sql.unsafe(createRoleOnce(prepared.sql.replace(/;\s*$/, "")));
+      }
+      if (created !== undefined && created === migrationRole) {
+        if (!existed) {
+          await grantSchema(connection, scratch, created);
+          await connection.execute(`grant select, insert, update on okm_meta, okm_history, okm_backfill to ${quoteIdent(created)}`);
+        }
+        await assumeRole(connection, created, session);
+      }
+    } catch (error) {
+      throw failStep(migration.id, index, error);
+    }
+  }
+}
+function prepareCheckSql(sql) {
+  const parts = sqlStatements(sql);
+  const source = parts.length === 0 ? [sql] : parts;
+  const kept = [];
+  const skipped = [];
+  for (const statement of source) {
+    const kind = skipKind(statement);
+    if (kind !== undefined) {
+      skipped.push(kind);
+      continue;
+    }
+    kept.push(rewriteConcurrent(statement));
+  }
+  return {
+    sql: kept.length === 0 ? "" : `${kept.join(`;
+`)};`,
+    ...skipped.length > 0 ? { skip: skipped.join(", ") } : {}
+  };
+}
+function skipKind(sql) {
+  const text = sql.trim().replace(/\s+/g, " ").toLowerCase();
+  if (text.startsWith("vacuum"))
+    return "VACUUM is not run inside the check transaction";
+  if (/^(?:create|drop)\s+database\b/.test(text)) {
+    return "CREATE or DROP DATABASE is not run inside the check transaction";
+  }
+  if (text.startsWith("alter system"))
+    return "ALTER SYSTEM is not run inside the check transaction";
+  return;
+}
+function rewriteConcurrent(sql) {
+  const text = sql.trim().replace(/\s+/g, " ").toLowerCase();
+  if (/^(?:create\s+(?:unique\s+)?index|drop\s+index|reindex|refresh\s+materialized\s+view)\b/.test(text)) {
+    return sql.replace(/\s+concurrently\b/gi, "");
+  }
+  return sql;
+}
+async function ownScratch(sql, scratch, role) {
+  if (role === undefined)
+    return;
+  const exists = await sql.unsafe("select exists (select 1 from pg_roles where rolname = $1) as ok", [role]);
+  const present = cell(exists[0], "ok");
+  if (present === "t" || present === "true") {
+    await sql.unsafe(`alter schema ${quoteIdent(scratch)} owner to ${quoteIdent(role)}`);
+  }
+}
+async function setLocalTimeout(sql, name, ms) {
+  if (ms === undefined)
+    return;
+  await sql.unsafe("select set_config($1, $2, true)", [name, String(ms)]);
+}
+async function readXid(sql) {
+  const rows = await sql.unsafe("select pg_current_xact_id()::text as xid");
+  return cell(rows[0], "xid") ?? "";
+}
+function cell(row, key) {
+  if (typeof row !== "object" || row === null || !(key in row))
+    return;
+  const value = Reflect.get(row, key);
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  return;
+}
+function xidChanged() {
+  return new OkmError2("invalid", "okm migrate check left its transaction. A step committed, so the replay did not stay in one transaction.", {
+    kind: "invalid",
+    fix: {
+      summary: "Remove COMMIT, ROLLBACK, and other transaction control from the step. The check always rolls the replay back."
+    }
+  });
+}
+function failStep(id, index, error) {
+  const lost = sessionFailure(error);
+  if (lost !== undefined) {
+    return new OkmError2(lost.code, `Migration ${id} failed at step ${String(index + 1)}: ${lost.message}`, { kind: lost.kind, cause: error, fix: lost.fix });
+  }
+  if (error instanceof OkmError2)
+    return error;
+  const message = error instanceof Error ? error.message : "The step failed.";
+  return new OkmError2("invalid", `Migration ${id} failed at step ${String(index + 1)}: ${message}`, {
+    cause: error,
+    fix: { summary: "Fix the step and run apply again. Finished steps are not repeated." }
+  });
+}
+function driverOf(sql) {
+  return {
+    async execute(text, params) {
+      const query = params === undefined || params.length === 0 ? sql.unsafe(text) : sql.unsafe(text, [...params]);
+      const rows = await query;
+      const wire = Array.from(rows, (row) => cells(row));
+      return { rows: wire, count: rows.count ?? wire.length, notices: [] };
+    },
+    batch() {
+      return Promise.reject(new Error("okm migrate check does not batch."));
+    },
+    release() {
+      return Promise.resolve();
+    }
+  };
+}
+function cells(row) {
+  const values = Array.isArray(row) ? row : Object.values(row);
+  return values.map((value) => {
+    if (value === null || value === undefined)
+      return null;
+    if (value === true)
+      return "t";
+    if (value === false)
+      return "f";
+    if (typeof value === "string")
+      return value;
+    if (typeof value === "number" || typeof value === "bigint")
+      return String(value);
+    return null;
+  });
+}
+
+// src/tooling/migrate/check.ts
+var CHECK_SCHEMA_PREFIX = "okm_check_";
+var HISTORY_CODE = "OKM1547";
+var PREVIOUS_CODE = "OKM1548";
+var STALE_CODE = "OKM1549";
+var HISTORY_FIX = "Regenerate the migration so the stored catalog matches the schema the SQL applies.";
+var FORK_FIX = "Generate the later migration from the previous migration's catalog, not from an older parent.";
+var PREVIOUS_FIX = "Keep every table, column, constraint, and type the previous catalog relies on, or classify the migration as contract.";
+var STALE_FIX = "Run okm generate.";
+async function checkMigrations(cwd, flags, options) {
+  const opened = await openProject(cwd);
+  const target = selectTarget(opened.config, flags.target);
+  const allowPooler = flags.allowPooler || opened.config.allowPooler === true;
+  assertDirectConnection(target.url, allowPooler);
+  if (target.protected) {
+    throw new OkmError2("OKM1850", `okm migrate check writes a scratch schema and refuses protected target ${target.name}. Point it at a throwaway Postgres.`, {
+      kind: "forbidden",
+      fix: {
+        summary: "Point okm migrate check at a throwaway Postgres. --allow-protected does not apply."
+      }
+    });
+  }
+  const directory = projectPath(cwd, opened.config.migrations ?? "migrations");
+  const history = readHistory(directory);
+  const previous = previousFailures(history);
+  const stale = staleFailure(history, opened.built.catalog);
+  const lint = lintFailure(directory, history, opened.config.lintFrom);
+  if (lint.length > 0)
+    throwFailure([...previous, ...stale, ...lint]);
+  refuseTransactionControl(history);
+  if (options?.provision === true) {
+    const equivalence = await proveSnapshot(opened.config, target.url, flags, history);
+    if (equivalence !== undefined)
+      throwFailure([equivalence]);
+  }
+  const replayed = await replayHistory(opened.config, target.url, flags, history);
+  const failures = [...replayed.failures, ...previous, ...stale, ...lint];
+  if (failures.length > 0)
+    throwFailure(failures);
+  const summary = `ok ${String(history.length)} migrations
+`;
+  if (replayed.skips.length === 0)
+    return summary;
+  return `${summary}${replayed.skips.join(`
+`)}
+`;
+}
+function previousCatalogGaps(before, after) {
+  const afterBy = new Map(after.objects.map((object) => [identityKey2(object.identity), object]));
+  const gaps = [];
+  for (const object of before.objects) {
+    if (!checkedKind(object.kind))
+      continue;
+    const next = afterBy.get(identityKey2(object.identity));
+    if (next === undefined || next.kind !== object.kind) {
+      gaps.push(`${objectLabel(object)} is missing`);
+      continue;
+    }
+    if (object.kind === "column" && next.kind === "column") {
+      gaps.push(...columnGaps(object, next));
+    }
+    if (object.kind === "type" && next.kind === "type" && !sameType(object.definition, next.definition)) {
+      gaps.push(`${objectLabel(object)} changed`);
+    }
+  }
+  return gaps;
+}
+function recomputedMigrationClass(plan, before, after) {
+  if (plan.steps.length === 0)
+    return "expand";
+  if (plan.steps.some((step) => step.kind === undefined)) {
+    return planMigration({ before, after, name: plan.name }).class;
+  }
+  return strictestClass(plan.steps.map((step) => classOf(step.kind ?? "raw-sql")));
+}
+function migrationAllowsPreviousGaps(plan, before, after) {
+  return recomputedMigrationClass(plan, before, after) === "contract" && plan.class !== "expand";
+}
+function previousFailures(history) {
+  const failures = [];
+  let before = catalog([]);
+  for (const migration of history) {
+    const gaps = previousCatalogGaps(before, migration.catalog);
+    if (gaps.length > 0 && !migrationAllowsPreviousGaps(migration.plan, before, migration.catalog)) {
+      const stated = migration.plan.class === "expand" ? "expand" : recomputedMigrationClass(migration.plan, before, migration.catalog);
+      failures.push({
+        code: PREVIOUS_CODE,
+        message: `${migration.id}: previous catalog is not satisfied (${gaps.join("; ")}). The migration is classified ${stated}.`,
+        fix: PREVIOUS_FIX
+      });
+    }
+    before = migration.catalog;
+  }
+  return failures;
+}
+function staleFailure(history, head) {
+  const last = history.at(-1)?.catalog ?? catalog([]);
+  if (catalogsEqual(last, head))
+    return [];
+  return [
+    {
+      code: STALE_CODE,
+      message: "The last migration's catalog does not match the schema.",
+      fix: STALE_FIX
+    }
+  ];
+}
+function lintFailure(directory, history, lintFrom) {
+  const findings = lintMigrationDirectory(directory, lintIds(history, lintFrom));
+  if (!hasError(findings))
+    return [];
+  const refusal = lintRefusal(findings);
+  return [{ code: refusal.code, message: refusal.message, fix: refusal.fix.summary }];
+}
+function lintIds(history, lintFrom) {
+  if (lintFrom === undefined)
+    return;
+  const ids = history.map((migration) => migration.id);
+  const start = ids.indexOf(lintFrom);
+  if (start < 0) {
+    throw new OkmError2("invalid", `lintFrom ${lintFrom} is not a migration id.`, {
+      fix: {
+        summary: "Set lintFrom to a migration id. Files before that id are the adoption baseline and are not linted."
+      }
+    });
+  }
+  return new Set(ids.slice(start));
+}
+async function proveSnapshot(config, url, flags, history) {
+  const provided = `${CHECK_SCHEMA_PREFIX}p${crypto.randomUUID().replaceAll("-", "")}`;
+  const replayed = `${CHECK_SCHEMA_PREFIX}r${crypto.randomUUID().replaceAll("-", "")}`;
+  const difference = await proveCheckSnapshot(url, provided, replayed, config, flags.allowPooler || config.allowPooler === true, history);
+  if (difference === undefined)
+    return;
+  return {
+    code: "OKM1521",
+    message: `Provisioning from the snapshot does not match the replayed history.
+${difference}`,
+    fix: "Regenerate the snapshot from the history. okm migrate check --provision is the command that reports this."
+  };
+}
+async function replayHistory(config, url, flags, history) {
+  if (history.length === 0)
+    return { failures: [], skips: [] };
+  const scratch = `${CHECK_SCHEMA_PREFIX}${crypto.randomUUID().replaceAll("-", "")}`;
+  const outcome = await replayCheckHistory(url, scratch, config, flags.allowPooler || config.allowPooler === true, history);
+  if (outcome.stop === undefined)
+    return { failures: [], skips: outcome.skips };
+  return {
+    failures: [historyFailure(history, outcome.stop.index, outcome.stop.back)],
+    skips: outcome.skips
+  };
+}
+function refuseTransactionControl(history) {
+  for (const migration of history) {
+    migration.steps.forEach((step, index) => {
+      const word = transactionControl(step.sql);
+      if (word === undefined)
+        return;
+      throw new OkmError2("OKM1551", `Migration ${migration.id} step ${String(index + 1)} contains ${word}.`, {
+        fix: {
+          summary: "Remove transaction control from the step. okm migrate check replays one transaction and rolls it back."
+        }
+      });
+    });
+  }
+}
+function historyFailure(history, index, back) {
+  const migration = history[index];
+  const id = migration?.id ?? "migration";
+  const fork = migration === undefined ? undefined : forkMessage(history, index);
+  if (fork !== undefined)
+    return { code: HISTORY_CODE, message: fork, fix: FORK_FIX };
+  const steps = back.steps.map((step) => step.sql).join(`
+`);
+  return {
+    code: HISTORY_CODE,
+    message: `${id}: history differs from the stored catalog
+${steps}`,
+    fix: HISTORY_FIX
+  };
+}
+function forkMessage(history, index) {
+  const current = history[index];
+  const previous = history[index - 1];
+  if (current === undefined || previous === undefined)
+    return;
+  if (samePlan(previous.catalog, current.catalog, current.plan))
+    return;
+  for (let parentIndex = 0;parentIndex < index; parentIndex += 1) {
+    const parent = parentIndex === 0 ? catalog([]) : history[parentIndex - 1]?.catalog;
+    if (parent === undefined)
+      continue;
+    if (!samePlan(parent, current.catalog, current.plan))
+      continue;
+    return `migration ${current.id} was generated from a different parent than ${previous.id}`;
+  }
+  return;
+}
+function samePlan(before, after, file) {
+  try {
+    return sameSql(planMigration({ before, after, name: "parent" }), file);
+  } catch (error) {
+    if (error instanceof OkmError2 && error.code === "OKM1530")
+      return false;
+    throw error;
+  }
+}
+function sameSql(planned, file) {
+  if (planned.steps.length !== file.steps.length)
+    return false;
+  return planned.steps.every((step, index) => step.sql === file.steps[index]?.sql);
+}
+function readHistory(directory) {
+  return loadMigrations(directory).map((migration) => ({
+    id: migration.id,
+    catalogHash: migration.catalogHash,
+    steps: migration.steps,
+    plan: readMigrationPlan(join(directory, `${migration.id}.sql`)),
+    catalog: parseCatalog2(readFileSync(join(directory, `${migration.id}.catalog.json`), "utf8"))
+  }));
+}
+function throwFailure(failures) {
+  const first = failures[0];
+  if (first === undefined)
+    throw new Error("okm migrate check has no failure to report.");
+  const message = failures.length === 1 ? first.message : failures.map((failure) => `${failure.code} ${failure.message}`).join(`
+`);
+  throw new OkmError2(first.code, message, { fix: { summary: first.fix } });
+}
+function checkedKind(kind) {
+  return kind === "table" || kind === "column" || kind === "constraint" || kind === "type";
+}
+function columnGaps(before, after) {
+  const gaps = [];
+  const place = objectLabel(before);
+  if (canonicalTypeName(before.definition.dataType) !== canonicalTypeName(after.definition.dataType)) {
+    gaps.push(`${place} changed type from ${before.definition.dataType} to ${after.definition.dataType}`);
+  }
+  if (before.definition.nullable && !after.definition.nullable && !columnHasDefault(after)) {
+    gaps.push(`${place} nullability tightened without a default`);
+  }
+  return gaps;
+}
+function columnHasDefault(column) {
+  return column.definition.defaultExpression !== undefined || column.definition.identity !== undefined || column.definition.generated !== undefined;
+}
+function sameType(before, after) {
+  const beforeDomain = isDomain(before);
+  const afterDomain = isDomain(after);
+  if (beforeDomain !== afterDomain)
+    return false;
+  if (beforeDomain && afterDomain) {
+    return canonicalTypeName(before.base) === canonicalTypeName(after.base) && before.check === after.check;
+  }
+  if (!beforeDomain && !afterDomain) {
+    if (before.labels.length !== after.labels.length)
+      return false;
+    return before.labels.every((label, index) => label === after.labels[index]);
+  }
+  return false;
+}
+function objectLabel(object) {
+  if (object.kind === "column" || object.kind === "constraint") {
+    return `${object.kind} ${object.identity.parent.name}.${object.identity.name}`;
+  }
+  if (object.kind === "table" || object.kind === "type") {
+    return `${object.kind} ${object.identity.name}`;
+  }
+  return object.kind;
+}
+export {
+  checkMigrations
+};