woonplan-packages-redishelper 1.0.73 → 1.0.77

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/setters.d.ts

@@ -1,7 +1,7 @@
 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;

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), { data: JSON.stringify(options.data), messageid: messageid }));
+            return sendMessageToStream(config, 'api', __assign(__assign({}, options), { data: JSON.stringify(options.data), messageid: messageid }));
         })
             .catch(reject);
     });

package/index.ts

@@ -1,6 +1,6 @@
 import { Redis } from "ioredis"
 import { RedisConfig, RedisMessage } from "./types"
-import { sendMessageToStream, publishMessageResponse } from "./setters"
+import { sendMessageToStream, publishMessageResponse, toApiRequest } from "./setters"
 import { getOrRequestData, subscribeToMessageResponse, requestAndWaitForList } from "./getters"
 import { getRedisClient } from "./memdb"
 import { getKeyRequestedChannelName } from "./utils"
@@ -47,7 +47,7 @@ const dataRequester = ( config:RedisConfig, groupname:string, service:string, co
 }
 
 
-const socketToApiListener = ( config:RedisConfig, groupname:string, channelname:string, consumername:string, callback:Function ) => {
+const toApiListener = ( config:RedisConfig, groupname:string, channelname:string, consumername:string, callback:Function ) => {
   const listenerclient = getRedisClient( config )
   createGroup( listenerclient, groupname, channelname )
   .then(
@@ -205,4 +205,4 @@ const listenForMessage = ( client:Redis, groupname:string, channelname:string, c
     })
 }
 
-export { listenToStream, RedisMessage, sendMessageToStream, publishMessageResponse, getOrRequestData, socketToApiListener, dataRequester, subscribeToMessageResponse, requestAndWaitForList }
+export { listenToStream, RedisMessage, sendMessageToStream, toApiRequest, publishMessageResponse, getOrRequestData, toApiListener, dataRequester, subscribeToMessageResponse, requestAndWaitForList }

package/package.json

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

package/setters.ts

@@ -12,13 +12,14 @@ 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 )
 }
 
-export interface SocketToApiOptions{
+export interface toApiRequestOptions{
   endpoint:string, 
   data?: Struct 
   method?:string 
@@ -28,7 +29,7 @@ export interface SocketToApiOptions{
 const timeout = 1500
 
 // send a message from socket to api, creating a message id to publish the response on 
-const socketToApi = ( config:RedisConfig, options:SocketToApiOptions = { endpoint : '', method: 'GET', data : {}, } ) => new Promise((resolve, reject) => {
+const toApiRequest = ( config:RedisConfig, options:toApiRequestOptions = { endpoint : '', method: 'GET', data : {}, } ) => new Promise((resolve, reject) => {
   const client = getRedisClient( config ),
         callbackclient = getRedisClient( config ),
         messageid = uuidv4()
@@ -49,7 +50,7 @@ const socketToApi = ( config:RedisConfig, options:SocketToApiOptions = { endpoin
       }        
     }, timeout )
 
-    return sendMessageToStream( client, 'api', {
+    return sendMessageToStream( config, 'api', {
       ...options,
       data : JSON.stringify( options.data ),
       messageid : messageid
@@ -60,4 +61,4 @@ const socketToApi = ( config:RedisConfig, options:SocketToApiOptions = { endpoin
 })
 
 
-export { publishMessageResponse, sendMessageToStream, socketToApi }
+export { publishMessageResponse, sendMessageToStream, toApiRequest }