woonplan-packages-redishelper 1.0.25 → 1.0.29

package/data.ts

@@ -0,0 +1,77 @@
+import { Redis } from "ioredis"
+import { getMessageReponseKey } from "./utils"
+import { sendMessageToStream } from "./setters"
+import { RedisMessage } from "."
+
+const getOrRequestKey = ( client:Redis, key:string, service:string ) => new Promise((resolve, reject) => {
+  client.get( key )
+  .then(
+    ( result ) => {
+      if( result ) resolve( result );
+      if( !result ){
+        return requestAndWaitForKey( client, key, service )
+      }
+    }  
+  )
+  .then(
+    (result) => resolve( result )
+  )
+  .catch(
+    (error) => {
+      console.log( error );
+      resolve( null )
+    }
+  )
+})
+
+const requestAndWaitForKey = (
+  client:Redis,
+  key:string,
+  service:string,
+) => new Promise((resolve, reject) => {
+  service = capitalizeFirstLetter( service );
+  // send message for list to be created and then block untill we have a list
+  client.xadd( `keyRequestedFrom${service}Service`, '*', 'key', key )
+
+  sendMessageToStream( client, `keyRequestedFrom${service}Service`, {
+    key : key
+  } as RedisMessage )
+  .then(
+    (messageid:string) => {
+      // subscribing to keyspace is an option, but it increases CPU usage. First trying this way
+      return subscribeToMessageResponse( client, messageid )
+    }
+  ).then(
+    (result) => resolve( result )
+  ).catch(
+    () => resolve( null )
+  )
+})
+
+const subscribeToMessageResponse = ( client:Redis, messageid:string ) => client.subscribe( getMessageReponseKey( messageid ) )
+
+const publishMessageResponse = ( client:Redis, messageid:string, message:string ) => client.publish( getMessageReponseKey( messageid ), message )
+
+
+const requestAndWaitForList = (
+  client:Redis,
+  service:string,
+  listname:string,
+  listsubject:string,
+  props = {}
+,{
+  
+}) => new Promise((resolve) => {
+  service = capitalizeFirstLetter( service );
+  
+  // send message for list to be created and then block untill we have a list
+  client.xadd( `listRequestedFrom${service}Service`, '*', 'listname', listname, 'listsubject', listsubject, 'props', JSON.stringify( props ))
+  .then(
+    () => resolve( client.blmove( listname, listname, 'RIGHT', 'LEFT', 2) )
+  )
+})
+
+const capitalizeFirstLetter = (string:string) => string.charAt(0).toUpperCase() + string.slice(1)
+
+
+export { getOrRequestKey, requestAndWaitForList, publishMessageResponse, subscribeToMessageResponse }

package/dist/data.d.ts

@@ -0,0 +1,6 @@
+import { Redis } from "ioredis";
+declare const getOrRequestKey: (client: Redis, key: string, service: string) => Promise<unknown>;
+declare const subscribeToMessageResponse: (client: Redis, messageid: string) => Promise<number>;
+declare const publishMessageResponse: (client: Redis, messageid: string, message: string) => Promise<number>;
+declare const requestAndWaitForList: (client: Redis, service: string, listname: string, listsubject: string, props: {} | undefined, {}: {}) => Promise<unknown>;
+export { getOrRequestKey, requestAndWaitForList, publishMessageResponse, subscribeToMessageResponse };

