woonplan-packages-redishelper 2.0.85 → 2.0.87

package/dist/tsc/classes/Broker.js

@@ -1,322 +1,322 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const class_validator_1 = require("class-validator");
-const ioredis_1 = tslib_1.__importDefault(require("ioredis"));
-const rollbar_1 = tslib_1.__importDefault(require("rollbar"));
-const utils_1 = require("../services/utils");
-const Listener_1 = tslib_1.__importDefault(require("./Listener"));
-const ListListener_1 = tslib_1.__importDefault(require("./ListListener"));
-const uuid_1 = require("uuid");
-const lock_1 = require("../services/lock");
-const SetWatcher_1 = tslib_1.__importDefault(require("./SetWatcher"));
-class Broker {
-    constructor(redisConfig, rollbarConfig, service, consumer) {
-        this.consumername = '';
-        this.listeners = new Map();
-        this.listprefix = 'listUpdated';
-        this.subscriptions = [];
-        this.rejectors = new Map;
-        this.resolvers = new Map;
-        this.timeouts = new Map;
-        this.redisConfig = redisConfig;
-        this.rollbar = new rollbar_1.default({
-            accessToken: rollbarConfig.accessToken,
-            environment: rollbarConfig.environment,
-        });
-        this.writer = new ioredis_1.default({
-            host: redisConfig.REDISURL,
-            password: redisConfig.REDISPW ?? ''
-        });
-        this.reader = new ioredis_1.default({
-            host: redisConfig.REDISURL,
-            password: redisConfig.REDISPW ?? ''
-        });
-        (0, lock_1.setupLock)(redisConfig);
-        this.reader.on('message', (channel, message) => this.onMessage.call(this, channel, message));
-        this.consumername = consumer;
-        this.service = service;
-    }
-    get requeststream() {
-        return this.getRequestStream(this.service);
-    }
-    getRequestStream(service) {
-        return `keyRequestedFrom${(0, utils_1.capitalizeFirstLetter)(service)}Service`;
-    }
-    createClient() {
-        return new ioredis_1.default({
-            host: this.redisConfig.REDISURL,
-            password: this.redisConfig.REDISPW ?? ''
-        });
-    }
-    createSetWatcher(setname, callback, finishedCallback, itemsPerCall = 1) {
-        new SetWatcher_1.default(this.createClient.call(this), setname, callback, finishedCallback, itemsPerCall);
-    }
-    setRequestEndpoint(callback) {
-        return this.addListener(this.requeststream, this.getRequestCallback(callback), this.service);
-    }
-    getRequestCallback(callback) {
-        return async (id, parameters) => {
-            let result = null;
-            try {
-                result = await callback(id, parameters);
-            }
-            catch (error) {
-                this.throwError(error);
-                result = JSON.stringify({
-                    rejected: true,
-                    error: {
-                        title: error?.message ?? ''
-                    }
-                });
-            }
-            finally {
-                if (!parameters.messageid)
-                    return null;
-                const channel = this.getRequestSubscriptionName(parameters.messageid);
-                return this.publish(channel, result);
-            }
-        };
-    }
-    publish(channel, result) {
-        return this.writer.publish(channel, result);
-    }
-    async createGroup(stream, group) {
-        try {
-            await this.writer.xgroup('CREATE', stream, group, '$', 'MKSTREAM');
-            return;
-        }
-        catch {
-            return;
-        }
-    }
-    addListener(stream, callback, group, deleteOnCompletion = false) {
-        const client = new ioredis_1.default({
-            host: this.redisConfig.REDISURL,
-            password: this.redisConfig.REDISPW ?? ''
-        });
-        this.createListener.call(this, client, stream, callback, group, deleteOnCompletion);
-        // dont wait for the result of create listener, just return this so we can chain
-        return this;
-    }
-    async createListener(client, stream, callback, group, deleteOnCompletion = false) {
-        if (group)
-            await this.createGroup.call(this, stream, group);
-        this.listeners.set(stream, new Listener_1.default(this, client, stream, callback, group, deleteOnCompletion));
-        console.log(`redishelper : listener added for ${stream}`);
-    }
-    addListListener(event, callback, finishedevent = '', itemsPerCall = 1) {
-        const client = new ioredis_1.default({
-            host: this.redisConfig.REDISURL,
-            password: this.redisConfig.REDISPW ?? ''
-        });
-        const channel = this.getListChannel(event);
-        this.listeners.set(channel, new ListListener_1.default(this, client, channel, callback, finishedevent, itemsPerCall));
-        console.log(`redishelper : listlistener added for ${channel}`);
-        return this;
-    }
-    async getList(listname, start = 0, stop = -1) {
-        const list = await this.reader.lrange(listname, start, stop);
-        return list;
-    }
-    async getSet(listname) {
-        const set = await this.reader.smembers(listname);
-        return set;
-    }
-    throwError(error) {
-        if (!this.rollbar)
-            throw new Error('Rollbar not initialized');
-        this.rollbar.error(error);
-    }
-    sendMessage(stream, data) {
-        console.log(`sending message to ${stream}`);
-        return this.writer.xadd(stream, '*', ...(0, utils_1.createRedisMessage)(data));
-    }
-    async sendMessageAndSubscribeForResponse(channel, target, messagedata, n = 2000) {
-        await this.subscribe(channel);
-        // send the message to the correct service
-        this.sendMessage(target, messagedata);
-        let resolver;
-        let rejecter;
-        // create a promise to be able to pass on to resolve later
-        const promise = new Promise((r, rj) => {
-            resolver = r;
-            rejecter = rj;
-        });
-        if (!resolver || !rejecter)
-            return null;
-        //setup a timeout
-        const timeout = this.setupTimeout(resolver, channel, n);
-        //setup a response
-        this.requestMessageResponse(channel, resolver, rejecter, timeout);
-        // return a promise that will resolve when the message returns or times out
-        return promise;
-    }
-    async getRequest(targetservice, key, data, timeout = 2000) {
-        // create a message id to subscribe to
-        const messageid = (0, uuid_1.v4)();
-        //subscribe to message response     
-        const channel = this.getRequestSubscriptionName(messageid);
-        return this.sendMessageAndSubscribeForResponse.call(this, channel, this.getRequestStream(targetservice), {
-            request: key,
-            messageid: messageid,
-            data: (0, utils_1.sanitizeValue)(data)
-        }, timeout);
-    }
-    async getApiRequest(endpoint, method, data, jwt = '') {
-        // create a message id to subscribe to
-        const messageid = (0, uuid_1.v4)();
-        //subscribe to message response     
-        const channel = this.getRequestSubscriptionName(messageid);
-        return this.sendMessageAndSubscribeForResponse.call(this, channel, this.getRequestStream('api'), {
-            endpoint: endpoint,
-            method: method,
-            messageid: messageid,
-            data: data,
-            jwt: jwt
-        });
-    }
-    requestMessageResponse(channel, resolver, rejector, timeout) {
-        this.resolvers.set(channel, resolver);
-        this.rejectors.set(channel, rejector);
-        this.timeouts.set(channel, timeout);
-    }
-    cleanupMessageReponse(channel) {
-        this.resolvers.delete(channel);
-        this.rejectors.delete(channel);
-        this.timeouts.delete(channel);
-    }
-    onMessage(channel, message) {
-        const rejector = this.rejectors.get(channel);
-        const resolver = this.resolvers.get(channel);
-        const timeout = this.timeouts.get(channel);
-        if (!rejector || !resolver || !timeout) {
-            this.cleanupMessageReponse.call(this, channel);
-            return;
-        }
-        // check if the request has been rejected
-        if ((0, class_validator_1.isJSON)(message)) {
-            const resolvemessage = JSON.parse(message);
-            if (resolvemessage.rejected && resolvemessage.error && resolvemessage.error?.title) {
-                rejector(new Error(resolvemessage.error.title));
-                clearTimeout(timeout);
-                return;
-            }
-        }
-        if (message.length)
-            resolver(message);
-        else
-            resolver(null);
-        this.unsubscribe(channel);
-        clearTimeout(timeout);
-    }
-    unsubscribe(channel) {
-        this.reader.unsubscribe(channel);
-        this.subscriptions = this.subscriptions.filter(s => s != channel);
-    }
-    setupTimeout(resolve, channel, n = 2000) {
-        return setTimeout(() => {
-            if (!this.subscriptions.includes(channel))
-                return;
-            console.log(`sub timedout: ${channel}`);
-            resolve(null);
-            this.unsubscribe(channel);
-        }, n);
-    }
-    subscribe(channel) {
-        this.subscriptions.push(channel);
-        return this.reader.subscribe(channel);
-    }
-    getRequestSubscriptionName(messageid) {
-        return `messageresponse${messageid}`;
-    }
-    async setKey(key, value) {
-        try {
-            return await this.writer.set(key, (0, utils_1.sanitizeValue)(value));
-        }
-        catch { }
-        return;
-    }
-    async readKey(key) {
-        try {
-            return await this.writer.get(key);
-        }
-        catch { }
-        return null;
-    }
-    async deleteKey(key) {
-        try {
-            return await this.writer.del(key);
-        }
-        catch { }
-        return;
-    }
-    async sendListEvent(event, listitems, data = {}, listname = "") {
-        if (listitems.length == 0)
-            return;
-        // if a listname exist, we first empty it 
-        if (listname.length > 0)
-            await this.deleteKey.call(this, listname);
-        const list = await this.addToSet.call(this, listitems, listname.length > 0 ? listname : undefined);
-        return this.sendMessage(this.getListChannel(event), {
-            ...data,
-            listname: list
-        });
-    }
-    async addToSet(listitems, listname) {
-        const list = listname ?? (0, uuid_1.v4)();
-        await this.writer.sadd(list, ...listitems.map(utils_1.sanitizeValue));
-        return list;
-    }
-    async addToList(listitems, listname) {
-        const list = listname ?? (0, uuid_1.v4)();
-        await this.writer.lpush(list, ...listitems.map(utils_1.sanitizeValue));
-        return list;
-    }
-    getListChannel(event) {
-        return `${this.listprefix}${event}`;
-    }
-    async getStreamMessages(stream) {
-        const streaminfo = await this.getStreamInfo.call(this, stream);
-        if (!streaminfo || !(0, class_validator_1.isArray)(streaminfo) || streaminfo.length < 10)
-            return [];
-        const params = this.decypherParameters(streaminfo);
-        if (!params.entries)
-            return [];
-        return this.decyperMessages(params.entries);
-    }
-    getStreamInfo(stream, count = 0) {
-        return this.reader.xinfo('STREAM', stream, 'FULL', 'COUNT', count);
-    }
-    async filterStream(stream, key, value) {
-        const messages = await this.getStreamMessages.call(this, stream);
-        return messages.filter(message => message.parameters?.[key] != null && message.parameters[key] == value);
-    }
-    decypherResponse(...responses) {
-        return responses.reduce((resp, response) => [
-            ...resp,
-            {
-                stream: response[0],
-                messages: this.decyperMessages(response[1])
-            }
-        ], []);
-    }
-    decyperMessages(messages) {
-        return messages.map((message) => ({
-            id: message[0],
-            parameters: this.decypherParameters(message[1])
-        }));
-    }
-    decypherParameters(parameters) {
-        return parameters.reduce((params, v, n) => (n == 0 || (n % 2 == 0)) && parameters.length >= n + 1 ? ({
-            ...params,
-            [v]: parameters[n + 1]
-        }) : params, {});
-    }
-    async isSetPickedUp(setname) {
-        const pickedup = await this.reader.get((0, utils_1.getSetPickedUpName)(setname));
-        return pickedup !== null;
-    }
-}
-exports.default = Broker;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const class_validator_1 = require("class-validator");
+const ioredis_1 = tslib_1.__importDefault(require("ioredis"));
+const rollbar_1 = tslib_1.__importDefault(require("rollbar"));
+const utils_1 = require("../services/utils");
+const Listener_1 = tslib_1.__importDefault(require("./Listener"));
+const ListListener_1 = tslib_1.__importDefault(require("./ListListener"));
+const uuid_1 = require("uuid");
+const lock_1 = require("../services/lock");
+const SetWatcher_1 = tslib_1.__importDefault(require("./SetWatcher"));
+class Broker {
+    constructor(redisConfig, rollbarConfig, service, consumer) {
+        this.consumername = '';
+        this.listeners = new Map();
+        this.listprefix = 'listUpdated';
+        this.subscriptions = [];
+        this.rejectors = new Map;
+        this.resolvers = new Map;
+        this.timeouts = new Map;
+        this.redisConfig = redisConfig;
+        this.rollbar = new rollbar_1.default({
+            accessToken: rollbarConfig.accessToken,
+            environment: rollbarConfig.environment,
+        });
+        this.writer = new ioredis_1.default({
+            host: redisConfig.REDISURL,
+            password: redisConfig.REDISPW ?? ''
+        });
+        this.reader = new ioredis_1.default({
+            host: redisConfig.REDISURL,
+            password: redisConfig.REDISPW ?? ''
+        });
+        (0, lock_1.setupLock)(redisConfig);
+        this.reader.on('message', (channel, message) => this.onMessage.call(this, channel, message));
+        this.consumername = consumer;
+        this.service = service;
+    }
+    get requeststream() {
+        return this.getRequestStream(this.service);
+    }
+    getRequestStream(service) {
+        return `keyRequestedFrom${(0, utils_1.capitalizeFirstLetter)(service)}Service`;
+    }
+    createClient() {
+        return new ioredis_1.default({
+            host: this.redisConfig.REDISURL,
+            password: this.redisConfig.REDISPW ?? ''
+        });
+    }
+    createSetWatcher(setname, callback, finishedCallback, itemsPerCall = 1) {
+        new SetWatcher_1.default(this.createClient.call(this), setname, callback, finishedCallback, itemsPerCall);
+    }
+    setRequestEndpoint(callback) {
+        return this.addListener(this.requeststream, this.getRequestCallback(callback), this.service);
+    }
+    getRequestCallback(callback) {
+        return async (id, parameters) => {
+            let result = null;
+            try {
+                result = await callback(id, parameters);
+            }
+            catch (error) {
+                this.throwError(error);
+                result = JSON.stringify({
+                    rejected: true,
+                    error: {
+                        title: error?.message ?? ''
+                    }
+                });
+            }
+            finally {
+                if (!parameters.messageid)
+                    return null;
+                const channel = this.getRequestSubscriptionName(parameters.messageid);
+                return this.publish(channel, result);
+            }
+        };
+    }
+    publish(channel, result) {
+        return this.writer.publish(channel, result);
+    }
+    async createGroup(stream, group) {
+        try {
+            await this.writer.xgroup('CREATE', stream, group, '$', 'MKSTREAM');
+            return;
+        }
+        catch {
+            return;
+        }
+    }
+    addListener(stream, callback, group, deleteOnCompletion = false) {
+        const client = new ioredis_1.default({
+            host: this.redisConfig.REDISURL,
+            password: this.redisConfig.REDISPW ?? ''
+        });
+        this.createListener.call(this, client, stream, callback, group, deleteOnCompletion);
+        // dont wait for the result of create listener, just return this so we can chain
+        return this;
+    }
+    async createListener(client, stream, callback, group, deleteOnCompletion = false) {
+        if (group)
+            await this.createGroup.call(this, stream, group);
+        this.listeners.set(stream, new Listener_1.default(this, client, stream, callback, group, deleteOnCompletion));
+        console.log(`redishelper : listener added for ${stream}`);
+    }
+    addListListener(event, callback, finishedevent = '', itemsPerCall = 1) {
+        const client = new ioredis_1.default({
+            host: this.redisConfig.REDISURL,
+            password: this.redisConfig.REDISPW ?? ''
+        });
+        const channel = this.getListChannel(event);
+        this.listeners.set(channel, new ListListener_1.default(this, client, channel, callback, finishedevent, itemsPerCall));
+        console.log(`redishelper : listlistener added for ${channel}`);
+        return this;
+    }
+    async getList(listname, start = 0, stop = -1) {
+        const list = await this.reader.lrange(listname, start, stop);
+        return list;
+    }
+    async getSet(listname) {
+        const set = await this.reader.smembers(listname);
+        return set;
+    }
+    throwError(error) {
+        if (!this.rollbar)
+            throw new Error('Rollbar not initialized');
+        this.rollbar.error(error);
+    }
+    sendMessage(stream, data) {
+        console.log(`sending message to ${stream}`);
+        return this.writer.xadd(stream, '*', ...(0, utils_1.createRedisMessage)(data));
+    }
+    async sendMessageAndSubscribeForResponse(channel, target, messagedata, n = 2000) {
+        await this.subscribe(channel);
+        // send the message to the correct service
+        this.sendMessage(target, messagedata);
+        let resolver;
+        let rejecter;
+        // create a promise to be able to pass on to resolve later
+        const promise = new Promise((r, rj) => {
+            resolver = r;
+            rejecter = rj;
+        });
+        if (!resolver || !rejecter)
+            return null;
+        //setup a timeout
+        const timeout = this.setupTimeout(resolver, channel, n);
+        //setup a response
+        this.requestMessageResponse(channel, resolver, rejecter, timeout);
+        // return a promise that will resolve when the message returns or times out
+        return promise;
+    }
+    async getRequest(targetservice, key, data, timeout = 2000) {
+        // create a message id to subscribe to
+        const messageid = (0, uuid_1.v4)();
+        //subscribe to message response     
+        const channel = this.getRequestSubscriptionName(messageid);
+        return this.sendMessageAndSubscribeForResponse.call(this, channel, this.getRequestStream(targetservice), {
+            request: key,
+            messageid: messageid,
+            data: (0, utils_1.sanitizeValue)(data)
+        }, timeout);
+    }
+    async getApiRequest(endpoint, method, data, jwt = '') {
+        // create a message id to subscribe to
+        const messageid = (0, uuid_1.v4)();
+        //subscribe to message response     
+        const channel = this.getRequestSubscriptionName(messageid);
+        return this.sendMessageAndSubscribeForResponse.call(this, channel, this.getRequestStream('api'), {
+            endpoint: endpoint,
+            method: method,
+            messageid: messageid,
+            data: data,
+            jwt: jwt
+        });
+    }
+    requestMessageResponse(channel, resolver, rejector, timeout) {
+        this.resolvers.set(channel, resolver);
+        this.rejectors.set(channel, rejector);
+        this.timeouts.set(channel, timeout);
+    }
+    cleanupMessageReponse(channel) {
+        this.resolvers.delete(channel);
+        this.rejectors.delete(channel);
+        this.timeouts.delete(channel);
+    }
+    onMessage(channel, message) {
+        const rejector = this.rejectors.get(channel);
+        const resolver = this.resolvers.get(channel);
+        const timeout = this.timeouts.get(channel);
+        if (!rejector || !resolver || !timeout) {
+            this.cleanupMessageReponse.call(this, channel);
+            return;
+        }
+        // check if the request has been rejected
+        if ((0, class_validator_1.isJSON)(message)) {
+            const resolvemessage = JSON.parse(message);
+            if (resolvemessage.rejected && resolvemessage.error) {
+                rejector(new Error(resolvemessage.error?.title ?? 'unknown-reason'));
+                clearTimeout(timeout);
+                return;
+            }
+        }
+        if (message.length)
+            resolver(message);
+        else
+            resolver(null);
+        this.unsubscribe(channel);
+        clearTimeout(timeout);
+    }
+    unsubscribe(channel) {
+        this.reader.unsubscribe(channel);
+        this.subscriptions = this.subscriptions.filter(s => s != channel);
+    }
+    setupTimeout(resolve, channel, n = 2000) {
+        return setTimeout(() => {
+            if (!this.subscriptions.includes(channel))
+                return;
+            console.log(`sub timedout: ${channel}`);
+            resolve(null);
+            this.unsubscribe(channel);
+        }, n);
+    }
+    subscribe(channel) {
+        this.subscriptions.push(channel);
+        return this.reader.subscribe(channel);
+    }
+    getRequestSubscriptionName(messageid) {
+        return `messageresponse${messageid}`;
+    }
+    async setKey(key, value) {
+        try {
+            return await this.writer.set(key, (0, utils_1.sanitizeValue)(value));
+        }
+        catch { }
+        return;
+    }
+    async readKey(key) {
+        try {
+            return await this.writer.get(key);
+        }
+        catch { }
+        return null;
+    }
+    async deleteKey(key) {
+        try {
+            return await this.writer.del(key);
+        }
+        catch { }
+        return;
+    }
+    async sendListEvent(event, listitems, data = {}, listname = "") {
+        if (listitems.length == 0)
+            return;
+        // if a listname exist, we first empty it 
+        if (listname.length > 0)
+            await this.deleteKey.call(this, listname);
+        const list = await this.addToSet.call(this, listitems, listname.length > 0 ? listname : undefined);
+        return this.sendMessage(this.getListChannel(event), {
+            ...data,
+            listname: list
+        });
+    }
+    async addToSet(listitems, listname) {
+        const list = listname ?? (0, uuid_1.v4)();
+        await this.writer.sadd(list, ...listitems.map(utils_1.sanitizeValue));
+        return list;
+    }
+    async addToList(listitems, listname) {
+        const list = listname ?? (0, uuid_1.v4)();
+        await this.writer.lpush(list, ...listitems.map(utils_1.sanitizeValue));
+        return list;
+    }
+    getListChannel(event) {
+        return `${this.listprefix}${event}`;
+    }
+    async getStreamMessages(stream) {
+        const streaminfo = await this.getStreamInfo.call(this, stream);
+        if (!streaminfo || !(0, class_validator_1.isArray)(streaminfo) || streaminfo.length < 10)
+            return [];
+        const params = this.decypherParameters(streaminfo);
+        if (!params.entries)
+            return [];
+        return this.decyperMessages(params.entries);
+    }
+    getStreamInfo(stream, count = 0) {
+        return this.reader.xinfo('STREAM', stream, 'FULL', 'COUNT', count);
+    }
+    async filterStream(stream, key, value) {
+        const messages = await this.getStreamMessages.call(this, stream);
+        return messages.filter(message => message.parameters?.[key] != null && message.parameters[key] == value);
+    }
+    decypherResponse(...responses) {
+        return responses.reduce((resp, response) => [
+            ...resp,
+            {
+                stream: response[0],
+                messages: this.decyperMessages(response[1])
+            }
+        ], []);
+    }
+    decyperMessages(messages) {
+        return messages.map((message) => ({
+            id: message[0],
+            parameters: this.decypherParameters(message[1])
+        }));
+    }
+    decypherParameters(parameters) {
+        return parameters.reduce((params, v, n) => (n == 0 || (n % 2 == 0)) && parameters.length >= n + 1 ? ({
+            ...params,
+            [v]: parameters[n + 1]
+        }) : params, {});
+    }
+    async isSetPickedUp(setname) {
+        const pickedup = await this.reader.get((0, utils_1.getSetPickedUpName)(setname));
+        return pickedup !== null;
+    }
+}
+exports.default = Broker;
 //# sourceMappingURL=Broker.js.map