@palbase/backend 9.0.1 → 10.1.0

package/dist/index.js

@@ -31,7 +31,7 @@ import {
   text,
   timestamp,
   uuid
-} from "./chunk-SO6YV35D.js";
+} from "./chunk-4WOQWFUP.js";
 
 // src/db/env-gen.ts
 function baseTsType(def) {
@@ -64,7 +64,50 @@ function rowType(def) {
 function optionalOnInsert(def) {
   return def.nullable === true || def.defaultRandom === true || def.defaultNow === true || def.defaultValue !== void 0;
 }
-function tableBlock(table, indent) {
+var AUTH_USERS_TABLE = "auth.users";
+function ownerColumnOf(table) {
+  for (const [col, builder] of Object.entries(table.columns)) {
+    if (builder._def.references?.table === AUTH_USERS_TABLE) return col;
+  }
+  return null;
+}
+function buildChildEdges(schema) {
+  const edges = /* @__PURE__ */ new Map();
+  for (const name of Object.keys(schema.tables)) edges.set(name, []);
+  for (const childName of Object.keys(schema.tables)) {
+    const table = schema.tables[childName];
+    if (table === void 0) continue;
+    for (const [col, builder] of Object.entries(table.columns)) {
+      const ref = builder._def.references;
+      if (ref === void 0) continue;
+      if (ref.table === childName) continue;
+      const bucket2 = edges.get(ref.table);
+      if (bucket2 === void 0) continue;
+      if (bucket2.some((e) => e.child === childName)) continue;
+      bucket2.push({ child: childName, column: col });
+    }
+  }
+  return edges;
+}
+function pruneCycles(raw2) {
+  const pruned = /* @__PURE__ */ new Map();
+  for (const table of raw2.keys()) pruned.set(table, []);
+  const state = /* @__PURE__ */ new Map();
+  function visit(table) {
+    state.set(table, "visiting");
+    for (const edge of raw2.get(table) ?? []) {
+      if (state.get(edge.child) === "visiting") continue;
+      pruned.get(table)?.push(edge);
+      if (state.get(edge.child) === void 0) visit(edge.child);
+    }
+    state.set(table, "done");
+  }
+  for (const table of raw2.keys()) {
+    if (state.get(table) === void 0) visit(table);
+  }
+  return pruned;
+}
+function tableBlock(table, children, indent) {
   const cols = Object.entries(table.columns);
   const rowLines = cols.map(([col, builder]) => {
     return `${indent}    ${col}: ${rowType(builder._def)};`;
@@ -74,6 +117,8 @@ function tableBlock(table, indent) {
     const opt = optionalOnInsert(def) ? "?" : "";
     return `${indent}    ${col}${opt}: ${rowType(def)};`;
   });
+  const owner = ownerColumnOf(table);
+  const childEntries = children.map((e) => `${JSON.stringify(e.child)}: ${JSON.stringify(e.column)}`).join("; ");
   return [
     `${indent}${table.name}: {`,
     `${indent}  row: {`,
@@ -82,12 +127,17 @@ function tableBlock(table, indent) {
     `${indent}  insert: {`,
     ...insertLines,
     `${indent}  };`,
+    `${indent}  owner: ${owner === null ? "null" : JSON.stringify(owner)};`,
+    `${indent}  children: {${childEntries === "" ? "" : ` ${childEntries} `}};`,
     `${indent}};`
   ].join("\n");
 }
 function makeEnvDts(schema) {
   const tableNames = Object.keys(schema.tables);
-  const blocks = tableNames.map((name) => tableBlock(schema.tables[name], "    "));
+  const children = pruneCycles(buildChildEdges(schema));
+  const blocks = tableNames.map(
+    (name) => tableBlock(schema.tables[name], children.get(name) ?? [], "    ")
+  );
   const body = blocks.length > 0 ? `
 ${blocks.join("\n")}
   ` : "";
@@ -182,6 +232,22 @@ function defineStorage(input) {
   return { __config: STORAGE_CONFIG_KIND, buckets };
 }
 
+// src/config/egress.ts
+var EGRESS_CONFIG_KIND = "egress";
+function defineEgress(input) {
+  if (input === null || typeof input !== "object" || !Array.isArray(input.hosts)) {
+    throw new Error("defineEgress expects { hosts: string[] }");
+  }
+  const hosts = [];
+  for (const h of input.hosts) {
+    if (typeof h !== "string" || h.trim().length === 0) {
+      throw new Error("defineEgress: every host must be a non-empty string");
+    }
+    hosts.push(h.trim().toLowerCase());
+  }
+  return { __config: EGRESS_CONFIG_KIND, hosts };
+}
+
 // src/config/notifications.ts
 var NOTIFICATIONS_CONFIG_KIND = "notifications";
 var RESERVED_SECRET_PREFIX = "PB_NOTIFICATIONS";
@@ -293,6 +359,124 @@ function camelToUpperSnake(s) {
   return s.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
 }
 
+// src/config/test-users.ts
+var TEST_USERS_CONFIG_KIND = "test-users";
+var TEST_USER_NAME_RE = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var E164_RE = /^\+[1-9]\d{1,14}$/;
+var OTP_LENGTH = 6;
+var OTP_RE = /^\d{6}$/;
+var MIN_PASSWORD_LENGTH = 8;
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeSeed(seed, userName) {
+  if (seed === void 0) return {};
+  if (!isPlainObject(seed)) {
+    throw new Error(`testUser ${JSON.stringify(userName)}: seed must be { <table>: [ {...} ] }`);
+  }
+  const out = {};
+  for (const [table, rows] of Object.entries(seed)) {
+    if (!Array.isArray(rows)) {
+      throw new Error(
+        `testUser ${JSON.stringify(userName)}: seed.${table} must be an array of rows`
+      );
+    }
+    if (rows.length === 0) {
+      throw new Error(
+        `testUser ${JSON.stringify(userName)}: seed.${table} is empty \u2014 remove it or add a row`
+      );
+    }
+    for (const row of rows) {
+      if (!isPlainObject(row)) {
+        throw new Error(
+          `testUser ${JSON.stringify(userName)}: every row in seed.${table} must be an object`
+        );
+      }
+    }
+    out[table] = rows;
+  }
+  return out;
+}
+function testUser(opts = {}) {
+  if (!isPlainObject(opts)) {
+    throw new Error("testUser() expects { email?, password?, phone?, otp?, seed? }");
+  }
+  const hasEmail = opts.email !== void 0;
+  const hasPassword = opts.password !== void 0;
+  if (hasEmail !== hasPassword) {
+    throw new Error(
+      "testUser() needs email AND password together (a fixture with stable credentials) or neither (a template the server generates credentials for)"
+    );
+  }
+  let email = null;
+  let password = null;
+  if (hasEmail) {
+    if (typeof opts.email !== "string" || !EMAIL_RE.test(opts.email)) {
+      throw new Error(`testUser email ${JSON.stringify(opts.email)} is not a valid address`);
+    }
+    if (typeof opts.password !== "string" || opts.password.length < MIN_PASSWORD_LENGTH) {
+      throw new Error(
+        `testUser password must be at least ${MIN_PASSWORD_LENGTH} characters (got ${typeof opts.password === "string" ? opts.password.length : 0})`
+      );
+    }
+    email = opts.email;
+    password = opts.password;
+  }
+  const hasPhone = opts.phone !== void 0;
+  const hasOTP = opts.otp !== void 0;
+  if (hasPhone !== hasOTP) {
+    throw new Error(
+      "testUser() needs phone AND otp together \u2014 nothing can receive an SMS at a fabricated number, so a phone fixture without its fixed code can never be signed in as"
+    );
+  }
+  let phone = null;
+  let otp = null;
+  if (hasPhone) {
+    if (typeof opts.phone !== "string" || !E164_RE.test(opts.phone)) {
+      throw new Error(
+        `testUser phone ${JSON.stringify(opts.phone)} must be E.164, e.g. "+905551112233"`
+      );
+    }
+    if (typeof opts.otp !== "string" || !OTP_RE.test(opts.otp)) {
+      throw new Error(
+        `testUser otp ${JSON.stringify(opts.otp)} must be ${OTP_LENGTH} digits`
+      );
+    }
+    phone = opts.phone;
+    otp = opts.otp;
+  }
+  return { email, password, phone, otp, seed: normalizeSeed(opts.seed, email ?? "<template>") };
+}
+function defineTestUsers(input) {
+  if (!isPlainObject(input) || !isPlainObject(input.users)) {
+    throw new Error("defineTestUsers expects { users: { <name>: testUser({...}) } }");
+  }
+  const users = {};
+  const emails = /* @__PURE__ */ new Map();
+  for (const name of Object.keys(input.users)) {
+    if (!TEST_USER_NAME_RE.test(name)) {
+      throw new Error(
+        `test user name ${JSON.stringify(name)} is invalid \u2014 must start with a letter and contain only letters, digits, and underscores`
+      );
+    }
+    const def = input.users[name];
+    if (def === void 0) continue;
+    if (def.email !== null) {
+      const lower = def.email.toLowerCase();
+      const already = emails.get(lower);
+      if (already !== void 0) {
+        throw new Error(
+          `test users ${JSON.stringify(already)} and ${JSON.stringify(name)} declare the same e-mail ${JSON.stringify(def.email)}`
+        );
+      }
+      emails.set(lower, name);
+    }
+    users[name] = def;
+  }
+  return { __config: TEST_USERS_CONFIG_KIND, users };
+}
+
 // src/config/flags.ts
 var FLAGS_CONFIG_KIND = "flags";
 var FLAG_KEY_RE = /^[a-zA-Z][a-zA-Z0-9_]*$/;
@@ -465,6 +649,33 @@ function recordThrows(target, fnName, throws) {
   const throwsBuffer = carrier[THROWS_BUFFER];
   if (throwsBuffer) throwsBuffer[fnName] = throws;
 }
+function getRoutes(ctor) {
+  const carrier = carrierOf(ctor);
+  const routes = carrier[ROUTES] ?? [];
+  const returnBuffer = carrier[RETURN_BUFFER];
+  if (returnBuffer) {
+    for (const route of routes) {
+      const buffered = returnBuffer[route.fnName];
+      if (buffered && route.returnSchema === void 0) {
+        route.returnSchema = buffered;
+      }
+    }
+  }
+  const throwsBuffer = carrier[THROWS_BUFFER];
+  if (throwsBuffer) {
+    for (const route of routes) {
+      const buffered = throwsBuffer[route.fnName];
+      if (buffered && route.throws === void 0) {
+        route.throws = buffered;
+      }
+    }
+  }
+  return routes.map((r) => ({
+    ...r,
+    params: r.params.slice(),
+    ...r.throws !== void 0 ? { throws: r.throws.slice() } : {}
+  }));
+}
 
 // src/decorators/methods.ts
 function makeMethodDecorator(method) {
@@ -1076,6 +1287,7 @@ export {
   Database,
   Delete,
   Documents,
+  EGRESS_CONFIG_KIND,
   EXTENSION_DEPENDENCIES,
   FLAGS_CONFIG_KIND,
   Flags,
@@ -1106,6 +1318,7 @@ export {
   Resource,
   STORAGE_CONFIG_KIND,
   Storage,
+  TEST_USERS_CONFIG_KIND,
   TooManyRequests,
   TraceId,
   Unauthorized,
@@ -1124,6 +1337,7 @@ export {
   boolean,
   bucket,
   buildProvider,
+  defineEgress,
   defineError,
   defineFlags,
   defineJob,
@@ -1131,12 +1345,14 @@ export {
   defineNotifications,
   defineSchema,
   defineStorage,
+  defineTestUsers,
   defineWebhook,
   defineWorker,
   documents,
   enumType,
   flag,
   getErrorRegistry,
+  getRoutes,
   integer,
   isPalbaseExtension,
   jsonb,
@@ -1149,6 +1365,7 @@ export {
   recordThrows,
   reservedSecretKey,
   storage,
+  testUser,
   text,
   timestamp,
   uuid,