@everystack/server 0.2.14 → 0.2.15

package/package.json

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

package/src/plugin.ts

@@ -111,6 +111,14 @@ export interface PluginLambdaHandlerOptions {
   actions?: Record<string, ActionHandler>;
   /** Override default Cache-Control headers */
   cache?: ServerCacheConfig;
+  /**
+   * Serve HTTP. Default true. Set false for an operator Lambda (server/ops.ts):
+   * routes are not built and HTTP-shaped events are rejected with 403 — the
+   * function answers `_action` invokes only. IAM (lambda:InvokeFunction) is the
+   * auth layer. Use with createAdminDb() so the privileged credential lives
+   * here, not in the HTTP-facing API function.
+   */
+  http?: boolean;
 }
 
 // --- Plugin Lambda Handler Implementation ---
@@ -118,9 +126,10 @@ export interface PluginLambdaHandlerOptions {
 export function createPluginLambdaHandler(
   options: PluginLambdaHandlerOptions
 ): (event: APIGatewayProxyEventV2 | Record<string, unknown>) => Promise<APIGatewayProxyStructuredResultV2 | unknown> {
+  const httpEnabled = options.http !== false;
   let cached: {
     ctx: PluginContext;
-    router: (path: string, method: string) => Handler;
+    router?: (path: string, method: string) => Handler;
     actions: Record<string, ActionHandler>;
     logSink?: LogSink;
   } | null = null;
@@ -136,11 +145,6 @@ export function createPluginLambdaHandler(
       contributions.push(await plugin(ctx));
     }
 
-    // Collect routes (plugin order = priority)
-    const pluginRoutes = contributions.flatMap(c => c.routes ?? []);
-    const appRoutes = options.routes?.(ctx) ?? [];
-    const allRoutes = [...pluginRoutes, ...appRoutes];
-
     // Collect actions (app-level takes precedence on collision)
     const pluginActions: Record<string, ActionHandler> = {};
     for (const contribution of contributions) {
@@ -150,6 +154,20 @@ export function createPluginLambdaHandler(
     }
     const allActions = { ...pluginActions, ...(options.actions ?? {}) };
 
+    // Operator mode (http: false) — actions only. Skip routing entirely;
+    // HTTP-shaped events are rejected below. Routes contributed by plugins
+    // are intentionally ignored.
+    if (!httpEnabled) {
+      cached = { ctx, actions: allActions };
+      log('info', 'Plugin handlers initialized (actions only)', { plugins: options.plugins.length });
+      return cached;
+    }
+
+    // Collect routes (plugin order = priority)
+    const pluginRoutes = contributions.flatMap(c => c.routes ?? []);
+    const appRoutes = options.routes?.(ctx) ?? [];
+    const allRoutes = [...pluginRoutes, ...appRoutes];
+
     // Collect log sink (first one wins)
     const logSink = contributions.find(c => c.logSink)?.logSink;
 
@@ -182,6 +200,20 @@ export function createPluginLambdaHandler(
       }
     }
 
+    // Operator mode — reject anything that isn't an `_action` invoke. A caller
+    // with IAM invoke rights can hand the function any event shape; refuse to
+    // route HTTP on the privileged connection.
+    if (!httpEnabled) {
+      if ('requestContext' in event || 'rawPath' in event) {
+        return {
+          statusCode: 403,
+          headers: { 'Content-Type': 'application/json', 'cache-control': 'no-store' },
+          body: JSON.stringify({ error: 'Forbidden' }),
+        };
+      }
+      return { error: 'Missing _action' };
+    }
+
     // HTTP event — Function URL or API Gateway
     const httpEvent = event as APIGatewayProxyEventV2;
     const requestId =
@@ -194,7 +226,7 @@ export function createPluginLambdaHandler(
       const request = eventToRequest(httpEvent);
       const path = httpEvent.rawPath;
       const method = httpEvent.requestContext.http.method;
-      const handlerFn = router(path, method);
+      const handlerFn = router!(path, method);
       const response = await handlerFn(request);
       const result = await responseToResult(response);
 
@@ -285,57 +317,19 @@ export interface OpsLambdaHandlerOptions {
 /**
  * Dedicated operator entrypoint — handles `_action` invokes only.
  *
+ * Thin alias for `createPluginLambdaHandler({ ...options, http: false })`.
  * Deploy as a separate Lambda (server/ops.ts) and link ADMIN_DATABASE_URL to
  * it instead of the API function. IAM (lambda:InvokeFunction) is the auth
- * layer, same as the API _action path. HTTP events are rejected: this
- * function must never be wired to a Function URL or the CDN.
+ * layer; HTTP-shaped events are rejected.
+ *
+ * @deprecated Prefer `createPluginLambdaHandler({ http: false })` directly.
  */
 export function createOpsLambdaHandler(
   options: OpsLambdaHandlerOptions
 ): (event: Record<string, unknown>) => Promise<unknown> {
-  let cached: { ctx: PluginContext; actions: Record<string, ActionHandler> } | null = null;
-
-  async function ensureInitialized() {
-    if (cached) return cached;
-    const ctx = await options.context();
-    const actions: Record<string, ActionHandler> = {};
-    for (const plugin of options.plugins) {
-      const contribution = await plugin(ctx);
-      if (contribution.actions) Object.assign(actions, contribution.actions);
-    }
-    Object.assign(actions, options.actions ?? {});
-    cached = { ctx, actions };
-    log('info', 'Ops handlers initialized', { actions: Object.keys(actions).length });
-    return cached;
-  }
-
-  return async (event: Record<string, unknown>): Promise<unknown> => {
-    if (!('_action' in event) || typeof event._action !== 'string') {
-      // Not an operator invoke. Reject HTTP-shaped events explicitly.
-      if ('requestContext' in event || 'rawPath' in event) {
-        return {
-          statusCode: 403,
-          headers: { 'Content-Type': 'application/json', 'cache-control': 'no-store' },
-          body: JSON.stringify({ error: 'Forbidden' }),
-        };
-      }
-      return { error: 'Missing _action' };
-    }
-
-    const { ctx, actions } = await ensureInitialized();
-    const actionName = event._action as string;
-    const actionHandler = actions[actionName];
-    if (!actionHandler) {
-      return { error: `Unknown action: ${actionName}` };
-    }
-    log('info', 'Ops action invoked', { action: actionName });
-    try {
-      return await actionHandler(event._payload, ctx);
-    } catch (error) {
-      log('error', 'Ops action error', { action: actionName, error: String(error) });
-      return { error: String(error) };
-    }
-  };
+  return createPluginLambdaHandler({ ...options, http: false }) as (
+    event: Record<string, unknown>
+  ) => Promise<unknown>;
 }
 
 // --- SSR Fallback Plugin ---