okmodel 0.6.0 → 0.8.0

package/dist/tooling/shared/j9t5s12a.js

@@ -0,0 +1,7 @@
+import {
+  build3
+} from "./zvnhh1n0.js";
+import"./mtrqn2hn.js";
+export {
+  build3 as build
+};

package/dist/tooling/shared/jne7b93p.js

@@ -0,0 +1,42 @@
+import {
+  open4
+} from "./417zdsk7.js";
+import {
+  createClient
+} from "./mtrqn2hn.js";
+
+// src/runtime/pg/pg.ts
+function connect(target, options) {
+  if (typeof target === "object" && !isPool(target)) {
+    return import("./2wtvc7rw.js").then((mod) => mod.default(target, options, open4));
+  }
+  const owned = !isPool(target);
+  const pool = isPool(target) ? target : open4({
+    url: target,
+    ...options.max !== undefined ? { max: options.max } : {},
+    ...options.timeouts !== undefined ? { timeouts: options.timeouts } : {},
+    ...options.prepared !== undefined ? { prepared: options.prepared } : {},
+    ...options.searchPath !== undefined ? { searchPath: options.searchPath } : {},
+    ...options.ssl !== undefined ? { ssl: options.ssl } : {}
+  });
+  return createClient(options.schema, pool, {
+    ownsPool: owned,
+    http: options.errors?.http,
+    includeValues: options.errors?.includeValues,
+    logger: options.logger,
+    signal: options.signal,
+    timeout: options.timeout,
+    timeouts: options.timeouts,
+    hookm: options.hookm,
+    catalog: options.catalog,
+    catalogDir: options.catalogDir,
+    requireMeta: options.requireMeta,
+    generators: options.generators
+  });
+}
+function isPool(target) {
+  return typeof target === "object" && "execute" in target && "capabilities" in target;
+}
+export {
+  connect
+};

package/dist/tooling/shared/ma2340rx.js

@@ -0,0 +1,118 @@
+import {
+  stack2
+} from "./cmptmb4f.js";
+import {
+  OkmError,
+  isOperator,
+  operatorValue
+} from "./f9mphxej.js";
+
+// src/dialects/pg/preset.ts
+var RESERVED_PRESETS = new Set([
+  "find",
+  "one",
+  "page",
+  "aggregate",
+  "count",
+  "exists",
+  "insert",
+  "update",
+  "delete",
+  "descendants",
+  "ancestors",
+  "sync",
+  "archive",
+  "restore",
+  "withArchived",
+  "onlyArchived",
+  "then",
+  "lock",
+  "watch",
+  "subscribe",
+  "stream",
+  "inspect",
+  "explain",
+  "with",
+  "for",
+  "as"
+]);
+function checkPresetNames(names, where) {
+  for (const name of names) {
+    if (!RESERVED_PRESETS.has(name))
+      continue;
+    throw new OkmError("OKM1040", `Preset ${name} on ${where} is a client method or a reserved name. Reserved: ${[...RESERVED_PRESETS].join(", ")}.`, { fix: { summary: `Rename the preset ${name}.` } });
+  }
+}
+
+// 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 OkmError("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 OkmError("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: stack2(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/tooling/shared/mtrqn2hn.js

@@ -0,0 +1,505 @@
+import {
+  OkmError,
+  safe,
+  throwNamed,
+  archiveRules,
+  readOptionNames,
+  readNeedsOperatorSql,
+  bindCall,
+  compileCall,
+  decodeResult,
+  logicalIntent,
+  appliedRules,
+  rejectKeys
+} from "./f9mphxej.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("./rq5kk8j6.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("./vs0t6qt8.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("./j9t5s12a.js"), table, options, base, view);
+    },
+    aggregate(options = {}) {
+      return lazyRead(session, () => import("./bz2dqhab.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("./dw08f3m8.js"), table, { id, walk, options }, base, view);
+  }
+  api.sync = (id, relation, ids, options) => lazyRead(session, () => import("./z8d7ptht.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("./vx86qjv8.js").then((mod) => mod.batch(session, ops, options, replica)), {
+    replica: () => batchHandle(session, ops, options, true)
+  });
+}
+var writers;
+function loadWrite() {
+  writers ??= import("./733a1tq3.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("./yfr8hzhm.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("./ma2340rx.js")).refine(session.schema, origin, mods.uses);
+    }
+    if (searched) {
+      call = (await import("./smn6kz1p.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("./pqy21k24.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("./72fyg4zv.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("./ddjtfgnx.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 server = await import("./pw8fgahx.js");
+  let rows;
+  try {
+    const result = await pool.execute(server.versionQuery, undefined, options);
+    rows = result.rows;
+  } catch (error) {
+    const { mapPostgresError } = await import("./ep8zh3bk.js");
+    throw mapPostgresError(error, mapOptions(http, false, schema));
+  }
+  await server.acceptServer(pool, schema, rows, 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("./ep8zh3bk.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("./9kazs5p6.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("./yfr8hzhm.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("./72fyg4zv.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, settleCall };

package/dist/tooling/shared/n4jqhpqz.js

@@ -0,0 +1,27 @@
+// src/runtime/tx.ts
+async function runWrite(host, statements, options, atomic) {
+  if (statements.length === 0)
+    return [];
+  const first = statements[0];
+  const limit = options?.timeout ?? host.timeouts?.statement;
+  const call = limit === undefined || limit === options?.timeout ? options : { ...options, timeout: limit };
+  const single = statements.length === 1 && first !== undefined && atomic === undefined;
+  const watched = host.hookm !== undefined && !single && host.tx === undefined ? await import("./96ps4g1z.js") : undefined;
+  watched?.phase(host.hookm, "start", 0);
+  let results;
+  try {
+    results = single ? [await host.pool.execute(first.text, first.params, call)] : await host.pool.batch(statements, call);
+  } catch (error) {
+    watched?.phase(host.hookm, "rollback", 0);
+    throw error;
+  }
+  watched?.phase(host.hookm, "commit", 0);
+  if (host.hookm !== undefined) {
+    const heard = results.flatMap((result) => result.notices);
+    if (heard.length > 0)
+      (await import("./96ps4g1z.js")).notices(host.hookm, heard);
+  }
+  return results;
+}
+
+export { runWrite };