@everystack/server 0.4.4 → 0.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everystack/server",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Server runtime primitives for Lambda — event adapters, routing, SSR, image processing",
   "license": "AGPL-3.0-only",
   "author": "Scalable Technology, Inc. <licensing@scalable.technology>",
@@ -61,6 +61,10 @@
       "types": "./src/plugin.ts",
       "default": "./src/plugin.ts"
     },
+    "./provision": {
+      "types": "./src/provision.ts",
+      "default": "./src/provision.ts"
+    },
     "./cdn": {
       "types": "./src/cdn/index.ts",
       "default": "./src/cdn/index.ts"
@@ -152,8 +156,8 @@
     "ts-jest": "29.4.9",
     "typescript": "5.9.3",
     "@everystack/auth": "0.4.0",
-    "@everystack/cli": "0.4.18",
-    "@everystack/pg-tools": "0.4.0"
+    "@everystack/pg-tools": "0.4.0",
+    "@everystack/cli": "0.4.20"
   },
   "scripts": {
     "test": "jest",

package/src/db.ts

@@ -7,24 +7,41 @@
  * 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).
+ * Read an SST-linked resource WITHOUT importing the `sst` package. SST injects
+ * every link as `process.env.SST_RESOURCE_<Name>` (a JSON blob) — SST's own
+ * Resource proxy just parses that env var (see sst/dist/resource/shared.js:
+ * `raw[name] = JSON.parse(process.env['SST_RESOURCE_' + name])`). Reading it
+ * directly means this module never imports `sst`, which is a deploy-time
+ * construct: Metro/esbuild cannot bundle it, and SST's own build-time
+ * version-check plugin mis-reads a node_module's `sst` import and fails the
+ * build. So the API/SSR helpers stayed unbundleable in the exact runtime half
+ * the framework targets. Returns undefined when the link is absent — every
+ * getter then falls through to process.env, unchanged.
  */
