okmodel 0.1.0 → 0.2.1

package/dist/shared/{8b04d28c.js → py3nh7jy.js}

@@ -1,11 +1,11 @@
 import {
   open3
-} from "./fgqgsb5z.js";
+} from "./0qkxbm1f.js";
 import {
   PGLITE_CAPABILITIES,
   readCapability2,
   hasCapability2
-} from "./xy79j5hq.js";
+} from "./9k6vetvf.js";
 export {
   PGLITE_CAPABILITIES as capabilities,
   hasCapability2 as hasCapability,

package/dist/shared/qa5dsc7z.js

@@ -0,0 +1,86 @@
+import {
+  send,
+  connectClient
+} from "./38crxbgn.js";
+import {
+  isConnectionLost
+} from "./tbszx8mz.js";
+import {
+  WireSession
+} from "./cstgkzdx.js";
+import {
+  rejectClosed,
+  runCall
+} from "./9k6vetvf.js";
+
+// src/adapters/pg/nodepostgres-extra.ts
+var RESET_ALL = "RESET ALL";
+var UNLOCK = "SELECT pg_advisory_unlock_all()";
+async function checkout(held) {
+  const { pool, counters, named, isClosed } = held;
+  if (isClosed())
+    return rejectClosed();
+  const client = await connectClient(pool, held.acquireMs, counters);
+  counters.reserved += 1;
+  let lost = false;
+  const onError = () => {
+    lost = true;
+  };
+  const events = client;
+  events.on("error", onError);
+  const local = new Set;
+  const session = new WireSession((text, params) => send(client, text, params, named, client), held.notices, isClosed, true, () => {
+    counters.reservedBusy += 1;
+  }, () => {
+    counters.reservedBusy = Math.max(0, counters.reservedBusy - 1);
+  }, local);
+  const guard = (run) => lost ? rejectClosed("The connection was lost.") : run().catch((error) => {
+    if (isConnectionLost(error))
+      lost = true;
+    throw error;
+  });
+  let released = false;
+  return {
+    execute: (text, params, options) => guard(() => runCall(isClosed(), options, (watch) => session.query(text, params, watch))),
+    batch: (statements, options) => guard(() => runCall(isClosed(), options, async (watch) => {
+      const { runAtomicBatch } = await import("./b066g80h.js");
+      return runAtomicBatch(session, statements, watch);
+    })),
+    cancel() {
+      session.cancel();
+    },
+    async release() {
+      if (released)
+        return;
+      released = true;
+      try {
+        if (!lost)
+          await reset(session, client);
+      } finally {
+        counters.reserved = Math.max(0, counters.reserved - 1);
+        events.removeListener("error", onError);
+        client.release(lost);
+      }
+    }
+  };
+}
+async function reset(session, client) {
+  const run = (text) => client.query(text);
+  if (session.depth() > 0)
+    await run("ROLLBACK").catch(() => {
+      return;
+    });
+  try {
+    await run(RESET_ALL);
+    await run(UNLOCK);
+  } catch {
+    await run("ROLLBACK").catch(() => {
+      return;
+    });
+    await run(RESET_ALL);
+    await run(UNLOCK);
+  }
+}
+export {
+  checkout
+};

package/dist/shared/{g5fhqmwe.js → qxa0yb9j.js}

@@ -1,19 +1,21 @@
 import {
-  CATALOG_VERSION2,
   assertNamespace2,
   identityKey2,
   identityLabel2,
   normaliseEdges,
   compareText,
   assertProvenance
-} from "./j5cn2963.js";
+} from "./t4tbsy9h.js";
+import {
+  CATALOG_VERSION2
+} from "./4e4c6vq2.js";
 import {
   assertIdentifier2,
   assertStoredText
-} from "./mkjmqjv4.js";
+} from "./nfzc5z0w.js";
 import {
   catalogError2
-} from "./ycwz42az.js";
+} from "./52szzakm.js";
 
 // src/contracts/catalog/order.ts
 function indexObjects(objects) {

package/dist/shared/r6nwkxnt.js

@@ -0,0 +1,86 @@
+import {
+  stack
+} from "./672t5vym.js";
+import {
+  checkPresetNames
+} from "./nsva2a6b.js";
+import {
+  isOperator,
+  operatorValue
+} from "./cn0n68ft.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/presets.ts
+function checkSchema(schema) {
+  for (const name in schema.model) {
+    const presets = schema.model[name]?.presets;
+    if (presets !== undefined)
+      checkPresetNames(Object.keys(presets), `table ${name}`);
+  }
+}
+function resolve(schema, table, uses) {
+  const model = schema.model[table];
+  const known = model?.presets ?? {};
+  const chain = [];
+  for (let use = uses;use !== undefined; use = use[0])
+    chain.unshift(use);
+  const wheres = [];
+  const rules = [];
+  for (const [, name, args] of chain) {
+    const preset = known[name];
+    if (typeof preset !== "function") {
+      throw new OkmError2("OKM1120", `Table ${table} has no preset ${name}.`, {
+        fix: { summary: `Use one of: ${Object.keys(known).join(", ")}.` }
+      });
+    }
+    const added = [];
+    const q = {
+      where(filter) {
+        added.push(filter);
+        return q;
+      }
+    };
+    if (preset(q, ...args) !== q) {
+      throw new OkmError2("OKM1121", `Preset ${name} on ${table} must return the builder it was given.`, { fix: { summary: "Return q, as in (q) => q.where({ ... })." } });
+    }
+    for (const filter of added)
+      wheres.push(filter);
+    rules.push({
+      rule: "preset",
+      contribution: `${name} filters ${[...new Set(added.flatMap(fieldsOf))].join(", ") || "nothing"}`,
+      provenance: ownerOf(model, name, table),
+      ...model?.source !== undefined ? { source: model.source } : {}
+    });
+  }
+  return { wheres, rules };
+}
+function refine(schema, call, uses) {
+  const { wheres, rules } = resolve(schema, call.table, uses);
+  return {
+    ...call,
+    where: stack(call.where, wheres),
+    ruleLines: [...call.ruleLines ?? [], ...rules]
+  };
+}
+function ownerOf(model, name, table) {
+  for (const trait of model?.traits ?? []) {
+    const presets = trait.presets;
+    if (presets !== undefined && Object.hasOwn(presets, name))
+      return `trait ${trait.name}`;
+  }
+  return `table ${table}`;
+}
+function fieldsOf(filter) {
+  if (isOperator(filter)) {
+    const branches = operatorValue(filter);
+    return Array.isArray(branches) ? branches.flatMap(fieldsOf) : [];
+  }
+  return typeof filter === "object" && filter !== null ? Object.keys(filter) : [];
+}
+export {
+  checkSchema,
+  refine,
+  resolve
+};

package/dist/shared/{4j72449d.js → rtnaqre0.js}

@@ -1,13 +1,13 @@
 import {
   catalogHash2,
   parseCatalog2
-} from "./y9m15dfv.js";
+} from "./d2whjz4k.js";
 import {
   parsePlan
-} from "./kynx7vbm.js";
+} from "./5z4q2zda.js";
 import {
   OkmError2
-} from "./ycwz42az.js";
+} from "./52szzakm.js";
 
 // src/tooling/migrate/files.ts
 import { existsSync, readdirSync, readFileSync } from "node:fs";

