@palbase/backend 16.0.0 → 17.0.0

package/dist/test/index.cjs

@@ -20,989 +20,111 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/test/index.ts
 var test_exports = {};
 __export(test_exports, {
-  createMockDB: () => createMockDB,
-  createTestContext: () => createTestContext
+  TestApiError: () => TestApiError,
+  api: () => api,
+  createTestApi: () => createTestApi
 });
 module.exports = __toCommonJS(test_exports);
 
-// src/runtime.ts
-var import_node_async_hooks = require("async_hooks");
-
-// 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";
+// src/test/api.ts
+var TestApiError = class extends Error {
+  status;
+  error;
+  data;
+  constructor(method, path, status, body) {
+    const envelope = body ?? {};
+    const code = envelope.error ?? String(status);
+    super(`${method} ${path} \u2192 ${status} ${code}${envelope.error_description ? `: ${envelope.error_description}` : ""}`);
+    this.name = "TestApiError";
+    this.status = status;
+    this.error = code;
+    this.data = envelope.data;
   }
 };
-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 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.`
+function required(value, envName) {
+  if (!value) {
+    throw new Error(
+      `${envName} is not set \u2014 the test client has nowhere to send requests. This is set by the deploy that runs your tests; if you are running them by hand, set it yourself.`
     );
   }
-  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()`);
-      },
-      insertMany: (rows) => {
-        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);
-        return this.push({ op: "insertMany", table: name, rows: encoded }, `${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()`);
-      }
+function createTestApi(config) {
+  const baseUrl = required(config.baseUrl, "PALBASE_TEST_BASE_URL").replace(/\/$/, "");
+  const apiKey = required(config.apiKey, "PALBASE_TEST_API_KEY");
+  const candidateToken = required(config.candidateToken, "PALBASE_TEST_CANDIDATE");
+  const requests = [];
+  let bearer = null;
+  async function call(method, path, body, opts = {}) {
+    const headers = {
+      apikey: apiKey,
+      // Selects the release under test. Omit it and the gateway serves the LIVE
+      // one, which would make the whole suite grade the wrong code.
+      "x-palbase-candidate": candidateToken,
+      ...opts.headers
     };
+    if (bearer) headers.authorization = `Bearer ${bearer}`;
+    if (body !== void 0) headers["content-type"] = "application/json";
+    const startedAt = Date.now();
+    const res = await fetch(`${baseUrl}${path}`, {
+      method,
+      headers,
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    const text = await res.text();
+    const parsed = text ? safeParse(text) : void 0;
+    requests.push({ method, path, status: res.status, ms: Date.now() - startedAt });
+    if (!res.ok) throw new TestApiError(method, path, res.status, parsed);
+    return parsed;
   }
-  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/runtime.ts
-var __requestALS = new import_node_async_hooks.AsyncLocalStorage();
-var runtime = null;
-function __setRuntime(services) {
-  runtime = services;
-}
-function __getRuntime() {
-  const scoped = __requestALS.getStore();
-  if (scoped) return scoped.runtime;
-  if (runtime === null) {
-    throw new Error(
-      "Palbase services accessed outside a request scope. The Database/Documents/\u2026 singletons are only available inside an endpoint handler (or after the runtime has called __runWithRuntime / __setRuntime)."
-    );
-  }
-  return runtime;
-}
-function makeServiceProxy(key) {
-  const handler = {
-    get(_target, prop, receiver) {
-      const client = __getRuntime()[key];
-      const value = Reflect.get(client, prop, receiver);
-      return typeof value === "function" ? value.bind(client) : value;
-    }
-  };
-  return new Proxy({}, handler);
-}
-function makeTablesAccessor(ops) {
-  const tablesProxy = new Proxy(
-    {},
-    {
-      get(_t, prop) {
-        if (typeof prop !== "string") return void 0;
-        const name = prop;
-        return {
-          insert: (data) => ops().insert(name, data),
-          update: (id, data) => ops().update(name, id, data),
-          delete: (id) => ops().delete(name, id),
-          findById: (id) => ops().findById(name, id),
-          findMany: (query) => ops().findMany(name, query)
-        };
-      }
-    }
-  );
-  return tablesProxy;
-}
-var rawDatabase = makeServiceProxy("Database");
-function makeTypedSurface(raw) {
-  const ops = {
-    query: (sql, params) => raw.query(sql, params),
-    insert: (table, data) => raw.insert(table, data),
-    update: (table, id, data) => raw.update(table, id, data),
-    delete: (table, id) => raw.delete(table, id),
-    findById: (table, id) => raw.findById(table, id),
-    findMany: (table, query) => raw.findMany(table, query)
-  };
-  return Object.assign(ops, {
-    tables: makeTablesAccessor(() => raw),
-    transaction(fn) {
-      const builder = new TxPlanBuilder();
-      return runTxPlan(raw, makeTxTablesAccessor(builder), builder, fn);
-    }
-  });
-}
-function makeTxTablesAccessor(builder) {
-  const tablesProxy = new Proxy(
-    {},
-    {
-      get(_t, prop) {
-        if (typeof prop !== "string") return void 0;
-        return builder.table(prop);
-      }
-    }
-  );
-  return tablesProxy;
-}
-var Database = Object.assign(makeTypedSurface(rawDatabase), {
-  /**
-   * Lazily resolve the runtime's service-role sibling on each call. We do NOT
-   * cache it: `rawDatabase.asService()` reads the CURRENT request scope through
-   * the runtime proxy, and the per-request runtime injects a service client
-   * bound to that request's identity headers — caching would leak one request's
-   * sibling into another concurrent request.
-   */
-  asService() {
-    return makeTypedSurface(rawDatabase.asService());
-  }
-});
-var Documents = makeServiceProxy("Documents");
-var Storage = makeServiceProxy("Storage");
-var Cache = makeServiceProxy("Cache");
-var Log = makeServiceProxy("Log");
-var Notifications = makeServiceProxy("Notifications");
-var Purchases = makeServiceProxy("Purchases");
-var rawFlags = makeServiceProxy("Flags");
-var Flags = Object.assign(
-  {
-    isEnabled(flagName, context) {
-      return rawFlags.isEnabled(flagName, context);
-    },
-    getVariant(flagName, context) {
-      return rawFlags.getVariant(flagName, context);
-    },
-    getAll(context) {
-      return rawFlags.getAll(context);
-    },
-    setOverride(key, value) {
-      return rawFlags.setOverride(key, value);
-    }
-  },
-  {
-    /**
-     * Lazily resolve the runtime's cross-user sibling on each call. We do NOT
-     * cache it: `rawFlags.asService()` reads the CURRENT request scope through
-     * the runtime proxy, so caching would leak one request's sibling into
-     * another concurrent request. Mirrors `Database.asService()`.
-     */
-    asService() {
-      return rawFlags.asService();
-    }
-  }
-);
-var Realtime = makeServiceProxy("Realtime");
-
-// src/test/mock-db.ts
-function createMockDB() {
-  const store = /* @__PURE__ */ new Map();
-  const tracked = {
-    inserted: /* @__PURE__ */ new Map(),
-    updated: /* @__PURE__ */ new Map(),
-    deleted: /* @__PURE__ */ new Map()
-  };
-  function rowsOf(table) {
-    let rows = store.get(table);
-    if (!rows) {
-      rows = [];
-      store.set(table, rows);
-    }
-    return rows;
-  }
-  function track(map, table, row) {
-    const list = map.get(table);
-    if (list) list.push(row);
-    else map.set(table, [row]);
-  }
-  const ops = {
-    async query(_sql, _params) {
-      return [];
-    },
-    async insert(table, data) {
-      const record = { id: crypto.randomUUID(), ...data };
-      rowsOf(table).push(record);
-      track(tracked.inserted, table, record);
-      return record;
-    },
-    async update(table, id, data) {
-      const rows = store.get(table) ?? [];
-      const idx = rows.findIndex((r) => r["id"] === id);
-      const updated = idx >= 0 ? { ...rows[idx], ...data } : { id, ...data };
-      if (idx >= 0) {
-        rows[idx] = updated;
-      }
-      track(tracked.updated, table, updated);
-      return updated;
-    },
-    async delete(table, id) {
-      const rows = store.get(table) ?? [];
-      const idx = rows.findIndex((r) => r["id"] === id);
-      if (idx >= 0) rows.splice(idx, 1);
-      const list = tracked.deleted.get(table);
-      if (list) list.push(id);
-      else tracked.deleted.set(table, [id]);
-    },
-    async findById(table, id) {
-      const rows = store.get(table) ?? [];
-      return rows.find((r) => r["id"] === id) ?? null;
-    },
-    async findMany(table, query) {
-      const rows = store.get(table) ?? [];
-      if (!query) return rows;
-      return rows.filter(
-        (row) => Object.entries(query).every(([key, val]) => row[key] === val)
+  return {
+    requests,
+    get: (path, opts) => call("GET", path, void 0, opts),
+    post: (path, body, opts) => call("POST", path, body, opts),
+    patch: (path, body, opts) => call("PATCH", path, body, opts),
+    put: (path, body, opts) => call("PUT", path, body, opts),
+    delete: (path, opts) => call("DELETE", path, void 0, opts),
+    query: (path, body, opts) => call("QUERY", path, body, opts),
+    async signIn(credentials) {
+      const result = await call(
+        "POST",
+        "/auth/login",
+        credentials
       );
-    }
-  };
-  async function txPlan(plan) {
-    const snapshot = /* @__PURE__ */ new Map();
-    for (const [table, rows] of store) snapshot.set(table, [...rows]);
-    const trackedSnapshot = {
-      inserted: cloneTracked(tracked.inserted),
-      updated: cloneTracked(tracked.updated),
-      deleted: new Map([...tracked.deleted].map(([k, v]) => [k, [...v]]))
-    };
-    const results = [];
-    try {
-      for (const op of plan.ops) {
-        const result = applyOp(op, results);
-        results.push(result);
-        const failure = guardFailure(op.guard, result.rows.length);
-        if (failure) throw failure;
-      }
-    } catch (err) {
-      store.clear();
-      for (const [table, rows] of snapshot) store.set(table, rows);
-      tracked.inserted = trackedSnapshot.inserted;
-      tracked.updated = trackedSnapshot.updated;
-      tracked.deleted = trackedSnapshot.deleted;
-      throw err;
-    }
-    return { results };
-  }
-  function applyOp(op, results) {
-    switch (op.op) {
-      case "insert": {
-        const record = { id: crypto.randomUUID(), ...resolveMap(op.values ?? {}, results, null) };
-        rowsOf(op.table).push(record);
-        track(tracked.inserted, op.table, record);
-        return { rows: [record], rows_affected: 1 };
-      }
-      case "insertMany": {
-        const written = (op.rows ?? []).map((row) => {
-          const record = { id: crypto.randomUUID(), ...resolveMap(row, results, null) };
-          rowsOf(op.table).push(record);
-          track(tracked.inserted, op.table, record);
-          return record;
-        });
-        return { rows: written, rows_affected: written.length };
-      }
-      case "update": {
-        const rows = rowsOf(op.table);
-        const where = resolveMap(op.where ?? {}, results, null);
-        const written = [];
-        for (let i = 0; i < rows.length; i++) {
-          const row = rows[i];
-          if (!row || !matches(row, where)) continue;
-          const next = { ...row, ...resolveMap(op.set ?? {}, results, row) };
-          rows[i] = next;
-          track(tracked.updated, op.table, next);
-          written.push(next);
-        }
-        return { rows: written, rows_affected: written.length };
-      }
-      case "delete": {
-        const rows = rowsOf(op.table);
-        const where = resolveMap(op.where ?? {}, results, null);
-        const removed = rows.filter((row) => matches(row, where));
-        for (const row of removed) {
-          rows.splice(rows.indexOf(row), 1);
-          const id = row["id"];
-          const list = tracked.deleted.get(op.table);
-          const key = typeof id === "string" ? id : String(id);
-          if (list) list.push(key);
-          else tracked.deleted.set(op.table, [key]);
-        }
-        return { rows: removed, rows_affected: removed.length };
-      }
-      case "select": {
-        const where = resolveMap(op.where ?? {}, results, null);
-        let found = rowsOf(op.table).filter((row) => matches(row, where));
-        if (op.limit !== void 0) found = found.slice(0, op.limit);
-        return { rows: found, rows_affected: found.length };
-      }
-    }
-  }
-  const client = {
-    ...ops,
-    txPlan,
-    // In tests there is no real DB role; `asService()` returns the same
-    // in-memory client so RLS-bypass code paths still hit the same store and
-    // tracking maps. The omitted `asService` matches the contract (no
-    // double-bypass), so callers can't recurse.
-    asService() {
-      return client;
-    },
-    inserted(table) {
-      return tracked.inserted.get(table) ?? [];
+      bearer = result.access_token;
+      return result.user ?? { id: "" };
     },
-    updated(table) {
-      return tracked.updated.get(table) ?? [];
+    async signOut() {
+      await call("POST", "/auth/logout", void 0);
+      bearer = null;
     },
-    deleted(table) {
-      return tracked.deleted.get(table) ?? [];
-    },
-    seed(table, data) {
-      store.set(table, [...data]);
+    asAnonymous() {
+      bearer = null;
     }
   };
-  return client;
-}
-function cloneTracked(map) {
-  return new Map([...map].map(([k, v]) => [k, [...v]]));
 }
-function resolveValue(value, results, current, column) {
-  if (typeof value !== "object" || value === null) return value;
-  const tagged = value;
-  if (tagged.$ref) {
-    const row = results[tagged.$ref.op]?.rows[0];
-    if (!row) {
-      throw txRejection(409, "tx_ref_unresolved", {
-        message: `operation ${tagged.$ref.op} produced no row to reference`
-      });
-    }
-    return row[tagged.$ref.field];
-  }
-  if (tagged.$expr) {
-    const fn = tagged.$expr["fn"];
-    if (fn === "now") return (/* @__PURE__ */ new Date()).toISOString();
-    const by = Number(tagged.$expr["by"]);
-    const base = Number(current?.[column] ?? 0);
-    return fn === "dec" ? base - by : base + by;
-  }
-  return value;
-}
-function resolveMap(map, results, current) {
-  const out = {};
-  for (const [key, value] of Object.entries(map)) {
-    out[key] = resolveValue(value, results, current, key);
+function safeParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
   }
-  return out;
-}
-function matches(row, where) {
-  return Object.entries(where).every(
-    ([key, value]) => value === null ? row[key] === null || row[key] === void 0 : row[key] === value
-  );
-}
-function guardFailure(guard, count) {
-  if (!guard) return null;
-  const ok = guard.kind === "one" ? count === 1 : guard.kind === "none" ? count === 0 : guard.kind === "atLeast" ? count >= guard.n : count <= guard.n;
-  if (ok) return null;
-  return txRejection(409, "tx_guard_failed", {
-    slot: guard.slot,
-    message: `expected ${guard.kind} ${guard.n} row(s), got ${count}`
-  });
-}
-function txRejection(status, code, extra) {
-  const err = new Error(extra.message);
-  err.status = status;
-  err.error_code = code;
-  if (extra.slot !== void 0) err.slot = extra.slot;
-  return err;
-}
-
-// src/test/context.ts
-function createMockLogger(logs) {
-  return {
-    info(message, ...args) {
-      logs.push({ level: "info", message, args });
-    },
-    warn(message, ...args) {
-      logs.push({ level: "warn", message, args });
-    },
-    error(message, ...args) {
-      logs.push({ level: "error", message, args });
-    },
-    debug(message, ...args) {
-      logs.push({ level: "debug", message, args });
-    }
-  };
-}
-function createMockCache() {
-  const store = /* @__PURE__ */ new Map();
-  const get = async (key) => {
-    return store.has(key) ? store.get(key) : null;
-  };
-  const set = async (key, value, _ttl) => {
-    store.set(key, value);
-  };
-  return {
-    get,
-    set,
-    async del(key) {
-      store.delete(key);
-    },
-    async incr(key) {
-      const raw = store.get(key);
-      const current = typeof raw === "number" ? raw : parseInt(String(raw ?? "0"), 10);
-      const next = current + 1;
-      store.set(key, next);
-      return next;
-    },
-    async getOrSet(key, ttl, fn) {
-      const hit = await get(key);
-      if (hit !== null) {
-        return hit;
-      }
-      const value = await fn();
-      await set(key, value, ttl);
-      return value;
-    }
-  };
 }
-function createMockModuleClients() {
-  const notImpl = (label) => {
-    throw new Error(
-      `${label} not configured in test mock \u2014 override the matching client on the returned context`
-    );
-  };
-  const docs = {
-    collection: () => notImpl("docs.collection"),
-    doc: () => notImpl("docs.doc")
-  };
-  const auth = {
-    verifyUserToken: () => notImpl("auth.verifyUserToken"),
-    getSession: () => notImpl("auth.getSession"),
-    mfa: {
-      enroll: () => notImpl("auth.mfa.enroll"),
-      verifyEnrollment: () => notImpl("auth.mfa.verifyEnrollment"),
-      challenge: () => notImpl("auth.mfa.challenge"),
-      recovery: () => notImpl("auth.mfa.recovery"),
-      listFactors: () => notImpl("auth.mfa.listFactors"),
-      removeFactor: () => notImpl("auth.mfa.removeFactor"),
-      regenerateRecoveryCodes: () => notImpl("auth.mfa.regenerateRecoveryCodes"),
-      emailEnroll: () => notImpl("auth.mfa.emailEnroll"),
-      emailChallenge: () => notImpl("auth.mfa.emailChallenge"),
-      emailVerify: () => notImpl("auth.mfa.emailVerify")
-    },
-    device: {
-      generateChallenge: () => notImpl("auth.device.generateChallenge"),
-      attestAndroid: () => notImpl("auth.device.attestAndroid"),
-      attestiOS: () => notImpl("auth.device.attestiOS"),
-      bind: () => notImpl("auth.device.bind"),
-      list: () => notImpl("auth.device.list"),
-      delete: () => notImpl("auth.device.delete"),
-      verifyRequestSignature: () => notImpl("auth.device.verifyRequestSignature"),
-      getToken: () => notImpl("auth.device.getToken"),
-      get isActive() {
-        return notImpl("auth.device.isActive");
-      },
-      setCachedToken: () => notImpl("auth.device.setCachedToken"),
-      dispose: () => notImpl("auth.device.dispose")
-    }
-  };
-  const storage = {
-    bucket: () => notImpl("storage.bucket")
-  };
-  const realtime = {
-    broadcast: async () => ({ data: void 0, error: null })
-  };
-  const functions = {
-    invoke: () => notImpl("functions.invoke")
-  };
-  const flags = {
-    isEnabled: () => notImpl("flags.isEnabled"),
-    getVariant: () => notImpl("flags.getVariant"),
-    getAll: () => notImpl("flags.getAll"),
-    setOverride: () => notImpl("flags.setOverride"),
-    asService: () => ({
-      setOverrideForUser: () => notImpl("flags.asService.setOverrideForUser"),
-      setOverridesForUser: () => notImpl("flags.asService.setOverridesForUser"),
-      clearOverrideForUser: () => notImpl("flags.asService.clearOverrideForUser"),
-      clearAllOverridesForUser: () => notImpl("flags.asService.clearAllOverridesForUser"),
-      batchSetOverrides: () => notImpl("flags.asService.batchSetOverrides")
-    })
-  };
-  const notifications = {
-    push: { send: () => notImpl("notifications.push.send") },
-    email: { send: () => notImpl("notifications.email.send") },
-    sms: { send: () => notImpl("notifications.sms.send") },
-    verifications: {
-      start: () => notImpl("notifications.verifications.start"),
-      check: () => notImpl("notifications.verifications.check")
-    },
-    inbox: {
-      send: () => notImpl("notifications.inbox.send"),
-      list: () => notImpl("notifications.inbox.list"),
-      unreadCount: () => notImpl("notifications.inbox.unreadCount"),
-      markRead: () => notImpl("notifications.inbox.markRead"),
-      markAllRead: () => notImpl("notifications.inbox.markAllRead"),
-      archive: () => notImpl("notifications.inbox.archive")
-    },
-    preferences: {
-      get: () => notImpl("notifications.preferences.get"),
-      update: () => notImpl("notifications.preferences.update")
-    },
-    templates: {
-      email: {
-        list: () => notImpl("notifications.templates.email.list"),
-        get: () => notImpl("notifications.templates.email.get"),
-        create: () => notImpl("notifications.templates.email.create"),
-        update: () => notImpl("notifications.templates.email.update"),
-        delete: () => notImpl("notifications.templates.email.delete")
-      },
-      sms: {
-        list: () => notImpl("notifications.templates.sms.list"),
-        get: () => notImpl("notifications.templates.sms.get"),
-        create: () => notImpl("notifications.templates.sms.create"),
-        update: () => notImpl("notifications.templates.sms.update"),
-        delete: () => notImpl("notifications.templates.sms.delete")
-      }
-    },
-    registerDevice: () => notImpl("notifications.registerDevice"),
-    unregisterDevice: () => notImpl("notifications.unregisterDevice")
-  };
-  const analytics = {
-    capture: () => notImpl("analytics.capture"),
-    identify: () => notImpl("analytics.identify"),
-    screen: () => notImpl("analytics.screen"),
-    query: {
-      count: () => notImpl("analytics.query.count"),
-      events: () => notImpl("analytics.query.events"),
-      properties: () => notImpl("analytics.query.properties"),
-      users: () => notImpl("analytics.query.users"),
-      funnel: () => notImpl("analytics.query.funnel"),
-      retention: () => notImpl("analytics.query.retention"),
-      cohort: () => notImpl("analytics.query.cohort")
-    },
-    management: {
-      overview: () => notImpl("analytics.management.overview"),
-      eventNames: () => notImpl("analytics.management.eventNames"),
-      userDetail: () => notImpl("analytics.management.userDetail"),
-      deleteUser: () => notImpl("analytics.management.deleteUser")
-    }
-  };
-  const links = {
-    create: () => notImpl("links.create"),
-    list: () => notImpl("links.list"),
-    get: () => notImpl("links.get"),
-    update: () => notImpl("links.update"),
-    delete: () => notImpl("links.delete"),
-    analytics: () => notImpl("links.analytics"),
-    qrCode: () => notImpl("links.qrCode"),
-    match: () => notImpl("links.match")
-  };
-  return {
-    auth,
-    storage,
-    docs,
-    realtime,
-    functions,
-    flags,
-    notifications,
-    analytics,
-    links
-  };
-}
-function createMockPurchases() {
-  return {
-    resolveSubject: async ({ userRef }) => ({ subjectId: `psj_test_${userRef}` }),
-    require: async () => void 0,
-    withSpend: async (_subjectId, _key, _opts, handler) => handler()
-  };
-}
-var NULL_CLIENT_INFO = {
-  sdkVersion: null,
-  appVersion: null,
-  platform: null,
-  osVersion: null
-};
-function createTestContext(options = {}) {
-  const logs = [];
-  const db = createMockDB();
-  if (options.db?.seed) {
-    for (const [table, data] of Object.entries(options.db.seed)) {
-      db.seed(table, data);
-    }
+var configured = null;
+var api = new Proxy({}, {
+  get(_target, prop) {
+    configured ??= createTestApi({
+      baseUrl: process.env.PALBASE_TEST_BASE_URL ?? "",
+      apiKey: process.env.PALBASE_TEST_API_KEY ?? "",
+      candidateToken: process.env.PALBASE_TEST_CANDIDATE ?? ""
+    });
+    return Reflect.get(configured, prop, configured);
   }
-  const log = createMockLogger(logs);
-  const cache = createMockCache();
-  const moduleClients = createMockModuleClients();
-  __setRuntime({
-    Database: db,
-    Documents: moduleClients.docs,
-    Storage: moduleClients.storage,
-    Cache: cache,
-    Log: log,
-    Notifications: moduleClients.notifications,
-    Flags: moduleClients.flags,
-    Realtime: moduleClients.realtime,
-    Purchases: createMockPurchases()
-  });
-  const ctx = {
-    input: options.input ?? {},
-    params: options.params ?? {},
-    query: options.query ?? {},
-    headers: options.headers ?? {},
-    user: options.user ?? null,
-    client: NULL_CLIENT_INFO,
-    method: "POST",
-    file: null,
-    db,
-    env: options.env ?? {},
-    log,
-    cache,
-    ...moduleClients,
-    // Empty errors map in tests by default. Tests that exercise an endpoint's
-    // declared errors construct their own throwers; this stub satisfies the
-    // PBRequest shape without forcing every test to declare `errors:`.
-    errors: {},
-    requestId: "req_test_000000000000",
-    traceId: "0".repeat(32),
-    spanId: "0".repeat(16),
-    logs
-  };
-  return ctx;
-}
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createMockDB,
-  createTestContext
+  TestApiError,
+  api,
+  createTestApi
 });
 //# sourceMappingURL=index.cjs.map