okmodel 0.7.0 → 0.9.0

package/dist/tooling/shared/3rmaz3pq.js

@@ -0,0 +1,140 @@
+import {
+  quote,
+  fail2
+} from "./hfq3n3bd.js";
+
+// src/runtime/sort.ts
+function insertAtEnd(table, columns, rows, group, tenantFields) {
+  const position = requiredColumn(table, "position");
+  const groupColumn = group === undefined ? undefined : requiredColumn(table, group);
+  const tenants = tenantColumns(table, tenantFields);
+  const planned = [];
+  const countOf = new Map;
+  const firstOf = new Map;
+  for (const row of rows) {
+    if (groupColumn !== undefined && !Object.hasOwn(row, groupColumn.field)) {
+      fail2("OKM1121", `insert on ${table.model.name} needs ${groupColumn.field} so position has a group.`, "Pass the group on the row. Position is assigned for you.");
+    }
+    const key = lockText(table.model.sql, wires(tenants, row), groupColumn === undefined ? null : cellWire(groupColumn, row[groupColumn.field]));
+    if (!firstOf.has(key))
+      firstOf.set(key, row);
+    const n = (countOf.get(key) ?? 0) + 1;
+    countOf.set(key, n);
+    planned.push({ key, n, row });
+  }
+  const params = [];
+  const bind = (wire, dataType) => {
+    params.push(wire);
+    return `$${String(params.length)}::${dataType}`;
+  };
+  const slotOf = new Map;
+  for (const key of firstOf.keys())
+    slotOf.set(key, bind(key, "text"));
+  const baseRows = [];
+  for (const [key, row] of firstOf) {
+    const parts = [slotOf.get(key) ?? bind(key, "text")];
+    if (groupColumn !== undefined)
+      parts.push(bind(cellWire(groupColumn, row[groupColumn.field]), groupColumn.dataType));
+    for (const column of tenants)
+      parts.push(bind(cellWire(column, row[column.field]), column.dataType));
+    baseRows.push(`(${parts.join(", ")})`);
+  }
+  const baseNames = ["okm_lock"];
+  if (groupColumn !== undefined)
+    baseNames.push("okm_g");
+  for (let index = 0;index < tenants.length; index += 1)
+    baseNames.push(`okm_t${String(index)}`);
+  const lists = planned.map((item) => {
+    const slot = slotOf.get(item.key) ?? bind(item.key, "text");
+    const slots = columns.map((column) => cell(column, item.row[column.field], bind));
+    slots.push(`((select b.pos from base b where b.okm_lock = ${slot}) + ${String(item.n)})::integer`);
+    return `(${slots.join(", ")})`;
+  });
+  const insertColumns = [...columns.map((column) => quote(column.sql)), quote(position.sql)];
+  const text = [
+    "with base as (",
+    "select i.okm_lock, coalesce(max(t.",
+    quote(position.sql),
+    "), 0) as pos from (values ",
+    baseRows.join(", "),
+    ") as i(",
+    baseNames.join(", "),
+    ") left join ",
+    quote(table.model.sql),
+    " as t on ",
+    joinOn(groupColumn, tenants),
+    " group by i.okm_lock",
+    ") insert into ",
+    quote(table.model.sql),
+    " (",
+    insertColumns.join(", "),
+    ") values ",
+    lists.join(", ")
+  ].join("");
+  return { lock: groupLock([...firstOf.keys()]), text, params };
+}
+function joinOn(group, tenants) {
+  const parts = [];
+  if (group !== undefined)
+    parts.push(`t.${quote(group.sql)} is not distinct from i.okm_g`);
+  for (let index = 0;index < tenants.length; index += 1) {
+    const column = tenants[index];
+    if (column === undefined)
+      continue;
+    parts.push(`t.${quote(column.sql)} is not distinct from i.okm_t${String(index)}`);
+  }
+  return parts.length === 0 ? "true" : parts.join(" and ");
+}
+function lockText(sqlName, tenants, group) {
+  return JSON.stringify([sqlName, tenants, group]);
+}
+function groupLock(keys) {
+  const ordered = [...keys].sort(compareText);
+  const values = ordered.map((_, index) => `($${String(index + 1)}::text)`).join(", ");
+  return {
+    text: `select pg_advisory_xact_lock(hashtextextended(k.okm_lock, 0::bigint)) from (select v.okm_lock from (values ${values}) as v(okm_lock) order by v.okm_lock) as k`,
+    params: ordered
+  };
+}
+function compareText(left, right) {
+  if (left < right)
+    return -1;
+  if (left > right)
+    return 1;
+  return 0;
+}
+function wires(columns, row) {
+  return columns.map((column) => cellWire(column, row[column.field]));
+}
+function cellWire(column, value) {
+  if (value === undefined || value === null)
+    return null;
+  return column.encode(value);
+}
+function cell(column, value, bind) {
+  if (value === undefined)
+    return "default";
+  if (value === null)
+    return bind(null, column.dataType);
+  return bind(column.encode(value), column.dataType);
+}
+function tenantColumns(table, fields) {
+  if (fields === undefined)
+    return [];
+  const columns = [];
+  for (const field of fields) {
+    const column = table.columns.get(field);
+    if (column !== undefined)
+      columns.push(column);
+  }
+  return columns;
+}
+function requiredColumn(table, field) {
+  const column = table.columns.get(field);
+  if (column === undefined)
+    fail2("OKM1120", `Table ${table.model.name} has no column ${field}.`);
+  return column;
+}
+export {
+  insertAtEnd
+};

