@palbase/backend 2.0.2 → 3.0.0

package/dist/index.cjs

@@ -28,14 +28,19 @@ __export(src_exports, {
   Log: () => Log,
   Notifications: () => Notifications,
   Queue: () => Queue,
+  Resource: () => Resource,
   Storage: () => Storage,
   __getRuntime: () => __getRuntime,
+  __registerResource: () => __registerResource,
   __requestALS: () => __requestALS,
+  __runResourceBoot: () => __runResourceBoot,
   __runWithRuntime: () => __runWithRuntime,
   __setRuntime: () => __setRuntime,
+  __shutdownResources: () => __shutdownResources,
   auth: () => auth,
   boolean: () => boolean,
-  defineEndpoint: () => defineEndpoint,
+  defineController: () => defineController,
+  defineHandler: () => defineHandler,
   defineJob: () => defineJob,
   defineMiddleware: () => defineMiddleware,
   defineSchema: () => defineSchema,
@@ -45,54 +50,19 @@ __export(src_exports, {
   enumType: () => enumType,
   integer: () => integer,
   jsonb: () => jsonb,
+  makeEnvDts: () => makeEnvDts,
   makeTypedDB: () => makeTypedDB,
+  route: () => route,
   storage: () => storage,
-  table: () => table,
   text: () => text,
   timestamp: () => timestamp,
-  typedDatabase: () => typedDatabase,
   uuid: () => uuid,
   z: () => import_zod.z
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/endpoint.ts
-function defineEndpoint(config) {
-  return config;
-}
-
 // src/runtime.ts
 var import_node_async_hooks = require("async_hooks");
-
-// src/db/typed-db.ts
-function makeTypedTable(name, raw) {
-  return {
-    insert: (data) => raw.insert(name, data),
-    update: (id, data) => raw.update(name, id, data),
-    delete: (id) => raw.delete(name, id),
-    findById: (id) => raw.findById(name, id),
-    findMany: (query) => raw.findMany(name, query)
-  };
-}
-function makeTypedDB(schema, raw) {
-  function buildTables(client) {
-    const tables = {};
-    for (const key of Object.keys(schema.tables)) {
-      const tableDef = schema.tables[key];
-      if (tableDef !== void 0) {
-        tables[key] = makeTypedTable(tableDef.name, client);
-      }
-    }
-    return tables;
-  }
-  const result = {
-    tables: buildTables(raw),
-    transaction: (fn) => raw.transaction((rawTx) => fn({ tables: buildTables(rawTx) }))
-  };
-  return result;
-}
-
-// src/runtime.ts
 var __requestALS = new import_node_async_hooks.AsyncLocalStorage();
 var runtime = null;
 function __setRuntime(services) {
@@ -121,7 +91,47 @@ function makeServiceProxy(key) {
   };
   return new Proxy({}, handler);
 }
-var Database = makeServiceProxy("Database");
+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");
+var Database = Object.assign(
+  // Spread the raw ops onto a fresh object so the added `tables`/typed
+  // `transaction` members live alongside them. Each op still forwards through
+  // the request-scoped runtime Proxy.
+  {
+    query: (sql, params) => rawDatabase.query(sql, params),
+    insert: (table, data) => rawDatabase.insert(table, data),
+    update: (table, id, data) => rawDatabase.update(table, id, data),
+    delete: (table, id) => rawDatabase.delete(table, id),
+    findById: (table, id) => rawDatabase.findById(table, id),
+    findMany: (table, query) => rawDatabase.findMany(table, query)
+  },
+  {
+    tables: makeTablesAccessor(() => rawDatabase),
+    transaction(fn) {
+      return rawDatabase.transaction(
+        (rawTx) => fn({ tables: makeTablesAccessor(() => rawTx) })
+      );
+    }
+  }
+);
 var Documents = makeServiceProxy("Documents");
 var Storage = makeServiceProxy("Storage");
 var Cache = makeServiceProxy("Cache");
@@ -129,25 +139,13 @@ var Queue = makeServiceProxy("Queue");
 var Log = makeServiceProxy("Log");
 var Notifications = makeServiceProxy("Notifications");
 var Flags = makeServiceProxy("Flags");
-function typedDatabase(schema) {
-  const typed = makeTypedDB(schema, Database);
-  const rawOps = {
-    query: (sql, params) => Database.query(sql, params),
-    insert: (table2, data) => Database.insert(table2, data),
-    update: (table2, id, data) => Database.update(table2, id, data),
-    delete: (table2, id) => Database.delete(table2, id),
-    findById: (table2, id) => Database.findById(table2, id),
-    findMany: (table2, q) => Database.findMany(table2, q),
-    transaction: (fn) => Database.transaction(fn)
-  };
-  return Object.assign(rawOps, typed);
-}
 
 // src/db/schema.ts
-function table(name, columns) {
-  return { name, columns };
-}
-function defineSchema(tables) {
+function defineSchema(input) {
+  const tables = {};
+  for (const name of Object.keys(input.tables)) {
+    tables[name] = { name, columns: input.tables[name] };
+  }
   return { tables };
 }
 
@@ -192,8 +190,8 @@ var ColumnBuilder = class _ColumnBuilder {
     return new _ColumnBuilder(this._def.type, this._def);
   }
   /** Add a foreign key reference. */
-  references(table2, column) {
-    this._def.references = { table: table2, column };
+  references(table, column) {
+    this._def.references = { table, column };
     return new _ColumnBuilder(this._def.type, this._def);
   }
   /** Set the ON DELETE action for a foreign key reference. */
@@ -227,6 +225,125 @@ function enumType(name, values) {
   return builder;
 }
 
+// src/db/typed-db.ts
+function makeTypedTable(name, raw) {
+  return {
+    insert: (data) => raw.insert(name, data),
+    update: (id, data) => raw.update(name, id, data),
+    delete: (id) => raw.delete(name, id),
+    findById: (id) => raw.findById(name, id),
+    findMany: (query) => raw.findMany(name, query)
+  };
+}
+function makeTypedDB(schema, raw) {
+  function buildTables(client) {
+    const tables = {};
+    for (const key of Object.keys(schema.tables)) {
+      const tableDef = schema.tables[key];
+      if (tableDef !== void 0) {
+        tables[key] = makeTypedTable(tableDef.name, client);
+      }
+    }
+    return tables;
+  }
+  const result = {
+    tables: buildTables(raw),
+    transaction: (fn) => raw.transaction((rawTx) => fn({ tables: buildTables(rawTx) }))
+  };
+  return result;
+}
+
+// src/db/env-gen.ts
+function baseTsType(def) {
+  switch (def.type) {
+    case "uuid":
+    case "text":
+    case "timestamp":
+      return "string";
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "jsonb":
+      return "unknown";
+    case "enum": {
+      const values = def.enumValues ?? [];
+      if (values.length === 0) return "string";
+      return values.map((v) => JSON.stringify(v)).join(" | ");
+    }
+    default:
+      return "unknown";
+  }
+}
+function rowType(def) {
+  const base = baseTsType(def);
+  return def.nullable ? `${base} | null` : base;
+}
+function optionalOnInsert(def) {
+  return def.nullable === true || def.defaultRandom === true || def.defaultNow === true || def.defaultValue !== void 0;
+}
+function tableBlock(table, indent) {
+  const cols = Object.entries(table.columns);
+  const rowLines = cols.map(([col, builder]) => {
+    return `${indent}    ${col}: ${rowType(builder._def)};`;
+  });
+  const insertLines = cols.map(([col, builder]) => {
+    const def = builder._def;
+    const opt = optionalOnInsert(def) ? "?" : "";
+    return `${indent}    ${col}${opt}: ${rowType(def)};`;
+  });
+  return [
+    `${indent}${table.name}: {`,
+    `${indent}  row: {`,
+    ...rowLines,
+    `${indent}  };`,
+    `${indent}  insert: {`,
+    ...insertLines,
+    `${indent}  };`,
+    `${indent}};`
+  ].join("\n");
+}
+function makeEnvDts(schema) {
+  const tableNames = Object.keys(schema.tables);
+  const blocks = tableNames.map((name) => tableBlock(schema.tables[name], "    "));
+  const body = blocks.length > 0 ? `
+${blocks.join("\n")}
+  ` : "";
+  return `// AUTO-GENERATED by @palbase/backend \u2014 DO NOT EDIT.
+// Regenerated from db/schema.ts on every \`palbase serve\` / deploy.
+// Augments the @palbase/backend/env \`Tables\` interface so \`Database.tables.*\`
+// is typed with no import and no generic.
+
+declare module "@palbase/backend/env" {
+  interface Tables {${body}}
+}
+
+export {};
+`;
+}
+
+// src/handler.ts
+function defineHandler(config) {
+  return { __palbase: "handler", ...config };
+}
+
+// src/controller.ts
+function makeRoute(method) {
+  return function(path, handler) {
+    return { __palbase: "route", method, path, handler };
+  };
+}
+var route = {
+  get: makeRoute("GET"),
+  post: makeRoute("POST"),
+  put: makeRoute("PUT"),
+  patch: makeRoute("PATCH"),
+  delete: makeRoute("DELETE")
+};
+function defineController(basePath, routes) {
+  return { __palbase: "controller", basePath, routes };
+}
+
 // src/middleware.ts
 function defineMiddleware(fn) {
   return fn;
@@ -486,6 +603,52 @@ function validateCustomWebhook(config) {
   };
 }
 
+// src/resource.ts
+var Resource = class {
+  /** The env-var names this resource needs. Optional; omit for none. */
+  static secrets;
+};
+function hasSecrets(value) {
+  if (typeof value !== "object" && typeof value !== "function") return false;
+  const secrets = value.secrets;
+  return secrets === void 0 || Array.isArray(secrets);
+}
+var registry = [];
+function __registerResource(resource) {
+  registry.push({ resource, booted: false });
+}
+function declaredSecrets(resource) {
+  const ctor = resource.constructor;
+  return hasSecrets(ctor) ? ctor.secrets ?? [] : [];
+}
+async function __runResourceBoot(envMap) {
+  for (const entry of registry) {
+    if (entry.booted) continue;
+    const secrets = declaredSecrets(entry.resource);
+    const env = {};
+    for (const name of secrets) {
+      const value = envMap[name];
+      if (value === void 0) {
+        throw new Error(
+          `Resource ${entry.resource.constructor.name} requires secret "${name}" but it is not set. Set it with \`palbase secret set ${name} ...\` (or in Studio) and redeploy.`
+        );
+      }
+      env[name] = value;
+    }
+    await entry.resource.init(env);
+    entry.booted = true;
+  }
+}
+async function __shutdownResources() {
+  for (let i = registry.length - 1; i >= 0; i -= 1) {
+    const entry = registry[i];
+    if (entry.booted && entry.resource.shutdown) {
+      await entry.resource.shutdown();
+    }
+  }
+  registry.length = 0;
+}
+
 // src/hooks.ts
 var auth = {
   onUserCreated(handler) {
@@ -533,14 +696,19 @@ var import_zod = require("zod");
   Log,
   Notifications,
   Queue,
+  Resource,
   Storage,
   __getRuntime,
+  __registerResource,
   __requestALS,
+  __runResourceBoot,
   __runWithRuntime,
   __setRuntime,
+  __shutdownResources,
   auth,
   boolean,
-  defineEndpoint,
+  defineController,
+  defineHandler,
   defineJob,
   defineMiddleware,
   defineSchema,
@@ -550,12 +718,12 @@ var import_zod = require("zod");
   enumType,
   integer,
   jsonb,
+  makeEnvDts,
   makeTypedDB,
+  route,
   storage,
-  table,
   text,
   timestamp,
-  typedDatabase,
   uuid,
   z
 });