@luckystack/sync 0.13.0 → 0.15.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   SYNC_ERROR_CODES
-} from "./chunk-AJ36D2PQ.js";
+} from "./chunk-IFVFF47D.js";
 
 // src/handleSyncRequest.ts
 import { randomUUID } from "crypto";
@@ -10,7 +10,6 @@ import {
   getRuntimeSyncMaps,
   validateRequest,
   extractTokenFromSocket,
-  formatRoomName as formatRoomName2,
   getIoInstance as getIoInstance2,
   tryCatch as tryCatch2,
   parseTransportRouteName,
@@ -35,7 +34,6 @@ import {
 // src/_shared/streamEmitters.ts
 import {
   dispatchHook,
-  formatRoomName,
   getIoInstance,
   getLogger,
   getProjectConfig as getProjectConfig2,
@@ -54,8 +52,20 @@ var redactToken = (token) => {
   if (token.length <= VISIBLE_PREFIX) return token;
   return `${token.slice(0, VISIBLE_PREFIX)}\u2026`;
 };
+var redactTokenRoom = (receiver, knownTokens) => {
+  if (!knownTokens.some((token) => Boolean(token) && token === receiver)) return receiver;
+  return redactToken(receiver) ?? receiver;
+};
 var redactTokens = (tokens) => tokens.map((t) => redactToken(t) ?? t);
 
+// src/_shared/physicalReceiver.ts
+import { formatRoomName } from "@luckystack/core";
+var resolvePhysicalReceiver = (receiver, { token, userId }) => {
+  if (receiver === "all") return "all";
+  if (token && receiver === token) return receiver;
+  return formatRoomName(receiver, { purpose: "broadcast", userId });
+};
+
 // src/_shared/streamEmitters.ts
 var DEFAULT_THRESHOLD_BYTES = 1048576;
 var AVG_PACKET_BYTES = 1024;
@@ -103,8 +113,8 @@ var collectRoomSocketsForPressure = (receiver) => {
   return out;
 };
 var buildSyncStreamEmitters = ({
-  cb,
   receiver,
+  token,
   userId,
   resolvedName,
   emitOriginatorChunk,
@@ -112,7 +122,7 @@ var buildSyncStreamEmitters = ({
   signal,
   originatorSocket
 }) => {
-  const physicalReceiver = !receiver || receiver === "all" ? receiver : formatRoomName(receiver, { purpose: "broadcast", userId: userId ?? null });
+  const physicalReceiver = receiver ? resolvePhysicalReceiver(receiver, { token, userId: userId ?? null }) : receiver;
   const chunkCounters = /* @__PURE__ */ new Map();
   const bumpChunkIndex = (recipient) => {
     const next = (chunkCounters.get(recipient) ?? 0) + 1;
@@ -126,7 +136,7 @@ var buildSyncStreamEmitters = ({
   };
   const buildBroadcastFrame = (payload) => ({
     ...payload,
-    cb,
+    cb: resolvedName,
     fullName: resolvedName,
     status: "stream"
   });
@@ -159,7 +169,12 @@ var buildSyncStreamEmitters = ({
     const io = getIoInstance();
     if (!io) return;
     dispatchStreamHooks(receiver, payload);
-    io.to(physicalReceiver).emit(socketEventNames.sync, buildBroadcastFrame(payload));
+    const frame = buildBroadcastFrame(payload);
+    if (physicalReceiver === "all") {
+      io.emit(socketEventNames.sync, frame);
+      return;
+    }
+    io.to(physicalReceiver).emit(socketEventNames.sync, frame);
   };
   const emitStreamToTokens = (tokens, payload = {}) => {
     if (isAborted()) {
@@ -254,7 +269,6 @@ var processClientSyncForRecipient = async ({
   serverOutput,
   receiver,
   resolvedName,
-  callbackKey,
   transport,
   handlerName,
   logLabel,
@@ -270,7 +284,7 @@ var processClientSyncForRecipient = async ({
     }
     tempSocket.emit(socketEventNames2.sync, {
       ...payload,
-      cb: callbackKey,
+      cb: resolvedName,
       fullName: resolvedName,
       status: "stream"
     });
@@ -288,14 +302,17 @@ var processClientSyncForRecipient = async ({
       //? a usable credential (defeats HttpOnly-cookie mode). The 4-char prefix
       //? still correlates error events.
       targetToken: redactToken(tempToken),
-      receiver,
+      //? A token room's name IS the token: every socket in it carries that
+      //? token, so comparing against the recipient's token catches any token
+      //? room, not only the originator's own.
+      receiver: redactTokenRoom(receiver, [tempToken]),
       transport
     }
   );
   const preferred = resolvePreferredLocale(tempSocket.handshake.headers);
   if (clientSyncError) {
     tempSocket.emit(socketEventNames2.sync, {
-      cb: callbackKey,
+      cb: resolvedName,
       fullName: resolvedName,
       ...buildSyncError({
         response: { status: "error", errorCode: "sync.clientExecutionFailed" },
@@ -306,7 +323,7 @@ var processClientSyncForRecipient = async ({
   }
   if (clientSyncResult?.status === "error") {
     tempSocket.emit(socketEventNames2.sync, {
-      cb: callbackKey,
+      cb: resolvedName,
       fullName: resolvedName,
       ...buildSyncError({
         response: ensureSyncErrorShape(clientSyncResult),
@@ -317,7 +334,7 @@ var processClientSyncForRecipient = async ({
   }
   if (clientSyncResult?.status !== "success") {
     tempSocket.emit(socketEventNames2.sync, {
-      cb: callbackKey,
+      cb: resolvedName,
       fullName: resolvedName,
       ...buildSyncError({
         response: { status: "error", errorCode: "sync.invalidClientResponse" },
@@ -327,7 +344,7 @@ var processClientSyncForRecipient = async ({
     return;
   }
   const result = {
-    cb: callbackKey,
+    cb: resolvedName,
     fullName: resolvedName,
     serverOutput,
     clientOutput: clientSyncResult,
@@ -661,6 +678,7 @@ function runReceiverAuth({
   buildSyncError,
   preferredLocale,
   user,
+  token,
   cleanupRequest
 }) {
   const syncConfig = getProjectConfig3().sync;
@@ -674,9 +692,7 @@ function runReceiverAuth({
     //? NOT the raw client `receiver`. Otherwise a non-identity
     //? registerRoomNameFormatter (multi-tenant) makes every joined member fail the
     //? check on the socket transport while HTTP still works.
-    isMember: () => socket.rooms.has(
-      receiver === "all" ? "all" : formatRoomName2(receiver, { purpose: "broadcast", userId: user?.id ?? null })
-    )
+    isMember: () => socket.rooms.has(resolvePhysicalReceiver(receiver, { token, userId: user?.id ?? null }))
   });
   if (!receiverAuth.allowed) {
     if (shouldLogDev()) {
@@ -750,7 +766,8 @@ async function runSyncServerExecution({
   emitBroadcastSyncStream,
   emitStreamToTokens,
   flushPressure,
-  abortController
+  abortController,
+  token
 }) {
   if (!serverSyncEntry) return { ok: true, serverOutput: {} };
   const { main: serverMain, inputType, inputTypeFilePath } = serverSyncEntry;
@@ -856,7 +873,8 @@ async function runSyncServerExecution({
       sync: resolvedName,
       stage: "server",
       userId: user?.id,
-      receiver,
+      //? A sync to your own token room carries the bearer token as `receiver`.
+      receiver: redactTokenRoom(receiver, [token]),
       transport: "socket"
     }
   );
@@ -902,13 +920,14 @@ async function resolveSyncRecipients({
   receiver,
   resolvedName,
   user,
+  token,
   socket,
   responseIndex,
   buildSyncError,
   preferredLocale,
   cleanupRequest
 }) {
-  const physicalReceiver = receiver === "all" ? "all" : formatRoomName2(receiver, { purpose: "broadcast", userId: user?.id ?? null });
+  const physicalReceiver = resolvePhysicalReceiver(receiver, { token, userId: user?.id ?? null });
   const sockets = physicalReceiver === "all" ? await ioInstance.fetchSockets() : await ioInstance.in(physicalReceiver).fetchSockets();
   if (sockets.length === 0) {
     if (shouldLogDev()) {
@@ -1008,14 +1027,10 @@ async function runSyncFanout({
         functionsObject,
         serverOutput: effectiveServerOutput,
         receiver,
+        //? Recipient frames are keyed on `resolvedName` inside the helper (SYNC
+        //? security: no client `cb` reaches another socket). The client `cb`
+        //? stays only for the originator's own cancel handshake.
         resolvedName,
-        //? Server-authoritative callback key (SYNC security): route recipient
-        //? callbacks off the SERVER-resolved route, never the client-supplied
-        //? `cb`. Otherwise a room co-member could send a legit `name` but a `cb`
-        //? for a DIFFERENT route and fire other clients' handlers for that route
-        //? (cross-route callback spoofing). The client `cb` stays only for the
-        //? originator's own cancel handshake.
-        callbackKey: resolvedName,
         transport: "socket",
         handlerName: "handleSyncRequest",
         logLabel: "sync",
@@ -1110,8 +1125,8 @@ async function handleSyncRequestInner({ msg, socket, token }) {
   const [handlerError] = await tryCatch2(async () => {
     if (!checkRouteExists({ syncObject, resolvedName, name, socket, responseIndex, buildSyncError, preferredLocale, user, cleanupRequest })) return;
     const { emitServerSyncStream, emitBroadcastSyncStream, emitStreamToTokens, flushPressure } = buildSyncStreamEmitters({
-      cb,
       receiver,
+      token,
       userId: user?.id ?? null,
       resolvedName,
       logLabel: "sync",
@@ -1125,7 +1140,7 @@ async function handleSyncRequestInner({ msg, socket, token }) {
     const serverSyncEntry = syncObject[`${resolvedName}_server`];
     currentPerRouteFormatter = serverSyncEntry?.errorFormatter;
     if (!runSyncAuth({ serverSyncEntry, user, resolvedName, socket, responseIndex, buildSyncError, preferredLocale, cleanupRequest })) return;
-    if (!runReceiverAuth({ receiver, resolvedName, socket, responseIndex, buildSyncError, preferredLocale, user, cleanupRequest })) return;
+    if (!runReceiverAuth({ receiver, resolvedName, socket, responseIndex, buildSyncError, preferredLocale, user, token, cleanupRequest })) return;
     const rateLimitOk = await applySyncRateLimits({
       resolvedName,
       token,
@@ -1146,6 +1161,7 @@ async function handleSyncRequestInner({ msg, socket, token }) {
       receiver,
       resolvedName,
       user,
+      token,
       socket,
       responseIndex,
       buildSyncError,
@@ -1169,7 +1185,8 @@ async function handleSyncRequestInner({ msg, socket, token }) {
       emitBroadcastSyncStream,
       emitStreamToTokens,
       flushPressure,
-      abortController
+      abortController,
+      token
     });
     if (!executionResult.ok) return;
     const { serverOutput } = executionResult;
@@ -1199,7 +1216,7 @@ async function handleSyncRequestInner({ msg, socket, token }) {
     sync: currentRouteName,
     stage: "handler",
     userId: currentUserId,
-    receiver,
+    receiver: redactTokenRoom(receiver, [token]),
     transport: "socket"
   });
   if (handlerError) {
@@ -1223,7 +1240,6 @@ import {
   getRuntimeSyncMaps as getRuntimeSyncMapsFromSource,
   validateRequest as validateRequest2,
   extractTokenFromSocket as extractTokenFromSocket2,
-  formatRoomName as formatRoomName3,
   getIoInstance as getIoInstance3,
   tryCatch as tryCatch3,
   parseTransportRouteName as parseTransportRouteName2,
@@ -1319,7 +1335,7 @@ var applyHttpSyncRateLimits = async ({
   return null;
 };
 async function stageResolveRoute(ctx) {
-  const { name, cb, data, normalizedReceiver, user, buildSyncError, preferredLocale } = ctx;
+  const { name, data, normalizedReceiver, user, buildSyncError, preferredLocale } = ctx;
   if (!name || typeof name !== "string") {
     return {
       error: buildSyncError({
@@ -1353,7 +1369,6 @@ async function stageResolveRoute(ctx) {
     };
   }
   const resolvedName = parsedRoute.normalizedFullName;
-  const callbackName = typeof cb === "string" && cb.trim().length > 0 ? cb.trim() : `${parsedRoute.serviceRoute.normalizedRouteName}/${parsedRoute.version}`;
   if (!normalizedReceiver) {
     return {
       error: buildSyncError({
@@ -1385,7 +1400,7 @@ async function stageResolveRoute(ctx) {
       })
     };
   }
-  return { resolvedName, callbackName };
+  return { resolvedName };
 }
 function stageCheckAuth(serverSyncEntry, ctx) {
   const { user, preferredLocale, buildSyncError } = ctx;
@@ -1538,11 +1553,11 @@ async function stageValidateInput(resolvedName, serverSyncEntry, ctx) {
   return null;
 }
 async function stageExecuteServer(resolvedName, serverSyncEntry, functionsObject, ctx) {
-  const { data, normalizedReceiver, user, preferredLocale, buildSyncError, effectiveAbortSignal, cb, stream } = ctx;
+  const { data, normalizedReceiver, user, preferredLocale, buildSyncError, effectiveAbortSignal, token, stream } = ctx;
   const { main: serverMain } = serverSyncEntry;
   const { emitServerSyncStream, emitBroadcastSyncStream, emitStreamToTokens, flushPressure } = buildSyncStreamEmitters({
-    cb,
     receiver: normalizedReceiver,
+    token,
     userId: user?.id ?? null,
     resolvedName,
     logLabel: "http sync",
@@ -1601,7 +1616,8 @@ async function stageExecuteServer(resolvedName, serverSyncEntry, functionsObject
       userId: user?.id,
       //? Bug fix: was `name` (the raw route-name string) — should be
       //? `normalizedReceiver` to match the field's semantics and the socket handler.
-      receiver: normalizedReceiver,
+      //? A sync to your own token room carries the bearer token as `receiver`.
+      receiver: redactTokenRoom(normalizedReceiver, [token]),
       transport: "http"
     }
   );
@@ -1639,9 +1655,9 @@ async function stageExecuteServer(resolvedName, serverSyncEntry, functionsObject
   return { serverOutput: serverSyncResult };
 }
 async function stageResolveRecipients(resolvedName, ctx) {
-  const { normalizedReceiver, user, buildSyncError, preferredLocale } = ctx;
+  const { normalizedReceiver, token, user, buildSyncError, preferredLocale } = ctx;
   const ioInstance = getIoInstance3();
-  const physicalReceiver = normalizedReceiver === "all" ? "all" : formatRoomName3(normalizedReceiver, { purpose: "broadcast", userId: user?.id ?? null });
+  const physicalReceiver = resolvePhysicalReceiver(normalizedReceiver, { token, userId: user?.id ?? null });
   const sockets = physicalReceiver === "all" ? await ioInstance.fetchSockets() : await ioInstance.in(physicalReceiver).fetchSockets();
   if (sockets.length === 0) {
     if (shouldLogDev()) {
@@ -1657,7 +1673,7 @@ async function stageResolveRecipients(resolvedName, ctx) {
   }
   return { sockets };
 }
-async function stageFanout(resolvedName, callbackName, serverOutput, sockets, syncObject, functionsObject, ctx) {
+async function stageFanout(resolvedName, serverOutput, sockets, syncObject, functionsObject, ctx) {
   const { data, normalizedReceiver, token, ignoreSelf, user, buildSyncError, preferredLocale } = ctx;
   if (shouldLogDev() && token && getProjectConfig4().sync.requireRoomMembership && normalizedReceiver !== "all" && normalizedReceiver !== token && !sockets.some((recipient) => extractTokenFromSocket2(recipient) === token)) {
     getLogger4().warn(
@@ -1676,87 +1692,91 @@ async function stageFanout(resolvedName, callbackName, serverOutput, sockets, sy
   };
   const preFanoutResult = await dispatchHook3("preSyncFanout", fanoutPayload);
   if (preFanoutResult.stopped) {
-    return buildSyncError({
-      response: {
-        status: "error",
-        errorCode: preFanoutResult.signal.errorCode,
-        httpStatus: preFanoutResult.signal.httpStatus
-      },
-      preferred: preferredLocale,
-      userLanguage: user?.language
-    });
+    return {
+      error: buildSyncError({
+        response: {
+          status: "error",
+          errorCode: preFanoutResult.signal.errorCode,
+          httpStatus: preFanoutResult.signal.httpStatus
+        },
+        preferred: preferredLocale,
+        userLanguage: user?.language
+      })
+    };
   }
-  let recipientCount = 0;
-  const { fanoutYieldEvery, fanoutYieldMs } = getProjectConfig4().sync;
-  const yieldEvery = Math.max(1, fanoutYieldEvery);
-  let fanoutIterCount = 1;
-  for (const tempSocket of sockets) {
-    fanoutIterCount++;
-    if (fanoutIterCount % yieldEvery === 0) {
-      await new Promise((resolve) => setTimeout(resolve, fanoutYieldMs));
-    }
-    const tempToken = extractTokenFromSocket2(tempSocket);
-    if (ignoreSelf && typeof ignoreSelf === "boolean" && token && token === tempToken) {
-      continue;
-    }
-    const preRecipientResult = await dispatchHook3("preSyncRecipient", {
-      routeName: resolvedName,
-      receiver: normalizedReceiver,
-      recipientSocketId: tempSocket.id,
-      recipientToken: tempToken,
-      recipientUserId: null,
-      serverOutput
-    });
-    if (preRecipientResult.stopped && preRecipientResult.signal.overrideOutput === void 0) {
-      continue;
-    }
-    const effectiveServerOutput = preRecipientResult.stopped ? preRecipientResult.signal.overrideOutput : serverOutput;
-    recipientCount++;
-    if (syncObject[`${resolvedName}_client`]) {
-      const clientSyncHandler = syncObject[`${resolvedName}_client`];
-      await processClientSyncForRecipient({
-        tempSocket,
-        tempToken,
-        clientSyncHandler,
-        data,
-        functionsObject,
-        serverOutput: effectiveServerOutput,
+  const deliver = async () => {
+    let recipientCount = 0;
+    const { fanoutYieldEvery, fanoutYieldMs } = getProjectConfig4().sync;
+    const yieldEvery = Math.max(1, fanoutYieldEvery);
+    let fanoutIterCount = 1;
+    for (const tempSocket of sockets) {
+      fanoutIterCount++;
+      if (fanoutIterCount % yieldEvery === 0) {
+        await new Promise((resolve) => setTimeout(resolve, fanoutYieldMs));
+      }
+      const tempToken = extractTokenFromSocket2(tempSocket);
+      if (ignoreSelf && typeof ignoreSelf === "boolean" && token && token === tempToken) {
+        continue;
+      }
+      const preRecipientResult = await dispatchHook3("preSyncRecipient", {
+        routeName: resolvedName,
         receiver: normalizedReceiver,
-        resolvedName,
-        callbackKey: callbackName,
-        transport: "http",
-        handlerName: "handleHttpSyncRequest",
-        logLabel: "http sync",
-        shouldLogDev,
-        shouldLogStream,
-        buildSyncError,
-        //? HTTP transport prefers `accept-language` over `x-language`
-        //? (reversed vs. the socket handler) — preserved verbatim from the
-        //? previous inlined error path.
-        resolvePreferredLocale: (headers) => extractLanguageFromHeader2(headers["accept-language"] || headers["x-language"]),
-        sourceUserId: user?.id
+        recipientSocketId: tempSocket.id,
+        recipientToken: tempToken,
+        recipientUserId: null,
+        serverOutput
+      });
+      if (preRecipientResult.stopped && preRecipientResult.signal.overrideOutput === void 0) {
+        continue;
+      }
+      const effectiveServerOutput = preRecipientResult.stopped ? preRecipientResult.signal.overrideOutput : serverOutput;
+      recipientCount++;
+      if (syncObject[`${resolvedName}_client`]) {
+        const clientSyncHandler = syncObject[`${resolvedName}_client`];
+        await processClientSyncForRecipient({
+          tempSocket,
+          tempToken,
+          clientSyncHandler,
+          data,
+          functionsObject,
+          serverOutput: effectiveServerOutput,
+          receiver: normalizedReceiver,
+          resolvedName,
+          transport: "http",
+          handlerName: "handleHttpSyncRequest",
+          logLabel: "http sync",
+          shouldLogDev,
+          shouldLogStream,
+          buildSyncError,
+          //? HTTP transport prefers `accept-language` over `x-language`
+          //? (reversed vs. the socket handler) — preserved verbatim from the
+          //? previous inlined error path.
+          resolvePreferredLocale: (headers) => extractLanguageFromHeader2(headers["accept-language"] || headers["x-language"]),
+          sourceUserId: user?.id
+        });
+        continue;
+      }
+      tempSocket.emit(socketEventNames4.sync, {
+        //? Server-resolved route, never the client `cb` (parity with the socket
+        //? handler): recipients fire callbacks for both `fullName` and `cb`.
+        cb: resolvedName,
+        fullName: resolvedName,
+        serverOutput: effectiveServerOutput,
+        clientOutput: {},
+        message: `${resolvedName} sync success`,
+        status: "success"
       });
-      continue;
     }
-    tempSocket.emit(socketEventNames4.sync, {
-      cb: callbackName,
-      fullName: resolvedName,
-      serverOutput: effectiveServerOutput,
-      clientOutput: {},
-      message: `${resolvedName} sync success`,
-      status: "success"
-    });
-  }
-  fanoutPayload.recipientCount = recipientCount;
-  await dispatchHook3("postSyncFanout", fanoutPayload);
-  return null;
+    fanoutPayload.recipientCount = recipientCount;
+    await dispatchHook3("postSyncFanout", fanoutPayload);
+  };
+  return { deliver };
 }
 async function handleHttpSyncRequest(args) {
   return runWithErrorTrackerIdentityScope2(() => handleHttpSyncRequestScoped(args));
 }
 async function handleHttpSyncRequestScoped({
   name,
-  cb,
   data,
   receiver,
   ignoreSelf,
@@ -1801,7 +1821,6 @@ async function handleHttpSyncRequestScoped({
     }
     const ctx = {
       name,
-      cb,
       data,
       normalizedReceiver,
       ignoreSelf,
@@ -1815,7 +1834,7 @@ async function handleHttpSyncRequestScoped({
     };
     const routeResult = await stageResolveRoute(ctx);
     if (routeResult.error) return routeResult.error;
-    const { resolvedName, callbackName } = routeResult;
+    const { resolvedName } = routeResult;
     currentRouteName = resolvedName;
     const { syncObject, functionsObject } = await getRuntimeSyncMapsFromSource();
     const serverSyncEntry = syncObject[`${resolvedName}_server`];
@@ -1849,8 +1868,22 @@ async function handleHttpSyncRequestScoped({
       if (executeResult.error) return executeResult.error;
       serverOutput = executeResult.serverOutput;
     }
-    const fanoutError = await stageFanout(resolvedName, callbackName, serverOutput, sockets, syncObject, functionsObject, ctx);
-    if (fanoutError) return fanoutError;
+    const fanout = await stageFanout(resolvedName, serverOutput, sockets, syncObject, functionsObject, ctx);
+    if (fanout.error) return fanout.error;
+    void tryCatch3(fanout.deliver, void 0, {
+      handler: "handleHttpSyncRequest",
+      sync: resolvedName,
+      stage: "fanout",
+      userId: user?.id,
+      receiver: redactTokenRoom(normalizedReceiver, [token]),
+      transport: "http"
+    }).then(([fanoutError]) => {
+      if (fanoutError) {
+        getLogger4().error(`http sync: ${resolvedName} fan-out failed after the originator was answered`, fanoutError, { sync: resolvedName, transport: "http" });
+      } else if (shouldLogDev()) {
+        getLogger4().debug(`http sync: ${resolvedName} fan-out completed`);
+      }
+    });
     if (shouldLogDev()) {
       getLogger4().debug(`http sync: ${resolvedName} completed`);
     }