okmodel 0.1.1 → 0.3.0

package/dist/shared/672t5vym.js

@@ -0,0 +1,12 @@
+import {
+  tag
+} from "./cn0n68ft.js";
+
+// src/runtime/preset-stack.ts
+function stack(where, presets) {
+  if (presets === undefined || presets.length === 0)
+    return where;
+  return tag("and", where === undefined ? presets : [where, ...presets]);
+}
+
+export { stack };

package/dist/shared/6bazvqwm.js

@@ -0,0 +1,86 @@
+import {
+  send,
+  connectClient
+} from "./bqha5cg6.js";
+import {
+  isConnectionLost
+} from "./tbszx8mz.js";
+import {
+  WireSession
+} from "./0jc3ffzf.js";
+import {
+  rejectClosed,
+  runCall
+} from "./rrstp3kb.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/6w5j844a.js

@@ -0,0 +1,201 @@
+import {
+  callerLocation,
+  withLocation
+} from "./k7dwkhvq.js";
+import {
+  definition,
+  unavailable
+} from "./tmbdywx0.js";
+import {
+  OkmError2,
+  throwNamed2
+} from "./52szzakm.js";
+
+// src/dialects/pg/filters.ts
+function openFilters(table, relations, spec, hiddenFields) {
+  const allow = spec.allow ?? {};
+  const sort = spec.sort ?? [];
+  for (const field of Object.keys(allow))
+    deny(hiddenFields, table, field);
+  for (const field of sort)
+    deny(hiddenFields, table, field);
+  const nested = spec.relations;
+  if (nested !== undefined) {
+    for (const name of Object.keys(nested)) {
+      const target = relationTable(relations, name);
+      for (const field of nested[name] ?? [])
+        deny(hiddenFields, target, field);
+    }
+  }
+  return {
+    parse(query) {
+      return import("./0v1g424p.js").then((mod) => mod.parseQuery(allow, sort, query));
+    }
+  };
+}
+function deny(hiddenFields, table, field) {
+  if (!hiddenFields.has(`${table}.${field}`))
+    return;
+  throw new OkmError2("OKM1123", `Field ${table}.${field} is hidden.`, {
+    fix: {
+      summary: "Remove the hidden field from the allowlist. Hidden fields stay out of caller filters and sorts."
+    }
+  });
+}
+function relationTable(relations, name) {
+  if (typeof relations !== "object" || relations === null)
+    return name;
+  const call = relations[name];
+  if (typeof call !== "object" || call === null || !("table" in call))
+    return name;
+  const table = call.table;
+  return typeof table === "string" ? table : name;
+}
+
+// src/dialects/pg/table.ts
+var TABLE_KNOWN = new Set([
+  "checks",
+  "comment",
+  "indexes",
+  "omitDefaults",
+  "presets",
+  "primaryKey",
+  "relations",
+  "renamedFrom",
+  "sqlName",
+  "tenancy",
+  "traits",
+  "unique",
+  "validate",
+  "validation"
+]);
+var TABLE_LATER = {
+  computed: "later",
+  policies: "later",
+  reference: "0.4"
+};
+function table2(name, columns, options) {
+  const source = callerLocation(1);
+  if (name.length === 0) {
+    definition(withLocation("table() needs a name.", source));
+  }
+  if (options !== undefined) {
+    rejectLater(options, TABLE_KNOWN, TABLE_LATER, `Table ${name}`);
+  }
+  remember(name, columns);
+  return {
+    name,
+    columns,
+    filters(spec) {
+      return openFilters(name, options?.relations, spec, hiddenFields);
+    },
+    ...options !== undefined ? { options } : {},
+    ...source !== undefined ? { source } : {}
+  };
+}
+function index2(...columns) {
+  return indexCall(columns.map((column) => column.name), false);
+}
+function sql2(strings, ...values) {
+  let text = strings[0] ?? "";
+  for (let index = 0;index < values.length; index += 1) {
+    text += sqlValue(values[index]);
+    text += strings[index + 1] ?? "";
+  }
+  return { text };
+}
+function snakeCase(name) {
+  let out = "";
+  for (let index = 0;index < name.length; index += 1) {
+    const char = name[index] ?? "";
+    const lower = char.toLowerCase();
+    if (lower !== char && char.toUpperCase() === char && out.length > 0 && !out.endsWith("_")) {
+      out += "_";
+    }
+    out += lower;
+  }
+  return out;
+}
+function emittedTypeName(name) {
+  let out = "";
+  let capitalize = true;
+  for (const char of name) {
+    const letter = char >= "a" && char <= "z" || char >= "A" && char <= "Z";
+    const digit = char >= "0" && char <= "9";
+    if (!letter && !digit) {
+      capitalize = true;
+      continue;
+    }
+    if (capitalize && letter) {
+      out += char.toUpperCase();
+      capitalize = false;
+      continue;
+    }
+    out += char;
+    capitalize = false;
+  }
+  if (out.length === 0) {
+    return "Table";
+  }
+  const first = out[0] ?? "";
+  if (first >= "0" && first <= "9") {
+    return `T${out}`;
+  }
+  return out;
+}
+function rejectLater(options, known, later, where) {
+  const record = options;
+  for (const key of Object.keys(record)) {
+    const prompt = later[key];
+    if (prompt !== undefined) {
+      if (record[key] !== undefined) {
+        const when = prompt === "later" ? "later" : `in ${prompt}`;
+        unavailable(`${where} option ${key} is not available yet. It arrives ${when}.`);
+      }
+      continue;
+    }
+    if (!known.has(key)) {
+      const accepted = [...known].sort().join(", ");
+      const candidates = [...known, ...Object.keys(later)];
+      throwNamed2("OKM1060", key, candidates, `${where} option ${key} is not supported. Accepted options: ${accepted}.`);
+    }
+  }
+}
+function indexCall(columns, isUnique, predicate) {
+  return {
+    columns,
+    isUnique,
+    ...predicate !== undefined ? { predicate } : {},
+    unique() {
+      return indexCall(columns, true, predicate);
+    }
+  };
+}
+function sqlValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (value === null || value === undefined) {
+    return "null";
+  }
+  if ("text" in value && typeof value.text === "string") {
+    return value.text;
+  }
+  if ("name" in value && typeof value.name === "string") {
+    return value.name;
+  }
+  definition("sql accepts a column, a string, a number, a boolean, or null.");
+}
+var hiddenFields = new Set;
+function remember(name, columns) {
+  for (const field of Object.keys(columns)) {
+    const column = columns[field];
+    if (column?.state?.hidden === true)
+      hiddenFields.add(`${name}.${field}`);
+  }
+}
+
+export { table2, index2, sql2, snakeCase, emittedTypeName, rejectLater };

