okmodel 0.2.1 → 0.4.0

package/dist/runtime/traits/index.js

@@ -1,38 +1,50 @@
+import"../../shared/8jb4ymh2.js";
 import {
   checkPresetNames,
   duplicatePreset
 } from "../../shared/nsva2a6b.js";
 import {
   checkTrait
-} from "../../shared/g1b5zzj9.js";
+} from "../../shared/n0dgs0pb.js";
+import {
+  quoteIdent
+} from "../../shared/41kv2xdm.js";
+import {
+  functionObject,
+  triggerObject
+} from "../../shared/9x25fxhc.js";
 import {
   timestamptz2
-} from "../../shared/xkz8g6by.js";
+} from "../../shared/1g0drakv.js";
 import {
   uuid2
-} from "../../shared/ps43134h.js";
+} from "../../shared/dyj86cmj.js";
 import {
   snakeCase
-} from "../../shared/x9v1qgeb.js";
+} from "../../shared/jsd07prz.js";
 import {
   ColumnBuilder2,
   retarget
-} from "../../shared/dd4f8mnx.js";
+} from "../../shared/c9z5g0fm.js";
 import {
   definition,
   unavailable
-} from "../../shared/xatfg0gn.js";
+} from "../../shared/tmbdywx0.js";
 import {
+  staticNamespace2,
   compareText
 } from "../../shared/t4tbsy9h.js";
 import {
   queryHandle,
   attachHttp,
   settleCall
-} from "../../shared/mxmcdsh5.js";
+} from "../../shared/kkzwp3d2.js";
 import {
   installArchiveInspect
 } from "../../shared/xrfnq5k8.js";
+import {
+  fitIdentifier2
+} from "../../shared/nfzc5z0w.js";
 import {
   OkmError2,
   catalogError2,
@@ -256,6 +268,124 @@ function list(names) {
   return names.join(", ");
 }
 
+// src/dialects/pg/fn/touch.ts
+function timestampRecords(built) {
+  const columns = updatedColumns(built);
+  if (columns.length === 0)
+    return [];
+  const namespace = staticNamespace2("public");
+  const byColumn = new Map;
+  for (const column of columns) {
+    const list = byColumn.get(column.name) ?? [];
+    list.push(column.parent);
+    byColumn.set(column.name, list);
+  }
+  const records = [];
+  for (const [column, tables] of byColumn) {
+    const name = fitIdentifier2(`okm_touch_${column}`);
+    const present = hasFunction(built, name) || records.some((object) => object.kind === "function" && object.identity.name === name);
+    if (!present) {
+      records.push(functionObject({
+        namespace,
+        name,
+        returns: "trigger",
+        language: "plpgsql",
+        volatility: "volatile",
+        body: `begin new.${quoteIdent(column)} = now(); return new; end`,
+        provenance: { origin: "trait", name: "timestamps" },
+        dependencies: []
+      }));
+    }
+    for (const parent of tables) {
+      const triggerName = fitIdentifier2(`${parent.name}_touch`);
+      if (hasTrigger(built, parent.name, triggerName))
+        continue;
+      if (records.some((object) => object.kind === "trigger" && object.identity.name === triggerName && object.identity.parent.name === parent.name)) {
+        continue;
+      }
+      records.push(triggerObject({
+        parent,
+        name: triggerName,
+        timing: "before",
+        events: ["update"],
+        level: "row",
+        calls: { namespace, name, argTypes: [] },
+        provenance: { origin: "trait", name: "timestamps" }
+      }));
+    }
+  }
+  return records;
+}
+function updatedColumns(built) {
+  if (!Array.isArray(built))
+    return [];
+  const found = [];
+  for (const object of built) {
+    if (typeof object !== "object" || object === null)
+      continue;
+    if (!("kind" in object) || object.kind !== "column")
+      continue;
+    if (!("provenance" in object) || !("identity" in object))
+      continue;
+    const provenance = object.provenance;
+    const identity = object.identity;
+    if (typeof provenance !== "object" || provenance === null)
+      continue;
+    if (typeof identity !== "object" || identity === null)
+      continue;
+    if (!("origin" in provenance) || provenance.origin !== "trait")
+      continue;
+    if (!("name" in provenance) || provenance.name !== "timestamps")
+      continue;
+    if (!("name" in identity) || identity.name !== "updated_at" && identity.name !== "updatedAt")
+      continue;
+    if (!("parent" in identity) || typeof identity.parent !== "object" || identity.parent === null)
+      continue;
+    const parent = identity.parent;
+    if (!("name" in parent) || typeof parent.name !== "string")
+      continue;
+    if (!("namespace" in parent) || typeof parent.namespace !== "object" || parent.namespace === null)
+      continue;
+    const namespace = parent.namespace;
+    if (!("form" in namespace) || namespace.form !== "static")
+      continue;
+    if (!("name" in namespace) || typeof namespace.name !== "string")
+      continue;
+    found.push({
+      parent: { namespace: staticNamespace2(namespace.name), name: parent.name },
+      name: identity.name
+    });
+  }
+  return found;
+}
+function hasFunction(built, name) {
+  return named(built, "function", name);
+}
+function hasTrigger(built, table, name) {
+  if (!Array.isArray(built))
+    return false;
+  return built.some((object) => {
+    if (!isNamed(object, "trigger", name))
+      return false;
+    const identity = object.identity;
+    return typeof identity === "object" && identity !== null && "parent" in identity && typeof identity.parent === "object" && identity.parent !== null && "name" in identity.parent && identity.parent.name === table;
+  });
+}
+function named(built, kind, name) {
+  if (!Array.isArray(built))
+    return false;
+  return built.some((object) => isNamed(object, kind, name));
+}
+function isNamed(object, kind, name) {
+  if (typeof object !== "object" || object === null)
+    return false;
+  if (!("kind" in object) || object.kind !== kind)
+    return false;
+  if (!("identity" in object) || typeof object.identity !== "object" || object.identity === null)
+    return false;
+  return "name" in object.identity && object.identity.name === name;
+}
+
 // src/runtime/archive-rules.ts
 function installArchiveContributions() {
   installArchiveInspect(archiveContributions);
@@ -329,7 +459,7 @@ function refuse(host, table) {
 }
 var archiveMod;
 function loadArchive() {
-  archiveMod ??= import("../../shared/m9tv7xn7.js");
+  archiveMod ??= import("../../shared/radd3z4g.js");
   return archiveMod;
 }
 async function settle(host, table, mods) {
@@ -376,6 +506,9 @@ function trait(name, input) {
       addFields(name, checked.fields, model, ctx);
       if (input.presets !== undefined)
         addPresets(name, input.presets, model, ctx);
+    },
+    contribute() {
+      return [];
     }
   };
 }
@@ -398,14 +531,11 @@ function timestamps(options) {
         definition(`timestamps() option ${key} is not supported. Accepted options: enforce.`);
       }
     }
