okmodel 0.6.0 → 0.8.0

package/dist/dialects/pg/index.js

@@ -1,12 +1,32 @@
+import"../../shared/12z7aznj.js";
 import {
   jsonReplacer2,
   json2,
   jsonb2
-} from "../../shared/9628a9xt.js";
+} from "../../shared/vk7rag46.js";
+import {
+  searchValue
+} from "../../shared/dzj09cye.js";
+import {
+  rowNumber2,
+  rank2,
+  denseRank2,
+  runningTotal2
+} from "../../shared/9a4ae4p8.js";
+import {
+  bucket2
+} from "../../shared/nbw1z4yd.js";
 import {
   withOwner2
 } from "../../shared/xqve9598.js";
 import {
+  smallint2,
+  integer2,
+  bigint2,
+  identity2,
+  encodeBigintString,
+  decodeBigintString,
+  integerToken,
   encodeInstant,
   decodeInstant,
   encodeDate,
@@ -17,22 +37,22 @@ import {
   time2,
   timetz2,
   interval2
-} from "../../shared/5yv4k6a6.js";
+} from "../../shared/nmnsgj7x.js";
 import {
-  schema2
-} from "../../shared/hazqqecq.js";
+  id2,
+  uuid2
+} from "../../shared/ecn8mfdq.js";
 import {
-  domainType
-} from "../../shared/ywspezzx.js";
+  schema2
+} from "../../shared/9dr2qnx7.js";
 import {
   one2,
   many2,
-  manyThrough2
-} from "../../shared/k68eedmy.js";
-import {
-  id2,
-  uuid2
-} from "../../shared/2jd1sn0e.js";
+  manyThrough2,
+  morph2,
+  morphMany2,
+  morphTo2
+} from "../../shared/exn3sd90.js";
 import {
   text2,
   varchar2,
@@ -40,18 +60,28 @@ import {
   citext2,
   encodeText,
   decodeText
-} from "../../shared/ed0b8k4s.js";
+} from "../../shared/typ3vy7t.js";
 import {
   table2,
   index2,
   sql2
-} from "../../shared/rpycarcr.js";
+} from "../../shared/gcefca6p.js";
 import {
   ColumnBuilder2,
   required,
-  openColumn,
   formatType
-} from "../../shared/ywr8hmey.js";
+} from "../../shared/606g0nbf.js";
+import {
+  isFragmentParts,
+  fragment2,
+  ident2
+} from "../../shared/bsek72fg.js";
+import {
+  quoteIdent
+} from "../../shared/sjk86yrx.js";
+import {
+  domainType
+} from "../../shared/ywspezzx.js";
 import {
   definition,
   rejected
@@ -61,11 +91,15 @@ import {
   compareText
 } from "../../shared/358zsv4r.js";
 import {
+  isOperator,
+  operatorName,
+  operatorValue,
   tag
 } from "../../shared/cn0n68ft.js";
 import {
   OkmError2,
-  catalogError2
+  catalogError2,
+  throwNamed2
 } from "../../shared/52szzakm.js";
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
@@ -95,146 +129,6 @@ function custom(spec) {
     ...spec.extension !== undefined ? { extension: spec.extension } : {}
   });
 }
