okmodel 0.6.0 → 0.8.0

package/dist/shared/{ys0xzyaj.js → hqpxf4a4.js}

@@ -1,10 +1,13 @@
 import {
+  orderHasRelevance,
   emitRelationFrom,
+  needsOperatorSql,
   decodeResult,
   emitJoin,
   emitWhere,
   emitOrder,
   emitPrimaryOrder,
+  refuseHidden,
   selectedColumns,
   rejectKeys,
   readLimit,
@@ -16,8 +19,8 @@ import {
   list,
   isRecord,
   registerFailFix,
-  fail
-} from "./2z7wv5tj.js";
+  fail2
+} from "./kgwp4jdd.js";
 import {
   throwNamed2
 } from "./52szzakm.js";
@@ -26,6 +29,32 @@ import {
 registerFailFix("OKM1105", "Pass limit on the include, or call .all(reason).");
 var INCLUDE_OPTIONS = ["all", "include", "limit", "orderBy", "select", "where"];
 function emitIncludeSelect(include, alias, sink, outputs, column) {
+  const morph = include.morphTo;
+  if (morph !== undefined) {
+    if (column > 0 || outputs?.fields.length)
+      sink.text(", ");
+    sink.text(alias);
+    sink.text(".payload");
+    outputs?.includes.push({
+      name: include.name,
+      kind: "one",
+      at: column,
+      fields: [],
+      nested: [],
+      morph: {
+        typeKey: morph.typeKey,
+        targets: morph.targets.map((target) => ({
+          type: target.type,
+          fields: target.columns.map((item, at) => ({
+            key: item.field,
+            at,
+            decode: item.decode
+          }))
+        }))
+      }
+    });
+    return column + 1;
+  }
   const selected = include.columns;
   sink.mark(`i:${include.name}:${include.relation.kind}`);
   if (include.relation.kind === "many") {
@@ -109,9 +138,13 @@ function emitIncludeSelect(include, alias, sink, outputs, column) {
   return cursor;
 }
 function emitIncludeJoin(schema, include, sink, parentAlias, alias, depth) {
+  if (include.morphTo !== undefined) {
+    emitMorphJoin(schema, include, sink, parentAlias, alias, depth);
+    return;
+  }
   const child = indexes(schema).get(include.relation.table);
   if (child === undefined) {
-    fail("OKM1120", `Relation ${include.name} names ${include.relation.table}, which is not in the schema.`);
+    fail2("OKM1120", `Relation ${include.name} names ${include.relation.table}, which is not in the schema.`);
   }
   const childAlias = `r${String(depth)}_${include.name}`;
   sink.text(" left join lateral (");
@@ -135,10 +168,7 @@ function emitIncludeJoin(schema, include, sink, parentAlias, alias, depth) {
     sink.text(") as item from ");
     emitRelationFrom(schema, include.relation, child, sink, parentAlias, childAlias, depth + 1);
     emitWhere(schema, child, include.where, sink, childAlias, depth + 1, true);
-    emitOrder(child, include.orderBy, sink, childAlias);
-    if (include.orderBy === undefined && child.model.primary.length > 0) {
-      emitPrimaryOrder(child, sink, childAlias);
-    }
+    emitIncludeOrder(child, include.orderBy, sink, childAlias);
     if (include.limit !== undefined) {
       sink.text(" limit ");
       sink.param(String(include.limit));
@@ -207,9 +237,12 @@ function emitIncludeJoin(schema, include, sink, parentAlias, alias, depth) {
   sink.text(" on true");
 }
 function emitNestedAggregate(schema, include, sink, alias, depth) {
+  if (include.relation.morph?.direction === "to") {
+    fail2("OKM1120", `Include ${include.name} is a morph and cannot be nested in this version.`);
+  }
   const child = indexes(schema).get(include.relation.table);
   if (child === undefined) {
-    fail("OKM1120", `Relation ${include.name} names ${include.relation.table}, which is not in the schema.`);
+    fail2("OKM1120", `Relation ${include.name} names ${include.relation.table}, which is not in the schema.`);
   }
   const childAlias = `n${String(depth)}_${include.name}`;
   sink.text("(select coalesce(json_agg(item order by ord), '[]'::json) from (select item, row_number() over () as ord from (select json_build_array(");
@@ -226,10 +259,7 @@ function emitNestedAggregate(schema, include, sink, alias, depth) {
   sink.text(") as item from ");
   emitRelationFrom(schema, include.relation, child, sink, alias, childAlias, depth);
   emitWhere(schema, child, include.where, sink, childAlias, depth, true);
-  emitOrder(child, include.orderBy, sink, childAlias);
-  if (include.orderBy === undefined && child.model.primary.length > 0) {
-    emitPrimaryOrder(child, sink, childAlias);
-  }
+  emitIncludeOrder(child, include.orderBy, sink, childAlias);
   if (include.limit !== undefined) {
     sink.text(" limit ");
     sink.param(String(include.limit));
@@ -237,6 +267,14 @@ function emitNestedAggregate(schema, include, sink, alias, depth) {
   }
   sink.text(") limited) ordered)");
 }
+function includeColumns(table, select) {
+  const columns = selectedColumns(table, select);
+  if (select === undefined)
+    return omitHidden(columns);
+  for (const column of columns)
+    refuseHidden(column);
+  return columns;
+}
 function omitHidden(columns) {
   for (const column of columns) {
     if (!column.hidden)
@@ -249,7 +287,7 @@ function readIncludes(schema, table, include, all) {
   if (include === undefined)
     return [];
   if (!isRecord(include)) {
-    fail("OKM1120", "include must be an object of relations.");
+    fail2("OKM1120", "include must be an object of relations.");
   }
   const parsed = [];
   for (const name of Object.keys(include)) {
@@ -262,9 +300,11 @@ function readIncludes(schema, table, include, all) {
   return parsed;
 }
 function parseInclude(schema, name, relation, value, all) {
+  if (relation.morph?.direction === "to")
+    return parseMorph(schema, name, relation, value);
   if (value === true) {
     if (relation.kind === "many" && all === undefined) {
-      fail("OKM1105", `Include ${name} is to-many and has no limit. Pass limit, or call .all(reason).`);
+      fail2("OKM1105", `Include ${name} is to-many and has no limit. Pass limit, or call .all(reason).`);
     }
     const child = childIndex(schema, relation);
     const columns = omitHidden(selectedColumns(child, undefined));
@@ -280,7 +320,7 @@ function parseInclude(schema, name, relation, value, all) {
     };
   }
   if (!isRecord(value)) {
-    fail("OKM1120", `Include ${name} must be true or an object.`);
+    fail2("OKM1120", `Include ${name} must be true or an object.`);
   }
   rejectKeys(value, INCLUDE_OPTIONS, `include ${name}`);
   const reason = typeof value.all === "string" ? value.all : all;
@@ -288,10 +328,10 @@ function parseInclude(schema, name, relation, value, all) {
   if (value.limit !== undefined)
     limit = readLimit(value.limit);
   if (relation.kind === "many" && limit === undefined && reason === undefined) {
-    fail("OKM1105", `Include ${name} is to-many and has no limit. Pass limit, or call .all(reason).`);
+    fail2("OKM1105", `Include ${name} is to-many and has no limit. Pass limit, or call .all(reason).`);
   }
   const child = childIndex(schema, relation);
-  const columns = omitHidden(selectedColumns(child, value.select));
+  const columns = includeColumns(child, value.select);
   const nestedValue = value.include;
   const nested = nestedValue === undefined ? [] : readIncludes(schema, child, nestedValue, reason);
   return {
@@ -317,10 +357,125 @@ function anchored(table, columns) {
 function childIndex(schema, relation) {
   const child = indexes(schema).get(relation.table);
   if (child === undefined) {
-    fail("OKM1120", `Relation ${relation.name} names ${relation.table}, which is not in the schema.`);
+    fail2("OKM1120", `Relation ${relation.name} names ${relation.table}, which is not in the schema.`);
   }
   return child;
 }
+function parseMorph(schema, name, relation, value) {
+  if (value !== true) {
+    fail2("OKM1120", `Include ${name} is a morph. Pass true. select, where, orderBy, and limit are not available on it.`);
+  }
+  const morph = relation.morph;
+  if (morph === undefined)
+    fail2("OKM1120", `Include ${name} is not a morph.`);
+  const planned = [];
+  for (const target of morph.targets) {
+    const child = indexes(schema).get(target.table);
+    if (child === undefined) {
+      fail2("OKM1120", `Relation ${name} names ${target.table}, which is not in the schema.`);
+    }
+    planned.push({
+      type: target.type,
+      table: target.table,
+      sql: target.sql,
+      keySql: target.keySql,
+      columns: omitHidden(selectedColumns(child, undefined))
+    });
+  }
+  return {
+    name,
+    relation,
+    where: undefined,
+    orderBy: undefined,
+    limit: undefined,
+    columns: [],
+    presence: undefined,
+    anchor: 0,
+    nested: [],
+    morphTo: {
+      typeKey: morph.typeField,
+      typeSql: morph.typeSql,
+      idSql: morph.idSql,
+      targets: planned
+    }
+  };
+}
+function emitMorphJoin(schema, include, sink, parentAlias, alias, depth) {
+  const morph = include.morphTo;
+  if (morph === undefined)
+    fail2("OKM1120", `Include ${include.name} is not a morph.`);
+  sink.text(" left join lateral (select payload from (");
+  for (let index = 0;index < morph.targets.length; index += 1) {
+    const target = morph.targets[index];
+    if (target === undefined)
+      continue;
+    if (index > 0)
+      sink.text(" union all ");
+    const childAlias = `m${String(depth)}_${include.name}_${String(index)}`;
+    const child = indexes(schema).get(target.table);
+    if (child === undefined) {
+      fail2("OKM1120", `Relation ${include.name} names ${target.table}, which is not in the schema.`);
+    }
+    sink.text("select json_build_array(");
+    sink.param(target.type);
+    sink.text("::text");
+    sink.mark(`mt:${target.type}`);
+    for (const column of target.columns) {
+      sink.text(", ");
+      sink.text(jsonExpr(`${childAlias}.${quote(column.sql)}`, column.dataType));
+    }
+    sink.text(") as payload from ");
+    sink.text(quote(target.sql));
+    sink.text(" ");
+    sink.text(childAlias);
+    sink.text(" where ");
+    sink.text(parentAlias);
+    sink.text(".");
+    sink.text(quote(morph.typeSql));
+    sink.text(" = ");
+    sink.param(target.type);
+    sink.text("::text");
+    sink.text(" and ");
+    sink.text(childAlias);
+    sink.text(".");
+    sink.text(quote(target.keySql));
+    sink.text(" = ");
+    sink.text(parentAlias);
+    sink.text(".");
+    sink.text(quote(morph.idSql));
+    emitWhere(schema, child, undefined, sink, childAlias, depth + 1, true);
+  }
+  sink.text(") matched limit 1) ");
+  sink.text(alias);
+  sink.text(" on true");
+}
+function decodeMorph(include, row) {
+  const morph = include.morph;
+  if (morph === undefined)
+    return null;
+  const raw = row[include.at];
+  if (raw === null || raw === undefined)
+    return null;
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed))
+    return null;
+  const type = parsed[0];
+  if (typeof type !== "string")
+    return null;
+  let target;
+  for (const item of morph.targets) {
+    if (item.type === type)
+      target = item;
+  }
+  if (target === undefined)
+    return null;
+  const child = {};
+  for (const field of target.fields) {
+    child[field.key] = jsonCell(parsed[field.at + 1], field.decode);
+  }
+  child[morph.typeKey] = type;
+  return child;
+}
 function decodeIncluded(plan, rows, table) {
   return decodeResult(plan, rows, table, decodeRowIncluded);
 }
@@ -335,6 +490,8 @@ function decodeRowIncluded(outputs, row) {
   return result;
 }
 function decodeInclude(include, row) {
+  if (include.morph !== undefined)
+    return decodeMorph(include, row);
   if (include.kind === "many") {
     const raw = row[include.at];
     if (raw === null || raw === undefined)
@@ -390,10 +547,58 @@ function jsonCell(value, decode) {
   const wire = typeof value === "string" ? value : JSON.stringify(value);
   return decode === undefined ? wire : decode(wire);
 }
+function emitIncludeOrder(child, orderBy, sink, alias) {
+  emitOrder(child, orderBy, sink, alias);
+  const named = isRecord(orderBy) ? Object.keys(orderBy) : [];
+  if (named.length === 0) {
+    if (child.model.primary.length > 0)
+      emitPrimaryOrder(child, sink, alias);
+    return;
+  }
+  for (const field of child.model.primary) {
+    if (named.includes(field))
+      continue;
+    const column = child.columns.get(field);
+    if (column === undefined)
+      continue;
+    sink.text(", ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(column.sql));
+    sink.text(" asc");
+  }
+}
+function needsOperator(schema, call) {
+  const table = indexes(schema).get(call.table);
+  if (table === undefined)
+    return false;
+  return walkOperators(schema, table, call.include);
+}
+function walkOperators(schema, table, include) {
+  if (!isRecord(include))
+    return false;
+  for (const name of Object.keys(include)) {
+    const value = include[name];
+    if (!isRecord(value))
+      continue;
+    const relation = table.relations.get(name);
+    if (relation === undefined)
+      continue;
+    const child = indexes(schema).get(relation.table);
+    if (child === undefined)
+      continue;
+    if (needsOperatorSql(child, value.where) || orderHasRelevance(value.orderBy))
+      return true;
+    if (walkOperators(schema, child, value.include))
+      return true;
+  }
+  return false;
+}
 var includeHooks = {
   read: readIncludes,
   select: emitIncludeSelect,
-  join: emitIncludeJoin
+  join: emitIncludeJoin,
+  needsOperator
 };
 export {
   decodeIncluded,

package/dist/shared/jebgrkeq.js

@@ -0,0 +1,179 @@
+import {
+  build3
+} from "./n0jmpgj1.js";
+import {
+  attachHttp
+} from "./bah9nbg3.js";
+import {
+  rejectKeys,
+  readLimit,
+  indexes,
+  isRecord,
+  fail2
+} from "./kgwp4jdd.js";
+import {
+  OkmError2
+} from "./52szzakm.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 OkmError2)
+      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 OkmError2("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 OkmError2 && 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 OkmError2("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 OkmError2("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 OkmError2("OKM1120", "stream() did not get a page of rows.");
+  }
+  return { items, next };
+}
+export {
+  streamRows
+};

package/dist/shared/{09p049xa.js → jp36k7dp.js}

@@ -1,32 +1,33 @@
 import {
   parseCatalog2
-} from "./qq3899ht.js";
+} from "./12z7aznj.js";
 import"./n442h54c.js";
-import"./wkme6tep.js";
+import"./cm3w0ywp.js";
+import"./35q0n9tz.js";
 import {
   watchReserved2
-} from "./q3j1tq7a.js";
+} from "./wcrheftc.js";
 import {
   ensureMigrationTables2
-} from "./nx9hh281.js";
+} from "./pan0370z.js";
 import {
   sealViews,
   catalogQuery2,
   managedRoleOptions2
-} from "./f0f1n281.js";
+} from "./mkrn359n.js";
 import {
   assumeRole,
   grantSchema,
   assertSchemaUsageLanded,
   catalogsEqual,
   snapshotDifference
-} from "./p248q79y.js";
+} from "./mnvjvqyp.js";
 import {
   roleExists
-} from "./knmes2kh.js";
+} from "./kj9d8maq.js";
 import {
   introspectSchema
-} from "./vjpnzwjz.js";
+} from "./p3xbdcvt.js";
 import {
   projectPath,
   loadMigrations,
@@ -35,7 +36,7 @@ import {
   hasError,
   lintRefusal,
   openProject
-} from "./t3g0k88x.js";
+} from "./f4jy1j7x.js";
 import {
   sqlStatements,
   transactionControl,
@@ -50,13 +51,13 @@ import {
   assertDirectConnection,
   assertStableBackend,
   selectTarget
-} from "./ttmg09vd.js";
+} from "./dpc2r7rb.js";
 import {
   isConnectionLost
-} from "./gwn6v667.js";
+} from "./cnkky55j.js";
 import {
   quoteIdent
-} from "./9s0ypp87.js";
+} from "./sjk86yrx.js";
 import {
   catalog,
   isDomain
@@ -151,12 +152,18 @@ async function inCheckTransaction(url, scratch, config, allowPooler, run) {
     onnotice: () => {}
   });
   const reserved = await sql.reserve();
-  const lost = { on: false };
+  const lost = { on: false, stop: () => {
+    return;
+  } };
   watchReserved2(reserved, lost);
   refuseWhenLost(reserved, lost);
   let open = false;
   let failure;
   let value;
+  let created = false;
+  let sawCommit = false;
+  let rolledBack = false;
+  let xid = "";
   try {
     await assertStableBackend(async () => {
       const rows = await reserved.unsafe("select pg_backend_pid()::text as pid");
@@ -165,8 +172,9 @@ async function inCheckTransaction(url, scratch, config, allowPooler, run) {
     }, allowPooler);
     await reserved.unsafe("begin");
     open = true;
-    const xid = await readXid(reserved);
+    xid = await readXid(reserved);
     await reserved.unsafe(`create schema ${quoteIdent(scratch)}`);
+    created = true;
     await reserved.unsafe(`set local search_path to ${quoteIdent(scratch)}`);
     await setLocalTimeout(reserved, "lock_timeout", config.timeouts?.lock);
     await setLocalTimeout(reserved, "statement_timeout", config.timeouts?.statement);
@@ -178,21 +186,36 @@ async function inCheckTransaction(url, scratch, config, allowPooler, run) {
         lost.on = true;
       return;
     });
-    if (!lost.on && after !== xid)
+    if (!lost.on && after !== xid) {
+      sawCommit = true;
       throw xidChanged();
-    if (!lost.on)
+    }
+    if (!lost.on) {
       await reserved.unsafe("rollback");
+      rolledBack = true;
+    }
     open = false;
   } catch (error) {
     if (isConnectionLost(error))
       lost.on = true;
     failure = error;
   } finally {
+    if (open && !lost.on && !sawCommit) {
+      const after = await readXid(reserved).catch((error) => {
+        if (isConnectionLost(error))
+          lost.on = true;
+        return;
+      });
+      if (!lost.on && after !== xid)
+        sawCommit = true;
+    }
     if (open && !lost.on) {
       await reserved.unsafe("rollback").catch((error) => {
         if (isConnectionLost(error))
           lost.on = true;
       });
+      if (!lost.on && !sawCommit)
+        rolledBack = true;
     }
     if (!lost.on)
       await reserved.unsafe("reset role").catch(() => {
@@ -207,6 +230,11 @@ async function inCheckTransaction(url, scratch, config, allowPooler, run) {
     }
     await finishQuiet(() => sql.end({ timeout: 5 }));
   }
+  if (!created || rolledBack) {
+    if (failure !== undefined)
+      throw sessionFailure(failure) ?? failure;
+    return value;
+  }
   const left = await dropScratch(url, scratch);
   if (left !== undefined) {
     const note = `Scratch schema ${left} is still present.`;