woonplan-packages-redishelper 1.0.50 → 1.0.55

package/dist/getters.d.ts

@@ -1,7 +1,6 @@
 import { Redis } from "ioredis";
-import { Struct } from "./types";
-declare const getOrRequestKey: (client: Redis, key: string, service: string) => Promise<unknown>;
-declare const requestAndWaitForData: (client: Redis, data: Struct, service: string) => Promise<unknown>;
+import { RedisConfig } from "./types";
+declare const getOrRequestKey: (config: RedisConfig, 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, requestAndWaitForData };
+export { getOrRequestKey, requestAndWaitForList, subscribeToMessageResponse };

package/dist/getters.js

@@ -1,14 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requestAndWaitForData = exports.subscribeToMessageResponse = exports.requestAndWaitForList = exports.getOrRequestKey = void 0;
+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)
+var memdb_1 = require("./memdb");
+var uuid_1 = require("uuid");
+var timeout = 250;
+var getOrRequestKey = function (config, key, service) { return new Promise(function (resolve, reject) {
+    var getterclient = (0, memdb_1.getRedisClient)(config);
+    getterclient.get(key)
         .then(function (result) {
         if (result)
             resolve(result);
         if (!result) {
-            return requestAndWaitForKey(client, key, service);
+            return requestAndWaitForKey(getterclient, config, key, service);
         }
     })
         .then(function (result) { return resolve(result); })
@@ -18,84 +22,50 @@ var getOrRequestKey = function (client, key, service) { return new Promise(funct
     });
 }); };
 exports.getOrRequestKey = getOrRequestKey;