package/dist/shared/{fgqgsb5z.js → 75xkjv0t.js}

@@ -9,7 +9,7 @@ import {
   runCall,
   EMPTY_NOTICES,
   resultFrom
-} from "./xy79j5hq.js";
+} from "./rrstp3kb.js";
 
 // src/adapters/pg/pglite.ts
 import { PGlite } from "@electric-sql/pglite";
@@ -48,7 +48,7 @@ async function open3(config = {}) {
     return {
       execute: (text, params, options) => runCall(closed, options, (watch) => session.query(text, params, watch)),
       batch: (statements, options) => runCall(closed, options, async (watch) => {
-        const { runAtomicBatch } = await import("./dynq16vb.js");
+        const { runAtomicBatch } = await import("./b066g80h.js");
         return runAtomicBatch(session, statements, watch);
       }),
       async release() {

package/dist/shared/7fvtrkwr.js

@@ -0,0 +1,84 @@
+import {
+  extensionObject
+} from "./th14ygv2.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/ext/index.ts
+function extension2(name, options = {}) {
+  const schema = options.schema ?? "public";
+  const relocatable = options.relocatable ?? true;
+  const version = options.version;
+  const record = extensionObject({
+    name,
+    schema,
+    relocatable,
+    ...version !== undefined ? { version } : {},
+    provenance: { origin: "extension", name }
+  });
+  return {
+    name,
+    schema,
+    relocatable,
+    ...version !== undefined ? { version } : {},
+    contribute(peers, built) {
+      const names = peerNames(peers);
+      assertDeclared(names, built);
+      return [record];
+    }
+  };
+}
+function peerNames(peers) {
+  if (!Array.isArray(peers)) {
+    extensionError("OKM1810", "schema({ extensions }) must be a list of extensions.");
+  }
+  const counts = new Map;
+  for (const peer of peers) {
+    if (!isPeer(peer)) {
+      extensionError("OKM1810", "schema({ extensions }) must be a list of extensions.");
+    }
+    counts.set(peer.name, (counts.get(peer.name) ?? 0) + 1);
+  }
+  for (const [name, count] of counts) {
+    if (count > 1)
+      extensionError("OKM1813", `Extension ${name} is defined twice.`);
+  }
+  return counts;
+}
+function assertDeclared(names, built) {
+  if (!Array.isArray(built))
+    return;
+  for (const object of built) {
+    if (typeof object !== "object" || object === null || !("dependencies" in object))
+      continue;
+    const dependencies = object.dependencies;
+    if (!Array.isArray(dependencies))
+      continue;
+    for (const edge of dependencies) {
+      if (typeof edge !== "object" || edge === null || !("target" in edge))
+        continue;
+      const target = edge.target;
+      if (typeof target !== "object" || target === null)
+        continue;
+      if (!("kind" in target) || !("name" in target))
+        continue;
+      if (target.kind === "extension" && typeof target.name === "string" && !names.has(target.name)) {
+        extensionError("OKM1810", `Extension ${target.name} is used but not declared.`);
+      }
+    }
+  }
+}
+function isPeer(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (!("name" in value) || !("contribute" in value))
+    return false;
+  return typeof value.name === "string" && value.name.length > 0 && typeof value.contribute === "function";
+}
+function extensionError(code, message) {
+  const summary = code === "OKM1813" ? "Keep one definition. A second copy fails at build." : "Declare the extension next to the schema that uses it.";
+  throw new OkmError2(code, message, { fix: { summary } });
+}
+
+export { extension2 };

package/dist/shared/7m88x3e9.js

@@ -0,0 +1,45 @@
+// src/runtime/trait-read.ts
+function touchFields(model) {
+  const traits = model.traits;
+  if (traits === undefined)
+    return;
+  const names = [];
+  for (const trait of traits) {
+    const touch = trait.touch;
+    if (touch === undefined)
+      continue;
+    for (const field of touch)
+      names.push(field);
+  }
+  return names.length === 0 ? undefined : names;
+}
+function fieldSealed(model, field) {
+  const traits = model.traits;
+  if (traits === undefined)
+    return false;
+  for (const trait of traits) {
+    const sealed = trait.sealed;
+    if (sealed === undefined)
+      continue;
+    for (const name of sealed)
+      if (name === field)
+        return true;
+  }
+  return false;
+}
+function sealingTrait(model, field) {
+  const traits = model.traits;
+  if (traits === undefined)
+    return;
+  for (const trait of traits) {
+    const sealed = trait.sealed;
+    if (sealed === undefined)
+      continue;
+    for (const name of sealed)
+      if (name === field)
+        return trait.name;
+  }
+  return;
+}
+
+export { touchFields, fieldSealed, sealingTrait };

package/dist/shared/{mtkwv8wx.js → 7p2wbz7f.js}

@@ -6,7 +6,7 @@ import {
   acquireTimeout2,
   errorField2,
   mapDriverError2
-} from "./hd293j9g.js";
+} from "./kyxb62mc.js";
 export {
   DriverError2 as DriverError,
   acquireTimeout2 as acquireTimeout,

package/dist/shared/83eaefwr.js

@@ -0,0 +1,10 @@
+import {
+  VALIDATION_NOT_IMPORTED2,
+  VALIDATION_NOT_IMPORTED_FIX2,
+  refuseMissingValidation2
+} from "./n442h54c.js";
+export {
+  VALIDATION_NOT_IMPORTED2 as VALIDATION_NOT_IMPORTED,
+  VALIDATION_NOT_IMPORTED_FIX2 as VALIDATION_NOT_IMPORTED_FIX,
+  refuseMissingValidation2 as refuseMissingValidation
+};

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/96ps4g1z.js

@@ -0,0 +1,32 @@
+// src/runtime/hookm.ts
+function notices(hookm, notices) {
+  if (hookm === undefined)
+    return;
+  for (const notice of notices) {
+    for (const hook of hookm)
+      call(() => hook.onNotice?.(notice));
+  }
+}
+function phase(hookm, phase, depth) {
+  if (hookm === undefined)
+    return;
+  const event = { phase, depth };
+  for (const hook of hookm)
+    call(() => hook.onTransaction?.(event));
+}
+function report(session, error) {
+  for (const hook of session.hookm ?? [])
+    call(() => hook.onError?.(error));
+  const entry = error instanceof Error ? { code: "code" in error ? String(error.code) : error.name, summary: error.message } : { code: "error", summary: String(error) };
+  call(() => session.logger?.error?.(entry));
+}
+function call(fn) {
+  try {
+    fn();
+  } catch {}
+}
+export {
+  notices,
+  phase,
+  report
+};

package/dist/shared/{xqbhg6cn.js → 999ade2q.js}

@@ -1,13 +1,17 @@
 import {
   PgSession
-} from "./dkn3y60a.js";
+} from "./xw1d69vd.js";
+import {
+  isConnectionLost
+} from "./tbszx8mz.js";
 import {
   driverErrors,
   rejectClosed,
   mapFailure,
   runCall,
-  rowsFrom
-} from "./xy79j5hq.js";
+  rowsFrom,
+  resultFrom
+} from "./rrstp3kb.js";
 
 // src/adapters/pg/postgres-extra.ts
 var RESET_ALL = "RESET ALL";
@@ -20,12 +24,18 @@ async function checkout(pool) {
   const local = new Set;
   const session = new PgSession(reserved, pool.counters, "reserved", local, pool.isClosed, pool.poolInflight, pool.notices, pool.named);
   let released = false;
+  let lost = false;
+  const guard = (run) => lost ? rejectClosed("The connection was lost.") : run().catch((error) => {
+    if (isConnectionLost(error))
+      lost = true;
+    throw error;
+  });
   return {
-    execute: (text, params, options) => runCall(pool.isClosed(), options, (watch) => session.query(text, params, watch)),
-    batch: (statements, options) => runCall(pool.isClosed(), options, async (watch) => {
-      const { runAtomicBatch } = await import("./dynq16vb.js");
+    execute: (text, params, options) => guard(() => runCall(pool.isClosed(), options, (watch) => session.query(text, params, watch))),
+    batch: (statements, options) => guard(() => runCall(pool.isClosed(), options, async (watch) => {
+      const { runAtomicBatch } = await import("./b066g80h.js");
       return runAtomicBatch(session, statements, watch);
-    }),
+    })),
     cancel() {
       session.cancel();
     },
@@ -34,10 +44,12 @@ async function checkout(pool) {
         return;
       released = true;
       try {
-        await resetConnection(reserved, session.depth());
+        if (!lost)
+          await resetConnection(reserved, session.depth());
       } finally {
         pool.counters.reserved = Math.max(0, pool.counters.reserved - 1);
-        reserved.release();
+        if (!lost)
+          reserved.release();
       }
     }
   };
@@ -112,8 +124,81 @@ function asParams(params) {
     return [];
   return params;
 }
+async function holdCheckout(gate, checkout) {
+  try {
+    const connection = await checkout();
+    let released = false;
+    const release = connection.release.bind(connection);
+    connection.release = () => {
+      if (released)
+        return Promise.resolve();
+      released = true;
+      return release().finally(() => {
+        gate.leave();
+      });
+    };
+    return connection;
+  } catch (error) {
+    gate.leave();
+    throw error;
+  }
+}
+async function holdListener(gate, start) {
+  try {
+    const stop = await start();
+    let stopped = false;
+    return async () => {
+      if (stopped)
+        return;
+      stopped = true;
+      try {
+        await stop();
+      } finally {
+        gate.leave();
+      }
+    };
+  } catch (error) {
+    gate.leave();
+    throw error;
+  }
+}
+function watchQuery(pending, watch, onAbort, ctx) {
+  return pending.then((result) => {
+    finishWatch(pending, watch, onAbort, ctx);
+    const why = watch.reason();
+    if (why === "timeout" || why === "cancelled")
+      return classify(why, watch);
+    ctx.note(ctx.text);
+    return resultFrom(result, ctx.notices.since(ctx.start));
+  }, (error) => {
+    finishWatch(pending, watch, onAbort, ctx);
+    return classify(error, watch);
+  });
+}
+function finishWatch(pending, watch, onAbort, ctx) {
+  ctx.leave();
+  ctx.untrack(pending);
+  watch.signal.removeEventListener("abort", onAbort);
+}
+async function classify(error, watch) {
+  const errors = await driverErrors();
+  if (error instanceof errors.DriverError)
+    return Promise.reject(error);
+  const why = typeof error === "string" ? error : watch.reason();
+  if (why === "timeout") {
+    return Promise.reject(errors.timedOut(typeof error === "string" ? undefined : error));
+  }
+  const code = errors.errorField(error, "code");
+  if (why === "cancelled" || code === "57014") {
+    return Promise.reject(errors.cancelled(typeof error === "string" ? undefined : error));
+  }
+  return Promise.reject(errors.mapDriverError(error));
+}
 export {
   checkout,
   describe,
-  stream
+  holdCheckout,
+  holdListener,
+  stream,
+  watchQuery
 };