redux-cluster-ws 2.0.1 → 2.0.3

package/dist/esm/server.js

@@ -5,295 +5,284 @@ import { hasher, replacer, generateUID } from "./utils.js";
 // Import WebSocket server for Node.js
 import { WebSocketServer } from "ws";
 export class ReduxClusterWSServerWrapper {
-    store;
-    uid;
-    connections;
-    authDatabase;
-    ipBanDatabase;
-    config;
-    server;
-    wss;
-    unsubscribe;
-    IP_BAN_ATTEMPTS = 15;
-    IP_BAN_TIMEOUT = 10800000; // 3 hours
-    CONNECTION_TIMEOUT = 30000;
-    gcInterval;
     constructor(store) {
-        this.store = store;
-        this.uid = generateUID();
-        this.connections = new Map();
-        this.authDatabase = {};
-        this.ipBanDatabase = {};
-        this.config = { host: "0.0.0.0", port: 10002 };
-        // Attach createWSServer method to store
-        store.createWSServer = this.createWSServer.bind(this);
-    }
-    createWSServer = (config) => {
-        this.config = { ...this.config, ...config };
-        // Setup authentication database
-        if (this.config.logins) {
-            for (const [login, password] of Object.entries(this.config.logins)) {
-                const hashedLogin = hasher(`REDUX_CLUSTER${login}`);
-                const hashedPassword = hasher(`REDUX_CLUSTER${password}`);
-                this.authDatabase[hashedLogin] = hashedPassword;
+        this.IP_BAN_ATTEMPTS = 15;
+        this.IP_BAN_TIMEOUT = 10800000; // 3 hours
+        this.CONNECTION_TIMEOUT = 30000;
+        this.createWSServer = (config) => {
+            this.config = { ...this.config, ...config };
+            // Setup authentication database
+            if (this.config.logins) {
+                for (const [login, password] of Object.entries(this.config.logins)) {
+                    const hashedLogin = hasher(`REDUX_CLUSTER${login}`);
+                    const hashedPassword = hasher(`REDUX_CLUSTER${password}`);
+                    this.authDatabase[hashedLogin] = hashedPassword;
+                }
             }
-        }
-        // Start garbage collection for banned IPs
-        this.startGarbageCollection();
-        // Create HTTP/HTTPS server if not provided
-        if (!this.config.server) {
-            if (this.config.ssl?.key && this.config.ssl?.cert) {
-                const ssl = {
-                    key: readFileSync(this.config.ssl.key),
-                    cert: readFileSync(this.config.ssl.cert) +
-                        (this.config.ssl.ca ? "\n" + readFileSync(this.config.ssl.ca) : ""),
-                };
-                this.server = createHttpsServer(ssl);
+            // Start garbage collection for banned IPs
+            this.startGarbageCollection();
+            // Create HTTP/HTTPS server if not provided
+            if (!this.config.server) {
+                if (this.config.ssl?.key && this.config.ssl?.cert) {
+                    const ssl = {
+                        key: readFileSync(this.config.ssl.key),
+                        cert: readFileSync(this.config.ssl.cert) +
+                            (this.config.ssl.ca ? "\n" + readFileSync(this.config.ssl.ca) : ""),
+                    };
+                    this.server = createHttpsServer(ssl);
+                }
+                else {
+                    this.server = createHttpServer();
+                }
+                this.server.setTimeout(this.CONNECTION_TIMEOUT);
+                this.server.listen(this.config.port, this.config.host);
             }
             else {
-                this.server = createHttpServer();
+                this.server = this.config.server;
             }
-            this.server.setTimeout(this.CONNECTION_TIMEOUT);
-            this.server.listen(this.config.port, this.config.host);
-        }
-        else {
-            this.server = this.config.server;
-        }
-        // Create WebSocket server
-        this.wss = new WebSocketServer({
-            server: this.server,
-            path: `/redux-cluster-${this.store.RCHash}`,
-        });
-        this.wss.on("connection", this.handleConnection.bind(this));
-        // Subscribe to store changes
-        this.unsubscribe = this.store.subscribe(() => {
-            if (this.store.mode === "snapshot") {
-                this.sendToAll();
-            }
-        });
-        // For action mode, override dispatch to send individual actions
-        if (this.store.mode === "action") {
-            const originalDispatch = this.store.dispatch;
-            this.store.dispatch = (action) => {
-                const result = originalDispatch(action);
-                // Send the action to all connected clients
-                if (action.type !== "@@INIT" && action.type !== "REDUX_CLUSTER_SYNC") {
-                    this.sendToAll({
-                        _msg: "REDUX_CLUSTER_MSGTOWORKER",
-                        _hash: this.store.RCHash,
-                        _action: action,
-                    });
+            // Create WebSocket server
+            this.wss = new WebSocketServer({
+                server: this.server,
+                path: `/redux-cluster-${this.store.RCHash}`,
+            });
+            this.wss.on("connection", this.handleConnection.bind(this));
+            // Subscribe to store changes
+            this.unsubscribe = this.store.subscribe(() => {
+                if (this.store.mode === "snapshot") {
+                    this.sendToAll();
                 }
-                return result;
+            });
+            // For action mode, override dispatch to send individual actions
+            if (this.store.mode === "action") {
+                const originalDispatch = this.store.dispatch;
+                this.store.dispatch = (action) => {
+                    const result = originalDispatch(action);
+                    // Send the action to all connected clients
+                    if (action.type !== "@@INIT" && action.type !== "REDUX_CLUSTER_SYNC") {
+                        this.sendToAll({
+                            _msg: "REDUX_CLUSTER_MSGTOWORKER",
+                            _hash: this.store.RCHash,
+                            _action: action,
+                        });
+                    }
+                    return result;
+                };
+            }
+            // Add server role
+            if (!this.store.role.includes("server")) {
+                this.store.role.push("server");
+            }
+        };
+        this.handleConnection = (ws, req) => {
+            const connectionId = generateUID();
+            const ip = this.extractIP(req);
+            const processedIP = replacer(ip, true);
+            // Check if IP is banned
+            if (this.isIPBanned(processedIP)) {
+                this.sendMessage(ws, {
+                    _msg: "REDUX_CLUSTER_SOCKET_AUTHSTATE",
+                    _hash: this.store.RCHash,
+                    _value: false,
+                    _banned: true,
+                });
+                ws.close();
+                return;
+            }
+            const connection = {
+                id: connectionId,
+                ws,
+                authenticated: false,
+                ip: processedIP,
             };
-        }
-        // Add server role
-        if (!this.store.role.includes("server")) {
-            this.store.role.push("server");
-        }
-    };
-    handleConnection = (ws, req) => {
-        const connectionId = generateUID();
-        const ip = this.extractIP(req);
-        const processedIP = replacer(ip, true);
-        // Check if IP is banned
-        if (this.isIPBanned(processedIP)) {
-            this.sendMessage(ws, {
-                _msg: "REDUX_CLUSTER_SOCKET_AUTHSTATE",
-                _hash: this.store.RCHash,
-                _value: false,
-                _banned: true,
+            this.connections.set(connectionId, connection);
+            ws.on("message", (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    this.handleMessage(connectionId, message);
+                }
+                catch (error) {
+                    this.store.stderr(`ReduxCluster.createWSServer message parse error: ${error}`);
+                    this.removeConnection(connectionId);
+                }
+            });
+            ws.on("close", () => {
+                this.removeConnection(connectionId);
+            });
+            ws.on("error", (error) => {
+                this.store.stderr(`ReduxCluster.createWSServer connection error: ${error.message}`);
+                this.removeConnection(connectionId);
             });
-            ws.close();
-            return;
-        }
-        const connection = {
-            id: connectionId,
-            ws,
-            authenticated: false,
-            ip: processedIP,
         };
-        this.connections.set(connectionId, connection);
-        ws.on("message", (data) => {
-            try {
-                const message = JSON.parse(data.toString());
-                this.handleMessage(connectionId, message);
+        this.handleMessage = (connectionId, message) => {
+            const connection = this.connections.get(connectionId);
+            if (!connection || message._hash !== this.store.RCHash) {
+                return;
             }
-            catch (error) {
-                this.store.stderr(`ReduxCluster.createWSServer message parse error: ${error}`);
+            switch (message._msg) {
+                case "REDUX_CLUSTER_SOCKET_AUTH":
+                    this.handleAuthentication(connectionId, message);
+                    break;
+                case "REDUX_CLUSTER_START":
+                    if (connection.authenticated) {
+                        this.sendMessage(connection.ws, {
+                            _msg: "REDUX_CLUSTER_MSGTOWORKER",
+                            _hash: this.store.RCHash,
+                            _action: {
+                                type: "REDUX_CLUSTER_SYNC",
+                                payload: this.store.getState(),
+                            },
+                        });
+                    }
+                    break;
+                case "REDUX_CLUSTER_MSGTOMASTER":
+                    if (connection.authenticated && message._action) {
+                        if (message._action.type === "REDUX_CLUSTER_SYNC") {
+                            throw new Error("Please don't use REDUX_CLUSTER_SYNC action type!");
+                        }
+                        this.store.dispatch(message._action);
+                    }
+                    break;
+            }
+        };
+        this.handleAuthentication = (connectionId, message) => {
+            const connection = this.connections.get(connectionId);
+            if (!connection)
+                return;
+            const { _login, _password } = message;
+            if (_login &&
+                _password &&
+                this.authDatabase[_login] &&
+                this.authDatabase[_login] === _password) {
+                // Authentication successful
+                connection.authenticated = true;
+                this.clearIPBan(connection.ip);
+                this.sendMessage(connection.ws, {
+                    _msg: "REDUX_CLUSTER_SOCKET_AUTHSTATE",
+                    _hash: this.store.RCHash,
+                    _value: true,
+                });
+            }
+            else {
+                // Authentication failed
+                this.recordFailedAttempt(connection.ip);
+                this.sendMessage(connection.ws, {
+                    _msg: "REDUX_CLUSTER_SOCKET_AUTHSTATE",
+                    _hash: this.store.RCHash,
+                    _value: false,
+                });
                 this.removeConnection(connectionId);
             }
-        });
-        ws.on("close", () => {
-            this.removeConnection(connectionId);
-        });
-        ws.on("error", (error) => {
-            this.store.stderr(`ReduxCluster.createWSServer connection error: ${error.message}`);
-            this.removeConnection(connectionId);
-        });
-    };
-    handleMessage = (connectionId, message) => {
-        const connection = this.connections.get(connectionId);
-        if (!connection || message._hash !== this.store.RCHash) {
-            return;
-        }
-        switch (message._msg) {
-            case "REDUX_CLUSTER_SOCKET_AUTH":
-                this.handleAuthentication(connectionId, message);
-                break;
-            case "REDUX_CLUSTER_START":
-                if (connection.authenticated) {
-                    this.sendMessage(connection.ws, {
-                        _msg: "REDUX_CLUSTER_MSGTOWORKER",
-                        _hash: this.store.RCHash,
-                        _action: {
-                            type: "REDUX_CLUSTER_SYNC",
-                            payload: this.store.getState(),
-                        },
-                    });
-                }
-                break;
-            case "REDUX_CLUSTER_MSGTOMASTER":
-                if (connection.authenticated && message._action) {
-                    if (message._action.type === "REDUX_CLUSTER_SYNC") {
-                        throw new Error("Please don't use REDUX_CLUSTER_SYNC action type!");
+        };
+        this.sendToAll = (message) => {
+            const msg = message || {
+                _msg: "REDUX_CLUSTER_MSGTOWORKER",
+                _hash: this.store.RCHash,
+                _action: { type: "REDUX_CLUSTER_SYNC", payload: this.store.getState() },
+            };
+            for (const connection of this.connections.values()) {
+                if (connection.authenticated && connection.ws.readyState === 1) {
+                    // WebSocket.OPEN = 1
+                    try {
+                        this.sendMessage(connection.ws, msg);
+                    }
+                    catch (error) {
+                        this.store.stderr(`ReduxCluster.createWSServer write error: ${error}`);
                     }
-                    this.store.dispatch(message._action);
                 }
-                break;
-        }
-    };
-    handleAuthentication = (connectionId, message) => {
-        const connection = this.connections.get(connectionId);
-        if (!connection)
-            return;
-        const { _login, _password } = message;
-        if (_login &&
-            _password &&
-            this.authDatabase[_login] &&
-            this.authDatabase[_login] === _password) {
-            // Authentication successful
-            connection.authenticated = true;
-            this.clearIPBan(connection.ip);
-            this.sendMessage(connection.ws, {
-                _msg: "REDUX_CLUSTER_SOCKET_AUTHSTATE",
-                _hash: this.store.RCHash,
-                _value: true,
-            });
-        }
-        else {
-            // Authentication failed
-            this.recordFailedAttempt(connection.ip);
-            this.sendMessage(connection.ws, {
-                _msg: "REDUX_CLUSTER_SOCKET_AUTHSTATE",
-                _hash: this.store.RCHash,
-                _value: false,
-            });
-            this.removeConnection(connectionId);
-        }
-    };
-    sendToAll = (message) => {
-        const msg = message || {
-            _msg: "REDUX_CLUSTER_MSGTOWORKER",
-            _hash: this.store.RCHash,
-            _action: { type: "REDUX_CLUSTER_SYNC", payload: this.store.getState() },
+            }
         };
-        for (const connection of this.connections.values()) {
-            if (connection.authenticated && connection.ws.readyState === 1) {
+        this.sendMessage = (ws, message) => {
+            if (ws.readyState === 1) {
                 // WebSocket.OPEN = 1
+                ws.send(JSON.stringify(message));
+            }
+        };
+        this.extractIP = (req) => {
+            const forwarded = req.headers["x-forwarded-for"];
+            if (typeof forwarded === "string") {
+                return forwarded.split(",")[0].trim();
+            }
+            if (Array.isArray(forwarded)) {
+                return forwarded[0];
+            }
+            return req.socket.remoteAddress || "127.0.0.1";
+        };
+        this.isIPBanned = (ip) => {
+            const banInfo = this.ipBanDatabase[ip];
+            if (!banInfo)
+                return false;
+            const isTimedOut = banInfo.time + this.IP_BAN_TIMEOUT < Date.now();
+            if (isTimedOut) {
+                delete this.ipBanDatabase[ip];
+                return false;
+            }
+            return banInfo.count >= this.IP_BAN_ATTEMPTS;
+        };
+        this.recordFailedAttempt = (ip) => {
+            const existing = this.ipBanDatabase[ip];
+            let count = 0;
+            if (existing) {
+                const isTimedOut = existing.time + this.IP_BAN_TIMEOUT < Date.now();
+                count = isTimedOut ? 0 : existing.count;
+            }
+            this.ipBanDatabase[ip] = {
+                time: Date.now(),
+                count: count + 1,
+            };
+        };
+        this.clearIPBan = (ip) => {
+            delete this.ipBanDatabase[ip];
+        };
+        this.removeConnection = (connectionId) => {
+            const connection = this.connections.get(connectionId);
+            if (connection) {
                 try {
-                    this.sendMessage(connection.ws, msg);
+                    connection.ws.close();
                 }
-                catch (error) {
-                    this.store.stderr(`ReduxCluster.createWSServer write error: ${error}`);
+                catch {
+                    // Ignore errors when closing
                 }
+                this.connections.delete(connectionId);
             }
-        }
-    };
-    sendMessage = (ws, message) => {
-        if (ws.readyState === 1) {
-            // WebSocket.OPEN = 1
-            ws.send(JSON.stringify(message));
-        }
-    };
-    extractIP = (req) => {
-        const forwarded = req.headers["x-forwarded-for"];
-        if (typeof forwarded === "string") {
-            return forwarded.split(",")[0].trim();
-        }
-        if (Array.isArray(forwarded)) {
-            return forwarded[0];
-        }
-        return req.socket.remoteAddress || "127.0.0.1";
-    };
-    isIPBanned = (ip) => {
-        const banInfo = this.ipBanDatabase[ip];
-        if (!banInfo)
-            return false;
-        const isTimedOut = banInfo.time + this.IP_BAN_TIMEOUT < Date.now();
-        if (isTimedOut) {
-            delete this.ipBanDatabase[ip];
-            return false;
-        }
-        return banInfo.count >= this.IP_BAN_ATTEMPTS;
-    };
-    recordFailedAttempt = (ip) => {
-        const existing = this.ipBanDatabase[ip];
-        let count = 0;
-        if (existing) {
-            const isTimedOut = existing.time + this.IP_BAN_TIMEOUT < Date.now();
-            count = isTimedOut ? 0 : existing.count;
-        }
-        this.ipBanDatabase[ip] = {
-            time: Date.now(),
-            count: count + 1,
         };
-    };
-    clearIPBan = (ip) => {
-        delete this.ipBanDatabase[ip];
-    };
-    removeConnection = (connectionId) => {
-        const connection = this.connections.get(connectionId);
-        if (connection) {
-            try {
-                connection.ws.close();
+        this.startGarbageCollection = () => {
+            this.gcInterval = setInterval(() => {
+                const now = Date.now();
+                for (const [ip, banInfo] of Object.entries(this.ipBanDatabase)) {
+                    if (banInfo.time + this.IP_BAN_TIMEOUT < now) {
+                        delete this.ipBanDatabase[ip];
+                    }
+                }
+            }, 60000); // Run every minute
+        };
+        this.destroy = () => {
+            if (this.gcInterval) {
+                clearInterval(this.gcInterval);
             }
-            catch {
-                // Ignore errors when closing
+            if (this.unsubscribe) {
+                this.unsubscribe();
             }
-            this.connections.delete(connectionId);
-        }
-    };
-    startGarbageCollection = () => {
-        this.gcInterval = setInterval(() => {
-            const now = Date.now();
-            for (const [ip, banInfo] of Object.entries(this.ipBanDatabase)) {
-                if (banInfo.time + this.IP_BAN_TIMEOUT < now) {
-                    delete this.ipBanDatabase[ip];
-                }
+            for (const connection of this.connections.values()) {
+                this.removeConnection(connection.id);
+            }
+            if (this.wss) {
+                this.wss.close();
             }
-        }, 60000); // Run every minute
-    };
-    destroy = () => {
-        if (this.gcInterval) {
-            clearInterval(this.gcInterval);
-        }
-        if (this.unsubscribe) {
-            this.unsubscribe();
-        }
-        for (const connection of this.connections.values()) {
-            this.removeConnection(connection.id);
-        }
-        if (this.wss) {
-            this.wss.close();
-        }
-        if (this.server && this.server.close) {
-            this.server.close();
-        }
-    };
+            if (this.server && this.server.close) {
+                this.server.close();
+            }
+        };
+        this.store = store;
+        this.uid = generateUID();
+        this.connections = new Map();
+        this.authDatabase = {};
+        this.ipBanDatabase = {};
+        this.config = { host: "0.0.0.0", port: 10002 };
+        // Attach createWSServer method to store
+        store.createWSServer = this.createWSServer.bind(this);
+    }
 }
 export function server(store) {
     new ReduxClusterWSServerWrapper(store);
     return store;
 }
-//# sourceMappingURL=server.js.map

package/dist/esm/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/esm/utils.js

@@ -66,4 +66,3 @@ export function deepClone(obj) {
     }
     return obj;
 }
-//# sourceMappingURL=utils.js.map

package/package.json

@@ -1,48 +1,52 @@
 {
   "name": "redux-cluster-ws",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "WebSocket client/server wrapper for redux-cluster with TypeScript support",
   "type": "module",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
-  "types": "./dist/esm/index.d.ts",
+  "types": "./dist/types/index.d.ts",
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/esm/index.d.ts",
+        "types": "./dist/types/index.d.ts",
         "default": "./dist/esm/index.js"
       },
       "require": {
-        "types": "./dist/cjs/index.d.ts",
+        "types": "./dist/types/index.d.ts",
         "default": "./dist/cjs/index.js"
       }
     },
     "./server": {
       "import": {
-        "types": "./dist/esm/server.d.ts",
+        "types": "./dist/types/server.d.ts",
         "default": "./dist/esm/server.js"
       },
       "require": {
-        "types": "./dist/cjs/server.d.ts",
+        "types": "./dist/types/server.d.ts",
         "default": "./dist/cjs/server.js"
       }
     },
     "./client": {
       "import": {
-        "types": "./dist/esm/client.d.ts",
+        "types": "./dist/types/client.d.ts",
         "default": "./dist/esm/client.js"
       },
       "require": {
-        "types": "./dist/cjs/client.d.ts",
+        "types": "./dist/types/client.d.ts",
         "default": "./dist/cjs/client.js"
       }
     }
   },
   "scripts": {
-    "build": "npm run clean && npm run build:esm && npm run build:cjs && npm run build:pkg",
-    "build:esm": "tsc --module ES2022 --outDir dist/esm --target ES2022 --declaration",
-    "build:cjs": "tsc -p tsconfig.cjs.json --declaration",
+    "build": "npm run clean && npm run build:esm && npm run build:cjs && npm run build:types && npm run build:pkg",
+    "build:esm": "tsc --module ES2020 --outDir dist/esm --target ES2020 --declaration false",
+    "build:cjs": "tsc -p tsconfig.cjs.json --declaration false",
+    "build:types": "tsc --module ES2020 --outDir dist/types --target ES2020 --declaration true --emitDeclarationOnly",
     "build:pkg": "echo '{\"type\":\"commonjs\"}' > dist/cjs/package.json",
+    "dev": "npm run clean && npm run build:esm:dev && npm run build:cjs:dev && npm run build:types",
+    "build:esm:dev": "tsc --module ES2020 --outDir dist/esm --target ES2020 --declaration false --sourceMap",
+    "build:cjs:dev": "tsc -p tsconfig.cjs.json --declaration false --sourceMap",
     "clean": "rm -rf dist",
     "lint": "eslint src/",
     "lint:fix": "eslint src/ --fix",
@@ -51,7 +55,6 @@
     "test:basic": "node tests/basic.test.cjs",
     "test:node": "node tests/node.test.cjs",
     "test:browser": "npm run build && node tests/browser/server.js",
-    "dev": "tsc --watch --outDir dist/esm",
     "prepublishOnly": "npm run build"
   },
   "repository": {
@@ -76,6 +79,11 @@
     "url": "https://github.com/siarheidudko/redux-cluster-ws/issues"
   },
   "homepage": "https://github.com/siarheidudko/redux-cluster-ws#readme",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "funding": [
     {
       "type": "individual",
@@ -96,9 +104,9 @@
   ],
   "dependencies": {
     "@sergdudko/objectstream": "^3.2.26",
-    "protoobject": "^1.1.30",
+    "protoobject": "^2.0.1",
     "redux": "^5.0.1",
-    "redux-cluster": "^2.0.2"
+    "redux-cluster": "^2.0.3"
   },
   "devDependencies": {
     "@eslint/js": "^9.35.0",

package/FUNDING.yml

@@ -1,7 +0,0 @@
-patreon: dudko_dev
-custom:
-  [
-    "http://dudko.dev/donate",
-    "https://paypal.me/dudkodev",
-    "https://www.buymeacoffee.com/dudko.dev",
-  ]