-    if (options.enforce === "trigger") {
-      unavailable(`timestamps({ enforce: "trigger" }) is not available yet. It arrives in 0.3.`);
-    }
-    if (options.enforce !== undefined) {
+    if (options.enforce !== undefined && options.enforce !== "trigger") {
       definition(`timestamps() enforce ${String(options.enforce)} must be trigger.`);
     }
   }
-  return trait("timestamps", {
+  const base = trait("timestamps", {
     fields: {
       createdAt: stamped(),
       updatedAt: stamped()
@@ -413,6 +543,14 @@ function timestamps(options) {
     touch: ["updatedAt"],
     sealed: ["createdAt", "updatedAt"]
   });
+  if (options?.enforce !== "trigger")
+    return base;
+  return {
+    ...base,
+    contribute(_peers, built) {
+      return timestampRecords(built);
+    }
+  };
 }
 function stamped() {
   return timestamptz2().defaultSql("now()").guarded();

package/dist/runtime/types.d.ts

@@ -672,6 +672,8 @@ export type ConnectOptions<S extends QuerySchema> = {
      * Directory of `catalog.hash` and `catalog.json`.
      *
      * When omitted, `connect` reads `.okm` under the process cwd if that hash file exists.
+     * The hash file is the fast path. A mismatch then reads `catalog.json` once
+     * per process and does not rebuild the catalog from the schema.
      */
     readonly catalogDir?: string;
     readonly logger?: {

package/dist/runtime/validate/index.js

@@ -1,12 +1,12 @@
 import {
   validationGate
-} from "../../shared/3a5ne750.js";
+} from "../../shared/9m80mkac.js";
 import {
   addSchemaHook
-} from "../../shared/7mht49yd.js";
+} from "../../shared/3p4b1fg0.js";
 import {
   queryHandle
-} from "../../shared/mxmcdsh5.js";
+} from "../../shared/kkzwp3d2.js";
 import {
   OkmError2
 } from "../../shared/52szzakm.js";
@@ -14,7 +14,7 @@ import {
 // src/runtime/validate/load.ts
 var engine;
 function loadEngine() {
-  engine ??= import("../../shared/n47rd821.js");
+  engine ??= import("../../shared/c8aghh05.js");
   return engine;
 }
 

package/dist/shared/{xkz8g6by.js → 1g0drakv.js}

@@ -1,10 +1,10 @@
 import {
   required
-} from "./dd4f8mnx.js";
+} from "./c9z5g0fm.js";
 import {
   definition,
   rejected
-} from "./xatfg0gn.js";
+} from "./tmbdywx0.js";
 
 // src/dialects/pg/temporal.ts
 var TEMPORAL_MISSING = "Date and time codecs need the Temporal global. okmodel does not ship a polyfill. Use a runtime that provides Temporal, or assign a polyfill to globalThis.Temporal before using these columns.";

package/dist/shared/2321avmn.js

@@ -0,0 +1,418 @@
+import {
+  parseCatalog2
+} from "./8jb4ymh2.js";
+import"./wqem4jed.js";
+import"./n442h54c.js";
+import {
+  applyTarget2,
+  backfillTiming2
+} from "./s4mb6a4b.js";
+import {
+  introspectSchema,
+  sealViews,
+  catalogQuery2,
+  managedRoleOptions2
+} from "./xghkt7a9.js";
+import {
+  loadMigrations,
+  catalogsEqual,
+  snapshotDifference
+} from "./7nk68fj8.js";
+import {
+  lintMigrationDirectory,
+  hasError,
+  lintRefusal,
+  selectTarget,
+  openProject
+} from "./q6zsyh31.js";
+import {
+  canonicalTypeName,
+  classOf,
+  strictestClass,
+  planMigration,
+  parsePlan
+} from "./n5y9zyj1.js";
+import {
+  quoteIdent
+} from "./41kv2xdm.js";
+import {
+  catalog,
+  isDomain
+} from "./g7ez901n.js";
+import {
+  identityKey2
+} from "./t4tbsy9h.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/tooling/migrate/check.ts
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import postgres from "postgres";
+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);
+  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 = join(cwd, opened.config.migrations ?? "migrations");
+  const history = readHistory(directory);
+  if (options?.provision === true) {
+    const equivalence = await proveSnapshot(opened.config, target.url, target.name, flags, history);
+    if (equivalence !== undefined)
+      throwFailure([equivalence]);
+  }
+  const previous = previousFailures(history);
+  const stale = staleFailure(history, opened.built.catalog);
+  const lint = lintFailure(directory, history, opened.config.lintFrom);
+  const replayed = await replayHistory(opened.config, target.url, target.name, flags, history);
+  const failures = [...replayed, ...previous, ...stale, ...lint];
+  if (failures.length > 0)
+    throwFailure(failures);
+  return `ok ${String(history.length)} migrations
+`;
+}
+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, target, flags, history) {
+  const head = history.at(-1);
+  if (head === undefined)
+    return;
+  const sql = postgres(url, {
+    max: 1,
+    connect_timeout: 5,
+    idle_timeout: 1,
+    onnotice: () => {}
+  });
+  const provided = `${CHECK_SCHEMA_PREFIX}p${crypto.randomUUID().replaceAll("-", "")}`;
+  const replayed = `${CHECK_SCHEMA_PREFIX}r${crypto.randomUUID().replaceAll("-", "")}`;
+  const timing = {
+    ...flags.lockTimeoutMs !== undefined ? { lockTimeoutMs: flags.lockTimeoutMs } : config.timeouts?.lock !== undefined ? { lockTimeoutMs: config.timeouts.lock } : {},
+    ...flags.statementTimeoutMs !== undefined ? { statementTimeoutMs: flags.statementTimeoutMs } : config.timeouts?.statement !== undefined ? { statementTimeoutMs: config.timeouts.statement } : {},
+    ...backfillTiming2(config.backfill)
+  };
+  try {
+    await sql.unsafe(`create schema ${quoteIdent(provided)}`);
+    await sql.unsafe(`create schema ${quoteIdent(replayed)}`);
+    const role = config.roles === undefined ? {} : { migrationRole: config.roles.migration, schema: provided };
+    await applyTarget2({
+      url,
+      target,
+      protected: false,
+      allowProtected: false,
+      allowPooler: flags.allowPooler || config.allowPooler === true,
+      searchPath: provided,
+      ...timing,
+      migrations: history.map((migration) => ({
+        id: migration.id,
+        catalogHash: migration.catalogHash,
+        steps: migration.steps
+      })),
+      snapshot: {
+        catalog: head.catalog,
+        migrationId: head.id,
+        catalogHash: head.catalogHash,
+        reference: [],
+        only: true
+      },
+      ...role
+    });
+    await applyTarget2({
+      url,
+      target,
+      protected: false,
+      allowProtected: false,
+      allowPooler: flags.allowPooler || config.allowPooler === true,
+      searchPath: replayed,
+      ...timing,
+      migrations: history.map((migration) => ({
+        id: migration.id,
+        catalogHash: migration.catalogHash,
+        steps: retargetSteps(migration.steps, replayed)
+      })),
+      ...config.roles !== undefined ? { migrationRole: config.roles.migration, schema: replayed } : {}
+    });
+    const runner = catalogQuery2(sql);
+    const liveProvided = await introspectSchema(runner, provided, "public", managedRoleOptions2(config.roles));
+    const liveReplayed = await introspectSchema(runner, replayed, "public", managedRoleOptions2(config.roles));
+    const difference = snapshotDifference(liveProvided, liveReplayed);
+    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."
+    };
+  } finally {
+    await sql.unsafe(`drop schema if exists ${quoteIdent(provided)} cascade`).catch(() => {
+      return;
+    });
+    await sql.unsafe(`drop schema if exists ${quoteIdent(replayed)} cascade`).catch(() => {
+      return;
+    });
+    await sql.end({ timeout: 5 });
+  }
+}
+async function replayHistory(config, url, target, flags, history) {
+  if (history.length === 0)
+    return [];
+  const sql = postgres(url, {
+    max: 1,
+    connect_timeout: 5,
+    idle_timeout: 1,
+    onnotice: () => {}
+  });
+  const scratch = `${CHECK_SCHEMA_PREFIX}${crypto.randomUUID().replaceAll("-", "")}`;
+  const failures = [];
+  try {
+    await sql.unsafe(`create schema ${quoteIdent(scratch)}`);
+    const runner = catalogQuery2(sql);
+    for (let index = 0;index < history.length; index += 1) {
+      const migration = history[index];
+      if (migration === undefined)
+        continue;
+      await applyTarget2({
+        url,
+        target,
+        protected: false,
+        allowProtected: false,
+        allowPooler: flags.allowPooler || config.allowPooler === true,
+        searchPath: scratch,
+        ...flags.lockTimeoutMs !== undefined ? { lockTimeoutMs: flags.lockTimeoutMs } : config.timeouts?.lock !== undefined ? { lockTimeoutMs: config.timeouts.lock } : {},
+        ...flags.statementTimeoutMs !== undefined ? { statementTimeoutMs: flags.statementTimeoutMs } : config.timeouts?.statement !== undefined ? { statementTimeoutMs: config.timeouts.statement } : {},
+        ...backfillTiming2(config.backfill),
+        migrations: [
+          {
+            id: migration.id,
+            catalogHash: migration.catalogHash,
+            steps: retargetSteps(migration.steps, scratch)
+          }
+        ],
+        ...config.roles !== undefined ? { migrationRole: config.roles.migration, schema: scratch } : {}
+      });
+      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;
+      failures.push(historyFailure(history, index, back));
+      break;
+    }
+  } finally {
+    await sql.unsafe(`drop schema if exists ${quoteIdent(scratch)} cascade`).catch(() => {
+      return;
+    });
+    await sql.end({ timeout: 5 });
+  }
+  return failures;
+}
+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 retargetSteps(steps, schema) {
+  const from = `${quoteIdent("public")}.`;
+  const to = `${quoteIdent(schema)}.`;
+  return steps.map((step) => ({
+    ...step,
+    sql: step.sql.replaceAll(from, to),
+    ...step.backfill === undefined ? {} : { backfill: { ...step.backfill, table: step.backfill.table.replaceAll(from, to) } }
+  }));
+}
+function readHistory(directory) {
+  return loadMigrations(directory).map((migration) => ({
+    id: migration.id,
+    catalogHash: migration.catalogHash,
+    steps: migration.steps,
+    plan: parsePlan(readFileSync(join(directory, `${migration.id}.sql`), "utf8")),
+    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
+};