okmodel 0.7.0 → 0.9.0

package/dist/tooling/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/tooling/shared/j664qjrt.js

@@ -0,0 +1,64 @@
+import {
+  decodeRows,
+  readHandle,
+  readCall,
+  attachHttp
+} from "./jr2nmr81.js";
+import {
+  OkmError,
+  throwNamed,
+  fail2
+} from "./hfq3n3bd.js";
+
+// src/runtime/lock.ts
+var LOCKS = ["update", "share"];
+var WAITS = ["nowait", "skip"];
+function shown(value) {
+  return typeof value === "string" ? value : JSON.stringify(value) ?? "undefined";
+}
+function build(session, table, options, mods, view) {
+  try {
+    return plan(session, table, options, mods, view);
+  } catch (error) {
+    throw error instanceof OkmError ? attachHttp(session.http, error) : error;
+  }
+}
+function plan(session, table, options, mods, view) {
+  const { lock, wait, ...rest } = options;
+  const forced = session.pool.forcedRoute;
+  if (rest.route === "replica" || forced === "replica") {
+    throw new OkmError("OKM1840", "A locking read needs the primary.", {
+      fix: {
+        summary: "Run the operation on the primary. Writes, batch, locks, and tx() never go to a replica."
+      }
+    });
+  }
+  if (lock === "skip") {
+    fail2("OKM1120", 'lock: "skip" claims rows on update. A read uses lock: "update" and wait: "skip".', 'Pass lock: "update" and wait: "skip" inside tx(). An update can claim rows on its own.');
+  }
+  if (session.tx === undefined) {
+    throw new OkmError("OKM1830", "A row lock needs a transaction. find was called outside tx().", {
+      fix: { summary: "Move the find into tx(): the lock lasts until the transaction ends." }
+    });
+  }
+  if (lock === undefined)
+    fail2("OKM1121", "wait needs lock: pass lock: update or lock: share.");
+  if (typeof lock !== "string" || !LOCKS.includes(lock)) {
+    throwNamed("OKM1120", shown(lock), LOCKS, `lock must be one of: ${LOCKS.join(", ")}.`);
+  }
+  if (wait !== undefined && (typeof wait !== "string" || !WAITS.includes(wait))) {
+    throwNamed("OKM1120", shown(wait), WAITS, `wait must be one of: ${WAITS.join(", ")}.`);
+  }
+  const clause = ` for ${lock} of t${wait === undefined ? "" : wait === "skip" ? " skip locked" : " nowait"}`;
+  const call = {
+    ...readCall("find", table, rest, mods.all, session.scope, session.schema.model[table], session.schema, view),
+    tail(sink) {
+      sink.text(clause);
+      sink.mark(`lock:${clause}`);
+    }
+  };
+  return readHandle(session, table, call, mods, (compiled, rows) => decodeRows(compiled, rows, table));
+}
+export {
+  build
+};

package/dist/tooling/shared/jpgmjsx3.js

@@ -0,0 +1,38 @@
+import {
+  WRITE_PARAM_BUDGET2,
+  executeWrite2,
+  explainWrite2,
+  updateSliceBody2,
+  rejectDuplicateTargets2,
+  emitSet2,
+  Sql2,
+  writeSet2,
+  rejectMixedSets2,
+  readClaim2,
+  rejectUpdateKeys2,
+  requireFilter2,
+  returningOption2,
+  expectOf2,
+  allowSet2,
+  noteGuarded2
+} from "./ezqn88nj.js";
+import"./w5d89rb4.js";
+import"./35zemrmf.js";
+export {
+  Sql2 as Sql,
+  WRITE_PARAM_BUDGET2 as WRITE_PARAM_BUDGET,
+  allowSet2 as allowSet,
+  emitSet2 as emitSet,
+  executeWrite2 as executeWrite,
+  expectOf2 as expectOf,
+  explainWrite2 as explainWrite,
+  noteGuarded2 as noteGuarded,
+  readClaim2 as readClaim,
+  rejectDuplicateTargets2 as rejectDuplicateTargets,
+  rejectMixedSets2 as rejectMixedSets,
+  rejectUpdateKeys2 as rejectUpdateKeys,
+  requireFilter2 as requireFilter,
+  returningOption2 as returningOption,
+  updateSliceBody2 as updateSliceBody,
+  writeSet2 as writeSet
+};

package/dist/tooling/shared/jr2nmr81.js

