@palbase/backend 25.0.4 → 27.0.0

package/dist/chunk-CJSKYY76.js

@@ -1,627 +0,0 @@
-// src/db/tx-plan.ts
-var TxRefError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "TxRefError";
-  }
-};
-var TxPlanError = class extends Error {
-  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}`
-  );
-}
-function now() {
-  return makeExpr({ fn: "now" });
-}
-function inc(by) {
-  assertFiniteNumber(by, "inc");
-  return makeExpr({ fn: "inc", by });
-}
-function dec(by) {
-  assertFiniteNumber(by, "dec");
-  return makeExpr({ fn: "dec", by });
-}
-function assertFiniteNumber(by, fn) {
-  if (typeof by !== "number" || !Number.isFinite(by)) {
-    throw new TxPlanError(`${fn}() needs a finite number, got ${String(by)}`);
-  }
-}
-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;
-      }
-    }
-  );
-}
-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;
-    }
-  });
-}
-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);
-    }
-  });
-}
-function refDescriptor(v) {
-  if (typeof v !== "object" || v === null) return null;
-  const d = v[REF];
-  return isRefDescriptor(d) ? d : null;
-}
-function isRefDescriptor(d) {
-  return typeof d === "object" && d !== null && typeof d.op === "number" && typeof d.field === "string";
-}
-function rowOpIndex(v) {
-  if (typeof v !== "object" || v === null) return null;
-  const op = v[ROW];
-  return typeof op === "number" ? op : null;
-}
-function exprOf(v) {
-  if (typeof v !== "object" || v === null) return null;
-  const e = v[EXPR];
-  return typeof e === "object" && e !== null ? e : null;
-}
-function isRowsHandle(v) {
-  return typeof v === "object" && v !== null && v[ROWS] !== void 0;
-}
-function encodeValue(value, column, allowColumnExpr) {
-  const ref = refDescriptor(value);
-  if (ref) return { $ref: { op: ref.op, field: ref.field } };
-  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;
-}
-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);
-  }
-}
-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;
-}
-var SKIPPED_OP = -1;
-var TxRowsImpl = class {
-  constructor(builder, opIndex, what) {
-    this.builder = builder;
-    this.opIndex = opIndex;
-    this.what = what;
-  }
-  builder;
-  opIndex;
-  what;
-  // Present so `isRowsHandle` recognises the object; never read for its value.
-  [ROWS] = true;
-  guarded = false;
-  // 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)}`);
-  }
-}
-var MAX_OPS = 1e3;
-var MAX_ROWS = 5e3;
-var TxPlanBuilder = class {
-  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: (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()`);
-      },
-      upsert: (values, options) => {
-        const encoded = encodeMap(values, false);
-        if (Object.keys(encoded).length === 0) {
-          throw new TxPlanError(`${name}.upsert() needs at least one column`);
-        }
-        if (options.onConflict.length === 0) {
-          throw new TxPlanError(`${name}.upsert() needs at least one onConflict column`);
-        }
-        return this.push(
-          { op: "upsert", table: name, values: encoded, onConflict: options.onConflict },
-          `${name}.upsert()`
-        );
-      },
-      insertMany: (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()`
-        );
-      },
-      updateWhere: (where, set) => {
-        const encodedWhere = encodeMap(where, false);
-        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()`
-        );
-      },
-      deleteWhere: (where) => {
-        const encodedWhere = encodeMap(where, false);
-        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()`
-        );
-      },
-      select: (where, options) => {
-        const op = { op: "select", table: name };
-        const encodedWhere = encodeMap(where ?? {}, false);
-        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()`);
-      }
-    };
-  }
-  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\`.)`
-      );
-    }
-  }
-}
-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;
-}
-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;
-}
-function isPlainObject(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-async function runTxPlan(transport, tables, builder, fn) {
-  const returned = fn({ tables });
-  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);
-}
-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;
-}
-
-// src/db/schema-json.ts
-function defOf(column) {
-  return "_def" in column ? column._def : column;
-}
-function columnToJSON(column) {
-  const def = defOf(column);
-  const out = {
-    type: def.type,
-    nullable: def.nullable,
-    primaryKey: def.primaryKey
-  };
-  if (def.defaultValue !== void 0) out.defaultValue = def.defaultValue;
-  if (def.defaultRandom === true) out.defaultRandom = true;
-  if (def.defaultNow === true) out.defaultNow = true;
-  if (def.renamedFrom !== void 0) out.renamedFrom = def.renamedFrom;
-  if (def.ignored === true) out.ignored = true;
-  if (def.owns === true) out.owns = true;
-  if (def.references !== void 0) {
-    out.references = { table: def.references.table, column: def.references.column };
-  }
-  if (def.onDeleteAction !== void 0) out.onDeleteAction = def.onDeleteAction;
-  if (def.enumName !== void 0) out.enumName = def.enumName;
-  if (def.enumValues !== void 0) out.enumValues = [...def.enumValues];
-  if (def.unique === true) out.unique = true;
-  if (def.dimensions !== void 0) out.dimensions = def.dimensions;
-  return out;
-}
-function policyToJSON(policy) {
-  return {
-    name: policy.name,
-    command: policy.command ?? "all",
-    roles: policy.roles ? [...policy.roles] : [],
-    // null rather than omitted: a policy with no USING clause is a different
-    // thing from one whose clause the emitter forgot, and Go reads the
-    // difference.
-    using: policy.using ?? null,
-    withCheck: policy.withCheck ?? null,
-    permissive: policy.permissive !== false
-  };
-}
-function commonSearchFields(search, out) {
-  if (search.synonyms !== void 0 && Object.keys(search.synonyms).length > 0) {
-    out.synonyms = Object.fromEntries(
-      Object.entries(search.synonyms).map(([word, alts]) => [word, [...alts]])
-    );
-  }
-  if (search.validity === true) out.validity = true;
-}
-function searchToJSON(search, vectorColumn) {
-  if (search.from !== void 0 && search.model !== void 0) {
-    const out2 = {};
-    const textCols = search.text === false ? void 0 : Array.isArray(search.text) && search.text.length > 0 ? search.text : search.from;
-    if (textCols !== void 0) out2.text = { columns: [...textCols] };
-    const v = { metric: search.metric ?? "cosine" };
-    if (vectorColumn !== void 0) v.column = vectorColumn;
-    v.embed = {
-      provider: search.model.provider,
-      model: search.model.model,
-      from: [...search.from],
-      ...search.model.apiKeyName !== void 0 ? { apiKeyName: search.model.apiKeyName } : {},
-      ...search.model.dimensions !== void 0 ? { dimensions: search.model.dimensions } : {},
-      ...search.model.baseURL !== void 0 ? { baseURL: search.model.baseURL } : {}
-    };
-    if (search.staleness !== void 0) v.staleness = search.staleness;
-    if (vectorColumn === void 0) {
-      v.mode = "chunks";
-      if (search.chunks !== void 0) {
-        const c = {};
-        if (search.chunks.size !== void 0 && search.chunks.size > 0) c.sizeChars = search.chunks.size;
-        if (search.chunks.overlap !== void 0 && search.chunks.overlap > 0) c.overlapChars = search.chunks.overlap;
-        if (Object.keys(c).length > 0) v.chunks = c;
-      }
-    }
-    out2.vector = [v];
-    commonSearchFields(search, out2);
-    return out2;
-  }
-  const out = {};
-  if (Array.isArray(search.text) && search.text.length > 0) out.text = { columns: [...search.text] };
-  const legs = search.vector === void 0 ? [] : Array.isArray(search.vector) ? search.vector : [search.vector];
-  if (legs.length > 0) {
-    out.vector = legs.map((leg) => {
-      const v = { metric: leg.metric ?? "cosine" };
-      if (leg.column !== void 0) v.column = leg.column;
-      if (leg.staleness !== void 0) v.staleness = leg.staleness;
-      if (leg.model !== void 0) {
-        v.embed = {
-          provider: leg.model.provider,
-          model: leg.model.model,
-          from: [...leg.from ?? []],
-          ...leg.model.apiKeyName !== void 0 ? { apiKeyName: leg.model.apiKeyName } : {},
-          ...leg.model.dimensions !== void 0 ? { dimensions: leg.model.dimensions } : {},
-          ...leg.model.baseURL !== void 0 ? { baseURL: leg.model.baseURL } : {}
-        };
-      }
-      return v;
-    });
-  }
-  commonSearchFields(search, out);
-  return out;
-}
-function memoryToJSON(m) {
-  return {
-    from: [...m.from],
-    into: m.into,
-    ...m.subject !== void 0 ? { subject: m.subject } : {},
-    extract: { provider: m.extract.provider, model: m.extract.model }
-  };
-}
-function tableToJSON(table, schemaName) {
-  const columns = {};
-  for (const [name, column] of Object.entries(table.columns)) {
-    columns[name] = columnToJSON(column);
-  }
-  const out = {
-    name: table.name,
-    schema: schemaName,
-    columns,
-    // Read, not re-derived. `defineSchema` already resolves the fail-closed
-    // default (RLS on unless the author wrote `rls: false`, and forced on by any
-    // policy), and a second copy of a SECURITY default is exactly the thing that
-    // drifts — the direction it drifted last time was "expose everything", and
-    // the live proof was one user reading another's rows.
-    rls: table.rls,
-    policies: (table.policies ?? []).map(policyToJSON)
-  };
-  if (table.primaryKey !== void 0 && table.primaryKey.length > 0) {
-    out.primaryKey = [...table.primaryKey];
-  }
-  if (table.unique !== void 0 && table.unique.length > 0) {
-    out.uniqueConstraints = table.unique.map((u) => ({ name: u.name, columns: [...u.columns] }));
-  }
-  if (table.raw !== void 0 && table.raw.length > 0) {
-    out.rawConstraints = table.raw.map((r) => ({
-      name: r.name,
-      up: r.up,
-      down: r.down ?? null
-    }));
-  }
-  if (table.checks !== void 0 && table.checks.length > 0) {
-    out.checks = table.checks.map((c) => ({ name: c.name, expr: c.expr }));
-  }
-  if (table.indexes !== void 0 && table.indexes.length > 0) {
-    out.indexes = table.indexes.map((i) => ({ name: i.name, columns: [...i.columns] }));
-  }
-  if (table.search !== void 0) {
-    const vectorColumn = Object.entries(columns).find(([, c]) => c.dimensions !== void 0)?.[0];
-    const sj = searchToJSON(table.search, vectorColumn);
-    if (sj.text !== void 0 || sj.vector !== void 0) out.search = sj;
-  }
-  if (table.memory !== void 0) {
-    out.memory = memoryToJSON(table.memory);
-  }
-  return out;
-}
-function qualifiedTableKey(schemaName, tableName) {
-  return schemaName === "" || schemaName === "public" ? tableName : `${schemaName}.${tableName}`;
-}
-function toSchemaJSON(schemas) {
-  const tables = {};
-  const extensions = [];
-  const meta = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const schema of schemas) {
-    if (seen.has(schema.name)) {
-      throw new Error(`two schemas declare the name "${schema.name}" \u2014 schema names must be unique`);
-    }
-    seen.add(schema.name);
-    for (const table of Object.values(schema.tables)) {
-      const json = tableToJSON(table, schema.name);
-      tables[qualifiedTableKey(schema.name, json.name)] = json;
-    }
-    extensions.push(...schema.extensions ?? []);
-    meta.push({ name: schema.name, exposed: schema.exposed });
-  }
-  return { tables, extensions: [...new Set(extensions)], schemas: meta };
-}
-
-export {
-  TxRefError,
-  TxPlanError,
-  now,
-  inc,
-  dec,
-  TxPlanBuilder,
-  runTxPlan,
-  qualifiedTableKey,
-  toSchemaJSON
-};
-//# sourceMappingURL=chunk-CJSKYY76.js.map