-function tryResource<T>(fn: () => T): T | undefined {
+function sstLink<T = Record<string, any>>(name: string): T | undefined {
+  const raw = process.env[`SST_RESOURCE_${name}`];
+  if (!raw) return undefined;
   try {
-    const val = fn();
-    // SST's Resource proxy may return undefined for missing keys
-    return val === undefined ? undefined : val;
+    return JSON.parse(raw) as T;
   } catch {
     return undefined;
   }
 }
 
+/**
+ * Read ANY SST-linked resource by name, without importing `sst` — the
+ * bundler-safe replacement for `Resource.<Name>` (e.g. `sstResource('Updates')?.name`
+ * for the ssrPlugin's updatesStorage bucket). Undefined when the link is absent,
+ * so callers can fall through to process.env or their own config.
+ */
+export function sstResource<T = Record<string, any>>(name: string): T | undefined {
+  return sstLink<T>(name);
+}
+
 export function getDatabaseUrl(): string {
   // An EXPLICIT DATABASE_URL wins over the component-derived master. This is what
   // lets the API connection be a least-privilege role (`authenticator`) while the SST
@@ -32,11 +49,11 @@ export function getDatabaseUrl(): string {
   // resolved first, setting DATABASE_URL to a least-privilege role would be silently
   // ignored. See docs/plans/credential-split-rls-everywhere.md.
 
-  // SST Secret — PascalCase (Resource.DatabaseUrl.value)
-  const pascal = tryResource(() => (Resource as any).DatabaseUrl?.value as string);
+  // SST Secret — PascalCase (SST_RESOURCE_DatabaseUrl → { value })
+  const pascal = sstLink('DatabaseUrl')?.value as string | undefined;
   if (pascal) return pascal;
-  // SST Secret — raw env name (Resource.DATABASE_URL.value)
-  const raw = tryResource(() => (Resource as any).DATABASE_URL?.value as string);
+  // SST Secret — raw env name (SST_RESOURCE_DATABASE_URL → { value })
+  const raw = sstLink('DATABASE_URL')?.value as string | undefined;
   if (raw) return raw;
   // process.env fallback
   if (process.env.DATABASE_URL) return process.env.DATABASE_URL;
@@ -54,8 +71,25 @@ export function getDatabaseUrl(): string {
  * no dedicated ADMIN_DATABASE_URL is provisioned — kept separate from getDatabaseUrl() so the
  * operator path never accidentally resolves the least-privilege DATABASE_URL secret.
  */
+export interface DatabaseComponentInfo {
+  username: string;
+  password: string;
+  host: string;
+  port: number;
+  database: string;
+}
+
+/**
+ * The linked SST Postgres component's connection fields, or null when none is linked.
+ * The single reader of the `Database` link — callers that only need host/port/database
+ * (db:psql, provision probe) use this instead of importing `sst`.
+ */
+export function getDatabaseComponentInfo(): DatabaseComponentInfo | null {
+  return sstLink<DatabaseComponentInfo>('Database') ?? null;
+}
+
 export function getMasterDatabaseUrl(): string | null {
-  const db = tryResource(() => Resource.Database);
+  const db = getDatabaseComponentInfo();
   if (db?.host) {
     return `postgresql://${db.username}:${db.password}@${db.host}:${db.port}/${db.database}`;
   }
@@ -73,11 +107,11 @@ export function getMasterDatabaseUrl(): string | null {
  * Returns null when no admin URL is configured (single-credential setup).
  */
 export function getAdminDatabaseUrl(): string | null {
-  // SST Secret — PascalCase (Resource.AdminDatabaseUrl.value)
-  const pascal = tryResource(() => (Resource as any).AdminDatabaseUrl?.value as string);
+  // SST Secret — PascalCase (SST_RESOURCE_AdminDatabaseUrl → { value })
+  const pascal = sstLink('AdminDatabaseUrl')?.value as string | undefined;
   if (pascal) return pascal;
-  // SST Secret — raw env name (Resource.ADMIN_DATABASE_URL.value)
-  const raw = tryResource(() => (Resource as any).ADMIN_DATABASE_URL?.value as string);
+  // SST Secret — raw env name (SST_RESOURCE_ADMIN_DATABASE_URL → { value })
+  const raw = sstLink('ADMIN_DATABASE_URL')?.value as string | undefined;
   if (raw) return raw;
   // process.env fallback
   if (process.env.ADMIN_DATABASE_URL) return process.env.ADMIN_DATABASE_URL;
@@ -85,11 +119,11 @@ export function getAdminDatabaseUrl(): string | null {
 }
 
 export function getJwtSecret(): Uint8Array {
-  // PascalCase Resource (Resource.JwtSecret.value)
-  const pascal = tryResource(() => (Resource as any).JwtSecret?.value as string);
+  // PascalCase Secret (SST_RESOURCE_JwtSecret → { value })
+  const pascal = sstLink('JwtSecret')?.value as string | undefined;
   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);
+  // Raw env name Secret (SST_RESOURCE_JWT_SECRET → { value })
+  const raw = sstLink('JWT_SECRET')?.value as string | undefined;
   if (raw) return new TextEncoder().encode(raw);
   // process.env fallback
   if (process.env.JWT_SECRET) return new TextEncoder().encode(process.env.JWT_SECRET);
@@ -288,11 +322,11 @@ export function getAdminSql(): ReturnType<typeof postgres> {
  * different host. Returns null when no replica is configured.
  */
 export function getReadDatabaseUrl(): string | null {
-  // SST Secret — PascalCase (Resource.ReadDatabaseUrl.value)
-  const pascal = tryResource(() => (Resource as any).ReadDatabaseUrl?.value as string);
+  // SST Secret — PascalCase (SST_RESOURCE_ReadDatabaseUrl → { value })
+  const pascal = sstLink('ReadDatabaseUrl')?.value as string | undefined;
   if (pascal) return pascal;
-  // SST Secret — raw env name (Resource.READ_DATABASE_URL.value)
-  const raw = tryResource(() => (Resource as any).READ_DATABASE_URL?.value as string);
+  // SST Secret — raw env name (SST_RESOURCE_READ_DATABASE_URL → { value })
+  const raw = sstLink('READ_DATABASE_URL')?.value as string | undefined;
   if (raw) return raw;
   // process.env fallback
   if (process.env.READ_DATABASE_URL) return process.env.READ_DATABASE_URL;

package/src/plugin.ts

@@ -42,8 +42,8 @@ export interface PluginContext {
   verifyToken: (token: string) => Promise<Record<string, unknown> | null>;
   /** Runtime environment */
   environment: string;
-  /** Publish a background job */
-  publishJob: (type: string, payload: unknown, options?: { schedulable?: boolean; runAt?: Date }) => Promise<string>;
+  /** Publish a background job. Optional — a lean app with no @everystack/jobs never sets it. */
+  publishJob?: (type: string, payload: unknown, options?: { schedulable?: boolean; runAt?: Date }) => Promise<string>;
   /** Cancel a scheduled job */
   cancelJob?: (jobId: string) => Promise<void>;
   /** Reschedule a pending job */
@@ -460,8 +460,9 @@ export function ssrPlugin(options: SsrPluginOptions = {}): (ctx: PluginContext)
 // --- Database Actions Plugin ---
 
 export interface DbPluginOptions {
-  /** Absolute path to drizzle migrations folder */
-  migrationsFolder: string;
+  /** Absolute path to drizzle migrations folder. Optional — a db:sync app has no migrations;
+   *  migrate/db:reset then answer with a clear error while provision/console/psql still work. */
+  migrationsFolder?: string;
   /** App-provided seed function — action only registered if provided */
   seed?: (db: any, schema: any) => Promise<any>;
   /** PostgreSQL schemas to drop during db:reset (default: ['public', 'drizzle']) */
@@ -553,8 +554,15 @@ export function dbPlugin(options: DbPluginOptions): Plugin {
       return { deps: { bucket, region: options.backupRegion ?? process.env.AWS_REGION, adminUrl } };
     };
 
+    // The migration-backed actions stay in the inventory even without a migrationsFolder —
+    // an explanatory error beats "Unknown action" pointing the operator the wrong way.
+    const NO_MIGRATIONS_ERROR =
+      'no migrationsFolder configured — this app has no migrations (db:sync manages its schema). '
+      + 'To use migrations, pass migrationsFolder to dbPlugin.';
+
     // --- migrate ---
     actions.migrate = async (_payload, _ctx) => {
+      if (!options.migrationsFolder) return { error: NO_MIGRATIONS_ERROR };
       const { runMigrations } = await import('./migrate');
       return await runMigrations(opsDb, options.migrationsFolder);
     };
@@ -575,6 +583,9 @@ export function dbPlugin(options: DbPluginOptions): Plugin {
       if (ctx.environment !== 'dev') {
         return { error: 'db:reset is only available in dev environment' };
       }
+      // Refuse BEFORE the drop: reset replays migrations after wiping the schemas — with no
+      // migrations there is nothing to rebuild from, and the drop would strand the database.
+      if (!options.migrationsFolder) return { error: NO_MIGRATIONS_ERROR };
       const { sql } = await import('drizzle-orm');
       const schemas = options.schemas ?? ['public', 'drizzle'];
       const dropStatements = schemas
@@ -596,18 +607,12 @@ export function dbPlugin(options: DbPluginOptions): Plugin {
       if (options.connectionInfo) {
         return await options.connectionInfo();
       }
-      try {
-        const { Resource } = await import('sst');
-        return {
-          host: (Resource as any).Database.host,
-          port: (Resource as any).Database.port,
-          database: (Resource as any).Database.database,
-          username: (Resource as any).Database.username,
-          password: (Resource as any).Database.password,
-        };
-      } catch {
+      const { getDatabaseComponentInfo } = await import('./db');
+      const db = getDatabaseComponentInfo();
+      if (!db) {
         return { error: 'No connectionInfo callback provided and SST Resource.Database not available' };
       }
+      return { host: db.host, port: db.port, database: db.database, username: db.username, password: db.password };
     };
 
     // --- db:query ---
@@ -778,13 +783,10 @@ export function dbPlugin(options: DbPluginOptions): Plugin {
           connection = { host: info.host, port: info.port, database: info.database };
         }
       } else {
-        try {
-          const { Resource } = await import('sst');
-          const db = (Resource as any).Database;
-          if (db?.host) connection = { host: db.host, port: db.port, database: db.database };
-        } catch {
-          // No linked component and no callback — the admin login lands unverified.
-        }
+        const { getDatabaseComponentInfo } = await import('./db');
+        const db = getDatabaseComponentInfo();
+        // No linked component and no callback — the admin login lands unverified.
+        if (db?.host) connection = { host: db.host, port: db.port, database: db.database };
       }
 
       return await runProvision(