redux-cluster 1.10.0 → 2.0.0

package/dist/esm/utils/crypto.js

@@ -0,0 +1,351 @@
+import * as crypto from "crypto";
+import { Transform } from "stream";
+import { SerializationMode } from "../types";
+// Import ObjectStream components - optional dependency
+let Stringifer = null;
+let Parser = null;
+// Initialize ObjectStream if available
+async function initializeObjectStream() {
+    try {
+        const objectStreamModule = await import("@sergdudko/objectstream");
+        Stringifer = objectStreamModule.Stringifer;
+        Parser = objectStreamModule.Parser;
+    }
+    catch {
+        // ObjectStream is optional
+    }
+}
+// Initialize once
+initializeObjectStream();
+// Import ProtoObject - optional dependency
+let protoObjectConstructor = null;
+// Initialize ProtoObject if available
+async function initializeProtoObject() {
+    try {
+        const protoObjectModule = await import("protoobject");
+        protoObjectConstructor = protoObjectModule.ProtoObject ||
+            protoObjectModule.default ||
+            protoObjectModule;
+    }
+    catch {
+        // ProtoObject is optional
+    }
+}
+// Initialize once
+initializeProtoObject();
+// Check if ProtoObject is available
+function isProtoObjectAvailable() {
+    return protoObjectConstructor !== null;
+}
+// Get ProtoObject class (proper TypeScript way)
+function getProtoObjectClass() {
+    return protoObjectConstructor;
+}
+// Generate hash for reducer names
+export function hasher(input) {
+    return crypto.createHash("md5").update(input).digest("hex");
+}
+// Create cipher for encryption
+export function createCipher(key) {
+    const iv = crypto.randomBytes(16);
+    return crypto.createCipheriv("aes-256-ctr", Buffer.from(key), iv);
+}
+// Create decipher for decryption
+export function createDecipher(key, iv) {
+    return crypto.createDecipheriv("aes-256-ctr", Buffer.from(key), iv);
+}
+// Encryption function for backup
+export function encrypter(data, password) {
+    const key = crypto.scryptSync(password, "salt", 32);
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv("aes-256-ctr", key, iv);
+    let encrypted = cipher.update(data, "utf8", "hex");
+    encrypted += cipher.final("hex");
+    return iv.toString("hex") + ":" + encrypted;
+}
+// Decryption function for backup
+export function decrypter(encryptedData, password) {
+    const [ivHex, encrypted] = encryptedData.split(":");
+    const key = crypto.scryptSync(password, "salt", 32);
+    const iv = Buffer.from(ivHex, "hex");
+    const decipher = crypto.createDecipheriv("aes-256-ctr", key, iv);
+    let decrypted = decipher.update(encrypted, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+}
+// Utility function for deep cloning objects
+export function deepClone(obj) {
+    if (typeof structuredClone === "function") {
+        return structuredClone(obj);
+    }
+    return JSON.parse(JSON.stringify(obj));
+}
+// Universal cloning function based on mode
+export function universalClone(obj, mode, _classRegistry) {
+    if (mode === SerializationMode.PROTOOBJECT && isProtoObjectAvailable()) {
+        return protoObjectClone(obj);
+    }
+    return deepClone(obj);
+}
+// ProtoObject cloning function that handles nested ProtoObject instances
+export function protoObjectClone(obj) {
+    const ProtoObjectClass = getProtoObjectClass();
+    if (!ProtoObjectClass) {
+        return deepClone(obj);
+    }
+    // If it's not a ProtoObject, use regular deep clone
+    if (!(obj instanceof ProtoObjectClass)) {
+        return deepClone(obj);
+    }
+    // Create a new ProtoObject with all properties
+    const clonedData = {};
+    // Copy all enumerable properties
+    for (const key of Object.keys(obj)) {
+        const value = obj[key];
+        if (value instanceof ProtoObjectClass) {
+            // Recursively clone nested ProtoObject
+            clonedData[key] = protoObjectClone(value);
+        }
+        else if (Array.isArray(value)) {
+            // Clone arrays with potential ProtoObject elements
+            clonedData[key] = value.map((item) => item instanceof ProtoObjectClass
+                ? protoObjectClone(item)
+                : deepClone(item));
+        }
+        else if (value !== null && typeof value === "object") {
+            // Clone nested objects
+            clonedData[key] = deepClone(value);
+        }
+        else {
+            // Copy primitive values
+            clonedData[key] = value;
+        }
+    }
+    return new ProtoObjectClass(clonedData);
+}
+// Universal serialization function
+export function universalSerialize(obj, mode, classRegistry) {
+    if (mode === SerializationMode.PROTOOBJECT && isProtoObjectAvailable()) {
+        return serializeProtoObject(obj, classRegistry);
+    }
+    // Default JSON serialization
+    return JSON.stringify(obj);
+}
+// Universal deserialization function
+export function universalDeserialize(str, mode, classRegistry) {
+    if (mode === SerializationMode.PROTOOBJECT && isProtoObjectAvailable()) {
+        return deserializeProtoObject(str, classRegistry);
+    }
+    // Default JSON deserialization
+    return JSON.parse(str);
+}
+// ProtoObject serialization for IPC with class information
+export function serializeProtoObject(obj, classRegistry) {
+    const ProtoObjectClass = getProtoObjectClass();
+    if (!ProtoObjectClass) {
+        return JSON.stringify(obj);
+    }
+    const serialize = (value) => {
+        if (value instanceof ProtoObjectClass) {
+            const data = {
+                __isProtoObject: true,
+                __className: value.constructor.name,
+            };
+            // Store class information if registry is provided
+            if (classRegistry && value.constructor.name !== "ProtoObject") {
+                classRegistry.set(value.constructor.name, value.constructor);
+            }
+            for (const key of Object.keys(value)) {
+                data[key] = serialize(value[key]);
+            }
+            return data;
+        }
+        else if (Array.isArray(value)) {
+            return value.map(serialize);
+        }
+        else if (value !== null && typeof value === "object") {
+            const result = {};
+            for (const [key, val] of Object.entries(value)) {
+                result[key] = serialize(val);
+            }
+            return result;
+        }
+        return value;
+    };
+    return JSON.stringify(serialize(obj));
+}
+// ProtoObject deserialization for IPC with class reconstruction
+export function deserializeProtoObject(str, classRegistry) {
+    const ProtoObjectClass = getProtoObjectClass();
+    if (!ProtoObjectClass) {
+        return JSON.parse(str);
+    }
+    const deserialize = (value) => {
+        if (value && typeof value === "object" && value.__isProtoObject) {
+            const className = value.__className;
+            const data = {};
+            for (const [key, val] of Object.entries(value)) {
+                if (key !== "__isProtoObject" && key !== "__className") {
+                    data[key] = deserialize(val);
+                }
+            }
+            // Try to use registered class, fallback to ProtoObject
+            if (className && classRegistry && classRegistry.has(className)) {
+                const ClassConstructor = classRegistry.get(className);
+                return new ClassConstructor(data);
+            }
+            else {
+                return new ProtoObjectClass(data);
+            }
+        }
+        else if (Array.isArray(value)) {
+            return value.map(deserialize);
+        }
+        else if (value !== null && typeof value === "object") {
+            const result = {};
+            for (const [key, val] of Object.entries(value)) {
+                result[key] = deserialize(val);
+            }
+            return result;
+        }
+        return value;
+    };
+    return deserialize(JSON.parse(str));
+}
+// Helper function to create a shared class registry
+export function createClassRegistry() {
+    return new Map();
+}
+// Stream pipeline functions for buffer->json->class->json->buffer processing
+// Create ObjectStream Parser for JSON parsing (Buffer -> Object)
+export function createObjectStreamParser() {
+    if (Parser) {
+        return new Parser();
+    }
+    return null;
+}
+// Create ObjectStream Stringifier for JSON serialization (Object -> Buffer)
+export function createObjectStreamStringifier() {
+    if (Stringifer) {
+        return new Stringifer();
+    }
+    return null;
+}
+// Legacy function for backward compatibility
+export function createObjectStream() {
+    return createObjectStreamParser();
+}
+// Create transform stream that converts JSON objects to ProtoObject instances
+export function createDeserializationStream(mode, classRegistry) {
+    return new Transform({
+        objectMode: true,
+        transform(chunk, encoding, callback) {
+            try {
+                if (mode === SerializationMode.PROTOOBJECT &&
+                    isProtoObjectAvailable()) {
+                    const deserialized = deserializeFromObject(chunk, classRegistry);
+                    callback(null, deserialized);
+                }
+                else {
+                    callback(null, chunk);
+                }
+            }
+            catch (error) {
+                callback(error instanceof Error ? error : new Error(String(error)));
+            }
+        },
+    });
+}
+// Create transform stream that converts ProtoObject instances to JSON objects
+export function createSerializationStream(mode, classRegistry) {
+    return new Transform({
+        objectMode: true,
+        transform(chunk, encoding, callback) {
+            try {
+                if (mode === SerializationMode.PROTOOBJECT &&
+                    isProtoObjectAvailable()) {
+                    const serialized = serializeToObject(chunk, classRegistry);
+                    callback(null, serialized);
+                }
+                else {
+                    callback(null, chunk);
+                }
+            }
+            catch (error) {
+                callback(error instanceof Error ? error : new Error(String(error)));
+            }
+        },
+    });
+}
+// Helper functions for object-level serialization/deserialization (without JSON.stringify)
+function serializeToObject(obj, classRegistry) {
+    const ProtoObjectClass = getProtoObjectClass();
+    if (!ProtoObjectClass) {
+        return obj;
+    }
+    const serialize = (value) => {
+        if (value instanceof ProtoObjectClass) {
+            const data = {
+                __isProtoObject: true,
+                __className: value.constructor.name,
+            };
+            // Store class information if registry is provided
+            if (classRegistry && value.constructor.name !== "ProtoObject") {
+                classRegistry.set(value.constructor.name, value.constructor);
+            }
+            for (const key of Object.keys(value)) {
+                data[key] = serialize(value[key]);
+            }
+            return data;
+        }
+        else if (Array.isArray(value)) {
+            return value.map(serialize);
+        }
+        else if (value !== null && typeof value === "object") {
+            const result = {};
+            for (const [key, val] of Object.entries(value)) {
+                result[key] = serialize(val);
+            }
+            return result;
+        }
+        return value;
+    };
+    return serialize(obj);
+}
+function deserializeFromObject(obj, classRegistry) {
+    const ProtoObjectClass = getProtoObjectClass();
+    if (!ProtoObjectClass) {
+        return obj;
+    }
+    const deserialize = (value) => {
+        if (value && typeof value === "object" && value.__isProtoObject) {
+            const className = value.__className;
+            const data = {};
+            for (const [key, val] of Object.entries(value)) {
+                if (key !== "__isProtoObject" && key !== "__className") {
+                    data[key] = deserialize(val);
+                }
+            }
+            // Try to use registered class, fallback to ProtoObject
+            if (className && classRegistry && classRegistry.has(className)) {
+                const ClassConstructor = classRegistry.get(className);
+                return new ClassConstructor(data);
+            }
+            else {
+                return new ProtoObjectClass(data);
+            }
+        }
+        else if (Array.isArray(value)) {
+            return value.map(deserialize);
+        }
+        else if (value !== null && typeof value === "object") {
+            const result = {};
+            for (const [key, val] of Object.entries(value)) {
+                result[key] = deserialize(val);
+            }
+            return result;
+        }
+        return value;
+    };
+    return deserialize(obj);
+}

package/package.json

@@ -1,34 +1,115 @@
-{
-  "name": "redux-cluster",
-  "version": "1.10.0",
-  "description": "Cluster module for redux synchronizes all redux store in cluster processes.",
-  "main": "index.js",
-  "scripts": {
-    "test": "node test.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/siarheidudko/redux-cluster.git"
-  },
-  "keywords": [
-    "redux",
-    "cluster",
-    "ipc",
-    "process"
-  ],
-  "author": "Siarhei Dudko",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/siarheidudko/redux-cluster/issues"
-  },
-  "homepage": "https://github.com/siarheidudko/redux-cluster#readme",
-  "dependencies": {
-    "@sergdudko/objectstream": "^1.6.0",
-    "event-stream": "^3.3.5",
-    "lodash": "^4.17.15",
-    "redux": "^4.0.4"
-  },
-  "devDependencies": {
-    "colors": "^1.4.0"
-  }
-}
+{
+  "name": "redux-cluster",
+  "version": "2.0.0",
+  "type": "module",
+  "description": "TypeScript cluster module for Redux that synchronizes Redux stores across cluster processes via IPC and TCP sockets",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    }
+  },
+  "files": [
+    "dist/esm/**/*",
+    "dist/cjs/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "funding": [
+    {
+      "type": "individual",
+      "url": "http://dudko.dev/donate"
+    },
+    {
+      "type": "buymeacoffee",
+      "url": "https://www.buymeacoffee.com/dudko.dev"
+    },
+    {
+      "type": "paypal",
+      "url": "https://paypal.me/dudkodev"
+    },
+    {
+      "type": "patreon",
+      "url": "https://patreon.com/dudko_dev"
+    }
+  ],
+  "scripts": {
+    "build": "npm run clean && npm run build:esm && npm run build:cjs && npm run build:pkg",
+    "build:esm": "tsc",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:pkg": "./scripts/create-package-files.sh",
+    "build:watch": "tsc --watch",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build",
+    "test": "npm run test:all",
+    "test:all": "node --test --import tsx tests/unit.test.ts tests/error.test.ts tests/transport.test.ts",
+    "test:unit": "node --test --import tsx tests/unit.test.ts",
+    "test:transport": "node --test --import tsx tests/transport.test.ts",
+    "test:cluster": "node --test --import tsx tests/cluster.test.ts",
+    "test:integration": "node --test --import tsx tests/integration.test.ts",
+    "test:error": "node --test --import tsx tests/error.test.ts",
+    "test:integration-full": "./integration/run-tests.sh",
+    "lint": "eslint src/**/*.ts tests/**/*.ts",
+    "lint:fix": "eslint src/**/*.ts tests/**/*.ts --fix",
+    "example:basic": "node examples/basic.js",
+    "example:server": "node examples/server.js",
+    "example:client": "node examples/client.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/siarheidudko/redux-cluster.git"
+  },
+  "keywords": [
+    "redux",
+    "cluster",
+    "ipc",
+    "process",
+    "typescript",
+    "synchronization",
+    "distributed",
+    "tcp",
+    "socket"
+  ],
+  "author": {
+    "name": "Siarhei Dudko",
+    "email": "siarhei@dudko.dev",
+    "url": "https://dudko.dev"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/siarheidudko/redux-cluster/issues"
+  },
+  "homepage": "https://github.com/siarheidudko/redux-cluster#readme",
+  "dependencies": {
+    "@sergdudko/objectstream": "^3.2.26",
+    "protoobject": "^1.1.30",
+    "redux": "^5.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.17",
+    "@typescript-eslint/eslint-plugin": "^8.42.0",
+    "@typescript-eslint/parser": "^8.42.0",
+    "eslint": "^9.35.0",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.20.5",
+    "typescript": "^5.5.4"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "overrides": {
+    "debug": ">=4.3.7"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}