woonplan-packages-redishelper 1.0.70 → 1.0.74

package/data.ts

@@ -1,74 +1,8 @@
 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 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 }
+export {  subscribeToMessageResponse }

package/dist/data.d.ts

@@ -1,5 +1,3 @@
 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 };
+export { subscribeToMessageResponse };

package/dist/data.js

@@ -1,46 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.subscribeToMessageResponse = exports.requestAndWaitForList = exports.getOrRequestKey = void 0;
+exports.subscribeToMessageResponse = 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 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

@@ -3,4 +3,5 @@ import { sendMessageToStream, publishMessageResponse } from "./setters";
 import { getOrRequestData, subscribeToMessageResponse, requestAndWaitForList } from "./getters";
 declare const listenToStream: (config: RedisConfig, groupname: string, channelname: string, consumername: string, callback: Function) => Promise<boolean>;
 declare const dataRequester: (config: RedisConfig, groupname: string, service: string, consumername: string, callback: Function) => void;
-export { listenToStream, RedisMessage, sendMessageToStream, publishMessageResponse, getOrRequestData, dataRequester, subscribeToMessageResponse, requestAndWaitForList };
+declare const socketToApiListener: (config: RedisConfig, groupname: string, channelname: string, consumername: string, callback: Function) => void;
+export { listenToStream, RedisMessage, sendMessageToStream, publishMessageResponse, getOrRequestData, socketToApiListener, dataRequester, subscribeToMessageResponse, requestAndWaitForList };

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requestAndWaitForList = exports.subscribeToMessageResponse = exports.dataRequester = exports.getOrRequestData = exports.publishMessageResponse = exports.sendMessageToStream = exports.listenToStream = void 0;
+exports.requestAndWaitForList = exports.subscribeToMessageResponse = exports.dataRequester = exports.socketToApiListener = exports.getOrRequestData = 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; } });
@@ -38,6 +38,47 @@ var dataRequester = function (config, groupname, service, consumername, callback
         .then(function () { return listenForMessageForDataRequest(listenerclient, groupname, channelname, consumername, callback); });
 };
 exports.dataRequester = dataRequester;
+var socketToApiListener = function (config, groupname, channelname, consumername, callback) {
+    var listenerclient = (0, memdb_1.getRedisClient)(config);
+    createGroup(listenerclient, groupname, channelname)
+        .then(function () { return listenForMessageForDataRequest(listenerclient, groupname, channelname, consumername, callback); });
+};
+exports.socketToApiListener = socketToApiListener;
+var listenForMessageForApiRequest = function (listenerclient, groupname, channelname, consumername, callback) {
+    console.log("listening to ".concat(channelname, " as ").concat(consumername));
+    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.messageid;
+        //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 : '');
+    })
+        .catch(function (e) {
+        console.log(e);
+        return (0, setters_1.publishMessageResponse)(listenerclient, messageid, '');
+    })
+        .finally(function () {
+        listenerclient.xack(channelname, groupname, streammsgid).then(function () {
+            console.log(streammsgid + ' acknowledged');
+        });
+        listenForMessageForApiRequest(listenerclient, groupname, channelname, consumername, callback);
+    });
+};
 var getMessagedataFromResult = function (results) {
     if (!results.length)
         throw ('no-messagedata');

package/dist/setters.d.ts

@@ -1,11 +1,12 @@
 import { Redis } from "ioredis";
 import { RedisConfig, RedisMessage, Struct } from "./types";
 declare const publishMessageResponse: (client: Redis, messageid: string, message: string) => Promise<number>;
-declare const sendMessageToStream: (client: Redis, channelname: string, message: RedisMessage) => Promise<string>;
+declare const sendMessageToStream: (config: RedisConfig, channelname: string, message: RedisMessage) => Promise<string>;
 export interface SocketToApiOptions {
     endpoint: string;
-    data: Struct;
-    method: string;
+    data?: Struct;
+    method?: string;
+    jwt?: string;
 }
 declare const socketToApi: (config: RedisConfig, options?: SocketToApiOptions) => Promise<unknown>;
 export { publishMessageResponse, sendMessageToStream, socketToApi };

package/dist/setters.js

@@ -30,7 +30,8 @@ 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 sendMessageToStream = function (config, channelname, message) {
+    var client = (0, memdb_1.getRedisClient)(config);
     var arrayOfKeysAndValues = (0, utils_1.redisMessageToArrayOfKeysAndValues)(message).reduce(utils_1.reduceArraysToArray, []);
     console.log('sending message', channelname);
     return client.xadd.apply(client, __spreadArray([channelname, '*'], arrayOfKeysAndValues, false));
@@ -56,7 +57,7 @@ var socketToApi = function (config, options) {
                     callbackclient.disconnect();
                 }
             }, timeout);
