@spfn/core 0.3.0-beta.27 → 0.3.0-beta.28

package/dist/server/index.js

@@ -429,7 +429,15 @@ function loadEnvFiles() {
 function createBoundedWriter(stream, maxQueue, onClose) {
   const pending = [];
   let flushing = false;
+  let reserved = 0;
   let closed = false;
+  const overflows = () => {
+    if (pending.length + reserved <= maxQueue) {
+      return false;
+    }
+    onClose("outbound queue overflow (slow consumer)");
+    return true;
+  };
   const flush = async () => {
     if (flushing || closed) {
       return;
@@ -453,11 +461,19 @@ function createBoundedWriter(stream, maxQueue, onClose) {
         return;
       }
       pending.push(frame);
-      if (pending.length > maxQueue) {
-        onClose("outbound queue overflow (slow consumer)");
-        return;
+      if (!overflows()) {
+        void flush();
       }
-      void flush();
+    },
+    reserve() {
+      if (closed) {
+        return false;
+      }
+      reserved++;
+      return !overflows();
+    },
+    clearReserved() {
+      reserved = 0;
     },
     close() {
       closed = true;
@@ -709,7 +725,7 @@ async function authorizeConnection(c, router, authConfig, subject, requested) {
     subject: subject || void 0,
     clientIp: c.req.header("x-forwarded-for") || c.req.header("x-real-ip")
   });
-  return { subject, requested, allowed, denied, request };
+  return { subject, requested, allowed, denied, request, principal: resolved.principal };
 }
 async function resolveConnectionPrincipal(subject, request, authConfig) {
   if (!subject || !authConfig?.resolvePrincipal) {
@@ -765,6 +781,16 @@ async function runStream(c, stream, admission, config) {
     sseLogger.warn("SSE connection closed", { events: [...connection.allowed], reason });
     cleanup(reason);
   });
+  const hold = createFrameHold(writer);
+  const subscriberContext = {
+    router: config.router,
+    authConfig: config.authConfig,
+    subject,
+    request,
+    writeFrame: createFrameWriter(writer),
+    send: hold.send,
+    isDead: () => connectionDead
+  };
   const connection = {
     subject,
     requested: admission.requested,
@@ -772,45 +798,61 @@ async function runStream(c, stream, admission, config) {
     denied: new Set(denied),
     unsubscribes: /* @__PURE__ */ new Map(),
     request,
-    subscribe: createEventSubscriber({
-      router: config.router,
-      authConfig: config.authConfig,
-      subject,
-      request,
-      writer,
-      isDead: () => connectionDead
-    }),
+    subscribe: createEventSubscriber(subscriberContext),
     notify: (frame, eventName) => {
       if (connectionDead) return;
-      writer.enqueue({ event: frame, data: JSON.stringify({ event: eventName }) });
+      hold.send(() => writer.enqueue({ event: frame, data: JSON.stringify({ event: eventName }) }));
     }
   };
   if (admission.pending?.open(connection) === false) {
     cleanup("aborted during admission");
     return;
   }
-  openSubscriptions(connection, writer);
+  void openSubscriptions(connection, writer, hold, {
+    ...subscriberContext,
+    principal: admission.principal
+  });
   pingTimer = setInterval(() => {
     if (connectionDead) return;
-    writer.enqueue({
+    hold.send(() => writer.enqueue({
       event: "ping",
       data: JSON.stringify({ timestamp: Date.now() })
-    });
+    }));
   }, config.pingInterval);
   await waitForDisconnect(c.req.raw.signal, () => connectionDead, (resolve2) => {
     onClosed = resolve2;
   });
   cleanup();
 }
-function openSubscriptions(connection, writer) {
+async function openSubscriptions(connection, writer, hold, ctx) {
+  const connected = { subscribedEvents: [...connection.allowed], deniedEvents: [...connection.denied] };
+  const producing = connected.subscribedEvents.filter((eventName) => ctx.router.events[eventName]._initial);
+  if (!ctx.subject || producing.length === 0) {
+    enqueueConnected(writer, { ...connected, initial: [] });
+    subscribeAllowed(connection);
+    return;
+  }
+  hold.hold();
+  subscribeAllowed(connection);
+  const served = await produceInitialFrames(producing, ctx.router, {
+    subject: ctx.subject,
+    principal: ctx.principal,
+    request: ctx.request
+  });
+  if (ctx.isDead()) {
+    return;
+  }
+  enqueueConnected(writer, { ...connected, initial: served.map(({ eventName }) => eventName) });
+  served.forEach(({ eventName, frames }) => frames.forEach((data) => ctx.writeFrame(eventName, data)));
+  hold.release();
+}
+function enqueueConnected(writer, connected) {
   writer.enqueue({
     event: "connected",
-    data: JSON.stringify({
-      subscribedEvents: [...connection.allowed],
-      deniedEvents: [...connection.denied],
-      timestamp: Date.now()
-    })
+    data: JSON.stringify({ ...connected, timestamp: Date.now() })
   });
+}
+function subscribeAllowed(connection) {
   for (const eventName of connection.allowed) {
     connection.unsubscribes.set(eventName, connection.subscribe(eventName));
   }
@@ -820,6 +862,54 @@ function openSubscriptions(connection, writer) {
     subscriptionCount: connection.unsubscribes.size
   });
 }
+async function produceInitialFrames(events, router, ctx) {
+  const results = await Promise.all(events.map((eventName) => askInitial(eventName, router.events[eventName], ctx)));
+  return results.filter((frames) => frames !== null);
+}
+async function askInitial(eventName, eventDef, ctx) {
+  try {
+    const payloads = await eventDef._initial(ctx);
+    return { eventName, frames: payloads.map((payload) => serializeFrame(eventName, payload)) };
+  } catch {
+    sseLogger.warn("SSE initial frames could not be produced \u2014 none sent for this event", {
+      event: eventName,
+      subject: ctx.subject
+    });
+    return null;
+  }
+}
+function createFrameHold(writer) {
+  let pending = null;
+  return {
+    send: (write) => {
+      if (!pending) {
+        write();
+      } else if (writer.reserve()) {
+        pending.push(write);
+      }
+    },
+    hold: () => {
+      pending = [];
+    },
+    release: () => {
+      const held = pending ?? [];
+      pending = null;
+      writer.clearReserved();
+      held.forEach((write) => write());
+    }
+  };
+}
+function createFrameWriter(writer) {
+  let messageId = 0;
+  return (eventName, data) => {
+    messageId++;
+    sseLogger.debug("SSE sending event", {
+      event: eventName,
+      messageId
+    });
+    writer.enqueue({ id: String(messageId), event: eventName, data });
+  };
+}
 async function waitForDisconnect(abortSignal, isDead, onServerClose) {
   if (abortSignal.aborted || isDead()) {
     return;
@@ -834,7 +924,6 @@ async function waitForDisconnect(abortSignal, isDead, onServerClose) {
   });
 }
 function createEventSubscriber(ctx) {
-  let messageId = 0;
   return (eventName) => {
     const eventDef = ctx.router.events[eventName];
     let active = true;
@@ -842,16 +931,8 @@ function createEventSubscriber(ctx) {
       if (!active || ctx.isDead() || !passesFrameFilters(eventName, eventDef, payload, ctx)) {
         return;
       }
-      messageId++;
-      sseLogger.debug("SSE sending event", {
-        event: eventName,
-        messageId
-      });
-      ctx.writer.enqueue({
-        id: String(messageId),
-        event: eventName,
-        data: serializeFrame(eventName, payload)
-      });
+      const data = serializeFrame(eventName, payload);
+      ctx.send(() => ctx.writeFrame(eventName, data));
     });
     return () => {
       active = false;