@palbase/backend 25.1.0 → 27.1.0

package/dist/chunk-JVZQCC77.js

@@ -0,0 +1,728 @@
+import {
+  __name
+} from "./chunk-VXPNPVAG.js";
+
+// src/db/input-guards.ts
+var REF_BRAND = /* @__PURE__ */ Symbol.for("palbase.db.ref");
+function brandRef(v, kind) {
+  Object.defineProperty(v, REF_BRAND, {
+    value: kind,
+    enumerable: false
+  });
+  return v;
+}
+__name(brandRef, "brandRef");
+function brandOf(v) {
+  if (typeof v !== "object" || v === null) return void 0;
+  return Object.hasOwn(v, REF_BRAND) ? v[REF_BRAND] : void 0;
+}
+__name(brandOf, "brandOf");
+function looksLikeUnbrandedRef(v) {
+  if (typeof v !== "object" || v === null) return null;
+  if (brandOf(v) !== void 0) return null;
+  if (isColumnExpr(v)) return null;
+  const o = v;
+  if (typeof o.$col === "string") return "col";
+  if (o.$sql !== void 0 && typeof o.$sql === "object" && o.$sql !== null) return "sql";
+  if (o.$expr !== void 0 && typeof o.$expr === "object" && o.$expr !== null) return "expr";
+  return null;
+}
+__name(looksLikeUnbrandedRef, "looksLikeUnbrandedRef");
+function isColRef(v) {
+  return brandOf(v) === "col" && typeof v.$col === "string";
+}
+__name(isColRef, "isColRef");
+function isPlanRef(v) {
+  if (brandOf(v) !== "ref") return false;
+  const r = v.$ref;
+  return r !== void 0 && typeof r.op === "number" && typeof r.field === "string";
+}
+__name(isPlanRef, "isPlanRef");
+function looksLikeUnbrandedPlanRef(v) {
+  if (typeof v !== "object" || v === null || brandOf(v) !== void 0) return false;
+  const r = v.$ref;
+  return r !== void 0 && typeof r === "object" && r !== null;
+}
+__name(looksLikeUnbrandedPlanRef, "looksLikeUnbrandedPlanRef");
+function isSqlFragment(v) {
+  if (brandOf(v) !== "sql") return false;
+  const f = v.$sql;
+  return f !== void 0 && Array.isArray(f.text) && Array.isArray(f.values);
+}
+__name(isSqlFragment, "isSqlFragment");
+var TX_EXPR = /* @__PURE__ */ Symbol.for("palbase.tx.expr");
+function isNowExpr(v) {
+  if (!isColumnExpr(v)) return false;
+  try {
+    const e = v[TX_EXPR];
+    return typeof e === "object" && e !== null && e.fn === "now";
+  } catch {
+    return false;
+  }
+}
+__name(isNowExpr, "isNowExpr");
+function isColumnExpr(v) {
+  if (typeof v !== "object" && typeof v !== "function") return false;
+  if (v === null) return false;
+  try {
+    return v[TX_EXPR] !== void 0;
+  } catch {
+    return false;
+  }
+}
+__name(isColumnExpr, "isColumnExpr");
+function assertNoExpressionHandles(caller, table, cols, data) {
+  for (const c of cols) {
+    const v = data[c];
+    if (isColumnExpr(v)) {
+      throw new Error(`${caller}(${table}): "${c}" bir ifade tutama\u011F\u0131 ald\u0131 (increment()/decrement()/now()). Bu yolda de\u011Fer beklenir. Saya\xE7 art\u0131\u015F\u0131 i\xE7in updateMany(where, { ${c}: increment(n) }) ya da $transaction i\xE7inde tx.tables.${table}.updateWhere(where, { ${c}: increment(n) }) kullan\u0131n.`);
+    }
+    if (isColRef(v)) {
+      throw new Error(`${caller}(${table}): "${c}" bir col() ald\u0131. Kolon referans\u0131 yaln\u0131z F\u0130LTREDE durabilir; bir kolonun de\u011Ferini ba\u015Fka bir kolona yazmak i\xE7in $query kullan\u0131n.`);
+    }
+  }
+}
+__name(assertNoExpressionHandles, "assertNoExpressionHandles");
+var KNOWN_OPS = /* @__PURE__ */ new Set([
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "neq",
+  "in",
+  // K1 metin operatörleri (FR-005) ve null testi (FR-006). Bu küme
+  // `fakeDatabase()` ile ORTAK kaynaktır: fake bir çağrıyı motorun reddettiği
+  // yerde kabul ederse, yazarın testi üretimde patlayan koda karşı yeşil verir.
+  "contains",
+  "icontains",
+  "startsWith",
+  "endsWith",
+  "isNull"
+]);
+var REFUSED_OPS = {
+  eq: 'e\u015Fitlik \xC7IPLAK yaz\u0131l\u0131r: { <kolon>: <de\u011Fer> } (ya da kolon kar\u015F\u0131la\u015Ft\u0131rmas\u0131 i\xE7in { <kolon>: col("\u2026") })'
+};
+function assertUsableFilter(caller, table, where) {
+  const COMPOSITES = /* @__PURE__ */ new Set([
+    "OR",
+    "AND",
+    "NOT"
+  ]);
+  if (!where) return;
+  if (isSqlFragment(where)) return;
+  for (const [col, cond] of Object.entries(where)) {
+    if (COMPOSITES.has(col)) {
+      const branches = col === "NOT" ? [
+        cond
+      ] : cond;
+      if (!Array.isArray(branches) && col !== "NOT") {
+        throw new Error(`${caller}(${table}): where.${col} bir dizi olmal\u0131`);
+      }
+      for (const b of branches) {
+        if (b === null || typeof b !== "object") {
+          throw new Error(`${caller}(${table}): where.${col} dallar\u0131 filtre nesnesi olmal\u0131`);
+        }
+        assertUsableFilter(caller, table, b);
+      }
+      continue;
+    }
+    if (col === "has") {
+      if (cond === null || typeof cond !== "object" || Array.isArray(cond)) {
+        throw new Error(`${caller}(${table}): where.has bir ili\u015Fki haritas\u0131 olmal\u0131 ({ <ili\u015Fki>: { \u2026 } })`);
+      }
+      for (const [rel, inner] of Object.entries(cond)) {
+        if (inner === null || typeof inner !== "object" || Array.isArray(inner)) {
+          throw new Error(`${caller}(${table}): where.has.${rel} bir filtre nesnesi olmal\u0131`);
+        }
+        assertUsableFilter(caller, table, inner);
+      }
+      continue;
+    }
+    if (cond === void 0) {
+      throw new Error(`${caller}(${table}): where.${col} de\u011Feri undefined \u2014 bu bir filtre de\u011Feri de\u011Fil. Ba\u011Flan\u0131nca NULL olur ve '= NULL' hi\xE7bir sat\u0131ra uymaz, yani sorgu sessizce bo\u015F sonu\xE7 d\xF6nerdi. De\u011Fer yoksa anahtar\u0131 filtreye hi\xE7 koymay\u0131n.`);
+    }
+    if (cond === null || typeof cond !== "object" || Array.isArray(cond)) continue;
+    if (isColRef(cond)) continue;
+    if (isNowExpr(cond)) continue;
+    const entries = Object.entries(cond);
+    if (entries.length === 0) {
+      throw new Error(`${caller}(${table}): where.${col} bo\u015F bir operat\xF6r nesnesi ({}) \u2014 hi\xE7bir ko\u015Ful \xFCretmez, yani bu alan filtreden sessizce D\xDC\u015EERD\u0130. Ko\u015Ful kurulmayacaksa anahtar\u0131 filtreye hi\xE7 koymay\u0131n (D-21).`);
+    }
+    for (const [op, v] of entries) {
+      if (op === "in") {
+        if (!Array.isArray(v)) throw new Error(`${caller}(${table}): where.${col}.in bir dizi olmal\u0131`);
+        if (v.some((x) => x === void 0)) {
+          throw new Error(`${caller}(${table}): where.${col}.in listesinde undefined var \u2014 sessizce NULL'a ba\u011Flan\u0131r ve o eleman hi\xE7bir sat\u0131rla e\u015Fle\u015Fmez. Listeyi kurarken eleyin.`);
+        }
+        continue;
+      }
+      if (REFUSED_OPS[op] !== void 0) {
+        throw new Error(`${caller}(${table}): where.${col}.${op} bu filtre dilinde yok \u2014 ${REFUSED_OPS[op]}`);
+      }
+      if (!KNOWN_OPS.has(op)) {
+        throw new Error(`${caller}(${table}): where.${col} bilinmeyen operat\xF6r "${op}" (gt/gte/lt/lte/neq/in/contains/icontains/startsWith/endsWith/isNull)`);
+      }
+      if (v === void 0) {
+        throw new Error(`${caller}(${table}): where.${col}.${op} de\u011Feri undefined \u2014 kar\u015F\u0131la\u015Ft\u0131rman\u0131n sa\u011F taraf\u0131 NULL olur ve sonu\xE7 hi\xE7bir sat\u0131ra uymaz. Ko\u015Fulu kurmay\u0131n.`);
+      }
+    }
+  }
+}
+__name(assertUsableFilter, "assertUsableFilter");
+function assertUsableWriteValues(caller, table, cols, data) {
+  for (const c of cols) {
+    if (data[c] === void 0) {
+      throw new Error(`${caller}(${table}): "${c}" de\u011Feri undefined \u2014 bu bir yazma de\u011Feri de\u011Fil. Kolonu bo\u015Faltmak istiyorsan null yaz; kolonu de\u011Fi\u015Ftirmek istemiyorsan nesneye hi\xE7 koyma (bir eksik istek alan\u0131 sessizce NULL yaz\u0131yordu \u2014 FR-016).`);
+    }
+  }
+}
+__name(assertUsableWriteValues, "assertUsableWriteValues");
+
+// src/db/tx-plan.ts
+var TxRefError = class extends Error {
+  static {
+    __name(this, "TxRefError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "TxRefError";
+  }
+};
+var TxPlanError = class extends Error {
+  static {
+    __name(this, "TxPlanError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "TxPlanError";
+  }
+};
+var EXPR = /* @__PURE__ */ Symbol.for("palbase.tx.expr");
+var REF = /* @__PURE__ */ Symbol.for("palbase.tx.ref");
+var ROW = /* @__PURE__ */ Symbol.for("palbase.tx.row");
+var ROWS = /* @__PURE__ */ Symbol.for("palbase.tx.rows");
+var TRAPPED_PROPS = [
+  "then",
+  "valueOf",
+  "toString",
+  "toJSON",
+  Symbol.toPrimitive
+];
+function trap(prop, what, hint) {
+  const name = typeof prop === "symbol" ? prop.description ?? String(prop) : prop;
+  throw new TxRefError(`${what} was used as a value (via \`${name}\`). Nothing in a transaction callback has run yet, so there is no value to read. ${hint}`);
+}
+__name(trap, "trap");
+function now() {
+  return makeExpr({
+    fn: "now"
+  });
+}
+__name(now, "now");
+function increment(by) {
+  assertAmount(by, "increment");
+  return makeExpr({
+    fn: "inc",
+    by
+  });
+}
+__name(increment, "increment");
+var inc = increment;
+function decrement(by) {
+  assertAmount(by, "decrement");
+  return makeExpr({
+    fn: "dec",
+    by
+  });
+}
+__name(decrement, "decrement");
+var dec = decrement;
+function assertAmount(by, fn) {
+  if (typeof by === "string") {
+    if (!/^-?\d+(\.\d+)?$/.test(by)) {
+      throw new TxPlanError(`${fn}() ondal\u0131k bir say\u0131 metni bekliyor, "${by}" ald\u0131 \u2014 kabul edilen bi\xE7im: "12", "-12", "12.50"`);
+    }
+  } else if (typeof by !== "number" || !Number.isFinite(by)) {
+    throw new TxPlanError(`${fn}() needs a finite number, got ${String(by)}`);
+  }
+  const negative = typeof by === "string" ? by.trimStart().startsWith("-") : by < 0;
+  if (negative) {
+    const other = fn === "increment" ? "decrement" : "increment";
+    throw new TxPlanError(`${fn}() negatif miktar almaz ("${String(by)}"). Ters y\xF6n i\xE7in ${other}() kullan\u0131n \u2014 i\u015Faretin miktarda saklanmas\u0131, y\xF6n\xFC okuyan hi\xE7bir kod taraf\u0131ndan g\xF6r\xFClmezdi.`);
+  }
+}
+__name(assertAmount, "assertAmount");
+function columnExprOf(v) {
+  return exprOf(v);
+}
+__name(columnExprOf, "columnExprOf");
+function makeExpr(expr) {
+  return new Proxy({
+    [EXPR]: expr
+  }, {
+    get(target, prop) {
+      if (prop === EXPR) return target[EXPR];
+      if (TRAPPED_PROPS.includes(prop)) {
+        trap(prop, "A plan expression", "Write it into an operation instead.");
+      }
+      return void 0;
+    }
+  });
+}
+__name(makeExpr, "makeExpr");
+function makeRef(op, field) {
+  const target = {
+    [REF]: {
+      op,
+      field
+    }
+  };
+  return new Proxy(target, {
+    get(t, prop) {
+      if (prop === REF) return t[REF];
+      if (TRAPPED_PROPS.includes(prop)) {
+        trap(prop, `\`${field}\` of a row this transaction has not written yet`, "Pass it to another operation in the same plan, or return it from the callback and read it after `transaction()` resolves.");
+      }
+      return void 0;
+    }
+  });
+}
+__name(makeRef, "makeRef");
+function makeRowHandle(op) {
+  const target = {
+    [ROW]: op
+  };
+  return new Proxy(target, {
+    get(t, prop) {
+      if (prop === ROW) return t[ROW];
+      if (TRAPPED_PROPS.includes(prop)) {
+        trap(prop, "A row this transaction has not written yet", "Read one of its columns to reference it, or return the row from the callback and read it after `transaction()` resolves.");
+      }
+      if (typeof prop === "symbol") return void 0;
+      return makeRef(op, prop);
+    }
+  });
+}
+__name(makeRowHandle, "makeRowHandle");
+function refDescriptor(v) {
+  if (typeof v !== "object" || v === null) return null;
+  const d = v[REF];
+  return isRefDescriptor(d) ? d : null;
+}
+__name(refDescriptor, "refDescriptor");
+function isRefDescriptor(d) {
+  return typeof d === "object" && d !== null && typeof d.op === "number" && typeof d.field === "string";
+}
+__name(isRefDescriptor, "isRefDescriptor");
+function rowOpIndex(v) {
+  if (typeof v !== "object" || v === null) return null;
+  const op = v[ROW];
+  return typeof op === "number" ? op : null;
+}
+__name(rowOpIndex, "rowOpIndex");
+function exprOf(v) {
+  if (typeof v !== "object" || v === null) return null;
+  const e = v[EXPR];
+  return typeof e === "object" && e !== null ? e : null;
+}
+__name(exprOf, "exprOf");
+function isRowsHandle(v) {
+  return typeof v === "object" && v !== null && v[ROWS] !== void 0;
+}
+__name(isRowsHandle, "isRowsHandle");
+function encodeValue(value, column, allowColumnExpr) {
+  const ref = refDescriptor(value);
+  if (ref) return brandRef({
+    $ref: {
+      op: ref.op,
+      field: ref.field
+    }
+  }, "ref");
+  if (isNowExpr(value)) return {
+    $expr: {
+      fn: "now"
+    }
+  };
+  const expr = exprOf(value);
+  if (expr) {
+    if (expr.fn !== "now" && !allowColumnExpr) {
+      throw new TxPlanError(`\`${column}\`: ${expr.fn}() reads the column's current value, so it is only valid in updateWhere(where, set).`);
+    }
+    return {
+      $expr: expr
+    };
+  }
+  if (rowOpIndex(value) !== null) {
+    throw new TxPlanError(`\`${column}\`: a row handle is not a value. Read the column you meant (e.g. \`row.id\`).`);
+  }
+  if (isRowsHandle(value)) {
+    throw new TxPlanError(`\`${column}\`: an operation result is not a value. Declare an expectation first (\`.expectOne(err)\`) and read a column from the row.`);
+  }
+  assertNoNestedHandles(value, column);
+  return value;
+}
+__name(encodeValue, "encodeValue");
+function encodeFilterValue(value, column) {
+  const ref = refDescriptor(value);
+  if (ref) return brandRef({
+    $ref: {
+      op: ref.op,
+      field: ref.field
+    }
+  }, "ref");
+  const expr = exprOf(value);
+  if (expr) {
+    throw new TxPlanError(`\`${column}\`: ${expr.fn}() bir YAZMA ifadesi, kar\u015F\u0131la\u015Ft\u0131rma de\u011Fil \u2014 filtrede kullan\u0131lamaz. Kolonu bir de\u011Ferle ya da col() ile kar\u015F\u0131la\u015Ft\u0131r\u0131n.`);
+  }
+  if (rowOpIndex(value) !== null) {
+    throw new TxPlanError(`\`${column}\`: a row handle is not a value. Read the column you meant (e.g. \`row.id\`).`);
+  }
+  if (isRowsHandle(value)) {
+    throw new TxPlanError(`\`${column}\`: an operation result is not a value. Declare an expectation first (\`.expectOne(err)\`) and read a column from the row.`);
+  }
+  if (Array.isArray(value)) return value.map((v) => encodeFilterValue(v, column));
+  if (value !== null && typeof value === "object" && !(value instanceof Date) && !isColRef(value) && !isSqlFragment(value)) {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = encodeFilterValue(v, column);
+    }
+    return out;
+  }
+  return value;
+}
+__name(encodeFilterValue, "encodeFilterValue");
+function encodeFilterMap(map) {
+  const out = {};
+  for (const key of Object.keys(map).sort()) {
+    const value = map[key];
+    if (value === void 0) continue;
+    out[key] = encodeFilterValue(value, key);
+  }
+  return out;
+}
+__name(encodeFilterMap, "encodeFilterMap");
+function assertNoNestedHandles(value, column) {
+  if (typeof value !== "object" || value === null) return;
+  if (value instanceof Date) return;
+  if (refDescriptor(value) || exprOf(value) || rowOpIndex(value) !== null || isRowsHandle(value)) {
+    throw new TxPlanError(`\`${column}\`: a plan handle is nested inside a value. The server would store it as literal JSON, not resolve it. Put the reference directly in the column.`);
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) assertNoNestedHandles(item, column);
+    return;
+  }
+  for (const item of Object.values(value)) {
+    assertNoNestedHandles(item, column);
+  }
+}
+__name(assertNoNestedHandles, "assertNoNestedHandles");
+function encodeMap(map, allowColumnExpr) {
+  const out = {};
+  for (const key of Object.keys(map).sort()) {
+    const value = map[key];
+    if (value === void 0) continue;
+    out[key] = encodeValue(value, key, allowColumnExpr);
+  }
+  return out;
+}
+__name(encodeMap, "encodeMap");
+var SKIPPED_OP = -1;
+var TxRowsImpl = class TxRowsImpl2 {
+  static {
+    __name(this, "TxRowsImpl");
+  }
+  builder;
+  opIndex;
+  what;
+  // Present so `isRowsHandle` recognises the object; never read for its value.
+  [ROWS] = true;
+  guarded = false;
+  constructor(builder, opIndex, what) {
+    this.builder = builder;
+    this.opIndex = opIndex;
+    this.what = what;
+  }
+  // The type-level `await` guard made real: TS rejects `await rows` at compile
+  // time, and reaching this means someone called `.then(...)` by hand.
+  then() {
+    throw new TxRefError(`${this.what} cannot be awaited: a transaction callback builds a plan, it does not run statements. Remove the \`await\`.`);
+  }
+  expectOne(error) {
+    this.declareGuard("one", 1, error);
+    if (this.opIndex === SKIPPED_OP) throw error;
+    return makeRowHandle(this.opIndex);
+  }
+  expectNone(error) {
+    this.declareGuard("none", 0, error);
+  }
+  expectAtLeast(n, error) {
+    assertGuardCount(n, "expectAtLeast");
+    this.declareGuard("atLeast", n, error);
+    if (this.opIndex === SKIPPED_OP && n > 0) throw error;
+  }
+  expectAtMost(n, error) {
+    assertGuardCount(n, "expectAtMost");
+    this.declareGuard("atMost", n, error);
+  }
+  declareGuard(kind, n, error) {
+    if (!(error instanceof Error)) {
+      throw new TxPlanError(`${this.what}: an expectation needs the Error to throw when it does not hold (e.g. \`.expect\u2026(new Conflict("already accepted"))\`).`);
+    }
+    if (this.guarded) {
+      throw new TxPlanError(`${this.what} already has an expectation. One operation carries one expectation; declare the second one on its own operation.`);
+    }
+    this.guarded = true;
+    if (this.opIndex === SKIPPED_OP) return;
+    this.builder.attachGuard(this.opIndex, kind, n, error);
+  }
+};
+function assertGuardCount(n, fn) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new TxPlanError(`${fn}(n) needs a non-negative integer, got ${String(n)}`);
+  }
+}
+__name(assertGuardCount, "assertGuardCount");
+var MAX_OPS = 1e3;
+var MAX_ROWS = 5e3;
+var TxPlanBuilder = class {
+  static {
+    __name(this, "TxPlanBuilder");
+  }
+  ops = [];
+  /** Errors handed to expectations, indexed by the `slot` the server echoes. */
+  slots = [];
+  /** The table surface handed to the callback. Untyped here; the public
+  * `transaction()` signatures put the schema types on top. */
+  table(name) {
+    return {
+      insert: /* @__PURE__ */ __name((values) => {
+        const encoded = encodeMap(values, false);
+        if (Object.keys(encoded).length === 0) {
+          throw new TxPlanError(`${name}.insert() needs at least one column`);
+        }
+        return this.push({
+          op: "insert",
+          table: name,
+          values: encoded
+        }, `${name}.insert()`);
+      }, "insert"),
+      put: /* @__PURE__ */ __name((values, options) => {
+        const encoded = encodeMap(values, false);
+        if (Object.keys(encoded).length === 0) {
+          throw new TxPlanError(`${name}.put() needs at least one column`);
+        }
+        if (options.onConflict.length === 0) {
+          throw new TxPlanError(`${name}.put() needs at least one onConflict column`);
+        }
+        return this.push({
+          op: "upsert",
+          table: name,
+          values: encoded,
+          onConflict: options.onConflict
+        }, `${name}.upsert()`);
+      }, "put"),
+      insertMany: /* @__PURE__ */ __name((rows, opts) => {
+        if (rows.length === 0) {
+          return new TxRowsImpl(this, SKIPPED_OP, `${name}.insertMany()`);
+        }
+        if (rows.length > MAX_ROWS) {
+          throw new TxPlanError(`${name}.insertMany() has ${rows.length} rows; the limit is ${MAX_ROWS}. Split the write across requests.`);
+        }
+        const encoded = rows.map((row) => encodeMap(row, false));
+        assertUniformRows(encoded, name);
+        if (opts !== void 0 && opts.onConflict.length === 0) {
+          throw new TxPlanError(`${name}.insertMany() was given a conflict action with no onConflict columns. Postgres matches a collision on columns, so name them.`);
+        }
+        return this.push({
+          op: "insertMany",
+          table: name,
+          rows: encoded,
+          // Omitted entirely when no options were given, so the op a plain
+          // insertMany produces is byte-identical to the one it produced
+          // before this option existed.
+          ...opts !== void 0 ? {
+            onConflict: opts.onConflict,
+            action: opts.action ?? "ignore"
+          } : {}
+        }, `${name}.insertMany()`);
+      }, "insertMany"),
+      updateWhere: /* @__PURE__ */ __name((where, set) => {
+        const encodedWhere = encodeFilterMap(where);
+        const encodedSet = encodeMap(set, true);
+        if (Object.keys(encodedWhere).length === 0) {
+          throw new TxPlanError(`${name}.updateWhere() needs a filter. An update with no filter rewrites the whole table.`);
+        }
+        if (Object.keys(encodedSet).length === 0) {
+          throw new TxPlanError(`${name}.updateWhere() needs at least one column to set`);
+        }
+        return this.push({
+          op: "update",
+          table: name,
+          set: encodedSet,
+          where: encodedWhere
+        }, `${name}.updateWhere()`);
+      }, "updateWhere"),
+      deleteWhere: /* @__PURE__ */ __name((where) => {
+        const encodedWhere = encodeFilterMap(where);
+        if (Object.keys(encodedWhere).length === 0) {
+          throw new TxPlanError(`${name}.deleteWhere() needs a filter. A delete with no filter empties the table.`);
+        }
+        return this.push({
+          op: "delete",
+          table: name,
+          where: encodedWhere
+        }, `${name}.deleteWhere()`);
+      }, "deleteWhere"),
+      select: /* @__PURE__ */ __name((where, options) => {
+        const op = {
+          op: "select",
+          table: name
+        };
+        const encodedWhere = encodeFilterMap(where ?? {});
+        if (Object.keys(encodedWhere).length > 0) op.where = encodedWhere;
+        if (options?.limit !== void 0) {
+          if (!Number.isInteger(options.limit) || options.limit < 0) {
+            throw new TxPlanError(`${name}.select(): limit needs a non-negative integer, got ${String(options.limit)}`);
+          }
+          op.limit = options.limit;
+        }
+        if (options?.lock !== void 0) op.lock = options.lock;
+        return this.push(op, `${name}.select()`);
+      }, "select")
+    };
+  }
+  push(op, what) {
+    if (this.ops.length >= MAX_OPS) {
+      throw new TxPlanError(`this transaction has ${MAX_OPS} operations, which is the limit. Use insertMany() for bulk writes, or split the work across requests.`);
+    }
+    const index = this.ops.length;
+    this.ops.push(op);
+    return new TxRowsImpl(this, index, what);
+  }
+  /** Attach an expectation to an op and record its error in the slot table. */
+  attachGuard(opIndex, kind, n, error) {
+    const op = this.ops[opIndex];
+    if (!op) throw new TxPlanError(`internal: expectation on unknown operation ${opIndex}`);
+    const slot = this.slots.length;
+    this.slots.push(error);
+    op.guard = {
+      kind,
+      n,
+      slot
+    };
+  }
+  /** The serialisable plan. Empty when the callback described no writes. */
+  body() {
+    return {
+      ops: this.ops
+    };
+  }
+  /** The error the server's `slot` selects, or `null` when it names one this
+  * plan never declared (a server/client disagreement, not a tenant error). */
+  errorForSlot(slot) {
+    return this.slots[slot] ?? null;
+  }
+};
+function assertUniformRows(rows, table) {
+  const first = rows[0];
+  if (!first) return;
+  const want = Object.keys(first);
+  const wantKey = want.join(",");
+  for (let i = 1; i < rows.length; i++) {
+    const got = Object.keys(rows[i]);
+    if (got.join(",") !== wantKey) {
+      throw new TxPlanError(`${table}.insertMany(): every row must set the same columns. Row 0 sets [${want.join(", ")}] but row ${i} sets [${got.join(", ")}]. (A property set to \`undefined\` counts as absent \u2014 use \`null\`.)`);
+    }
+  }
+}
+__name(assertUniformRows, "assertUniformRows");
+function materializeResult(value, results) {
+  const ref = refDescriptor(value);
+  if (ref) {
+    const row = rowOf(results, ref.op, `\`${ref.field}\``);
+    if (!(ref.field in row)) {
+      throw new TxPlanError(`the transaction's operation ${ref.op} returned no column \`${ref.field}\`.`);
+    }
+    return row[ref.field];
+  }
+  const rowOp = rowOpIndex(value);
+  if (rowOp !== null) return rowOf(results, rowOp, "a row");
+  if (isRowsHandle(value)) {
+    throw new TxPlanError("an operation result cannot be returned from a transaction callback: its row count is not known until the plan runs. Declare an expectation (`.expectOne(err)`) and return the row, or a column of it.");
+  }
+  if (Array.isArray(value)) return value.map((item) => materializeResult(item, results));
+  if (isPlainObject(value)) {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) out[key] = materializeResult(item, results);
+    return out;
+  }
+  return value;
+}
+__name(materializeResult, "materializeResult");
+function rowOf(results, opIndex, what) {
+  const result = results[opIndex];
+  if (!result) {
+    throw new TxPlanError(`the transaction returned no result for operation ${opIndex}, so ${what} cannot be read.`);
+  }
+  const row = result.rows[0];
+  if (!row) {
+    throw new TxPlanError(`the transaction's operation ${opIndex} returned no row, so ${what} cannot be read.`);
+  }
+  return row;
+}
+__name(rowOf, "rowOf");
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+__name(isPlainObject, "isPlainObject");
+async function runTxPlan(transport, handle, builder, fn) {
+  const returned = fn(handle);
+  const body = builder.body();
+  if (body.ops.length === 0) {
+    return materializeResult(returned, []);
+  }
+  let response;
+  try {
+    response = await transport.txPlan(body);
+  } catch (err) {
+    throw translateRejection(err, builder);
+  }
+  return materializeResult(returned, response.results);
+}
+__name(runTxPlan, "runTxPlan");
+function translateRejection(err, builder) {
+  if (typeof err !== "object" || err === null) return err;
+  const rejection = err;
+  if (rejection.error_code !== "tx_guard_failed" || typeof rejection.slot !== "number") {
+    return err;
+  }
+  return builder.errorForSlot(rejection.slot) ?? err;
+}
+__name(translateRejection, "translateRejection");
+
+export {
+  brandRef,
+  looksLikeUnbrandedRef,
+  isColRef,
+  isPlanRef,
+  looksLikeUnbrandedPlanRef,
+  isSqlFragment,
+  isNowExpr,
+  isColumnExpr,
+  assertNoExpressionHandles,
+  assertUsableFilter,
+  assertUsableWriteValues,
+  TxRefError,
+  TxPlanError,
+  now,
+  increment,
+  inc,
+  decrement,
+  dec,
+  columnExprOf,
+  TxPlanBuilder,
+  runTxPlan
+};
+//# sourceMappingURL=chunk-JVZQCC77.js.map