package/dist/data.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribeToMessageResponse = exports.publishMessageResponse = exports.requestAndWaitForList = exports.getOrRequestKey = void 0;
+var utils_1 = require("./utils");
+var setters_1 = require("./setters");
+var getOrRequestKey = function (client, key, service) { return new Promise(function (resolve, reject) {
+    client.get(key)
+        .then(function (result) {
+        if (result)
+            resolve(result);
+        if (!result) {
+            return requestAndWaitForKey(client, key, service);
+        }
+    })
+        .then(function (result) { return resolve(result); })
+        .catch(function (error) {
+        console.log(error);
+        resolve(null);
+    });
+}); };
+exports.getOrRequestKey = getOrRequestKey;
+var requestAndWaitForKey = function (client, key, service) { return new Promise(function (resolve, reject) {
+    service = capitalizeFirstLetter(service);
+    // send message for list to be created and then block untill we have a list
+    client.xadd("keyRequestedFrom".concat(service, "Service"), '*', 'key', key);
+    (0, setters_1.sendMessageToStream)(client, "keyRequestedFrom".concat(service, "Service"), {
+        key: key
+    })
+        .then(function (messageid) {
+        // subscribing to keyspace is an option, but it increases CPU usage. First trying this way
+        return subscribeToMessageResponse(client, messageid);
+    }).then(function (result) { return resolve(result); }).catch(function () { return resolve(null); });
+}); };
+var subscribeToMessageResponse = function (client, messageid) { return client.subscribe((0, utils_1.getMessageReponseKey)(messageid)); };
+exports.subscribeToMessageResponse = subscribeToMessageResponse;
+var publishMessageResponse = function (client, messageid, message) { return client.publish((0, utils_1.getMessageReponseKey)(messageid), message); };
+exports.publishMessageResponse = publishMessageResponse;
+var requestAndWaitForList = function (client, service, listname, listsubject, props, _a) {
+    if (props === void 0) { props = {}; }
+    return new Promise(function (resolve) {
+        service = capitalizeFirstLetter(service);
+        // send message for list to be created and then block untill we have a list
+        client.xadd("listRequestedFrom".concat(service, "Service"), '*', 'listname', listname, 'listsubject', listsubject, 'props', JSON.stringify(props))
+            .then(function () { return resolve(client.blmove(listname, listname, 'RIGHT', 'LEFT', 2)); });
+    });
+};
+exports.requestAndWaitForList = requestAndWaitForList;
+var capitalizeFirstLetter = function (string) { return string.charAt(0).toUpperCase() + string.slice(1); };

package/dist/getters.d.ts

@@ -0,0 +1,5 @@
+import { Redis } from "ioredis";
+declare const getOrRequestKey: (client: Redis, key: string, service: string) => Promise<unknown>;
+declare const subscribeToMessageResponse: (client: Redis, messageid: string) => Promise<number>;
+declare const requestAndWaitForList: (client: Redis, service: string, listname: string, listsubject: string, props: {} | undefined, {}: {}) => Promise<unknown>;
+export { getOrRequestKey, requestAndWaitForList, subscribeToMessageResponse };

package/dist/getters.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribeToMessageResponse = exports.requestAndWaitForList = exports.getOrRequestKey = void 0;
+var utils_1 = require("./utils");
+var getOrRequestKey = function (client, key, service) { return new Promise(function (resolve, reject) {
+    client.get(key)
+        .then(function (result) {
+        if (result)
+            resolve(result);
+        if (!result) {
+            return requestAndWaitForKey(client, key, service);
+        }
+    })
+        .then(function (result) { return resolve(result); })
+        .catch(function (error) {
+        console.log(error);
+        resolve(null);
+    });
+}); };
+exports.getOrRequestKey = getOrRequestKey;
+var requestAndWaitForKey = function (client, key, service) { return new Promise(function (resolve) {
+    service = capitalizeFirstLetter(service);
+    client.xadd("keyRequestedFrom".concat(service, "Service"), '*', 'key', key)
+        .then(function (messageid) {
+        // create a key to listen to, the key contains the message we just created;
+        return subscribeToMessageResponse(client, messageid);
+    }).then(function (result) { return resolve(result); }).catch(function () { return resolve(null); });
+}); };
+var subscribeToMessageResponse = function (client, messageid) { return client.subscribe((0, utils_1.getMessageReponseKey)(messageid)); };
+exports.subscribeToMessageResponse = subscribeToMessageResponse;
+var requestAndWaitForList = function (client, service, listname, listsubject, props, _a) {
+    if (props === void 0) { props = {}; }
+    return new Promise(function (resolve) {
+        service = capitalizeFirstLetter(service);
+        // send message for list to be created and then block untill we have a list
+        client.xadd("listRequestedFrom".concat(service, "Service"), '*', 'listname', listname, 'listsubject', listsubject, 'props', JSON.stringify(props))
+            .then(function () { return resolve(client.blmove(listname, listname, 'RIGHT', 'LEFT', 2)); });
+    });
+};
+exports.requestAndWaitForList = requestAndWaitForList;
+var capitalizeFirstLetter = function (string) { return string.charAt(0).toUpperCase() + string.slice(1); };

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { Redis } from "ioredis";
 import { RedisMessage } from "./types";
