@jusbid/redis 1.0.1 → 1.0.3

package/index.js

@@ -1,5 +1,15 @@
 const { createClient } = require('redis');
 const { logger } = require('@jusbid/logger');
+const {
+  closeRedisClients,
+  initRedisClients,
+  getRedisClients,
+  publish,
+  subscribe
+} = require('./socketRedisClient');
+
+const { initSocketManager, getIO, emitEvent } = require("./socket-manager");
+
 
 const redisOptions = {};
 
@@ -900,5 +910,13 @@ module.exports = {
   xDel,
   xTrim,
   xReadGroupNew,
-  deleteByPattern
+  deleteByPattern,
+  closeRedisClients,
+  initRedisClients,
+  getRedisClients,
+  publish,
+  subscribe,
+
+  initSocketManager, getIO, emitEvent
+
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jusbid/redis",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "main": "index.js",
   "private": false,
   "dependencies": {

package/redis-client.js

@@ -0,0 +1,16 @@
+// redis-client.js
+const { createClient } = require("@jusbid/redis");
+
+const createRedisClients = async ({ url = process.env.REDIS_URL } = {}) => {
+    const pubClient = createClient({ url });
+    const subClient = pubClient.duplicate();
+
+    pubClient.on("error", (err) => console.error("Redis Pub Client Error:", err));
+    subClient.on("error", (err) => console.error("Redis Sub Client Error:", err));
+
+    await Promise.all([pubClient.connect(), subClient.connect()]);
+
+    return { pubClient, subClient };
+};
+
+module.exports = { createRedisClients };

package/socket-manager.js

@@ -0,0 +1,39 @@
+let ioInstance = null;
+
+/**
+ * Initialize and store the io instance (call this ONCE, in index.js)
+ */
+const initSocketManager = (socketServerInstance) => {
+    if (!socketServerInstance) {
+        throw new Error("Socket server instance is required to initialize manager");
+    }
+    ioInstance = socketServerInstance;
+};
+
+/**
+ * Get the stored io instance (call this from ANY other file)
+ */
+const getIO = () => {
+    if (!ioInstance) {
+        throw new Error("Socket.IO not initialized. Call initSocketManager first.");
+    }
+    return ioInstance;
+};
+
+/**
+ * Emit from anywhere, without needing direct io access
+ */
+const emitEvent = (event, data, room = null) => {
+    const io = getIO();
+    if (room) {
+        io.to(room).emit(event, data);
+    } else {
+        io.emit(event, data);
+    }
+};
+
+module.exports = {
+    initSocketManager,
+    getIO,
+    emitEvent,
+};

package/socketRedisClient.js

@@ -0,0 +1,78 @@
+const { createClient } = require("redis");
+let pubClient = null;
+let subClient = null;
+let isInitialized = false;
+
+/**
+ * Initialize Redis clients ONCE, at app boot.
+ * pubClient: used for adapter broadcast + regular publish()
+ * subClient: used for adapter + regular subscribe()
+ */
+const initRedisClients = async ({ url = process.env.REDIS_URL } = {}) => {
+    if (isInitialized) {
+        return { pubClient, subClient };
+    }
+
+    pubClient = createClient({ url });
+    subClient = pubClient.duplicate();
+
+    pubClient.on("error", (err) => console.error("Redis Pub Client Error:", err.message));
+    subClient.on("error", (err) => console.error("Redis Sub Client Error:", err.message));
+
+    await Promise.all([pubClient.connect(), subClient.connect()]);
+
+    isInitialized = true;
+    console.log("Redis clients connected");
+
+    return { pubClient, subClient };
+};
+
+/**
+ * Get raw clients — needed by the Socket.IO Redis Adapter
+ */
+const getRedisClients = () => {
+    if (!isInitialized) {
+        throw new Error("Redis not initialized. Call initRedisClients first.");
+    }
+    return { pubClient, subClient };
+};
+
+/**
+ * Publish a message on any channel — usable from any file
+ */
+const publish = async (channel, payload) => {
+    if (!isInitialized) {
+        throw new Error("Redis not initialized. Call initRedisClients first.");
+    }
+    await pubClient.publish(channel, JSON.stringify(payload));
+};
+
+/**
+ * Subscribe to a channel with a handler — usable from any file
+ */
+const subscribe = async (channel, handler) => {
+    if (!isInitialized) {
+        throw new Error("Redis not initialized. Call initRedisClients first.");
+    }
+    await subClient.subscribe(channel, (message) => {
+        try {
+            handler(JSON.parse(message));
+        } catch (err) {
+            console.error(`Failed to handle message on "${channel}":`, err.message);
+        }
+    });
+};
+
+const closeRedisClients = async () => {
+    if (pubClient?.isOpen) await pubClient.quit();
+    if (subClient?.isOpen) await subClient.quit();
+    isInitialized = false;
+};
+
+module.exports = {
+    closeRedisClients,
+    initRedisClients,
+    getRedisClients,
+    publish,
+    subscribe
+}