okmodel 0.1.1 → 0.3.0

package/dist/shared/bqha5cg6.js

@@ -0,0 +1,229 @@
+import {
+  quoteIdent2,
+  noticeBuffer,
+  WireSession,
+  cursorStream
+} from "./0jc3ffzf.js";
+import {
+  NODE_POSTGRES_CAPABILITIES,
+  driverErrors,
+  rejectClosed,
+  mapFailure,
+  runCall
+} from "./rrstp3kb.js";
+
+// src/adapters/pg/nodepostgres.ts
+import net from "node:net";
+import pg from "pg";
+var CANCEL_CODE = 80877102;
+var identity = (value) => value;
+var WIRE = {
+  getTypeParser() {
+    return identity;
+  }
+};
+function open4(config) {
+  const max = config.max ?? 10;
+  const acquireMs = config.timeouts?.acquire;
+  const counters = { reserved: 0, busy: 0, reservedBusy: 0, waiting: 0 };
+  const inflight = new Set;
+  const notices = noticeBuffer();
+  let closed = false;
+  const isClosed = () => closed;
+  const named = config.prepared === "named";
+  const pool = new pg.Pool({
+    connectionString: config.url,
+    max,
+    idleTimeoutMillis: 0,
+    allowExitOnIdle: true,
+    connectionTimeoutMillis: 5000,
+    application_name: "okmodel",
+    types: WIRE,
+    ...config.ssl !== undefined ? { ssl: config.ssl } : {},
+    ...config.searchPath !== undefined ? { options: `-c search_path=${config.searchPath}` } : {}
+  });
+  pool.on("connect", (client) => {
+    client.on("notice", (notice) => {
+      notices.push(notice);
+    });
+  });
+  const root = new WireSession((text, params) => send(pool, text, params, named, undefined), notices, isClosed, true, () => {
+    counters.busy += 1;
+  }, () => {
+    counters.busy = Math.max(0, counters.busy - 1);
+  }, inflight);
+  const held = { pool, acquireMs, counters, notices, named, isClosed };
+  const checkout = () => closed ? rejectClosed() : import("./6bazvqwm.js").then((mod) => mod.checkout(held));
+  return {
+    capabilities: NODE_POSTGRES_CAPABILITIES,
+    execute(text, params, options) {
+      return runCall(closed, options, async (watch) => {
+        if (watch === undefined)
+          return root.query(text, params, undefined);
+        const client = await connectClient(pool, acquireMs, counters);
+        counters.busy += 1;
+        const session = new WireSession((statement, values) => send(client, statement, values, named, client), notices, isClosed, true, () => {
+          return;
+        }, () => {
+          return;
+        }, inflight);
+        try {
+          return await session.query(text, params, watch);
+        } finally {
+          counters.busy = Math.max(0, counters.busy - 1);
+          client.release();
+        }
+      });
+    },
+    async batch(statements, options) {
+      const connection = await checkout();
+      try {
+        return await connection.batch(statements, options);
+      } finally {
+        await connection.release();
+      }
+    },
+    reserve: () => checkout(),
+    stream(text, params) {
+      return stream(text, params);
+    },
+    listen(channel, onNotify) {
+      return listen(channel, onNotify);
+    },
+    cancel() {
+      for (const pending of inflight)
+        pending.cancel?.();
+    },
+    stats: () => statsOf(counters, max),
+    async close() {
+      closed = true;
+      await pool.end();
+    }
+  };
+  function stream(text, params) {
+    return async function* () {
+      const connection = await checkout();
+      try {
+        yield* cursorStream((statement, values) => connection.execute(statement, values), text, params);
+      } finally {
+        await connection.release();
+      }
+    }();
+  }
+  async function listen(channel, onNotify) {
+    if (closed)
+      return rejectClosed();
+    const client = await connectClient(pool, acquireMs, counters);
+    counters.reserved += 1;
+    const quoted = quoteIdent2(channel);
+    const onNotification = (message) => {
+      if (message.channel === channel)
+        onNotify(message.payload ?? "");
+    };
+    client.on("notification", onNotification);
+    try {
+      await client.query(`LISTEN ${quoted}`);
+    } catch (error) {
+      counters.reserved = Math.max(0, counters.reserved - 1);
+      client.release();
+      throw error;
+    }
+    let stopped = false;
+    return async () => {
+      if (stopped)
+        return;
+      stopped = true;
+      try {
+        await client.query(`UNLISTEN ${quoted}`);
+      } finally {
+        client.removeListener("notification", onNotification);
+        counters.reserved = Math.max(0, counters.reserved - 1);
+        client.release();
+      }
+    };
+  }
+}
+function send(runner, text, params, named, client) {
+  const query = {
+    text,
+    rowMode: "array",
+    types: WIRE,
+    ...params !== undefined && params.length > 0 ? { values: params } : {},
+    ...named ? { name: statementName(text) } : {}
+  };
+  const pending = runner.query(query);
+  if (client !== undefined)
+    pending.cancel = () => cancelBackend(client);
+  return pending;
+}
+var names = new Map;
+function statementName(text) {
+  const existing = names.get(text);
+  if (existing !== undefined)
+    return existing;
+  const name = `okm_${String(names.size)}`;
+  names.set(text, name);
+  return name;
+}
+function cancelBackend(client) {
+  const pid = client.processID;
+  const secret = client.secretKey;
+  if (typeof pid !== "number" || typeof secret !== "number")
+    return;
+  const socket = client.host.startsWith("/") === true ? net.connect(client.host) : net.connect(client.port, client.host);
+  socket.unref();
+  socket.once("error", () => {
+    socket.destroy();
+  });
+  socket.once("connect", () => {
+    const bytes = Buffer.alloc(16);
+    bytes.writeInt32BE(16, 0);
+    bytes.writeInt32BE(CANCEL_CODE, 4);
+    bytes.writeInt32BE(pid, 8);
+    bytes.writeInt32BE(secret, 12);
+    socket.end(bytes);
+  });
+}
+function connectClient(pool, acquireMs, counters) {
+  counters.waiting += 1;
+  let settled = false;
+  return new Promise((resolve, reject) => {
+    let timer;
+    if (acquireMs !== undefined) {
+      timer = setTimeout(() => {
+        settled = true;
+        counters.waiting = Math.max(0, counters.waiting - 1);
+        driverErrors().then((errors) => {
+          reject(errors.acquireTimeout());
+        });
+      }, acquireMs);
+    }
+    pool.connect().then((client) => {
+      if (settled) {
+        client.release();
+        return;
+      }
+      if (timer !== undefined)
+        clearTimeout(timer);
+      counters.waiting = Math.max(0, counters.waiting - 1);
+      resolve(client);
+    }, (error) => {
+      if (settled)
+        return;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      counters.waiting = Math.max(0, counters.waiting - 1);
+      mapFailure(error).then(reject);
+    });
+  });
+}
+function statsOf(counters, size) {
+  return {
+    size,
+    idle: Math.max(0, size - counters.reserved - counters.busy),
+    inflight: counters.busy + counters.reservedBusy,
+    waiting: counters.waiting
+  };
+}
+
+export { open4, send, connectClient };

