@jskit-ai/realtime 0.1.28 → 0.1.29

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/realtime",
-  version: "0.1.28",
+  version: "0.1.29",
   kind: "runtime",
   description: "Thin, generic realtime runtime wrappers for socket.io server and client.",
   options: {
@@ -95,7 +95,7 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/kernel": "0.1.29",
+        "@jskit-ai/kernel": "0.1.30",
         "@socket.io/redis-adapter": "^8.3.0",
         "redis": "^5.8.2",
         "socket.io": "^4.8.3",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/realtime",
-  "version": "0.1.28",
+  "version": "0.1.29",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -16,7 +16,7 @@
   },
   "dependencies": {
     "@socket.io/redis-adapter": "^8.3.0",
-    "@jskit-ai/kernel": "0.1.29",
+    "@jskit-ai/kernel": "0.1.30",
     "redis": "^5.8.2",
     "socket.io": "^4.8.3",
     "socket.io-client": "^4.8.3"

package/src/server/RealtimeServiceProvider.js

@@ -8,6 +8,7 @@ import {
   createSocketIoServer,
   closeSocketIoServer,
   resolveRealtimeRedisUrl,
+  resolveRealtimeRedisNamespace,
   configureSocketIoRedisAdapter,
   closeSocketIoRedisConnections
 } from "./runtime.js";
@@ -684,8 +685,10 @@ class RealtimeServiceProvider {
 
     const env = typeof app.has === "function" && app.has("jskit.env") ? app.make("jskit.env") : {};
     const redisUrl = resolveRealtimeRedisUrl(env);
+    const redisNamespace = resolveRealtimeRedisNamespace(env);
     this.redisConnection = await configureSocketIoRedisAdapter(this.socketIoServer, {
-      redisUrl
+      redisUrl,
+      redisNamespace
     });
   }
 

package/src/server/runtime.js

@@ -4,7 +4,8 @@ import { createClient as createRedisClient } from "redis";
 import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 
 const SOCKET_IO_PATH = "/socket.io";
-const REALTIME_REDIS_URL_ENV_KEY = "REALTIME_REDIS_URL";
+const REDIS_URL_ENV_KEY = "REDIS_URL";
+const REDIS_NAMESPACE_ENV_KEY = "REDIS_NAMESPACE";
 
 function resolveHttpServer({ httpServer = null, fastify = null } = {}) {
   if (httpServer && typeof httpServer === "object") {
@@ -59,18 +60,39 @@ async function closeSocketIoServer(io) {
 
 function resolveRealtimeRedisUrl(env = {}) {
   const source = env && typeof env === "object" && !Array.isArray(env) ? env : {};
-  return normalizeText(source[REALTIME_REDIS_URL_ENV_KEY]);
+  return normalizeText(source[REDIS_URL_ENV_KEY]);
+}
+
+function resolveRealtimeRedisNamespace(env = {}) {
+  const source = env && typeof env === "object" && !Array.isArray(env) ? env : {};
+  return normalizeText(source[REDIS_NAMESPACE_ENV_KEY]);
+}
+
+function buildSocketIoRedisAdapterKey(redisNamespace = "") {
+  const normalizedRedisNamespace = normalizeText(redisNamespace).replace(/:+$/g, "");
+  if (!normalizedRedisNamespace) {
+    return "";
+  }
+  return `${normalizedRedisNamespace}:socket.io`;
 }
 
 async function configureSocketIoRedisAdapter(
   io,
-  { redisUrl = "" } = {}
+  {
+    redisUrl = "",
+    redisNamespace = "",
+    createRedisAdapter = createSocketIoRedisAdapter,
+    createRedisConnection = createRedisClient
+  } = {}
 ) {
   const normalizedRedisUrl = normalizeText(redisUrl);
+  const adapterKey = buildSocketIoRedisAdapterKey(redisNamespace);
   if (!normalizedRedisUrl) {
     return Object.freeze({
       enabled: false,
       redisUrl: "",
+      redisNamespace: "",
+      adapterKey: "",
       pubClient: null,
       subClient: null
     });
@@ -79,7 +101,7 @@ async function configureSocketIoRedisAdapter(
     throw new Error("configureSocketIoRedisAdapter requires socket.io server instance with adapter().");
   }
 
-  const pubClient = createRedisClient({
+  const pubClient = createRedisConnection({
     url: normalizedRedisUrl
   });
   const subClient = pubClient.duplicate();
@@ -87,7 +109,8 @@ async function configureSocketIoRedisAdapter(
   try {
     await pubClient.connect();
     await subClient.connect();
-    io.adapter(createSocketIoRedisAdapter(pubClient, subClient));
+    const adapterOptions = adapterKey ? { key: adapterKey } : undefined;
+    io.adapter(createRedisAdapter(pubClient, subClient, adapterOptions));
   } catch (error) {
     await closeSocketIoRedisConnections({
       pubClient,
@@ -99,6 +122,8 @@ async function configureSocketIoRedisAdapter(
   return Object.freeze({
     enabled: true,
     redisUrl: normalizedRedisUrl,
+    redisNamespace: normalizeText(redisNamespace),
+    adapterKey,
     pubClient,
     subClient
   });
@@ -127,8 +152,10 @@ async function closeSocketIoRedisConnections({ pubClient = null, subClient = nul
 export {
   createSocketIoServer,
   closeSocketIoServer,
-  REALTIME_REDIS_URL_ENV_KEY,
+  REDIS_URL_ENV_KEY,
+  REDIS_NAMESPACE_ENV_KEY,
   resolveRealtimeRedisUrl,
+  resolveRealtimeRedisNamespace,
   configureSocketIoRedisAdapter,
   closeSocketIoRedisConnections
 };

package/test/serverRuntime.test.js

@@ -2,10 +2,12 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import {
-  REALTIME_REDIS_URL_ENV_KEY,
+  REDIS_URL_ENV_KEY,
+  REDIS_NAMESPACE_ENV_KEY,
   createSocketIoServer,
   closeSocketIoServer,
   resolveRealtimeRedisUrl,
+  resolveRealtimeRedisNamespace,
   configureSocketIoRedisAdapter,
   closeSocketIoRedisConnections
 } from "../src/server/runtime.js";
@@ -108,7 +110,15 @@ test("closeSocketIoServer swallows ERR_SERVER_NOT_RUNNING", async () => {
 
 test("resolveRealtimeRedisUrl reads and normalizes env URL", () => {
   assert.equal(resolveRealtimeRedisUrl({}), "");
-  assert.equal(resolveRealtimeRedisUrl({ [REALTIME_REDIS_URL_ENV_KEY]: " redis://localhost:6379 " }), "redis://localhost:6379");
+  assert.equal(resolveRealtimeRedisUrl({ [REDIS_URL_ENV_KEY]: " redis://localhost:6379 " }), "redis://localhost:6379");
+});
+
+test("resolveRealtimeRedisNamespace reads and normalizes env namespace", () => {
+  assert.equal(resolveRealtimeRedisNamespace({}), "");
+  assert.equal(
+    resolveRealtimeRedisNamespace({ [REDIS_NAMESPACE_ENV_KEY]: " app:production " }),
+    "app:production"
+  );
 });
 
 test("configureSocketIoRedisAdapter keeps memory mode when URL is empty", async () => {
@@ -147,3 +157,49 @@ test("closeSocketIoRedisConnections closes both clients when present", async ()
 
   assert.deepEqual(calls, ["sub.quit", "pub.quit"]);
 });
+
+test("configureSocketIoRedisAdapter applies namespaced adapter key when redis namespace is set", async () => {
+  const adapterCalls = [];
+  const io = {
+    adapter(adapter) {
+      adapterCalls.push(adapter);
+    }
+  };
+  const connectionCalls = [];
+  const createRedisConnection = ({ url }) => {
+    const client = {
+      url,
+      async connect() {
+        connectionCalls.push(`${url}:connect`);
+      },
+      async quit() {},
+      duplicate() {
+        return {
+          async connect() {
+            connectionCalls.push(`${url}:duplicate.connect`);
+          },
+          async quit() {}
+        };
+      }
+    };
+    return client;
+  };
+  const createRedisAdapter = (pubClient, subClient, options) => ({
+    pubClient,
+    subClient,
+    options
+  });
+
+  const result = await configureSocketIoRedisAdapter(io, {
+    redisUrl: "redis://localhost:6379",
+    redisNamespace: "my-app:production",
+    createRedisConnection,
+    createRedisAdapter
+  });
+
+  assert.equal(connectionCalls.length, 2);
+  assert.equal(adapterCalls.length, 1);
+  assert.equal(adapterCalls[0].options?.key, "my-app:production:socket.io");
+  assert.equal(result.adapterKey, "my-app:production:socket.io");
+  assert.equal(result.redisNamespace, "my-app:production");
+});