@everystack/server 0.2.9 → 0.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everystack/server",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Server runtime primitives for Lambda — event adapters, routing, SSR, image processing",
   "license": "AGPL-3.0-only",
   "publishConfig": {

package/src/db.ts

@@ -1,21 +1,57 @@
 /// <reference path="./sst-env.d.ts" />
 /**
- * @everystack/server/db — SST Resource-linked database helpers.
+ * @everystack/server/db — Database and secret helpers.
  *
- * Provides a lazy singleton Drizzle connection using SST Resource linking
- * for database credentials and secrets.
+ * Provides a lazy singleton Drizzle connection. Supports both SST Resource
+ * linking (PascalCase names) and process.env (SCREAMING_SNAKE_CASE names)
+ * transparently. Works with createSecrets() or manual sst.Secret declarations.
  */
 
 import { Resource } from 'sst';
 import { drizzle } from 'drizzle-orm/postgres-js';
 import postgres from 'postgres';
 
+/**
+ * Safely read a Resource property. Returns undefined if the Resource
+ * or property doesn't exist (avoids runtime throw from SST's proxy).
+ */
+function tryResource<T>(fn: () => T): T | undefined {
+  try {
+    const val = fn();
+    // SST's Resource proxy may return undefined for missing keys
+    return val === undefined ? undefined : val;
+  } catch {
+    return undefined;
+  }
+}
+
 export function getDatabaseUrl(): string {
-  return `postgresql://${Resource.Database.username}:${Resource.Database.password}@${Resource.Database.host}:${Resource.Database.port}/${Resource.Database.database}`;
+  // SST Postgres component (Resource.Database)
+  const db = tryResource(() => Resource.Database);
+  if (db?.host) {
+    return `postgresql://${db.username}:${db.password}@${db.host}:${db.port}/${db.database}`;
+  }
+  // SST Secret — PascalCase (Resource.DatabaseUrl.value)
+  const pascal = tryResource(() => (Resource as any).DatabaseUrl?.value as string);
+  if (pascal) return pascal;
+  // SST Secret — raw env name (Resource.DATABASE_URL.value)
+  const raw = tryResource(() => (Resource as any).DATABASE_URL?.value as string);
+  if (raw) return raw;
+  // process.env fallback
+  if (process.env.DATABASE_URL) return process.env.DATABASE_URL;
+  throw new Error('DATABASE_URL not set — link an sst.aws.Postgres or sst.Secret, or set process.env.DATABASE_URL');
 }
 
 export function getJwtSecret(): Uint8Array {
-  return new TextEncoder().encode(Resource.JwtSecret.value);
+  // PascalCase Resource (Resource.JwtSecret.value)
+  const pascal = tryResource(() => (Resource as any).JwtSecret?.value as string);
+  if (pascal) return new TextEncoder().encode(pascal);
+  // Raw env name Resource (Resource.JWT_SECRET.value)
+  const raw = tryResource(() => (Resource as any).JWT_SECRET?.value as string);
+  if (raw) return new TextEncoder().encode(raw);
+  // process.env fallback
+  if (process.env.JWT_SECRET) return new TextEncoder().encode(process.env.JWT_SECRET);
+  throw new Error('JWT_SECRET not set — link an sst.Secret or set process.env.JWT_SECRET');
 }
 
 // Lazy singleton DB connection

package/src/plugin.ts

@@ -466,9 +466,13 @@ export function dbPlugin(options: DbPluginOptions): Plugin {
           const { eq, and, or, gt, lt, gte, lte, ne, count, sum, avg, sql, desc, asc } =
             await import('drizzle-orm');
           const evalContext: Record<string, unknown> = {
+            ctx,
             db: ctx.db, schema: ctx.schema,
             eq, and, or, gt, lt, gte, lte, ne, count, sum, avg, sql, desc, asc,
           };
+          // Expose plugin-contributed context (notifications, rpc, etc.)
+          if (ctx.notifications) evalContext.notifications = ctx.notifications;
+          if (ctx.rpc) evalContext.rpc = ctx.rpc;
           const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
           const fn = new AsyncFunction(
             ...Object.keys(evalContext),

package/src/sst-env.d.ts

@@ -4,9 +4,14 @@
 /**
  * SST Resource type declarations for @everystack/server/db.
  *
- * Augments the `sst` module's Resource interface with the shapes
- * expected by db.ts. Consumers must link matching SST resources
- * (e.g., sst.aws.Postgres named "Database", sst.Secret named "JwtSecret").
+ * Augments the `sst` module's Resource interface with shapes expected
+ * by db.ts. Both PascalCase (JwtSecret) and SCREAMING_SNAKE_CASE
+ * (JWT_SECRET) naming conventions are supported at runtime — db.ts
+ * tries each in order and falls back to process.env.
+ *
+ * Consumers link matching SST resources in sst.config.ts:
+ *   - sst.aws.Postgres named "Database"
+ *   - sst.Secret named "JwtSecret" or "JWT_SECRET"
  */
 declare module 'sst' {
   export interface Resource {
@@ -20,6 +25,7 @@ declare module 'sst' {
     JwtSecret: {
       value: string;
     };
+    [key: string]: any;
   }
 }