okmodel 0.2.1 → 0.4.0

package/dist/shared/8ktwd3rh.js

@@ -0,0 +1,97 @@
+import {
+  normaliseEdges,
+  assertProvenance
+} from "./t4tbsy9h.js";
+import {
+  assertIdentifier2
+} from "./nfzc5z0w.js";
+import {
+  catalogError2
+} from "./52szzakm.js";
+
+// src/contracts/catalog/extension.ts
+function extensionObject(input) {
+  assertIdentifier2(input.name, "extension");
+  assertIdentifier2(input.schema, "extension schema");
+  assertProvenance(input.provenance);
+  assertVersion(input.version);
+  const definition = {
+    schema: input.schema,
+    relocatable: input.relocatable ?? true,
+    ...input.version !== undefined ? { version: input.version } : {}
+  };
+  return {
+    kind: "extension",
+    identity: { kind: "extension", name: input.name },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function isExactVersion(version) {
+  return version !== undefined && /^\d+(?:\.\d+)*$/.test(version);
+}
+function compareExtensionVersions(left, right) {
+  const a = parts(left);
+  const b = parts(right);
+  const length = Math.max(a.length, b.length);
+  for (let index = 0;index < length; index += 1) {
+    const diff = (a[index] ?? 0) - (b[index] ?? 0);
+    if (diff !== 0)
+      return diff < 0 ? -1 : 1;
+  }
+  return 0;
+}
+function sameExtensionDefinition(before, after) {
+  if (before.definition.schema !== after.definition.schema)
+    return false;
+  if (before.definition.relocatable !== after.definition.relocatable)
+    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;
+  if (isExactVersion(version) || /^>=\d+(?:\.\d+)*$/.test(version))
+    return;
+  catalogError2("OKM1020", `Extension version ${String(version)} must be a dotted version or a >= floor.`);
+}
+function parts(version) {
+  return version.split(".").map((part) => Number(part));
+}
+
+export { extensionObject, isExactVersion, compareExtensionVersions, sameExtensionDefinition, alignExtensionVersions };

package/dist/shared/94ez8kzh.js

@@ -0,0 +1,19 @@
+// src/dialects/pg/quote.ts
+function quoteLiteral(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function arrayElement(encoded, raw) {
+  if (raw && (encoded === "true" || encoded === "false" || isBareNumber(encoded))) {
+    return encoded;
+  }
+  return `"${encoded.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
+}
+function isBareNumber(encoded) {
+  let pattern = bareNumber;
+  pattern ??= /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+  bareNumber = pattern;
+  return pattern.test(encoded);
+}
+var bareNumber;
+
+export { quoteLiteral, arrayElement };

package/dist/shared/{3a5ne750.js → 9m80mkac.js}

@@ -1,9 +1,9 @@
 import {
   ColumnBuilder2
-} from "./dd4f8mnx.js";
+} from "./c9z5g0fm.js";
 import {
   definition
-} from "./xatfg0gn.js";
+} from "./tmbdywx0.js";
 import {
   OkmError2
 } from "./52szzakm.js";

package/dist/shared/9x25fxhc.js

@@ -0,0 +1,150 @@
+import {
+  staticNamespace2,
+  assertNamespace2,
+  normaliseEdges,
+  assertProvenance
+} from "./t4tbsy9h.js";
+import {
+  assertIdentifier2
+} from "./nfzc5z0w.js";
+import {
+  catalogError2
+} from "./52szzakm.js";
+
+// src/contracts/catalog/routine.ts
+var VOLATILITY = new Set(["volatile", "stable", "immutable"]);
+var SECURITY = new Set(["invoker", "definer"]);
+var TIMING = new Set(["before", "after", "instead"]);
+var LEVEL = new Set(["row", "statement"]);
+var EVENT_ORDER = ["insert", "update", "delete", "truncate"];
+var TYPE_TEXT = /^[A-Za-z][A-Za-z0-9_ ]*(\(\d+(,\s*\d+)?\))?(\[\])*$/;
+function functionObject(input) {
+  assertIdentifier2(input.name, "function");
+  const namespace = input.namespace ?? staticNamespace2("public");
+  assertNamespace2(namespace);
+  assertProvenance(input.provenance);
+  if (input.language !== "sql" && input.language !== "plpgsql") {
+    catalogError2("OKM1020", `Function ${input.name} language must be sql or plpgsql.`);
+  }
+  const volatility = input.volatility ?? "volatile";
+  if (!VOLATILITY.has(volatility)) {
+    catalogError2("OKM1020", `Function ${input.name} volatility ${volatility} is not supported.`);
+  }
+  const security = input.security ?? "invoker";
+  if (!SECURITY.has(security)) {
+    catalogError2("OKM1020", `Function ${input.name} security ${security} is not supported.`);
+  }
+  assertTypeName(input.returns, `function ${input.name} return type`);
+  const args = (input.arguments ?? []).map((argument) => readArgument(input.name, argument));
+  if (input.body.length === 0) {
+    catalogError2("OKM1020", `Function ${input.name} needs a body.`);
+  }
+  const atomic = input.atomic === true;
+  if (atomic && input.language !== "sql") {
+    catalogError2("OKM1020", `Function ${input.name} BEGIN ATOMIC needs language sql.`);
+  }
+  if (input.searchPath !== undefined && input.searchPath.trim().length === 0) {
+    catalogError2("OKM1020", `Function ${input.name} search_path is empty.`);
+  }
+  const definition = {
+    arguments: args,
+    returns: input.returns,
+    language: input.language,
+    volatility,
+    security,
+    body: input.body,
+    ...input.searchPath !== undefined ? { searchPath: input.searchPath } : {},
+    ...atomic ? { atomic: true } : {}
+  };
+  return {
+    kind: "function",
+    identity: {
+      kind: "function",
+      namespace,
+      name: input.name,
+      argTypes: args.map((arg) => arg.type)
+    },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function triggerObject(input) {
+  assertIdentifier2(input.name, "trigger");
+  assertNamespace2(input.parent.namespace);
+  assertIdentifier2(input.parent.name, "trigger table");
+  assertProvenance(input.provenance);
+  if (!TIMING.has(input.timing)) {
+    catalogError2("OKM1020", `Trigger ${input.name} timing ${input.timing} is not supported.`);
+  }
+  if (!LEVEL.has(input.level)) {
+    catalogError2("OKM1020", `Trigger ${input.name} level ${input.level} is not supported.`);
+  }
+  const events = EVENT_ORDER.filter((event) => input.events.includes(event));
+  if (events.length === 0) {
+    catalogError2("OKM1020", `Trigger ${input.name} needs an event.`);
+  }
+  const updateOf = input.updateOf === undefined ? undefined : [...input.updateOf];
+  if (updateOf !== undefined) {
+    if (!events.includes("update")) {
+      catalogError2("OKM1020", `Trigger ${input.name} lists UPDATE OF columns without an update event.`);
+    }
+    if (input.level !== "row") {
+      catalogError2("OKM1020", `Trigger ${input.name} UPDATE OF columns need level row.`);
+    }
+    for (const column of updateOf)
+      assertIdentifier2(column, "trigger column");
+  }
+  assertIdentifier2(input.calls.name, "trigger function");
+  assertNamespace2(input.calls.namespace);
+  for (const typeName of input.calls.argTypes)
+    assertTypeName(typeName, `trigger ${input.name}`);
+  const edges = [
+    { kind: "table", namespace: input.parent.namespace, name: input.parent.name },
+    {
+      kind: "function",
+      namespace: input.calls.namespace,
+      name: input.calls.name,
+      argTypes: input.calls.argTypes
+    },
+    ...(updateOf ?? []).map((column) => ({
+      kind: "column",
+      parent: input.parent,
+      name: column
+    })),
+    ...input.dependencies ?? []
+  ];
+  const definition = {
+    timing: input.timing,
+    events,
+    level: input.level,
+    calls: {
+      namespace: input.calls.namespace,
+      name: input.calls.name,
+      argTypes: [...input.calls.argTypes]
+    },
+    ...updateOf !== undefined && updateOf.length > 0 ? { updateOf } : {},
+    ...input.when !== undefined && input.when.length > 0 ? { when: input.when } : {}
+  };
+  return {
+    kind: "trigger",
+    identity: { kind: "trigger", parent: input.parent, name: input.name },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(edges),
+    provenance: input.provenance
+  };
+}
+function readArgument(fn, argument) {
+  assertIdentifier2(argument.name, `function ${fn} argument`);
+  assertTypeName(argument.type, `function ${fn} argument ${argument.name}`);
+  return { name: argument.name, type: argument.type };
+}
+function assertTypeName(typeName, role) {
+  if (!TYPE_TEXT.test(typeName)) {
+    catalogError2("OKM1020", `${role} ${typeName} is not a type name.`);
+  }
+}
+
+export { functionObject, triggerObject };

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/{4jzzghr6.js → awrsqrn7.js}

@@ -2,10 +2,7 @@ import {
   assertOperatorFits,
   textArray,
   arrayElementType
-} from "./zt8y0wzb.js";
-import {
-  runWrite
-} from "./n4jqhpqz.js";
+} from "./n7mcc1gk.js";
 import {
   stack
 } from "./672t5vym.js";
@@ -14,12 +11,15 @@ import {
   fieldSealed,
   sealingTrait
 } from "./7m88x3e9.js";
+import {
+  runWrite
+} from "./n4jqhpqz.js";
 import {
   writeWouldValidate
-} from "./3a5ne750.js";
+} from "./9m80mkac.js";
 import {
   encodeJson
-} from "./yw5c610b.js";
+} from "./gjthds9j.js";
 import {
   withRowFilters,
   archiveRules,

package/dist/shared/{4b9da9d7.js → axhk06q1.js}

@@ -5,9 +5,10 @@ import {
   assertBoundText,
   assertRegconfig,
   textArray
-} from "./zt8y0wzb.js";
+} from "./n7mcc1gk.js";
 import {
   installOperatorSql,
+  quote,
   isRecord,
   fail
 } from "./xrfnq5k8.js";
@@ -35,6 +36,10 @@ function emitStructured(column, ref, name, value, sink) {
     emitMatches(column, ref, value, sink);
     return;
   }
+  if (name === "similar" || name === "wordSimilar") {
+    emitTrigram(column, ref, name, value, sink);
+    return;
+  }
   assertOperatorFits(column, name);
   fail("OKM1121", `${name} is not a value operator on ${column.field}. Use has, none, or every on a relation.`);
 }
@@ -135,4 +140,17 @@ function emitMatches(column, ref, value, sink) {
   sink.param(value.query);
   sink.text(")");
 }
+function emitTrigram(column, ref, name, value, sink) {
+  if (!isRecord(value) || typeof value.query !== "string" || typeof value.schema !== "string") {
+    fail("OKM1121", `${name} on ${column.field} needs query text.`);
+  }
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value.schema)) {
+    fail("OKM1121", `${name} on ${column.field} needs an extension schema name.`);
+  }
+  sink.text(ref);
+  sink.text(" operator(");
+  sink.text(quote(value.schema));
+  sink.text(name === "similar" ? ".%) " : ".<%) ");
+  sink.param(value.query);
+}
 installOperatorSql(emitStructured);

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

@@ -1,16 +1,28 @@
 import {
   open2
-} from "./ecdzej21.js";
-import"./d2whjz4k.js";
+} from "./wqem4jed.js";
+import"./8jb4ymh2.js";
 import"./n442h54c.js";
 import {
-  loadMigrations
-} from "./rtnaqre0.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 "./5z4q2zda.js";
+} from "./q6zsyh31.js";
+import"./n5y9zyj1.js";
+import"./41kv2xdm.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -18,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;
@@ -33,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) {
@@ -81,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();
@@ -104,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(`
 `)}
@@ -159,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;
@@ -167,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/{n47rd821.js → c8aghh05.js}

@@ -1,6 +1,6 @@
 import {
   validationGate
-} from "./3a5ne750.js";
+} from "./9m80mkac.js";
 import {
   isOperator
 } from "./cn0n68ft.js";

package/dist/shared/{dd4f8mnx.js → c9z5g0fm.js}

@@ -1,10 +1,12 @@
 import {
   definition,
   rejected,
-  quoteLiteral,
   writeArray,
   readArray
-} from "./xatfg0gn.js";
+} from "./tmbdywx0.js";
+import {
+  quoteLiteral
+} from "./94ez8kzh.js";
 import {
   REFERENTIAL_ACTIONS,
   referentialAction

package/dist/shared/{ps43134h.js → dyj86cmj.js}

@@ -1,15 +1,15 @@
 import {
   encodeText,
   decodeText
-} from "./sacqha1y.js";
+} from "./4m9fn52z.js";
 import {
   required,
   openColumn
-} from "./dd4f8mnx.js";
+} from "./c9z5g0fm.js";
 import {
   definition,
   rejected
-} from "./xatfg0gn.js";
+} from "./tmbdywx0.js";
 import {
   readClientGenerator
 } from "./rwmrejjz.js";
@@ -66,4 +66,4 @@ function uuidText() {
 }
 var uuidPattern;
 
-export { id2, uuid2 };
+export { id2, uuid2, encodeUuid, decodeUuid };

package/dist/shared/{0qkxbm1f.js → fa9vt245.js}

@@ -9,7 +9,7 @@ import {
   runCall,
   EMPTY_NOTICES,
   resultFrom
-} from "./9k6vetvf.js";
+} from "./rrstp3kb.js";
 
 // src/adapters/pg/pglite.ts
 import { PGlite } from "@electric-sql/pglite";

package/dist/shared/{qa5dsc7z.js → fb00y8fp.js}

@@ -1,17 +1,17 @@
 import {
   send,
   connectClient
-} from "./38crxbgn.js";
+} from "./6p5k20sm.js";
 import {
   isConnectionLost
 } from "./tbszx8mz.js";
 import {
   WireSession
-} from "./cstgkzdx.js";
+} from "./zvbjc949.js";
 import {
   rejectClosed,
   runCall
-} from "./9k6vetvf.js";
+} from "./rrstp3kb.js";
 
 // src/adapters/pg/nodepostgres-extra.ts
 var RESET_ALL = "RESET ALL";