@spfn/core 0.2.0-beta.42 → 0.2.0-beta.44

package/dist/server/index.js

@@ -438,15 +438,28 @@ function createSSEHandler(router, config = {}, tokenManager) {
       subject: subject || void 0,
       clientIp: c.req.header("x-forwarded-for") || c.req.header("x-real-ip")
     });
+    c.header("X-Accel-Buffering", "no");
     return streamSSE(c, async (stream) => {
       const unsubscribes = [];
       let messageId = 0;
+      let connectionDead = false;
+      let pingTimer;
+      const cleanup = () => {
+        if (connectionDead) return;
+        connectionDead = true;
+        clearInterval(pingTimer);
+        unsubscribes.forEach((fn) => fn());
+        sseLogger.info("SSE dead connection cleaned up", {
+          events: allowedEvents
+        });
+      };
       for (const eventName of allowedEvents) {
         const eventDef = router.events[eventName];
         if (!eventDef) {
           continue;
         }
         const unsubscribe = eventDef.subscribe((payload) => {
+          if (connectionDead) return;
           if (subject && authConfig?.filter?.[eventName]) {
             if (!authConfig.filter[eventName](subject, payload)) {
               return;
@@ -461,10 +474,17 @@ function createSSEHandler(router, config = {}, tokenManager) {
             event: eventName,
             messageId
           });
-          void stream.writeSSE({
+          stream.writeSSE({
             id: String(messageId),
             event: eventName,
             data: JSON.stringify(message)
+          }).catch((err) => {
+            sseLogger.warn("SSE write failed", {
+              event: eventName,
+              messageId,
+              error: err.message
+            });
+            cleanup();
           });
         });
         unsubscribes.push(unsubscribe);
@@ -480,21 +500,23 @@ function createSSEHandler(router, config = {}, tokenManager) {
           timestamp: Date.now()
         })
       });
-      const pingTimer = setInterval(() => {
-        void stream.writeSSE({
+      pingTimer = setInterval(() => {
+        if (connectionDead) return;
+        stream.writeSSE({
           event: "ping",
           data: JSON.stringify({ timestamp: Date.now() })
+        }).catch((err) => {
+          sseLogger.warn("SSE ping failed", {
+            error: err.message
+          });
+          cleanup();
         });
       }, pingInterval);
       const abortSignal = c.req.raw.signal;
-      while (!abortSignal.aborted) {
+      while (!abortSignal.aborted && !connectionDead) {
         await stream.sleep(pingInterval);
       }
-      clearInterval(pingTimer);
-      unsubscribes.forEach((fn) => fn());
-      sseLogger.info("SSE connection closed", {
-        events: allowedEvents
-      });
+      cleanup();
     }, async (err) => {
       sseLogger.error("SSE stream error", {
         error: err.message
@@ -1285,36 +1307,53 @@ async function registerJobs(router) {
 async function ensureQueue(boss, queueName) {
   await boss.createQueue(queueName);
 }
+async function executeJobHandler(job2, pgBossJob) {
+  jobLogger2.debug(`[Job:${job2.name}] Executing...`, { jobId: pgBossJob.id });
+  const startTime = Date.now();
+  try {
+    if (job2.inputSchema) {
+      await job2.handler(pgBossJob.data);
+    } else {
+      await job2.handler();
+    }
+    const duration = Date.now() - startTime;
+    jobLogger2.info(`[Job:${job2.name}] Completed in ${duration}ms`, {
+      jobId: pgBossJob.id,
+      duration
+    });
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    jobLogger2.error(`[Job:${job2.name}] Failed after ${duration}ms`, {
+      jobId: pgBossJob.id,
+      duration,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    throw error;
+  }
+}
 async function registerWorker(boss, job2, queueName) {
   await ensureQueue(boss, queueName);
+  const batchSize = job2.options?.batchSize ?? 1;
   await boss.work(
     queueName,
-    { batchSize: 1 },
-    async (jobs) => {
-      for (const pgBossJob of jobs) {
-        jobLogger2.debug(`[Job:${job2.name}] Executing...`, { jobId: pgBossJob.id });
-        const startTime = Date.now();
-        try {
-          if (job2.inputSchema) {
-            await job2.handler(pgBossJob.data);
-          } else {
-            await job2.handler();
-          }
-          const duration = Date.now() - startTime;
-          jobLogger2.info(`[Job:${job2.name}] Completed in ${duration}ms`, {
-            jobId: pgBossJob.id,
-            duration
-          });
-        } catch (error) {
-          const duration = Date.now() - startTime;
-          jobLogger2.error(`[Job:${job2.name}] Failed after ${duration}ms`, {
-            jobId: pgBossJob.id,
-            duration,
-            error: error instanceof Error ? error.message : String(error)
-          });
-          throw error;
+    { batchSize },
+    async (pgBossJobs) => {
+      if (batchSize <= 1) {
+        await executeJobHandler(job2, pgBossJobs[0]);
+        return;
+      }
+      const results = await Promise.allSettled(
+        pgBossJobs.map((pgBossJob) => executeJobHandler(job2, pgBossJob))
+      );
+      const failedIds = [];
+      for (let i = 0; i < results.length; i++) {
+        if (results[i].status === "rejected") {
+          failedIds.push(pgBossJobs[i].id);
         }
       }
+      if (failedIds.length > 0) {
+        await boss.fail(queueName, failedIds);
+      }
     }
   );
 }