redux-cluster 1.10.0 → 2.0.1

package/dist/esm/core/redux-cluster.js

@@ -0,0 +1,363 @@
+import { createStore } from "redux";
+import cluster from "cluster";
+import { readFileSync } from "fs";
+import { join } from "path";
+import { hasher, universalClone, universalSerialize, universalDeserialize, createClassRegistry, } from "../utils/crypto";
+import { MessageType, SerializationMode, } from "../types";
+import { ClusterServer } from "../network/server";
+import { ClusterClient } from "../network/client";
+import { BackupManager } from "./backup";
+// Global reducers registry to prevent name conflicts
+const reducers = {};
+export class ReduxCluster {
+    constructor(reducer, config = {}) {
+        this.role = [];
+        this.connected = false;
+        this.mode = "action";
+        this.resync = 1000;
+        this.stderr = console.error;
+        this.allsock = {};
+        this.classRegistry = createClassRegistry();
+        this.altReducer = reducer;
+        this.RCHash = hasher(reducer.name) || "";
+        // Set configuration with defaults
+        this.config = {
+            serializationMode: SerializationMode.JSON,
+            debug: false,
+            ...config,
+        };
+        // Apply configuration to instance properties
+        if (config.mode)
+            this.mode = config.mode;
+        if (config.role)
+            this.role.push(...config.role);
+        if (config.stderr)
+            this.stderr = config.stderr;
+        if (config.resync)
+            this.resync = config.resync;
+        // Initialize class registry only if ProtoObject mode is enabled
+        if (this.config.serializationMode === SerializationMode.PROTOOBJECT) {
+            this.classRegistry = createClassRegistry();
+        }
+        // Load package info
+        try {
+            let packagePath;
+            try {
+                // Try CommonJS approach first (__dirname available)
+                packagePath = join(__dirname, "../../package.json");
+            }
+            catch {
+                // Fallback - use relative path from process.cwd()
+                packagePath = join(process.cwd(), "package.json");
+            }
+            const packageJson = JSON.parse(readFileSync(packagePath, "utf8"));
+            this.version = packageJson.version;
+            this.homepage = packageJson.homepage;
+        }
+        catch {
+            this.version = "2.0.0";
+            this.homepage = "https://github.com/siarheidudko/redux-cluster";
+        }
+        // Validate reducer uniqueness (only if different hash)
+        if (typeof reducers[reducer.name] !== "undefined" &&
+            reducers[reducer.name] !== this.RCHash) {
+            throw new Error("Please don't use a reducer with the same name!");
+        }
+        reducers[reducer.name] = this.RCHash;
+        // Get default state
+        try {
+            const defaultState = this.altReducer(undefined, {});
+            if (typeof defaultState === "object" && defaultState !== null) {
+                this.defaultState = defaultState;
+            }
+            else {
+                throw new Error("The returned value is not an object.");
+            }
+        }
+        catch {
+            this.defaultState = {};
+        }
+        // Create Redux store with custom reducer
+        this.store = createStore(this.createNewReducer());
+        // Bind Redux methods
+        this.dispatch = this.store.dispatch;
+        this.getState = this.store.getState;
+        this.subscribe = this.store.subscribe;
+        this.replaceReducer = this.store.replaceReducer;
+        this[Symbol.observable] = this.store[Symbol.observable];
+        this.initializeClusterRole();
+    }
+    // Internal method for sync actions
+    internalSync(payload) {
+        this.store.dispatch({
+            type: MessageType.SYNC,
+            payload,
+            _internal: true,
+        });
+    }
+    // Expose internal sync for backup purposes
+    _internalSync(payload) {
+        this.internalSync(payload);
+    }
+    createNewReducer() {
+        return (state = this.defaultState, action) => {
+            // Handle sync action (internal use only)
+            if (action.type === MessageType.SYNC) {
+                // Check if this is an internal sync call
+                const syncAction = action;
+                if (syncAction._internal) {
+                    return universalClone(syncAction.payload, this.config.serializationMode, this.classRegistry);
+                }
+                else {
+                    throw new Error("Please don't use REDUX_CLUSTER_SYNC action type!");
+                }
+            }
+            // Handle sync mode
+            if (this.mode === "action") {
+                this.updateCounter();
+                this.sendActionsToNodes(action);
+            }
+            return this.altReducer(state, action);
+        };
+    }
+    updateCounter() {
+        if (typeof this.counter === "undefined" || this.counter === this.resync) {
+            this.counter = 1;
+        }
+        else {
+            this.counter++;
+        }
+        // Periodic full sync
+        if (this.counter === this.resync) {
+            if (this.role.includes("master")) {
+                setTimeout(() => this.sendtoall(), 100);
+            }
+            if (this.role.includes("server")) {
+                setTimeout(() => this.sendtoallsock(), 100);
+            }
+        }
+    }
+    sendActionsToNodes(action) {
+        if (this.role.includes("master")) {
+            setTimeout(() => this.sendtoall({
+                _msg: MessageType.MSG_TO_WORKER,
+                _hash: this.RCHash,
+                _action: action,
+            }), 1);
+        }
+        if (this.role.includes("server")) {
+            setTimeout(() => this.sendtoallsock({
+                _msg: MessageType.MSG_TO_WORKER,
+                _hash: this.RCHash,
+                _action: action,
+            }), 1);
+        }
+    }
+    initializeClusterRole() {
+        // Assign "master" role only to primary process in cluster
+        if (cluster.isPrimary) {
+            this.initializeMaster();
+        }
+        else {
+            // Assign "worker" role to non-master processes
+            this.initializeWorker();
+        }
+    }
+    initializeMaster() {
+        if (!this.role.includes("master")) {
+            this.role.push("master");
+        }
+        // Subscribe to changes in snapshot mode
+        this.unsubscribe = this.subscribe(() => {
+            if (this.mode === "snapshot") {
+                this.sendtoall();
+            }
+        });
+        // Listen for messages from workers
+        cluster.on("message", (worker, message, _handle) => {
+            if (arguments.length === 2) {
+                _handle = message;
+                message = worker;
+                worker = undefined;
+            }
+            this.handleMasterMessage(message, worker);
+        });
+        this.connected = true;
+    }
+    initializeWorker() {
+        if (!this.role.includes("worker")) {
+            this.role.push("worker");
+        }
+        // Override dispatch to send to master
+        this.dispatchNEW = this.dispatch;
+        this.dispatch = (action) => {
+            if (process.send) {
+                process.send({
+                    _msg: MessageType.MSG_TO_MASTER,
+                    _hash: this.RCHash,
+                    _action: action,
+                });
+            }
+        };
+        // Listen for messages from master
+        process.on("message", (data) => {
+            this.handleWorkerMessage(data);
+        });
+        this.connected = true;
+        // Request initial state
+        if (process.send) {
+            process.send({
+                _msg: MessageType.START,
+                _hash: this.RCHash,
+            });
+        }
+    }
+    handleMasterMessage(message, worker) {
+        if (message._hash === this.RCHash) {
+            switch (message._msg) {
+                case MessageType.MSG_TO_MASTER:
+                    if (message._action.type === MessageType.SYNC &&
+                        !message._action._internal) {
+                        throw new Error("Please don't use REDUX_CLUSTER_SYNC action type!");
+                    }
+                    // Deserialize action if it contains ProtoObject
+                    let action = message._action;
+                    if (message._serialized) {
+                        try {
+                            action = universalDeserialize(message._serialized, this.config.serializationMode, this.classRegistry)._action;
+                        }
+                        catch {
+                            // Fallback to regular action
+                            action = message._action;
+                        }
+                    }
+                    this.store.dispatch(action);
+                    break;
+                case MessageType.START:
+                    const responseMsg = {
+                        _msg: MessageType.MSG_TO_WORKER,
+                        _hash: this.RCHash,
+                        _action: {
+                            type: MessageType.SYNC,
+                            payload: this.getState(),
+                            _internal: true,
+                        },
+                    };
+                    const serializedResponse = {
+                        ...responseMsg,
+                        _serialized: universalSerialize(responseMsg, this.config.serializationMode, this.classRegistry),
+                    };
+                    if (worker && cluster.workers && cluster.workers[worker.id]) {
+                        cluster.workers[worker.id].send(serializedResponse);
+                    }
+                    else {
+                        this.sendtoall();
+                    }
+                    break;
+                default:
+                    // Ignore unknown message types
+                    break;
+            }
+        }
+    }
+    handleWorkerMessage(data) {
+        if (data._hash === this.RCHash && this.role.includes("worker")) {
+            // Deserialize ProtoObject if needed
+            let processedData = data;
+            if (data._serialized) {
+                try {
+                    processedData = JSON.parse(data._serialized);
+                    processedData = universalDeserialize(data._serialized, this.config.serializationMode, this.classRegistry);
+                }
+                catch {
+                    // Fallback to regular data if deserialization fails
+                    processedData = data;
+                }
+            }
+            switch (processedData._msg) {
+                case MessageType.MSG_TO_WORKER:
+                    if (this.dispatchNEW) {
+                        this.dispatchNEW(processedData._action);
+                    }
+                    break;
+                case MessageType.CONN_STATUS:
+                    this.connected = processedData._connected;
+                    break;
+                default:
+                    // Ignore unknown message types
+                    break;
+            }
+        }
+    }
+    sendtoall(message) {
+        if (cluster.isPrimary && cluster.workers) {
+            const msg = message || {
+                _msg: MessageType.MSG_TO_WORKER,
+                _hash: this.RCHash,
+                _action: {
+                    type: MessageType.SYNC,
+                    payload: this.getState(),
+                    _internal: true,
+                },
+            };
+            // Serialize ProtoObject instances for IPC
+            const serializedMsg = {
+                ...msg,
+                _serialized: universalSerialize(msg, this.config.serializationMode, this.classRegistry),
+            };
+            for (const id in cluster.workers) {
+                if (cluster.workers[id]) {
+                    cluster.workers[id].send(serializedMsg);
+                }
+            }
+        }
+    }
+    sendtoallsock(message) {
+        for (const id in this.allsock) {
+            if (typeof this.allsock[id] === "object" &&
+                typeof this.allsock[id].sendtoall === "function") {
+                setTimeout(() => this.allsock[id].sendtoall(message), 1);
+            }
+        }
+    }
+    createServer(settings) {
+        if (!cluster.isPrimary && settings?.path && process.platform === "win32") {
+            throw new Error("Named channel is not supported in the child process, please use TCP-server");
+        }
+        if (!this.role.includes("server")) {
+            this.role.push("server");
+        }
+        this.connected = false;
+        return new ClusterServer(this, settings);
+    }
+    createClient(settings) {
+        if (this.role.includes("client")) {
+            throw new Error("One storage cannot be connected to two servers at the same time.");
+        }
+        if (!this.role.includes("client")) {
+            this.role.push("client");
+        }
+        this.connected = false;
+        return new ClusterClient(this, settings);
+    }
+    backup(settings) {
+        return new BackupManager(this, settings).initialize();
+    }
+    // Register custom ProtoObject classes for proper serialization
+    registerClass(name, classConstructor) {
+        if (this.config.serializationMode === SerializationMode.PROTOOBJECT) {
+            this.classRegistry.set(name, classConstructor);
+        }
+        else {
+            console.warn("registerClass() is only available in ProtoObject mode");
+        }
+    }
+    // Get registered classes (useful for debugging)
+    getRegisteredClasses() {
+        if (this.config.serializationMode === SerializationMode.PROTOOBJECT) {
+            return Array.from(this.classRegistry.keys());
+        }
+        return [];
+    }
+}
+Symbol.observable;

