okmodel 0.3.0 → 0.5.0

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/{p24x2334.js → h4nqvjkp.js}

@@ -3,7 +3,7 @@ import {
   readHandle,
   readCall,
   attachHttp
-} from "./k34e0xf2.js";
+} from "./bt9sfq0z.js";
 import {
   selectedColumns,
   parseOrder,
@@ -15,7 +15,7 @@ import {
   isRecord,
   registerFailFix,
   fail
-} from "./xrfnq5k8.js";
+} from "./qgvt8nx1.js";
 import {
   OkmError2,
   throwNamed2
@@ -30,6 +30,7 @@ var OPTIONS = [
   "limit",
   "include",
   "after",
+  "route",
   "signal",
   "timeout"
 ];
@@ -69,7 +70,8 @@ function plan(session, table, options, mods, view) {
       limit: size + 1,
       include: record.include,
       signal: record.signal,
-      timeout: record.timeout
+      timeout: record.timeout,
+      route: record.route
     }, undefined, session.scope, session.schema.model[table], session.schema, view),
     ...after !== undefined ? { after } : {}
   };

package/dist/shared/{edwqqryd.js → h8ne16fq.js}

@@ -17,7 +17,7 @@ import {
   isRecord,
   registerFailFix,
   fail
-} from "./xrfnq5k8.js";
+} from "./qgvt8nx1.js";
 import {
   throwNamed2
 } from "./52szzakm.js";

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/jdgqqx31.js

@@ -0,0 +1,72 @@
+import {
+  open2
+} from "./wqem4jed.js";
+import"./8bwbwy8h.js";
+import {
+  createdOf,
+  testing2
+} from "./g516zdsb.js";
+import"./n442h54c.js";
+import {
+  assertTargetPolicy,
+  assertDirectConnection,
+  selectTarget,
+  loadConfig,
+  loadSchema
+} from "./xdpj5kkm.js";
+import"./ayz64vzj.js";
+import"./8xsbagad.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/{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 → k7cc9nzk.js}

@@ -5,12 +5,12 @@ import {
   openClient,
   withHttp,
   settleCall
-} from "./k34e0xf2.js";
+} from "./bt9sfq0z.js";
 import {
   rejectKeys,
   isRecord,
   fail
-} from "./xrfnq5k8.js";
+} from "./qgvt8nx1.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -312,8 +312,16 @@ function held(session, frame, after, depth) {
   };
   const pool = depth === 0 ? {
     capabilities: base.capabilities,
-    execute: (text, params, options) => guarded(() => frame.conn.execute(text, params, stoppable(frame, options)), false),
-    batch: (statements, options) => guarded(() => frame.conn.batch(statements, stoppable(frame, options)), true),
+    execute: (text, params, options) => {
+      if (options?.route === "replica")
+        replicaInside();
+      return guarded(() => frame.conn.execute(text, params, stoppable(frame, options)), false);
+    },
+    batch: (statements, options) => {
+      if (options?.route === "replica")
+        replicaInside();
+      return guarded(() => frame.conn.batch(statements, stoppable(frame, options)), true);
+    },
     stats: () => base.stats(),
     close: () => Promise.resolve()
   } : base;
@@ -364,13 +372,22 @@ function lockKey(key) {
   return ["select pg_advisory_xact_lock($1::bigint)", String(key)];
 }
 function callOf(options) {
-  if (options?.signal === undefined && options?.timeout === undefined)
+  if (options?.signal === undefined && options?.timeout === undefined && options?.route === undefined) {
     return;
+  }
   return {
-    ...options.signal !== undefined ? { signal: options.signal } : {},
-    ...options.timeout !== undefined ? { timeout: options.timeout } : {}
+    ...options?.signal !== undefined ? { signal: options.signal } : {},
+    ...options?.timeout !== undefined ? { timeout: options.timeout } : {},
+    ...options?.route !== undefined ? { route: options.route } : {}
   };
 }
+function replicaInside() {
+  throw new OkmError2("OKM1840", "This operation needs the primary.", {
+    fix: {
+      summary: "Run the operation on the primary. Writes, batch, locks, and tx() never go to a replica."
+    }
+  });
+}
 export {
   tx
 };