package/dist/shared/bryqk9k9.js

@@ -0,0 +1,31 @@
+import {
+  withHttp
+} from "./k34e0xf2.js";
+import {
+  decodeResult
+} from "./xrfnq5k8.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/read-stream.ts
+async function* streamRows(session, call, prepare, log) {
+  await session.connected;
+  if (session.pool.capabilities.stream !== true || session.pool.stream === undefined) {
+    throw log(new OkmError2("OKM1111", "stream needs a driver with stream: true. This driver does not have it.", withHttp(session.http, {
+      fix: { summary: "Use a driver that sets stream, or read with find." }
+    })));
+  }
+  const { plan, params } = await prepare();
+  const decode = plan.outputs.includes.length === 0 ? decodeResult : (await import("./edwqqryd.js")).decodeIncluded;
+  for await (const chunk of session.pool.stream(plan.text, params)) {
+    const decoded = decode(plan, chunk, call.table);
+    if (!Array.isArray(decoded))
+      continue;
+    for (const row of decoded)
+      yield row;
+  }
+}
+export {
+  streamRows
+};

package/dist/shared/c8aghh05.js

@@ -0,0 +1,442 @@
+import {
+  validationGate
+} from "./9m80mkac.js";
+import {
+  isOperator
+} from "./cn0n68ft.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/validate/engine.ts
+var BRAND = Symbol("okmodel.validated");
+var EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var INTEGER_TEXT = /^-?\d+$/;
+var INTEGER_RANGE = {
+  smallint: [-32768n, 32767n],
+  integer: [-2147483648n, 2147483647n],
+  bigint: [-9223372036854775808n, 9223372036854775807n]
+};
+async function prepare(model, source, schemaFlag, op, input) {
+  engage(model, source, schemaFlag);
+  if (op === "update")
+    return finishUpdate(model, input);
+  return finish(model, "insert", input, false, false, undefined, undefined);
+}
+async function stand(model, source, schemaFlag, op, body, mode, pick, omit) {
+  engage(model, source, schemaFlag);
+  const input = op === "update" ? patchOf(body) : body;
+  if (mode === "check")
+    return issuesOf(model, op, input, pick, omit);
+  return finish(model, op, input, true, true, pick, omit);
+}
+function engage(model, source, schemaFlag) {
+  const gate = validationGate(schemaFlag, source);
+  if (gate !== undefined)
+    model.validation = gate;
+}
+async function finishUpdate(model, input) {
+  if (Array.isArray(input)) {
+    const items = [];
+    const issues = [];
+    for (let index = 0;index < input.length; index += 1) {
+      const item = input[index];
+      if (!isRecord(item))
+        failShape("update expects { where, set } or a list of rows.");
+      const set = await oneValue(model, "update", item.set, false, false, undefined, undefined);
+      pushIndexed(issues, index, set.issues);
+      items.push({ ...item, set: set.row });
+    }
+    if (issues.length > 0)
+      throwIssues(issues);
+    return items;
+  }
+  if (!isRecord(input) || !isRecord(input.set))
+    return input;
+  const set = await oneValue(model, "update", input.set, false, false, undefined, undefined);
+  if (set.issues.length > 0)
+    throwIssues(set.issues);
+  return { ...input, set: set.row };
+}
+async function finish(model, op, input, seal, strict, pick, omit) {
+  if (Array.isArray(input)) {
+    const rows = [];
+    const issues = [];
+    for (let index = 0;index < input.length; index += 1) {
+      const one = await oneValue(model, op, input[index], seal, strict, pick, omit);
+      pushIndexed(issues, index, one.issues);
+      rows.push(one.row);
+    }
+    if (issues.length > 0)
+      throwIssues(issues);
+    return seal ? Object.freeze(rows) : rows;
+  }
+  const one = await oneValue(model, op, input, seal, strict, pick, omit);
+  if (one.issues.length > 0)
+    throwIssues(one.issues);
+  return one.row;
+}
+async function issuesOf(model, op, input, pick, omit) {
+  if (Array.isArray(input)) {
+    const issues = [];
+    for (let index = 0;index < input.length; index += 1) {
+      const one = await oneValue(model, op, input[index], false, true, pick, omit);
+      pushIndexed(issues, index, one.issues);
+    }
+    return issues;
+  }
+  const one = await oneValue(model, op, input, false, true, pick, omit);
+  return one.issues;
+}
+function pushIndexed(issues, index, found) {
+  for (const issue of found)
+    issues.push({ path: [index, ...issue.path], message: issue.message });
+}
+async function oneValue(model, op, input, seal, strict, pick, omit) {
+  if (!isRecord(input))
+    failShape("insert expects an object or a list of objects.");
+  if (isBranded(input)) {
+    const row = copyRow(input);
+    keep(row, pick, omit);
+    return { row: seal ? sealRow(row) : row, issues: [] };
+  }
+  const row = acceptKeys(model, op, input, strict);
+  keep(row, pick, omit);
+  const gate = model.validation;
+  const issues = [];
+  if (gate === undefined)
+    return { row, issues };
+  for (const column of model.columns) {
+    if (!column.writable || op === "update" && column.guardUpdate)
+      continue;
+    if (!Object.hasOwn(row, column.field)) {
+      if (op === "insert" && gate.required.includes(column.field) && selected(column.field, pick, omit)) {
+        issues.push({ path: [column.field], message: "required" });
+      }
+      continue;
+    }
+    if (!selected(column.field, pick, omit))
+      continue;
+    let value = row[column.field];
+    if (isOperator(value))
+      continue;
+    if (value === null) {
+      if (gate.notNull.includes(column.field))
+        issues.push({ path: [column.field], message: "required" });
+      continue;
+    }
+    value = await applyTransforms(gate.fields[column.field], op, value);
+    row[column.field] = value;
+    issues.push(...derivedIssues(column, gate, value));
+    const checked = await checkRules(gate.fields[column.field], op, value, column.field);
+    row[column.field] = checked.value;
+    issues.push(...checked.issues);
+  }
+  const rowChecked = await checkRules(gate.row, op, row, undefined);
+  issues.push(...rowChecked.issues);
+  if (seal && issues.length === 0)
+    return { row: sealRow(row), issues };
+  return { row, issues };
+}
+function acceptKeys(model, op, input, strict) {
+  const row = {};
+  for (const key of Object.keys(input)) {
+    const column = findColumn(model, key);
+    if (column === undefined)
+      continue;
+    const blocked = op === "update" && column.guardUpdate || !column.writable;
+    if (blocked) {
+      if (strict) {
+        const reason = op === "update" && column.guardUpdate ? "is a primary key" : column.guarded ? "is guarded" : "cannot be written";
+        refuse(model.name, key, reason);
+      }
+      if (input[key] !== undefined)
+        row[key] = input[key];
+      continue;
+    }
+    if (input[key] !== undefined)
+      row[key] = input[key];
+  }
+  return row;
+}
+function refuse(table, field, reason) {
+  throw new OkmError2("OKM1190", `Field ${table}.${field} ${reason}. Input cannot set it.`, {
+    kind: "invalid",
+    fix: { summary: "Remove the guarded field. Input cannot set it." }
+  });
+}
+function keep(row, pick, omit) {
+  if (pick === undefined && omit === undefined)
+    return;
+  for (const key of Object.keys(row)) {
+    if (!selected(key, pick, omit))
+      delete row[key];
+  }
+}
+function selected(field, pick, omit) {
+  if (pick !== undefined && !pick.includes(field))
+    return false;
+  if (omit !== undefined && omit.includes(field))
+    return false;
+  return true;
+}
+async function applyTransforms(rules, op, value) {
+  if (rules === undefined)
+    return value;
+  let phase;
+  let current = value;
+  for (const item of rules) {
+    const step = active(item, phase);
+    phase = step.phase;
+    if (step.rule === undefined || step.limit !== undefined && step.limit !== op)
+      continue;
+    if (isTransform(step.rule))
+      current = transformValue(step.rule, current);
+  }
+  return current;
+}
+async function checkRules(rules, op, value, field) {
+  if (rules === undefined)
+    return { value, issues: [] };
+  const issues = [];
+  let phase;
+  let current = value;
+  for (const item of rules) {
+    const step = active(item, phase);
+    phase = step.phase;
+    if (step.rule === undefined || step.limit !== undefined && step.limit !== op)
+      continue;
+    const rule = step.rule;
+    if (isTransform(rule))
+      continue;
+    if (isStandard(rule)) {
+      const result = await rule["~standard"].validate(current);
+      if (result.issues === undefined) {
+        current = result.value;
+        continue;
+      }
+      for (const issue of result.issues) {
+        issues.push({ path: issuePath(field, issue.path), message: issue.message });
+      }
+      continue;
+    }
+    if (rule.k === "email" && typeof rule.key === "string") {
+      if (typeof current !== "string" || !EMAIL.test(current))
+        issues.push(fieldIssue(field, rule.key));
+      continue;
+    }
+    if (rule.k === "min" && typeof rule.n === "number" && typeof rule.key === "string") {
+      const ok = typeof current === "string" ? textLength(current) >= rule.n : typeof current === "number" && current >= rule.n;
+      if (!ok)
+        issues.push(fieldIssue(field, rule.key));
+      continue;
+    }
+    if (rule.k === "rule" && typeof rule.fn === "function" && typeof rule.path === "string" && typeof rule.key === "string" && !rule.fn(current)) {
+      issues.push({ path: [rule.path], message: rule.key });
+    }
+  }
+  return { value: current, issues };
+}
+function fieldIssue(field, message) {
+  return { path: field === undefined ? [] : [field], message };
+}
+function derivedIssues(column, gate, value) {
+  const issues = [];
+  const type = column.dataType.replace(/\[\]/g, "");
+  const length = /^(?:varchar|character varying|char|character)\((\d+)\)$/.exec(type);
+  if (length !== null && typeof value === "string" && textLength(value) > Number(length[1])) {
+    issues.push({ path: [column.field], message: "too_long" });
+  }
+  const list = gate.pick[column.field];
+  if (list !== undefined && (typeof value !== "string" || !list.includes(value))) {
+    issues.push({ path: [column.field], message: "picklist" });
+  }
+  const range = INTEGER_RANGE[type];
+  if (range !== undefined && !integerInRange(value, range[0], range[1])) {
+    issues.push({ path: [column.field], message: "integer_range" });
+  }
+  if (type === "numeric" || type.startsWith("numeric(") || type === "real" || type === "double precision") {
+    if (!precisionOk(type, value))
+      issues.push({ path: [column.field], message: "precision" });
+  }
+  if (type === "uuid" && (typeof value !== "string" || !UUID.test(value))) {
+    issues.push({ path: [column.field], message: "uuid" });
+  }
+  if ((type === "json" || type === "jsonb") && !jsonOk(value)) {
+    issues.push({ path: [column.field], message: "json" });
+  }
+  return issues;
+}
+function textLength(value) {
+  let count = 0;
+  for (let index = 0;index < value.length; ) {
+    const code = value.codePointAt(index) ?? 0;
+    index += code > 65535 ? 2 : 1;
+    count += 1;
+  }
+  return count;
+}
+function integerInRange(value, low, high) {
+  const parsed = integerValue(value);
+  if (parsed === undefined)
+    return false;
+  return parsed >= low && parsed <= high;
+}
+function integerValue(value) {
+  if (typeof value === "bigint")
+    return value;
+  if (typeof value === "number" && Number.isSafeInteger(value))
+    return BigInt(value);
+  if (typeof value === "string" && INTEGER_TEXT.test(value)) {
+    try {
+      return BigInt(value);
+    } catch {
+      return;
+    }
+  }
+  return;
+}
+function precisionOk(type, value) {
+  if (type === "real" || type === "double precision") {
+    return typeof value === "number" && Number.isFinite(value);
+  }
+  const text = typeof value === "number" ? Number.isFinite(value) ? String(value) : "" : typeof value === "string" ? value : "";
+  const plain = plainDecimal(text);
+  if (plain === undefined)
+    return false;
+  const match = /^numeric\((\d+)(?:,(\d+))?\)$/.exec(type);
+  if (match === null)
+    return true;
+  const precision = Number(match[1]);
+  const scale = match[2] === undefined ? 0 : Number(match[2]);
+  const [whole, fraction = ""] = plain.replace(/^-/, "").split(".");
+  const digits = `${whole === "0" ? "" : whole}${fraction}`.replace(/^0+/, "");
+  return fraction.length <= scale && (whole ?? "").replace(/^0+/, "").length <= precision - scale && digits.length <= precision;
+}
+function plainDecimal(text) {
+  if (!/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(text))
+    return;
+  const match = /^(-?)(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/.exec(text);
+  if (match === null)
+    return;
+  const whole = match[2] ?? "0";
+  const fraction = match[3] ?? "";
+  const exp = match[4] === undefined ? 0 : Number(match[4]);
+  if (!Number.isSafeInteger(exp))
+    return;
+  const digits = `${whole}${fraction}`;
+  const point = whole.length + exp;
+  let plain;
+  if (point >= digits.length)
+    plain = digits + "0".repeat(point - digits.length);
+  else if (point > 0)
+    plain = `${digits.slice(0, point)}.${digits.slice(point)}`;
+  else
+    plain = `0.${"0".repeat(-point)}${digits}`;
+  return `${match[1] ?? ""}${plain}`;
+}
+function jsonOk(value) {
+  try {
+    return JSON.stringify(value) !== undefined;
+  } catch {
+    return false;
+  }
+}
+function isStandard(value) {
+  if (typeof value !== "object" || value === null || !("~standard" in value))
+    return false;
+  const standard = value["~standard"];
+  return typeof standard === "object" && standard !== null && standard.version === 1 && typeof standard.validate === "function";
+}
+function active(item, phase) {
+  if (isStandard(item))
+    return { phase, limit: undefined, rule: item };
+  if (!isRule(item))
+    return { phase, limit: undefined, rule: undefined };
+  if (item.k === "phase" && (item.op === "insert" || item.op === "update")) {
+    return { phase: item.op, limit: undefined, rule: undefined };
+  }
+  if (item.k === "when" && (item.op === "insert" || item.op === "update")) {
+    const inner = item.rule;
+    if (isStandard(inner) || isRule(inner))
+      return { phase, limit: item.op, rule: inner };
+  }
+  return { phase, limit: phase, rule: item };
+}
+function isRule(value) {
+  return typeof value === "object" && value !== null && "k" in value && typeof value.k === "string";
+}
+function isTransform(rule) {
+  return !isStandard(rule) && (rule.k === "trim" || rule.k === "lower");
+}
+function transformValue(rule, value) {
+  if (typeof value !== "string")
+    return value;
+  if (rule.k === "trim")
+    return value.trim();
+  if (rule.k === "lower")
+    return value.toLowerCase();
+  return value;
+}
+function issuePath(field, path) {
+  const segments = [];
+  if (field !== undefined)
+    segments.push(field);
+  if (path === undefined)
+    return segments;
+  for (const part of path) {
+    const key = typeof part === "object" && part !== null && "key" in part ? part.key : part;
+    if (typeof key === "string" || typeof key === "number")
+      segments.push(key);
+  }
+  return segments;
+}
+function patchOf(body) {
+  if (isRecord(body) && isRecord(body.set))
+    return body.set;
+  return body;
+}
+function copyRow(value) {
+  const row = {};
+  for (const key of Object.keys(value))
+    row[key] = value[key];
+  return row;
+}
+function sealRow(row) {
+  Object.defineProperty(row, BRAND, { value: true });
+  return Object.freeze(row);
+}
+function isBranded(value) {
+  return Object.hasOwn(value, BRAND) && value[BRAND] === true;
+}
+function findColumn(model, field) {
+  for (const column of model.columns)
+    if (column.field === field)
+      return column;
+  return;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function failShape(message) {
+  throw new OkmError2("OKM1121", message, { kind: "invalid" });
+}
+function throwIssues(issues) {
+  const columns = [];
+  for (const issue of issues) {
+    const field = [...issue.path].reverse().find((part) => typeof part === "string");
+    if (typeof field === "string" && !columns.includes(field))
+      columns.push(field);
+  }
+  throw new OkmError2("OKM1200", "Validation failed.", {
+    kind: "invalid",
+    ...columns.length > 0 ? { columns } : {},
+    issues,
+    fix: { summary: "Fix the fields named in issues. Each issue message is a key." }
+  });
+}
+export {
+  prepare,
+  stand
+};