okmodel 0.6.0 → 0.8.0

package/dist/tooling/shared/djydjpqt.js

@@ -0,0 +1,261 @@
+import {
+  noTimeout
+} from "./rs1jb051.js";
+import {
+  PGLITE_CAPABILITIES,
+  driverErrors,
+  rejectClosed,
+  rejectCancelled,
+  rejectTimedOut,
+  nextTransactionDepth,
+  runCall,
+  EMPTY_NOTICES,
+  resultFrom
+} from "./xhrnjch9.js";
+
+// src/adapters/pg/pglite.ts
+import { PGlite } from "@electric-sql/pglite";
+async function open6(config = {}) {
+  const wire = await import("./dzx85q70.js");
+  const db = new PGlite({
+    dataDir: config.dataDir ?? "memory://",
+    parsers: wire.parsers,
+    serializers: wire.serializers
+  });
+  await db.waitReady;
+  const acquireMs = config.timeouts?.acquire;
+  const slot = new Slot;
+  const notices = noticeBuffer();
+  const queryOptions = {
+    rowMode: "array",
+    parsers: wire.parsers,
+    serializers: wire.serializers,
+    onNotice(notice) {
+      notices.push(notice);
+    }
+  };
+  let closed = false;
+  let inflight = 0;
+  const session = new PgliteSession(db, queryOptions, notices, () => {
+    inflight += 1;
+  }, () => {
+    inflight = Math.max(0, inflight - 1);
+  }, (error) => wire.fail(error));
+  async function lease() {
+    if (closed)
+      return rejectClosed();
+    await slot.acquire(acquireMs);
+    let released = false;
+    return {
+      execute: (text, params, options) => {
+        const refused = noTimeout(options);
+        if (refused !== undefined)
+          return refused;
+        return runCall(closed, options, (watch) => session.query(text, params, watch));
+      },
+      batch: (statements, options) => {
+        const refused = noTimeout(options);
+        if (refused !== undefined)
+          return refused;
+        return runCall(closed, options, async (watch) => {
+          const { runAtomicBatch } = await import("./3rrw5w8f.js");
+          return runAtomicBatch(session, statements, watch);
+        });
+      },
+      async release() {
+        if (released)
+          return;
+        released = true;
+        try {
+          const { resetQueried } = await import("./08kemxjd.js");
+          await resetQueried(session);
+        } finally {
+          slot.release();
+        }
+      }
+    };
+  }
+  return {
+    capabilities: PGLITE_CAPABILITIES,
+    execute(text, params, options) {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      return runCall(closed, options, async (watch) => {
+        await slot.acquire(acquireMs);
+        try {
+          return await session.query(text, params, watch);
+        } finally {
+          slot.release();
+        }
+      });
+    },
+    async batch(statements, options) {
+      const refused = noTimeout(options);
+      if (refused !== undefined)
+        return refused;
+      const connection = await lease();
+      try {
+        return await connection.batch(statements, options);
+      } finally {
+        await connection.release();
+      }
+    },
+    reserve: () => lease(),
+    async describe(text) {
+      await slot.acquire(acquireMs);
+      try {
+        const described = await db.describeQuery(text);
+        return {
+          columns: described.resultFields.map((field) => field.name),
+          parameterCount: described.queryParams.length
+        };
+      } finally {
+        slot.release();
+      }
+    },
+    async listen(channel, onNotify) {
+      const unlisten = await db.listen(channel, onNotify);
+      return async () => {
+        await unlisten();
+      };
+    },
+    stats() {
+      return { size: 1, idle: slot.idle, inflight, waiting: slot.waiting };
+    },
+    async close() {
+      closed = true;
+      await db.close();
+    }
+  };
+}
+function seal2(pool) {
+  let closed = 0;
+  return new Proxy(pool, {
+    get: (inner, key) => key === "close" ? () => Promise.resolve(closed = 1) : (inner = inner[key], closed && inner?.call ? () => rejectClosed() : inner)
+  });
+}
+
+class PgliteSession {
+  canCancel = false;
+  transactionDepth = 0;
+  db;
+  options;
+  notices;
+  enter;
+  leave;
+  fail;
+  constructor(db, options, notices, enter, leave, fail) {
+    this.db = db;
+    this.options = options;
+    this.notices = notices;
+    this.enter = enter;
+    this.leave = leave;
+    this.fail = fail;
+  }
+  query(text, params, watch) {
+    const why = watch?.reason();
+    if (why === "timeout")
+      return rejectTimedOut();
+    if (why === "cancelled" || watch?.signal.aborted === true)
+      return rejectCancelled();
+    this.enter();
+    const pending = params === undefined || params.length === 0 ? this.db.query(text, undefined, this.options) : this.db.query(text, params, this.options);
+    return pending.then((result) => {
+      this.leave();
+      this.note(text);
+      return resultFrom(result, this.notices.take());
+    }, (error) => {
+      this.leave();
+      this.notices.take();
+      return this.fail(stampQuery(error, text)).then((mapped) => {
+        throw mapped;
+      });
+    });
+  }
+  inTransaction() {
+    return this.transactionDepth > 0;
+  }
+  abandon() {
+    this.transactionDepth = 0;
+  }
+  rollback() {
+    return this.query("ROLLBACK", undefined, undefined).then(() => {
+      this.transactionDepth = 0;
+    }, (error) => {
+      this.transactionDepth = 0;
+      throw error;
+    });
+  }
+  note(text) {
+    this.transactionDepth = nextTransactionDepth(this.transactionDepth, text);
+  }
+}
+function noticeBuffer() {
+  let notices;
+  return {
+    push(notice) {
+      const severity = notice.severity ?? "";
+      const message = notice.message ?? "";
+      const code = notice.code !== undefined && notice.code.length > 0 ? notice.code : undefined;
+      const entry = code === undefined ? { severity, message } : { severity, message, code };
+      (notices ??= []).push(entry);
+    },
+    take() {
+      const taken = notices ?? EMPTY_NOTICES;
+      notices = undefined;
+      return taken;
+    }
+  };
+}
+
+class Slot {
+  held = false;
+  waiters = [];
+  acquire(acquireMs) {
+    if (!this.held) {
+      this.held = true;
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const waiter = {
+        resolve,
+        timer: undefined
+      };
+      if (acquireMs !== undefined) {
+        waiter.timer = setTimeout(() => {
+          const index = this.waiters.indexOf(waiter);
+          if (index !== -1)
+            this.waiters.splice(index, 1);
+          driverErrors().then((errors) => {
+            reject(errors.acquireTimeout());
+          });
+        }, acquireMs);
+      }
+      this.waiters.push(waiter);
+    });
+  }
+  release() {
+    const next = this.waiters.shift();
+    if (next === undefined) {
+      this.held = false;
+      return;
+    }
+    if (next.timer !== undefined)
+      clearTimeout(next.timer);
+    next.resolve();
+  }
+  get idle() {
+    return this.held ? 0 : 1;
+  }
+  get waiting() {
+    return this.waiters.length;
+  }
+}
+function stampQuery(error, text) {
+  if (typeof error === "object" && error !== null && !("query" in error))
+    Reflect.set(error, "query", text);
+  return error;
+}
+
+export { open6, seal2 };

