okmodel 0.7.0 → 0.8.0

package/dist/tooling/shared/345tbc2k.js

@@ -0,0 +1,16 @@
+import {
+  OkmError,
+  DriverError2
+} from "./f9mphxej.js";
+
+// src/adapters/lazy-errors.ts
+function refused() {
+  return Promise.reject(new OkmError("OKM1120", "timeout"));
+}
+function closed() {
+  return Promise.reject(new DriverError2("The pool is closed.", { sqlstate: "08006" }));
+}
+export {
+  closed,
+  refused
+};

package/dist/tooling/shared/3m1hkg7z.js

@@ -0,0 +1,344 @@
+import {
+  DriverError2,
+  timedOut2,
+  isConnectionLost
+} from "./f9mphxej.js";
+import {
+  PgSession2
+} from "./p7f08ktn.js";
+import {
+  driverErrors,
+  rejectClosed,
+  mapFailure,
+  runCall,
+  rowsFrom,
+  resultFrom
+} from "./xhrnjch9.js";
+
+// src/adapters/pg/postgres-extra.ts
+var RESET_ALL = "RESET ALL";
+var UNLOCK = "SELECT pg_advisory_unlock_all()";
+async function checkout(pool, timeoutMs) {
+  if (pool.isClosed())
+    return rejectClosed();
+  const reserved = await reserveConnection(pool.sql, pool.acquireMs, pool.counters, timeoutMs);
+  pool.counters.reserved += 1;
+  const local = new Set;
+  const session = new PgSession2(reserved, pool.counters, "reserved", local, pool.isClosed, pool.poolInflight, pool.notices, pool.named);
+  let released = false;
+  const lost = { on: false, stop: () => {
+    return;
+  } };
+  arm(reserved, lost);
+  let limit = timeoutMs !== undefined && timeoutMs > 0 ? timeoutMs : 0;
+  const remember = (timeout) => {
+    if (timeout !== undefined && timeout > 0)
+      limit = timeout;
+  };
+  const guard = (run) => lost.on ? rejectClosed() : run().catch((error) => {
+    if (isConnectionLost(error))
+      lost.on = true;
+    throw error;
+  });
+  return {
+    execute: (text, params, options) => {
+      remember(options?.timeout);
+      return guard(() => runCall(pool.isClosed(), options, (watch) => session.query(text, params, watch)));
+    },
+    batch: (statements, options) => {
+      remember(options?.timeout);
+      return guard(() => runCall(pool.isClosed(), options, async (watch) => {
+        const { runAtomicBatch } = await import("./3rrw5w8f.js");
+        return runAtomicBatch(session, statements, watch);
+      }));
+    },
+    cancel() {
+      session.cancel();
+    },
+    async release() {
+      if (released)
+        return;
+      released = true;
+      const ms = limit;
+      try {
+        if (!lost.on)
+          await deadline(ms, () => resetConnection(reserved, session.depth()), lost);
+      } catch {
+        lost.on = true;
+      } finally {
+        pool.counters.reserved = Math.max(0, pool.counters.reserved - 1);
+        if (lost.on)
+          await deadline(ms, () => pool.sql.unsafe("select 1"), pool.sql).catch(() => {
+            return;
+          });
+        else
+          reserved.release();
+      }
+    }
+  };
+}
+async function describe(sql, text, params) {
+  const pending = sql.unsafe(text, asParams(params), { prepare: true });
+  const described = await pending.describe();
+  return {
+    columns: described.columns.map((column) => column.name),
+    parameterCount: described.types.length
+  };
+}
+async function* stream(sql, text, params) {
+  const pending = sql.unsafe(text, asParams(params));
+  for await (const chunk of pending.cursor(64)) {
+    yield rowsFrom(chunk);
+  }
+}
+function poolWaits(sql) {
+  const options = sql.options;
+  if (options === undefined || options.q !== undefined)
+    return options;
+  const q = new Set;
+  const n = new Set;
+  options.q = q;
+  options.n = n;
+  options.onclose = (id) => {
+    n.add(id);
+    if (n.size < options.max) {
+      queueMicrotask(() => {
+        for (const wait of q)
+          wait.a();
+      });
+      return;
+    }
+    n.clear();
+    for (const wait of q)
+      wait.s();
+    q.clear();
+  };
+  return options;
+}
+function deadline(ms, run, link) {
+  let timer;
+  let off = () => {
+    return;
+  };
+  const slot = link !== undefined && "stop" in link ? link : undefined;
+  const pool = slot === undefined && link !== undefined ? poolWaits(link) : undefined;
+  let ended = false;
+  return new Promise((resolve, reject) => {
+    const fail = (error) => {
+      if (ended)
+        return;
+      ended = true;
+      reject(error);
+    };
+    const stop = () => {
+      fail(new DriverError2("Connection closed", { sqlstate: "08006" }));
+    };
+    if (slot !== undefined)
+      slot.stop = stop;
+    const go = () => {
+      const pending = run();
+      if (ms > 0 && timer === undefined) {
+        timer = setTimeout(() => {
+          pending.cancel?.();
+          fail(timedOut2());
+        }, ms);
+      }
+      pending.then((value) => {
+        if (ended) {
+          value.release?.();
+          return;
+        }
+        ended = true;
+        pool?.n?.clear();
+        resolve(value);
+      }, fail);
+    };
+    if (ms === 0 && pool?.q !== undefined) {
+      let used = false;
+      const wait = {
+        s: stop,
+        a() {
+          if (used || ended)
+            return;
+          used = true;
+          go();
+        }
+      };
+      pool.q.add(wait);
+      off = () => pool.q?.delete(wait);
+    }
+    go();
+  }).finally(() => {
+    clearTimeout(timer);
+    if (slot !== undefined)
+      slot.stop = () => {
+        return;
+      };
+    off();
+  });
+}
+async function runBatch(pool, statements, options) {
+  const connection = await checkout(pool, options?.timeout);
+  try {
+    return await connection.batch(statements, options);
+  } finally {
+    await connection.release();
+  }
+}
+function reserveConnection(sql, acquireMs, counters, callMs) {
+  counters.waiting += 1;
+  let settled = false;
+  const finish = () => {
+    counters.waiting = Math.max(0, counters.waiting - 1);
+  };
+  return new Promise((resolve, reject) => {
+    let timer;
+    if (acquireMs !== undefined) {
+      timer = setTimeout(() => {
+        if (settled)
+          return;
+        settled = true;
+        finish();
+        driverErrors().then((errors) => {
+          reject(errors.acquireTimeout());
+        });
+      }, acquireMs);
+    }
+    const ms = callMs !== undefined && callMs > 0 ? callMs : 0;
+    deadline(ms, () => sql.reserve(), sql).then((connection) => {
+      if (settled) {
+        resetConnection(connection, 0).catch(() => {
+          return;
+        }).finally(() => {
+          connection.release();
+        });
+        return;
+      }
+      settled = true;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      finish();
+      resolve(connection);
+    }, (error) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      finish();
+      mapFailure(error).then(reject);
+    });
+  });
+}
+async function resetConnection(sql, depth) {
+  if (depth > 0)
+    await sql.unsafe("ROLLBACK").catch(() => {
+      return;
+    });
+  try {
+    await sql.unsafe(RESET_ALL);
+    await sql.unsafe(UNLOCK);
+  } catch {
+    await sql.unsafe("ROLLBACK").catch(() => {
+      return;
+    });
+    await sql.unsafe(RESET_ALL);
+    await sql.unsafe(UNLOCK);
+  }
+}
+function asParams(params) {
+  if (params === undefined)
+    return [];
+  return params;
+}
+function arm(sql, lost) {
+  const unsafe = sql.unsafe.bind(sql);
+  sql.unsafe = (text, params, options) => unsafe(text, params, {
+    ...options,
+    onexecute(connection) {
+      connection.onclose = () => {
+        lost.on = true;
+        lost.stop();
+      };
+    }
+  });
+}
+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((value) => {
+    finishWatch(pending, watch, onAbort, ctx);
+    const why = watch.reason();
+    if (why === "timeout" || why === "cancelled")
+      return classify(why, watch);
+    ctx.note(ctx.text);
+    return resultFrom(value, 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,
+  holdCheckout,
+  holdListener,
+  runBatch,
+  stream,
+  watchQuery
+};

package/dist/tooling/shared/3rrw5w8f.js

@@ -0,0 +1,81 @@
+import {
+  DriverError2,
+  outcomeUnknown2,
+  mapDriverError2,
+  isConnectionLost
+} from "./f9mphxej.js";
+
+// src/adapters/pg/batch.ts
+var savepointIds = 0;
+async function runAtomicBatch(session, statements, watch) {
+  if (session.inTransaction())
+    return savepoint(session, statements, watch);
+  return transaction(session, statements, watch);
+}
+async function transaction(session, statements, watch) {
+  try {
+    await control(session, "BEGIN", watch);
+    const results = await statementsOf(session, statements, watch);
+    try {
+      await control(session, "COMMIT", watch);
+    } catch (error) {
+      if (isConnectionLost(error))
+        throw outcomeUnknown2(error);
+      throw stamp(error, null);
+    }
+    return results;
+  } catch (error) {
+    if (!isConnectionLost(error))
+      await rollback(session);
+    throw error;
+  }
+}
+async function savepoint(session, statements, watch) {
+  savepointIds += 1;
+  const name = `okm_b${String(savepointIds)}`;
+  try {
+    await control(session, `SAVEPOINT ${name}`, watch);
+    const results = await statementsOf(session, statements, watch);
+    await control(session, `RELEASE SAVEPOINT ${name}`, watch);
+    return results;
+  } catch (error) {
+    if (!isConnectionLost(error))
+      await rollback(session, `ROLLBACK TO SAVEPOINT ${name}`);
+    throw error;
+  }
+}
+function control(session, text, watch) {
+  return session.query(text, undefined, watch).then(() => {
+    return;
+  });
+}
+async function rollback(session, text = "ROLLBACK") {
+  try {
+    await session.query(text, undefined, undefined);
+  } catch {
+    session.abandon();
+  }
+}
+async function statementsOf(session, statements, watch) {
+  const results = Array.from({ length: statements.length });
+  for (let index = 0;index < statements.length; index += 1) {
+    const statement = statements[index];
+    if (statement === undefined)
+      continue;
+    try {
+      results[index] = await session.query(statement.text, statement.params, watch);
+    } catch (error) {
+      throw stamp(error, index);
+    }
+  }
+  return results;
+}
+function stamp(error, batchIndex) {
+  const mapped = mapDriverError2(error, batchIndex);
+  if (mapped instanceof DriverError2)
+    return mapped;
+  return error;
+}
+export {
+  runAtomicBatch
+};

package/dist/tooling/shared/3tq8pnb8.js

@@ -0,0 +1,131 @@
+import {
+  OkmError,
+  writeArray
+} from "./f9mphxej.js";
+
+// src/dialects/pg/operator-fit.ts
+var FAMILIES = {
+  startsWith: ["text"],
+  endsWith: ["text"],
+  like: ["text"],
+  ilike: ["text"],
+  contains: ["text", "array", "jsonb", "range"],
+  containedBy: ["array", "jsonb", "range"],
+  overlaps: ["array", "range"],
+  hasKey: ["jsonb"],
+  hasAnyKey: ["jsonb"],
+  path: ["json", "jsonb"],
+  matches: ["tsvector"],
+  relevance: ["tsvector"],
+  "json.set": ["json", "jsonb"],
+  "arr.append": ["array"],
+  "arr.remove": ["array"]
+};
+var ACCEPTED = {
+  text: [
+    "eq",
+    "not",
+    "lt",
+    "lte",
+    "gt",
+    "gte",
+    "between",
+    "startsWith",
+    "contains",
+    "endsWith",
+    "like",
+    "ilike",
+    "inList",
+    "notIn"
+  ],
+  array: [
+    "eq",
+    "not",
+    "contains",
+    "containedBy",
+    "overlaps",
+    "inList",
+    "notIn",
+    "arr.append",
+    "arr.remove"
+  ],
+  jsonb: ["eq", "not", "contains", "containedBy", "hasKey", "hasAnyKey", "path", "json.set"],
+  json: ["eq", "not", "path", "json.set"],
+  range: ["eq", "not", "lt", "lte", "gt", "gte", "contains", "containedBy", "overlaps"],
+  tsvector: ["eq", "not", "matches", "relevance"],
+  scalar: ["eq", "not", "lt", "lte", "gt", "gte", "between", "inList", "notIn", "inc"]
+};
+var SAFE_TYPE = /^[A-Za-z_][A-Za-z0-9_]*(\(\d+\))?(\[\])*$/;
+var REGCONFIG = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?$/;
+function columnFamily(dataType) {
+  if (dataType.endsWith("[]"))
+    return "array";
+  if (dataType === "jsonb")
+    return "jsonb";
+  if (dataType === "json")
+    return "json";
+  if (dataType === "tsvector")
+    return "tsvector";
+  if (dataType.endsWith("range"))
+    return "range";
+  if (dataType === "text" || dataType === "citext" || dataType.startsWith("varchar(") || dataType.startsWith("char(") || dataType.startsWith("character")) {
+    return "text";
+  }
+  return "scalar";
+}
+function assertOperatorFits(column, name) {
+  const families = FAMILIES[name];
+  if (families === undefined)
+    return;
+  if (families.includes(columnFamily(column.dataType)))
+    return;
+  const accepted = ACCEPTED[columnFamily(column.dataType)];
+  const search = (name === "matches" || name === "relevance") && columnFamily(column.dataType) === "text" ? " Search needs a column built for search, not a plain text column." : "";
+  throw new OkmError("OKM1124", `Operator ${name} does not apply to ${column.dataType} column ${column.field}. Accepted operators: ${accepted.join(", ")}.${search}`, { fix: { summary: `Use one of: ${accepted.join(", ")}.` } });
+}
+function sqlType(dataType, column) {
+  if (SAFE_TYPE.test(dataType))
+    return dataType;
+  assertOperatorFits(column, "contains");
+  throw new OkmError("OKM1124", `Operator contains does not apply to ${column.dataType} column ${column.field}. Accepted operators: ${ACCEPTED[columnFamily(column.dataType)].join(", ")}.`, { fix: { summary: "Use a column type this operator accepts." } });
+}
+function assertNoControl(value, role) {
+  for (let index = 0;index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 31 || code === 127) {
+      throw new OkmError("OKM1122", `${role} contains a control character.`, {
+        fix: { summary: "Remove NUL and other control characters. The value is not sent." }
+      });
+    }
+  }
+}
+function assertBoundText(value, role) {
+  if (value.length === 0) {
+    throw new OkmError("OKM1122", `${role} is empty.`, {
+      fix: { summary: "Pass a non-empty key or path segment." }
+    });
+  }
+  assertNoControl(value, role);
+}
+function assertRegconfig(config) {
+  if (!REGCONFIG.test(config)) {
+    throw new OkmError("OKM1122", `Language ${config} is not a text search language. Pass a name such as english.`, { fix: { summary: "Pass a language name such as english." } });
+  }
+}
+function textArray(values, role) {
+  for (const value of values)
+    assertBoundText(value, role);
+  return writeArray(values, 1, (value) => String(value), false);
+}
+function arrayElementType(dataType, column) {
+  if (!dataType.endsWith("[]")) {
+    assertOperatorFits(column, "arr.append");
+  }
+  const element = dataType.slice(0, -2);
+  if (!SAFE_TYPE.test(element)) {
+    throw new OkmError("OKM1124", `Operator arr.append does not apply to ${column.dataType} column ${column.field}. Accepted operators: ${ACCEPTED.array.join(", ")}.`, { fix: { summary: "Use arr.append on an array column." } });
+  }
+  return element;
+}
+
+export { assertOperatorFits, sqlType, assertNoControl, assertBoundText, assertRegconfig, textArray, arrayElementType };