@@ -0,0 +1,497 @@
+import {
+  OkmError,
+  safe,
+  throwNamed,
+  archiveRules,
+  readOptionNames,
+  readNeedsOperatorSql,
+  bindCall,
+  compileCall,
+  decodeResult,
+  logicalIntent,
+  appliedRules,
+  rejectKeys
+} from "./hfq3n3bd.js";
+
+// src/runtime/client.ts
+var PLAN_LIMIT = 64;
+var SINGLE_ENDPOINT = {
+  endpoint: "primary",
+  role: "primary",
+  reason: "single-endpoint"
+};
+function createClient(schema, pool, options) {
+  const closing = {
+    current: undefined,
+    early: false
+  };
+  const checked = checkServer(pool, schema, options.http, options.requireMeta === true, callOptions(options), {
+    ...options.catalog !== undefined ? { catalog: options.catalog } : {},
+    ...options.catalogDir !== undefined ? { catalogDir: options.catalogDir } : {}
+  });
+  const connected = checked.catch((error) => {
+    if (!closing.early)
+      throw error;
+    throw new OkmError("unavailable", "The client was closed before it connected. Await connected before close(), or do not close it before use.", { kind: "unavailable", fix: { summary: "Await client.connected before calling close()." } });
+  });
+  connected.catch(() => {
+    return;
+  });
+  const session = {
+    schema,
+    pool,
+    ownsPool: options.ownsPool,
+    http: options.http,
+    includeValues: options.includeValues === true,
+    logger: options.logger,
+    connected,
+    cache: new Map,
+    generators: options.generators,
+    timeouts: options.timeouts,
+    hookm: options.hookm,
+    closing
+  };
+  return openClient(session);
+}
+function openClient(session) {
+  const names = Object.keys(session.schema.model);
+  const tables = {};
+  for (const name of names)
+    tables[name] = tableApi(session, name);
+  const close = () => {
+    if (!session.ownsPool)
+      return Promise.resolve();
+    session.closing.early = true;
+    session.closing.current ??= session.pool.close();
+    return session.closing.current;
+  };
+  const client = {
+    ...tables,
+    table(name) {
+      const found = tables[name];
+      if (found !== undefined)
+        return found;
+      try {
+        if (session.schema.model[name] !== undefined && session.schema.tenancy !== undefined && session.scope === undefined) {
+          session.schema.tenancy.missing(name);
+        }
+        throwNamed("OKM1120", name, names, `Table ${name} is not in the schema. Accepted names: ${names.join(", ")}.`);
+      } catch (error) {
+        if (error instanceof OkmError)
+          throw attachHttp(session.http, error);
+        throw error;
+      }
+    },
+    close,
+    connected: session.connected,
+    tx: (...args) => import("./stebqyyd.js").then((mod) => mod.tx(session, args)),
+    batch: (ops, options) => batchHandle(session, ops, options),
+    ...session.tx?.extras
+  };
+  const hooks = session.schema.hooks;
+  if (hooks !== undefined) {
+    for (const hook of hooks) {
+      hook(client, {
+        names,
+        tables,
+        scoped: session.scope !== undefined,
+        open: (scope) => openClient({ ...session, scope })
+      });
+    }
+  }
+  attachAsyncDispose(client, close);
+  return client;
+}
+function attachAsyncDispose(client, close) {
+  const symbol = Symbol.asyncDispose;
+  if (typeof symbol !== "symbol")
+    return;
+  Object.defineProperty(client, symbol, {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: () => close()
+  });
+}
+function tableApi(session, table, view, uses) {
+  const base = { uses };
+  const mods = { archive: view, uses };
+  const api = {
+    find(options = {}) {
+      if ("lock" in options) {
+        return lazyRead(session, () => import("./j664qjrt.js"), table, options, base, view);
+      }
+      return start(session, "find", table, options, base, view);
+    },
+    one(options = {}) {
+      return start(session, "one", table, options, base, view);
+    },
+    count(options = {}) {
+      return start(session, "count", table, options, base, view);
+    },
+    exists(options = {}) {
+      return start(session, "exists", table, options, base, view);
+    },
+    page(options) {
+      return lazyRead(session, () => import("./w17sj05d.js"), table, options, base, view);
+    },
+    aggregate(options = {}) {
+      return lazyRead(session, () => import("./7aews1zg.js"), table, options, base, view);
+    },
+    insert(data, options = {}) {
+      return writeHandle(session, "insert", table, data, options, mods);
+    },
+    update(target, options = {}) {
+      return writeHandle(session, "update", table, target, options, mods);
+    },
+    delete(target, options = {}) {
+      return writeHandle(session, "delete", table, target, options, mods);
+    }
+  };
+  for (const walk of ["descendants", "ancestors"]) {
+    api[walk] = (id, options) => lazyRead(session, () => import("./m4hhb8aa.js"), table, { id, walk, options }, base, view);
+  }
+  api.sync = (id, relation, ids, options) => lazyRead(session, () => import("./0r05zhyq.js"), table, { id, relation, ids, options }, base, view, true);
+  const hooks = session.schema.hooks;
+  if (hooks !== undefined) {
+    for (const hook of hooks) {
+      hook(api, {
+        table,
+        ...view !== undefined ? { view } : {},
+        uses,
+        reopen: (next) => tableApi(session, table, next, uses),
+        session
+      });
+    }
+  }
+  for (const name in session.schema.model[table]?.presets) {
+    api[name] = (...args) => tableApi(session, table, view, [uses, name, args]);
+  }
+  api[Symbol.for("okm.lane")] = [session, table, mapError];
+  return api;
+}
+function batchHandle(session, ops, options, replica) {
+  return queryHandle(() => import("./shjs0379.js").then((mod) => mod.batch(session, ops, options, replica)), {
+    replica: () => batchHandle(session, ops, options, true)
+  });
+}
+var writers;
+function loadWrite() {
+  writers ??= import("./jpgmjsx3.js");
+  return writers;
+}
+function queryHandle(run, extra) {
+  let pending;
+  const once = () => {
+    pending ??= run();
+    return pending;
+  };
+  const self = {
+    then(onFulfilled, onRejected) {
+      return once().then(onFulfilled, onRejected);
+    },
+    catch(onRejected) {
+      return self.then(undefined, onRejected);
+    },
+    finally(fn) {
+      return self.then((value) => {
+        fn();
+        return value;
+      }, (error) => {
+        fn();
+        throw error;
+      });
+    },
+    safe() {
+      return safe(once());
+    },
+    ...extra
+  };
+  return self;
+}
+function writeHandle(session, op, table, input, options, mods) {
+  return queryHandle(() => runWrite(session, op, table, input, options, mods), {
+    "~plan": () => runWrite(session, op, table, input, options, mods, true),
+    sql() {
+      return loadWrite().then((mod) => mod.explainWrite(session.schema, op, table, input, options, mods, session.generators, session.scope));
+    },
+    expect(count) {
+      return writeHandle(session, op, table, input, options, { ...mods, expect: count });
+    },
+    all(reason) {
+      return writeHandle(session, op, table, input, options, { ...mods, all: reason });
+    }
+  });
+}
+async function runWrite(session, op, table, input, options, mods, plan) {
+  await session.connected;
+  const mod = await loadWrite();
+  try {
+    return await mod.executeWrite(session, op, table, input, options, mods, session.scope, plan);
+  } catch (error) {
+    throw logged(session, await mapError(session, error));
+  }
+}
+function rejectedRead(error) {
+  const fail = () => Promise.reject(error);
+  return queryHandle(fail, {
+    all: () => rejectedRead(error),
+    required: () => rejectedRead(error),
+    inspect: fail,
+    sql: fail,
+    stream() {
+      return {
+        [Symbol.asyncIterator]() {
+          return { next: fail };
+        }
+      };
+    }
+  });
+}
+function start(session, op, table, options, mods, view) {
+  const model = session.schema.model[table];
+  let call;
+  try {
+    call = readCall(op, table, options, mods.all, session.scope, model, session.schema, view);
+  } catch (error) {
+    return rejectedRead(error instanceof OkmError ? attachHttp(session.http, error) : error);
+  }
+  return readHandle(session, table, call, mods, async (plan, rows) => {
+    const value = await decodeRows(plan, rows, table);
+    if (mods.required === true && value === null) {
+      throw new OkmError("not_found", `one() on ${table} matched no row.`, withHttp(session.http, { kind: "not_found", table }));
+    }
+    return value;
+  }, () => ({
+    all(reason) {
+      return start(session, op, table, options, { ...mods, all: reason }, view);
+    },
+    required() {
+      return start(session, op, table, options, { ...mods, required: true }, view);
+    },
+    stream(batch) {
+      return streamLazy(session, call, mods, view, batch);
+    }
+  }));
+}
+function lazyRead(session, load, table, options, mods, view, sync) {
+  const read = () => load().then((mod) => ({ it: mod.build(session, table, options, mods, view) }));
+  const sql = () => read().then((box) => box.it.sql());
+  const extra = { sql };
+  if (sync) {
+    extra.expect = (count) => lazyRead(session, load, table, options, { ...mods, expect: count }, view, true);
+  } else {
+    extra.inspect = () => read().then((box) => box.it.inspect());
+    extra.all = (reason) => lazyRead(session, load, table, options, { ...mods, all: reason }, view);
+  }
+  return queryHandle(() => read().then((box) => box.it), extra);
+}
+async function decodeRows(plan, rows, table) {
+  return plan.outputs.includes.length === 0 ? decodeResult(plan, rows, table) : (await import("./ytk1tjs0.js")).decodeIncluded(plan, rows, table);
+}
+function readHandle(session, table, call, mods, decode, extra) {
+  let prepared;
+  const origin = call;
+  const searched = "search" in call;
+  const prepare = async () => {
+    if (prepared !== undefined)
+      return prepared;
+    if (mods.uses !== undefined) {
+      call = (await import("./5bmksndh.js")).refine(session.schema, origin, mods.uses);
+    }
+    if (searched) {
+      call = (await import("./wbwq1jsa.js")).applyTextSearch(session.schema, call);
+    }
+    const hooks = await hooksFor(call);
+    if (readNeedsOperatorSql(session.schema, call) || hooks?.needsOperator(session.schema, call)) {
+      await loadOperatorSql();
+    }
+    if (call.build === undefined && selectHasWindow(call.select)) {
+      call = (await import("./c0xevn1h.js")).attach(session.schema, call);
+    }
+    const bound = bindCall(session.schema, call, hooks);
+    let plan = session.cache.get(bound.key);
+    if (plan === undefined) {
+      plan = compileCall(session.schema, call, bound.key, hooks);
+      if (session.cache.size >= PLAN_LIMIT) {
+        const oldest = session.cache.keys().next().value;
+        if (oldest !== undefined)
+          session.cache.delete(oldest);
+      }
+      session.cache.set(bound.key, plan);
+    }
+    prepared = { plan, params: bound.params };
+    return prepared;
+  };
+  const sync = () => !searched && call.include === undefined && mods.uses === undefined && !selectHasWindow(call.select) && !readNeedsOperatorSql(session.schema, call);
+  const run = async () => {
+    await session.connected;
+    const { plan, params } = await prepare();
+    try {
+      const result = await session.pool.execute(plan.text, params, callOptions(call, session.timeouts?.statement));
+      if (session.hookm && result.notices.length) {
+        import("./96ps4g1z.js").then((mod) => mod.notices(session.hookm, result.notices));
+      }
+      return await decode(plan, result.rows);
+    } catch (error) {
+      const mapped = await mapError(session, error);
+      if (session.schema.model[table]?.conceal !== true)
+        throw logged(session, mapped);
+      const { scrubCall } = await import("./tpssp7ac.js");
+      throw logged(session, scrubCall(mapped, session.schema, call));
+    }
+  };
+  return queryHandle(run, {
+    inspect() {
+      const source = session.schema.model[table]?.source;
+      if (call.include === undefined && prepared !== undefined) {
+        return finish(session, inspection(prepared.plan, prepared.params, call, source), call);
+      }
+      if (sync()) {
+        const bound = bindNow(session.schema, call);
+        prepared = bound;
+        return finish(session, inspection(bound.plan, bound.params, call, source), call);
+      }
+      return prepare().then(({ plan, params }) => finish(session, inspection(plan, params, call, source), call));
+    },
+    sql() {
+      if (call.include === undefined && prepared !== undefined) {
+        return { text: prepared.plan.text, params: prepared.params };
+      }
+      if (sync()) {
+        const { plan, params } = bindNow(session.schema, call);
+        prepared = { plan, params };
+        return { text: plan.text, params };
+      }
+      return prepare().then(({ plan, params }) => ({ text: plan.text, params }));
+    },
+    ...extra?.(prepare)
+  });
+}
+function streamLazy(session, call, mods, view, batch) {
+  return async function* () {
+    const { streamRows } = await import("./yhp829bx.js");
+    yield* streamRows(session, call, mods, view, batch, (error) => logged(session, error));
+  }();
+}
+function archiveRecord(model, view) {
+  if (model?.archive === undefined)
+    return;
+  const rules = archiveRules(model, view);
+  if (rules === undefined)
+    return;
+  return { ruleLines: rules };
+}
+function readCall(op, table, options, all, scope, model, schema, view) {
+  const record = options;
+  rejectKeys(record, readOptionNames(op), op, true);
+  return {
+    op,
+    table,
+    ...record.where !== undefined ? { where: record.where } : {},
+    ...record.select !== undefined ? { select: record.select } : {},
+    ...record.orderBy !== undefined ? { orderBy: record.orderBy } : {},
+    ...record.limit !== undefined ? { limit: record.limit } : {},
+    ...record.include !== undefined ? { include: record.include } : {},
+    ..."search" in record ? { search: record.search } : {},
+    ...callOptions(record),
+    ...all !== undefined ? { all } : {},
+    ...scope !== undefined ? { scope } : {},
+    ...schema.tenancy !== undefined && model !== undefined ? { tenancyRules: schema.tenancy.rules(table, model.source, scope) } : {},
+    ...view !== undefined ? { archive: view } : {},
+    ...archiveRecord(model, view)
+  };
+}
+async function checkServer(pool, schema, http, requireMeta, options, source) {
+  const { acceptServer } = await import("./76pv6qff.js");
+  await acceptServer(pool, schema, http, requireMeta, options, source);
+}
+async function mapError(session, error) {
+  if (error instanceof OkmError) {
+    return session.http === undefined ? error : new OkmError(error.code, error.message, { ...errorFields(error), http: session.http });
+  }
+  const { mapPostgresError } = await import("./yfedr1zb.js");
+  return mapPostgresError(error, mapOptions(session.http, session.includeValues, session.schema));
+}
+function errorFields(error) {
+  return {
+    kind: error.kind,
+    ...error.table !== undefined ? { table: error.table } : {},
+    ...error.columns.length > 0 ? { columns: error.columns } : {},
+    fix: error.fix
+  };
+}
+var includeHooks;
+var operatorSql;
+function loadOperatorSql() {
+  operatorSql ??= import("./7b3xp9gc.js").then(() => {
+    return;
+  });
+  return operatorSql;
+}
+function selectHasWindow(select) {
+  return Array.isArray(select) && select.some((item) => typeof item !== "string");
+}
+function hooksFor(call) {
+  if (call.include === undefined)
+    return Promise.resolve(undefined);
+  includeHooks ??= import("./ytk1tjs0.js").then((mod) => mod.includeHooks);
+  return includeHooks;
+}
+function bindNow(schema, call) {
+  const bound = bindCall(schema, call);
+  const plan = compileCall(schema, call, bound.key);
+  return { plan, params: bound.params };
+}
+function finish(session, view, call) {
+  if (session.schema.model[call.table]?.conceal !== true)
+    return view;
+  return import("./tpssp7ac.js").then((mod) => mod.redactView(session.schema, view, call));
+}
+function inspection(plan, params, call, source) {
+  return {
+    intent: logicalIntent(call),
+    rules: appliedRules(call, source),
+    plan: { strategy: "postgres:single-statement", statements: 1, fingerprint: plan.fingerprint },
+    sql: { text: plan.text, params },
+    routing: SINGLE_ENDPOINT
+  };
+}
+function withHttp(http, options) {
+  return http === undefined ? options : { ...options, http };
+}
+function attachHttp(http, error) {
+  if (http === undefined)
+    return error;
+  return new OkmError(error.code, error.message, { ...errorFields(error), http });
+}
+function callOptions(input, statement) {
+  const timeout = input.timeout ?? statement;
+  const route = input.route;
+  const pin = input.pin;
+  if (input.signal === undefined && timeout === undefined && route === undefined && pin === undefined) {
+    return;
+  }
+  return {
+    ...input.signal !== undefined ? { signal: input.signal } : {},
+    ...timeout !== undefined ? { timeout } : {},
+    ...route !== undefined ? { route } : {},
+    ...pin !== undefined ? { pin } : {}
+  };
+}
+function mapOptions(http, includeValues, schema) {
+  return {
+    ...http !== undefined ? { http } : {},
+    ...includeValues ? { includeValues: true } : {},
+    schema
+  };
+}
+async function settleCall(session, error) {
+  throw logged(session, await mapError(session, error));
+}
+function logged(session, error) {
+  session.logger?.error?.({ code: error.code, summary: error.summary });
+  return error;
+}
+
+export { createClient, openClient, queryHandle, decodeRows, readHandle, readCall, withHttp, attachHttp, mapOptions, settleCall };