+import { sendMessageToStream, publishMessageResponse } from "./setters";
+import { getOrRequestKey } from "./getters";
 declare const listenToStream: (client: Redis, groupname: string, channelname: string, consumername: string, callback: Function) => Promise<boolean>;
-declare const sendMessageToStream: (client: Redis, channelname: string, message: RedisMessage) => void;
-export { listenToStream, RedisMessage, sendMessageToStream };
+export { listenToStream, RedisMessage, sendMessageToStream, publishMessageResponse, getOrRequestKey };

package/dist/index.js

@@ -1,15 +1,11 @@
 "use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendMessageToStream = exports.listenToStream = void 0;
+exports.getOrRequestKey = exports.publishMessageResponse = exports.sendMessageToStream = exports.listenToStream = void 0;
+var setters_1 = require("./setters");
+Object.defineProperty(exports, "sendMessageToStream", { enumerable: true, get: function () { return setters_1.sendMessageToStream; } });
+Object.defineProperty(exports, "publishMessageResponse", { enumerable: true, get: function () { return setters_1.publishMessageResponse; } });
+var getters_1 = require("./getters");
+Object.defineProperty(exports, "getOrRequestKey", { enumerable: true, get: function () { return getters_1.getOrRequestKey; } });
 var listenToStream = function (client, groupname, channelname, consumername, callback) { return new Promise(function (resolve, reject) {
     createGroup(client, groupname, channelname).then(function () {
         listenForMessage(client, groupname, channelname, consumername, callback);
@@ -22,19 +18,12 @@ var listenToStream = function (client, groupname, channelname, consumername, cal
 exports.listenToStream = listenToStream;
 var createGroup = function (client, groupname, channelname) { return new Promise(function (resolve, reject) {
     client.xgroup('CREATE', channelname, groupname, '$', 'MKSTREAM').then(function () { return resolve(true); }).catch(function (error) {
+        // group exists
         if (error.message.includes('BUSYGROUP'))
             return resolve(true);
         reject(error);
     });
 }); };
-var reduceArraysToArray = function (toArray, fromArray) { return toArray.concat(fromArray); };
-var redisMessageToArrayOfKeysAndValues = function (message) { return Object.keys(message).map(function (key) { return [key, message[key]]; }); };
-var sendMessageToStream = function (client, channelname, message) {
-    var arrayOfKeysAndValues = redisMessageToArrayOfKeysAndValues(message).reduce(reduceArraysToArray, []);
-    console.log('sendings message', channelname);
-    client.xadd.apply(client, __spreadArray([channelname, '*'], arrayOfKeysAndValues, false));
-};
-exports.sendMessageToStream = sendMessageToStream;
 var listenForMessage = function (client, groupname, channelname, consumername, callback, lastId) {
     if (lastId === void 0) { lastId = "$"; }
     console.log("listening to ".concat(channelname, " as ").concat(consumername));
@@ -52,8 +41,10 @@ var listenForMessage = function (client, groupname, channelname, consumername, c
                         return;
                     messagedata[key] = keysandvalues[n + 1];
                 });
-                callback(messagedata).catch(function (error) {
+                callback(messagedata, id).catch(function (error) {
                     console.log(error);
+                    // in case somebody was subscribed to the response;
+                    (0, setters_1.publishMessageResponse)(client, id, '');
                 }).finally(function () {
                     // not sure yet? For now always acknowledge
                     client.xack(channelname, groupname, id).then(function () {

package/dist/setters.d.ts

@@ -0,0 +1,5 @@
+import { Redis } from "ioredis";
+import { RedisMessage } from "./types";
+declare const publishMessageResponse: (client: Redis, messageid: string, message: string) => Promise<number>;
+declare const sendMessageToStream: (client: Redis, channelname: string, message: RedisMessage) => Promise<string>;
+export { publishMessageResponse, sendMessageToStream };

package/dist/setters.js

@@ -0,0 +1,21 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendMessageToStream = exports.publishMessageResponse = void 0;
+var utils_1 = require("./utils");
+var publishMessageResponse = function (client, messageid, message) { return client.publish((0, utils_1.getMessageReponseKey)(messageid), message); };
+exports.publishMessageResponse = publishMessageResponse;
+var sendMessageToStream = function (client, channelname, message) {
+    var arrayOfKeysAndValues = (0, utils_1.redisMessageToArrayOfKeysAndValues)(message).reduce(utils_1.reduceArraysToArray, []);
+    console.log('sendings message', channelname);
+    return client.xadd.apply(client, __spreadArray([channelname, '*'], arrayOfKeysAndValues, false));
+};
+exports.sendMessageToStream = sendMessageToStream;

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+import { RedisMessage } from "./types";
+declare const getMessageReponseKey: (messageid: string) => string;
+declare const reduceArraysToArray: (toArray: any[], fromArray: []) => any[];
+declare const redisMessageToArrayOfKeysAndValues: (message: RedisMessage) => any[];
+export { getMessageReponseKey, redisMessageToArrayOfKeysAndValues, reduceArraysToArray };

package/dist/utils.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduceArraysToArray = exports.redisMessageToArrayOfKeysAndValues = exports.getMessageReponseKey = void 0;
+var messagePrefix = "messageresponse";
+var getMessageReponseKey = function (messageid) { return messagePrefix + messageid; };
+exports.getMessageReponseKey = getMessageReponseKey;
+var reduceArraysToArray = function (toArray, fromArray) { return toArray.concat(fromArray); };
+exports.reduceArraysToArray = reduceArraysToArray;
+var redisMessageToArrayOfKeysAndValues = function (message) { return Object.keys(message).map(function (key) { return [key, message[key]]; }); };
+exports.redisMessageToArrayOfKeysAndValues = redisMessageToArrayOfKeysAndValues;

package/getters.ts

@@ -0,0 +1,69 @@
+import { Redis } from "ioredis"
+import { getMessageReponseKey } from "./utils"
+const getOrRequestKey = ( client:Redis, key:string, service:string ) => new Promise((resolve, reject) => {
+  client.get( key )
+  .then(
+    ( result ) => {
+      if( result ) resolve( result );
+      if( !result ){
+        return requestAndWaitForKey( client, key, service )
+      }
+    }  
+  )
+  .then(
+    (result) => resolve( result )
+  )
+  .catch(
+    (error) => {
+      console.log( error );
+      resolve( null )
+    }
+  )
+})
+
+const requestAndWaitForKey = (
+  client:Redis,
+  key:string,
+  service:string,
+) => new Promise((resolve) => {
+  service = capitalizeFirstLetter( service );
+  
+  client.xadd( `keyRequestedFrom${service}Service`, '*', 'key', key )
+  .then(
+    (messageid:string) => {
+      // create a key to listen to, the key contains the message we just created;
+      return subscribeToMessageResponse( client, messageid )
+    }
+  ).then(
+    (result) => resolve( result )
+  ).catch(
+    () => resolve( null )
+  )
+})
+
+
+const subscribeToMessageResponse = ( client:Redis, messageid:string ) => client.subscribe( getMessageReponseKey( messageid ) )
+
+
+const requestAndWaitForList = (
+  client:Redis,
+  service:string,
+  listname:string,
+  listsubject:string,
+  props = {}
+,{
+  
+}) => new Promise((resolve) => {
+  service = capitalizeFirstLetter( service );
+  
+  // send message for list to be created and then block untill we have a list
+  client.xadd( `listRequestedFrom${service}Service`, '*', 'listname', listname, 'listsubject', listsubject, 'props', JSON.stringify( props ))
+  .then(
+    () => resolve( client.blmove( listname, listname, 'RIGHT', 'LEFT', 2) )
+  )
+})
+
+const capitalizeFirstLetter = (string:string) => string.charAt(0).toUpperCase() + string.slice(1)
+
+
+export { getOrRequestKey, requestAndWaitForList, subscribeToMessageResponse }

package/index.ts

@@ -1,5 +1,7 @@
 import { Redis } from "ioredis"
 import { RedisMessage } from "./types"
+import { sendMessageToStream, publishMessageResponse } from "./setters"
+import { getOrRequestKey, subscribeToMessageResponse } from "./getters"
 
 const listenToStream = ( client:Redis, groupname:string, channelname:string, consumername:string, callback:Function ):Promise<boolean> => new Promise((resolve,reject) => { 
   createGroup( client, groupname, channelname ).then(
@@ -20,6 +22,7 @@ const createGroup = ( client:Redis, groupname:string, channelname:string ):Promi
     () => resolve( true )
   ).catch(
     ( error:Error ) => {      
+      // group exists
       if( error.message.includes('BUSYGROUP'))
         return resolve( true );
       
@@ -28,17 +31,6 @@ const createGroup = ( client:Redis, groupname:string, channelname:string ):Promi
   )
 })
 
-const reduceArraysToArray = ( toArray:any[], fromArray:[] ) => toArray.concat( fromArray )
-const redisMessageToArrayOfKeysAndValues = ( message:RedisMessage ):any[] => Object.keys(message).map((key) => [ key, message[key]]);
-
-const sendMessageToStream = ( client:Redis, channelname:string, message:RedisMessage) => {
-  const arrayOfKeysAndValues = redisMessageToArrayOfKeysAndValues( message ).reduce( reduceArraysToArray, [] );
-  console.log( 'sendings message', channelname )
-  client.xadd( channelname, '*', ...arrayOfKeysAndValues )
-}
-
-
-
 const listenForMessage = ( client:Redis, groupname:string, channelname:string, consumername:string, callback:Function, lastId = "$" ) => {
   console.log( `listening to ${channelname} as ${consumername}`)
   client.xreadgroup('GROUP', groupname, consumername, 'COUNT', 1, 'BLOCK', 0, 'STREAMS', channelname, '>')
@@ -61,9 +53,11 @@ const listenForMessage = ( client:Redis, groupname:string, channelname:string, c
                 messagedata[key] = keysandvalues[n+1];
               })
 
-              callback( messagedata ).catch(
+              callback( messagedata, id ).catch(
                 ( error:Error ) => {
-                  console.log( error );        
+                  console.log( error );
+                  // in case somebody was subscribed to the response;
+                  publishMessageResponse( client, id, '' );
                 }
               ).finally(()=>{
                 // not sure yet? For now always acknowledge
@@ -85,4 +79,4 @@ const listenForMessage = ( client:Redis, groupname:string, channelname:string, c
     })
 }
 
-export { listenToStream, RedisMessage, sendMessageToStream }
+export { listenToStream, RedisMessage, sendMessageToStream, publishMessageResponse, getOrRequestKey, subscribeToMessageResponse }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "woonplan-packages-redishelper",
-  "version": "1.0.25",
+  "version": "1.0.29",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/setters.ts

@@ -0,0 +1,17 @@
+
+import { Redis } from "ioredis"
+import { RedisMessage } from "./types"
+import { getMessageReponseKey, redisMessageToArrayOfKeysAndValues, reduceArraysToArray } from "./utils"
+
+const publishMessageResponse = ( client:Redis, messageid:string, message:string ) => client.publish( getMessageReponseKey( messageid ), message )
+
+
+const sendMessageToStream = ( client:Redis, channelname:string, message:RedisMessage) => {
+  const arrayOfKeysAndValues = redisMessageToArrayOfKeysAndValues( message ).reduce( reduceArraysToArray, [] );
+  console.log( 'sendings message', channelname )
+  return client.xadd( channelname, '*', ...arrayOfKeysAndValues )
+}
+
+
+
+export { publishMessageResponse, sendMessageToStream }

package/utils.ts

@@ -0,0 +1,8 @@
+import { RedisMessage } from "./types"
+const messagePrefix:string = "messageresponse";
+
+const getMessageReponseKey = ( messageid:string ) => messagePrefix + messageid
+const reduceArraysToArray = ( toArray:any[], fromArray:[] ) => toArray.concat( fromArray )
+const redisMessageToArrayOfKeysAndValues = ( message:RedisMessage ):any[] => Object.keys(message).map((key) => [ key, message[key]]);
+
+export { getMessageReponseKey, redisMessageToArrayOfKeysAndValues, reduceArraysToArray };