@palbase/backend 16.0.0 → 17.1.0

package/dist/test/index.js

@@ -1,481 +1,120 @@
-import {
-  __setRuntime
-} from "../chunk-I72YYSEI.js";
-import "../chunk-7LAXRLPG.js";
-
-// 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]);
+// 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;
   }
-  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)
-      );
-    }
-  };
-  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) ?? [];
-    },
-    updated(table) {
-      return tracked.updated.get(table) ?? [];
-    },
-    deleted(table) {
-      return tracked.deleted.get(table) ?? [];
-    },
-    seed(table, data) {
-      store.set(table, [...data]);
-    }
-  };
-  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;
+};
+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.`
+    );
   }
   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 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;
   }
-  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;
+    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 signInAs(name) {
+      const identity = (config.identities ?? {})[name];
+      if (!identity) {
+        const declared = Object.keys(config.identities ?? {});
+        throw new Error(
+          `no test identity named ${JSON.stringify(name)} \u2014 the deploy mints one per user declared in config/test-users.ts` + (declared.length ? `; this run has: ${declared.join(", ")}` : ", and this project declares none")
+        );
       }
-      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")
+      return this.signIn(identity);
     },
-    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")
-      }
+    async signIn(credentials) {
+      const result = await call(
+        "POST",
+        "/auth/login",
+        credentials
+      );
+      bearer = result.access_token;
+      return result.user ?? { id: "" };
     },
-    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")
+    async signOut() {
+      await call("POST", "/auth/logout", void 0);
+      bearer = null;
     },
-    management: {
-      overview: () => notImpl("analytics.management.overview"),
-      eventNames: () => notImpl("analytics.management.eventNames"),
-      userDetail: () => notImpl("analytics.management.userDetail"),
-      deleteUser: () => notImpl("analytics.management.deleteUser")
+    asAnonymous() {
+      bearer = null;
     }
   };
-  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()
-  };
+function parseIdentities(raw) {
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
 }
-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);
-    }
+function safeParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
   }
-  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;
 }
+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 ?? "",
+      identities: parseIdentities(process.env.PALBASE_TEST_IDENTITIES)
+    });
+    return Reflect.get(configured, prop, configured);
+  }
+});
 export {
-  createMockDB,
-  createTestContext
+  TestApiError,
+  api,
+  createTestApi
 };
 //# sourceMappingURL=index.js.map