-            return sendMessageToStream(client, 'api', __assign(__assign({}, options), { messageid: messageid }));
+            return sendMessageToStream(config, 'api', __assign(__assign({}, options), { data: JSON.stringify(options.data), messageid: messageid }));
         })
             .catch(reject);
     });

package/index.ts

@@ -46,6 +46,58 @@ const dataRequester = ( config:RedisConfig, groupname:string, service:string, co
   )
 }
 
+
+const socketToApiListener = ( config:RedisConfig, groupname:string, channelname:string, consumername:string, callback:Function ) => {
+  const listenerclient = getRedisClient( config )
+  createGroup( listenerclient, groupname, channelname )
+  .then(
+    () => listenForMessageForDataRequest( listenerclient, groupname, channelname, consumername, callback )
+  )
+}
+
+
+const listenForMessageForApiRequest = (
+  listenerclient:Redis, groupname:string, channelname:string, consumername:string, callback:Function
+) => {
+  console.log( `listening to ${channelname} as ${consumername}`)
+  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.messageid;
+      //stream id from redis
+      streammsgid = id;
+      return messagedata
+    } 
+  )
+  .then( (messagedata) =>
+    callback( messagedata, streammsgid )
+  )
+  .then(( result:any ) => 
+    publishMessageResponse( listenerclient, messageid, result != null ? result : '' )
+  )
+  .catch((e)=>{
+    console.log( e )
+    return publishMessageResponse( listenerclient, messageid, '' )
+  })
+  .finally( () => 
+    {
+      listenerclient.xack( channelname, groupname, streammsgid ).then( () => {
+        console.log( streammsgid + ' acknowledged')
+      })
+      listenForMessageForApiRequest( listenerclient, groupname, channelname, consumername, callback );
+
+    }
+  )
+}
+
+
+
 const getMessagedataFromResult = ( results:any ) => {
   if( !results.length ) throw('no-messagedata');
 
@@ -153,4 +205,4 @@ const listenForMessage = ( client:Redis, groupname:string, channelname:string, c
     })
 }
 
-export { listenToStream, RedisMessage, sendMessageToStream, publishMessageResponse, getOrRequestData, dataRequester, subscribeToMessageResponse, requestAndWaitForList }
+export { listenToStream, RedisMessage, sendMessageToStream, publishMessageResponse, getOrRequestData, socketToApiListener, dataRequester, subscribeToMessageResponse, requestAndWaitForList }

package/package.json

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

package/setters.ts

@@ -12,7 +12,8 @@ const publishMessageResponse = ( client:Redis, messageid:string, message:string
 }
 
 
-const sendMessageToStream = ( client:Redis, channelname:string, message:RedisMessage) => {
+const sendMessageToStream = ( config:RedisConfig, channelname:string, message:RedisMessage) => {
+  const client = getRedisClient( config )
   const arrayOfKeysAndValues = redisMessageToArrayOfKeysAndValues( message ).reduce( reduceArraysToArray, [] );
   console.log( 'sending message', channelname )
   return client.xadd( channelname, '*', ...arrayOfKeysAndValues )
@@ -20,8 +21,9 @@ const sendMessageToStream = ( client:Redis, channelname:string, message:RedisMes
 
 export interface SocketToApiOptions{
   endpoint:string, 
-  data : Struct 
-  method:string 
+  data?: Struct 
+  method?:string 
+  jwt? :string
 }
 
 const timeout = 1500
@@ -48,8 +50,9 @@ const socketToApi = ( config:RedisConfig, options:SocketToApiOptions = { endpoin
       }        
     }, timeout )
 
-    return sendMessageToStream( client, 'api', {
+    return sendMessageToStream( config, 'api', {
       ...options,
+      data : JSON.stringify( options.data ),
       messageid : messageid
     })
   })