package/dist/esm/index.d.ts

@@ -0,0 +1,22 @@
+import { Reducer, Action, combineReducers, bindActionCreators, applyMiddleware, compose } from "redux";
+import { ReduxCluster } from "./core/redux-cluster";
+import { ReduxClusterConfig } from "./types";
+import { hasher } from "./utils/crypto";
+export * from "redux";
+export * from "./types";
+export declare const functions: {
+    hasher: typeof hasher;
+};
+export declare function createStore<S = any, A extends Action = Action>(reducer: Reducer<S, A>, config?: ReduxClusterConfig): ReduxCluster<S, A>;
+declare const _default: {
+    createStore: typeof createStore;
+    functions: {
+        hasher: typeof hasher;
+    };
+    combineReducers: typeof combineReducers;
+    bindActionCreators: typeof bindActionCreators;
+    applyMiddleware: typeof applyMiddleware;
+    compose: typeof compose;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,MAAM,EACN,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,OAAO,EACR,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAGxC,cAAc,OAAO,CAAC;AAGtB,cAAc,SAAS,CAAC;AAGxB,eAAO,MAAM,SAAS;;CAErB,CAAC;AAGF,wBAAgB,WAAW,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,EAC5D,OAAO,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EACtB,MAAM,CAAC,EAAE,kBAAkB,GAC1B,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAEpB;;;;;;;;;;;AAGD,wBAQE"}

package/dist/esm/index.js

@@ -0,0 +1,25 @@
+import { combineReducers, bindActionCreators, applyMiddleware, compose, } from "redux";
+import { ReduxCluster } from "./core/redux-cluster";
+import { hasher } from "./utils/crypto";
+// Re-export Redux functions and types
+export * from "redux";
+// Export our types
+export * from "./types";
+// Export utility functions
+export const functions = {
+    hasher,
+};
+// Main function to create a ReduxCluster store
+export function createStore(reducer, config) {
+    return new ReduxCluster(reducer, config);
+}
+// Default export for CommonJS compatibility
+export default {
+    createStore,
+    functions,
+    // Re-export Redux
+    combineReducers,
+    bindActionCreators,
+    applyMiddleware,
+    compose,
+};

package/dist/esm/network/client.d.ts

@@ -0,0 +1,23 @@
+import { ReduxClusterStore, ClientSettings } from "../types";
+export declare class ClusterClient {
+    private store;
+    private settings;
+    login?: string;
+    password?: string;
+    private client;
+    private listenOptions;
+    private shouldReconnect;
+    private reconnectTimeout?;
+    constructor(store: ReduxClusterStore, settings?: ClientSettings);
+    private setupCredentials;
+    private setupConnection;
+    private getListenOptions;
+    private setupEventHandlers;
+    private handleConnection;
+    private handleDisconnection;
+    private setupPipeline;
+    private handleServerMessage;
+    private connectToServer;
+    disconnect(): void;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/esm/network/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/network/client.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAe,MAAM,UAAU,CAAC;AAG1E,qBAAa,aAAa;IAUtB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,QAAQ;IAVX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAEzB,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,aAAa,CAAM;IAC3B,OAAO,CAAC,eAAe,CAAiB;IACxC,OAAO,CAAC,gBAAgB,CAAC,CAAiB;gBAGhC,KAAK,EAAE,iBAAiB,EACxB,QAAQ,GAAE,cAAmB;IAOvC,OAAO,CAAC,gBAAgB;IASxB,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,gBAAgB;IAuBxB,OAAO,CAAC,kBAAkB;IAgB1B,OAAO,CAAC,gBAAgB;IA6CxB,OAAO,CAAC,mBAAmB;IAgB3B,OAAO,CAAC,aAAa;IA2DrB,OAAO,CAAC,mBAAmB;IA4C3B,OAAO,CAAC,eAAe;IAIhB,UAAU,IAAI,IAAI;CAmB1B"}

package/dist/esm/network/client.js

@@ -0,0 +1,214 @@
+import * as net from "net";
+import * as os from "os";
+import * as path from "path";
+import * as zlib from "zlib";
+import * as stream from "stream";
+import { MessageType } from "../types";
+import { hasher } from "../utils/crypto";
+export class ClusterClient {
+    constructor(store, settings = {}) {
+        this.store = store;
+        this.settings = settings;
+        this.shouldReconnect = true;
+        this.setupCredentials();
+        this.setupConnection();
+        this.connectToServer();
+    }
+    setupCredentials() {
+        if (typeof this.settings.login === "string") {
+            this.login = hasher(`REDUX_CLUSTER${this.settings.login}`);
+        }
+        if (typeof this.settings.password === "string") {
+            this.password = hasher(`REDUX_CLUSTER${this.settings.password}`);
+        }
+    }
+    setupConnection() {
+        this.listenOptions = this.getListenOptions();
+        this.client = new net.Socket();
+        this.setupEventHandlers();
+        this.setupPipeline();
+    }
+    getListenOptions() {
+        const defaultOptions = { port: 10001 };
+        if (typeof this.settings.path === "string") {
+            switch (os.platform()) {
+                case "win32":
+                    return { path: path.join("\\\\?\\pipe", this.settings.path) };
+                default:
+                    return { path: path.join(this.settings.path) };
+            }
+        }
+        const options = { ...defaultOptions };
+        if (typeof this.settings.host === "string") {
+            options.host = this.settings.host;
+        }
+        if (typeof this.settings.port === "number") {
+            options.port = this.settings.port;
+        }
+        return options;
+    }
+    setupEventHandlers() {
+        this.client.on("connect", () => {
+            this.handleConnection();
+        });
+        this.client.on("close", () => {
+            this.handleDisconnection();
+        });
+        this.client.on("error", (err) => {
+            this.store.stderr(`ReduxCluster.createClient client error: ${err.message}`);
+        });
+    }
+    handleConnection() {
+        this.store.connected = true;
+        this.store.sendtoall({
+            _msg: MessageType.CONN_STATUS,
+            _hash: this.store.RCHash,
+            _connected: true,
+        });
+        // Override write method for object mode + compression
+        this.client.writeNEW = this.client.write;
+        this.client.write = (data) => {
+            try {
+                const compressed = zlib.gzipSync(Buffer.from(JSON.stringify(data)));
+                return this.client.writeNEW(compressed);
+            }
+            catch (err) {
+                this.store.stderr(`ReduxCluster.createClient write error: ${err.message}`);
+                return false;
+            }
+        };
+        // Save original dispatch for local state updates
+        if (typeof this.store.dispatchNEW !== "function") {
+            this.store.dispatchNEW = this.store.dispatch;
+        }
+        // Override dispatch to send actions to server
+        this.store.dispatch = (action) => {
+            this.client.write({
+                _msg: MessageType.MSG_TO_MASTER,
+                _hash: this.store.RCHash,
+                _action: action,
+            });
+        };
+        // Authenticate with server
+        this.client.write({
+            _msg: MessageType.SOCKET_AUTH,
+            _hash: this.store.RCHash,
+            _login: this.login,
+            _password: this.password,
+        });
+    }
+    handleDisconnection() {
+        this.store.connected = false;
+        this.store.sendtoall({
+            _msg: MessageType.CONN_STATUS,
+            _hash: this.store.RCHash,
+            _connected: false,
+        });
+        // Reconnect after 250ms only if reconnection is enabled
+        if (this.shouldReconnect) {
+            this.reconnectTimeout = setTimeout(() => {
+                new ClusterClient(this.store, this.settings);
+            }, 250);
+        }
+    }
+    setupPipeline() {
+        // Create processing pipeline
+        const mbstring = new stream.Transform({
+            transform(buffer, encoding, callback) {
+                this.push(buffer);
+                callback();
+            },
+        });
+        mbstring.setEncoding("utf8");
+        const gunzipper = zlib.createGunzip();
+        // Simple JSON parser
+        const parser = new stream.Transform({
+            objectMode: true,
+            transform(chunk, encoding, callback) {
+                try {
+                    const data = JSON.parse(chunk.toString());
+                    this.push(data);
+                    callback();
+                }
+                catch {
+                    callback(); // Invalid JSON, ignore but continue
+                }
+            },
+        });
+        const eventHandler = new stream.Writable({
+            objectMode: true,
+            write: (data, encoding, callback) => {
+                this.handleServerMessage(data);
+                callback();
+            },
+        });
+        // Setup error handlers
+        [gunzipper, mbstring, parser, eventHandler].forEach((streamObj) => {
+            streamObj.on("error", (err) => {
+                this.store.stderr(`ReduxCluster.createClient stream error: ${err.message}`);
+            });
+        });
+        // Connect pipeline
+        this.client.pipe(gunzipper).pipe(mbstring).pipe(parser).pipe(eventHandler);
+    }
+    handleServerMessage(data) {
+        if (this.client.destroyed || data._hash !== this.store.RCHash) {
+            return;
+        }
+        switch (data._msg) {
+            case MessageType.MSG_TO_WORKER:
+                // Always use dispatchNEW (original dispatch) for local state updates
+                // because the regular dispatch is overridden to send to server
+                if (this.store.dispatchNEW) {
+                    // Mark SYNC actions as internal
+                    let actionToDispatch = data._action;
+                    if (actionToDispatch.type === "REDUX_CLUSTER_SYNC") {
+                        actionToDispatch = { ...actionToDispatch, _internal: true };
+                    }
+                    this.store.dispatchNEW(actionToDispatch);
+                }
+                else {
+                    this.store.stderr("dispatchNEW method not available");
+                }
+                break;
+            case MessageType.SOCKET_AUTH_STATE:
+                if (data._value === true) {
+                    // Authentication successful, request initial state
+                    this.client.write({
+                        _msg: MessageType.START,
+                        _hash: this.store.RCHash,
+                    });
+                }
+                else {
+                    // Authentication failed
+                    const error = data._banned
+                        ? new Error("your ip is locked for 3 hours")
+                        : new Error("authorization failed");
+                    this.client.destroy(error);
+                }
+                break;
+            default:
+                // Ignore unknown message types
+                break;
+        }
+    }
+    connectToServer() {
+        this.client.connect(this.listenOptions);
+    }
+    disconnect() {
+        this.shouldReconnect = false;
+        // Clear reconnection timeout if it exists
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = undefined;
+        }
+        // Remove all event listeners
+        if (this.client) {
+            this.client.removeAllListeners();
+            // Destroy the socket
+            if (!this.client.destroyed) {
+                this.client.destroy();
+            }
+        }
+    }
+}

package/dist/esm/network/server.d.ts

@@ -0,0 +1,39 @@
+import { ServerSettings, ReduxClusterStore, ClusterMessage, ClusterSocket } from "../types";
+export declare class ClusterServer {
+    private store;
+    private settings;
+    readonly uid: string;
+    readonly sockets: Record<string, ClusterSocket>;
+    readonly database: Record<string, string>;
+    readonly ip2ban: Record<string, {
+        time: number;
+        count: number;
+    }>;
+    private readonly ip2banTimeout;
+    private readonly ip2banGC;
+    private server;
+    private unsubscribe?;
+    private shouldAutoRestart;
+    constructor(store: ReduxClusterStore, settings?: ServerSettings);
+    private setupDatabase;
+    private setupBanSystem;
+    private cleanupBannedIPs;
+    private setupServer;
+    private getListenOptions;
+    private startListening;
+    private handleNewConnection;
+    private isIPBanned;
+    private rejectConnection;
+    private setupSocket;
+    private setupSocketPipeline;
+    private handleSocketMessage;
+    private handleAuthentication;
+    private recordFailedLogin;
+    private closeSocket;
+    private setupStoreIntegration;
+    sendtoall(message?: ClusterMessage): void;
+    ip2banGCStop(): void;
+    private cleanup;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=server.d.ts.map