okmodel 0.7.0 → 0.9.0

package/dist/tooling/shared/ybdew6j7.js

@@ -0,0 +1,294 @@
+import {
+  assertNoControl
+} from "./w5d89rb4.js";
+import {
+  OkmError,
+  throwNamed,
+  isOperator,
+  operatorName,
+  operatorValue,
+  tag,
+  refuseHidden,
+  quote,
+  list,
+  fail2
+} from "./hfq3n3bd.js";
+
+// src/dialects/pg/ops/fragment.ts
+var IDENT = Symbol("okmodel.sql.ident");
+var COLUMN = Symbol("okmodel.sql.column");
+function fragmentError(message, fix) {
+  throw new OkmError("OKM1125", message, { fix: { summary: fix } });
+}
+function isFragmentParts(value) {
+  return Array.isArray(value) && value.every(isPart);
+}
+function isPart(value) {
+  if (typeof value !== "object" || value === null || !("k" in value))
+    return false;
+  const kind = value.k;
+  if (kind === "t")
+    return "s" in value && typeof value.s === "string";
+  if (kind === "p")
+    return "v" in value && typeof value.v === "string";
+  if (kind === "n" || kind === "c")
+    return true;
+  if (kind === "i")
+    return "n" in value && typeof value.n === "string";
+  if (kind === "f")
+    return "parts" in value && isFragmentParts(value.parts);
+  return false;
+}
+function readSelectFragment(value) {
+  if (!isOperator(value) || operatorName(value) !== "sql")
+    return;
+  const named = value;
+  if (typeof named.as !== "string") {
+    fragmentError("A select fragment needs as(name).", 'Call .as("len") and pass that value in select.');
+  }
+  const stored = operatorValue(value);
+  if (!isFragmentParts(stored)) {
+    fragmentError("A fragment was not created by fragment``.", "Call fragment`...`.");
+  }
+  const textual = named.text === true;
+  return textual ? { as: named.as, parts: stored, textual: true } : { as: named.as, parts: stored };
+}
+function scanLiteral(literal, state) {
+  for (let index = 0;index < literal.length; index += 1) {
+    const char = literal[index] ?? "";
+    const code = literal.charCodeAt(index);
+    if (state.quote !== undefined) {
+      if (char !== state.quote)
+        continue;
+      if (literal[index + 1] === state.quote) {
+        index += 1;
+        continue;
+      }
+      state.quote = undefined;
+      continue;
+    }
+    if (code <= 31 && code !== 9 && code !== 10 && code !== 13 || code === 127) {
+      fragmentError("A fragment literal contains a control character.", "Remove NUL and other control characters. A newline, tab, or return is allowed.");
+    }
+    if (char === "'" || char === '"') {
+      state.quote = char;
+      continue;
+    }
+    if (char === "(") {
+      state.paren += 1;
+      continue;
+    }
+    if (char === ")") {
+      state.paren -= 1;
+      if (state.paren < 0) {
+        fragmentError("A fragment has unbalanced SQL.", "Keep parentheses and quotes balanced. A fragment cannot close the surrounding predicate.");
+      }
+      continue;
+    }
+    if (char === ";") {
+      fragmentError("A fragment cannot include a semicolon.", "Pass the value as an interpolation. The fragment is one expression.");
+    }
+    if (char === "$") {
+      fragmentError("A fragment cannot include a dollar quote or a parameter marker.", "Interpolate the value. The planner numbers parameters.");
+    }
+    if (char === "-" && literal[index + 1] === "-" || char === "/" && literal[index + 1] === "*") {
+      fragmentError("A fragment cannot include a comment.", "Remove the comment. A comment can hide the rest of the predicate.");
+    }
+  }
+}
+function appendText(parts, literal) {
+  if (literal.length === 0)
+    return;
+  parts.push({ k: "t", s: literal });
+}
+function appendValue(parts, value) {
+  if (value === null) {
+    parts.push({ k: "n" });
+    return;
+  }
+  if (typeof value === "string") {
+    parts.push({ k: "p", v: value });
+    return;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      fragmentError("A fragment needs a finite number.", "Pass a finite number, or leave it out.");
+    }
+    parts.push({ k: "p", v: String(value) });
+    return;
+  }
+  if (typeof value === "boolean") {
+    parts.push({ k: "p", v: value ? "true" : "false" });
+    return;
+  }
+  if (typeof value === "bigint") {
+    parts.push({ k: "p", v: String(value) });
+    return;
+  }
+  if (typeof value === "object") {
+    if (COLUMN in value) {
+      parts.push({ k: "c" });
+      return;
+    }
+    if (IDENT in value) {
+      const name = value[IDENT];
+      if (typeof name === "string") {
+        parts.push({ k: "i", n: name });
+        return;
+      }
+    }
+    if (isOperator(value) && operatorName(value) === "sql") {
+      const nested = operatorValue(value);
+      if (!isFragmentParts(nested)) {
+        fragmentError("A fragment was not created by fragment``.", "Call fragment`...`.");
+      }
+      parts.push({ k: "f", parts: nested });
+      return;
+    }
+  }
+  fragmentError("A fragment cannot interpolate that value.", "Interpolate a string, number, boolean, null, ident(name), fragment.column, or another fragment.");
+}
+function hasSql(parts) {
+  for (const part of parts) {
+    if (part.k === "t") {
+      if (part.s.trim().length > 0)
+        return true;
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
+function compile(strings, values) {
+  const state = { quote: undefined, paren: 0 };
+  const parts = [];
+  for (let index = 0;index < values.length + 1; index += 1) {
+    const literal = strings[index] ?? "";
+    scanLiteral(literal, state);
+    appendText(parts, literal);
+    if (index === values.length)
+      continue;
+    if (state.quote !== undefined) {
+      fragmentError("A fragment cannot interpolate inside quotes.", "Do not put an interpolation inside quotes. Write title = ${name}.");
+    }
+    appendValue(parts, values[index]);
+  }
+  if (state.quote !== undefined || state.paren !== 0) {
+    fragmentError("A fragment has unbalanced SQL.", "Keep parentheses and quotes balanced. A fragment cannot close the surrounding predicate.");
+  }
+  if (!hasSql(parts)) {
+    fragmentError("A fragment needs SQL text.", "Write an expression, or interpolate a value.");
+  }
+  return parts;
+}
+function isTemplate(value) {
+  return Array.isArray(value) && "raw" in value;
+}
+function bind(parts, textual = false) {
+  const tagged = tag("sql", parts);
+  return Object.assign(tagged, {
+    as(name) {
+      if (typeof name !== "string" || name.length === 0) {
+        fragmentError("as(name) needs a result name.", 'Call .as("len") with a name that is not a column.');
+      }
+      assertNoControl(name, "fragment as");
+      const selected = Object.assign(tag("sql", parts), { as: name });
+      return textual ? Object.assign(selected, { text: true }) : selected;
+    }
+  });
+}
+function fragmentTag(strings, ...values) {
+  if (!isTemplate(strings)) {
+    fragmentError("Call fragment as a template: fragment`...`.", "Write fragment`length(${fragment.column}) > ${1}`.");
+  }
+  return bind(compile(strings, values));
+}
+var fragment = Object.assign(fragmentTag, {
+  column: { [COLUMN]: true }
+});
+
+// src/runtime/sql-fragment.ts
+function emitSqlValue(table, ref, value, sink) {
+  const dot = ref.indexOf(".");
+  const alias = dot < 0 ? ref : ref.slice(0, dot);
+  writeFragment(requireParts(value), sink, alias, ref, table, "where");
+}
+function emitSqlSelect(table, parts, sink, alias) {
+  writeFragment(parts, sink, alias, undefined, table, "select");
+}
+function decodeSqlNumber(wire) {
+  const parsed = Number(wire);
+  if (!Number.isFinite(parsed)) {
+    throw new OkmError("OKM1125", "A select fragment must be a number.", {
+      fix: { summary: "Use a numeric expression, such as length(title). Text stays in where." }
+    });
+  }
+  return parsed;
+}
+function requireParts(value) {
+  if (!isFragmentParts(value)) {
+    throw new OkmError("OKM1125", "A fragment was not created by fragment``.", {
+      fix: { summary: "Call fragment`...`." }
+    });
+  }
+  return value;
+}
+function writeFragment(parts, sink, alias, ref, table, place) {
+  sink.mark(":g");
+  sink.text("(");
+  for (const part of parts)
+    writePart(part, sink, alias, ref, table, place);
+  sink.mark(":g");
+  sink.text(")");
+}
+function writePart(part, sink, alias, ref, table, place) {
+  if (part.k === "t") {
+    sink.mark(`:t:${String(part.s.length)}:${part.s}`);
+    sink.text(part.s);
+    return;
+  }
+  if (part.k === "p") {
+    sink.mark(":p");
+    sink.param(part.v);
+    return;
+  }
+  if (part.k === "n") {
+    sink.mark(":n");
+    sink.text("null");
+    return;
+  }
+  if (part.k === "i") {
+    writeIdent(part.n, table, sink, alias, place);
+    return;
+  }
+  if (part.k === "c") {
+    if (ref === undefined) {
+      throw new OkmError("OKM1125", "fragment.column belongs on a where field.", {
+        fix: { summary: "Use ident(name) in select, or put fragment.column on a where field." }
+      });
+    }
+    sink.mark(":c");
+    sink.text(ref);
+    return;
+  }
+  writeFragment(part.parts, sink, alias, ref, table, place);
+}
+function writeIdent(name, table, sink, alias, place) {
+  const column = table.columns.get(name);
+  if (column === undefined) {
+    throwNamed("OKM1120", name, table.names, `Field ${name} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+  }
+  if (place === "select") {
+    if (column.hidden) {
+      fail2("OKM1120", `Field ${column.field} is hidden.`, "A select fragment cannot name a hidden field.");
+    }
+  } else {
+    refuseHidden(column);
+  }
+  sink.mark(`:i:${String(column.field.length)}:${column.field}`);
+  sink.text(alias);
+  sink.text(".");
+  sink.text(quote(column.sql));
+}
+
+export { readSelectFragment, emitSqlValue, emitSqlSelect, decodeSqlNumber };

package/dist/tooling/shared/yfedr1zb.js

@@ -0,0 +1,6 @@
+import {
+  mapPostgresError2
+} from "./hfq3n3bd.js";
+export {
+  mapPostgresError2 as mapPostgresError
+};

package/dist/tooling/shared/yhp829bx.js

@@ -0,0 +1,177 @@
+import {
+  build3
+} from "./829fjxyw.js";
+import {
+  attachHttp
+} from "./jr2nmr81.js";
+import {
+  OkmError,
+  rejectKeys,
+  readLimit,
+  indexes,
+  isRecord,
+  fail2
+} from "./hfq3n3bd.js";
+
+// src/runtime/read-stream.ts
+var DEFAULT_BATCH = 1000;
+var MAX_BATCH = 2147483647;
+async function* streamRows(session, call, mods, view, batchOptions, log) {
+  const stop = (error) => {
+    throw log(attachHttp(session.http, error));
+  };
+  let batch;
+  let total;
+  let signal;
+  let deadline;
+  try {
+    if (call.op !== "find") {
+      fail2("OKM1120", `stream() reads rows from find(). ${call.op}() returns one value.`);
+    }
+    if (call.search !== undefined) {
+      fail2("OKM1120", "stream() does not take search in this version. Use find({ search, limit }) for a ranked list.", "Ranked pages are later. find({ search, limit }) returns one ranked list.");
+    }
+    if (Array.isArray(call.select) && call.select.some((item) => typeof item !== "string")) {
+      fail2("OKM1120", "stream() does not take a window. The keyset cursor has no window value to encode.");
+    }
+    const indexed = indexes(session.schema).get(call.table);
+    if (indexed === undefined)
+      fail2("OKM1120", `Table ${call.table} is not in the schema.`);
+    if (indexed.model.primary.length === 0) {
+      fail2("OKM1120", `stream() needs a primary key on ${indexed.model.name}. A keyset batch orders by that key.`, "Give the table a primary key. stream() orders by it.");
+    }
+    batch = readBatch(batchOptions);
+    if (mods.all !== undefined && mods.all.length === 0) {
+      fail2("OKM1101", "find() .all needs a reason.");
+    }
+    if (call.limit !== undefined)
+      total = readLimit(call.limit);
+    else if (mods.all === undefined) {
+      fail2("OKM1101", "find() needs a limit, or .all(reason) when the full set is intentional.");
+    }
+    const timeout = call.timeout;
+    if (timeout !== undefined && (typeof timeout !== "number" || !(timeout > 0))) {
+      fail2("OKM1121", "timeout must be a number of milliseconds above 0.");
+    }
+    signal = signalOf(call.signal);
+    deadline = timeout === undefined ? undefined : Date.now() + timeout;
+  } catch (error) {
+    if (error instanceof OkmError)
+      stop(error);
+    throw error;
+  }
+  if (total === 0)
+    return;
+  const cancel = session.pool.capabilities.cancel === true;
+  const statement = session.timeouts?.statement;
+  const pin = {};
+  let after;
+  let left = total;
+  let pending;
+  try {
+    while (left === undefined || left > 0) {
+      if (signal?.aborted === true) {
+        stop(new OkmError("cancelled", "The stream was cancelled.", { kind: "cancelled" }));
+      }
+      const remaining = timeLeft(deadline);
+      const size = left === undefined ? batch : Math.min(batch, left);
+      const handle = build3(session, call.table, pageFields(call, size, after, signal, batchTimeout(remaining, cancel, statement)), mods, view, pin);
+      pending = handle;
+      const value = asPage(await handle);
+      pending = undefined;
+      for (const row of value.items) {
+        yield row;
+        if (left !== undefined) {
+          left -= 1;
+          if (left === 0)
+            return;
+        }
+      }
+      if (value.next === null || value.items.length < size)
+        return;
+      after = value.next;
+    }
+  } catch (error) {
+    if (error instanceof OkmError && error.kind === "timeout" && error.message === "The stream timed out.") {
+      stop(error);
+    }
+    throw error;
+  } finally {
+    if (pending !== undefined) {
+      pending.then(() => {
+        return;
+      }, () => {
+        return;
+      });
+    }
+  }
+}
+function readBatch(options) {
+  if (options === undefined)
+    return DEFAULT_BATCH;
+  if (!isRecord(options))
+    fail2("OKM1120", "stream() takes an object. Pass { batch }.");
+  rejectKeys(options, ["batch"], "stream");
+  const batch = options.batch;
+  if (batch === undefined)
+    return DEFAULT_BATCH;
+  if (typeof batch !== "number" || !Number.isInteger(batch) || batch < 1 || batch > MAX_BATCH) {
+    fail2("OKM1121", "stream() batch must be an integer from 1 to 2147483647.");
+  }
+  return batch;
+}
+function pageFields(call, size, after, signal, timeout) {
+  const out = { limit: size };
+  if (call.where !== undefined)
+    out.where = call.where;
+  if (call.select !== undefined)
+    out.select = call.select;
+  if (call.orderBy !== undefined)
+    out.orderBy = call.orderBy;
+  if (call.include !== undefined)
+    out.include = call.include;
+  if (call.route !== undefined)
+    out.route = call.route;
+  if (after !== undefined)
+    out.after = after;
+  if (signal !== undefined)
+    out.signal = signal;
+  if (timeout !== undefined)
+    out.timeout = timeout;
+  return out;
+}
+function timeLeft(deadline) {
+  if (deadline === undefined)
+    return;
+  const left = deadline - Date.now();
+  if (left <= 0)
+    throw new OkmError("timeout", "The stream timed out.", { kind: "timeout" });
+  return left;
+}
+function batchTimeout(remaining, cancel, statement) {
+  if (!cancel || remaining === undefined)
+    return;
+  if (statement !== undefined && statement > 0 && statement < remaining)
+    return statement;
+  return remaining;
+}
+function signalOf(value) {
+  if (typeof value === "object" && value !== null && "aborted" in value) {
+    return value;
+  }
+  return;
+}
+function asPage(value) {
+  if (typeof value !== "object" || value === null || !("items" in value) || !("next" in value)) {
+    throw new OkmError("OKM1120", "stream() did not get a page of rows.");
+  }
+  const items = value.items;
+  const next = value.next;
+  if (!Array.isArray(items) || next !== null && typeof next !== "string") {
+    throw new OkmError("OKM1120", "stream() did not get a page of rows.");
+  }
+  return { items, next };
+}
+export {
+  streamRows
+};