okmodel 0.6.0 → 0.8.0

package/dist/shared/qd9hhd8f.js

@@ -0,0 +1,37 @@
+import {
+  WRITE_PARAM_BUDGET2,
+  executeWrite2,
+  explainWrite2,
+  updateSliceBody2,
+  rejectDuplicateTargets2,
+  emitSet2,
+  Sql2,
+  writeSet2,
+  rejectMixedSets2,
+  readClaim2,
+  rejectUpdateKeys2,
+  requireFilter2,
+  returningOption2,
+  expectOf2,
+  allowSet2,
+  noteGuarded2
+} from "./bxas03mq.js";
+import"./mss6ctgv.js";
+export {
+  Sql2 as Sql,
+  WRITE_PARAM_BUDGET2 as WRITE_PARAM_BUDGET,
+  allowSet2 as allowSet,
+  emitSet2 as emitSet,
+  executeWrite2 as executeWrite,
+  expectOf2 as expectOf,
+  explainWrite2 as explainWrite,
+  noteGuarded2 as noteGuarded,
+  readClaim2 as readClaim,
+  rejectDuplicateTargets2 as rejectDuplicateTargets,
+  rejectMixedSets2 as rejectMixedSets,
+  rejectUpdateKeys2 as rejectUpdateKeys,
+  requireFilter2 as requireFilter,
+  returningOption2 as returningOption,
+  updateSliceBody2 as updateSliceBody,
+  writeSet2 as writeSet
+};

package/dist/shared/{mb2ycs1p.js → qfw14tna.js}

@@ -1,9 +1,9 @@
 import {
-  effectivePredicate
-} from "./b3awxn7h.js";
+  stack2
+} from "./mss6ctgv.js";
 import {
-  stack
-} from "./672t5vym.js";
+  effectivePredicate
+} from "./n454kcnw.js";
 import {
   runWrite
 } from "./n4jqhpqz.js";
