okmodel 0.7.0 → 0.9.0

package/dist/tooling/shared/t6zjeake.js

@@ -0,0 +1,261 @@
+import {
+  noTimeout
+} from "./3yn79q5m.js";
+import {
+  PGLITE_CAPABILITIES,
+  driverErrors,
+  rejectClosed,
+  rejectCancelled,
+  rejectTimedOut,
+  nextTransactionDepth,
+  runCall,
+  EMPTY_NOTICES,
+  resultFrom
+} from "./5x3pf400.js";
+
+// src/adapters/pg/pglite.ts
+import { PGlite } from "@electric-sql/pglite";
+async function open6(config = {}) {
+  const wire = await import("./8m5znpdt.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("./gqwevek4.js");
+          return runAtomicBatch(session, statements, watch);
+        });
+      },
+      async release() {
+        if (released)
+          return;
+        released = true;
+        try {
+          const { resetQueried } = await import("./9wsnsvbf.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/tcwpjvxe.js

@@ -0,0 +1,9 @@
+// src/runtime/inflight.ts
+async function refuseUncancellableTimeout(pool, timeout) {
+  if (pool.capabilities.cancel === true || timeout === undefined || !(timeout > 0))
+    return;
+  const { refused } = await import("./sjwkt1pg.js");
+  await refused();
+}
+
+export { refuseUncancellableTimeout };

package/dist/tooling/shared/tpssp7ac.js

@@ -0,0 +1,160 @@
+import {
+  OkmError,
+  isOperator,
+  operatorValue,
+  safetyInstalled,
+  runSafety
+} from "./hfq3n3bd.js";
+
+// src/runtime/exposure.ts
+var REDACTED = "[redacted]";
+var namesOf = new WeakMap;
+function redactView(schema, view, call) {
+  const names = concealedNames(schema);
+  const secrets = new Set;
+  harvest(schema, call.where, names, undefined, secrets);
+  harvest(schema, call.include, names, undefined, secrets);
+  const model = schema.model[call.table];
+  const rules = model === undefined ? view.rules : [...view.rules, ...exposureRules(model, call)];
+  if (safetyInstalled())
+    runSafety(rules, undefined);
+  return {
+    ...view,
+    intent: {
+      ...view.intent,
+      where: walk(view.intent.where, names),
+      include: walk(view.intent.include, names)
+    },
+    rules,
+    sql: {
+      ...view.sql,
+      params: view.sql.params.map((value) => value !== null && secrets.has(value) ? REDACTED : value)
+    }
+  };
+}
+function scrubCall(error, schema, call) {
+  const names = concealedNames(schema);
+  const secrets = new Set;
+  harvest(schema, call.where, names, undefined, secrets);
+  harvest(schema, call.include, names, undefined, secrets);
+  let message = error.message;
+  for (const secret of secrets) {
+    if (secret.length < 4 || !message.includes(secret))
+      continue;
+    message = message.replaceAll(secret, REDACTED);
+  }
+  if (message === error.message)
+    return error;
+  return new OkmError(error.code, message, {
+    kind: error.kind,
+    ...error.table !== undefined ? { table: error.table } : {},
+    ...error.columns.length > 0 ? { columns: error.columns } : {},
+    fix: error.fix
+  });
+}
+function concealedNames(schema) {
+  const cached = namesOf.get(schema);
+  if (cached !== undefined)
+    return cached;
+  const names = new Set;
+  for (const model of Object.values(schema.model)) {
+    if (model.conceal !== true)
+      continue;
+    for (const column of model.columns) {
+      if (column.hidden || column.sensitive)
+        names.add(column.field);
+    }
+  }
+  namesOf.set(schema, names);
+  return names;
+}
+function exposureRules(model, call) {
+  const named = namedSelect(call.select);
+  const source = model.source;
+  const rules = [];
+  for (const column of model.columns) {
+    if (column.hidden && (named === undefined || !named.has(column.field))) {
+      rules.push({
+        rule: "hidden",
+        contribution: `hidden ${model.name}.${column.field} excluded`,
+        provenance: "catalog",
+        ...source !== undefined ? { source } : {}
+      });
+    }
+    if (column.sensitive) {
+      rules.push({
+        rule: "sensitive",
+        contribution: `sensitive ${model.name}.${column.field} redacted`,
+        provenance: "catalog",
+        ...source !== undefined ? { source } : {}
+      });
+    }
+  }
+  return rules;
+}
+function namedSelect(select) {
+  if (!Array.isArray(select))
+    return;
+  const names = new Set;
+  for (const name of select) {
+    if (typeof name === "string")
+      names.add(name);
+  }
+  return names;
+}
+function harvest(schema, value, names, key, into) {
+  if (Array.isArray(value)) {
+    for (const item of value)
+      harvest(schema, item, names, key, into);
+    return;
+  }
+  if (isOperator(value)) {
+    harvest(schema, operatorValue(value), names, key, into);
+    return;
+  }
+  if (typeof value === "object" && value !== null) {
+    const record = value;
+    for (const child of Object.keys(record))
+      harvest(schema, record[child], names, child, into);
+    return;
+  }
+  if (key === undefined || !names.has(key))
+    return;
+  const encode = encodeOf(schema, key);
+  if (encode === undefined)
+    return;
+  try {
+    into.add(encode(value));
+  } catch {}
+}
+function encodeOf(schema, field) {
+  for (const model of Object.values(schema.model)) {
+    for (const column of model.columns) {
+      if (column.field === field && (column.hidden || column.sensitive)) {
+        return column.encode;
+      }
+    }
+  }
+  return;
+}
+function walk(value, names, key) {
+  if (Array.isArray(value))
+    return value.map((item) => walk(item, names, key));
+  if (typeof value === "object" && value !== null) {
+    const record = value;
+    if (typeof record.op === "string" && "value" in record) {
+      return { op: record.op, value: walk(record.value, names, key) };
+    }
+    const out = {};
+    for (const child of Object.keys(record))
+      out[child] = walk(record[child], names, child);
+    return out;
+  }
+  if (key !== undefined && names.has(key))
+    return REDACTED;
+  return value;
+}
+export {
+  redactView,
+  scrubCall
+};

package/dist/tooling/shared/v6j1ep6w.js

@@ -0,0 +1,42 @@
+import {
+  open4
+} from "./asgr07mp.js";
+import {
+  createClient
+} from "./jr2nmr81.js";
+
+// src/runtime/pg/pg.ts
+function connect(target, options) {
+  if (typeof target === "object" && !isPool(target)) {
+    return import("./kbqnrs1x.js").then((mod) => mod.default(target, options, open4));
+  }
+  const owned = !isPool(target);
+  const pool = isPool(target) ? target : open4({
+    url: target,
+    ...options.max !== undefined ? { max: options.max } : {},
+    ...options.timeouts !== undefined ? { timeouts: options.timeouts } : {},
+    ...options.prepared !== undefined ? { prepared: options.prepared } : {},
+    ...options.searchPath !== undefined ? { searchPath: options.searchPath } : {},
+    ...options.ssl !== undefined ? { ssl: options.ssl } : {}
+  });
+  return createClient(options.schema, pool, {
+    ownsPool: owned,
+    http: options.errors?.http,
+    includeValues: options.errors?.includeValues,
+    logger: options.logger,
+    signal: options.signal,
+    timeout: options.timeout,
+    timeouts: options.timeouts,
+    hookm: options.hookm,
+    catalog: options.catalog,
+    catalogDir: options.catalogDir,
+    requireMeta: options.requireMeta,
+    generators: options.generators
+  });
+}
+function isPool(target) {
+  return typeof target === "object" && "execute" in target && "capabilities" in target;
+}
+export {
+  connect
+};