woonplan-packages-redishelper 1.0.48 → 1.0.52

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,71 +22,43 @@ var getOrRequestKey = function (client, key, service) { return new Promise(funct
     });
 }); };
 exports.getOrRequestKey = getOrRequestKey;
-var requestAndWaitForKey = function (client, key, service) { return new Promise(function (resolve) {
+var requestAndWaitForKey = function (getterclient, config, 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 () {
+    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("keyRequestedFrom".concat(service, "Service"), '*', 'key', key)
+        .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) {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Redis } from "ioredis";
 import { 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 };
+export { listenToStream, RedisMessage, sendMessageToStream, publishMessageResponse, getOrRequestKey, 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.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,6 @@ 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 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);

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

@@ -11,7 +11,10 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 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); };
+var publishMessageResponse = function (client, messageid, message) {
+    console.log("publishing to ".concat(messageid, " at ").concat(new Date().toISOString()));
+    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, []);

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/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 { Struct, 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,106 +28,58 @@ 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 );
   
-  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(
-    () => {
+  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( `keyRequestedFrom${service}Service`, '*', 'key', key )
+  .catch(
     (e) => {
       console.log( e )
       resolve( null )
     }
   )
+  .finally(
+    () => getterclient.disconnect()
+  )
 })
 
 const subscribeToMessageResponse = ( client:Redis, messageid:string ) => client.subscribe( getMessageReponseKey( messageid ) )
@@ -149,4 +107,4 @@ const requestAndWaitForList = (
 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,7 @@
 import { Redis } from "ioredis"
 import { RedisMessage } from "./types"
 import { sendMessageToStream, publishMessageResponse } from "./setters"
-import { getOrRequestKey, subscribeToMessageResponse, requestAndWaitForList, requestAndWaitForData } from "./getters"
+import { getOrRequestKey, subscribeToMessageResponse, requestAndWaitForList } 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(
@@ -81,4 +81,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, 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.48",
+  "version": "1.0.52",
   "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

@@ -3,7 +3,10 @@ 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 publishMessageResponse = ( client:Redis, messageid:string, message:string ) => {
+  console.log( `publishing to ${messageid} at ${new Date().toISOString()}` )
+  return client.publish( getMessageReponseKey( messageid ), message )
+}
 
 
 const sendMessageToStream = ( client:Redis, channelname:string, message:RedisMessage) => {

package/types.ts

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