okmodel 0.1.1 → 0.2.1

package/dist/shared/mxmcdsh5.js

@@ -0,0 +1,450 @@
+import {
+  archiveRules,
+  readOptionNames,
+  readNeedsOperatorSql,
+  bindCall,
+  compileCall,
+  decodeResult,
+  logicalIntent,
+  appliedRules
+} from "./xrfnq5k8.js";
+import {
+  OkmError2,
+  safe2,
+  throwNamed2
+} from "./52szzakm.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 connected = checkServer(pool, schema, options.http, options.requireMeta === true, callOptions(options), {
+    ...options.catalog !== undefined ? { catalog: options.catalog } : {},
+    ...options.catalogDir !== undefined ? { catalogDir: options.catalogDir } : {}
+  });
+  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: { current: undefined }
+  };
+  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.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);
+        }
+        throwNamed2("OKM1120", name, names, `Table ${name} is not in the schema. Accepted names: ${names.join(", ")}.`);
+      } catch (error) {
+        if (error instanceof OkmError2)
+          throw attachHttp(session.http, error);
+        throw error;
+      }
+    },
+    close,
+    connected: session.connected,
+    tx: (...args) => import("./g9f0zqce.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("./mrq77sgw.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("./e7a268fy.js"), table, options, base, view);
+    },
+    aggregate(options = {}) {
+      return lazyRead(session, () => import("./10tjenmd.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);
+    }
+  };
+  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]);
+  }
+  return api;
+}
+function batchHandle(session, ops, options, replica) {
+  return queryHandle(() => import("./v18jva5b.js").then((mod) => mod.batch(session, ops, options, replica)), {
+    replica: () => batchHandle(session, ops, options, true)
+  });
+}
+var writers;
+function loadWrite() {
+  writers ??= import("./4jzzghr6.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 safe2(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 start(session, op, table, options, mods, view) {
+  const model = session.schema.model[table];
+  const call = readCall(op, table, options, mods.all, session.scope, model, session.schema, view);
+  return readHandle(session, table, call, mods, async (plan, rows) => {
+    const value = await decodeRows(plan, rows, table);
+    if (mods.required === true && value === null) {
+      throw new OkmError2("not_found", `one() on ${table} matched no row.`, withHttp(session.http, { kind: "not_found", table }));
+    }
+    return value;
+  }, (prepare) => ({
+    all(reason) {
+      return start(session, op, table, options, { ...mods, all: reason }, view);
+    },
+    required() {
+      return start(session, op, table, options, { ...mods, required: true }, view);
+    },
+    stream() {
+      return streamLazy(session, call, prepare);
+    }
+  }));
+}
+function lazyRead(session, load, table, options, mods, view) {
+  const read = () => load().then((mod) => ({ it: mod.build(session, table, options, mods, view) }));
+  return queryHandle(() => read().then((box) => box.it), {
+    inspect: () => read().then((box) => box.it.inspect()),
+    sql: () => read().then((box) => box.it.sql()),
+    all: (reason) => lazyRead(session, load, table, options, { ...mods, all: reason }, view)
+  });
+}
+async function decodeRows(plan, rows, table) {
+  return plan.outputs.includes.length === 0 ? decodeResult(plan, rows, table) : (await import("./edwqqryd.js")).decodeIncluded(plan, rows, table);
+}
+function readHandle(session, table, call, mods, decode, extra) {
+  let prepared;
+  const origin = call;
+  const prepare = async () => {
+    if (prepared !== undefined)
+      return prepared;
+    if (mods.uses !== undefined) {
+      call = (await import("./r6nwkxnt.js")).refine(session.schema, origin, mods.uses);
+    }
+    if (readNeedsOperatorSql(session.schema, call))
+      await loadOperatorSql();
+    const hooks = await hooksFor(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 = () => call.include === undefined && mods.uses === undefined && !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("./e6wg00wd.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, prepare) {
+  return async function* () {
+    const { streamRows } = await import("./zd93g3rq.js");
+    yield* streamRows(session, call, prepare, (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;
+  const accepted = readOptionNames(op);
+  for (const key of Object.keys(record)) {
+    if (!accepted.includes(key)) {
+      throwNamed2("OKM1120", key, accepted, `Option ${key} is not accepted by ${op}. Accepted options: ${accepted.join(", ")}.`);
+    }
+  }
+  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 } : {},
+    ...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("./ge03bfca.js");
+  let rows;
+  try {
+    const result = await pool.execute(server.versionQuery, undefined, options);
+    rows = result.rows;
+  } catch (error) {
+    const { mapPostgresError } = await import("./s6gqfn5j.js");
+    throw mapPostgresError(error, mapOptions(http, false));
+  }
+  await server.acceptServer(pool, schema, rows, http, requireMeta, options, source);
+}
+async function mapError(session, error) {
+  if (error instanceof OkmError2) {
+    return session.http === undefined ? error : new OkmError2(error.code, error.message, { ...errorFields(error), http: session.http });
+  }
+  const { mapPostgresError } = await import("./s6gqfn5j.js");
+  return mapPostgresError(error, mapOptions(session.http, session.includeValues));
+}
+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("./4b9da9d7.js").then(() => {
+    return;
+  });
+  return operatorSql;
+}
+function hooksFor(call) {
+  if (call.include === undefined)
+    return Promise.resolve(undefined);
+  includeHooks ??= import("./edwqqryd.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("./e6wg00wd.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 OkmError2(error.code, error.message, { ...errorFields(error), http });
+}
+function callOptions(input, statement) {
+  const timeout = input.timeout ?? statement;
+  if (input.signal === undefined && timeout === undefined)
+    return;
+  return {
+    ...input.signal !== undefined ? { signal: input.signal } : {},
+    ...timeout !== undefined ? { timeout } : {}
+  };
+}
+function mapOptions(http, includeValues) {
+  return {
+    ...http !== undefined ? { http } : {},
+    ...includeValues ? { includeValues: true } : {}
+  };
+}
+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/shared/n442h54c.js

@@ -0,0 +1,14 @@
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/validate/closed.ts
+var VALIDATION_NOT_IMPORTED2 = "Validation is enabled but `okmodel/validate` was not imported.";
+var VALIDATION_NOT_IMPORTED_FIX2 = 'Import "okmodel/validate" before schema().';
+function refuseMissingValidation2() {
+  throw new OkmError2("OKM1201", VALIDATION_NOT_IMPORTED2, {
+    fix: { summary: VALIDATION_NOT_IMPORTED_FIX2 }
+  });
+}
+
+export { VALIDATION_NOT_IMPORTED2, VALIDATION_NOT_IMPORTED_FIX2, refuseMissingValidation2 };