package/dist/tooling/shared/dw08f3m8.js

@@ -0,0 +1,9 @@
+import {
+  build2,
+  identityColumn2
+} from "./ec71zqgt.js";
+import"./mtrqn2hn.js";
+export {
+  build2 as build,
+  identityColumn2 as identityColumn
+};

package/dist/tooling/shared/dy672fz6.js

@@ -0,0 +1,16 @@
+import {
+  open6,
+  seal2
+} from "./djydjpqt.js";
+import {
+  PGLITE_CAPABILITIES,
+  readCapability2,
+  hasCapability2
+} from "./xhrnjch9.js";
+export {
+  PGLITE_CAPABILITIES as capabilities,
+  hasCapability2 as hasCapability,
+  open6 as open,
+  readCapability2 as readCapability,
+  seal2 as seal
+};

package/dist/tooling/shared/dzx85q70.js

@@ -0,0 +1,66 @@
+import {
+  mapFailure
+} from "./xhrnjch9.js";
+
+// src/adapters/pg/pglite-wire.ts
+var OIDS = [
+  16,
+  17,
+  20,
+  21,
+  23,
+  25,
+  114,
+  700,
+  701,
+  1043,
+  1082,
+  1114,
+  1184,
+  1700,
+  2950,
+  3802,
+  1000,
+  1005,
+  1007,
+  1009,
+  1016,
+  1115,
+  1182,
+  1185,
+  1231,
+  199,
+  3807
+];
+function identity(value) {
+  return value;
+}
+function serialize(value) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return String(value);
+  if (typeof value === "boolean")
+    return value ? "t" : "f";
+  return value;
+}
+var parsers = {};
+var serializers = {};
+for (const oid of OIDS) {
+  parsers[oid] = identity;
+  serializers[oid] = serialize;
+}
+function fail(error) {
+  return mapFailure(protocol(error));
+}
+function protocol(error) {
+  if (typeof error !== "object" || error === null || !("code" in error))
+    return error;
+  if (error.code !== "08P01")
+    return error;
+  const message = error instanceof Error ? error.message : "";
+  return new Error(message.length > 0 ? message : "protocol error");
+}
+export {
+  fail,
+  parsers,
+  serializers
+};