package/dist/shared/rwmrejjz.js

@@ -0,0 +1,26 @@
+// src/contracts/generator.ts
+var CLIENT_DEFAULT = Symbol.for("okmodel.clientDefault");
+function clientGenerator(call, name, options) {
+  const marked = call;
+  Object.defineProperty(marked, CLIENT_DEFAULT, {
+    value: options === undefined ? { label: "client", name } : { label: "client", name, options },
+    enumerable: false
+  });
+  return marked;
+}
+function readClientGenerator(value) {
+  if (typeof value !== "function")
+    return;
+  const mark = value[CLIENT_DEFAULT];
+  if (isMark(mark))
+    return { label: "client", name: mark.name, call: value };
+  return { label: "client", name: "function", call: value };
+}
+function isMark(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const name = value.name;
+  return value.label === "client" && typeof name === "string" && name !== "function";
+}
+
+export { clientGenerator, readClientGenerator };

package/dist/shared/{zhc5vmgf.js → s6gqfn5j.js}

@@ -1,12 +1,12 @@
 import {
   isConnectionSqlstate,
   isConnectionFailure
-} from "./ngk8gj61.js";
+} from "./tbszx8mz.js";
 import {
   OkmError2,
   stripRowValues,
   matchingParen
-} from "./ycwz42az.js";
+} from "./52szzakm.js";
 
 // src/dialects/pg/errors.ts
 function mapPostgresError(error, options) {

package/dist/shared/sacqha1y.js

@@ -0,0 +1,70 @@
+import {
+  required
+} from "./dd4f8mnx.js";
+import {
+  definition,
+  rejected
+} from "./xatfg0gn.js";
+
+// src/dialects/pg/text.ts
+function text2() {
+  return required({ baseType: "text", encode: encodeText, decode: decodeText, sqlForm: "quote" });
+}
+function varchar2(length) {
+  const limit = boundedLength(length, "varchar");
+  return required({
+    baseType: `varchar(${String(limit)})`,
+    encode: (value) => encodeLimited(value, limit, "varchar"),
+    decode: decodeText,
+    sqlForm: "quote"
+  });
+}
+function char2(length) {
+  const limit = boundedLength(length, "char");
+  return required({
+    baseType: `char(${String(limit)})`,
+    encode: (value) => encodeLimited(value, limit, "char"),
+    decode: decodeText,
+    sqlForm: "quote"
+  });
+}
+function citext2() {
+  return required({
+    baseType: "citext",
+    encode: encodeText,
+    decode: decodeText,
+    sqlForm: "quote",
+    extension: "citext"
+  });
+}
+function encodeText(value) {
+  return value;
+}
+function decodeText(wire) {
+  return wire;
+}
+function encodeLimited(value, limit, role) {
+  if (characterLength(value) > limit) {
+    rejected(`${role} accepts at most ${String(limit)} characters.`);
+  }
+  return value;
+}
+function boundedLength(length, role) {
+  if (!Number.isInteger(length) || length < 1 || length > 10485760) {
+    definition(`${role} length ${String(length)} must be an integer from 1 to 10485760.`);
+  }
+  return length;
+}
+function characterLength(value) {
+  let count = 0;
+  for (let index = 0;index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 55296 && code <= 56319) {
+      index += 1;
+    }
+    count += 1;
+  }
+  return count;
+}
+
+export { text2, varchar2, char2, citext2, encodeText, decodeText };

