@palbase/backend 17.4.0 → 18.0.0

package/dist/bin/palbase-backend.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env bun
+import {
+  BootRefused,
+  createApp,
+  loadConfig
+} from "../chunk-VYH4U7ZQ.js";
+import "../chunk-POYAFBLF.js";
+import "../chunk-W5ODXPY3.js";
+import {
+  getRegisteredControllers
+} from "../chunk-YL4C5NRY.js";
+import "../chunk-QMVK4X3V.js";
+import "../chunk-7D4SUZUM.js";
+
+// src/bin/palbase-backend.ts
+import { readdir, stat } from "fs/promises";
+import { join, resolve } from "path";
+import { pathToFileURL } from "url";
+var USAGE = `palbase-backend \u2014 run this project's backend
+
+  palbase-backend serve      start the backend
+  palbase-backend dev        start it and reload on change
+  palbase-backend routes     print the route table and exit
+
+Configuration comes from the environment (a .env beside package.json is read):
+
+  DATABASE_URL               required \u2014 the stack's Postgres
+  AUTH_JWKS_URL              required \u2014 where your stack publishes its signing keys
+  MODULE_BASE_URL            where Documents/Storage/Notifications/Flags/Realtime live
+  PALBASE_ANON_KEY           publishable key, sent on module calls
+  PALBASE_SERVICE_ROLE_KEY   secret key, for privileged module calls
+  PORT                       default 3000
+`;
+function die(message) {
+  console.error(message);
+  process.exit(1);
+}
+async function loadDotEnv(root) {
+  const file = Bun.file(join(root, ".env"));
+  if (!await file.exists()) return;
+  for (const raw of (await file.text()).split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq < 1) continue;
+    const key = line.slice(0, eq).trim();
+    if (process.env[key] !== void 0) continue;
+    let value = line.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    process.env[key] = value;
+  }
+}
+async function findControllers(root) {
+  const dir = join(root, "controllers");
+  try {
+    if (!(await stat(dir)).isDirectory()) return [];
+  } catch {
+    return [];
+  }
+  const out = [];
+  const walk = async (d) => {
+    for (const entry of await readdir(d, { withFileTypes: true })) {
+      const full = join(d, entry.name);
+      if (entry.isDirectory()) await walk(full);
+      else if (/\.controller\.(ts|js|mts|mjs)$/.test(entry.name)) out.push(full);
+    }
+  };
+  await walk(dir);
+  return out.sort();
+}
+async function importSchema(root) {
+  for (const candidate of ["db/schema.ts", "db/schema.js"]) {
+    const path = join(root, candidate);
+    try {
+      await stat(path);
+      return (await import(pathToFileURL(path).href)).default;
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function main() {
+  const command = process.argv[2] ?? "serve";
+  if (command === "--help" || command === "-h" || command === "help") {
+    console.log(USAGE);
+    return;
+  }
+  if (!["serve", "dev", "routes"].includes(command)) {
+    die(`palbase-backend: unknown command "${command}".
+
+${USAGE}`);
+  }
+  if (typeof Bun === "undefined") {
+    die(
+      "palbase-backend needs Bun: the engine serves `fetch` natively and opens its own\nPostgres pool through Bun.sql. Install it from https://bun.sh, then re-run."
+    );
+  }
+  if (command === "dev" && !process.env.PALBASE_WATCHING) {
+    const self = Bun.fileURLToPath(import.meta.url);
+    const child = Bun.spawn(["bun", "--watch", self, "serve"], {
+      stdio: ["inherit", "inherit", "inherit"],
+      env: { ...process.env, PALBASE_WATCHING: "1" }
+    });
+    process.exit(await child.exited);
+  }
+  const root = resolve(process.env.PALBASE_PROJECT_DIR ?? process.cwd());
+  await loadDotEnv(root);
+  const files = await findControllers(root);
+  if (files.length === 0) {
+    die(
+      `palbase-backend: no controllers found under ${join(root, "controllers")}.
+A backend is its controllers \u2014 add one and run again:
+
+  // controllers/hello.controller.ts
+  import { Controller, Get } from "@palbase/backend";
+  @Controller("/hello")
+  class HelloController {
+    @Get("") hi(): Promise<{ ok: boolean }> { return Promise.resolve({ ok: true }); }
+  }
+`
+    );
+  }
+  for (const file of files) await import(pathToFileURL(file).href);
+  const controllers = getRegisteredControllers();
+  if (controllers.length === 0) {
+    die(
+      `palbase-backend: ${files.length} controller file(s) loaded but none registered.
+Every one of them is missing its @Controller decorator, or the files were
+compiled with decorators stripped. Nothing would answer, so this is fatal.`
+    );
+  }
+  let config;
+  try {
+    config = loadConfig(process.env);
+  } catch (e) {
+    if (e instanceof BootRefused) {
+      die(
+        `${e.message}
+
+Put them in a .env beside package.json, or export them. A local stack
+(docker compose up) publishes both.`
+      );
+    }
+    throw e;
+  }
+  const app = await createApp({ config, controllers, schema: await importSchema(root) });
+  if (command === "routes") {
+    for (const route of app.routes) console.log(route.id);
+    await app.shutdown();
+    return;
+  }
+  Bun.serve({ port: config.port, idleTimeout: 60, fetch: app.handle });
+  console.log(`palbase-backend listening on http://localhost:${config.port}`);
+  console.log(`  ${app.routes.length} endpoint(s) from ${files.length} controller file(s)`);
+  for (const route of app.routes) console.log(`  ${route.id}`);
+  for (const signal of ["SIGTERM", "SIGINT"]) {
+    process.on(signal, () => {
+      void app.shutdown().finally(() => process.exit(0));
+    });
+  }
+}
+main().catch((e) => {
+  console.error(e instanceof Error ? e.message : e);
+  process.exit(1);
+});
+//# sourceMappingURL=palbase-backend.js.map

package/dist/bin/palbase-backend.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/bin/palbase-backend.ts"],"sourcesContent":["#!/usr/bin/env bun\n/**\n * palbase-backend — run this project's backend.\n *\n *   npm run dev        →  palbase-backend dev     (reloads on change)\n *   npm start          →  palbase-backend serve\n *\n * There is no scaffolding step and no server file to write. The project IS the\n * backend: every `controllers/*.controller.ts` is imported, which is what\n * registers it, and the engine is built around whatever registered.\n *\n * It is the same engine the deployed runtime builds — not a development\n * stand-in. A dev server that is a different program from the production one is\n * a source of \"works locally\" reports, and this one has no second implementation\n * to disagree with.\n */\nimport { readdir, stat } from \"node:fs/promises\";\nimport { join, resolve } from \"node:path\";\nimport { pathToFileURL } from \"node:url\";\n\nimport { createApp, loadConfig, BootRefused } from \"../engine/index.js\";\nimport { getRegisteredControllers } from \"../decorators/controller.js\";\n\nconst USAGE = `palbase-backend — run this project's backend\n\n  palbase-backend serve      start the backend\n  palbase-backend dev        start it and reload on change\n  palbase-backend routes     print the route table and exit\n\nConfiguration comes from the environment (a .env beside package.json is read):\n\n  DATABASE_URL               required — the stack's Postgres\n  AUTH_JWKS_URL              required — where your stack publishes its signing keys\n  MODULE_BASE_URL            where Documents/Storage/Notifications/Flags/Realtime live\n  PALBASE_ANON_KEY           publishable key, sent on module calls\n  PALBASE_SERVICE_ROLE_KEY   secret key, for privileged module calls\n  PORT                       default 3000\n`;\n\nfunction die(message: string): never {\n  console.error(message);\n  process.exit(1);\n}\n\n/** Read a `.env` beside the project, without adding a dependency for it. */\nasync function loadDotEnv(root: string): Promise<void> {\n  const file = Bun.file(join(root, \".env\"));\n  if (!(await file.exists())) return;\n  for (const raw of (await file.text()).split(\"\\n\")) {\n    const line = raw.trim();\n    if (!line || line.startsWith(\"#\")) continue;\n    const eq = line.indexOf(\"=\");\n    if (eq < 1) continue;\n    const key = line.slice(0, eq).trim();\n    // The environment wins: an exported value is the operator being explicit,\n    // and a file quietly overriding it is how a \"why is it still pointing at\n    // the old database\" hour begins.\n    if (process.env[key] !== undefined) continue;\n    let value = line.slice(eq + 1).trim();\n    if (\n      (value.startsWith('\"') && value.endsWith('\"')) ||\n      (value.startsWith(\"'\") && value.endsWith(\"'\"))\n    ) {\n      value = value.slice(1, -1);\n    }\n    process.env[key] = value;\n  }\n}\n\n/** Every `*.controller.ts` under `controllers/`, sorted, recursively. */\nasync function findControllers(root: string): Promise<string[]> {\n  const dir = join(root, \"controllers\");\n  try {\n    if (!(await stat(dir)).isDirectory()) return [];\n  } catch {\n    return [];\n  }\n  const out: string[] = [];\n  const walk = async (d: string): Promise<void> => {\n    for (const entry of await readdir(d, { withFileTypes: true })) {\n      const full = join(d, entry.name);\n      if (entry.isDirectory()) await walk(full);\n      else if (/\\.controller\\.(ts|js|mts|mjs)$/.test(entry.name)) out.push(full);\n    }\n  };\n  await walk(dir);\n  // Sorted so route precedence is the same on every machine.\n  return out.sort();\n}\n\nasync function importSchema(root: string): Promise<unknown> {\n  for (const candidate of [\"db/schema.ts\", \"db/schema.js\"]) {\n    const path = join(root, candidate);\n    try {\n      await stat(path);\n      return (await import(pathToFileURL(path).href)).default;\n    } catch {\n      // Not every project declares a schema; the typed `.tables` surface is\n      // simply absent then.\n    }\n  }\n  return undefined;\n}\n\nasync function main(): Promise<void> {\n  const command = process.argv[2] ?? \"serve\";\n  if (command === \"--help\" || command === \"-h\" || command === \"help\") {\n    console.log(USAGE);\n    return;\n  }\n  if (![\"serve\", \"dev\", \"routes\"].includes(command)) {\n    die(`palbase-backend: unknown command \"${command}\".\\n\\n${USAGE}`);\n  }\n  if (typeof Bun === \"undefined\") {\n    die(\n      \"palbase-backend needs Bun: the engine serves `fetch` natively and opens its own\\n\" +\n        \"Postgres pool through Bun.sql. Install it from https://bun.sh, then re-run.\",\n    );\n  }\n\n  // `dev` is `serve` under Bun's watcher. Re-exec rather than reimplement:\n  // one code path serves, and the reload is the runtime's job, not ours.\n  if (command === \"dev\" && !process.env.PALBASE_WATCHING) {\n    const self = Bun.fileURLToPath(import.meta.url);\n    const child = Bun.spawn([\"bun\", \"--watch\", self, \"serve\"], {\n      stdio: [\"inherit\", \"inherit\", \"inherit\"],\n      env: { ...process.env, PALBASE_WATCHING: \"1\" },\n    });\n    process.exit(await child.exited);\n  }\n\n  const root = resolve(process.env.PALBASE_PROJECT_DIR ?? process.cwd());\n  await loadDotEnv(root);\n\n  const files = await findControllers(root);\n  if (files.length === 0) {\n    die(\n      `palbase-backend: no controllers found under ${join(root, \"controllers\")}.\\n` +\n        `A backend is its controllers — add one and run again:\\n\\n` +\n        `  // controllers/hello.controller.ts\\n` +\n        `  import { Controller, Get } from \"@palbase/backend\";\\n` +\n        `  @Controller(\"/hello\")\\n` +\n        `  class HelloController {\\n` +\n        `    @Get(\"\") hi(): Promise<{ ok: boolean }> { return Promise.resolve({ ok: true }); }\\n` +\n        `  }\\n`,\n    );\n  }\n\n  // Importing IS the registration — the decorator records each class as it runs.\n  for (const file of files) await import(pathToFileURL(file).href);\n  const controllers = getRegisteredControllers();\n  if (controllers.length === 0) {\n    die(\n      `palbase-backend: ${files.length} controller file(s) loaded but none registered.\\n` +\n        `Every one of them is missing its @Controller decorator, or the files were\\n` +\n        `compiled with decorators stripped. Nothing would answer, so this is fatal.`,\n    );\n  }\n\n  let config;\n  try {\n    config = loadConfig(process.env as Record<string, string | undefined>);\n  } catch (e) {\n    if (e instanceof BootRefused) {\n      die(\n        `${e.message}\\n\\n` +\n          `Put them in a .env beside package.json, or export them. A local stack\\n` +\n          `(docker compose up) publishes both.`,\n      );\n    }\n    throw e;\n  }\n\n  const app = await createApp({ config, controllers, schema: await importSchema(root) });\n\n  if (command === \"routes\") {\n    for (const route of app.routes) console.log(route.id);\n    await app.shutdown();\n    return;\n  }\n\n  Bun.serve({ port: config.port, idleTimeout: 60, fetch: app.handle });\n  console.log(`palbase-backend listening on http://localhost:${config.port}`);\n  console.log(`  ${app.routes.length} endpoint(s) from ${files.length} controller file(s)`);\n  for (const route of app.routes) console.log(`  ${route.id}`);\n\n  for (const signal of [\"SIGTERM\", \"SIGINT\"] as const) {\n    process.on(signal, () => {\n      void app.shutdown().finally(() => process.exit(0));\n    });\n  }\n}\n\n// Not a top-level await: this file is also emitted in a CommonJS flavour, where\n// one is a build error. The rejection handler is the point either way — an\n// unhandled one exits 0 on some runtimes, which would report a dead backend as\n// a successful start.\nmain().catch((e: unknown) => {\n  console.error(e instanceof Error ? e.message : e);\n  process.exit(1);\n});\n"],"mappings":"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","names":[]}

package/dist/chunk-7D4SUZUM.js

@@ -0,0 +1,38 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};
+//# sourceMappingURL=chunk-7D4SUZUM.js.map

package/dist/chunk-7D4SUZUM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-N32VDWKH.js

@@ -0,0 +1,172 @@
+import {
+  HttpError
+} from "./chunk-QMVK4X3V.js";
+
+// src/purchases/registry.ts
+var ENTITLEMENTS = /* @__PURE__ */ Symbol.for("palbase.backend.purchases.entitlements");
+var SPENDS = /* @__PURE__ */ Symbol.for("palbase.backend.purchases.spends");
+function carrierOf(target) {
+  return typeof target === "function" ? target : target.constructor ?? target;
+}
+function own(carrier, slot) {
+  if (!Object.prototype.hasOwnProperty.call(carrier, slot)) {
+    carrier[slot] = {};
+  }
+  return carrier[slot];
+}
+function recordEntitlement(target, fnName, key) {
+  own(carrierOf(target), ENTITLEMENTS)[fnName] = key;
+}
+function recordSpend(target, fnName, meta) {
+  own(carrierOf(target), SPENDS)[fnName] = meta;
+}
+function entitlementFor(ctor, fnName) {
+  return carrierOf(ctor)[ENTITLEMENTS]?.[fnName];
+}
+function spendFor(ctor, fnName) {
+  return carrierOf(ctor)[SPENDS]?.[fnName];
+}
+
+// src/error-registry.ts
+import {
+  OpenAPIRegistry,
+  OpenApiGeneratorV31,
+  extendZodWithOpenApi
+} from "@asteasolutions/zod-to-openapi";
+import { z } from "zod";
+extendZodWithOpenApi(z);
+var ERROR_REGISTRY = /* @__PURE__ */ Symbol.for("palbase.backend.errorRegistry");
+var BUILTIN_DATA_SCHEMAS = {
+  bad_request: z.object({
+    fields: z.array(z.object({ field: z.string(), message: z.string() }))
+  }),
+  too_many_requests: z.object({ retryAfter: z.number().int() }),
+  // Purchases (@RequireEntitlement / @Spend). Their payloads are what make a
+  // paywall renderable on the client: WHICH entitlement was missing, and for a
+  // spend the real ceiling and reset time rather than a guessed retry delay.
+  entitlement_required: z.object({ entitlement: z.string().nullable() }),
+  quota_exceeded: z.object({
+    key: z.string(),
+    scope: z.string(),
+    window: z.string(),
+    used: z.number().int(),
+    reserved: z.number().int(),
+    max: z.number().int(),
+    remaining: z.number().int(),
+    resetAt: z.string()
+  }),
+  credit_insufficient: z.object({
+    key: z.string(),
+    balance: z.number().int(),
+    reserved: z.number().int(),
+    remaining: z.number().int()
+  })
+};
+function getErrorRegistry() {
+  const g = globalThis;
+  if (!g[ERROR_REGISTRY]) {
+    const m = /* @__PURE__ */ new Map();
+    for (const [code, status, className] of [
+      ["bad_request", 400, "BadRequest"],
+      ["unauthorized", 401, "Unauthorized"],
+      ["forbidden", 403, "Forbidden"],
+      ["not_found", 404, "NotFound"],
+      ["conflict", 409, "Conflict"],
+      ["too_many_requests", 429, "TooManyRequests"],
+      // Thrown by the purchases decorators, so they are pre-seeded like the
+      // other built-ins: a project never declares them, but every gated or
+      // metered route must surface them as TYPED errors on the client.
+      ["entitlement_required", 403, "EntitlementRequired"],
+      ["quota_exceeded", 429, "QuotaExceeded"],
+      ["credit_insufficient", 429, "CreditInsufficient"]
+    ]) {
+      const dataSchema = BUILTIN_DATA_SCHEMAS[code];
+      m.set(code, {
+        code,
+        status,
+        className,
+        builtin: true,
+        ...dataSchema ? { dataSchema, dataDigest: digestOf(code, dataSchema) } : {}
+      });
+    }
+    g[ERROR_REGISTRY] = m;
+  }
+  return g[ERROR_REGISTRY];
+}
+function defineError(code, status, dataSchema) {
+  if (!Number.isInteger(status) || status < 400 || status > 599) {
+    throw new Error(
+      `defineError: status for "${code}" must be a 4xx/5xx integer, got ${status} \u2014 error responses must not clobber success responses in the project spec.`
+    );
+  }
+  const registry = getErrorRegistry();
+  const existing = registry.get(code);
+  const className = defaultClassName(code);
+  const dataDigest = dataSchema ? digestOf(code, dataSchema) : void 0;
+  if (existing) {
+    const sameShape = existing.status === status && !existing.builtin && existing.dataDigest === dataDigest;
+    if (!sameShape) {
+      throw new Error(
+        `defineError: duplicate error code "${code}" with a different shape (existing: status ${existing.status}${existing.builtin ? ", built-in" : ""}${existing.status === status && !existing.builtin ? ", different data schema" : ""}). Error codes are project-unique.`
+      );
+    }
+  }
+  const makeWithData = (schema) => class extends HttpError {
+    static code = code;
+    static status = status;
+    constructor(data, message) {
+      super(status, code, message ?? humanize(code), schema.parse(data));
+      this.name = className;
+    }
+  };
+  const makeWithoutData = () => class extends HttpError {
+    static code = code;
+    static status = status;
+    constructor(message) {
+      super(status, code, message ?? humanize(code));
+      this.name = className;
+    }
+  };
+  const cls = dataSchema ? makeWithData(dataSchema) : makeWithoutData();
+  Object.defineProperty(cls, "name", { value: className });
+  registry.set(code, {
+    code,
+    status,
+    className,
+    builtin: false,
+    ...dataSchema ? { dataSchema } : {},
+    ...dataDigest !== void 0 ? { dataDigest } : {}
+  });
+  return cls;
+}
+function digestOf(code, dataSchema) {
+  const TMP_REF = "__PalbaseErrorDataDigest";
+  const tmpRegistry = new OpenAPIRegistry();
+  tmpRegistry.register(TMP_REF, z.object({ data: dataSchema }).openapi(TMP_REF));
+  const generated = new OpenApiGeneratorV31(tmpRegistry.definitions).generateComponents();
+  const out = generated.components?.schemas?.[TMP_REF];
+  const digest = JSON.stringify(out ?? null);
+  if (digest.includes('"$ref"')) {
+    throw new Error(
+      `defineError: dataSchema for "${code}" carries .openapi(refId) metadata \u2014 it would emit dangling $ref pointers in the project spec. Use a plain zod schema (z.object({...})) without .openapi(...).`
+    );
+  }
+  return digest;
+}
+function defaultClassName(code) {
+  return code.split("_").map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+function humanize(code) {
+  const s = code.replace(/_/g, " ");
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+export {
+  recordEntitlement,
+  recordSpend,
+  entitlementFor,
+  spendFor,
+  getErrorRegistry,
+  defineError
+};
+//# sourceMappingURL=chunk-N32VDWKH.js.map

package/dist/chunk-N32VDWKH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/purchases/registry.ts","../src/error-registry.ts"],"sourcesContent":["/**\n * Per-method purchases metadata, stored on the controller class the same way\n * `decorators/registry.ts` stores routes: a symbol-keyed static, plain data, no\n * `reflect-metadata`.\n *\n * Its only consumer is the OpenAPI step, which needs to know that a route is\n * gated (declare 403) or metered (declare 429) so the iOS client codegen emits\n * TYPED errors instead of a bare status number. Enforcement does NOT read this\n * — the decorators wrap the method directly — so a stale registry can never\n * cause a missed gate.\n */\n\nimport type { EntitlementKey, LimitKey } from \"./keys.js\";\n\nconst ENTITLEMENTS: unique symbol = Symbol.for(\"palbase.backend.purchases.entitlements\");\nconst SPENDS: unique symbol = Symbol.for(\"palbase.backend.purchases.spends\");\n\n/** What `@Spend` recorded for one method. */\nexport interface SpendMeta {\n  key: LimitKey;\n  count: number;\n}\n\ninterface PurchasesCarrier {\n  [ENTITLEMENTS]?: Record<string, EntitlementKey>;\n  [SPENDS]?: Record<string, SpendMeta>;\n}\n\n/** Resolve a decorated target (prototype or constructor) to the constructor\n * that owns the metadata, mirroring `carrierOf` in decorators/registry.ts. */\nfunction carrierOf(target: object): PurchasesCarrier {\n  return (\n    typeof target === \"function\"\n      ? (target as unknown as PurchasesCarrier)\n      : (((target as { constructor?: unknown }).constructor ?? target) as PurchasesCarrier)\n  );\n}\n\n/** Own (not inherited) slot, so a subclass never mutates its base's metadata. */\nfunction own<K extends typeof ENTITLEMENTS | typeof SPENDS>(\n  carrier: PurchasesCarrier,\n  slot: K,\n): NonNullable<PurchasesCarrier[K]> {\n  if (!Object.prototype.hasOwnProperty.call(carrier, slot)) {\n    carrier[slot] = {} as never;\n  }\n  return carrier[slot] as NonNullable<PurchasesCarrier[K]>;\n}\n\nexport function recordEntitlement(target: object, fnName: string, key: EntitlementKey): void {\n  own(carrierOf(target), ENTITLEMENTS)[fnName] = key;\n}\n\nexport function recordSpend(target: object, fnName: string, meta: SpendMeta): void {\n  own(carrierOf(target), SPENDS)[fnName] = meta;\n}\n\n/** The entitlement `fnName` is gated on, or undefined when it is not gated. */\nexport function entitlementFor(ctor: object, fnName: string): EntitlementKey | undefined {\n  return carrierOf(ctor)[ENTITLEMENTS]?.[fnName];\n}\n\n/** What `fnName` spends, or undefined when it spends nothing. */\nexport function spendFor(ctor: object, fnName: string): SpendMeta | undefined {\n  return carrierOf(ctor)[SPENDS]?.[fnName];\n}\n","// defineError — project-defined typed error classes + the module-global error\n// registry the OpenAPI spec twins join against.\n//\n// `defineError(code, status, dataSchema?)` returns an `HttpError` subclass whose\n// constructor is typed by the zod schema (`new TodoLocked({ retryAfter: 30 })`).\n// Each call self-registers `{ code, status, className, dataSchema }` in a\n// registry anchored on `globalThis` under `Symbol.for(...)` — mirroring the\n// ROUTES pattern — so the deploy bundle's registrations land on the single SDK\n// instance the extractor `require()`s. The registry is pre-seeded with the named\n// built-in classes (`NotFound`, `Conflict`, …) so throw inference can resolve\n// ad-hoc `throw new NotFound(...)` sites by their canonical wire codes.\n//\n// Duplicate code with a DIFFERENT shape (status OR converted data schema) is a\n// hard error at registration time (deploy fails loudly — error codes are\n// project-unique); structurally-identical re-registration is idempotent (each\n// controller BUNDLE carries its own copy of a shared models/errors.ts, so the\n// same defineError line legitimately runs once per bundle in one process).\nimport {\n  OpenAPIRegistry,\n  OpenApiGeneratorV31,\n  extendZodWithOpenApi,\n} from \"@asteasolutions/zod-to-openapi\";\nimport { z, type ZodTypeAny } from \"zod\";\nimport { HttpError } from \"./errors.js\";\n\nextendZodWithOpenApi(z);\n\n/** One registered error: the wire code, HTTP status, the class name the\n * analyzer sees, the optional data payload schema, and whether it is one of the\n * pre-seeded built-in named classes. */\nexport interface RegisteredError {\n  code: string;\n  status: number;\n  className: string;\n  dataSchema?: ZodTypeAny;\n  /** JSON.stringify of the converted JSON schema — equal digest ⇔ the spec\n   * twins would emit an identical `data` schema for this error. */\n  dataDigest?: string;\n  builtin: boolean;\n}\n\n/** The cross-module-instance registry anchor (the pinned contract symbol). */\nconst ERROR_REGISTRY: unique symbol = Symbol.for(\"palbase.backend.errorRegistry\");\n\ninterface RegistryCarrier {\n  [ERROR_REGISTRY]?: Map<string, RegisteredError>;\n}\n\n/** Get (creating + pre-seeding if absent) the project-global error registry,\n * keyed by wire code. Anchored on `globalThis` so every copy of the SDK in a\n * process shares the one registry. */\n/** The fixed data schemas the built-in named errors ship. Declared HERE (not in\n * errors.ts, which stays zod-free) because this is where the registry converts\n * them to JSON-schema for the spec — keying codegen's typed `error.data`. Only\n * the errors that semantically carry a payload have a schema; the rest are\n * data-less. `.int()` is preserved so the wire/codegen sees an integer. */\nconst BUILTIN_DATA_SCHEMAS: Record<string, ZodTypeAny> = {\n  bad_request: z.object({\n    fields: z.array(z.object({ field: z.string(), message: z.string() })),\n  }),\n  too_many_requests: z.object({ retryAfter: z.number().int() }),\n  // Purchases (@RequireEntitlement / @Spend). Their payloads are what make a\n  // paywall renderable on the client: WHICH entitlement was missing, and for a\n  // spend the real ceiling and reset time rather than a guessed retry delay.\n  entitlement_required: z.object({ entitlement: z.string().nullable() }),\n  quota_exceeded: z.object({\n    key: z.string(),\n    scope: z.string(),\n    window: z.string(),\n    used: z.number().int(),\n    reserved: z.number().int(),\n    max: z.number().int(),\n    remaining: z.number().int(),\n    resetAt: z.string(),\n  }),\n  credit_insufficient: z.object({\n    key: z.string(),\n    balance: z.number().int(),\n    reserved: z.number().int(),\n    remaining: z.number().int(),\n  }),\n};\n\nexport function getErrorRegistry(): Map<string, RegisteredError> {\n  const g = globalThis as RegistryCarrier;\n  if (!g[ERROR_REGISTRY]) {\n    const m = new Map<string, RegisteredError>();\n    for (const [code, status, className] of [\n      [\"bad_request\", 400, \"BadRequest\"],\n      [\"unauthorized\", 401, \"Unauthorized\"],\n      [\"forbidden\", 403, \"Forbidden\"],\n      [\"not_found\", 404, \"NotFound\"],\n      [\"conflict\", 409, \"Conflict\"],\n      [\"too_many_requests\", 429, \"TooManyRequests\"],\n      // Thrown by the purchases decorators, so they are pre-seeded like the\n      // other built-ins: a project never declares them, but every gated or\n      // metered route must surface them as TYPED errors on the client.\n      [\"entitlement_required\", 403, \"EntitlementRequired\"],\n      [\"quota_exceeded\", 429, \"QuotaExceeded\"],\n      [\"credit_insufficient\", 429, \"CreditInsufficient\"],\n    ] as const) {\n      const dataSchema = BUILTIN_DATA_SCHEMAS[code];\n      m.set(code, {\n        code,\n        status,\n        className,\n        builtin: true,\n        ...(dataSchema ? { dataSchema, dataDigest: digestOf(code, dataSchema) } : {}),\n      });\n    }\n    g[ERROR_REGISTRY] = m;\n  }\n  return g[ERROR_REGISTRY];\n}\n\n/** Class returned for schema-bearing errors: ctor(data, message?). */\nexport interface DefinedErrorWithData<S extends ZodTypeAny> {\n  new (data: z.input<S>, message?: string): HttpError;\n  readonly code: string;\n  readonly status: number;\n}\n\n/** Class returned for schema-less errors: ctor(message?). */\nexport interface DefinedError {\n  new (message?: string): HttpError;\n  readonly code: string;\n  readonly status: number;\n}\n\n/**\n * Define a project error class. MUST be called with literal args (string\n * literal `code`, numeric literal `status`) at module top level — the deploy\n * stager's static analyzer reads those literals to resolve throw sites.\n *\n * @example\n * // models/todos/errors.ts\n * export const TodoLocked = defineError(\"todo_locked\", 409, z.object({ retryAfter: z.number() }));\n * // services/todo.service.ts\n * throw new TodoLocked({ retryAfter: 30 });\n */\nexport function defineError<S extends ZodTypeAny>(\n  code: string,\n  status: number,\n  dataSchema: S,\n): DefinedErrorWithData<S>;\nexport function defineError(code: string, status: number): DefinedError;\nexport function defineError(code: string, status: number, dataSchema?: ZodTypeAny): unknown {\n  if (!Number.isInteger(status) || status < 400 || status > 599) {\n    throw new Error(\n      `defineError: status for \"${code}\" must be a 4xx/5xx integer, got ${status} — ` +\n        `error responses must not clobber success responses in the project spec.`,\n    );\n  }\n  const registry = getErrorRegistry();\n  const existing = registry.get(code);\n  const className = defaultClassName(code);\n  const dataDigest = dataSchema ? digestOf(code, dataSchema) : undefined;\n  if (existing) {\n    const sameShape =\n      existing.status === status && !existing.builtin && existing.dataDigest === dataDigest;\n    if (!sameShape) {\n      throw new Error(\n        `defineError: duplicate error code \"${code}\" with a different shape ` +\n          `(existing: status ${existing.status}${existing.builtin ? \", built-in\" : \"\"}` +\n          `${existing.status === status && !existing.builtin ? \", different data schema\" : \"\"}). ` +\n          `Error codes are project-unique.`,\n      );\n    }\n  }\n  // Local factories so the class-constructor closures capture a NON-optional\n  // schema binding (narrowing does not flow into closures created in a branch).\n  const makeWithData = (schema: ZodTypeAny) =>\n    class extends HttpError {\n      static readonly code = code;\n      static readonly status = status;\n      constructor(data: unknown, message?: string) {\n        super(status, code, message ?? humanize(code), schema.parse(data));\n        this.name = className;\n      }\n    };\n  const makeWithoutData = () =>\n    class extends HttpError {\n      static readonly code = code;\n      static readonly status = status;\n      constructor(message?: string) {\n        super(status, code, message ?? humanize(code));\n        this.name = className;\n      }\n    };\n  const cls = dataSchema ? makeWithData(dataSchema) : makeWithoutData();\n  Object.defineProperty(cls, \"name\", { value: className });\n  registry.set(code, {\n    code,\n    status,\n    className,\n    builtin: false,\n    ...(dataSchema ? { dataSchema } : {}),\n    ...(dataDigest !== undefined ? { dataDigest } : {}),\n  });\n  return cls;\n}\n\n/** Convert a data schema through the SAME library the spec twins use and\n * return its JSON-schema digest (the duplicate-shape comparison key). Doubles\n * as the self-containment guard: a schema carrying `.openapi(refId)` metadata\n * (top-level or nested) converts to `$ref` pointers into components the\n * project spec never emits — a dangling ref every spec consumer would choke\n * on — so it is rejected here, at the definition site, with a fixable message. */\nfunction digestOf(code: string, dataSchema: ZodTypeAny): string {\n  const TMP_REF = \"__PalbaseErrorDataDigest\";\n  const tmpRegistry = new OpenAPIRegistry();\n  // Wrap the schema as a property — exactly how the envelope embeds it — so a\n  // TOP-LEVEL .openapi(refId) is not masked by the registration refId and\n  // surfaces as the same $ref the real emission would produce.\n  tmpRegistry.register(TMP_REF, z.object({ data: dataSchema }).openapi(TMP_REF));\n  const generated = new OpenApiGeneratorV31(tmpRegistry.definitions).generateComponents();\n  const out = generated.components?.schemas?.[TMP_REF];\n  const digest = JSON.stringify(out ?? null);\n  if (digest.includes('\"$ref\"')) {\n    throw new Error(\n      `defineError: dataSchema for \"${code}\" carries .openapi(refId) metadata — ` +\n        `it would emit dangling $ref pointers in the project spec. ` +\n        `Use a plain zod schema (z.object({...})) without .openapi(...).`,\n    );\n  }\n  return digest;\n}\n\n/** \"todo_locked\" → \"TodoLocked\" (used as Error.name; the source class NAME the\n * analyzer sees is whatever the user assigned the const to — they should match\n * by convention, and the descriptor carries the analyzed const name anyway). */\nfunction defaultClassName(code: string): string {\n  return code\n    .split(\"_\")\n    .map((p) => p.charAt(0).toUpperCase() + p.slice(1))\n    .join(\"\");\n}\n\n/** \"todo_locked\" → \"Todo locked\" — the default human-readable message. */\nfunction humanize(code: string): string {\n  const s = code.replace(/_/g, \" \");\n  return s.charAt(0).toUpperCase() + s.slice(1);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-POYAFBLF.js

@@ -0,0 +1,189 @@
+import {
+  TxPlanBuilder,
+  runTxPlan
+} from "./chunk-W5ODXPY3.js";
+
+// src/runtime.ts
+import { AsyncLocalStorage } from "async_hooks";
+var __requestALS = new AsyncLocalStorage();
+var runtime = null;
+function __setRuntime(services) {
+  runtime = services;
+}
+function __runWithRuntime(services, fn) {
+  return __requestALS.run({ runtime: services }, fn);
+}
+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");
+function makeBucketsAccessor(storage) {
+  return new Proxy(
+    {},
+    {
+      get(_t, prop) {
+        if (typeof prop !== "string") return void 0;
+        return storage().bucket(prop);
+      }
+    }
+  );
+}
+var rawStorage = makeServiceProxy("Storage");
+var Storage = Object.assign(
+  {
+    // FORWARDED explicitly, not assigned onto the service proxy.
+    //
+    // `Object.assign(rawStorage, {buckets})` writes onto the proxy's TARGET, and
+    // the proxy's only trap is `get`, which forwards every read to the module
+    // client — so the property landed somewhere nothing reads and
+    // `Storage.buckets.docs` was `undefined` in a deployed handler. It
+    // typechecked, every test passed, and the live call answered
+    // "TypeError: undefined is not an object". `Database` never had the bug
+    // because it builds a plain surface the same way this now does.
+    bucket: (name) => rawStorage.bucket(name)
+  },
+  { buckets: makeBucketsAccessor(() => rawStorage) }
+);
+var Cache = makeServiceProxy("Cache");
+var Secrets = makeServiceProxy("Secrets");
+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);
+    },
+    /**
+     * Resolve a flag's value, with an optional fallback.
+     *
+     * FORWARDED as of 2026-08-15. This surface is written out by hand, method
+     * by method, and `get` was missing from it — so the client implemented it,
+     * thirty assertions covered it, and `Flags.get("x")` was `undefined` in a
+     * deployed handler. Exactly the shape of the `Storage.buckets` defect found
+     * the same day: a hand-maintained forwarding list is a list somebody has to
+     * remember to update.
+     */
+    get(flagName, defaultOrContext, maybeContext) {
+      return rawFlags.get(flagName, defaultOrContext, maybeContext);
+    },
+    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");
+
+export {
+  __requestALS,
+  __setRuntime,
+  __runWithRuntime,
+  __getRuntime,
+  Database,
+  Documents,
+  Storage,
+  Cache,
+  Secrets,
+  Log,
+  Notifications,
+  Purchases,
+  Flags,
+  Realtime
+};
+//# sourceMappingURL=chunk-POYAFBLF.js.map