@@ -16,8 +16,8 @@ import {
   quote,
   isRecord,
   registerFailFix,
-  fail
-} from "./2z7wv5tj.js";
+  fail2
+} from "./kgwp4jdd.js";
 import {
   safetyInstalled,
   runSafety
@@ -50,7 +50,7 @@ function explainArchive(schema, op, table, input, options, mods, scope) {
 function planArchive(schema, op, tableName, input, options, mods, scope) {
   const table = indexes(schema).get(tableName);
   if (table === undefined)
-    fail("OKM1120", `Table ${tableName} is not in the schema.`);
+    fail2("OKM1120", `Table ${tableName} is not in the schema.`);
   const archive = table.model.archive;
   if (archive === undefined) {
     throw new OkmError2("OKM1052", `Table ${tableName} is not archivable.`, {
@@ -61,7 +61,7 @@ function planArchive(schema, op, tableName, input, options, mods, scope) {
   rejectKeys(record, OPTIONS, op);
   const expect = expectOf(record.expect ?? mods.expect);
   const read = readTarget(op, table, input, mods);
-  const target = { ...read, where: stack(read.where, mods.presets) };
+  const target = { ...read, where: stack2(read.where, mods.presets) };
   const view = op === "restore" ? "only" : undefined;
   noteArchive(table, view);
   const statement = withRowFilters(scope, view, () => op === "archive" ? archiveSql(schema, table, target.where) : restoreSql(schema, table, target));
@@ -83,25 +83,25 @@ function noteArchive(table, view) {
 }
 function readTarget(op, table, input, mods) {
   if (!isRecord(input))
-    fail("OKM1121", `${op} expects { where }.`);
+    fail2("OKM1121", `${op} expects { where }.`);
   const keys = Object.keys(input);
   if (op === "restore" && input.archiveId !== undefined) {
     if (input.where !== undefined)
-      fail("OKM1120", "restore takes where or archiveId, not both.");
+      fail2("OKM1120", "restore takes where or archiveId, not both.");
     for (const key of keys) {
       if (key !== "archiveId") {
-        fail("OKM1120", "restore accepts where or archiveId.");
+        fail2("OKM1120", "restore accepts where or archiveId.");
       }
     }
     if (typeof input.archiveId !== "string" || input.archiveId.length === 0) {
-      fail("OKM1121", "restore archiveId must be a uuid.");
+      fail2("OKM1121", "restore archiveId must be a uuid.");
     }
     const idField = table.model.archive?.idField ?? "archiveId";
     return { where: { [idField]: input.archiveId }, archiveId: input.archiveId };
   }
   for (const key of keys) {
     if (key !== "where")
-      fail("OKM1120", `${op} accepts where.`);
+      fail2("OKM1120", `${op} accepts where.`);
   }
   requireFilter(table, input.where, mods, op);
   return { where: input.where, archiveId: undefined };
@@ -358,12 +358,12 @@ function expectOf(value) {
 function requireFilter(table, where, mods, op) {
   if (mods.all !== undefined) {
     if (mods.all.trim().length === 0) {
-      fail("OKM1102", `${op} on ${table.model.name} needs a where. .all needs a reason.`);
+      fail2("OKM1102", `${op} on ${table.model.name} needs a where. .all needs a reason.`);
     }
     return;
   }
   if (!effectivePredicate(where)) {
-    fail("OKM1102", `${op} on ${table.model.name} needs a where. Pass a filter, or .all(reason).`);
+    fail2("OKM1102", `${op} on ${table.model.name} needs a where. Pass a filter, or .all(reason).`);
   }
 }
 function callOptions(input) {

package/dist/shared/{9s0ypp87.js → sjk86yrx.js}

@@ -1,6 +1,6 @@
 import {
   creationOrder2
-} from "./qq3899ht.js";
+} from "./12z7aznj.js";
 import {
   isDomain
 } from "./ywspezzx.js";

package/dist/shared/th3be82n.js

@@ -0,0 +1,208 @@
+import {
+  refusePrototypeKey
+} from "./a62rb2da.js";
+import {
+  isBucket
+} from "./nbw1z4yd.js";
+import {
+  parseOrder,
+  projectExpr,
+  quote,
+  list,
+  isRecord,
+  fail2
+} from "./kgwp4jdd.js";
+import {
+  throwNamed2
+} from "./52szzakm.js";
+
+// 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) {
+    throwNamed2("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/shared/{ed0b8k4s.js → typ3vy7t.js}

@@ -1,6 +1,6 @@
 import {
   required
-} from "./ywr8hmey.js";
+} from "./606g0nbf.js";
 import {
   definition,
   rejected

package/dist/shared/{5d8t84hg.js → v1wad97q.js}

@@ -1,19 +1,19 @@
 import {
   refuseUncancellableTimeout
-} from "./b4v57v3x.js";
+} from "./2d3xq4ps.js";
 import {
   isConnectionLost
-} from "./gwn6v667.js";
+} from "./cnkky55j.js";
 import {
   openClient,
   withHttp,
   settleCall
-} from "./j60w0dvr.js";
+} from "./bah9nbg3.js";
 import {
   rejectKeys,
   isRecord,
-  fail
-} from "./2z7wv5tj.js";
+  fail2
+} from "./kgwp4jdd.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -96,15 +96,15 @@ class Frame {
 }
 async function tx(session, args) {
   if (typeof args[0] === "function" && args.length > 1) {
-    fail("OKM1120", "options go first: tx(options, fn).");
+    fail2("OKM1120", "options go first: tx(options, fn).");
   }
   const fn = typeof args[0] === "function" ? args[0] : args[1];
   const given = typeof args[0] === "function" ? {} : args[0] ?? {};
   try {
     if (typeof fn !== "function")
-      fail("OKM1121", "tx expects a callback: tx(fn) or tx(options, fn).");
+      fail2("OKM1121", "tx expects a callback: tx(fn) or tx(options, fn).");
     if (!isRecord(given))
-      fail("OKM1121", "tx options must be an object.");
+      fail2("OKM1121", "tx options must be an object.");
     rejectKeys(given, ["isolation", "retry", "signal", "timeout"], "tx");
     const options = given;
     check(options);
@@ -123,14 +123,14 @@ function failWith(session, error) {
 }
 function check(options) {
   if (options.isolation !== undefined && !Object.hasOwn(BEGIN, options.isolation)) {
-    fail("OKM1120", `isolation must be one of: ${Object.keys(BEGIN).join(", ")}.`);
+    fail2("OKM1120", `isolation must be one of: ${Object.keys(BEGIN).join(", ")}.`);
   }
   const { retry, timeout } = options;
   if (retry !== undefined && (!Number.isInteger(retry) || retry < 0)) {
-    fail("OKM1121", "retry must be an integer from 0 up.");
+    fail2("OKM1121", "retry must be an integer from 0 up.");
   }
   if (timeout !== undefined && (typeof timeout !== "number" || !(timeout > 0))) {
-    fail("OKM1121", "timeout must be a number of milliseconds above 0.");
+    fail2("OKM1121", "timeout must be a number of milliseconds above 0.");
   }
 }
 async function outer(session, fn, options) {
@@ -269,7 +269,7 @@ async function run(session, after, hear) {
 }
 async function nested(session, fn, options) {
   if (Object.keys(options).length > 0) {
-    fail("OKM1121", "isolation, retry, timeout, and signal belong to the outermost tx(). A nested tx() is a savepoint on the same transaction.");
+    fail2("OKM1121", "isolation, retry, timeout, and signal belong to the outermost tx(). A nested tx() is a savepoint on the same transaction.");
   }
   const { state: frame, depth } = session.tx;
   frame.check();
@@ -347,7 +347,7 @@ function held(session, frame, after, depth) {
       extras: {
         afterCommit(callback) {
           if (typeof callback !== "function") {
-            fail("OKM1121", "afterCommit expects a function.");
+            fail2("OKM1121", "afterCommit expects a function.");
           }
           frame.check();
           after.push(callback);
@@ -380,7 +380,7 @@ function lockKey(key) {
   }
   const fits = typeof key === "number" ? Number.isSafeInteger(key) : typeof key === "bigint" && key >= -(2n ** 63n) && key < 2n ** 63n;
   if (!fits)
-    fail("OKM1121", "advisoryLock takes a string, a safe integer, or a bigint that fits in 64 bits.");
+    fail2("OKM1121", "advisoryLock takes a string, a safe integer, or a bigint that fits in 64 bits.");
   return ["select pg_advisory_xact_lock($1::bigint)", String(key)];
 }
 function callOf(options) {

package/dist/shared/{x72jb7ad.js → v8g1vgv8.js}

@@ -6,7 +6,7 @@ import {
   acquireTimeout2,
   errorField2,
   mapDriverError2
-} from "./31vm914h.js";
+} from "./cm3w0ywp.js";
 export {
   DriverError2 as DriverError,
   acquireTimeout2 as acquireTimeout,

package/dist/shared/{9628a9xt.js → vk7rag46.js}

@@ -1,6 +1,6 @@
 import {
   required
-} from "./ywr8hmey.js";
+} from "./606g0nbf.js";
 import {
   rejected
 } from "./tmbdywx0.js";

package/dist/shared/{ze4hxsmy.js → w9ejzaqf.js}

@@ -1,6 +1,6 @@
 import {
   ColumnBuilder2
-} from "./ywr8hmey.js";
+} from "./606g0nbf.js";
 import {
   definition
 } from "./tmbdywx0.js";