-var requestAndWaitForKey = function (client, key, service) { return new Promise(function (resolve) {
-    service = capitalizeFirstLetter(service);
-    var createdMessageId = '';
-    client.xadd("keyRequestedFrom".concat(service, "Service"), '*', 'key', key)
-        .then(function (messageid) {
-        createdMessageId = messageid;
-        // create a key to listen to, the key contains the message we just created;
-        return subscribeToMessageResponse(client, messageid);
-    }).then(function () {
-        console.log("subscribed to ".concat(createdMessageId, " at ").concat(new Date().toUTCString()));
+var requestAndWaitForKey = function (getterclient, config, key, service) { return new Promise(function (resolve) {
+    var messageid = (0, uuid_1.v4)();
+    // create a listener  
+    var listenerclient = (0, memdb_1.getRedisClient)(config);
+    subscribeToMessageResponse(listenerclient, messageid).
+        then(function () {
+        console.log("subscribed to ".concat(messageid, " at ").concat(new Date().toISOString()));
         // we are subscribed
         // setting up a one time event listener
-        client.once("message", function (channel, message) {
-            console.log("unsubscribing from ".concat(channel));
-            client.unsubscribe().then(function () {
-                if (message.length)
-                    resolve(message);
-                else
-                    resolve(null);
-            }).catch(function (error) {
-                console.log(error);
-            });
-        });
-        // setup timeout 
-        setTimeout(function () {
-            if (client.status != "end") {
-                console.log("sub timedout");
-                client.unsubscribe();
+        listenerclient.once("message", function (channel, message) {
+            if (message.length)
+                resolve(message);
+            else
                 resolve(null);
-            }
-        }, 250);
-    }).catch(function (e) {
-        console.log(e);
-        resolve(null);
-    });
-}); };
-var requestAndWaitForData = function (client, data, service) { return new Promise(function (resolve) {
-    service = capitalizeFirstLetter(service);
-    client.xadd("dataRequestedFrom".concat(service, "Service"), '*', 'data', JSON.stringify(data))
-        .then(function (messageid) {
-        // create a key to listen to, the key contains the message we just created;
-        return subscribeToMessageResponse(client, messageid);
-    }).then(function () {
-        // we are subscribed
-        // setting up a one time event listener
-        client.once("message", function (channel, message) {
             console.log("unsubscribing from ".concat(channel));
-            client.unsubscribe().then(function () {
-                if (message.length)
-                    resolve(message);
-                else
-                    resolve(null);
-            });
+            listenerclient.unsubscribe();
+            listenerclient.disconnect();
         });
         // setup timeout 
         setTimeout(function () {
-            if (client.status != "end") {
+            if (listenerclient.status != "end") {
                 console.log("sub timedout");
-                client.unsubscribe();
                 resolve(null);
+                listenerclient.unsubscribe();
+                listenerclient.disconnect();
             }
-        }, 250);
-    }).catch(function (e) {
+        }, timeout);
+    });
+    // send out the request
+    getterclient.xadd((0, utils_1.getKeyRequestedChannelName)(service), '*', 'key', key, 'messageid', messageid)
+        .catch(function (e) {
         console.log(e);
         resolve(null);
-    });
+    })
+        .finally(function () { return getterclient.disconnect(); });
 }); };
-exports.requestAndWaitForData = requestAndWaitForData;
 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))
+        client.xadd((0, utils_1.getListRequestedChannelName)(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,6 +1,7 @@
 import { Redis } from "ioredis";
-import { RedisMessage } from "./types";
+import { RedisConfig, RedisMessage } from "./types";
 import { sendMessageToStream, publishMessageResponse } from "./setters";
-import { getOrRequestKey, subscribeToMessageResponse, requestAndWaitForList, requestAndWaitForData } from "./getters";
+import { getOrRequestKey, subscribeToMessageResponse, requestAndWaitForList } from "./getters";
 declare const listenToStream: (client: Redis, groupname: string, channelname: string, consumername: string, callback: Function) => Promise<boolean>;
-export { listenToStream, RedisMessage, sendMessageToStream, publishMessageResponse, requestAndWaitForData, getOrRequestKey, subscribeToMessageResponse, requestAndWaitForList };
+declare const dataRequester: (config: RedisConfig, groupname: string, service: string, consumername: string, callback: Function) => void;
+export { listenToStream, RedisMessage, sendMessageToStream, publishMessageResponse, getOrRequestKey, dataRequester, subscribeToMessageResponse, requestAndWaitForList };

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requestAndWaitForList = exports.subscribeToMessageResponse = exports.getOrRequestKey = exports.requestAndWaitForData = exports.publishMessageResponse = exports.sendMessageToStream = exports.listenToStream = void 0;
+exports.requestAndWaitForList = exports.subscribeToMessageResponse = exports.dataRequester = 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; } });
@@ -8,7 +8,8 @@ var getters_1 = require("./getters");
 Object.defineProperty(exports, "getOrRequestKey", { enumerable: true, get: function () { return getters_1.getOrRequestKey; } });
 Object.defineProperty(exports, "subscribeToMessageResponse", { enumerable: true, get: function () { return getters_1.subscribeToMessageResponse; } });
 Object.defineProperty(exports, "requestAndWaitForList", { enumerable: true, get: function () { return getters_1.requestAndWaitForList; } });
-Object.defineProperty(exports, "requestAndWaitForData", { enumerable: true, get: function () { return getters_1.requestAndWaitForData; } });
+var memdb_1 = require("./memdb");
+var utils_1 = require("./utils");
 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);
@@ -27,6 +28,58 @@ var createGroup = function (client, groupname, channelname) { return new Promise
         reject(error);
     });
 }); };
