okmodel 0.1.1 → 0.2.1

package/dist/shared/n47rd821.js

@@ -0,0 +1,442 @@
+import {
+  validationGate
+} from "./3a5ne750.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
+};

package/dist/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 };

package/dist/shared/{mkjmqjv4.js → nfzc5z0w.js}

@@ -1,6 +1,6 @@
 import {
   catalogError2
-} from "./ycwz42az.js";
+} from "./52szzakm.js";
 
 // src/contracts/utf8.ts
 function utf8ByteLength2(value) {
@@ -273,109 +273,7 @@ function toHex(bytes) {
 // src/contracts/catalog/words.ts
 var words;
 function reservedWords() {
-  words ??= new Set([
-    "all",
-    "analyse",
-    "analyze",
-    "and",
-    "any",
-    "array",
-    "as",
-    "asc",
-    "asymmetric",
-    "authorization",
-    "binary",
-    "both",
-    "case",
-    "cast",
-    "check",
-    "collate",
-    "collation",
-    "column",
-    "concurrently",
-    "constraint",
-    "create",
-    "cross",
-    "current_catalog",
-    "current_date",
-    "current_role",
-    "current_schema",
-    "current_time",
-    "current_timestamp",
-    "current_user",
-    "default",
-    "deferrable",
-    "desc",
-    "distinct",
-    "do",
-    "else",
-    "end",
-    "except",
-    "false",
-    "fetch",
-    "for",
-    "foreign",
-    "freeze",
-    "from",
-    "full",
-    "grant",
-    "group",
-    "having",
-    "ilike",
-    "in",
-    "initially",
-    "inner",
-    "intersect",
-    "into",
-    "is",
-    "isnull",
-    "join",
-    "lateral",
-    "leading",
-    "left",
-    "like",
-    "limit",
-    "localtime",
-    "localtimestamp",
-    "natural",
-    "not",
-    "notnull",
-    "null",
-    "offset",
-    "on",
-    "only",
-    "or",
-    "order",
-    "outer",
-    "overlaps",
-    "placing",
-    "primary",
-    "references",
-    "returning",
-    "right",
-    "select",
-    "session_user",
-    "similar",
-    "some",
-    "symmetric",
-    "system_user",
-    "table",
-    "tablesample",
-    "then",
-    "to",
-    "trailing",
-    "true",
-    "union",
-    "unique",
-    "user",
-    "using",
-    "variadic",
-    "verbose",
-    "when",
-    "where",
-    "window",
-    "with"
-  ]);
+  words ??= new Set("all analyse analyze and any array as asc asymmetric authorization binary both case cast check collate collation column concurrently constraint create cross current_catalog current_date current_role current_schema current_time current_timestamp current_user default deferrable desc distinct do else end except false fetch for foreign freeze from full grant group having ilike in initially inner intersect into is isnull join lateral leading left like limit localtime localtimestamp natural not notnull null offset on only or order outer overlaps placing primary references returning right select session_user similar some symmetric system_user table tablesample then to trailing true union unique user using variadic verbose when where window with".split(" "));
   return words;
 }
 

package/dist/shared/nsva2a6b.js

@@ -0,0 +1,42 @@
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/preset.ts
+var RESERVED_PRESETS = new Set([
+  "find",
+  "one",
+  "page",
+  "aggregate",
+  "count",
+  "exists",
+  "insert",
+  "update",
+  "delete",
+  "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 OkmError2("OKM1040", `Preset ${name} on ${where} is a client method or a reserved name. Reserved: ${[...RESERVED_PRESETS].join(", ")}.`, { fix: { summary: `Rename the preset ${name}.` } });
+  }
+}
+function duplicatePreset(name, table, first, second) {
+  throw new OkmError2("OKM1040", `Preset ${name} on ${table} is defined by ${first} and by ${second}.`, { fix: { summary: `Rename the preset in ${first} or in ${second}, or drop one of them.` } });
+}
+
+export { checkPresetNames, duplicatePreset };

package/dist/shared/ps43134h.js

@@ -0,0 +1,69 @@
+import {
+  encodeText,
+  decodeText
+} from "./sacqha1y.js";
+import {
+  required,
+  openColumn
+} from "./dd4f8mnx.js";
+import {
+  definition,
+  rejected
+} from "./xatfg0gn.js";
+import {
+  readClientGenerator
+} from "./rwmrejjz.js";
+
+// src/dialects/pg/keys.ts
+function id2(options) {
+  const chosen = options?.default;
+  const client = typeof chosen === "function" ? readClientGenerator(chosen) : undefined;
+  const okid = client?.name === "okid";
+  const supplied = chosen === "none";
+  if (client === undefined && chosen !== undefined && chosen !== "uuidv7" && chosen !== "uuidv4" && chosen !== "none") {
+    definition(`id() default ${String(chosen)} must be uuidv7, uuidv4, none, or a client generator.`);
+  }
+  return openColumn({
+    baseType: okid ? "text" : "uuid",
+    nullable: false,
+    hasDefault: client !== undefined || !supplied,
+    generated: false,
+    guarded: client !== undefined || !supplied,
+    hidden: false,
+    omitWrite: client !== undefined || !supplied,
+    omitUpdate: true,
+    ...client !== undefined ? { clientDefault: client } : {},
+    ...okid ? { collation: "C" } : {},
+    idSource: chosen === undefined ? "implicit" : "column",
+    ...client === undefined && !supplied ? { defaultSql: chosen === "uuidv4" ? "gen_random_uuid()" : "uuidv7()" } : {},
+    primaryKey: true,
+    encode: okid ? encodeText : encodeUuid,
+    decode: okid ? decodeText : decodeUuid,
+    sqlForm: "quote"
+  });
+}
+function uuid2() {
+  return required({
+    baseType: "uuid",
+    encode: encodeUuid,
+    decode: decodeUuid,
+    sqlForm: "quote"
+  });
+}
+function encodeUuid(value) {
+  const text = value.toLowerCase();
+  if (!uuidText().test(text)) {
+    rejected(`uuid ${value} must be 8-4-4-4-12 hexadecimal digits, for example 01890c5a-8f0e-7c3a-9b2d-6e4f1a0b9c8d.`);
+  }
+  return text;
+}
+function decodeUuid(wire) {
+  return encodeUuid(wire);
+}
+function uuidText() {
+  uuidPattern ??= /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+  return uuidPattern;
+}
+var uuidPattern;
+
+export { id2, uuid2 };