package/dist/tooling/shared/3yn79q5m.js

@@ -0,0 +1,12 @@
+import {
+  rejectUncancellable
+} from "./5x3pf400.js";
+
+// src/adapters/pg/no-inflight-timeout.ts
+function noTimeout(options) {
+  if ((options?.timeout ?? 0) <= 0)
+    return;
+  return rejectUncancellable();
+}
+
+export { noTimeout };

package/dist/tooling/shared/54tqkxja.js

@@ -0,0 +1,51 @@
+// src/adapters/pg/watch.ts
+var callers = new WeakMap;
+function listenOn(signal, onAbort) {
+  let set = callers.get(signal);
+  if (set === undefined) {
+    const created = new Set;
+    callers.set(signal, created);
+    signal.addEventListener("abort", () => {
+      for (const each of created)
+        each();
+    }, { once: true });
+    set = created;
+  }
+  const registered = set;
+  registered.add(onAbort);
+  return () => {
+    registered.delete(onAbort);
+  };
+}
+function openWatch(options) {
+  let kind;
+  const controller = new AbortController;
+  const onAbort = () => {
+    if (kind === undefined)
+      kind = "cancelled";
+    controller.abort();
+  };
+  const release = options.signal === undefined ? undefined : listenOn(options.signal, onAbort);
+  let timer;
+  if (options.timeout !== undefined) {
+    timer = setTimeout(() => {
+      if (kind === undefined)
+        kind = "timeout";
+      controller.abort();
+    }, options.timeout);
+  }
+  return {
+    signal: controller.signal,
+    finish() {
+      if (timer !== undefined)
+        clearTimeout(timer);
+      release?.();
+    },
+    reason() {
+      return kind;
+    }
+  };
+}
+export {
+  openWatch
+};

package/dist/tooling/shared/57btdkgm.js

