okmodel 0.5.1 → 0.7.0

package/dist/shared/2c13q96h.js

@@ -0,0 +1,18 @@
+import {
+  DriverError2
+} from "./cm3w0ywp.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/adapters/lazy-errors.ts
+function refused() {
+  return Promise.reject(new OkmError2("OKM1120", "timeout"));
+}
+function closed() {
+  return Promise.reject(new DriverError2("The pool is closed.", { sqlstate: "08006" }));
+}
+export {
+  closed,
+  refused
+};

package/dist/shared/2d3xq4ps.js

@@ -0,0 +1,9 @@
+// src/runtime/inflight.ts
+async function refuseUncancellableTimeout(pool, timeout) {
+  if (pool.capabilities.cancel === true || timeout === undefined || !(timeout > 0))
+    return;
+  const { refused } = await import("./2c13q96h.js");
+  await refused();
+}
+
+export { refuseUncancellableTimeout };

package/dist/shared/2shdbn8q.js

@@ -0,0 +1,23 @@
+import {
+  ensureMigrationTables2,
+  applyTarget2,
+  applyProject2,
+  pushProject2,
+  backfillTiming2
+} from "./p6qc5gcp.js";
+import"./m6p12kbr.js";
+import"./8skf0cam.js";
+import"./b5pftnn2.js";
+import"./gs74dbj5.js";
+import"./tsvww22q.js";
+import"./n442h54c.js";
+import"./9s0ypp87.js";
+import"./qq3899ht.js";
+import"./14vx95q4.js";
+export {
+  applyProject2 as applyProject,
+  applyTarget2 as applyTarget,
+  backfillTiming2 as backfillTiming,
+  ensureMigrationTables2 as ensureMigrationTables,
+  pushProject2 as pushProject
+};

package/dist/shared/{t4tbsy9h.js → 358zsv4r.js}