+// this function is made as a responsding function to getters/requestAndWaitForKey
+// dataRequester listens to a stream and then publishes a respond 
+var dataRequester = function (config, groupname, service, consumername, callback) {
+    var channelname = (0, utils_1.getKeyRequestedChannelName)(service);
+    var listenerclient = (0, memdb_1.getRedisClient)(config);
+    createGroup(listenerclient, groupname, channelname)
+        .then(function () { return listenForMessageForDataRequest(listenerclient, groupname, channelname, consumername, callback); });
+};
+exports.dataRequester = dataRequester;
+var getMessagedataFromResult = function (results) {
+    if (!results.length)
+        throw ('no-messagedata');
+    var result = results[0], messages = result[1];
+    if (!messages.length)
+        throw ('no-messagedata');
+    var message = messages[0], id = message[0], keysandvalues = message[1];
+    var messagedata = {};
+    keysandvalues.forEach(function (key, n) {
+        if (!(n == 0 || n % 2 == 0))
+            return;
+        messagedata[key] = keysandvalues[n + 1];
+    });
+    return { messagedata: messagedata, id: id };
+};
+var listenForMessageForDataRequest = function (listenerclient, groupname, channelname, consumername, callback) {
+    var streammsgid = '';
+    var messageid = '';
+    // block client while listening for a message
+    listenerclient.xreadgroup('GROUP', groupname, consumername, 'COUNT', 1, 'BLOCK', 0, 'STREAMS', channelname, '>')
+        .then(function (results) {
+        return getMessagedataFromResult(results);
+    })
+        .then(function (_a) {
+        var messagedata = _a.messagedata, id = _a.id;
+        // messageid should have been set in getters/requestAndWaitForKey
+        if ('messageid' in messagedata)
+            messageid = messagedata.id;
+        //stream id from redis
+        streammsgid = id;
+        return messagedata;
+    })
+        .then(function (messagedata) {
+        return callback(messagedata, streammsgid);
+    })
+        .then(function (result) { return (0, setters_1.publishMessageResponse)(listenerclient, messageid, result != null ? result : ''); })
+        .finally(function () {
+        listenerclient.xack(channelname, groupname, streammsgid).then(function () {
+            console.log(streammsgid + ' acknowledged');
+        });
+        listenForMessageForDataRequest(listenerclient, groupname, channelname, consumername, callback);
+    });
+};
 var listenForMessage = function (client, groupname, channelname, consumername, callback, lastId) {
     if (lastId === void 0) { lastId = "$"; }
     console.log("listening to ".concat(channelname, " as ").concat(consumername));

package/dist/memdb.d.ts

@@ -0,0 +1,4 @@
+import { RedisConfig } from "./types";
+import { Redis } from "ioredis";
+declare const getRedisClient: (config: RedisConfig) => Redis;
+export { getRedisClient };

package/dist/memdb.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRedisClient = void 0;
+var IORedis = require("ioredis");
+var getRedisClient = function (config) { return new IORedis(config.REDISURL); };
+exports.getRedisClient = getRedisClient;

package/dist/setters.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendMessageToStream = exports.publishMessageResponse = void 0;
 var utils_1 = require("./utils");
 var publishMessageResponse = function (client, messageid, message) {
-    console.log("publishing to ".concat(messageid, " at ").concat(new Date().toUTCString()));
+    console.log("publishing to ".concat(messageid, " at ").concat(new Date().toISOString()));
     return client.publish((0, utils_1.getMessageReponseKey)(messageid), message);
 };
 exports.publishMessageResponse = publishMessageResponse;

package/dist/types.d.ts

@@ -4,3 +4,6 @@ export interface RedisMessage {
 export interface Struct {
     [index: string]: any;
 }
+export interface RedisConfig {
+    REDISURL: string | number | undefined;
+}

package/dist/utils.d.ts

@@ -2,4 +2,6 @@ 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 };
+declare const getKeyRequestedChannelName: (service: string) => string;
+declare const getListRequestedChannelName: (service: string) => string;
+export { getMessageReponseKey, redisMessageToArrayOfKeysAndValues, reduceArraysToArray, getKeyRequestedChannelName, getListRequestedChannelName };

package/dist/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.reduceArraysToArray = exports.redisMessageToArrayOfKeysAndValues = exports.getMessageReponseKey = void 0;
+exports.getListRequestedChannelName = exports.getKeyRequestedChannelName = exports.reduceArraysToArray = exports.redisMessageToArrayOfKeysAndValues = exports.getMessageReponseKey = void 0;
 var messagePrefix = "messageresponse";
 var getMessageReponseKey = function (messageid) { return messagePrefix + messageid; };
 exports.getMessageReponseKey = getMessageReponseKey;
@@ -8,3 +8,8 @@ var reduceArraysToArray = function (toArray, fromArray) { return toArray.concat(
 exports.reduceArraysToArray = reduceArraysToArray;
 var redisMessageToArrayOfKeysAndValues = function (message) { return Object.keys(message).map(function (key) { return [key, message[key]]; }); };
 exports.redisMessageToArrayOfKeysAndValues = redisMessageToArrayOfKeysAndValues;
+var capitalizeFirstLetter = function (string) { return string.charAt(0).toUpperCase() + string.slice(1); };
+var getKeyRequestedChannelName = function (service) { return "keyRequestedFrom".concat(capitalizeFirstLetter(service), "Service"); };
+exports.getKeyRequestedChannelName = getKeyRequestedChannelName;
+var getListRequestedChannelName = function (service) { return "listRequestedFrom".concat(capitalizeFirstLetter(service), "Service"); };
+exports.getListRequestedChannelName = getListRequestedChannelName;

package/getters.ts

@@ -1,13 +1,19 @@
 import { Redis } from "ioredis"
-import { getMessageReponseKey } from "./utils"
-import { Struct } from "./types"
-const getOrRequestKey = ( client:Redis, key:string, service:string ) => new Promise((resolve, reject) => {
-  client.get( key )
+import { getMessageReponseKey, getKeyRequestedChannelName, getListRequestedChannelName } from "./utils"
+import { RedisConfig } from "./types"
+import { getRedisClient } from "./memdb"
+import { v4 as uuidv4 } from 'uuid';
+
+const timeout = 250;
+
+const getOrRequestKey = ( config:RedisConfig, key:string, service:string ) => new Promise((resolve, reject) => {
+  const getterclient = getRedisClient( config )
+  getterclient.get( key )
   .then(
     ( result ) => {
       if( result ) resolve( result );
       if( !result ){
-        return requestAndWaitForKey( client, key, service )
+        return requestAndWaitForKey( getterclient, config, key, service )
       }
     }  
   )
@@ -22,113 +28,56 @@ const getOrRequestKey = ( client:Redis, key:string, service:string ) => new Prom
   )
 })
 
+
 const requestAndWaitForKey = (
-  client:Redis,
+  getterclient:Redis,
+  config:RedisConfig,
   key:string,
   service:string,
-) => new Promise((resolve) => {
-  service = capitalizeFirstLetter( service );
-  
-  let createdMessageId = '';
-
-  client.xadd( `keyRequestedFrom${service}Service`, '*', 'key', key )
-  .then(
-    (messageid:string) => {
-      createdMessageId = messageid;
-      // create a key to listen to, the key contains the message we just created;
-      return subscribeToMessageResponse( client, messageid )
-    }
-  ).then(
-    () => {
-
-      
-      console.log( `subscribed to ${createdMessageId} at ${new Date().toUTCString()}` )
-
+) => new Promise((resolve) => {  
+  const messageid  = uuidv4()
+
+  // create a listener  
+  const listenerclient = getRedisClient( config )
+  subscribeToMessageResponse( listenerclient, messageid ).
+  then(
+    () => {      
+      console.log( `subscribed to ${messageid} at ${new Date().toISOString()}` )
       // we are subscribed
       // setting up a one time event listener
-      client.once( "message", ( channel, message ) => {
-        console.log( `unsubscribing from ${channel}` )
+      listenerclient.once( "message", ( channel, message ) => {        
+        if( message.length ) resolve( message );
+        else resolve( null )
 
-        client.unsubscribe().then(
-          () => {          
-            if( message.length ) resolve( message );
-            else resolve( null )
-          }
-        ).catch(
-          (error) => {
-            console.log( error )
-          }
-        );
+        console.log( `unsubscribing from ${channel}` )
 
-      })      
+        listenerclient.unsubscribe()
+        listenerclient.disconnect()
+      })  
 
       // setup timeout 
       setTimeout( () => {
-        if( client.status != "end" ){
+        if( listenerclient.status != "end" ){
           console.log( `sub timedout`)
-          client.unsubscribe();
           resolve( null )
-        }
-        
-      }, 250 )
-    }
-  ).catch(
-    (e) => {
-      console.log( e )
-      resolve( null )
+          listenerclient.unsubscribe()
+          listenerclient.disconnect()
+        }        
+      }, timeout )
     }
   )
-})
-
 
-const requestAndWaitForData = (
-  client:Redis,
-  data:Struct,
-  service:string,
-) => new Promise((resolve) => {
-  service = capitalizeFirstLetter( service );
-  
-  client.xadd( `dataRequestedFrom${service}Service`, '*', 'data', JSON.stringify( data ) )
-  .then(
-    (messageid:string) => {
-      // create a key to listen to, the key contains the message we just created;
-      return subscribeToMessageResponse( client, messageid )
-    }
-  ).then(
-    () => {
-      // we are subscribed
-      // setting up a one time event listener
-
-
-      
-      client.once( "message", ( channel, message ) => {
-        console.log( `unsubscribing from ${channel}` )
-
-        client.unsubscribe().then(
-          () => {          
-            if( message.length ) resolve( message );
-            else resolve( null )
-          }
-        );
-      })
-
-      // setup timeout 
-      setTimeout( () => {
-        if( client.status != "end" ){
-          console.log( `sub timedout`)
-          client.unsubscribe();
-          resolve( null )
-        }
-        
-      }, 250 )
-
-    }
-  ).catch(
+  // send out the request
+  getterclient.xadd( getKeyRequestedChannelName( service ), '*', 'key', key, 'messageid', messageid )
+  .catch(
     (e) => {
       console.log( e )
       resolve( null )
     }
   )
+  .finally(
+    () => getterclient.disconnect()
+  )
 })
 
 const subscribeToMessageResponse = ( client:Redis, messageid:string ) => client.subscribe( getMessageReponseKey( messageid ) )
@@ -143,17 +92,14 @@ const requestAndWaitForList = (
   props = {}
 ,{
   
-}) => new Promise((resolve) => {
-  service = capitalizeFirstLetter( service );
-  
+}) => new Promise((resolve) => {  
   // 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 ))
+  client.xadd( getListRequestedChannelName( 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, requestAndWaitForData }
+export { getOrRequestKey, requestAndWaitForList, subscribeToMessageResponse }

package/index.ts

@@ -1,7 +1,9 @@
 import { Redis } from "ioredis"
-import { RedisMessage } from "./types"
+import { RedisConfig, RedisMessage, Struct } from "./types"
 import { sendMessageToStream, publishMessageResponse } from "./setters"
-import { getOrRequestKey, subscribeToMessageResponse, requestAndWaitForList, requestAndWaitForData } from "./getters"
+import { getOrRequestKey, subscribeToMessageResponse, requestAndWaitForList } from "./getters"
+import { getRedisClient } from "./memdb"
+import { getKeyRequestedChannelName } from "./utils"
 
 const listenToStream = ( client:Redis, groupname:string, channelname:string, consumername:string, callback:Function ):Promise<boolean> => new Promise((resolve,reject) => { 
   createGroup( client, groupname, channelname ).then(
@@ -31,6 +33,77 @@ const createGroup = ( client:Redis, groupname:string, channelname:string ):Promi
   )
 })
 
+
+// this function is made as a responsding function to getters/requestAndWaitForKey
+// dataRequester listens to a stream and then publishes a respond 
+const dataRequester = ( config:RedisConfig, groupname:string, service:string, consumername:string, callback:Function ) => {
+  const channelname = getKeyRequestedChannelName( service ) ;
+  const listenerclient = getRedisClient( config )
+  createGroup( listenerclient, groupname, channelname )
+  .then(
+    () => listenForMessageForDataRequest( listenerclient, groupname, channelname, consumername, callback )
+  )
+}
+
+const getMessagedataFromResult = ( results:any ) => {
+  if( !results.length ) throw('no-messagedata');
+
+  const result    = results[0],
+        messages  = result[1]
+
+  if( !messages.length ) throw('no-messagedata');
+  const message       = messages[0],
+        id            = message[0],
+        keysandvalues = message[1] as string[]
+
+  let messagedata:RedisMessage = {};
+
+  keysandvalues.forEach( (key, n ) => {
+    if( !( n == 0 || n % 2 == 0 ) ) return;
+    messagedata[key] = keysandvalues[n+1];
+  })
+
+  return { messagedata, id}
+}
+
+const listenForMessageForDataRequest = (
+  listenerclient:Redis, groupname:string, channelname:string, consumername:string, callback:Function
+) => {
+
+  let streammsgid = '';
+  let messageid   = '';
+  // block client while listening for a message
+  listenerclient.xreadgroup('GROUP', groupname, consumername, 'COUNT', 1, 'BLOCK', 0, 'STREAMS', channelname, '>')
+  .then( (results) => 
+    getMessagedataFromResult( results )
+  )
+  .then(({messagedata,id}) => {      
+      // messageid should have been set in getters/requestAndWaitForKey
+      if( 'messageid' in messagedata ) messageid = messagedata.id;
+
+      //stream id from redis
+      streammsgid = id;
+      return messagedata
+    } 
+  )
+  .then( (messagedata) =>
+    callback( messagedata, streammsgid )
+  )
+  .then(
+    ( result:any ) => publishMessageResponse( listenerclient, messageid, result != null ? result : '' )
+  )
+  .finally( () => 
+    {
+      listenerclient.xack( channelname, groupname, streammsgid ).then( () => {
+        console.log( streammsgid + ' acknowledged')
+      })
+      listenForMessageForDataRequest( listenerclient, groupname, channelname, consumername, callback );
+
+    }
+  )
+}
+
+
 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, '>')
@@ -81,4 +154,4 @@ const listenForMessage = ( client:Redis, groupname:string, channelname:string, c
     })
 }
 
-export { listenToStream, RedisMessage, sendMessageToStream, publishMessageResponse, requestAndWaitForData, getOrRequestKey, subscribeToMessageResponse, requestAndWaitForList }
+export { listenToStream, RedisMessage, sendMessageToStream, publishMessageResponse, getOrRequestKey, dataRequester, subscribeToMessageResponse, requestAndWaitForList }

package/memdb.ts

@@ -0,0 +1,7 @@
+import { RedisConfig } from "./types"
+import { Redis } from "ioredis"
+const IORedis           = require("ioredis");
+
+const getRedisClient = ( config:RedisConfig ):Redis => new IORedis( config.REDISURL );
+
+export { getRedisClient }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "woonplan-packages-redishelper",
-  "version": "1.0.50",
+  "version": "1.0.55",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,9 +15,12 @@
   "devDependencies": {
     "@types/ioredis": "^4.28.4",
     "@types/node": "^16.11.13",
+    "@types/uuid": "^8.3.4",
     "typescript": "^4.2.3"
   },
   "dependencies": {
-    "@types/ioredis": "^4.28.5"
+    "@types/ioredis": "^4.28.5",
+    "ioredis": "^4.28.2",
+    "uuid": "^8.3.2"
   }
 }

package/setters.ts

@@ -4,7 +4,7 @@ import { RedisMessage } from "./types"
 import { getMessageReponseKey, redisMessageToArrayOfKeysAndValues, reduceArraysToArray } from "./utils"
 
 const publishMessageResponse = ( client:Redis, messageid:string, message:string ) => {
-  console.log( `publishing to ${messageid} at ${new Date().toUTCString()}` )
+  console.log( `publishing to ${messageid} at ${new Date().toISOString()}` )
   return client.publish( getMessageReponseKey( messageid ), message )
 }
 

package/types.ts

@@ -5,3 +5,6 @@ export interface Struct{
   [index: string]: any;  
 }
 
+export interface RedisConfig{
+  REDISURL: string | number | undefined;  
+}

package/utils.ts

@@ -4,5 +4,7 @@ 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 };
+const capitalizeFirstLetter = (string:string) => string.charAt(0).toUpperCase() + string.slice(1)
+const getKeyRequestedChannelName = ( service:string ) => `keyRequestedFrom${capitalizeFirstLetter(service)}Service`
+const getListRequestedChannelName = ( service:string ) => `listRequestedFrom${capitalizeFirstLetter(service)}Service`
+export { getMessageReponseKey, redisMessageToArrayOfKeysAndValues, reduceArraysToArray, getKeyRequestedChannelName, getListRequestedChannelName };