@@ -0,0 +1,209 @@
+import {
+  refusePrototypeKey
+} from "./0j0jtse1.js";
+import {
+  throwNamed,
+  parseOrder,
+  projectExpr,
+  quote,
+  list,
+  isRecord,
+  fail2
+} from "./hfq3n3bd.js";
+
+// src/dialects/pg/ops/bucket.ts
+var RUNTIME = Symbol.for("okmodel.bucket");
+function isBucket(value) {
+  return typeof value === "object" && value !== null && RUNTIME in value;
+}
+
+// src/runtime/bucket-group.ts
+function readBucket(table, value, fields, aliases) {
+  if (!isBucket(value))
+    fail2("OKM1120", "bucket group");
+  const column = typeof value.column === "string" ? table.columns.get(value.column) : undefined;
+  if (typeof value.column !== "string" || column === undefined) {
+    throwNamed("OKM1120", String(value.column), table.names, `Field ${String(value.column)} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+  }
+  if (column.hidden) {
+    fail2("OKM1120", `Field ${column.field} is hidden, so groupBy cannot read it.`);
+  }
+  const unit = unitOf(value.unit);
+  if (unit === undefined) {
+    fail2("OKM1120", `bucket() unit ${String(value.unit)} is not a time unit. Accepted units: second, minute, hour, day, week, month, quarter, year.`);
+  }
+  const shift = weekShift(value.weekStart, unit);
+  const kind = temporalKind(column.dataType);
+  if (kind !== "timestamptz" && kind !== "date") {
+    fail2("OKM1120", `bucket() does not apply to ${kind === "timestamp" ? "timestamp" : column.dataType} column ${column.field}. Use timestamptz or date.`);
+  }
+  if (kind === "date" && clockUnit(unit)) {
+    fail2("OKM1120", `bucket() unit ${unit} does not apply to date column ${column.field}. Accepted units: day, week, month, quarter, year.`);
+  }
+  let tz;
+  if (kind === "timestamptz") {
+    if (typeof value.tz !== "string") {
+      fail2("OKM1120", `bucket() on timestamptz column ${column.field} needs tz, an IANA time zone.`);
+    }
+    if (!iana(value.tz))
+      fail2("OKM1120", `bucket() tz ${value.tz} is not an IANA time zone.`);
+    tz = value.tz;
+  } else if (value.tz !== undefined) {
+    fail2("OKM1120", `bucket() on date column ${column.field} does not take tz.`);
+  }
+  if (typeof value.as !== "string" || value.as.length === 0) {
+    fail2("OKM1120", "bucket() needs as, the name of the result key.");
+  }
+  refusePrototypeKey(value.as, "bucket as");
+  if (value.as === "count" || value.as === "sum" || value.as === "avg" || value.as === "min" || value.as === "max") {
+    fail2("OKM1120", `bucket as ${value.as} clashes with an aggregate key.`);
+  }
+  if (fields.has(value.as) || aliases.has(value.as)) {
+    fail2("OKM1120", `bucket as ${value.as} clashes with another group.`);
+  }
+  aliases.add(value.as);
+  return { kind: "bucket", column, unit, tz, as: value.as, shift, clock: clockUnit(unit) };
+}
+function writeBucket(sink, outputs, wrote, group) {
+  if (wrote.at > 0)
+    sink.text(", ");
+  if (group.clock)
+    emitClock(sink, group);
+  else
+    emitCalendar(sink, group);
+  outputs?.fields.push({
+    key: `g:${group.as}`,
+    at: wrote.at,
+    decode: bucketDecode(group)
+  });
+  wrote.at += 1;
+}
+function writeGrouped(sink, names, orderBy) {
+  sink.text(ordinals(names.length));
+  if (isRecord(orderBy) && Object.keys(orderBy).length > 0) {
+    sink.text(" order by ");
+    const keys = Object.keys(orderBy);
+    for (let index = 0;index < keys.length; index += 1) {
+      const key = keys[index];
+      if (key === undefined)
+        continue;
+      const parsed = parseOrder(key, orderBy[key]);
+      if (index > 0)
+        sink.text(", ");
+      sink.text(String(names.indexOf(key) + 1));
+      sink.text(parsed.dir === "asc" ? " asc" : " desc");
+      sink.text(parsed.nulls === "first" ? " nulls first" : " nulls last");
+      sink.mark(`o:${key}:${parsed.dir}:${parsed.nulls}`);
+    }
+    return;
+  }
+  sink.text(" order by ");
+  const parts = [];
+  for (let index = 1;index <= names.length; index += 1) {
+    parts.push(`${String(index)} asc nulls last`);
+  }
+  sink.text(parts.join(", "));
+}
+function unitOf(value) {
+  if (value === "second" || value === "minute" || value === "hour" || value === "day" || value === "week" || value === "month" || value === "quarter" || value === "year") {
+    return value;
+  }
+  return;
+}
+function clockUnit(unit) {
+  return unit === "second" || unit === "minute" || unit === "hour";
+}
+function weekShift(value, unit) {
+  if (value === undefined)
+    return 0;
+  if (unit !== "week")
+    fail2("OKM1120", "bucket() weekStart applies to unit week.");
+  if (value === "monday")
+    return 0;
+  if (value === "sunday")
+    return 1;
+  if (value === "saturday")
+    return 2;
+  return fail2("OKM1120", "bucket() weekStart must be monday, sunday, or saturday.");
+}
+function temporalKind(dataType) {
+  if (dataType === "date")
+    return "date";
+  if (dataType === "timestamptz" || dataType.startsWith("timestamptz("))
+    return "timestamptz";
+  if (dataType === "timestamp" || dataType.startsWith("timestamp("))
+    return "timestamp";
+  return;
+}
+function iana(tz) {
+  try {
+    Intl.DateTimeFormat("en-US", { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function bucketDecode(group) {
+  if (group.clock || !group.column.dataType.startsWith("timestamptz"))
+    return group.column.decode;
+  return decodeDay;
+}
+function decodeDay(wire) {
+  const temporal = globalThis.Temporal;
+  if (typeof temporal !== "object" || temporal === null || !("PlainDate" in temporal)) {
+    return fail2("OKM1120", "Date and time codecs need the Temporal global. okmodel does not ship a polyfill. Use a runtime that provides Temporal, or assign a polyfill to globalThis.Temporal before using these columns.");
+  }
+  try {
+    return temporal.PlainDate.from(wire);
+  } catch {
+    return fail2("OKM1120", `date ${wire} must be YYYY-MM-DD.`);
+  }
+}
+var ZONE = "\x00";
+function emitClock(sink, group) {
+  const column = `t.${quote(group.column.sql)}`;
+  const wrapped = projectExpr(`date_trunc('${group.unit}', ${column}, ${ZONE})`, "timestamptz");
+  const at = wrapped.indexOf(ZONE);
+  sink.text(wrapped.slice(0, at));
+  sink.param(group.tz ?? "");
+  sink.text(wrapped.slice(at + ZONE.length));
+}
+function emitCalendar(sink, group) {
+  const column = `t.${quote(group.column.sql)}`;
+  sink.text("(date_trunc('");
+  sink.text(group.unit);
+  sink.text("', ");
+  emitLocal(sink, column, group.tz);
+  if (group.shift === 0) {
+    sink.text("))::date");
+    return;
+  }
+  const days = group.shift === 1 ? "1 day" : "2 days";
+  sink.text(" + interval '");
+  sink.text(days);
+  sink.text("') - interval '");
+  sink.text(days);
+  sink.text("')::date");
+}
+function emitLocal(sink, column, tz) {
+  if (tz === undefined) {
+    sink.text(column);
+    return;
+  }
+  sink.text("(");
+  sink.text(column);
+  sink.text(" AT TIME ZONE ");
+  sink.param(tz);
+  sink.text(")");
+}
+function ordinals(count) {
+  const parts = [];
+  for (let index = 1;index <= count; index += 1)
+    parts.push(String(index));
+  return parts.join(", ");
+}
+export {
+  readBucket,
+  writeBucket,
+  writeGrouped
+};

package/dist/tooling/shared/5bmksndh.js

@@ -0,0 +1,118 @@
+import {
+  stack2
+} from "./35zemrmf.js";
+import {
+  OkmError,
+  isOperator,
+  operatorValue
+} from "./hfq3n3bd.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/5p8km5jb.js

@@ -0,0 +1,38 @@
+import {
+  open6,
+  seal2
+} from "./t6zjeake.js";
+import {
+  createClient
+} from "./jr2nmr81.js";
+
+// src/runtime/pg/pglite.ts
+async function connect(target, options) {
+  if (typeof target === "object" && !isPool(target)) {
+    return import("./kbqnrs1x.js").then((mod) => mod.default(target, options, open6));
+  }
+  const pool = isPool(target) ? seal2(target) : await open6({
+    ...target !== undefined ? { dataDir: target } : {},
+    ...options.timeouts !== undefined ? { timeouts: options.timeouts } : {}
+  });
+  return createClient(options.schema, pool, {
+    ownsPool: true,
+    http: options.errors?.http,
+    includeValues: options.errors?.includeValues,
+    logger: options.logger,
+    signal: options.signal,
+    requireMeta: options.requireMeta,
+    timeout: options.timeout,
+    timeouts: options.timeouts,
+    hookm: options.hookm,
+    catalog: options.catalog,
+    catalogDir: options.catalogDir,
+    generators: options.generators
+  });
+}
+function isPool(target) {
+  return typeof target === "object" && target !== null && "execute" in target && "capabilities" in target;
+}
+export {
+  connect
+};