@@ -503,7 +503,7 @@ function constraint2(input) {
   const name = input.name === undefined ? deterministicName2({
     parent: input.parent.name,
     purpose: input.constraintKind,
-    nameKey
+    nameKey: input.constraintKind === "check" ? nameKey : defaultNameKey(input.constraintKind, columns)
   }) : fitIdentifier2(input.name);
   const identity = {
     kind: "constraint",

package/dist/shared/3v7t1yrv.js

@@ -0,0 +1,208 @@
+import {
+  refusePrototypeKey
+} from "./q5c6ngn3.js";
+import {
+  isBucket
+} from "./nbw1z4yd.js";
+import {
+  parseOrder,
+  projectExpr,
+  quote,
+  list,
+  isRecord,
+  fail2
+} from "./67txcrcw.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/5e3tf63j.js

@@ -0,0 +1,220 @@
+import {
+  encodeUuid,
+  decodeUuid
+} from "./hyh73qk6.js";
+import {
+  encodeText,
+  decodeText
+} from "./ed0b8k4s.js";
+import {
+  snakeCase
+} from "./rpycarcr.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/view/client.ts
+var globalViews = new WeakMap;
+function viewGlobalReason(model) {
+  return globalViews.get(model);
+}
+function viewMentions(query, name) {
+  let pattern = '(^|[^A-Za-z0-9_])"?';
+  for (const char of name) {
+    if ("\\^$[]().*+?|{}".includes(char))
+      pattern += "\\";
+    pattern += char;
+  }
+  pattern += '"?(?![A-Za-z0-9_])';
+  return new RegExp(pattern).test(query);
+}
+function viewClient(name, columns, query, tenancy, refresh = "plain") {
+  const field = camelCase(name);
+  const marked = readGlobal(name, tenancy);
+  return {
+    field,
+    install(model, scope, tables, casing, scoped) {
+      if (Object.hasOwn(model, field)) {
+        throw new OkmError2("OKM1023", `View ${name} uses the client name ${field}.`, {
+          fix: { summary: "Give the view a name that no table uses." }
+        });
+      }
+      const exposes = exposesKey(columns, scope);
+      if (scope !== undefined && readsTenant(query, tables, casing, scoped)) {
+        if (!exposes && marked === undefined) {
+          throw new OkmError2("OKM1820", `View ${name} reads a tenant table and does not expose ${scope.key}.`, {
+            fix: {
+              summary: "Expose the tenant key so the predicate can be applied, or declare global(reason)."
+            }
+          });
+        }
+        if (exposes) {
+          scope.scopeView(field);
+          scoped.add(name);
+        }
+      }
+      const built = {
+        name: field,
+        sql: name,
+        primary: [],
+        uniques: [],
+        columns: columnModels(columns, scope),
+        relations: []
+      };
+      if (marked !== undefined)
+        globalViews.set(built, marked);
+      model[field] = built;
+    },
+    hook(target, ctx) {
+      if (ctx.table === field && ctx.session !== undefined) {
+        if (refresh !== "plain")
+          target.refresh = refreshHandle(ctx.session, name, refresh);
+        return;
+      }
+      publish(field, target, ctx);
+    }
+  };
+}
+function refreshHandle(session, name, mode) {
+  const concurrently = mode === "concurrently";
+  return () => lazyRefresh(() => import("./z7s6fpxv.js").then((mod) => mod.refreshView(session, name, concurrently)));
+}
+function lazyRefresh(run) {
+  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;
+      });
+    },
+    "~refresh": true
+  };
+  return self;
+}
+function publish(field, target, ctx) {
+  if (ctx.tables === undefined || ctx.table !== undefined)
+    return;
+  const handle = ctx.tables[field];
+  if (typeof handle !== "object" || handle === null)
+    return;
+  const source = handle;
+  const views = target.views;
+  const map = typeof views === "object" && views !== null ? views : {};
+  map[field] = {
+    find: source.find,
+    one: source.one,
+    count: source.count,
+    exists: source.exists,
+    ...typeof source.refresh === "function" ? { refresh: source.refresh } : {}
+  };
+  target.views = map;
+  delete ctx.tables[field];
+  delete target[field];
+}
+function columnModels(columns, tenancy) {
+  const seen = new Set;
+  const models = [];
+  for (const column of columns) {
+    const field = fieldName(column.name, tenancy);
+    if (seen.has(field)) {
+      throw new OkmError2("OKM1020", `View column ${column.name} repeats ${field}.`, {
+        fix: { summary: "Declare each output column once." }
+      });
+    }
+    seen.add(field);
+    const uuid = column.type.toLowerCase() === "uuid";
+    const key = tenancy !== undefined && field === tenancy.key;
+    models.push({
+      field,
+      sql: column.name,
+      dataType: column.type,
+      encode: uuid ? (value) => encodeUuid(textValue(value)) : (value) => encodeText(textValue(value)),
+      decode: uuid ? decodeUuid : decodeText,
+      hidden: false,
+      sensitive: false,
+      guarded: key,
+      writable: false,
+      guardUpdate: false
+    });
+  }
+  return models;
+}
+function exposesKey(columns, tenancy) {
+  if (tenancy === undefined)
+    return false;
+  return columns.some((column) => fieldName(column.name, tenancy) === tenancy.key);
+}
+function readsTenant(query, tables, casing, scoped) {
+  for (const name of scoped) {
+    if (viewMentions(query, name))
+      return true;
+  }
+  for (const table of tables) {
+    const mark = table.options?.tenancy;
+    if (isGlobalMark(mark))
+      continue;
+    const sql = casing === "snake" ? snakeCase(table.name) : table.name;
+    if (viewMentions(query, sql) || viewMentions(query, table.name))
+      return true;
+  }
+  return false;
+}
+function readGlobal(name, tenancy) {
+  if (tenancy === undefined)
+    return;
+  if (!isGlobalMark(tenancy)) {
+    throw new OkmError2("OKM1020", `View ${name} tenancy must be global("reason").`, {
+      fix: { summary: 'Pass global("reason") from okmodel/tenancy, or omit tenancy.' }
+    });
+  }
+  return tenancy.reason;
+}
+function isGlobalMark(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const record = value;
+  return record.kind === "global" && typeof record.reason === "string" && record.reason.trim().length > 0;
+}
+function fieldName(column, tenancy) {
+  const field = camelCase(column);
+  if (tenancy !== undefined && (column === tenancy.key || field === tenancy.key))
+    return tenancy.key;
+  return field;
+}
+function camelCase(name) {
+  let out = "";
+  let upper = false;
+  for (const char of name) {
+    if (char === "_") {
+      upper = out.length > 0;
+      continue;
+    }
+    out += upper ? char.toUpperCase() : char;
+    upper = false;
+  }
+  return out;
+}
+function textValue(value) {
+  if (typeof value !== "string") {
+    throw new OkmError2("OKM1121", "A view column value must be text.", {
+      fix: { summary: "Pass a string." }
+    });
+  }
+  return value;
+}
+
+export { viewGlobalReason, viewMentions, viewClient };

package/dist/shared/5fe3kbsh.js

@@ -0,0 +1,10 @@
+import {
+  resetSession2,
+  resetQueried2,
+  refuseWhenLost2
+} from "./zm0ptry0.js";
+export {
+  refuseWhenLost2 as refuseWhenLost,
+  resetQueried2 as resetQueried,
+  resetSession2 as resetSession
+};

package/dist/shared/5v3xf80k.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 "./1w508jbr.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
+};