okmodel 0.2.1 → 0.4.0

package/dist/shared/xghkt7a9.js

@@ -0,0 +1,1144 @@
+import {
+  roleObject,
+  grantObject,
+  defaultPrivilegeObject
+} from "./8jb4ymh2.js";
+import {
+  planMigration
+} from "./n5y9zyj1.js";
+import {
+  quoteIdent,
+  createObjectSql
+} from "./41kv2xdm.js";
+import {
+  functionObject,
+  triggerObject
+} from "./9x25fxhc.js";
+import {
+  normaliseViewQuery,
+  viewObject,
+  materializedViewObject,
+  materializedViewIndex
+} from "./y005b761.js";
+import {
+  extensionObject
+} from "./8ktwd3rh.js";
+import {
+  catalog,
+  enumType,
+  domainType
+} from "./g7ez901n.js";
+import {
+  staticNamespace2,
+  identityKey2,
+  table3,
+  column2,
+  index3,
+  constraint2,
+  sequence2
+} from "./t4tbsy9h.js";
+import {
+  referentialAction
+} from "./4e4c6vq2.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/tooling/migrate/drift.ts
+import postgres from "postgres";
+
+// src/dialects/pg/view/depend.ts
+function cellText(value) {
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  return "";
+}
+var VIEW_DEPENDENCIES = `
+  select v.relname as view, t.relname as table, a.attname as column
+  from pg_depend d
+  join pg_rewrite r on r.oid = d.objid and d.classid = 'pg_rewrite'::regclass
+  join pg_class v on v.oid = r.ev_class
+  join pg_class t on t.oid = d.refobjid and d.refclassid = 'pg_class'::regclass
+  join pg_attribute a on a.attrelid = t.oid and a.attnum = d.refobjsubid
+  join pg_namespace n on n.oid = v.relnamespace
+  where n.nspname = $1
+    and v.relkind in ('v', 'm')
+    and d.refobjsubid > 0
+    and v.oid <> t.oid
+    and t.relkind in ('r', 'p', 'v', 'm')
+`;
+function viewDependencyEdges(rows, namespace, objects) {
+  const keys = new Set(objects.map((object) => identityKey2(object.identity)));
+  const byView = new Map;
+  for (const row of rows) {
+    const view = cellText(row.view);
+    const table = cellText(row.table);
+    const column = cellText(row.column);
+    if (view.length === 0 || table.length === 0 || column.length === 0)
+      continue;
+    const columnEdge = {
+      kind: "column",
+      parent: { namespace, name: table },
+      name: column
+    };
+    const columnKey = identityKey2(columnEdge);
+    let edge = columnEdge;
+    if (!keys.has(columnKey)) {
+      const viewEdge = objectEdge(namespace, table, objects);
+      if (viewEdge === undefined)
+        continue;
+      edge = viewEdge;
+    }
+    const list = byView.get(view) ?? [];
+    list.push(edge);
+    byView.set(view, list);
+  }
+  return byView;
+}
+function objectEdge(namespace, name, objects) {
+  for (const object of objects) {
+    if (object.kind !== "view" && object.kind !== "materializedView")
+      continue;
+    if (object.identity.name !== name)
+      continue;
+    if (object.identity.namespace.form !== "static" || namespace.form !== "static")
+      continue;
+    if (object.identity.namespace.name !== namespace.name)
+      continue;
+    return object.identity;
+  }
+  return;
+}
+var PUBLIC = staticNamespace2("public");
+
+// src/dialects/pg/introspect.ts
+var PROVENANCE_NAME = "database";
+async function introspectSchema(runner, concrete, logical = "public", options) {
+  const namespace = staticNamespace2(logical);
+  const provenance = { origin: "file", name: PROVENANCE_NAME };
+  const params = [concrete];
+  const [
+    tables,
+    columns,
+    constraints,
+    indexes,
+    sequences,
+    enums,
+    domains,
+    extensions,
+    functions,
+    triggers,
+    functionDeps,
+    views,
+    viewDeps
+  ] = await Promise.all([
+    runner.query(TABLES, params),
+    runner.query(COLUMNS, params),
+    runner.query(CONSTRAINTS, params),
+    runner.query(INDEXES, params),
+    runner.query(SEQUENCES, params),
+    runner.query(ENUMS, params),
+    runner.query(DOMAINS, params),
+    runner.query(EXTENSIONS, params),
+    runner.query(FUNCTIONS, params),
+    runner.query(TRIGGERS, params),
+    runner.query(FUNCTION_DEPS, params),
+    runner.query(VIEWS, params),
+    runner.query(VIEW_DEPENDENCIES, params)
+  ]);
+  const objects = [];
+  const parents = new Map;
+  for (const row of tables) {
+    const name = text(row, "name");
+    const parent = { namespace, name };
+    parents.set(name, parent);
+    const method = partitionMethod(text(row, "partstrat"));
+    const partColumns = list(text(row, "partcols"));
+    objects.push(table3({
+      namespace,
+      name,
+      provenance,
+      ...method === undefined || partColumns.length === 0 ? {} : { partition: { method, columns: partColumns } }
+    }));
+  }
+  const sequenceIdentity = new Map;
+  for (const row of sequences) {
+    const name = text(row, "name");
+    const dataType = sequenceType(text(row, "type"));
+    const ownedTable = text(row, "owned_table");
+    const dependencies = [];
+    if (ownedTable.length > 0) {
+      dependencies.push({ kind: "table", namespace, name: ownedTable });
+    }
+    const built = sequence2({
+      namespace,
+      name,
+      dataType,
+      start: numberText(row, "start"),
+      increment: numberText(row, "increment"),
+      cycle: flag(row, "cycle"),
+      provenance,
+      ...dependencies.length > 0 ? { dependencies } : {}
+    });
+    sequenceIdentity.set(name, built.identity);
+    objects.push(built);
+  }
+  const enumLabels = new Map;
+  for (const row of enums) {
+    const name = text(row, "name");
+    const labels = enumLabels.get(name) ?? [];
+    labels.push(text(row, "label"));
+    enumLabels.set(name, labels);
+  }
+  for (const [name, labels] of enumLabels) {
+    objects.push(enumType({ namespace, name, labels, provenance }));
+  }
+  const domainNames = new Set;
+  const domainChecks = new Map;
+  for (const row of domains) {
+    const name = text(row, "name");
+    const found = domainChecks.get(name) ?? { base: text(row, "base"), checks: [] };
+    const expression = checkExpression(text(row, "definition"));
+    if (expression.length > 0)
+      found.checks.push(expression);
+    domainChecks.set(name, found);
+  }
+  for (const [name, domain] of domainChecks) {
+    const check = domain.checks.join(" and ");
+    if (check.length === 0)
+      continue;
+    domainNames.add(name);
+    objects.push(domainType({ namespace, name, base: domain.base, check, provenance }));
+  }
+  for (const row of columns) {
+    const parentName = text(row, "parent");
+    const parent = parents.get(parentName) ?? { namespace, name: parentName };
+    const identity = text(row, "identity");
+    const generated = text(row, "generated") === "s";
+    const expression = text(row, "expression");
+    const collation = text(row, "collation");
+    const sequenceName = text(row, "sequence");
+    const dataType = text(row, "type");
+    const extra = [];
+    const extensionName = text(row, "extension");
+    if (extensionName.length > 0)
+      extra.push({ kind: "extension", name: extensionName });
+    const owned = sequenceIdentity.get(sequenceName);
+    if (owned !== undefined)
+      extra.push(owned);
+    if (enumLabels.has(dataType) || domainNames.has(dataType)) {
+      extra.push({ kind: "type", namespace, name: dataType });
+    }
+    const built = column2({
+      parent,
+      name: text(row, "name"),
+      dataType,
+      nullable: !flag(row, "not_null"),
+      provenance,
+      ...extra.length > 0 ? { dependencies: extra } : {},
+      ...identity === "a" || identity === "d" ? { identity: { always: identity === "a" } } : {},
+      ...generated ? { generated: { stored: true, expression } } : {},
+      ...!generated && identity !== "a" && identity !== "d" && expression.length > 0 ? { defaultExpression: expression } : {},
+      ...collation.length > 0 ? { collation } : {}
+    });
+    objects.push(built);
+  }
+  for (const row of constraints) {
+    const parentName = text(row, "parent");
+    const parent = parents.get(parentName) ?? { namespace, name: parentName };
+    const kind = constraintKind(text(row, "contype"));
+    const columns = list(text(row, "columns"));
+    const name = text(row, "name");
+    const expression = kind === "check" ? checkExpression(text(row, "definition")) : "";
+    const refTable = text(row, "ref_table");
+    const refColumns = list(text(row, "ref_columns"));
+    const definition = text(row, "definition");
+    const onDelete = actionAfter(definition, "delete");
+    const onUpdate = actionAfter(definition, "update");
+    objects.push(constraint2({
+      parent,
+      constraintKind: kind,
+      name,
+      nameKey: constraintNameKey(kind, parentName, name, columns),
+      columns,
+      provenance,
+      deferrable: flag(row, "deferrable"),
+      initially: flag(row, "deferred") ? "deferred" : "immediate",
+      nullsNotDistinct: /nulls not distinct/i.test(definition),
+      ...expression.length > 0 ? { expression } : {},
+      ...refTable.length > 0 ? {
+        references: {
+          parent: { namespace, name: refTable },
+          columns: refColumns,
+          ...onDelete !== undefined ? { onDelete } : {},
+          ...onUpdate !== undefined ? { onUpdate } : {}
+        }
+      } : {}
+    }));
+  }
+  const matviewNames = new Set(views.filter((row) => text(row, "kind") === "m").map((row) => text(row, "name")));
+  for (const row of indexes) {
+    const parentName = text(row, "parent");
+    const parent = parents.get(parentName) ?? { namespace, name: parentName };
+    if (matviewNames.has(parentName)) {
+      const columns = list(text(row, "columns"));
+      const predicate = text(row, "predicate");
+      const expression = indexExpression(row, columns);
+      objects.push(materializedViewIndex({
+        parent,
+        name: text(row, "name"),
+        columns,
+        unique: flag(row, "is_unique"),
+        provenance,
+        ...expression.length > 0 ? { expression } : {},
+        ...predicate.length > 0 ? { predicate } : {}
+      }));
+      continue;
+    }
+    const columns = list(text(row, "columns"));
+    const predicate = text(row, "predicate");
+    const expression = indexExpression(row, columns);
+    objects.push(index3({
+      parent,
+      name: text(row, "name"),
+      nameKey: columns.length > 0 ? columns.join("_") : "expr",
+      columns,
+      unique: flag(row, "is_unique"),
+      provenance,
+      ...expression.length > 0 ? { expression } : {},
+      ...predicate.length > 0 ? { predicate } : {}
+    }));
+  }
+  for (const row of extensions) {
+    const name = text(row, "name");
+    const version = text(row, "version");
+    objects.push(extensionObject({
+      name,
+      schema: text(row, "schema"),
+      relocatable: flag(row, "relocatable"),
+      ...version.length > 0 ? { version } : {},
+      provenance: { origin: "extension", name }
+    }));
+  }
+  const atomicEdges = new Map;
+  for (const row of functionDeps) {
+    const key = `${text(row, "name")}(${text(row, "arg_types")})`;
+    const edges = atomicEdges.get(key) ?? [];
+    const tableName = text(row, "table");
+    const columnName = text(row, "column");
+    if (columnName.length > 0) {
+      edges.push({
+        kind: "column",
+        parent: { namespace, name: tableName },
+        name: columnName
+      });
+    } else if (tableName.length > 0) {
+      edges.push({ kind: "table", namespace, name: tableName });
+    }
+    atomicEdges.set(key, edges);
+  }
+  for (const row of functions) {
+    const name = text(row, "name");
+    const language = text(row, "language") === "sql" ? "sql" : "plpgsql";
+    const argTypes = splitTypes(text(row, "arg_types"));
+    const source = text(row, "body");
+    const atomic = language === "sql" && source.length === 0;
+    const body = atomic ? atomicBody(text(row, "definition")) : source;
+    const searchPath = searchPathOf(text(row, "config"));
+    const key = `${name}(${text(row, "arg_types")})`;
+    objects.push(functionObject({
+      namespace,
+      name,
+      arguments: argumentList(row.arg_names, argTypes),
+      returns: text(row, "returns"),
+      language,
+      volatility: volatilityOf(text(row, "volatility")),
+      security: flag(row, "security") ? "definer" : "invoker",
+      body,
+      ...searchPath !== undefined ? { searchPath } : {},
+      ...atomic ? { atomic: true } : {},
+      provenance,
+      ...atomic ? { dependencies: atomicEdges.get(key) ?? [] } : {}
+    }));
+  }
+  for (const row of triggers) {
+    const bits = Number(text(row, "tgtype"));
+    const updateOf = list(text(row, "update_of"));
+    const when = text(row, "predicate");
+    const argTypes = splitTypes(text(row, "arg_types"));
+    objects.push(triggerObject({
+      parent: { namespace, name: text(row, "parent") },
+      name: text(row, "name"),
+      timing: triggerTiming(bits),
+      events: triggerEvents(bits),
+      level: (bits & 1) === 1 ? "row" : "statement",
+      calls: {
+        namespace: staticNamespace2(text(row, "function_schema")),
+        name: text(row, "function"),
+        argTypes
+      },
+      ...updateOf.length > 0 ? { updateOf } : {},
+      ...when.length > 0 ? { when } : {},
+      provenance
+    }));
+  }
+  for (const row of views) {
+    const kind = text(row, "kind") === "m" ? "materializedView" : "view";
+    const columns = printedColumns(text(row, "columns"));
+    const query = normaliseViewQuery(text(row, "query"));
+    const name = text(row, "name");
+    if (kind === "materializedView") {
+      objects.push(materializedViewObject({ namespace, name, columns, query, provenance }));
+    } else {
+      objects.push(viewObject({ namespace, name, columns, query, provenance }));
+    }
+  }
+  const viewEdges = viewDependencyEdges(viewDeps, namespace, objects);
+  for (let index = 0;index < objects.length; index += 1) {
+    const object = objects[index];
+    if (object === undefined)
+      continue;
+    if (object.kind !== "view" && object.kind !== "materializedView")
+      continue;
+    const dependencies = viewEdges.get(object.identity.name);
+    if (dependencies === undefined || dependencies.length === 0)
+      continue;
+    objects[index] = object.kind === "view" ? viewObject({
+      namespace,
+      name: object.identity.name,
+      columns: object.definition.columns,
+      query: object.definition.query,
+      provenance,
+      dependencies
+    }) : materializedViewObject({
+      namespace,
+      name: object.identity.name,
+      columns: object.definition.columns,
+      query: object.definition.query,
+      provenance,
+      dependencies
+    });
+  }
+  if (options?.managedRoles !== undefined) {
+    objects.push(...await readPrivileges(runner, concrete, namespace, provenance, objects, options.managedRoles));
+  }
+  return catalog(objects);
+}
+var EMITTED = new Set(["SELECT", "INSERT", "UPDATE", "DELETE", "EXECUTE", "USAGE"]);
+var ROLES = `select rolname, rolcanlogin, rolinherit from pg_roles where rolname !~ '^pg_'`;
+var RELATION_GRANTS = `select c.relname as name,
+  case c.relkind when 'v' then 'view' when 'm' then 'materializedView' when 'S' then 'sequence' else 'table' end as kind,
+  r.rolname as role, a.privilege_type as privilege
+  from pg_class c
+  join pg_namespace n on n.oid = c.relnamespace
+  cross join lateral aclexplode(c.relacl) as a
+  join pg_roles r on r.oid = a.grantee
+  where n.nspname = $1
+    and c.relkind in ('r', 'p', 'v', 'm', 'S')
+    and c.relacl is not null
+    and a.grantee <> 0
+    and a.grantee <> c.relowner
+    and not exists (select 1 from pg_inherits i where i.inhrelid = c.oid)
+    and not exists (
+      select 1 from pg_depend d
+      where d.classid = 'pg_class'::regclass and d.objid = c.oid and d.deptype = 'e'
+    )`;
+var FUNCTION_GRANTS = `select p.proname as name,
+  replace(pg_get_function_identity_arguments(p.oid), ' ', '') as args,
+  r.rolname as role, a.privilege_type as privilege
+  from pg_proc p
+  join pg_namespace n on n.oid = p.pronamespace
+  cross join lateral aclexplode(p.proacl) as a
+  join pg_roles r on r.oid = a.grantee
+  where n.nspname = $1
+    and p.proacl is not null
+    and a.grantee <> 0
+    and a.grantee <> p.proowner
+    and not exists (
+      select 1 from pg_depend d
+      where d.classid = 'pg_proc'::regclass and d.objid = p.oid and d.deptype = 'e'
+    )`;
+var DEFAULT_PRIVILEGES = `select owner_role.rolname as for_role, grantee.rolname as grantee,
+  case d.defaclobjtype when 'S' then 'sequence' when 'f' then 'function' else 'table' end as object_kind,
+  a.privilege_type as privilege
+  from pg_default_acl d
+  join pg_namespace n on n.oid = d.defaclnamespace
+  join pg_roles owner_role on owner_role.oid = d.defaclrole
+  cross join lateral aclexplode(d.defaclacl) as a
+  join pg_roles grantee on grantee.oid = a.grantee
+  where n.nspname = $1
+    and d.defaclobjtype in ('r', 'S', 'f')
+    and a.grantee <> 0`;
+async function readPrivileges(runner, concrete, namespace, provenance, built, managedRoles) {
+  const managed = new Set(managedRoles);
+  const [roles, relations, functions, defaults] = await Promise.all([
+    runner.query(ROLES, []),
+    runner.query(RELATION_GRANTS, [concrete]),
+    runner.query(FUNCTION_GRANTS, [concrete]),
+    runner.query(DEFAULT_PRIVILEGES, [concrete])
+  ]);
+  const objects = [];
+  for (const row of roles) {
+    const name = text(row, "rolname");
+    objects.push(roleObject({
+      name,
+      login: flag(row, "rolcanlogin"),
+      inherit: flag(row, "rolinherit"),
+      owner: managed.has(name) ? "managed" : "external",
+      provenance
+    }));
+  }
+  for (const row of relations) {
+    const kind = grantKind(text(row, "kind"));
+    const name = text(row, "name");
+    const privilege = text(row, "privilege").toUpperCase();
+    const target = built.find((object) => privilegeTarget(object) === `${kind}:${name}`);
+    if (!EMITTED.has(privilege) || target === undefined)
+      continue;
+    objects.push(grantObject({
+      role: text(row, "role"),
+      object: { kind, namespace, name },
+      privilege,
+      provenance,
+      dependencies: [{ kind: "role", name: text(row, "role") }, target.identity]
+    }));
+  }
+  for (const row of functions) {
+    const privilege = text(row, "privilege").toUpperCase();
+    const name = `${text(row, "name")}(${text(row, "args")})`;
+    const target = built.find((object) => privilegeTarget(object) === `function:${name}`);
+    if (!EMITTED.has(privilege) || target === undefined)
+      continue;
+    objects.push(grantObject({
+      role: text(row, "role"),
+      object: { kind: "function", namespace, name },
+      privilege,
+      provenance,
+      dependencies: [{ kind: "role", name: text(row, "role") }, target.identity]
+    }));
+  }
+  for (const row of defaults) {
+    const privilege = text(row, "privilege").toUpperCase();
+    if (!EMITTED.has(privilege))
+      continue;
+    const forRole = text(row, "for_role");
+    const grantee = text(row, "grantee");
+    objects.push(defaultPrivilegeObject({
+      forRole,
+      namespace,
+      objectKind: text(row, "object_kind"),
+      grantee,
+      privilege,
+      provenance,
+      dependencies: [
+        { kind: "role", name: forRole },
+        { kind: "role", name: grantee }
+      ]
+    }));
+  }
+  return objects;
+}
+function privilegeTarget(object) {
+  if (object.kind === "table" || object.kind === "view" || object.kind === "materializedView" || object.kind === "sequence") {
+    return `${object.kind}:${object.identity.name}`;
+  }
+  if (object.kind === "function") {
+    return `function:${object.identity.name}(${object.identity.argTypes.join(",")})`;
+  }
+  return "";
+}
+function grantKind(kind) {
+  if (kind === "view" || kind === "materializedView" || kind === "sequence")
+    return kind;
+  return "table";
+}
+function printedColumns(value) {
+  if (value.length === 0)
+    return [];
+  return value.split(`
+`).map((line) => {
+    const splitAt = line.indexOf("|");
+    return {
+      name: splitAt < 0 ? line : line.slice(0, splitAt),
+      dataType: splitAt < 0 ? "text" : line.slice(splitAt + 1)
+    };
+  });
+}
+function argumentList(names, types) {
+  const stored = Array.isArray(names) ? names.map((item) => String(item)) : typeof names === "string" && names.startsWith("{") ? names.slice(1, -1).split(",").filter((item) => item.length > 0) : [];
+  return types.map((type, index) => ({ name: stored[index] || `arg${String(index + 1)}`, type }));
+}
+function splitTypes(value) {
+  return value.length === 0 ? [] : value.split("|");
+}
+function volatilityOf(value) {
+  if (value === "s")
+    return "stable";
+  if (value === "i")
+    return "immutable";
+  return "volatile";
+}
+function searchPathOf(config) {
+  const match = /search_path=([^,}]+)/.exec(config);
+  const found = match?.[1]?.replaceAll('"', "");
+  return found === undefined || found.length === 0 ? undefined : found;
+}
+function atomicBody(definition) {
+  const start = definition.indexOf("BEGIN ATOMIC");
+  if (start < 0)
+    return definition.trim();
+  const end = definition.lastIndexOf("END");
+  return definition.slice(start, end < start ? undefined : end + 3).trim();
+}
+function triggerTiming(bits) {
+  if ((bits & 64) !== 0)
+    return "instead";
+  if ((bits & 2) !== 0)
+    return "before";
+  return "after";
+}
+function triggerEvents(bits) {
+  const events = [];
+  if ((bits & 4) !== 0)
+    events.push("insert");
+  if ((bits & 16) !== 0)
+    events.push("update");
+  if ((bits & 8) !== 0)
+    events.push("delete");
+  if ((bits & 32) !== 0)
+    events.push("truncate");
+  return events;
+}
+function indexExpression(row, columns) {
+  const method = text(row, "am");
+  const stored = text(row, "expression");
+  if (method.length === 0 || method === "btree")
+    return stored;
+  const opclasses = list(text(row, "opc"));
+  const body = columns.map((name, index) => {
+    const opclass = opclasses[index];
+    return opclass === undefined ? quoteIdent(name) : `${quoteIdent(name)} ${opclass}`;
+  }).join(", ");
+  return `using ${method} (${body.length > 0 ? body : stored})`;
+}
+var CHILD = "not exists (select 1 from pg_inherits i where i.inhrelid = c.oid)";
+var TABLES = `
+  select c.relname as name, pt.partstrat as partstrat,
+    (
+      select coalesce(string_agg(a.attname, ',' order by cols.ord), '')
+      from unnest(pt.partattrs) with ordinality as cols(attnum, ord)
+      join pg_attribute a on a.attrelid = c.oid and a.attnum = cols.attnum
+    ) as partcols
+  from pg_class c
+  join pg_namespace n on n.oid = c.relnamespace
+  left join pg_partitioned_table pt on pt.partrelid = c.oid
+  where n.nspname = $1
+    and c.relkind in ('r', 'p')
+    and ${CHILD}
+    and ${member("c.oid", "pg_class")}
+`;
+var COLUMNS = `
+  select c.relname as parent, a.attname as name,
+    case
+      when ty.typtype = 'e' and ty.typnamespace = n.oid then ty.typname
+      else format_type(a.atttypid, a.atttypmod)
+    end as type,
+    a.attnotnull as not_null, a.attidentity as identity, a.attgenerated as generated,
+    case
+      when a.attcollation = 0 or a.attcollation = ty.typcollation then ''
+      else coalesce((select col.collname from pg_collation col where col.oid = a.attcollation), '')
+    end as collation,
+    pg_get_expr(ad.adbin, ad.adrelid) as expression,
+    (
+      select ext.extname
+      from pg_depend member
+      join pg_extension ext on ext.oid = member.refobjid
+      where member.objid = ty.oid and member.deptype = 'e' and member.classid = 'pg_type'::regclass
+      limit 1
+    ) as extension,
+    (
+      select owned.relname
+      from pg_depend d
+      join pg_class owned on owned.oid = d.objid and owned.relkind = 'S'
+      where d.refobjid = c.oid and d.refobjsubid = a.attnum and d.deptype = 'a'
+        and d.classid = 'pg_class'::regclass
+      limit 1
+    ) as sequence
+  from pg_class c
+  join pg_namespace n on n.oid = c.relnamespace
+  join pg_attribute a on a.attrelid = c.oid and a.attnum > 0 and not a.attisdropped
+  join pg_type ty on ty.oid = a.atttypid
+  left join pg_attrdef ad on ad.adrelid = a.attrelid and ad.adnum = a.attnum
+  where n.nspname = $1
+    and c.relkind in ('r', 'p')
+    and ${CHILD}
+    and ${member("c.oid", "pg_class")}
+`;
+var CONSTRAINTS = `
+  select rel.relname as parent, con.conname as name, con.contype as contype,
+    con.condeferrable as deferrable, con.condeferred as deferred,
+    pg_get_constraintdef(con.oid) as definition,
+    (
+      select coalesce(string_agg(a.attname, ',' order by cols.ord), '')
+      from unnest(con.conkey) with ordinality as cols(attnum, ord)
+      join pg_attribute a on a.attrelid = con.conrelid and a.attnum = cols.attnum
+    ) as columns,
+    ref.relname as ref_table,
+    (
+      select coalesce(string_agg(a.attname, ',' order by cols.ord), '')
+      from unnest(con.confkey) with ordinality as cols(attnum, ord)
+      join pg_attribute a on a.attrelid = con.confrelid and a.attnum = cols.attnum
+    ) as ref_columns
+  from pg_constraint con
+  join pg_class rel on rel.oid = con.conrelid
+  join pg_namespace n on n.oid = rel.relnamespace
+  left join pg_class ref on ref.oid = con.confrelid
+  where n.nspname = $1
+    and con.contype in ('p', 'u', 'f', 'c')
+    and not exists (select 1 from pg_inherits i where i.inhrelid = rel.oid)
+`;
+var INDEXES = `
+  select tbl.relname as parent, idx.relname as name, i.indisunique as is_unique,
+    (
+      select coalesce(string_agg(a.attname, ',' order by cols.ord), '')
+      from unnest(i.indkey) with ordinality as cols(attnum, ord)
+      join pg_attribute a on a.attrelid = tbl.oid and a.attnum = cols.attnum
+      where cols.attnum > 0
+    ) as columns,
+    pg_get_expr(i.indexprs, i.indrelid) as expression,
+    pg_get_expr(i.indpred, i.indrelid) as predicate,
+    am.amname as am,
+    (
+      select coalesce(string_agg(opc.opcname, ',' order by cols.ord), '')
+      from unnest(i.indclass) with ordinality as cols(opcoid, ord)
+      join pg_opclass opc on opc.oid = cols.opcoid
+    ) as opc
+  from pg_index i
+  join pg_class idx on idx.oid = i.indexrelid
+  join pg_class tbl on tbl.oid = i.indrelid
+  join pg_namespace n on n.oid = tbl.relnamespace
+  join pg_am am on am.oid = idx.relam
+  where n.nspname = $1
+    and not i.indisprimary
+    and not exists (select 1 from pg_constraint con where con.conindid = i.indexrelid)
+    and not exists (select 1 from pg_inherits inh where inh.inhrelid = tbl.oid)
+    and not exists (select 1 from pg_inherits inh where inh.inhrelid = idx.oid)
+    and ${member("idx.oid", "pg_class")}
+`;
+var DOMAINS = `
+  select t.typname as name,
+    format_type(t.typbasetype, t.typtypmod) as base,
+    coalesce(pg_get_constraintdef(c.oid), '') as definition
+  from pg_type t
+  join pg_namespace n on n.oid = t.typnamespace
+  left join pg_constraint c on c.contypid = t.oid
+  where n.nspname = $1
+    and t.typtype = 'd'
+    and ${member("t.oid", "pg_type")}
+  order by t.typname, c.conname
+`;
+var ENUMS = `
+  select t.typname as name, e.enumlabel as label
+  from pg_type t
+  join pg_namespace n on n.oid = t.typnamespace
+  join pg_enum e on e.enumtypid = t.oid
+  where n.nspname = $1
+    and t.typtype = 'e'
+    and ${member("t.oid", "pg_type")}
+  order by t.typname, e.enumsortorder
+`;
+var EXTENSIONS = `
+  select e.extname as name, n.nspname as schema, e.extrelocatable as relocatable,
+    e.extversion as version
+  from pg_extension e
+  join pg_namespace n on n.oid = e.extnamespace
+  where n.nspname = $1
+`;
+var FUNCTIONS = `
+  select p.proname as name, l.lanname as language, p.provolatile as volatility,
+    p.prosecdef as security, coalesce(p.proconfig::text, '') as config, p.prosrc as body,
+    pg_get_function_result(p.oid) as returns, p.proargnames as arg_names,
+    (
+      select coalesce(string_agg(format_type(t.oid, null), '|' order by t.ord), '')
+      from unnest(p.proargtypes) with ordinality as t(oid, ord)
+    ) as arg_types,
+    pg_get_functiondef(p.oid) as definition
+  from pg_proc p
+  join pg_namespace n on n.oid = p.pronamespace
+  join pg_language l on l.oid = p.prolang
+  where n.nspname = $1
+    and p.prokind = 'f'
+    and ${member("p.oid", "pg_proc")}
+`;
+var TRIGGERS = `
+  select t.tgname as name, c.relname as parent, t.tgtype::text as tgtype,
+    p.proname as function, fns.nspname as function_schema,
+    (
+      select coalesce(string_agg(format_type(x.oid, null), '|' order by x.ord), '')
+      from unnest(p.proargtypes) with ordinality as x(oid, ord)
+    ) as arg_types,
+    coalesce(pg_get_expr(t.tgqual, t.tgrelid), '') as predicate,
+    (
+      select coalesce(string_agg(a.attname, ',' order by cols.ord), '')
+      from unnest(t.tgattr) with ordinality as cols(attnum, ord)
+      join pg_attribute a on a.attrelid = t.tgrelid and a.attnum = cols.attnum
+    ) as update_of
+  from pg_trigger t
+  join pg_class c on c.oid = t.tgrelid
+  join pg_namespace n on n.oid = c.relnamespace
+  join pg_proc p on p.oid = t.tgfoid
+  join pg_namespace fns on fns.oid = p.pronamespace
+  where n.nspname = $1
+    and not t.tgisinternal
+    and ${CHILD}
+`;
+var VIEWS = `
+  select c.relname as name, c.relkind as kind, pg_get_viewdef(c.oid, true) as query,
+    (
+      select coalesce(string_agg(
+        a.attname || '|' || format_type(a.atttypid, a.atttypmod),
+        E'\\n' order by a.attnum
+      ), '')
+      from pg_attribute a
+      where a.attrelid = c.oid and a.attnum > 0 and not a.attisdropped
+    ) as columns
+  from pg_class c
+  join pg_namespace n on n.oid = c.relnamespace
+  where n.nspname = $1
+    and c.relkind in ('v', 'm')
+    and ${CHILD}
+    and ${member("c.oid", "pg_class")}
+`;
+var FUNCTION_DEPS = `
+  select p.proname as name,
+    (
+      select coalesce(string_agg(format_type(t.oid, null), '|' order by t.ord), '')
+      from unnest(p.proargtypes) with ordinality as t(oid, ord)
+    ) as arg_types,
+    c.relname as table, coalesce(a.attname, '') as column
+  from pg_depend d
+  join pg_proc p on p.oid = d.objid and d.classid = 'pg_proc'::regclass
+  join pg_namespace n on n.oid = p.pronamespace
+  join pg_class c on c.oid = d.refobjid and d.refclassid = 'pg_class'::regclass
+  left join pg_attribute a on a.attrelid = c.oid and a.attnum = d.refobjsubid and d.refobjsubid > 0
+  where n.nspname = $1
+    and d.deptype = 'n'
+    and c.relkind in ('r', 'p')
+    and p.prokind = 'f'
+    and p.prosrc = ''
+`;
+function member(oid, classid) {
+  return `not exists (
+    select 1 from pg_depend member
+    where member.objid = ${oid} and member.deptype = 'e' and member.classid = '${classid}'::regclass
+  )`;
+}
+var SEQUENCES = `
+  select c.relname as name, format_type(s.seqtypid, null) as type,
+    s.seqstart::text as start, s.seqincrement::text as increment, s.seqcycle as cycle,
+    (
+      select owned.relname
+      from pg_depend d
+      join pg_class owned on owned.oid = d.refobjid and owned.relkind in ('r', 'p')
+      where d.objid = c.oid and d.deptype = 'a'
+      limit 1
+    ) as owned_table
+  from pg_sequence s
+  join pg_class c on c.oid = s.seqrelid
+  join pg_namespace n on n.oid = c.relnamespace
+  where n.nspname = $1
+    and ${member("c.oid", "pg_class")}
+`;
+function partitionMethod(value) {
+  if (value === "r")
+    return "range";
+  if (value === "l")
+    return "list";
+  if (value === "h")
+    return "hash";
+  return;
+}
+function constraintNameKey(kind, parent, name, columns) {
+  if (kind === "primaryKey")
+    return "pkey";
+  const tag = kind === "unique" ? "key" : kind === "foreignKey" ? "fkey" : "check";
+  const prefix = `${parent}_`;
+  const suffix = `_${tag}`;
+  if (name.startsWith(prefix) && name.endsWith(suffix) && name.length > prefix.length + suffix.length) {
+    return name.slice(prefix.length, -suffix.length);
+  }
+  if (columns.length > 0)
+    return columns.join("_");
+  return tag;
+}
+function constraintKind(value) {
+  if (value === "p")
+    return "primaryKey";
+  if (value === "u")
+    return "unique";
+  if (value === "f")
+    return "foreignKey";
+  return "check";
+}
+function sequenceType(value) {
+  if (value === "smallint")
+    return "smallint";
+  if (value === "integer")
+    return "integer";
+  return "bigint";
+}
+function checkExpression(definition) {
+  return definition.trim().replace(/^check\s+/i, "");
+}
+function actionAfter(definition, event) {
+  const match = new RegExp(`on ${event} ([a-z ]+)`, "i").exec(definition);
+  const words = match?.[1]?.trim().toLowerCase() ?? "";
+  if (words.length === 0 || words === "no action")
+    return;
+  return referentialAction(words);
+}
+function list(value) {
+  if (value.length === 0)
+    return [];
+  return value.split(",");
+}
+function text(row, key) {
+  const value = row[key];
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  return "";
+}
+function numberText(row, key) {
+  const value = text(row, key);
+  return value.length === 0 ? "1" : value;
+}
+function flag(row, key) {
+  const value = row[key];
+  return value === true || value === "true" || value === "t";
+}
+
+// src/dialects/pg/view/scratch.ts
+var SCRATCH = "okm_view_seal";
+var VIEW_SHAPE = `
+  select c.relname as name, c.relkind as kind, pg_get_viewdef(c.oid, true) as query,
+    (
+      select coalesce(string_agg(
+        a.attname || '|' || format_type(a.atttypid, a.atttypmod),
+        E'\\n' order by a.attnum
+      ), '')
+      from pg_attribute a
+      where a.attrelid = c.oid and a.attnum > 0 and not a.attisdropped
+    ) as columns
+  from pg_class c
+  join pg_namespace n on n.oid = c.relnamespace
+  where n.nspname = $1 and c.relkind in ('v', 'm')
+`;
+async function sealViews(runner, source) {
+  const views = source.objects.filter((object) => object.kind === "view" || object.kind === "materializedView");
+  if (views.length === 0)
+    return source;
+  await dropScratch(runner);
+  await runner.query(`create schema ${quoteIdent(SCRATCH)}`);
+  try {
+    await runner.query(`set search_path to ${quoteIdent(SCRATCH)}`);
+    for (const object of source.objects) {
+      if (object.kind !== "type")
+        continue;
+      const statement = createObjectSql(object, SCRATCH);
+      if (statement !== undefined)
+        await runner.query(statement);
+    }
+    for (const object of source.objects) {
+      if (object.kind !== "table")
+        continue;
+      await runner.query(stubTable(object, source));
+    }
+    await createViews(runner, views);
+    const shapes = await runner.query(VIEW_SHAPE, [SCRATCH]);
+    const deps = await runner.query(VIEW_DEPENDENCIES, [SCRATCH]);
+    const edges = viewDependencyEdges(deps, PUBLIC, source.objects);
+    const byName = new Map(shapes.map((row) => [cellText(row.name), row]));
+    const next = source.objects.map((object) => {
+      if (object.kind !== "view" && object.kind !== "materializedView")
+        return object;
+      const row = byName.get(object.identity.name);
+      if (row === undefined) {
+        throw new OkmError2("OKM1020", `View ${object.identity.name} was not created in the scratch schema.`, {
+          fix: { summary: "The query has to run against the tables in this schema." }
+        });
+      }
+      const columns = readColumns(object, cellText(row.columns));
+      const query = normaliseViewQuery(cellText(row.query));
+      const dependencies = edges.get(object.identity.name) ?? [];
+      if (object.kind === "view") {
+        return viewObject({
+          namespace: object.identity.namespace,
+          name: object.identity.name,
+          columns,
+          query,
+          owner: object.owner,
+          provenance: object.provenance,
+          dependencies
+        });
+      }
+      return materializedViewObject({
+        namespace: object.identity.namespace,
+        name: object.identity.name,
+        columns,
+        query,
+        owner: object.owner,
+        provenance: object.provenance,
+        dependencies,
+        ...object.definition.refresh !== undefined ? { refresh: object.definition.refresh } : {}
+      });
+    });
+    return catalog(next);
+  } finally {
+    await runner.query("set search_path to public");
+    await dropScratch(runner);
+  }
+}
+async function createViews(runner, views) {
+  const pending = [...views];
+  let last = "";
+  for (let pass = 0;pass < views.length && pending.length > 0; pass += 1) {
+    const failed = [];
+    let created = 0;
+    for (const object of pending) {
+      const sql = object.kind === "materializedView" ? `create materialized view ${quoteIdent(object.identity.name)} as ${object.definition.query} with no data` : `create view ${quoteIdent(object.identity.name)} as ${object.definition.query}`;
+      try {
+        await runner.query(sql);
+        created += 1;
+      } catch (error) {
+        last = error instanceof Error ? error.message : String(error);
+        failed.push(object);
+      }
+    }
+    if (created === 0) {
+      throw new OkmError2("OKM1020", `View ${failed[0]?.identity.name ?? ""} could not be created. ${last}`, {
+        fix: { summary: "The query has to run against the tables in this schema." }
+      });
+    }
+    pending.length = 0;
+    pending.push(...failed);
+  }
+}
+function stubTable(object, source) {
+  const columns = source.objects.filter((item) => item.kind === "column" && item.identity.parent.name === object.identity.name);
+  const lines = columns.map((column) => `${quoteIdent(column.identity.name)} ${column.definition.dataType}`);
+  return `create table ${quoteIdent(object.identity.name)} (${lines.join(", ")})`;
+}
+function readColumns(object, printed) {
+  const live = printed.length === 0 ? [] : printed.split(`
+`);
+  const declared = object.definition.columns;
+  if (live.length !== declared.length) {
+    throw mismatch(object.identity.name, declared.map((column) => column.name).join(", "), printed);
+  }
+  return declared.map((column, index) => {
+    const line = live[index] ?? "";
+    const splitAt = line.indexOf("|");
+    const name = splitAt < 0 ? line : line.slice(0, splitAt);
+    const type = splitAt < 0 ? "" : line.slice(splitAt + 1);
+    if (name !== column.name || type !== column.dataType) {
+      throw mismatch(object.identity.name, `${column.name}:${column.dataType}`, live[index] ?? "");
+    }
+    return column;
+  });
+}
+function mismatch(view, declared, live) {
+  return new OkmError2("OKM1020", `View ${view} declares ${declared} and the database has ${live}.`, { fix: { summary: "Declare the columns the query returns, in that order, with those types." } });
+}
+async function dropScratch(runner) {
+  const present = await runner.query(`select 1 as ok from pg_namespace where nspname = $1`, [
+    SCRATCH
+  ]);
+  if (present.length === 0)
+    return;
+  const rows = await runner.query(`
+    select c.relname as name, c.relkind as kind
+    from pg_class c
+    join pg_namespace n on n.oid = c.relnamespace
+    where n.nspname = $1 and c.relkind in ('v', 'm', 'r')
+  `, [SCRATCH]);
+  const views = rows.filter((row) => cellText(row.kind) === "v" || cellText(row.kind) === "m");
+  for (let pass = 0;pass < Math.max(views.length, 1); pass += 1) {
+    for (const row of views) {
+      const kind = cellText(row.kind) === "m" ? "materialized view" : "view";
+      try {
+        await runner.query(`drop ${kind} if exists ${quoteIdent(SCRATCH)}.${quoteIdent(cellText(row.name))}`);
+      } catch {}
+    }
+  }
+  for (const row of rows) {
+    if (cellText(row.kind) !== "r")
+      continue;
+    await runner.query(`drop table if exists ${quoteIdent(SCRATCH)}.${quoteIdent(cellText(row.name))}`);
+  }
+  await runner.query(`drop schema if exists ${quoteIdent(SCRATCH)} cascade`);
+}
+
+// src/tooling/migrate/drift.ts
+async function assertAuthorDrift2(url, author, roles) {
+  const sql = postgres(url, {
+    max: 1,
+    connect_timeout: 5,
+    idle_timeout: 1,
+    onnotice: () => {}
+  });
+  try {
+    const present = await sql`
+      select to_regclass('public.okm_meta')::text as reg
+    `;
+    if (present[0]?.reg == null)
+      return;
+    const runner = catalogQuery2(sql);
+    const authorOnServer = await sealViews(runner, author);
+    const live = await introspectSchema(runner, "public", "public", managedRoleOptions2(roles));
+    const plan = planMigration({ before: live, after: authorOnServer, name: "check" });
+    if (plan.steps.length === 0)
+      return;
+    throw new OkmError2("OKM1520", `The database differs from the schema.
+${plan.steps.map((step) => step.sql).join(`
+`)}`, {
+      fix: {
+        summary: "Change the schema or the database so okm check reports no difference."
+      }
+    });
+  } finally {
+    await sql.end({ timeout: 5 });
+  }
+}
+function catalogQuery2(sql) {
+  return {
+    async query(text, params) {
+      const rows = await sql.unsafe(text, params === undefined ? undefined : [...params]);
+      return rows.map((row) => {
+        const copy = {};
+        for (const [key, value] of Object.entries(row))
+          copy[key] = value;
+        return copy;
+      });
+    }
+  };
+}
+function managedRoleOptions2(roles) {
+  const names = managedRoleNames(roles);
+  return names === undefined ? undefined : { managedRoles: names };
+}
+function managedRoleNames(roles) {
+  if (roles === undefined)
+    return;
+  const names = new Set([roles.migration, roles.app]);
+  for (const role of roles.managed ?? [])
+    names.add(role.name);
+  return [...names];
+}
+
+export { introspectSchema, sealViews, assertAuthorDrift2, catalogQuery2, managedRoleOptions2 };