-// src/dialects/pg/integer.ts
-function smallint() {
-  return required({
-    baseType: "smallint",
-    encode: (value) => integerToken(value, -32768, 32767, "smallint"),
-    decode: (wire) => decodeBounded(wire, -32768, 32767, "smallint"),
-    sqlForm: "raw"
-  });
-}
-function integer() {
-  return required({
-    baseType: "integer",
-    encode: (value) => integerToken(value, -2147483648, 2147483647, "integer"),
-    decode: (wire) => decodeBounded(wire, -2147483648, 2147483647, "integer"),
-    sqlForm: "raw"
-  });
-}
-function bigint(options) {
-  const mode = options?.as ?? "string";
-  if (mode === "number") {
-    return required({
-      baseType: "bigint",
-      encode: encodeBigintNumber,
-      decode: decodeBigintNumber,
-      sqlForm: "raw",
-      typeLabel: "number"
-    });
-  }
-  if (mode === "bigint") {
-    return required({
-      baseType: "bigint",
-      encode: encodeBigintValue,
-      decode: decodeBigintValue,
-      sqlForm: "raw",
-      typeLabel: "bigint"
-    });
-  }
-  if (mode !== "string") {
-    definition(`bigint as ${String(mode)} must be string, number, or bigint.`);
-  }
-  return required({
-    baseType: "bigint",
-    encode: encodeBigintString,
-    decode: decodeBigintString,
-    sqlForm: "raw"
-  });
-}
-function identity(options) {
-  const mode = options?.as ?? "string";
-  if (mode === "number") {
-    return openColumn({
-      ...identityFlags(),
-      encode: encodeBigintNumber,
-      decode: decodeBigintNumber,
-      typeLabel: "number"
-    });
-  }
-  if (mode === "bigint") {
-    return openColumn({
-      ...identityFlags(),
-      encode: encodeBigintValue,
-      decode: decodeBigintValue,
-      typeLabel: "bigint"
-    });
-  }
-  if (mode !== "string") {
-    definition(`identity as ${String(mode)} must be string, number, or bigint.`);
-  }
-  return openColumn({
-    ...identityFlags(),
-    encode: encodeBigintString,
-    decode: decodeBigintString
-  });
-}
-function encodeBigintString(value) {
-  parseBigint(value);
-  return value;
-}
-function decodeBigintString(wire) {
-  return encodeBigintString(wire);
-}
-function encodeBigintNumber(value) {
-  if (!Number.isSafeInteger(value)) {
-    rejected(`bigint number ${String(value)} must be an integer from ${String(Number.MIN_SAFE_INTEGER)} to ${String(Number.MAX_SAFE_INTEGER)}.`);
-  }
-  return String(value);
-}
-function decodeBigintNumber(wire) {
-  const parsed = parseBigint(wire);
-  const value = Number(parsed);
-  if (!Number.isSafeInteger(value)) {
-    rejected(`bigint ${wire} must be an integer from ${String(Number.MIN_SAFE_INTEGER)} to ${String(Number.MAX_SAFE_INTEGER)} when as is number.`);
-  }
-  return value;
-}
-function encodeBigintValue(value) {
-  return value.toString();
-}
-function decodeBigintValue(wire) {
-  return parseBigint(wire);
-}
-function integerToken(value, min, max, role) {
-  if (!Number.isInteger(value) || value < min || value > max) {
-    rejected(`${role} ${String(value)} must be an integer from ${String(min)} to ${String(max)}.`);
-  }
-  return String(value);
-}
-function decodeBounded(wire, min, max, role) {
-  if (!integerText().test(wire)) {
-    rejected(`${role} ${wire} must be an integer, for example 0 or -12.`);
-  }
-  const value = Number(wire);
-  integerToken(value, min, max, role);
-  return value;
-}
-function identityFlags() {
-  return {
-    baseType: "bigint",
-    nullable: false,
-    hasDefault: true,
-    generated: false,
-    guarded: false,
-    hidden: false,
-    omitWrite: true,
-    sqlForm: "raw",
-    identity: { always: true },
-    primaryKey: true
-  };
-}
-function parseBigint(wire) {
-  if (!integerText().test(wire)) {
-    rejected(`bigint ${wire} must be an integer with no leading zeros, for example 0 or -12.`);
-  }
-  return BigInt(wire);
-}
-function integerText() {
-  integerPattern ??= /^-?(?:0|[1-9]\d*)$/;
-  return integerPattern;
-}
-var integerPattern;
 // src/dialects/pg/finite.ts
 function decimalText(value, role) {
   if (!Number.isFinite(value)) {
@@ -761,11 +655,11 @@ function canonicalScalar(typeName) {
 // src/dialects/pg/namespace.ts
 var t = {
   id: id2,
-  identity,
+  identity: identity2,
   uuid: uuid2,
-  smallint,
-  integer,
-  bigint,
+  smallint: smallint2,
+  integer: integer2,
+  bigint: bigint2,
   numeric,
   real,
   double,
@@ -887,11 +781,11 @@ function like(pattern) {
 }
 // src/dialects/pg/ops/matches.ts
 function matches(query, options) {
-  return tag("matches", {
-    query,
-    mode: options?.mode ?? "websearch",
-    config: options?.config
-  });
+  return tag("matches", searchValue(query, options));
+}
+// src/dialects/pg/ops/relevance.ts
+function relevance(query, options) {
+  return tag("relevance", searchValue(query, options));
 }
 // src/dialects/pg/ops/lt.ts
 function lt(value) {
@@ -934,12 +828,371 @@ function path(segments, op) {
 function startsWith(value) {
   return tag("startsWith", value);
 }
+// src/dialects/pg/ops/lane.ts
+var LANE = Symbol.for("okm.lane");
+var READ = "read";
+var WRITE = "write";
+var BLOCKED = new Set(["__proto__", "constructor", "toString", "hasOwnProperty"]);
+async function raw(handle, cls, statement, source) {
+  const lane = readLane(handle);
+  const kind = readClass(statement);
+  const indexed = openTable(lane);
+  const parts = readParts(source);
+  const compiled = compile(indexed, parts);
+  const word = verb(compiled.text);
+  if (kind === READ && word !== "select") {
+    bad("A raw read starts with select.", 'Pass "read" and a single select. A leading with is a write.');
+  }
+  if (kind === WRITE && word !== "insert" && word !== "update" && word !== "delete") {
+    bad("A raw write starts with insert, update, or delete.", 'Pass "write" and one insert, update, or delete.');
+  }
+  const tenancy = predicateOf(lane.session, indexed);
+  if (kind === WRITE && tenancy !== undefined) {
+    unverifiable("A raw write on a tenant table cannot keep the tenant predicate.", 'Use update or delete. unscoped("reason") is the reviewed hatch.');
+  }
+  const guard = kind === READ ? guardOf(indexed, tenancy, compiled.params.length) : undefined;
+  if (guard !== undefined)
+    requireKey(indexed, lane.session.schema.tenancy?.key, parts);
+  const text = guard === undefined ? compiled.text : wrap(indexed, lane.session.schema.tenancy?.key, compiled.text, guard.text);
+  const params = guard === undefined ? compiled.params : [...compiled.params, ...guard.params];
+  await lane.session.connected;
+  try {
+    const result = await lane.session.pool.execute(text, params, kind === WRITE ? { route: "primary" } : undefined);
+    return decodeRows(cls, result.rows, indexed);
+  } catch (error) {
+    return raise(lane, error);
+  }
+}
+async function explain(handle, query) {
+  const lane = readLane(handle);
+  const got = readPlanned(await readSql(query));
+  if (production())
+    return { text: got.text, params: [], plan: null };
+  await lane.session.connected;
+  let rows;
+  try {
+    const result = await lane.session.pool.execute(`explain ${got.text}`, got.params);
+    rows = result.rows;
+  } catch (error) {
+    return raise(lane, error);
+  }
+  const plan = [];
+  for (const row of rows) {
+    const line = row[0];
+    if (typeof line === "string")
+      plan.push(line);
+  }
+  return { text: got.text, params: got.params, plan };
+}
+async function raise(lane, error) {
+  const mapped = await lane.fail(lane.session, error);
+  lane.session.logger?.error?.({ code: mapped.code, summary: mapped.summary });
+  throw mapped;
+}
+function production() {
+  const proc = Reflect.get(globalThis, "process");
+  if (typeof proc !== "object" || proc === null)
+    return false;
+  const env = Reflect.get(proc, "env");
+  if (typeof env !== "object" || env === null)
+    return false;
+  return Reflect.get(env, "NODE_ENV") === "production";
+}
+function readLane(handle) {
+  const value = Reflect.get(handle, LANE);
+  if (!Array.isArray(value)) {
+    bad("Pass the table handle.", "raw and explain take the table, such as db.notes, including a table from for().");
+  }
+  const session = value[0];
+  const table = value[1];
+  const fail = value[2];
+  if (typeof table !== "string" || typeof fail !== "function" || !isSession(session)) {
+    bad("Pass the table handle.", "raw and explain take the table, such as db.notes, including a table from for().");
+  }
+  return { session, table, fail };
+}
+function isSession(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const schema = Reflect.get(value, "schema");
+  const connected = Reflect.get(value, "connected");
+  const pool = Reflect.get(value, "pool");
+  if (typeof schema !== "object" || schema === null)
+    return false;
+  if (typeof Reflect.get(schema, "model") !== "object")
+    return false;
+  if (typeof connected !== "object" || connected === null || typeof Reflect.get(connected, "then") !== "function") {
+    return false;
+  }
+  return typeof pool === "object" && pool !== null && typeof Reflect.get(pool, "execute") === "function";
+}
+function readSql(query) {
+  const sql = Reflect.get(query, "sql");
+  if (typeof sql !== "function") {
+    bad("Pass a query.", "explain takes the table and a query from that table, such as notes.find({ limit: 1 }).");
+  }
+  return sql.call(query);
+}
+function readPlanned(value) {
+  if (typeof value !== "object" || value === null) {
+    bad("The statement has no text.", "Call explain on a query.");
+  }
+  const text = Reflect.get(value, "text");
+  const params = Reflect.get(value, "params");
+  if (typeof text !== "string" || !Array.isArray(params)) {
+    bad("The statement has no text.", "Call explain on a query.");
+  }
+  const bound = [];
+  for (const param of params) {
+    if (typeof param !== "string" && param !== null) {
+      bad("A statement parameter was not text.", "Parameters are bound text.");
+    }
+    bound.push(param);
+  }
+  return { text, params: bound };
+}
+function openTable(lane) {
+  const model = lane.session.schema.model[lane.table];
+  if (model === undefined) {
+    bad(`Table ${lane.table} is not in the schema.`, "Call raw on a table this schema declares.");
+  }
+  const columns = new Map;
+  const names = [];
+  for (const column of model.columns) {
+    columns.set(column.field, column);
+    names.push(column.field);
+  }
+  names.sort();
+  return { model, columns, names };
+}
+function compile(table, parts) {
+  const params = [];
+  const chunks = [];
+  let count = 0;
+  const sink = {
+    text(value) {
+      chunks.push(value);
+    },
+    param(encoded) {
+      params.push(encoded);
+      count += 1;
+      chunks.push(`$${String(count)}`);
+    },
+    mark() {}
+  };
+  for (const part of parts)
+    writePart(part, sink, table);
+  return { text: chunks.join(""), params };
+}
+function writePart(part, sink, table) {
+  if (part.k === "t") {
+    sink.text(part.s);
+    return;
+  }
+  if (part.k === "p") {
+    sink.param(part.v);
+    return;
+  }
+  if (part.k === "n") {
+    sink.text("null");
+    return;
+  }
+  if (part.k === "i") {
+    writeIdent(part.n, sink, table);
+    return;
+  }
+  if (part.k === "c") {
+    throw new OkmError2("OKM1125", "fragment.column belongs on a where field.", {
+      fix: { summary: "Use ident(name) in a raw statement." }
+    });
+  }
+  sink.text("(");
+  for (const nested of part.parts)
+    writePart(nested, sink, table);
+  sink.text(")");
+}
+function writeIdent(name, sink, table) {
+  const column = table.columns.get(name);
+  if (column === undefined) {
+    throwNamed2("OKM1120", name, table.names, `Field ${name} is not on ${table.model.name}. Accepted names: ${table.names.join(", ")}.`);
+  }
+  if (column.hidden) {
+    throw new OkmError2("OKM1120", `Field ${column.field} is hidden.`, {
+      fix: { summary: "A raw statement cannot name a hidden field." }
+    });
+  }
+  sink.text(quoteIdent(column.sql));
+}
+function readClass(statement) {
+  if (statement === READ || statement === WRITE)
+    return statement;
+  bad('The statement class is "read" or "write".', 'Pass "read" or "write".');
+}
+function readParts(source) {
+  if (typeof source !== "object" || source === null) {
+    bad("Pass fragment`...`.", "Identifiers are ident(name). A string, number, boolean, or null is a parameter.");
+  }
+  if (typeof Reflect.get(source, "as") === "string") {
+    bad("Pass the fragment, not .as(name).", "The class names the row. Drop .as().");
+  }
+  if (!isOperator(source) || operatorName(source) !== "sql") {
+    bad("Pass fragment`...`.", "Identifiers are ident(name). A string, number, boolean, or null is a parameter.");
+  }
+  const stored = operatorValue(source);
+  if (!isFragmentParts(stored)) {
+    bad("Pass fragment`...`.", "Call fragment`...`. Do not build the parts yourself.");
+  }
+  return stored;
+}
+function verb(text) {
+  return /^[a-z]+/i.exec(text.trimStart())?.[0]?.toLowerCase() ?? "";
+}
+function predicateOf(session, table) {
+  const tenancy = session.schema.tenancy;
+  if (tenancy === undefined)
+    return;
+  const chunks = [];
+  const params = [];
+  let count = 0;
+  const wrote = tenancy.predicate({
+    table: table.model.name,
+    fieldSql: (field) => table.columns.get(field)?.sql,
+    encode: table.columns.get(tenancy.key)?.encode,
+    alias: "okm_tenant",
+    appended: false,
+    scope: session.scope,
+    sink: {
+      text(value) {
+        chunks.push(value);
+      },
+      param(encoded) {
+        params.push(encoded);
+        count += 1;
+        chunks.push(`$${String(count)}`);
+      },
+      mark() {}
+    }
+  });
+  if (!wrote)
+    return;
+  return { text: chunks.join("").replace(/^\s*where\s+/i, ""), params };
+}
+function guardOf(table, tenancy, userCount) {
+  const archive = table.model.archive?.at;
+  if (tenancy === undefined && archive === undefined)
+    return;
+  const parts = [];
+  if (tenancy !== undefined)
+    parts.push(shift(tenancy.text, userCount));
+  if (archive !== undefined)
+    parts.push(`okm_tenant.${quoteIdent(archive)} is null`);
+  return { text: parts.join(" and "), params: tenancy?.params ?? [] };
+}
+function requireKey(table, tenantKey, parts) {
+  const key = rowKey(table, tenantKey);
+  if (key === undefined) {
+    unverifiable("A raw read needs one primary key column besides the tenant key.", "Declare one primary key. The tenant predicate binds that column.");
+  }
+  if (!namesIdent(parts, key)) {
+    unverifiable(`A raw read must select ${key} with ident.`, `Put ident("${key}") in the select list. Do not alias it. The tenant predicate is added outside the statement.`);
+  }
+}
+function rowKey(table, tenantKey) {
+  const keys = table.model.primary.filter((field) => field !== tenantKey);
+  return keys.length === 1 ? keys[0] : undefined;
+}
+function namesIdent(parts, name) {
+  for (const part of parts) {
+    if (part.k === "i" && part.n === name)
+      return true;
+    if (part.k === "f" && namesIdent(part.parts, name))
+      return true;
+  }
+  return false;
+}
+function wrap(table, tenantKey, text, where) {
+  const key = rowKey(table, tenantKey);
+  const column = key === undefined ? undefined : table.columns.get(key);
+  if (column === undefined) {
+    unverifiable("A raw read needs one primary key column besides the tenant key.", "Declare one primary key. The tenant predicate binds that column.");
+  }
+  const quoted = quoteIdent(column.sql);
+  return `select okm_raw.* from (${text}) as okm_raw where okm_raw.${quoted} in (select ${quoted} from ${quoteIdent(table.model.sql)} as okm_tenant where ${where})`;
+}
+function shift(text, by) {
+  if (by === 0)
+    return text;
+  return text.replace(/\$(\d+)/g, (_match, digits) => `$${String(Number(digits) + by)}`);
+}
+function decodeRows(cls, rows, table) {
+  const ctor = readClassCtor(cls);
+  const sample = construct(ctor);
+  const keys = Object.keys(sample);
+  if (keys.length === 0) {
+    bad("The class needs an initializer on every result column.", 'Write `id = ""` or `n = 0`. The initializer selects the decode, and the order is the select list.');
+  }
+  for (const key of keys) {
+    if (BLOCKED.has(key))
+      bad(`Field ${key} is reserved.`, "Rename the class field.");
+  }
+  return rows.map((wire) => {
+    const row = construct(ctor);
+    for (let index = 0;index < keys.length; index += 1) {
+      const key = keys[index];
+      if (key === undefined)
+        continue;
+      Reflect.set(row, key, decodeWire(wire[index], Reflect.get(sample, key), table.columns.get(key)));
+    }
+    return row;
+  });
+}
+function readClassCtor(cls) {
+  if (typeof cls !== "function") {
+    bad("Pass a class.", "The result of raw is one instance of that class per row.");
+  }
+  return cls;
+}
+function construct(ctor) {
+  try {
+    return new ctor;
+  } catch {
+    bad("The class must construct with no arguments.", "Give each field an initializer and no constructor arguments.");
+  }
+}
+function decodeWire(wire, sample, column) {
+  if (wire === null || wire === undefined)
+    return null;
+  if (column !== undefined)
+    return column.decode === undefined ? wire : column.decode(wire);
+  if (typeof sample === "number") {
+    const parsed = Number(wire);
+    if (!Number.isFinite(parsed)) {
+      bad("A class field initialized with a number received a non-numeric value.", "Use a numeric expression, or initialize the field with a string.");
+    }
+    return parsed;
+  }
+  if (typeof sample === "boolean") {
+    if (wire === "t" || wire === "true" || wire === "1")
+      return true;
+    if (wire === "f" || wire === "false" || wire === "0")
+      return false;
+    bad("A class field initialized with a boolean received another value.", "Use a boolean expression, or initialize the field with a string.");
+  }
+  return wire;
+}
+function bad(message, fix) {
+  throw new OkmError2("OKM1602", message, { fix: { summary: fix } });
+}
+function unverifiable(message, fix) {
+  throw new OkmError2("OKM1702", message, { fix: { summary: fix } });
+}
 export {
   ColumnBuilder2 as ColumnBuilder,
   exports_arr_ns as arr,
   between,
-  bigint,
+  bigint2 as bigint,
   boolean,
+  bucket2 as bucket,
   bytea,
   char2 as char,
   cidr,
@@ -949,19 +1202,23 @@ export {
   custom,
   date2 as date,
   daterange,
+  denseRank2 as denseRank,
   domain,
   double,
   endsWith,
   enumColumn as enum,
   eq,
   every,
+  explain,
+  fragment2 as fragment,
   gt,
   gte,
   has,
   hasAnyKey,
   hasKey,
   id2 as id,
-  identity,
+  ident2 as ident,
+  identity2 as identity,
   ilike,
   inList,
   inc,
@@ -969,7 +1226,7 @@ export {
   inet,
   int4range,
   int8range,
-  integer,
+  integer2 as integer,
   interval2 as interval,
   exports_json_ns as json,
   jsonReplacer2 as jsonReplacer,
@@ -984,6 +1241,9 @@ export {
   many2 as many,
   manyThrough2 as manyThrough,
   matches,
+  morph2 as morph,
+  morphMany2 as morphMany,
+  morphTo2 as morphTo,
   none,
   not,
   notIn,
@@ -994,9 +1254,14 @@ export {
   overlaps,
   path,
   point,
+  rank2 as rank,
+  raw,
   real,
+  relevance,
+  rowNumber2 as rowNumber,
+  runningTotal2 as runningTotal,
   schema2 as schema,
-  smallint,
+  smallint2 as smallint,
   sql2 as sql,
   startsWith,
   t,