package/dist/tooling/shared/ec71zqgt.js

@@ -0,0 +1,270 @@
+import {
+  readHandle,
+  readCall,
+  attachHttp
+} from "./mtrqn2hn.js";
+import {
+  OkmError,
+  throwNamed,
+  decodeResult,
+  emitWhere,
+  emitOrder,
+  selectedColumns,
+  rejectKeys,
+  projectExpr,
+  indexes,
+  quote,
+  list,
+  isRecord,
+  fail2
+} from "./f9mphxej.js";
+
+// src/runtime/tree.ts
+var OPTIONS = [
+  "where",
+  "select",
+  "orderBy",
+  "depth",
+  "self",
+  "relation",
+  "route",
+  "signal",
+  "timeout"
+];
+function build2(session, table, options, mods, view) {
+  try {
+    return open(session, table, options, mods, view);
+  } catch (error) {
+    throw error instanceof OkmError ? attachHttp(session.http, error) : error;
+  }
+}
+function open(session, table, options, mods, view) {
+  const packed = readPacked(options);
+  const user = packed.user;
+  rejectKeys(user, OPTIONS, packed.walk);
+  const indexed = indexes(session.schema).get(table);
+  if (indexed === undefined)
+    fail2("OKM1120", `Table ${table} is not in the schema.`);
+  const edge = pickEdge(indexed, user.relation);
+  const identity = identityColumn2(session, indexed);
+  const depth = readDepth(user.depth);
+  const self = readSelf(user.self);
+  const id = userId(identity, packed.id);
+  const shared = {
+    ...user.where !== undefined ? { where: user.where } : {},
+    ...user.select !== undefined ? { select: user.select } : {},
+    ...user.orderBy !== undefined ? { orderBy: user.orderBy } : {},
+    ...user.signal !== undefined ? { signal: user.signal } : {},
+    ...user.timeout !== undefined ? { timeout: user.timeout } : {},
+    ...user.route !== undefined ? { route: user.route } : {}
+  };
+  const base = readCall("find", table, shared, mods.all, session.scope, session.schema.model[table], session.schema, view);
+  const spec = { direction: packed.walk, edge, identity, depth, self, id };
+  const call = {
+    ...base,
+    op: packed.walk,
+    build: (schema, planned, sink, outputs, source) => {
+      emitTree(schema, planned, sink, outputs, source, spec);
+    }
+  };
+  return readHandle(session, table, call, mods, (compiled, rows) => decodeResult(compiled, rows, table));
+}
+function emitTree(schema, table, sink, outputs, call, spec) {
+  const { direction, edge, identity, depth, self, id } = spec;
+  sink.mark(`walk:${direction}|rel:${edge.name}|self:${self ? "1" : "0"}|depth:${depth === undefined ? "all" : String(depth)}|`);
+  const selected = selectedColumns(table, call.select);
+  sink.text("with recursive walk as (select ");
+  emitKeyList(sink, "s", edge.parent, "k");
+  emitKeyList(sink, "s", edge.child, "f");
+  sink.text(", 0 as depth, array[s.");
+  sink.text(quote(identity.sql));
+  sink.text("] as seen from ");
+  sink.text(quote(table.model.sql));
+  sink.text(" s where s.");
+  sink.text(quote(identity.sql));
+  sink.text(" = ");
+  sink.param(identity.encode(id));
+  emitWhere(schema, table, undefined, sink, "s", 0, true);
+  sink.text(" union all select ");
+  let started = emitBare(sink, "c", edge.parent, false);
+  emitBare(sink, "c", edge.child, started);
+  sink.text(", w.depth + 1, w.seen || c.");
+  sink.text(quote(identity.sql));
+  sink.text(" from ");
+  sink.text(quote(table.model.sql));
+  sink.text(" c join walk w on ");
+  if (direction === "descendants")
+    emitStep(sink, "c", edge.child, edge.parent, "k");
+  else
+    emitStep(sink, "c", edge.parent, edge.child, "f");
+  sink.text(" where c.");
+  sink.text(quote(identity.sql));
+  sink.text(" <> all(w.seen)");
+  if (depth !== undefined) {
+    sink.text(" and w.depth < ");
+    sink.text(String(depth));
+  }
+  emitWhere(schema, table, undefined, sink, "c", 0, true);
+  sink.text(") select ");
+  let column = 0;
+  for (let index = 0;index < selected.length; index += 1) {
+    const item = selected[index];
+    if (item === undefined)
+      continue;
+    if (column > 0)
+      sink.text(", ");
+    sink.text(projectExpr(`t.${quote(item.sql)}`, item.dataType));
+    sink.mark(`s:${item.field}`);
+    outputs?.fields.push({ key: item.field, at: column, decode: item.decode });
+    column += 1;
+  }
+  if (column === 0)
+    sink.text("1");
+  sink.text(" from ");
+  sink.text(quote(table.model.sql));
+  sink.text(" t join walk w on ");
+  emitStep(sink, "t", edge.parent, edge.parent, "k");
+  if (self)
+    emitWhere(schema, table, call.where, sink, "t", 0, false);
+  else {
+    sink.text(" where w.depth > 0");
+    emitWhere(schema, table, call.where, sink, "t", 0, true);
+  }
+  if (call.orderBy !== undefined) {
+    emitOrder(table, call.orderBy, sink, "t");
+    return;
+  }
+  sink.text(" order by w.depth asc");
+  sink.mark("order:depth");
+  for (const field of table.model.primary) {
+    const item = table.columns.get(field);
+    if (item === undefined)
+      continue;
+    sink.text(", t.");
+    sink.text(quote(item.sql));
+    sink.text(" asc");
+  }
+}
+function emitKeyList(sink, alias, columns, prefix) {
+  for (let index = 0;index < columns.length; index += 1) {
+    const name = columns[index];
+    if (name === undefined)
+      continue;
+    if (index > 0 || prefix === "f")
+      sink.text(", ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(name));
+    sink.text(" as ");
+    sink.text(prefix);
+    sink.text(String(index));
+  }
+}
+function emitBare(sink, alias, columns, lead) {
+  let started = lead;
+  for (const name of columns) {
+    if (started)
+      sink.text(", ");
+    started = true;
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(name));
+  }
+  return started;
+}
+function emitStep(sink, alias, columns, against, prefix) {
+  for (let index = 0;index < columns.length; index += 1) {
+    const name = columns[index];
+    if (name === undefined || against[index] === undefined)
+      continue;
+    if (index > 0)
+      sink.text(" and ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(name));
+    sink.text(" = w.");
+    sink.text(prefix);
+    sink.text(String(index));
+  }
+}
+function readPacked(options) {
+  if (!isRecord(options) || options.walk !== "descendants" && options.walk !== "ancestors") {
+    fail2("OKM1120", "descendants and ancestors are table methods.");
+  }
+  const user = options.options;
+  if (user === undefined)
+    return { id: options.id, walk: options.walk, user: {} };
+  if (!isRecord(user))
+    fail2("OKM1120", `${options.walk} options must be an object.`);
+  return { id: options.id, walk: options.walk, user };
+}
+function pickEdge(table, relation) {
+  const edges = selfEdges(table);
+  if (edges.length === 0) {
+    fail2("OKM1120", `${table.model.name} has no relation to itself.`, `Declare children: many("${table.model.name}") or parent: one("${table.model.name}").`);
+  }
+  const groups = new Set(edges.map((edge) => edge.child.join("\x00")));
+  if (relation === undefined) {
+    if (groups.size !== 1) {
+      fail2("OKM1120", `${table.model.name} has more than one relation to itself. Pass relation.`, `Accepted names: ${edges.map((edge) => edge.name).join(", ")}.`);
+    }
+    const only = edges[0];
+    if (only === undefined)
+      fail2("OKM1120", `${table.model.name} has no relation to itself.`);
+    return only;
+  }
+  if (typeof relation !== "string" || relation.length === 0) {
+    fail2("OKM1120", "relation must be a name.");
+  }
+  const found = edges.find((edge) => edge.name === relation);
+  if (found === undefined) {
+    throwNamed("OKM1120", relation, edges.map((edge) => edge.name), `Relation ${relation} is not a self-relation of ${table.model.name}. Accepted names: ${list(edges.map((edge) => edge.name))}.`);
+  }
+  return found;
+}
+function selfEdges(table) {
+  const edges = [];
+  for (const relation of table.model.relations) {
+    if (relation.table !== table.model.name || relation.through !== undefined)
+      continue;
+    edges.push(relation.kind === "many" ? { name: relation.name, parent: relation.local, child: relation.remote } : { name: relation.name, parent: relation.remote, child: relation.local });
+  }
+  return edges;
+}
+function identityColumn2(session, table) {
+  const tenancy = session.schema.tenancy;
+  const keys = tenancy === undefined ? [] : tenancy.keys ?? [tenancy.key];
+  const fields = table.model.primary.filter((field) => !keys.includes(field));
+  if (fields.length !== 1) {
+    fail2("OKM1120", `${table.model.name} needs one primary key column besides the tenant key.`, "Use a single-column primary key.");
+  }
+  const field = fields[0];
+  const column = field === undefined ? undefined : table.columns.get(field);
+  if (column === undefined) {
+    fail2("OKM1120", `${table.model.name} needs one primary key column besides the tenant key.`);
+  }
+  return column;
+}
+function readDepth(value) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    fail2("OKM1120", "depth must be an integer from 0 up.");
+  }
+  return value;
+}
+function readSelf(value) {
+  if (value === undefined)
+    return false;
+  if (typeof value !== "boolean")
+    fail2("OKM1120", "self must be true or false.");
+  return value;
+}
+function userId(column, id) {
+  if (id === undefined || id === null) {
+    fail2("OKM1121", `${column.field} needs a value.`);
+  }
+  return id;
+}
+
+export { build2, identityColumn2 };

package/dist/{shared/d5azex6s.js → tooling/shared/ep8zh3bk.js}

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