okmodel 0.0.0 → 0.1.1

package/dist/shared/rgs0st28.js

@@ -0,0 +1,1066 @@
+import {
+  isOperator,
+  operatorName,
+  operatorValue
+} from "./cn0n68ft.js";
+import {
+  assertIdentifier2
+} from "./mkjmqjv4.js";
+import {
+  OkmError2,
+  safe2,
+  throwNamed2
+} from "./ycwz42az.js";
+
+// src/runtime/plan.ts
+var FIND_OPTIONS = ["include", "limit", "orderBy", "select", "where"];
+var ONE_OPTIONS = ["include", "orderBy", "select", "where"];
+var FILTER_OPTIONS = ["where"];
+var BASE_RULES = [
+  { rule: "parameterised", contribution: "planner", provenance: "planner" },
+  { rule: "allowlisted", contribution: "catalog", provenance: "catalog" },
+  { rule: "identifier", contribution: "catalog", provenance: "catalog" }
+];
+var indexesOf = new WeakMap;
+function verifyRead(rules) {}
+function bindCall(schema, call, hooks) {
+  const params = [];
+  const marks = [];
+  const sink = {
+    text() {},
+    param(encoded) {
+      params.push(encoded);
+    },
+    mark(token) {
+      marks.push(token);
+    }
+  };
+  emit(schema, call, sink, undefined, hooks);
+  verifyRead(BASE_RULES);
+  return { key: marks.join(""), params };
+}
+function compileCall(schema, call, key, hooks) {
+  const parts = [];
+  let n = 0;
+  const sink = {
+    text(value) {
+      parts.push(value);
+    },
+    param() {
+      n += 1;
+      parts.push(`$${String(n)}`);
+    },
+    mark() {}
+  };
+  const fields = [];
+  const includes = [];
+  emit(schema, call, sink, { fields, includes }, hooks);
+  return {
+    fingerprint: fingerprint(key),
+    text: parts.join(""),
+    mode: call.op,
+    outputs: { fields, includes }
+  };
+}
+function decodeResult(plan, rows, table, rowOf = decodeRow) {
+  if (plan.mode === "count") {
+    const cell = rows[0]?.[0];
+    if (cell === null || cell === undefined)
+      return 0;
+    return Number(cell);
+  }
+  if (plan.mode === "exists") {
+    const cell = rows[0]?.[0];
+    return cell === "t" || cell === "true" || cell === "1";
+  }
+  const decoded = [];
+  for (const row of rows)
+    decoded.push(rowOf(plan.outputs, row));
+  if (plan.mode === "one") {
+    if (decoded.length > 1) {
+      throw new OkmError2("not_unique", `one() on ${table} matched more than one row. Pass orderBy to take the first, or narrow where.`, { kind: "not_unique", table });
+    }
+    return decoded[0] ?? null;
+  }
+  return decoded;
+}
+function logicalIntent(call) {
+  return {
+    op: call.op,
+    table: call.table,
+    where: plain(call.where),
+    select: call.select,
+    orderBy: call.orderBy,
+    limit: call.limit,
+    include: plain(call.include),
+    all: call.all
+  };
+}
+function appliedRules(call) {
+  const rules = [...BASE_RULES];
+  if (call.where !== undefined) {
+    rules.push({ rule: "filter", contribution: "caller", provenance: "caller" });
+  }
+  if (call.op === "find" || hasMany(call.include)) {
+    rules.push({
+      rule: "bounded",
+      contribution: call.all ?? "limit",
+      provenance: "caller"
+    });
+  }
+  return rules;
+}
+function emit(schema, call, sink, outputs, hooks) {
+  const table = indexes(schema).get(call.table);
+  if (table === undefined) {
+    throwNamed2("OKM1120", call.table, [...indexes(schema).keys()], `Table ${call.table} is not in the schema. Accepted names: ${list([...indexes(schema).keys()])}.`);
+  }
+  rejectOptions(call);
+  const selected = selectedColumns(table, call.select);
+  sink.mark(`${call.op}|${call.table}|`);
+  if (call.op === "count") {
+    sink.text("select count(*)::text from ");
+    sink.text(quote(table.model.sql));
+    sink.text(" t");
+    emitWhere(schema, table, call.where, sink, "t", 0);
+    return;
+  }
+  if (call.op === "exists") {
+    sink.text("select exists(select 1 from ");
+    sink.text(quote(table.model.sql));
+    sink.text(" t");
+    emitWhere(schema, table, call.where, sink, "t", 0);
+    sink.text(")::text");
+    return;
+  }
+  sink.text("select ");
+  let column = 0;
+  for (let index = 0;index < selected.length; index += 1) {
+    const item = selected[index];
+    if (item === undefined)
+      continue;
+    if (index > 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 (call.include !== undefined && hooks === undefined) {
+    fail("OKM1120", "An include needs the include planner.");
+  }
+  const includes = hooks === undefined || call.include === undefined ? [] : hooks.read(schema, table, call.include, call.all);
+  if (selected.length === 0 && includes.length === 0)
+    sink.text("1");
+  for (let index = 0;index < includes.length; index += 1) {
+    const include = includes[index];
+    if (include === undefined)
+      continue;
+    if (hooks === undefined)
+      continue;
+    column = hooks.select(include, `i${String(index)}`, sink, outputs, column);
+  }
+  sink.text(" from ");
+  sink.text(quote(table.model.sql));
+  sink.text(" t");
+  for (let index = 0;index < includes.length; index += 1) {
+    const include = includes[index];
+    if (include === undefined)
+      continue;
+    hooks?.join(schema, include, sink, "t", `i${String(index)}`, 0);
+  }
+  emitWhere(schema, table, call.where, sink, "t", 0);
+  emitOrder(table, call.orderBy, sink, "t");
+  emitLimit(call, sink);
+}
+function emitJoin(sink, parent, child, relation) {
+  for (let index = 0;index < relation.local.length; index += 1) {
+    const local = relation.local[index];
+    const remote = relation.remote[index];
+    if (local === undefined || remote === undefined)
+      continue;
+    if (index > 0)
+      sink.text(" and ");
+    sink.text(child);
+    sink.text(".");
+    sink.text(quote(remote));
+    sink.text(" = ");
+    sink.text(parent);
+    sink.text(".");
+    sink.text(quote(local));
+  }
+}
+function emitWhere(schema, table, where, sink, alias, depth, appended = false) {
+  if (where === undefined)
+    return;
+  if (isOperator(where) && operatorName(where) === "or") {
+    sink.text(appended ? " and " : " where ");
+    emitOr(schema, table, operatorValue(where), sink, alias, depth);
+    return;
+  }
+  if (!isRecord(where)) {
+    fail("OKM1121", "where must be an object of fields. Wrap an object value with eq.");
+  }
+  const keys = Object.keys(where);
+  if (keys.length === 0)
+    return;
+  sink.text(appended ? " and " : " where ");
+  emitAnd(schema, table, where, sink, alias, depth);
+}
+function emitAnd(schema, table, where, sink, alias, depth) {
+  if (!isRecord(where)) {
+    fail("OKM1121", "where must be an object of fields. Wrap an object value with eq.");
+  }
+  const keys = Object.keys(where);
+  let wrote = false;
+  for (const key of keys) {
+    const value = where[key];
+    if (value === undefined)
+      continue;
+    if (wrote)
+      sink.text(" and ");
+    wrote = true;
+    emitPredicate(schema, table, key, value, sink, alias, depth);
+  }
+  if (!wrote)
+    sink.text("true");
+}
+function emitPredicate(schema, table, key, value, sink, alias, depth) {
+  const relation = table.relations.get(key);
+  if (relation !== undefined) {
+    emitRelationFilter(schema, relation, value, sink, alias, depth);
+    return;
+  }
+  const column = table.columns.get(key);
+  if (column === undefined) {
+    throwNamed2("OKM1120", key, table.names, `Field ${key} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+  }
+  sink.mark(`w:${key}`);
+  emitOperand(schema, table, column, value, sink, alias, depth);
+}
+function emitOperand(schema, table, column, value, sink, alias, depth) {
+  const ref = `${alias}.${quote(column.sql)}`;
+  if (isOperator(value)) {
+    emitOperator(schema, table, column, ref, operatorName(value), operatorValue(value), sink, alias, depth);
+    return;
+  }
+  if (value === null) {
+    sink.mark(":null");
+    sink.text(ref);
+    sink.text(" is null");
+    return;
+  }
+  if (typeof value === "object") {
+    fail("OKM1121", `Field ${column.field} received an object. Wrap it with eq. eq is the equality form for json and jsonb.`);
+  }
+  sink.mark(":eq");
+  sink.text(ref);
+  sink.text(" = ");
+  sink.param(column.encode(value));
+}
+function emitOperator(schema, table, column, ref, name, value, sink, alias, depth) {
+  sink.mark(`:${name}`);
+  if (name === "or") {
+    emitOr(schema, table, value, sink, alias, depth);
+    return;
+  }
+  if (column === undefined) {
+    fail("OKM1121", "That operator needs a field.");
+  }
+  if (name === "not") {
+    emitNot(schema, table, column, ref, value, sink, alias, depth);
+    return;
+  }
+  if (name === "eq") {
+    emitOperand(schema, table, column, value, sink, alias, depth);
+    return;
+  }
+  if (name === "lt" || name === "lte" || name === "gt" || name === "gte") {
+    sink.text(ref);
+    sink.text(name === "lt" ? " < " : name === "lte" ? " <= " : name === "gt" ? " > " : " >= ");
+    sink.param(column.encode(requireValue(column, value)));
+    return;
+  }
+  if (name === "between") {
+    if (!Array.isArray(value) || value.length !== 2) {
+      fail("OKM1121", `between on ${column.field} needs two values.`);
+    }
+    sink.text(ref);
+    sink.text(" between ");
+    sink.param(column.encode(requireValue(column, value[0])));
+    sink.text(" and ");
+    sink.param(column.encode(requireValue(column, value[1])));
+    return;
+  }
+  if (name === "inList" || name === "notIn") {
+    emitIn(column, ref, name, value, sink);
+    return;
+  }
+  if (name === "startsWith" || name === "contains" || name === "endsWith") {
+    if (typeof value !== "string") {
+      fail("OKM1121", `${name} on ${column.field} needs a string.`);
+    }
+    sink.text(ref);
+    sink.text(" like ");
+    sink.param(literalPattern(value, name));
+    sink.text(" escape E'\\\\'");
+    return;
+  }
+  if (name === "like" || name === "ilike") {
+    if (typeof value !== "string") {
+      fail("OKM1121", `${name} on ${column.field} needs a string.`);
+    }
+    sink.text(ref);
+    sink.text(name === "like" ? " like " : " ilike ");
+    sink.param(value);
+    return;
+  }
+  fail("OKM1121", `${name} is not a value operator on ${column.field}. Use has, none, or every on a relation.`);
+}
+function emitNot(schema, table, column, ref, value, sink, alias, depth) {
+  if (value === null) {
+    sink.mark(":null");
+    sink.text(ref);
+    sink.text(" is not null");
+    return;
+  }
+  if (isOperator(value) && operatorName(value) === "inList") {
+    const listed = operatorValue(value);
+    if (Array.isArray(listed) && listed.length === 0) {
+      sink.text("true");
+      return;
+    }
+  }
+  sink.text("not (");
+  emitOperand(schema, table, column, value, sink, alias, depth);
+  sink.text(")");
+}
+function emitIn(column, ref, name, value, sink) {
+  if (!Array.isArray(value)) {
+    fail("OKM1121", `${name} on ${column.field} needs a list.`);
+  }
+  sink.mark(`:${String(value.length)}`);
+  if (value.length === 0) {
+    sink.text(name === "inList" ? "false" : "true");
+    return;
+  }
+  sink.text(ref);
+  sink.text(name === "inList" ? " in (" : " not in (");
+  for (let index = 0;index < value.length; index += 1) {
+    if (index > 0)
+      sink.text(", ");
+    sink.param(column.encode(requireValue(column, value[index])));
+  }
+  sink.text(")");
+}
+function emitOr(schema, table, value, sink, alias, depth) {
+  if (!Array.isArray(value) || value.length === 0) {
+    sink.text("false");
+    sink.mark(":0");
+    return;
+  }
+  sink.mark(`:${String(value.length)}`);
+  sink.text("(");
+  for (let index = 0;index < value.length; index += 1) {
+    const branch = value[index];
+    if (index > 0)
+      sink.text(" or ");
+    sink.text("(");
+    if (!isRecord(branch)) {
+      fail("OKM1121", "or() branches must be where objects.");
+    }
+    let wrote = false;
+    for (const key of Object.keys(branch)) {
+      const item = branch[key];
+      if (item === undefined)
+        continue;
+      if (wrote)
+        sink.text(" and ");
+      wrote = true;
+      emitPredicate(schema, table, key, item, sink, alias, depth);
+    }
+    if (!wrote)
+      sink.text("true");
+    sink.text(")");
+  }
+  sink.text(")");
+}
+function emitRelationFilter(schema, relation, value, sink, alias, depth) {
+  if (!isOperator(value)) {
+    fail("OKM1121", `Relation ${relation.name} needs has, none, or every.`);
+  }
+  const name = operatorName(value);
+  if (name !== "has" && name !== "none" && name !== "every") {
+    fail("OKM1121", `Relation ${relation.name} needs has, none, or every.`);
+  }
+  const child = indexes(schema).get(relation.table);
+  if (child === undefined) {
+    fail("OKM1120", `Relation ${relation.name} names ${relation.table}, which is not in the schema.`);
+  }
+  const childAlias = `r${String(depth)}_${relation.name}`;
+  sink.mark(`rel:${relation.name}:${name}`);
+  if (name === "none" || name === "every")
+    sink.text("not ");
+  sink.text("exists (select 1 from ");
+  sink.text(quote(child.model.sql));
+  sink.text(" ");
+  sink.text(childAlias);
+  sink.text(" where ");
+  emitJoin(sink, alias, childAlias, relation);
+  const inner = operatorValue(value);
+  if (name === "every") {
+    sink.text(" and not (");
+    emitAnd(schema, child, inner ?? {}, sink, childAlias, depth + 1);
+    sink.text(")");
+    sink.text(")");
+    return;
+  }
+  emitWhere(schema, child, inner, sink, childAlias, depth + 1, true);
+  sink.text(")");
+}
+function emitOrder(table, orderBy, sink, alias) {
+  if (orderBy === undefined)
+    return;
+  if (!isRecord(orderBy)) {
+    fail("OKM1120", "orderBy must be an object of fields.");
+  }
+  const keys = Object.keys(orderBy);
+  if (keys.length === 0)
+    return;
+  sink.text(" order by ");
+  for (let index = 0;index < keys.length; index += 1) {
+    const key = keys[index];
+    if (key === undefined)
+      continue;
+    const column = table.columns.get(key);
+    if (column === undefined) {
+      throwNamed2("OKM1120", key, table.names, `Field ${key} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+    }
+    const parsed = parseOrder(key, orderBy[key]);
+    if (index > 0)
+      sink.text(", ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(column.sql));
+    sink.text(parsed.dir === "asc" ? " asc" : " desc");
+    sink.text(parsed.nulls === "first" ? " nulls first" : " nulls last");
+    sink.mark(`o:${key}:${parsed.dir}:${parsed.nulls}`);
+  }
+}
+function emitPrimaryOrder(table, sink, alias) {
+  sink.text(" order by ");
+  for (let index = 0;index < table.model.primary.length; index += 1) {
+    const field = table.model.primary[index];
+    if (field === undefined)
+      continue;
+    const column = table.columns.get(field);
+    if (column === undefined)
+      continue;
+    if (index > 0)
+      sink.text(", ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(column.sql));
+    sink.text(" asc");
+  }
+}
+function emitLimit(call, sink) {
+  if (call.op === "one") {
+    const ordered = call.orderBy !== undefined && isRecord(call.orderBy) && Object.keys(call.orderBy).length > 0;
+    sink.text(ordered ? " limit 1" : " limit 2");
+    sink.mark(ordered ? "one:1" : "one:2");
+    return;
+  }
+  if (call.op !== "find")
+    return;
+  if (call.all !== undefined) {
+    if (call.all.length === 0) {
+      fail("OKM1101", "find() .all needs a reason.");
+    }
+    sink.mark(`all:${call.all}`);
+    if (call.limit !== undefined) {
+      const limit = readLimit(call.limit);
+      sink.text(" limit ");
+      sink.param(String(limit));
+      sink.mark(`l:${String(limit)}`);
+    }
+    return;
+  }
+  if (call.limit === undefined) {
+    fail("OKM1101", "find() needs a limit, or .all(reason) when the full set is intentional.");
+  }
+  const limit = readLimit(call.limit);
+  sink.text(" limit ");
+  sink.param(String(limit));
+  sink.mark(`l:${String(limit)}`);
+}
+function selectedColumns(table, select) {
+  if (select === undefined) {
+    const columns = [];
+    for (const column of table.model.columns) {
+      if (!column.hidden)
+        columns.push(column);
+    }
+    return columns;
+  }
+  if (!Array.isArray(select)) {
+    fail("OKM1120", "select must be a list of field names.");
+  }
+  const columns = [];
+  for (const name of select) {
+    if (typeof name !== "string") {
+      fail("OKM1120", "select must be a list of field names.");
+    }
+    const column = table.columns.get(name);
+    if (column === undefined) {
+      throwNamed2("OKM1120", name, table.names, `Field ${name} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+    }
+    columns.push(column);
+  }
+  return columns;
+}
+function parseOrder(field, value) {
+  if (value === "asc")
+    return { dir: "asc", nulls: "last" };
+  if (value === "desc")
+    return { dir: "desc", nulls: "first" };
+  if (isRecord(value)) {
+    const dir = value.dir ?? value.direction;
+    if (dir !== "asc" && dir !== "desc") {
+      fail("OKM1120", `orderBy ${field} must be asc or desc.`);
+    }
+    const nulls = value.nulls;
+    if (nulls === undefined)
+      return { dir, nulls: dir === "asc" ? "last" : "first" };
+    if (nulls !== "first" && nulls !== "last") {
+      fail("OKM1120", `orderBy ${field} nulls must be first or last.`);
+    }
+    return { dir, nulls };
+  }
+  fail("OKM1120", `orderBy ${field} must be asc or desc.`);
+}
+function rejectOptions(call) {
+  const record = call;
+  const accepted = call.op === "find" ? FIND_OPTIONS : call.op === "one" ? ONE_OPTIONS : FILTER_OPTIONS;
+  const present = {};
+  if (call.where !== undefined)
+    present.where = call.where;
+  if (call.select !== undefined)
+    present.select = call.select;
+  if (call.orderBy !== undefined)
+    present.orderBy = call.orderBy;
+  if (call.limit !== undefined)
+    present.limit = call.limit;
+  if (call.include !== undefined)
+    present.include = call.include;
+  rejectKeys(present, accepted, call.op);
+}
+function rejectKeys(value, accepted, where) {
+  for (const key of Object.keys(value)) {
+    if (accepted.includes(key))
+      continue;
+    throwNamed2("OKM1120", key, accepted, `Option ${key} is not accepted by ${where}. Accepted options: ${list(accepted)}.`);
+  }
+}
+function readLimit(value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new OkmError2("invalid", "limit must be an integer from 0 up.", { kind: "invalid" });
+  }
+  return value;
+}
+function requireValue(column, value) {
+  if (value === undefined || value === null || typeof value === "object") {
+    fail("OKM1121", `Field ${column.field} needs a value. Wrap an object with eq.`);
+  }
+  return value;
+}
+function projectExpr(sql, dataType) {
+  if (dataType === "timestamptz" || dataType === "timestamp")
+    return jsonExpr(sql, dataType);
+  return sql;
+}
+function jsonExpr(sql, dataType) {
+  if (dataType === "timestamptz") {
+    return `to_char(${sql} AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.US"Z"')`;
+  }
+  if (dataType === "timestamp") {
+    return `to_char(${sql}, 'YYYY-MM-DD"T"HH24:MI:SS.US')`;
+  }
+  return `${sql}::text`;
+}
+function literalPattern(value, mode) {
+  let out = "";
+  for (let index = 0;index < value.length; index += 1) {
+    const char = value[index] ?? "";
+    if (char === "\\" || char === "%" || char === "_")
+      out += "\\";
+    out += char;
+  }
+  if (mode === "startsWith")
+    return `${out}%`;
+  if (mode === "endsWith")
+    return `%${out}`;
+  return `%${out}%`;
+}
+function decodeRow(outputs, row) {
+  const result = {};
+  for (const field of outputs.fields) {
+    result[field.key] = cell(row[field.at], field.decode);
+  }
+  return result;
+}
+function cell(value, decode) {
+  if (value === null || value === undefined)
+    return null;
+  return decode === undefined ? value : decode(value);
+}
+function indexes(schema) {
+  const cached = indexesOf.get(schema);
+  if (cached !== undefined)
+    return cached;
+  const built = new Map;
+  for (const model of Object.values(schema.model)) {
+    assertIdentifier2(model.sql, `table ${model.name}`);
+    const columns = new Map;
+    const names = [];
+    for (const column of model.columns) {
+      assertIdentifier2(column.sql, `column ${model.name}.${column.field}`);
+      columns.set(column.field, column);
+      names.push(column.field);
+    }
+    names.sort();
+    const relations = new Map;
+    for (const relation of model.relations)
+      relations.set(relation.name, relation);
+    built.set(model.name, { model, columns, relations, names });
+  }
+  indexesOf.set(schema, built);
+  return built;
+}
+function fingerprint(key) {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  const mask = 0xffffffffffffffffn;
+  for (let index = 0;index < key.length; index += 1) {
+    hash ^= BigInt(key.charCodeAt(index));
+    hash = hash * prime & mask;
+  }
+  return `Q_${hash.toString(16).padStart(16, "0")}`;
+}
+function quote(name) {
+  let out = '"';
+  for (let index = 0;index < name.length; index += 1) {
+    const char = name[index] ?? "";
+    out += char === '"' ? '""' : char;
+  }
+  return `${out}"`;
+}
+function list(names) {
+  return names.length === 0 ? "(none)" : names.join(", ");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !isOperator(value);
+}
+function fail(code, message) {
+  const fix = code === "OKM1121" ? { summary: "Use eq for an object value, or has, none, or every for a relation." } : code === "OKM1101" ? { summary: "Pass limit, or call .all(reason)." } : code === "OKM1102" ? { summary: "Pass where, or call .all(reason) to match every row." } : code === "OKM1104" ? { summary: "Set on to the columns of a unique constraint or the primary key." } : code === "OKM1105" ? { summary: "Pass limit on the include, or call .all(reason)." } : code === "OKM1190" ? { summary: "Remove the guarded field. Input cannot set it." } : undefined;
+  throw new OkmError2(code, message, fix === undefined ? undefined : { fix });
+}
+function plain(value) {
+  if (isOperator(value)) {
+    return { op: operatorName(value), value: plain(operatorValue(value)) };
+  }
+  if (Array.isArray(value))
+    return value.map((item) => plain(item));
+  if (typeof value === "object" && value !== null) {
+    const out = {};
+    for (const key of Object.keys(value))
+      out[key] = plain(value[key]);
+    return out;
+  }
+  return value;
+}
+function hasMany(include) {
+  if (!isRecord(include))
+    return false;
+  return Object.keys(include).length > 0;
+}
+
+// src/runtime/client.ts
+var PLAN_LIMIT = 64;
+var SINGLE_ENDPOINT = {
+  endpoint: "primary",
+  role: "primary",
+  reason: "single-endpoint"
+};
+function createClient(schema, pool, options) {
+  const connected = checkServer(pool, schema, options.http, options.requireMeta === true, callOptions(options), {
+    ...options.catalog !== undefined ? { catalog: options.catalog } : {},
+    ...options.catalogDir !== undefined ? { catalogDir: options.catalogDir } : {}
+  });
+  const session = {
+    schema,
+    pool,
+    ownsPool: options.ownsPool,
+    http: options.http,
+    includeValues: options.includeValues === true,
+    logger: options.logger,
+    connected,
+    cache: new Map
+  };
+  const tables = {};
+  for (const name of Object.keys(schema.model)) {
+    tables[name] = tableApi(session, name);
+  }
+  let closing;
+  const client = {
+    ...tables,
+    table(name) {
+      const found = tables[name];
+      if (found !== undefined)
+        return found;
+      try {
+        throwNamed2("OKM1120", name, Object.keys(tables), `Table ${name} is not in the schema. Accepted names: ${Object.keys(tables).join(", ")}.`);
+      } catch (error) {
+        if (error instanceof OkmError2)
+          throw attachHttp(session.http, error);
+        throw error;
+      }
+    },
+    close() {
+      if (!options.ownsPool)
+        return Promise.resolve();
+      closing ??= pool.close();
+      return closing;
+    },
+    connected
+  };
+  attachAsyncDispose(client, () => client.close());
+  return client;
+}
+function attachAsyncDispose(client, close) {
+  const symbol = Symbol.asyncDispose;
+  if (typeof symbol !== "symbol")
+    return;
+  Object.defineProperty(client, symbol, {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: () => close()
+  });
+}
+function tableApi(session, table) {
+  return {
+    find(options = {}) {
+      return start(session, "find", table, options, {});
+    },
+    one(options = {}) {
+      return start(session, "one", table, options, {});
+    },
+    count(options = {}) {
+      return start(session, "count", table, options, {});
+    },
+    exists(options = {}) {
+      return start(session, "exists", table, options, {});
+    },
+    insert(data, options = {}) {
+      return writeHandle(session, "insert", table, data, options, {});
+    },
+    update(target, options = {}) {
+      return writeHandle(session, "update", table, target, options, {});
+    },
+    delete(target, options = {}) {
+      return writeHandle(session, "delete", table, target, options, {});
+    }
+  };
+}
+var writers;
+function loadWrite() {
+  writers ??= import("./x5x59srr.js");
+  return writers;
+}
+function writeHandle(session, op, table, input, options, mods) {
+  let pending;
+  const run = () => {
+    pending ??= runWrite(session, op, table, input, options, mods);
+    return pending;
+  };
+  const self = {
+    then(onFulfilled, onRejected) {
+      return run().then(onFulfilled, onRejected);
+    },
+    catch(onRejected) {
+      return self.then(undefined, onRejected);
+    },
+    finally(fn) {
+      return self.then((value) => {
+        fn();
+        return value;
+      }, (error) => {
+        fn();
+        throw error;
+      });
+    },
+    safe() {
+      return safe2(run());
+    },
+    sql() {
+      return loadWrite().then((mod) => mod.explainWrite(session.schema, op, table, input, options, mods));
+    },
+    expect(count) {
+      return writeHandle(session, op, table, input, options, { ...mods, expect: count });
+    },
+    all(reason) {
+      return writeHandle(session, op, table, input, options, { ...mods, all: reason });
+    }
+  };
+  return self;
+}
+async function runWrite(session, op, table, input, options, mods) {
+  await session.connected;
+  const mod = await loadWrite();
+  try {
+    return await mod.executeWrite({ schema: session.schema, pool: session.pool }, op, table, input, options, mods);
+  } catch (error) {
+    throw logged(session, await mapError(session, error));
+  }
+}
+function start(session, op, table, options, mods) {
+  const call = readCall(op, table, options, mods.all);
+  let prepared;
+  const prepare = async () => {
+    if (prepared !== undefined)
+      return prepared;
+    const hooks = await hooksFor(call);
+    const bound = bindCall(session.schema, call, hooks);
+    let plan = session.cache.get(bound.key);
+    if (plan === undefined) {
+      plan = compileCall(session.schema, call, bound.key, hooks);
+      if (session.cache.size >= PLAN_LIMIT) {
+        const oldest = session.cache.keys().next().value;
+        if (oldest !== undefined)
+          session.cache.delete(oldest);
+      }
+      session.cache.set(bound.key, plan);
+    }
+    prepared = { plan, params: bound.params };
+    return prepared;
+  };
+  const run = async () => {
+    await session.connected;
+    const { plan, params } = await prepare();
+    try {
+      const result = await session.pool.execute(plan.text, params, callOptions(mods));
+      const value = plan.outputs.includes.length === 0 ? decodeResult(plan, result.rows, table) : (await import("./hadrfb9h.js")).decodeIncluded(plan, result.rows, table);
+      if (mods.required === true && value === null) {
+        throw new OkmError2("not_found", `one() on ${table} matched no row.`, withHttp(session.http, { kind: "not_found", table }));
+      }
+      return value;
+    } catch (error) {
+      throw logged(session, await mapError(session, error));
+    }
+  };
+  let pending;
+  const once = () => {
+    pending ??= run();
+    return pending;
+  };
+  const self = {
+    then(onFulfilled, onRejected) {
+      return once().then(onFulfilled, onRejected);
+    },
+    catch(onRejected) {
+      return this.then(undefined, onRejected);
+    },
+    finally(fn) {
+      return this.then((value) => {
+        fn();
+        return value;
+      }, (error) => {
+        fn();
+        throw error;
+      });
+    },
+    inspect() {
+      if (call.include === undefined && prepared !== undefined) {
+        return inspection(prepared.plan, prepared.params, call);
+      }
+      if (call.include === undefined) {
+        const bound = bindNow(session.schema, call);
+        prepared = bound;
+        return inspection(bound.plan, bound.params, call);
+      }
+      return prepare().then(({ plan, params }) => inspection(plan, params, call));
+    },
+    sql() {
+      if (call.include === undefined && prepared !== undefined) {
+        return { text: prepared.plan.text, params: prepared.params };
+      }
+      if (call.include === undefined) {
+        const { plan, params } = bindNow(session.schema, call);
+        prepared = { plan, params };
+        return { text: plan.text, params };
+      }
+      return prepare().then(({ plan, params }) => ({ text: plan.text, params }));
+    },
+    safe() {
+      return safe2(once());
+    },
+    all(reason) {
+      return start(session, op, table, options, { ...mods, all: reason });
+    },
+    required() {
+      return start(session, op, table, options, { ...mods, required: true });
+    },
+    stream() {
+      return streamRows(session, call, prepare);
+    }
+  };
+  return self;
+}
+async function* streamRows(session, call, prepare) {
+  await session.connected;
+  if (session.pool.capabilities.stream !== true || session.pool.stream === undefined) {
+    throw logged(session, new OkmError2("OKM1111", "stream needs a driver with stream: true. This driver does not have it.", withHttp(session.http, {
+      fix: { summary: "Use a driver that sets stream, or read with find." }
+    })));
+  }
+  const { plan, params } = await prepare();
+  const decode = plan.outputs.includes.length === 0 ? decodeResult : (await import("./hadrfb9h.js")).decodeIncluded;
+  for await (const chunk of session.pool.stream(plan.text, params)) {
+    const decoded = decode(plan, chunk, call.table);
+    if (!Array.isArray(decoded))
+      continue;
+    for (const row of decoded)
+      yield row;
+  }
+}
+function readCall(op, table, options, all) {
+  const record = options;
+  const accepted = op === "find" ? ["include", "limit", "orderBy", "select", "where"] : op === "one" ? ["include", "orderBy", "select", "where"] : ["where"];
+  for (const key of Object.keys(record)) {
+    if (!accepted.includes(key)) {
+      throwNamed2("OKM1120", key, accepted, `Option ${key} is not accepted by ${op}. Accepted options: ${accepted.join(", ")}.`);
+    }
+  }
+  return {
+    op,
+    table,
+    ...record.where !== undefined ? { where: record.where } : {},
+    ...record.select !== undefined ? { select: record.select } : {},
+    ...record.orderBy !== undefined ? { orderBy: record.orderBy } : {},
+    ...record.limit !== undefined ? { limit: record.limit } : {},
+    ...record.include !== undefined ? { include: record.include } : {},
+    ...all !== undefined ? { all } : {}
+  };
+}
+async function checkServer(pool, schema, http, requireMeta, options, source) {
+  let rows;
+  try {
+    const result = await pool.execute(SERVER_CHECK, undefined, options);
+    rows = result.rows;
+  } catch (error) {
+    const { mapPostgresError } = await import("./zhc5vmgf.js");
+    throw mapPostgresError(error, mapOptions(http, false));
+  }
+  const version = rows[0]?.[1];
+  if (version === null || version === undefined || !version.startsWith("PostgreSQL")) {
+    throw new OkmError2("OKM1801", "The server is not PostgreSQL. The schema dialect is postgres.", withHttp(http, {
+      fix: { summary: "Open the schema with the Postgres driver that matches it." }
+    }));
+  }
+  const recorded = rows[0]?.[2];
+  if (recorded === null || recorded === undefined || recorded.length === 0) {
+    if (requireMeta) {
+      throw new OkmError2("OKM1520", "okm_meta has no catalog hash.", withHttp(http, {
+        fix: {
+          summary: "Apply migrations so okm_meta records the catalog, or omit requireMeta to adopt this database."
+        }
+      }));
+    }
+  } else {
+    const { assertCompatible } = await import("./qk3hxfja.js");
+    try {
+      await assertCompatible(pool, schema, recorded, source, options);
+    } catch (error) {
+      if (error instanceof OkmError2)
+        throw attachHttp(http, error);
+      throw error;
+    }
+  }
+  const requires = schema.requires?.postgres;
+  if (requires === undefined)
+    return;
+  const major = Math.floor(Number(rows[0]?.[0] ?? "0") / 1e4);
+  const match = /^>=(\d+)$/.exec(requires.trim());
+  const need = match?.[1] === undefined ? undefined : Number(match[1]);
+  if (need === undefined || major < need) {
+    throw new OkmError2("OKM1802", `The server is PostgreSQL ${String(major)}. schema({ requires }) asks for ${requires}.`, withHttp(http, {
+      fix: { summary: "Upgrade the server, or lower requires to a version the server meets." }
+    }));
+  }
+}
+async function mapError(session, error) {
+  if (error instanceof OkmError2) {
+    return session.http === undefined ? error : new OkmError2(error.code, error.message, { ...errorFields(error), http: session.http });
+  }
+  const { mapPostgresError } = await import("./zhc5vmgf.js");
+  return mapPostgresError(error, mapOptions(session.http, session.includeValues));
+}
+function errorFields(error) {
+  return {
+    kind: error.kind,
+    ...error.table !== undefined ? { table: error.table } : {},
+    ...error.columns.length > 0 ? { columns: error.columns } : {},
+    fix: error.fix
+  };
+}
+var includeHooks;
+function hooksFor(call) {
+  if (call.include === undefined)
+    return Promise.resolve(undefined);
+  includeHooks ??= import("./hadrfb9h.js").then((mod) => mod.includeHooks);
+  return includeHooks;
+}
+function bindNow(schema, call) {
+  const bound = bindCall(schema, call);
+  const plan = compileCall(schema, call, bound.key);
+  return { plan, params: bound.params };
+}
+function inspection(plan, params, call) {
+  return {
+    intent: logicalIntent(call),
+    rules: appliedRules(call),
+    plan: { strategy: "postgres:single-statement", statements: 1, fingerprint: plan.fingerprint },
+    sql: { text: plan.text, params },
+    routing: SINGLE_ENDPOINT
+  };
+}
+function withHttp(http, options) {
+  return http === undefined ? options : { ...options, http };
+}
+function attachHttp(http, error) {
+  if (http === undefined)
+    return error;
+  return new OkmError2(error.code, error.message, { ...errorFields(error), http });
+}
+function callOptions(input) {
+  if (input.signal === undefined && input.timeout === undefined)
+    return;
+  return {
+    ...input.signal !== undefined ? { signal: input.signal } : {},
+    ...input.timeout !== undefined ? { timeout: input.timeout } : {}
+  };
+}
+var SERVER_CHECK = "select current_setting('server_version_num'), version(), (select (xpath('//catalog_hash/text()', query_to_xml('select catalog_hash from okm_meta where id = ''head''', true, false, '')))[1]::text where to_regclass('okm_meta') is not null)";
+function mapOptions(http, includeValues) {
+  return {
+    ...http !== undefined ? { http } : {},
+    ...includeValues ? { includeValues: true } : {}
+  };
+}
+function logged(session, error) {
+  session.logger?.error?.({ code: error.code, summary: error.summary });
+  return error;
+}
+
+export { decodeResult, emitJoin, emitWhere, emitOrder, emitPrimaryOrder, selectedColumns, rejectKeys, readLimit, projectExpr, jsonExpr, decodeRow, cell, indexes, quote, list, isRecord, fail, createClient };