not-node 6.1.8 → 6.2.0

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.8",
+	"version": "6.2.0",
 	"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/identity/identity.js

@@ -22,16 +22,16 @@ class Identity {
 
     static setPrimaryRoles(list = []) {
         this.#primaryRoles = [...list];
-        this.#providers.forEach((itm) => {
-            itm.setPrimaryRoles([...list]);
+        Object.keys(this.#providers).forEach((itm) => {
+            this.#providers[itm].setPrimaryRoles([...list]);
         });
         return this;
     }
 
     static setSecondaryRoles(list = []) {
         this.#secondaryRoles = [...list];
-        this.#providers.forEach((itm) => {
-            itm.setSecondaryRoles([...list]);
+        Object.keys(this.#providers).forEach((itm) => {
+            this.#providers[itm].setSecondaryRoles([...list]);
         });
         return this;
     }

package/src/identity/providers/session.js

@@ -13,11 +13,11 @@ module.exports = class IdentityProviderSession {
     }
 
     static setPrimaryRoles(list = []) {
-        this.#options.primaryRoles = list;
+        IdentityProviderSession.#getOptions().primaryRoles = [...list];
     }
 
     static setSecondaryRoles(list = []) {
-        this.#options.secondaryRoles = list;
+        IdentityProviderSession.#getOptions().secondaryRoles = [...list];
     }
 
     constructor(req) {
@@ -42,7 +42,11 @@ module.exports = class IdentityProviderSession {
     getPrimaryRole() {
         const roles = this.getRole();
         for (let role of roles) {
-            if (this.#options.primaryRoles.includes(role)) {
+            if (
+                IdentityProviderSession.#getOptions().primaryRoles.includes(
+                    role
+                )
+            ) {
                 return role;
             }
         }

package/src/identity/providers/token.js

@@ -22,11 +22,11 @@ module.exports = class IdentityProviderToken {
     }
 
     static setPrimaryRoles(list = []) {
-        this.#options.primaryRoles = list;
+        IdentityProviderToken.#getOptions().primaryRoles = [...list];
     }
 
     static setSecondaryRoles(list = []) {
-        this.#options.secondaryRoles = list;
+        IdentityProviderToken.#getOptions().secondaryRoles = [...list];
     }
 
     constructor(req) {
@@ -186,7 +186,9 @@ module.exports = class IdentityProviderToken {
     getPrimaryRole() {
         const roles = this.getRole();
         for (let role of roles) {
-            if (this.#options.primaryRoles.includes(role)) {
+            if (
+                IdentityProviderToken.#getOptions().primaryRoles.includes(role)
+            ) {
                 return role;
             }
         }