not-node 6.1.9 → 6.2.1

package/index.js

@@ -54,3 +54,9 @@ module.exports.Generic = require("./src/generic/index.js");
 module.exports.notMetasStyler = require("./src/metas.js");
 //for http headers files, web pages, XHR etc
 module.exports.notHeadersStyler = require("./src/headers.js");
+
+/** Interconnect between instances */
+//static interface
+module.exports.notCluster = require("./src/cluster");
+//static provider
+module.exports.notClusterRedisProvider = require("./src/cluster/cluster.redis");

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "not-node",
-	"version": "6.1.9",
+	"version": "6.2.1",
 	"description": "node complimentary part for client side notFramework.",
 	"main": "index.js",
 	"scripts": {

package/src/cluster/cluster.redis.js

@@ -0,0 +1,120 @@
+const notEnv = require("../env.js");
+const notCommon = require("../common");
+const { error } = require("not-log")(module, "ClusterRedis");
+
+module.exports = class notClusterRedisProvider {
+    static #clientGetter = null;
+    static #clientName = "db.redis";
+    static #subscriber = null;
+    static #publisher = null;
+
+    static async setClientName(name) {
+        try {
+            this.#clientName = name;
+            await this.#resetClient();
+        } catch (e) {
+            error(e);
+        }
+    }
+
+    static async setClientGetter(getter) {
+        try {
+            this.#clientGetter = getter;
+            await this.#resetClient();
+        } catch (e) {
+            error(e);
+        }
+    }
+
+    static async #resetClient() {
+        try {
+            if (this.#publisher) {
+                await this.#publisher.disconnect();
+                this.#publisher = null;
+            }
+            if (this.#subscriber) {
+                await this.#subscriber.disconnect();
+                this.#subscriber = null;
+            }
+        } catch (e) {
+            error(e);
+        }
+    }
+
+    static #getClient() {
+        try {
+            if (this.#clientGetter) {
+                return this.#clientGetter();
+            } else {
+                return notEnv.getEnv(this.#clientName);
+            }
+        } catch (e) {
+            error(e);
+        }
+    }
+
+    static async #getPublisher() {
+        try {
+            if (!this.#publisher) {
+                this.#publisher = this.#getClient().duplicate();
+                await this.#publisher.connect();
+            }
+            return this.#publisher;
+        } catch (e) {
+            error(e);
+        }
+    }
+
+    static async #getSubscriber() {
+        try {
+            if (!this.#subscriber) {
+                this.#subscriber = this.#getClient().duplicate();
+                await this.#subscriber.connect();
+            }
+            return this.#subscriber;
+        } catch (e) {
+            error(e);
+        }
+    }
+
+    static #createListener(func) {
+        return async (message) => {
+            try {
+                await notCommon.executeFunctionAsAsync(func, [
+                    JSON.parse(message),
+                ]);
+            } catch (e) {
+                error(e);
+            }
+        };
+    }
+
+    static async on(eventName, func) {
+        try {
+            const listener = this.#createListener(func);
+            const subscriber = await this.#getSubscriber();
+            await subscriber.subscribe(eventName, listener);
+            return listener;
+        } catch (e) {
+            error(e);
+        }
+    }
+
+    static async off(eventName, listener) {
+        try {
+            const subscriber = await this.#getSubscriber();
+            return subscriber.unsubscribe(eventName, listener);
+        } catch (e) {
+            error(e);
+        }
+    }
+
+    static async emit(eventName, message) {
+        try {
+            const publisher = await this.#getPublisher();
+            return publisher.publish(eventName, JSON.stringify(message));
+        } catch (e) {
+            error(e);
+        }
+    }
+};

package/src/cluster/index.js

@@ -0,0 +1,25 @@
+const { log } = require("not-log")(module, "notCluster");
+const notClusterRedis = require("./cluster.redis.js");
+
+module.exports = class notCluster {
+    static #provider = notClusterRedis;
+
+    static setProvider(newProvider) {
+        log(
+            `Setting new cluster messaging provider: ${newProvider.prototype.constructor.name}`
+        );
+        this.#provider = newProvider;
+    }
+
+    static on() {
+        return this.#provider.on(...arguments);
+    }
+
+    static off() {
+        return this.#provider.off(...arguments);
+    }
+
+    static emit() {
+        return this.#provider.emit(...arguments);
+    }
+};

package/src/fields/index.js

@@ -180,3 +180,27 @@ function getMutationForField(name, list) {
     return false;
 }
 module.exports.getMutationForField = getMutationForField;
+
+function mutateFieldSide(field, mutation, side) {
+    if (Object.hasOwn(mutation, side)) {
+        if (Object.hasOwn(field, side)) {
+            field[side] = { ...field[side], ...mutation[side] };
+        } else {
+            field[side] = mutation[side];
+        }
+    }
+}
+
+module.exports.mutateFieldSide = mutateFieldSide;
+
+function mutateField(sourceField, sourceMutation) {
+    const sides = ["ui", " model"];
+    let field = structuredClone(sourceField);
+    let mutation = structuredClone(sourceMutation);
+    if (mutation) {
+        sides.forEach((side) => mutateFieldSide(field, mutation, side));
+    }
+    return field;
+}
+
+module.exports.mutateField = mutateField;