@spfn/core 0.2.0-beta.53 → 0.2.0-beta.55

package/dist/server/index.js

@@ -8,7 +8,7 @@ import { cors } from 'hono/cors';
 import { registerRoutes } from '@spfn/core/route';
 import { ErrorHandler, RequestLogger } from '@spfn/core/middleware';
 import { streamSSE } from 'hono/streaming';
-import { randomBytes } from 'crypto';
+import { randomBytes, createHash } from 'crypto';
 import { Agent, setGlobalDispatcher } from 'undici';
 import { initDatabase, getDatabase, closeDatabase } from '@spfn/core/db';
 import { initCache, getCache, closeCache } from '@spfn/core/cache';
@@ -445,6 +445,23 @@ function createBoundedWriter(stream, maxQueue, onClose) {
 
 // src/event/sse/handler.ts
 var sseLogger = logger.child("@spfn/core:sse");
+var frameCache = /* @__PURE__ */ new WeakMap();
+function serializeFrame(eventName, payload) {
+  if (payload === null || typeof payload !== "object") {
+    return JSON.stringify({ event: eventName, data: payload });
+  }
+  let byEvent = frameCache.get(payload);
+  if (!byEvent) {
+    byEvent = /* @__PURE__ */ new Map();
+    frameCache.set(payload, byEvent);
+  }
+  let serialized = byEvent.get(eventName);
+  if (serialized === void 0) {
+    serialized = JSON.stringify({ event: eventName, data: payload });
+    byEvent.set(eventName, serialized);
+  }
+  return serialized;
+}
 var DEFAULT_MAX_QUEUE = 1e3;
 function createSSEHandler(router, config = {}, tokenManager) {
   const {
@@ -495,12 +512,14 @@ function createSSEHandler(router, config = {}, tokenManager) {
       let connectionDead = false;
       let pingTimer;
       let writer;
+      let onClosed;
       const cleanup = (reason) => {
         if (connectionDead) return;
         connectionDead = true;
         clearInterval(pingTimer);
         unsubscribes.forEach((fn) => fn());
         writer?.close();
+        onClosed?.();
         sseLogger.info("SSE dead connection cleaned up", {
           events: allowedEvents,
           reason
@@ -530,10 +549,6 @@ function createSSEHandler(router, config = {}, tokenManager) {
             }
           }
           messageId++;
-          const message = {
-            event: eventName,
-            data: payload
-          };
           sseLogger.debug("SSE sending event", {
             event: eventName,
             messageId
@@ -541,7 +556,7 @@ function createSSEHandler(router, config = {}, tokenManager) {
           writer.enqueue({
             id: String(messageId),
             event: eventName,
-            data: JSON.stringify(message)
+            data: serializeFrame(eventName, payload)
           });
         });
         unsubscribes.push(unsubscribe);
@@ -558,8 +573,15 @@ function createSSEHandler(router, config = {}, tokenManager) {
         });
       }, pingInterval);
       const abortSignal = c.req.raw.signal;
-      while (!abortSignal.aborted && !connectionDead) {
-        await stream.sleep(pingInterval);
+      if (!abortSignal.aborted && !connectionDead) {
+        await new Promise((resolve2) => {
+          const onAbort = () => resolve2();
+          abortSignal.addEventListener("abort", onAbort, { once: true });
+          onClosed = () => {
+            abortSignal.removeEventListener("abort", onAbort);
+            resolve2();
+          };
+        });
       }
       cleanup();
     }, async (err) => {
@@ -596,24 +618,28 @@ async function authorizeEvents(subject, requestedEvents, authConfig) {
   }
   return allowed;
 }
+function hashToken(token) {
+  return createHash("sha256").update(token).digest("hex");
+}
 var InMemoryTokenStore = class {
   tokens = /* @__PURE__ */ new Map();
   async set(token, data) {
-    this.tokens.set(token, data);
+    this.tokens.set(hashToken(token), data);
   }
   async consume(token) {
-    const data = this.tokens.get(token);
+    const key = hashToken(token);
+    const data = this.tokens.get(key);
     if (!data) {
       return null;
     }
-    this.tokens.delete(token);
+    this.tokens.delete(key);
     return data;
   }
   async cleanup() {
     const now = Date.now();
-    for (const [token, data] of this.tokens) {
+    for (const [key, data] of this.tokens) {
       if (data.expiresAt <= now) {
-        this.tokens.delete(token);
+        this.tokens.delete(key);
       }
     }
   }
@@ -626,14 +652,14 @@ var CacheTokenStore = class {
   async set(token, data) {
     const ttlSeconds = Math.max(1, Math.ceil((data.expiresAt - Date.now()) / 1e3));
     await this.cache.set(
-      this.prefix + token,
+      this.prefix + hashToken(token),
       JSON.stringify(data),
       "EX",
       ttlSeconds
     );
   }
   async consume(token) {
-    const key = this.prefix + token;
+    const key = this.prefix + hashToken(token);
     let raw = null;
     if (this.cache.getdel) {
       raw = await this.cache.getdel(key);
@@ -668,7 +694,6 @@ var SSETokenManager = class {
   async issue(subject) {
     const token = randomBytes(32).toString("hex");
     await this.store.set(token, {
-      token,
       subject,
       expiresAt: Date.now() + this.ttl
     });
@@ -1372,7 +1397,7 @@ async function applyProxyGuard(app, config) {
   if (mode === "off") {
     return;
   }
-  const { createProxyGuard, createCacheNonceStore } = await import('@spfn/core/middleware');
+  const { createProxyGuard, createCacheNonceStore, createInMemoryNonceStore } = await import('@spfn/core/middleware');
   let nonceStore;
   if (proxyGuardConfig?.nonce) {
     try {
@@ -1382,10 +1407,12 @@ async function applyProxyGuard(app, config) {
         nonceStore = createCacheNonceStore(cache);
         serverLogger.info("Proxy-guard nonce replay rejection: cache (Redis/Valkey)");
       } else {
-        serverLogger.warn("Proxy-guard nonce enabled but no cache available \u2014 using timestamp window only");
+        nonceStore = createInMemoryNonceStore();
+        serverLogger.info("Proxy-guard nonce replay rejection: in-memory (single instance only \u2014 use a cache for multi-instance)");
       }
     } catch {
-      serverLogger.warn("Proxy-guard nonce enabled but cache module unavailable \u2014 using timestamp window only");
+      nonceStore = createInMemoryNonceStore();
+      serverLogger.warn("Proxy-guard nonce: cache module unavailable \u2014 using in-memory store (single instance only)");
     }
   }
   const autoSkip = [config?.healthCheck?.path ?? "/health"];
@@ -1404,6 +1431,7 @@ async function applyProxyGuard(app, config) {
     allowedOrigins: proxyGuardConfig?.allowedOrigins,
     maxBodyBytes: proxyGuardConfig?.maxBodyBytes,
     nonceStore,
+    nonceFailClosed: proxyGuardConfig?.nonceFailClosed,
     skipPaths
   }));
   serverLogger.info(`\u2713 Proxy-guard enabled (mode: ${mode})`);
@@ -1649,9 +1677,7 @@ async function registerJobs(router) {
     }
     jobLogger2.info("Existing jobs cleared");
   }
-  for (const job2 of jobs) {
-    await registerJob(job2);
-  }
+  await Promise.all(jobs.map((job2) => registerJob(job2)));
   jobLogger2.info("All jobs registered successfully");
 }
 async function ensureQueue(boss, queueName) {
@@ -1684,9 +1710,10 @@ async function executeJobHandler(job2, pgBossJob) {
 async function registerWorker(boss, job2, queueName) {
   await ensureQueue(boss, queueName);
   const batchSize = job2.options?.batchSize ?? 1;
+  const pollingIntervalSeconds = job2.options?.pollingIntervalSeconds ?? env.JOB_POLLING_INTERVAL_SECONDS;
   await boss.work(
     queueName,
-    { batchSize },
+    { batchSize, pollingIntervalSeconds },
     async (pgBossJobs) => {
       if (batchSize <= 1) {
         await executeJobHandler(job2, pgBossJobs[0]);
@@ -1764,24 +1791,54 @@ async function registerJob(job2) {
   jobLogger2.debug(`Job registered: ${job2.name}`);
 }
 var wsLogger = logger.child("@spfn/core:ws");
+function isOriginAllowed(origin, allowList) {
+  if (!allowList) {
+    return true;
+  }
+  if (!origin) {
+    return true;
+  }
+  return allowList.has(origin);
+}
 async function attachWSHandler(server, router, config = {}, tokenManager) {
   const WebSocketServer = await loadWSServer();
   const {
     pingInterval = 3e4,
     path = "/ws",
+    maxPayload = 1048576,
+    maxBufferedBytes = 1048576,
+    maxConnections = 1e4,
+    maxConnectionsPerSubject = 0,
+    allowedOrigins,
     auth: authConfig
   } = config;
+  const originAllowList = allowedOrigins && allowedOrigins.length > 0 ? new Set(allowedOrigins) : null;
   if (authConfig?.enabled && !tokenManager) {
     throw new Error(
       "WebSocket auth.enabled=true requires a tokenManager. Pass tokenManager or use .websockets(router, { auth: { enabled: true } }) via startServer."
     );
   }
-  const wss = new WebSocketServer({ server, path });
+  const wss = new WebSocketServer({ server, path, maxPayload });
   const clients = /* @__PURE__ */ new Set();
+  const subjectCounts = /* @__PURE__ */ new Map();
   wss.on("connection", (ws, req) => {
+    if (!isOriginAllowed(req.headers?.origin, originAllowList)) {
+      wsLogger.warn("WebSocket rejected: disallowed origin", { origin: req.headers?.origin });
+      ws.close(1008, "Origin not allowed");
+      return;
+    }
+    if (clients.size >= maxConnections) {
+      ws.close(1013, "Server at capacity");
+      return;
+    }
     clients.add(ws);
     ws.on("close", () => clients.delete(ws));
-    handleConnection(ws, req, router, authConfig, tokenManager, pingInterval).catch((err) => {
+    handleConnection(ws, req, router, authConfig, tokenManager, {
+      pingInterval,
+      maxBufferedBytes,
+      maxConnectionsPerSubject,
+      subjectCounts
+    }).catch((err) => {
       wsLogger.error("WebSocket connection handler error", err);
       if (ws.readyState === 1) ws.close(1011, "Internal server error");
     });
@@ -1804,7 +1861,8 @@ async function attachWSHandler(server, router, config = {}, tokenManager) {
     });
   });
 }
-async function handleConnection(ws, req, router, authConfig, tokenManager, pingInterval) {
+async function handleConnection(ws, req, router, authConfig, tokenManager, opts) {
+  const { pingInterval, maxBufferedBytes, maxConnectionsPerSubject, subjectCounts } = opts;
   let pingTimer;
   let connectionUnsubscribes = [];
   let subscribedEvents = [];
@@ -1838,13 +1896,26 @@ async function handleConnection(ws, req, router, authConfig, tokenManager, pingI
     ws.close(4003, "Not authorized for any requested events");
     return;
   }
+  if (maxConnectionsPerSubject > 0 && typeof subject === "string") {
+    const current = subjectCounts.get(subject) ?? 0;
+    if (current >= maxConnectionsPerSubject) {
+      ws.close(1013, "Too many connections for this subject");
+      return;
+    }
+    subjectCounts.set(subject, current + 1);
+    ws.on("close", () => {
+      const remaining = (subjectCounts.get(subject) ?? 1) - 1;
+      if (remaining <= 0) subjectCounts.delete(subject);
+      else subjectCounts.set(subject, remaining);
+    });
+  }
   subscribedEvents = allowedEvents;
   wsLogger.info("WebSocket connection established", {
     events: allowedEvents,
     subject: subject ?? void 0
   });
-  const connection = createConnection(ws);
-  connectionUnsubscribes = subscribeEvents(ws, router, allowedEvents, subject, authConfig);
+  const connection = createConnection(ws, maxBufferedBytes);
+  connectionUnsubscribes = subscribeEvents(ws, router, allowedEvents, subject, authConfig, maxBufferedBytes);
   if (ws.readyState !== 1) {
     connectionUnsubscribes.forEach((fn) => fn());
     connectionUnsubscribes = [];
@@ -1854,8 +1925,18 @@ async function handleConnection(ws, req, router, authConfig, tokenManager, pingI
     onClientMessage(data, router, connection, subject).catch((err) => wsLogger.error("Unhandled message error", err));
   });
   if (pingInterval > 0) {
+    ws.isAlive = true;
+    ws.on("pong", () => {
+      ws.isAlive = true;
+    });
     pingTimer = setInterval(() => {
-      if (ws.readyState === 1) ws.ping();
+      if (ws.readyState !== 1) return;
+      if (ws.isAlive === false) {
+        ws.terminate();
+        return;
+      }
+      ws.isAlive = false;
+      ws.ping();
     }, pingInterval);
   }
   connection.send("__connected", {
@@ -1894,16 +1975,24 @@ async function resolveAllowedEvents(subject, requestedEvents, authConfig) {
   const allowed = await authConfig.authorize(subject, requestedEvents);
   return allowed.length === 0 ? null : allowed;
 }
-function createConnection(ws) {
+function safeSend(ws, frame, maxBufferedBytes) {
+  if (ws.readyState !== 1) return;
+  if (ws.bufferedAmount > maxBufferedBytes) {
+    ws.close(1013, "Send buffer overflow");
+    return;
+  }
+  try {
+    ws.send(JSON.stringify(frame));
+  } catch {
+  }
+}
+function createConnection(ws, maxBufferedBytes) {
   return {
-    send: (type, payload) => {
-      if (ws.readyState !== 1) return;
-      ws.send(JSON.stringify({ type, data: payload }));
-    },
+    send: (type, payload) => safeSend(ws, { type, data: payload }, maxBufferedBytes),
     close: (code, reason) => ws.close(code, reason)
   };
 }
-function subscribeEvents(ws, router, allowedEvents, subject, authConfig) {
+function subscribeEvents(ws, router, allowedEvents, subject, authConfig, maxBufferedBytes) {
   const unsubscribes = [];
   for (const eventName of allowedEvents) {
     const eventDef = router.events[eventName];
@@ -1913,10 +2002,7 @@ function subscribeEvents(ws, router, allowedEvents, subject, authConfig) {
       if (subject && authConfig?.filter?.[eventName]) {
         if (!authConfig.filter[eventName](subject, payload)) return;
       }
-      try {
-        ws.send(JSON.stringify({ type: eventName, data: payload }));
-      } catch {
-      }
+      safeSend(ws, { type: eventName, data: payload }, maxBufferedBytes);
     });
     unsubscribes.push(unsubscribe);
   }