package/dist/shared/{qk3hxfja.js → sfh4pk75.js}

@@ -1,6 +1,6 @@
 import {
   OkmError2
-} from "./ycwz42az.js";
+} from "./52szzakm.js";
 
 // src/runtime/drift.ts
 async function assertCompatible(pool, schema, recordedHash, source, options) {
@@ -8,16 +8,16 @@ async function assertCompatible(pool, schema, recordedHash, source, options) {
   if (code.hash === recordedHash)
     return;
   if (code.artifact !== undefined) {
-    const { loadTrustedCatalog } = await import("./w8samvk1.js");
+    const { loadTrustedCatalog } = await import("./a1gdp7j9.js");
     loadTrustedCatalog(code.artifact.text, code.artifact.hash);
   } else {
     const artifact = await readCatalogFile(source.catalogDir);
     if (artifact !== undefined) {
-      const { loadTrustedCatalog } = await import("./w8samvk1.js");
+      const { loadTrustedCatalog } = await import("./a1gdp7j9.js");
       loadTrustedCatalog(artifact.text, artifact.hash);
     }
   }
-  const { assertDrift } = await import("./p0cbr3g2.js");
+  const { assertDrift } = await import("./zwmqxb0g.js");
   await assertDrift(pool, code.hash, recordedHash, options);
 }
 async function codeHash(schema, source) {
@@ -26,7 +26,7 @@ async function codeHash(schema, source) {
   const listed = await readHashFile(source.catalogDir);
   if (listed !== undefined)
     return { hash: listed };
-  const { catalogHash } = await import("./w8samvk1.js");
+  const { catalogHash } = await import("./a1gdp7j9.js");
   return { hash: catalogHash(schemaCatalog(schema)) };
 }
 function schemaCatalog(schema) {

package/dist/shared/{j5cn2963.js → t4tbsy9h.js}

@@ -1,73 +1,15 @@
+import {
+  referentialAction
+} from "./4e4c6vq2.js";
 import {
   assertIdentifier2,
   fitIdentifier2,
   deterministicName2,
   assertStoredText
-} from "./mkjmqjv4.js";
+} from "./nfzc5z0w.js";
 import {
   catalogError2
-} from "./ycwz42az.js";
-
-// src/contracts/catalog/types.ts
-var OWNERS2 = ["managed", "external", "ignored"];
-var OBJECT_KINDS2 = [
-  "table",
-  "column",
-  "index",
-  "constraint",
-  "sequence",
-  "view",
-  "materializedView",
-  "type",
-  "function",
-  "trigger",
-  "policy",
-  "extension",
-  "role",
-  "grant",
-  "defaultPrivilege"
-];
-var BUILT_KINDS2 = ["table", "column", "index", "constraint", "sequence", "type"];
-var OBJECT_OPERATIONS2 = [
-  "create",
-  "replace",
-  "alter",
-  "drop",
-  "recreateWithDependents"
-];
-var KIND_OPERATIONS2 = {
-  table: ["create", "alter", "drop", "recreateWithDependents"],
-  column: ["create", "alter", "drop", "recreateWithDependents"],
-  index: ["create", "drop", "recreateWithDependents"],
-  constraint: ["create", "alter", "drop", "recreateWithDependents"],
-  sequence: ["create", "alter", "drop"],
-  view: ["create", "replace", "drop", "recreateWithDependents"],
-  materializedView: ["create", "drop", "recreateWithDependents"],
-  type: ["create", "alter", "drop"],
-  function: ["create", "replace", "drop", "recreateWithDependents"],
-  trigger: ["create", "drop", "recreateWithDependents"],
-  policy: ["create", "alter", "drop"],
-  extension: ["create", "alter", "drop"],
-  role: ["create", "alter"],
-  grant: ["create", "drop"],
-  defaultPrivilege: ["create", "alter", "drop"]
-};
-var REFERENTIAL_ACTIONS = [
-  "cascade",
-  "no action",
-  "restrict",
-  "set default",
-  "set null"
-];
-function referentialAction(value) {
-  for (const action of REFERENTIAL_ACTIONS) {
-    if (action === value) {
-      return action;
-    }
-  }
-  return;
-}
-var CATALOG_VERSION2 = 1;
+} from "./52szzakm.js";
 
 // src/contracts/catalog/json.ts
 function canonicalJson(value) {
@@ -431,6 +373,12 @@ function column2(input) {
   if (input.defaultExpression !== undefined) {
     assertStoredText(input.defaultExpression, "column default");
   }
+  if (input.collation !== undefined) {
+    assertStoredText(input.collation, "column collation");
+    if (input.collation.length === 0) {
+      catalogError2("OKM1020", `Column ${input.name} has an empty collation.`);
+    }
+  }
   if (input.generated !== undefined) {
     assertStoredText(input.generated.expression, "column generated expression");
   }
@@ -443,6 +391,7 @@ function column2(input) {
     dataType: input.dataType,
     nullable: input.nullable,
     ...input.defaultExpression !== undefined ? { defaultExpression: input.defaultExpression } : {},
+    ...input.collation !== undefined ? { collation: input.collation } : {},
     ...input.identity !== undefined ? { identity: { always: input.identity.always } } : {},
     ...input.generated !== undefined ? {
       generated: {
@@ -698,4 +647,4 @@ function copyPartition(partition) {
   return { method: partition.method, columns: [...partition.columns] };
 }
 
-export { OWNERS2, OBJECT_KINDS2, BUILT_KINDS2, OBJECT_OPERATIONS2, KIND_OPERATIONS2, REFERENTIAL_ACTIONS, referentialAction, CATALOG_VERSION2, canonicalJson, staticNamespace2, templateNamespace2, assertNamespace2, resolveNamespace2, identityKey2, identifierLimitApplies2, identityLabel2, sameRef2, sameNamespace2, identityToJson, namespaceToJson, table3, column2, index3, constraint2, sequence2, normaliseEdges, compareText, assertProvenance };
+export { canonicalJson, staticNamespace2, templateNamespace2, assertNamespace2, resolveNamespace2, identityKey2, identifierLimitApplies2, identityLabel2, sameRef2, sameNamespace2, identityToJson, namespaceToJson, table3, column2, index3, constraint2, sequence2, normaliseEdges, compareText, assertProvenance };

package/dist/shared/{ngk8gj61.js → tbszx8mz.js}

@@ -30,6 +30,20 @@ function isConnectionFailure(error) {
   const message = error.message;
   return message.includes("ECONNREFUSED") || message.includes("ECONNRESET") || message.includes("CONNECTION_CLOSED") || message.includes("terminating connection") || message.includes("The pool is closed");
 }
+function isConnectionLost(error) {
+  if (isConnectionFailure(error))
+    return true;
+  if (typeof error !== "object" || error === null)
+    return false;
+  if (Reflect.get(error, "kind") === "outcome_unknown")
+    return true;
+  if (readCode(error, "code") === "ERR_POSTGRES_CONNECTION_CLOSED")
+    return true;
+  if (error instanceof Error && error.message.includes("Connection terminated"))
+    return true;
+  const cause = Reflect.get(error, "cause");
+  return cause !== undefined && cause !== error && isConnectionLost(cause);
+}
 function readCode(error, key) {
   if (typeof error !== "object" || error === null || !(key in error))
     return;
@@ -37,4 +51,4 @@ function readCode(error, key) {
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }
 
-export { isConnectionSqlstate, isConnectionFailure };
+export { isConnectionSqlstate, isConnectionFailure, isConnectionLost };

package/dist/shared/v18jva5b.js

@@ -0,0 +1,90 @@
+import {
+  runWrite
+} from "./n4jqhpqz.js";
+import {
+  withHttp,
+  settleCall
+} from "./mxmcdsh5.js";
+import {
+  rejectKeys,
+  isRecord,
+  fail
+} from "./xrfnq5k8.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/batch.ts
+async function batch(session, ops, options, replica) {
+  try {
+    if (replica !== undefined) {
+      throw new OkmError2("OKM1840", "batch() needs the primary. .replica() is not allowed on a batch.", withHttp(session.http, {
+        fix: { summary: "Remove .replica(). A batch always runs on the primary." }
+      }));
+    }
+    if (!Array.isArray(ops))
+      fail("OKM1121", "batch expects a list of write operations.");
+    const record = options ?? {};
+    if (!isRecord(record))
+      fail("OKM1121", "batch options must be an object.");
+    rejectKeys(record, ["signal", "timeout"], "batch");
+    const prepared = [];
+    for (const op of ops) {
+      const plan = typeof op === "object" && op !== null ? op["~plan"] : undefined;
+      if (plan === undefined) {
+        fail("OKM1121", "batch takes write operations: insert, update, delete, and archive. Pass them without awaiting.");
+      }
+      const item = await plan();
+      if (item.checked !== undefined) {
+        fail("OKM1121", item.checked === "restore" ? "batch does not take restore: it is refused while its parent is archived, and a batch cannot report that after it commits. Use tx()." : "batch does not take a write with expect: the count is checked after the statement ran, and a batch cannot report that after it commits. Use tx().");
+      }
+      prepared.push(item);
+    }
+    return await run(session, prepared, record);
+  } catch (error) {
+    return settleCall(session, error);
+  }
+}
+async function run(session, prepared, options) {
+  await session.connected;
+  const statements = [];
+  const starts = [];
+  for (const item of prepared) {
+    starts.push(statements.length);
+    statements.push(...item.statements);
+  }
+  if (statements.length === 0)
+    return prepared.map((item) => item.finish([]));
+  let results;
+  try {
+    results = await runWrite(session, statements, call(options), true);
+  } catch (error) {
+    throw at(error, starts);
+  }
+  return prepared.map((item, index) => {
+    const from = starts[index] ?? 0;
+    return item.finish(results.slice(from, from + item.statements.length));
+  });
+}
+function call(options) {
+  const { signal, timeout } = options;
+  if (signal === undefined && timeout === undefined)
+    return;
+  return {
+    ...signal !== undefined ? { signal } : {},
+    ...typeof timeout === "number" ? { timeout } : {}
+  };
+}
+function at(error, starts) {
+  const failed = error?.batchIndex;
+  const move = error?.at;
+  if (typeof failed !== "number" || typeof move !== "function")
+    return error;
+  let index = 0;
+  while (index + 1 < starts.length && (starts[index + 1] ?? Infinity) <= failed)
+    index += 1;
+  return index === failed ? error : move.call(error, index);
+}
+export {
+  batch
+};