okmodel 0.3.0 → 0.4.0

package/dist/shared/{ne02ng5c.js → 84ptn35q.js}

@@ -1,19 +1,21 @@
 import {
   open2
-} from "./xw1d69vd.js";
+} from "./wqem4jed.js";
 import"./n442h54c.js";
-import"./t616ynfn.js";
+import"./8jb4ymh2.js";
 import {
   assertRoleHealth
 } from "./hcmdtwgh.js";
 import {
   errorDoc,
+  assertTargetPolicy,
   selectTarget,
   openProject
-} from "./5nmdenb6.js";
+} from "./q6zsyh31.js";
 import {
   omitManagedObjects
-} from "./2ssqrv66.js";
+} from "./n5y9zyj1.js";
+import"./41kv2xdm.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -36,6 +38,7 @@ ${doc.fix}
   const objects = omitManagedObjects(opened.built.catalog).objects;
   if (opened.config.roles !== undefined) {
     const target = selectTarget(opened.config, flags?.target);
+    assertTargetPolicy(target, "check", flags?.allowProtected ?? false);
     const pool = open2({ url: target.url, max: 1 });
     try {
       await assertRoleHealth(pool, opened.config.roles, objects);

package/dist/shared/{t616ynfn.js → 8jb4ymh2.js}

@@ -9,16 +9,14 @@ import {
 } from "./y005b761.js";
 import {
   extensionObject
-} from "./th14ygv2.js";
+} from "./8ktwd3rh.js";
 import {
   dependencyOrder,
-  catalog
-} from "./jkc6ws1p.js";
-import {
+  catalog,
   enumType,
   domainType,
   isDomain
-} from "./qbxzvwwc.js";
+} from "./g7ez901n.js";
 import {
   canonicalJson,
   staticNamespace2,
@@ -46,7 +44,8 @@ import {
 } from "./4e4c6vq2.js";
 import {
   sha2562,
-  assertIdentifier2
+  assertIdentifier2,
+  fitIdentifier2
 } from "./nfzc5z0w.js";
 import {
   catalogError2
@@ -201,7 +200,7 @@ function renameTable2(source, change) {
   if (!found) {
     catalogError2("OKM1020", `Table ${change.from} is not in the catalog.`);
   }
-  const next = source.objects.map((object) => rewriteTableName(object, change, fromKey, toIdentity));
+  const next = source.objects.map((object) => rewriteTableName(object, change, fromKey, toIdentity, source));
   return catalog(next);
 }
 var serializedText = new WeakMap;
@@ -473,8 +472,8 @@ function rewriteExpr(text, change, active) {
     return text;
   return replaceIdentifier(text, change.from, change.to);
 }
-function rewriteTableName(object, change, fromKey, toIdentity) {
-  const dependencies = retarget(object.dependencies, fromKey, toIdentity);
+function rewriteTableName(object, change, fromKey, toIdentity, source) {
+  const dependencies = retarget(object.dependencies, fromKey, toIdentity, change);
   const named = object.kind === "table" && object.identity.name === change.from && sameNamespace2(object.identity.namespace, change.namespace);
   if (object.kind === "table") {
     return table3({
@@ -579,9 +578,19 @@ function rewriteTableName(object, change, fromKey, toIdentity) {
     });
     return rewriteView(object, dependencies, rewriteExpr(object.definition.query, { from: change.from, to: change.to }, local));
   }
-  if (object.kind === "role" || object.kind === "grant" || object.kind === "defaultPrivilege") {
+  if (object.kind === "role" || object.kind === "defaultPrivilege") {
     return retargeted(object, dependencies);
   }
+  if (object.kind === "grant") {
+    return grantObject({
+      role: object.identity.role,
+      object: movedGrantRef(object.identity.object, change, source),
+      privilege: object.identity.privilege,
+      owner: object.owner,
+      provenance: object.provenance,
+      dependencies
+    });
+  }
   if (object.kind === "trigger") {
     const parent = movedParent(object.identity.parent, change);
     const local = parent.name !== object.identity.parent.name;
@@ -644,8 +653,46 @@ function rewriteSequence(object, dependencies) {
 function renameList(names, from, to) {
   return names.map((name) => name === from ? to : name);
 }
-function retarget(edges, fromKey, to) {
-  return edges.map((edge) => identityKey2(edge.target) === fromKey ? to : edge.target);
+function retarget(edges, fromKey, to, change) {
+  return edges.map((edge) => {
+    if (identityKey2(edge.target) === fromKey)
+      return to;
+    if (change === undefined)
+      return edge.target;
+    return movedChild(edge.target, change);
+  });
+}
+function movedChild(target, change) {
+  if (!("parent" in target))
+    return target;
+  if (target.parent.name !== change.from || !sameNamespace2(target.parent.namespace, change.namespace)) {
+    return target;
+  }
+  return { ...target, parent: { namespace: target.parent.namespace, name: change.to } };
+}
+function movedGrantRef(object, change, source) {
+  if (object.kind === "table" && object.name === change.from && sameNamespace2(object.namespace, change.namespace)) {
+    return { ...object, name: change.to };
+  }
+  if (object.kind !== "sequence")
+    return object;
+  const next = renamedIdentitySequence(source, change, object.name);
+  if (next === undefined)
+    return object;
+  return { ...object, name: next };
+}
+function renamedIdentitySequence(source, change, sequenceName) {
+  for (const object of source.objects) {
+    if (object.kind !== "column" || object.definition.identity === undefined)
+      continue;
+    if (object.identity.parent.name !== change.from || !sameNamespace2(object.identity.parent.namespace, change.namespace)) {
+      continue;
+    }
+    if (fitIdentifier2(`${change.from}_${object.identity.name}_seq`) !== sequenceName)
+      continue;
+    return fitIdentifier2(`${change.to}_${object.identity.name}_seq`);
+  }
+  return;
 }
 function dependencyJson(edges) {
   const indexed = edges.map((edge) => ({

package/dist/shared/{th14ygv2.js → 8ktwd3rh.js}

@@ -50,11 +50,39 @@ function sameExtensionDefinition(before, after) {
     return false;
   return sameVersion(before.definition.version, after.definition.version);
 }
+function alignExtensionVersions(source, other) {
+  const loose = looseNames(source, other);
+  if (loose.size === 0)
+    return source;
+  let changed = false;
+  const objects = source.objects.map((object) => {
+    if (object.kind !== "extension" || object.definition.version === undefined)
+      return object;
+    if (!loose.has(object.identity.name))
+      return object;
+    changed = true;
+    const { version: _version, ...definition } = object.definition;
+    return { ...object, definition };
+  });
+  return changed ? { version: source.version, objects } : source;
+}
 function sameVersion(before, after) {
   if (!isExactVersion(after) || !isExactVersion(before))
     return true;
   return before === after;
 }
+function looseNames(source, other) {
+  const names = new Set;
+  for (const catalog of [source, other]) {
+    for (const object of catalog.objects) {
+      if (object.kind !== "extension")
+        continue;
+      if (!isExactVersion(object.definition.version))
+        names.add(object.identity.name);
+    }
+  }
+  return names;
+}
 function assertVersion(version) {
   if (version === undefined)
     return;
@@ -66,4 +94,4 @@ function parts(version) {
   return version.split(".").map((part) => Number(part));
 }
 
-export { extensionObject, isExactVersion, compareExtensionVersions, sameExtensionDefinition };
+export { extensionObject, isExactVersion, compareExtensionVersions, sameExtensionDefinition, alignExtensionVersions };

package/dist/shared/9yn6a2vd.js

@@ -0,0 +1,11 @@
+// src/runtime/compat-words.ts
+var CURRENT = "current";
+var BEHIND_EXPAND = "behind by expand";
+var BEHIND_CONTRACT = "behind by contract";
+var AHEAD_EXPAND = "ahead by expand";
+var AHEAD_CONTRACT = "ahead by contract";
+function failedAt(step) {
+  return `failed at step ${String(step)} (resume with okm migrate apply)`;
+}
+
+export { CURRENT, BEHIND_EXPAND, BEHIND_CONTRACT, AHEAD_EXPAND, AHEAD_CONTRACT, failedAt };

package/dist/shared/ady1ms74.js

@@ -0,0 +1,72 @@
+import {
+  open2
+} from "./wqem4jed.js";
+import"./8jb4ymh2.js";
+import {
+  createdOf,
+  testing2
+} from "./ygem90rn.js";
+import"./n442h54c.js";
+import {
+  assertTargetPolicy,
+  assertDirectConnection,
+  selectTarget,
+  loadConfig,
+  loadSchema
+} from "./q6zsyh31.js";
+import"./n5y9zyj1.js";
+import"./41kv2xdm.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/tooling/migrate/seed.ts
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+async function seedProject(cwd, file, flags) {
+  const config = await loadConfig(cwd);
+  const target = selectTarget(config, flags.target);
+  assertTargetPolicy(target, "seed", flags.allowProtected);
+  const path = join(cwd, file);
+  if (!existsSync(path)) {
+    throw new OkmError2("invalid", `Seed file ${file} was not found.`, {
+      fix: { summary: "Pass okm seed <file> a module in this project." }
+    });
+  }
+  assertDirectConnection(target.url, flags.allowPooler || config.allowPooler === true);
+  const schema = await loadSchema(cwd, config.schema);
+  const pool = open2({ url: target.url, max: 1 });
+  const harness = await testing2(schema, { driver: pool, migrate: false });
+  try {
+    const imported = await import(`${pathToFileURL(path).href}?okm=${Date.now()}`);
+    const seed = isRecord(imported) ? imported.default : undefined;
+    if (typeof seed !== "function") {
+      throw new OkmError2("invalid", `${file} must default-export a function.`, {
+        fix: { summary: "export default async function seed(t) { ... }." }
+      });
+    }
+    await seed(harness);
+    return formatCreated(target.name, createdOf(harness));
+  } finally {
+    await harness.close();
+  }
+}
+function formatCreated(target, counts) {
+  const lines = [`target ${target}`];
+  if (counts.length === 0)
+    lines.push("created nothing");
+  else {
+    for (const item of counts)
+      lines.push(`${item.table} ${String(item.count)}`);
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+export {
+  seedProject
+};

package/dist/shared/{scwxrpx2.js → c5g81ngb.js}

@@ -1,17 +1,28 @@
 import {
   open2
-} from "./xw1d69vd.js";
-import"./t616ynfn.js";
+} from "./wqem4jed.js";
+import"./8jb4ymh2.js";
 import"./n442h54c.js";
 import {
-  loadMigrations
-} from "./g4f5kcx9.js";
+  CURRENT,
+  BEHIND_EXPAND,
+  BEHIND_CONTRACT,
+  AHEAD_EXPAND,
+  AHEAD_CONTRACT,
+  failedAt
+} from "./9yn6a2vd.js";
+import {
+  loadMigrations,
+  expandProvisioned,
+  provisionHistoryIsKnown
+} from "./7nk68fj8.js";
 import {
   assertTargetPolicy,
   listTargets,
   loadConfig
-} from "./5nmdenb6.js";
-import"./2ssqrv66.js";
+} from "./q6zsyh31.js";
+import"./n5y9zyj1.js";
+import"./41kv2xdm.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -19,8 +30,8 @@ import {
 // src/tooling/migrate/status.ts
 import { join } from "node:path";
 function describeStatus(migrations, history, recorded) {
-  const done = new Set(history.map((row) => `${row.migrationId}:${String(row.stepIndex)}`));
   const known = new Set(migrations.map((migration) => migration.id));
+  const done = expandProvisioned(migrations, new Set(history.map((row) => `${row.migrationId}:${String(row.stepIndex)}`)), history.map((row) => row.migrationId));
   for (const migration of migrations) {
     let have = 0;
     let missing = -1;
@@ -34,33 +45,33 @@ function describeStatus(migrations, history, recorded) {
       return {
         version: migration.id,
         catalogHash: recorded?.hash ?? "-",
-        state: `failed at step ${String(missing)}`
+        state: failedAt(missing)
       };
     }
   }
-  const extra = history.some((row) => !known.has(row.migrationId));
   const pending = migrations.filter((migration) => migration.steps.some((_, index) => !done.has(`${migration.id}:${String(index)}`)));
   const finished = lastComplete(migrations, done);
   const version = recorded?.version ?? finished ?? "-";
   const catalogHash = recorded?.hash ?? "-";
+  const extra = history.some((row) => !provisionHistoryIsKnown(row.migrationId, known));
   if (extra)
-    return { version, catalogHash, state: "ahead" };
+    return { version, catalogHash, state: aheadState(history, known) };
   if (pending.length > 0) {
     const contract = pending.some((migration) => migration.steps.some((step) => step.class !== "expand"));
     return {
       version,
       catalogHash,
-      state: contract ? "behind by contract" : "behind by expand"
+      state: contract ? BEHIND_CONTRACT : BEHIND_EXPAND
     };
   }
   const last = migrations.at(-1);
   if (last !== undefined && recorded !== undefined && recorded.hash !== last.catalogHash) {
-    return { version, catalogHash, state: "ahead" };
+    return { version, catalogHash, state: aheadState(history, known) };
   }
   return {
     version: recorded?.version ?? last?.id ?? "-",
     catalogHash: recorded?.hash ?? last?.catalogHash ?? "-",
-    state: "current"
+    state: CURRENT
   };
 }
 async function readTargetStatus(input) {
@@ -82,7 +93,8 @@ async function readTargetStatus(input) {
       version: described.version,
       catalogHash: described.catalogHash,
       state: described.state,
-      protected: input.protected
+      protected: input.protected,
+      backfills: await readBackfills(pool)
     };
   } finally {
     await pool.close();
@@ -105,8 +117,17 @@ async function statusProject(cwd, flags) {
 }
 function formatStatus(rows) {
   const lines = ["target\tversion\tcatalog\tstate\tprotected"];
+  const backfills = [];
   for (const row of rows) {
     lines.push([row.target, row.version, row.catalogHash, row.state, row.protected ? "true" : "false"].join("\t"));
+    backfills.push(...row.backfills);
+  }
+  if (backfills.length > 0) {
+    lines.push("backfill");
+    lines.push("migration\tstep\trows\tkey\tstate");
+    for (const item of backfills) {
+      lines.push([item.migrationId, String(item.stepIndex), item.rows, item.lastKey, item.state].join("\t"));
+    }
   }
   return `${lines.join(`
 `)}
@@ -160,7 +181,33 @@ async function readHistory(pool) {
     rows.push({
       migrationId,
       stepIndex: Number(step),
-      class: stepClass === "contract" || stepClass === "unclassified" ? stepClass : "expand"
+      class: storedClass(stepClass)
+    });
+  }
+  return rows;
+}
+async function readBackfills(pool) {
+  const present = await pool.execute("select to_regclass('okm_backfill') is not null");
+  if (!wireTrue(present.rows[0]?.[0] ?? null))
+    return [];
+  const result = await pool.execute(`select migration_id, step_index::text, rows_touched::text, last_key, state
+     from okm_backfill
+     where state <> 'done'
+     order by migration_id, step_index`);
+  const rows = [];
+  for (const row of result.rows) {
+    const migrationId = row[0];
+    const step = row[1];
+    const touched = row[2];
+    const state = row[4];
+    if (migrationId == null || step == null || touched == null || state == null)
+      continue;
+    rows.push({
+      migrationId,
+      stepIndex: Number(step),
+      rows: touched,
+      lastKey: row[3] ?? "-",
+      state
     });
   }
   return rows;
@@ -168,6 +215,26 @@ async function readHistory(pool) {
 function wireTrue(value) {
   return value === "t" || value === "true";
 }
+function aheadState(history, known) {
+  let sawExtra = false;
+  let expandOnly = true;
+  for (const row of history) {
+    if (known.has(row.migrationId))
+      continue;
+    sawExtra = true;
+    if (row.class !== "expand")
+      expandOnly = false;
+  }
+  if (!sawExtra) {
+    expandOnly = history.length > 0 && history.every((row) => row.class === "expand");
+  }
+  return expandOnly ? AHEAD_EXPAND : AHEAD_CONTRACT;
+}
+function storedClass(value) {
+  if (value === "expand" || value === "contract" || value === "unclassified")
+    return value;
+  return "unclassified";
+}
 export {
   statusProject
 };

package/dist/shared/{6bazvqwm.js → fb00y8fp.js}

@@ -1,13 +1,13 @@
 import {
   send,
   connectClient
-} from "./bqha5cg6.js";
+} from "./6p5k20sm.js";
 import {
   isConnectionLost
 } from "./tbszx8mz.js";
 import {
   WireSession
-} from "./0jc3ffzf.js";
+} from "./zvbjc949.js";
 import {
   rejectClosed,
   runCall

package/dist/shared/{jkc6ws1p.js → g7ez901n.js}

@@ -1,11 +1,18 @@
 import {
+  assertNamespace2,
   identityKey2,
   identityLabel2,
-  compareText
+  normaliseEdges,
+  compareText,
+  assertProvenance
 } from "./t4tbsy9h.js";
 import {
   CATALOG_VERSION2
 } from "./4e4c6vq2.js";
+import {
+  assertIdentifier2,
+  assertStoredText
+} from "./nfzc5z0w.js";
 import {
   catalogError2
 } from "./52szzakm.js";
@@ -135,4 +142,78 @@ function assertForeignKeys(objects, keys) {
   }
 }
 
-export { dependencyOrder, catalog };
+// src/contracts/catalog/enum.ts
+function enumType(input) {
+  assertNamespace2(input.namespace);
+  assertIdentifier2(input.name, "type");
+  assertProvenance(input.provenance);
+  if (input.labels.length === 0) {
+    catalogError2("OKM1020", `Enum ${input.name} must list at least one label.`);
+  }
+  const labels = [];
+  const seen = new Set;
+  for (const label of input.labels) {
+    assertStoredText(label, "enum label");
+    if (label.length === 0) {
+      catalogError2("OKM1020", `Enum ${input.name} has an empty label.`);
+    }
+    if (seen.has(label)) {
+      catalogError2("OKM1020", `Enum ${input.name} repeats label ${label}.`);
+    }
+    seen.add(label);
+    labels.push(label);
+  }
+  const identity = {
+    kind: "type",
+    namespace: input.namespace,
+    name: input.name
+  };
+  return {
+    kind: "type",
+    identity,
+    owner: input.owner ?? "managed",
+    definition: { labels },
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function domainType(input) {
+  assertNamespace2(input.namespace);
+  assertIdentifier2(input.name, "type");
+  assertProvenance(input.provenance);
+  if (input.base.length === 0) {
+    catalogError2("OKM1020", `Domain ${input.name} needs a base type.`);
+  }
+  assertStoredText(input.check, "domain check");
+  if (input.check.length === 0) {
+    catalogError2("OKM1020", `Domain ${input.name} needs a check.`);
+  }
+  const identity = {
+    kind: "type",
+    namespace: input.namespace,
+    name: input.name
+  };
+  const definition = { base: input.base, check: input.check };
+  return {
+    kind: "type",
+    identity,
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function isDomain(definition) {
+  return "base" in definition;
+}
+function sameEnumLabels(left, right) {
+  if (left.length !== right.length)
+    return false;
+  for (let index = 0;index < left.length; index += 1) {
+    if (left[index] !== right[index])
+      return false;
+  }
+  return true;
+}
+
+export { dependencyOrder, catalog, enumType, domainType, isDomain, sameEnumLabels };

package/dist/shared/{kgnc8grt.js → gdh9mrtp.js}

@@ -1,6 +1,6 @@
 import {
   open3
-} from "./75xkjv0t.js";
+} from "./fa9vt245.js";
 import {
   PGLITE_CAPABILITIES,
   readCapability2,

package/dist/shared/hqjsxnz7.js

@@ -0,0 +1,13 @@
+import {
+  assertAuthorDrift2,
+  catalogQuery2,
+  managedRoleOptions2
+} from "./xghkt7a9.js";
+import"./n5y9zyj1.js";
+import"./41kv2xdm.js";
+import"./8jb4ymh2.js";
+export {
+  assertAuthorDrift2 as assertAuthorDrift,
+  catalogQuery2 as catalogQuery,
+  managedRoleOptions2 as managedRoleOptions
+};

package/dist/shared/htnaj77v.js

@@ -0,0 +1,17 @@
+// src/runtime/catalog-cache.ts
+var inflight = new Map;
+function loadOnce(key, load) {
+  const found = inflight.get(key);
+  if (found !== undefined)
+    return found;
+  const pending = Promise.resolve().then(load);
+  inflight.set(key, pending);
+  pending.catch(() => {
+    if (inflight.get(key) === pending)
+      inflight.delete(key);
+  });
+  return pending;
+}
+export {
+  loadOnce
+};

package/dist/shared/{mt5wswjz.js → jgxzjzcz.js}

@@ -4,7 +4,7 @@ import {
 import {
   withHttp,
   settleCall
-} from "./k34e0xf2.js";
+} from "./kkzwp3d2.js";
 import {
   rejectKeys,
   isRecord,

package/dist/shared/{6w5j844a.js → jsd07prz.js}

@@ -60,6 +60,7 @@ var TABLE_KNOWN = new Set([
   "omitDefaults",
   "presets",
   "primaryKey",
+  "reference",
   "relations",
   "renamedFrom",
   "sqlName",
@@ -71,8 +72,7 @@ var TABLE_KNOWN = new Set([
 ]);
 var TABLE_LATER = {
   computed: "later",
-  policies: "later",
-  reference: "0.4"
+  policies: "later"
 };
 function table2(name, columns, options) {
   const source = callerLocation(1);

package/dist/shared/{m78s7898.js → kafaa5zv.js}

@@ -5,7 +5,7 @@ import {
   openClient,
   withHttp,
   settleCall
-} from "./k34e0xf2.js";
+} from "./kkzwp3d2.js";
 import {
   rejectKeys,
   isRecord,

package/dist/shared/kj680nxv.js

@@ -0,0 +1,19 @@
+import {
+  applyTarget2,
+  applyProject2,
+  pushProject2,
+  backfillTiming2
+} from "./s4mb6a4b.js";
+import"./7nk68fj8.js";
+import"./q6zsyh31.js";
+import"./n5y9zyj1.js";
+import"./n442h54c.js";
+import"./41kv2xdm.js";
+import"./8jb4ymh2.js";
+import"./wqem4jed.js";
+export {
+  applyProject2 as applyProject,
+  applyTarget2 as applyTarget,
+  backfillTiming2 as backfillTiming,
+  pushProject2 as pushProject
+};