okmodel 0.1.0 → 0.2.1

package/dist/shared/10tjenmd.js

@@ -0,0 +1,210 @@
+import {
+  readHandle,
+  readCall,
+  attachHttp
+} from "./mxmcdsh5.js";
+import {
+  emitWhere,
+  emitOrder,
+  rejectKeys,
+  readLimit,
+  projectExpr,
+  cell,
+  indexes,
+  quote,
+  list,
+  isRecord,
+  fail
+} from "./xrfnq5k8.js";
+import {
+  OkmError2,
+  throwNamed2
+} from "./52szzakm.js";
+
+// src/runtime/aggregate.ts
+var OPTIONS = [
+  "where",
+  "groupBy",
+  "count",
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "orderBy",
+  "limit",
+  "signal",
+  "timeout"
+];
+var NUMERIC = /^(smallint|integer|bigint|real|double precision|numeric|decimal)\b/;
+var AS_NUMBER = (wire) => Number(wire);
+var AS_TEXT = (wire) => wire;
+var UNORDERED = /^(json|jsonb|bytea|point|line|tsvector)\b|\[\]$/;
+var FUNCTIONS = [
+  { option: "sum", tag: "s", numeric: true },
+  { option: "avg", tag: "a", numeric: true },
+  { option: "min", tag: "n", numeric: false },
+  { option: "max", tag: "x", numeric: false }
+];
+function build(session, table, options, mods, view) {
+  try {
+    return plan(session, table, options, mods, view);
+  } catch (error) {
+    throw error instanceof OkmError2 ? attachHttp(session.http, error) : error;
+  }
+}
+function plan(session, table, options, mods, view) {
+  const record = isRecord(options) ? options : {};
+  rejectKeys(record, OPTIONS, "aggregate");
+  const indexed = indexes(session.schema).get(table);
+  if (indexed === undefined)
+    fail("OKM1120", `Table ${table} is not in the schema.`);
+  const spec = parse(indexed, record);
+  if (spec.groups.length > 0 && record.limit === undefined && mods.all === undefined) {
+    fail("OKM1101", "aggregate() with groupBy needs a limit, or .all(reason) for every group.");
+  }
+  const orderBy = record.orderBy;
+  if (orderBy !== undefined) {
+    if (!isRecord(orderBy))
+      fail("OKM1120", "orderBy must be an object of fields.");
+    for (const field of Object.keys(orderBy)) {
+      if (!spec.groups.some((column) => column.field === field)) {
+        throwNamed2("OKM1120", field, spec.groups.map((column) => column.field), `aggregate() orders by a groupBy field. Accepted names: ${list(spec.groups.map((column) => column.field))}.`);
+      }
+    }
+  }
+  if (record.limit !== undefined)
+    readLimit(record.limit);
+  const base = readCall("find", table, {
+    where: record.where,
+    orderBy,
+    limit: record.limit,
+    signal: record.signal,
+    timeout: record.timeout
+  }, mods.all, session.scope, session.schema.model[table], session.schema, view);
+  const call = { ...base, op: "aggregate", build: statement(spec) };
+  return readHandle(session, table, call, mods, (compiled, rows) => decode(compiled, rows));
+}
+function parse(table, record) {
+  const groups = columns(table, record.groupBy, "groupBy");
+  const count = record.count === true;
+  if (record.count !== undefined && typeof record.count !== "boolean") {
+    fail("OKM1120", "count is true when you want a row count.");
+  }
+  const calls = [];
+  for (const { option, tag, numeric } of FUNCTIONS) {
+    for (const column of columns(table, record[option], option)) {
+      const fits = numeric ? NUMERIC.test(column.dataType) : !UNORDERED.test(column.dataType);
+      if (!fits) {
+        fail("OKM1124", `${option} does not apply to ${column.dataType} column ${column.field}. ${numeric ? "sum and avg take integer, real, and numeric columns." : "min and max need an ordered type."}`);
+      }
+      calls.push({ option, tag, column, decode: numeric ? sumDecode(column) : column.decode });
+    }
+  }
+  if (!count && calls.length === 0 && groups.length === 0) {
+    fail("OKM1120", "aggregate() needs count, sum, avg, min, max, or groupBy.");
+  }
+  return { groups, count, calls };
+}
+function sumDecode(column) {
+  const kind = typeof (column.decode?.("0") ?? "");
+  if (kind === "string")
+    return AS_TEXT;
+  if (kind === "number")
+    return AS_NUMBER;
+  return fail("OKM1124", `sum and avg need a column whose value is a number or a string. ${column.field} reads as ${kind}.`);
+}
+function columns(table, value, option) {
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value))
+    fail("OKM1120", `${option} must be a list of field names.`);
+  const out = [];
+  for (const name of value) {
+    const column = typeof name === "string" ? table.columns.get(name) : undefined;
+    if (typeof name !== "string" || column === undefined) {
+      throwNamed2("OKM1120", String(name), table.names, `Field ${String(name)} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+    }
+    if (column.hidden) {
+      fail("OKM1120", `Field ${column.field} is hidden, so ${option} cannot read it.`);
+    }
+    out.push(column);
+  }
+  return out;
+}
+function statement(spec) {
+  return (schema, table, sink, outputs, call) => {
+    sink.mark(`aggregate|${table.model.name}|g:${spec.groups.map((column) => column.field).join(",")}|c:${String(spec.count)}|${spec.calls.map((item) => `${item.tag}:${item.column.field}`).join(",")}|`);
+    sink.text("select ");
+    const wrote = { at: 0 };
+    for (const column of spec.groups) {
+      put(sink, outputs, wrote, projectExpr(`t.${quote(column.sql)}`, column.dataType), {
+        key: `g:${column.field}`,
+        decode: column.decode
+      });
+    }
+    if (spec.count)
+      put(sink, outputs, wrote, "count(*)::text", { key: "c:", decode: undefined });
+    for (const item of spec.calls) {
+      const ref = `t.${quote(item.column.sql)}`;
+      const expr = item.option === "sum" || item.option === "avg" ? `${item.option}(${ref})::text` : projectExpr(`${item.option}(${ref})`, item.column.dataType);
+      put(sink, outputs, wrote, expr, {
+        key: `${item.tag}:${item.column.field}`,
+        decode: item.decode
+      });
+    }
+    sink.text(" from ");
+    sink.text(quote(table.model.sql));
+    sink.text(" t");
+    emitWhere(schema, table, call.where, sink, "t", 0);
+    if (spec.groups.length > 0) {
+      sink.text(" group by ");
+      sink.text(spec.groups.map((column) => `t.${quote(column.sql)}`).join(", "));
+      if (isRecord(call.orderBy) && Object.keys(call.orderBy).length > 0) {
+        emitOrder(table, call.orderBy, sink, "t");
+      } else {
+        sink.text(" order by ");
+        sink.text(spec.groups.map((column) => `t.${quote(column.sql)} asc nulls last`).join(", "));
+      }
+    }
+    if (call.limit !== undefined) {
+      const limit = String(call.limit);
+      sink.text(" limit ");
+      sink.param(limit);
+      sink.mark(`l:${limit}`);
+    }
+    if (typeof call.all === "string")
+      sink.mark(`all:${call.all}`);
+  };
+}
+function put(sink, outputs, wrote, expr, out) {
+  if (wrote.at > 0)
+    sink.text(", ");
+  sink.text(expr);
+  outputs?.fields.push({ key: out.key, at: wrote.at, decode: out.decode });
+  wrote.at += 1;
+}
+function decode(compiled, rows) {
+  const items = [];
+  for (const row of rows) {
+    const item = {};
+    for (const field of compiled.outputs.fields) {
+      const value = row[field.at];
+      const tag = field.key.slice(0, 2);
+      const name = field.key.slice(2);
+      if (tag === "g:") {
+        item[name] = cell(value, field.decode);
+      } else if (tag === "c:") {
+        item.count = Number(value ?? 0);
+      } else {
+        const group = tag === "s:" ? "sum" : tag === "a:" ? "avg" : tag === "n:" ? "min" : "max";
+        const into = item[group] ??= {};
+        into[name] = cell(value, field.decode);
+      }
+    }
+    items.push(item);
+  }
+  return items;
+}
+export {
+  build
+};

package/dist/shared/{tb4ze1tr.js → 1dp5knt7.js}

@@ -1,13 +1,17 @@
 import {
   PgSession
-} from "./7ck0dtry.js";
+} from "./ecdzej21.js";
+import {
+  isConnectionLost
+} from "./tbszx8mz.js";
 import {
   driverErrors,
   rejectClosed,
   mapFailure,
   runCall,
-  rowsFrom
-} from "./xy79j5hq.js";
+  rowsFrom,
+  resultFrom
+} from "./9k6vetvf.js";
 
 // src/adapters/pg/postgres-extra.ts
 var RESET_ALL = "RESET ALL";
@@ -20,12 +24,18 @@ async function checkout(pool) {
   const local = new Set;
   const session = new PgSession(reserved, pool.counters, "reserved", local, pool.isClosed, pool.poolInflight, pool.notices, pool.named);
   let released = false;
+  let lost = false;
+  const guard = (run) => lost ? rejectClosed("The connection was lost.") : run().catch((error) => {
+    if (isConnectionLost(error))
+      lost = true;
+    throw error;
+  });
   return {
-    execute: (text, params, options) => runCall(pool.isClosed(), options, (watch) => session.query(text, params, watch)),
-    batch: (statements, options) => runCall(pool.isClosed(), options, async (watch) => {
-      const { runAtomicBatch } = await import("./dynq16vb.js");
+    execute: (text, params, options) => guard(() => runCall(pool.isClosed(), options, (watch) => session.query(text, params, watch))),
+    batch: (statements, options) => guard(() => runCall(pool.isClosed(), options, async (watch) => {
+      const { runAtomicBatch } = await import("./b066g80h.js");
       return runAtomicBatch(session, statements, watch);
-    }),
+    })),
     cancel() {
       session.cancel();
     },
@@ -34,10 +44,12 @@ async function checkout(pool) {
         return;
       released = true;
       try {
-        await resetConnection(reserved, session.depth());
+        if (!lost)
+          await resetConnection(reserved, session.depth());
       } finally {
         pool.counters.reserved = Math.max(0, pool.counters.reserved - 1);
-        reserved.release();
+        if (!lost)
+          reserved.release();
       }
     }
   };
@@ -112,8 +124,81 @@ function asParams(params) {
     return [];
   return params;
 }
+async function holdCheckout(gate, checkout) {
+  try {
+    const connection = await checkout();
+    let released = false;
+    const release = connection.release.bind(connection);
+    connection.release = () => {
+      if (released)
+        return Promise.resolve();
+      released = true;
+      return release().finally(() => {
+        gate.leave();
+      });
+    };
+    return connection;
+  } catch (error) {
+    gate.leave();
+    throw error;
+  }
+}
+async function holdListener(gate, start) {
+  try {
+    const stop = await start();
+    let stopped = false;
+    return async () => {
+      if (stopped)
+        return;
+      stopped = true;
+      try {
+        await stop();
+      } finally {
+        gate.leave();
+      }
+    };
+  } catch (error) {
+    gate.leave();
+    throw error;
+  }
+}
+function watchQuery(pending, watch, onAbort, ctx) {
+  return pending.then((result) => {
+    finishWatch(pending, watch, onAbort, ctx);
+    const why = watch.reason();
+    if (why === "timeout" || why === "cancelled")
+      return classify(why, watch);
+    ctx.note(ctx.text);
+    return resultFrom(result, ctx.notices.since(ctx.start));
+  }, (error) => {
+    finishWatch(pending, watch, onAbort, ctx);
+    return classify(error, watch);
+  });
+}
+function finishWatch(pending, watch, onAbort, ctx) {
+  ctx.leave();
+  ctx.untrack(pending);
+  watch.signal.removeEventListener("abort", onAbort);
+}
+async function classify(error, watch) {
+  const errors = await driverErrors();
+  if (error instanceof errors.DriverError)
+    return Promise.reject(error);
+  const why = typeof error === "string" ? error : watch.reason();
+  if (why === "timeout") {
+    return Promise.reject(errors.timedOut(typeof error === "string" ? undefined : error));
+  }
+  const code = errors.errorField(error, "code");
+  if (why === "cancelled" || code === "57014") {
+    return Promise.reject(errors.cancelled(typeof error === "string" ? undefined : error));
+  }
+  return Promise.reject(errors.mapDriverError(error));
+}
 export {
   checkout,
   describe,
-  stream
+  holdCheckout,
+  holdListener,
+  stream,
+  watchQuery
 };

package/dist/shared/38crxbgn.js

@@ -0,0 +1,229 @@
+import {
+  quoteIdent2,
+  noticeBuffer,
+  WireSession,
+  cursorStream
+} from "./cstgkzdx.js";
+import {
+  NODE_POSTGRES_CAPABILITIES,
+  driverErrors,
+  rejectClosed,
+  mapFailure,
+  runCall
+} from "./9k6vetvf.js";
+
+// src/adapters/pg/nodepostgres.ts
+import net from "node:net";
+import pg from "pg";
+var CANCEL_CODE = 80877102;
+var identity = (value) => value;
+var WIRE = {
+  getTypeParser() {
+    return identity;
+  }
+};
+function open4(config) {
+  const max = config.max ?? 10;
+  const acquireMs = config.timeouts?.acquire;
+  const counters = { reserved: 0, busy: 0, reservedBusy: 0, waiting: 0 };
+  const inflight = new Set;
+  const notices = noticeBuffer();
+  let closed = false;
+  const isClosed = () => closed;
+  const named = config.prepared === "named";
+  const pool = new pg.Pool({
+    connectionString: config.url,
+    max,
+    idleTimeoutMillis: 0,
+    allowExitOnIdle: true,
+    connectionTimeoutMillis: 5000,
+    application_name: "okmodel",
+    types: WIRE,
+    ...config.ssl !== undefined ? { ssl: config.ssl } : {},
+    ...config.searchPath !== undefined ? { options: `-c search_path=${config.searchPath}` } : {}
+  });
+  pool.on("connect", (client) => {
+    client.on("notice", (notice) => {
+      notices.push(notice);
+    });
+  });
+  const root = new WireSession((text, params) => send(pool, text, params, named, undefined), notices, isClosed, true, () => {
+    counters.busy += 1;
+  }, () => {
+    counters.busy = Math.max(0, counters.busy - 1);
+  }, inflight);
+  const held = { pool, acquireMs, counters, notices, named, isClosed };
+  const checkout = () => closed ? rejectClosed() : import("./qa5dsc7z.js").then((mod) => mod.checkout(held));
+  return {
+    capabilities: NODE_POSTGRES_CAPABILITIES,
+    execute(text, params, options) {
+      return runCall(closed, options, async (watch) => {
+        if (watch === undefined)
+          return root.query(text, params, undefined);
+        const client = await connectClient(pool, acquireMs, counters);
+        counters.busy += 1;
+        const session = new WireSession((statement, values) => send(client, statement, values, named, client), notices, isClosed, true, () => {
+          return;
+        }, () => {
+          return;
+        }, inflight);
+        try {
+          return await session.query(text, params, watch);
+        } finally {
+          counters.busy = Math.max(0, counters.busy - 1);
+          client.release();
+        }
+      });
+    },
+    async batch(statements, options) {
+      const connection = await checkout();
+      try {
+        return await connection.batch(statements, options);
+      } finally {
+        await connection.release();
+      }
+    },
+    reserve: () => checkout(),
+    stream(text, params) {
+      return stream(text, params);
+    },
+    listen(channel, onNotify) {
+      return listen(channel, onNotify);
+    },
+    cancel() {
+      for (const pending of inflight)
+        pending.cancel?.();
+    },
+    stats: () => statsOf(counters, max),
+    async close() {
+      closed = true;
+      await pool.end();
+    }
+  };
+  function stream(text, params) {
+    return async function* () {
+      const connection = await checkout();
+      try {
+        yield* cursorStream((statement, values) => connection.execute(statement, values), text, params);
+      } finally {
+        await connection.release();
+      }
+    }();
+  }
+  async function listen(channel, onNotify) {
+    if (closed)
+      return rejectClosed();
+    const client = await connectClient(pool, acquireMs, counters);
+    counters.reserved += 1;
+    const quoted = quoteIdent2(channel);
+    const onNotification = (message) => {
+      if (message.channel === channel)
+        onNotify(message.payload ?? "");
+    };
+    client.on("notification", onNotification);
+    try {
+      await client.query(`LISTEN ${quoted}`);
+    } catch (error) {
+      counters.reserved = Math.max(0, counters.reserved - 1);
+      client.release();
+      throw error;
+    }
+    let stopped = false;
+    return async () => {
+      if (stopped)
+        return;
+      stopped = true;
+      try {
+        await client.query(`UNLISTEN ${quoted}`);
+      } finally {
+        client.removeListener("notification", onNotification);
+        counters.reserved = Math.max(0, counters.reserved - 1);
+        client.release();
+      }
+    };
+  }
+}
+function send(runner, text, params, named, client) {
+  const query = {
+    text,
+    rowMode: "array",
+    types: WIRE,
+    ...params !== undefined && params.length > 0 ? { values: params } : {},
+    ...named ? { name: statementName(text) } : {}
+  };
+  const pending = runner.query(query);
+  if (client !== undefined)
+    pending.cancel = () => cancelBackend(client);
+  return pending;
+}
+var names = new Map;
+function statementName(text) {
+  const existing = names.get(text);
+  if (existing !== undefined)
+    return existing;
+  const name = `okm_${String(names.size)}`;
+  names.set(text, name);
+  return name;
+}
+function cancelBackend(client) {
+  const pid = client.processID;
+  const secret = client.secretKey;
+  if (typeof pid !== "number" || typeof secret !== "number")
+    return;
+  const socket = client.host.startsWith("/") === true ? net.connect(client.host) : net.connect(client.port, client.host);
+  socket.unref();
+  socket.once("error", () => {
+    socket.destroy();
+  });
+  socket.once("connect", () => {
+    const bytes = Buffer.alloc(16);
+    bytes.writeInt32BE(16, 0);
+    bytes.writeInt32BE(CANCEL_CODE, 4);
+    bytes.writeInt32BE(pid, 8);
+    bytes.writeInt32BE(secret, 12);
+    socket.end(bytes);
+  });
+}
+function connectClient(pool, acquireMs, counters) {
+  counters.waiting += 1;
+  let settled = false;
+  return new Promise((resolve, reject) => {
+    let timer;
+    if (acquireMs !== undefined) {
+      timer = setTimeout(() => {
+        settled = true;
+        counters.waiting = Math.max(0, counters.waiting - 1);
+        driverErrors().then((errors) => {
+          reject(errors.acquireTimeout());
+        });
+      }, acquireMs);
+    }
+    pool.connect().then((client) => {
+      if (settled) {
+        client.release();
+        return;
+      }
+      if (timer !== undefined)
+        clearTimeout(timer);
+      counters.waiting = Math.max(0, counters.waiting - 1);
+      resolve(client);
+    }, (error) => {
+      if (settled)
+        return;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      counters.waiting = Math.max(0, counters.waiting - 1);
+      mapFailure(error).then(reject);
+    });
+  });
+}
+function statsOf(counters, size) {
+  return {
+    size,
+    idle: Math.max(0, size - counters.reserved - counters.busy),
+    inflight: counters.busy + counters.reservedBusy,
+    waiting: counters.waiting
+  };
+}
+
+export { open4, send, connectClient };