@jskit-ai/realtime 0.1.177 → 0.1.178

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/realtime",
-  "version": "0.1.177",
+  "version": "0.1.178",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -20,8 +20,8 @@
     "socket.io-client": "^4.8.3"
   },
   "peerDependencies": {
-    "@jskit-ai/kernel": "0.1.180",
-    "@jskit-ai/shell-web": "0.1.184",
+    "@jskit-ai/kernel": "0.1.181",
+    "@jskit-ai/shell-web": "0.1.185",
     "vue": "^3.5.13"
   },
   "description": "Thin, generic realtime runtime wrappers for socket.io server and client.",

package/patterns/realtime-application/example/package.json

@@ -2,7 +2,7 @@
   "private": true,
   "type": "module",
   "dependencies": {
-    "@jskit-ai/realtime": "0.1.177",
-    "@jskit-ai/shell-web": "0.1.184"
+    "@jskit-ai/realtime": "0.1.178",
+    "@jskit-ai/shell-web": "0.1.185"
   }
 }

package/src/server/RealtimeProvider.js

@@ -63,28 +63,25 @@ const RealtimeProvider = defineProvider({
   provides: {
     realtime: "runtime.realtime"
   },
-  setup({ authService, config, database, env, events, fastify, logger, workspaces }) {
+  setup({ config, env, fastify, logger }) {
     const io = createSocketIoServer({ fastify });
     const providerLogger = createProviderLogger(logger, { debugEnabled: debugEnabled(config, env) });
-    const delivery = createRealtimeDelivery({ io, database, logger: providerLogger, authService, workspaces });
     const realtime = createRealtimeCapability({ io });
     stateByCapability.set(realtime, {
       authenticationRequired: false,
-      delivery,
+      delivery: null,
       io,
       providerLogger,
       redisConnection: null
     });
-    events.register({
-      id: "runtime.realtime.delivery",
-      matches: (event) => Boolean(normalizeText(event?.realtime?.event)),
-      handle: delivery.handle
-    });
     return { realtime };
   },
-  async boot({ authService, env, workspaces }, { outputs }) {
+  async boot({ authService, database, env, events, workspaces }, { outputs }) {
     const state = stateByCapability.get(outputs.realtime);
     if (!state) throw new Error("Realtime runtime state is unavailable.");
+    state.delivery = createRealtimeDelivery({
+      io: state.io, database, logger: state.providerLogger, authService, workspaces
+    });
     state.authenticationRequired = realtimeAuthenticationRequired(authService);
     registerSocketAudienceBootstrap({
       io: state.io,
@@ -98,11 +95,16 @@ const RealtimeProvider = defineProvider({
       redisNamespace: resolveRealtimeRedisNamespace(env)
     });
     state.delivery.start({ redisConfigured: state.redisConnection.enabled });
+    events.register({
+      id: "runtime.realtime.delivery",
+      matches: (event) => Boolean(normalizeText(event?.realtime?.event)),
+      handle: state.delivery.handle
+    });
   },
   async shutdown(_dependencies, { outputs }) {
     const state = stateByCapability.get(outputs.realtime);
     if (!state) return;
-    state.delivery.stop();
+    state.delivery?.stop();
     await closeSocketIoServer(state.io);
     await closeSocketIoRedisConnections(state.redisConnection || {});
     stateByCapability.delete(outputs.realtime);

package/src/server/realtimeAudience.js

@@ -26,6 +26,17 @@ function roomForWorkspaceUser(workspaceId, userId) {
   return `workspace:${String(workspaceId || "").trim()}:user:${String(userId || "").trim()}`;
 }
 
+function workspaceAudienceRooms(workspaceIds, actorId) {
+  const rooms = [];
+  for (const rawId of normalizeArray(workspaceIds)) {
+    const workspaceId = normalizeRecordId(rawId, { fallback: null });
+    if (workspaceId) {
+      rooms.push(roomForWorkspace(workspaceId), roomForWorkspaceUser(workspaceId, actorId));
+    }
+  }
+  return rooms;
+}
+
 function resolveScopeWorkspaceId(scope = {}) {
   const kind = normalizeText(scope?.kind).toLowerCase();
   if (kind === "workspace") return normalizeRecordId(scope.id, { fallback: null });
@@ -242,11 +253,8 @@ function registerSocketAudienceBootstrap({ io, logger, authService = null, works
       const workspaceIds = typeof repository?.listActiveWorkspaceIdsByUserId === "function"
         ? await repository.listActiveWorkspaceIdsByUserId(actorId)
         : [];
-      for (const rawId of normalizeArray(workspaceIds)) {
-        const workspaceId = normalizeRecordId(rawId, { fallback: null });
-        if (!workspaceId) continue;
-        socket.join(roomForWorkspace(workspaceId));
-        socket.join(roomForWorkspaceUser(workspaceId, actorId));
+      for (const room of workspaceAudienceRooms(workspaceIds, actorId)) {
+        socket.join(room);
       }
     } catch (error) {
       logger.warn({ error: String(error?.message || error) }, "Realtime socket audience bootstrap failed.");
@@ -262,21 +270,18 @@ async function revalidateSocket({ socket, authService, workspaces = null }) {
     socket.disconnect(true);
     return null;
   }
-  if (actor) {
-    rememberSocketActorId(socket, actor.id);
-    const repository = workspaces?.repositories?.workspaceMemberships;
-    if (typeof repository?.listActiveWorkspaceIdsByUserId === "function") {
-      const workspaceIds = await repository.listActiveWorkspaceIdsByUserId(actor.id);
-      const rooms = new Set(normalizeArray(workspaceIds).flatMap((id) => {
-        const workspaceId = normalizeRecordId(id, { fallback: null });
-        return workspaceId ? [roomForWorkspace(workspaceId), roomForWorkspaceUser(workspaceId, actor.id)] : [];
-      }));
-      for (const room of socket.rooms) {
-        if (room.startsWith("workspace:") && !rooms.has(room)) await socket.leave(room);
-      }
-      for (const room of rooms) await socket.join(room);
-    }
+  if (!actor) return null;
+
+  rememberSocketActorId(socket, actor.id);
+  const repository = workspaces?.repositories?.workspaceMemberships;
+  if (typeof repository?.listActiveWorkspaceIdsByUserId !== "function") return actor;
+
+  const workspaceIds = await repository.listActiveWorkspaceIdsByUserId(actor.id);
+  const rooms = new Set(workspaceAudienceRooms(workspaceIds, actor.id));
+  for (const room of socket.rooms) {
+    if (room.startsWith("workspace:") && !rooms.has(room)) await socket.leave(room);
   }
+  for (const room of rooms) await socket.join(room);
   return actor;
 }
 

package/src/server/realtimeDelivery.js

@@ -6,11 +6,14 @@ const DELIVERY_EVENT = "jskit:realtime:delivery";
 function publicRealtimePayload(event) {
   const { realtime } = event && typeof event === "object" ? event : {};
   const canonical = {};
-  for (const key of ["type", "source", "entity", "operation", "entityId", "scope", "actorId", "commandId", "sourceClientId", "occurredAt"]) {
+  for (const key of [
+    "type", "source", "entity", "operation", "entityId", "scope", "actorId",
+    "commandId", "sourceClientId", "occurredAt"
+  ]) {
     if (Object.hasOwn(event, key)) canonical[key] = event[key];
   }
   const payload = realtime?.payload;
-  if (payload != null && (!payload || typeof payload !== "object" || Array.isArray(payload))) {
+  if (payload != null && (typeof payload !== "object" || Array.isArray(payload))) {
     throw new TypeError("Realtime event payload must be an object when provided.");
   }
   return Object.freeze({ ...(payload || {}), ...canonical });
@@ -35,7 +38,7 @@ function createRealtimeDelivery({ io, database = null, logger, authService = nul
   let revalidationTimer = null;
   let stopped = false;
 
-  async function authenticate(socket) {
+  async function revalidate(socket) {
     try {
       return await revalidateSocket({ socket, authService, workspaces });
     } catch (error) {
@@ -48,11 +51,16 @@ function createRealtimeDelivery({ io, database = null, logger, authService = nul
   async function deliverLocal({ eventName, payload, targets }) {
     await Promise.all([...io.sockets.sockets.values()].map(async (socket) => {
       try {
-        const actor = await authenticate(socket);
+        const actor = await revalidate(socket);
         if (!socket.connected) return;
         if (!targets.broadcastAllClients && !targets.rooms.some((room) => socket.rooms.has(room))) return;
-        if (typeof authService.realtime?.authorizeEvent === "function" &&
-            await authService.realtime.authorizeEvent({ actor, event: { name: eventName, payload } }) !== true) return;
+        if (typeof authService.realtime?.authorizeEvent === "function") {
+          const authorized = await authService.realtime.authorizeEvent({
+            actor,
+            event: { name: eventName, payload }
+          });
+          if (authorized !== true) return;
+        }
         if (socket.connected) socket.emit(eventName, payload);
       } catch (error) {
         logger.warn({ socketEvent: eventName, error: String(error?.message || error) }, "Realtime delivery denied after authorization failure.");
@@ -71,7 +79,7 @@ function createRealtimeDelivery({ io, database = null, logger, authService = nul
   function scheduleRevalidation() {
     if (stopped) return;
     revalidationTimer = setTimeout(async () => {
-      await Promise.all([...io.sockets.sockets.values()].map(authenticate));
+      await Promise.all([...io.sockets.sockets.values()].map(revalidate));
       scheduleRevalidation();
     }, 30_000);
     revalidationTimer.unref();

package/test/providerRuntime.test.js

@@ -8,9 +8,37 @@ import { RealtimeClientProvider } from "../src/client/RealtimeClientProvider.js"
 import { RealtimeProvider } from "../src/server/RealtimeProvider.js";
 import { registerSocketAudienceBootstrap } from "../src/server/realtimeAudience.js";
 import { createRealtimeDelivery } from "../src/server/realtimeDelivery.js";
+import { attachDeferredAuthService, createDeferredAuthService } from "../../auth-core/src/server/deferredAuthService.js";
 
 const logger = Object.freeze({ debug() {}, info() {}, warn() {}, error() {} });
 
+test("RealtimeProvider waits for authentication boot before accessing the auth service", async () => {
+  const authService = createDeferredAuthService();
+  const authProvider = defineProvider({
+    id: "test.deferred.auth",
+    provides: { authService: "auth.service" },
+    setup() { return { authService }; },
+    boot() {
+      attachDeferredAuthService(authService, {
+        realtime: { requireAuthentication: true },
+        async authenticateRequest() { return { authenticated: false, actor: null }; }
+      });
+    }
+  });
+  const runtime = createCapabilityRuntime({
+    inputs: {
+      "runtime.config": {}, "runtime.env": {},
+      "runtime.fastify": { server: createServer() }, "runtime.logger": logger
+    },
+    providers: [EventProvider, RealtimeProvider, authProvider]
+  });
+  try {
+    await runtime.start();
+  } finally {
+    await runtime.shutdown();
+  }
+});
+
 function createIoDouble() {
   const emitted = [];
   return {