woonplan-packages-redishelper 1.0.66 → 1.0.70

package/dist/getters.js

@@ -4,7 +4,7 @@ exports.subscribeToMessageResponse = exports.requestAndWaitForList = exports.get
 var utils_1 = require("./utils");
 var memdb_1 = require("./memdb");
 var uuid_1 = require("uuid");
-var timeout = 250;
+var timeout = 1500;
 var getOrRequestData = function (config, request, service, data) {
     if (data === void 0) { data = {}; }
     return new Promise(function (resolve, reject) {
@@ -26,7 +26,7 @@ var requestAndWaitForData = function (getterclient, config, request, service, da
         var listenerclient = (0, memdb_1.getRedisClient)(config);
         subscribeToMessageResponse(listenerclient, messageid).
             then(function () {
-            console.log("subscribed to ".concat(messageid, " at ").concat(new Date().toISOString()));
+            //console.log( `subscribed to ${messageid} at ${new Date().toISOString()}` )
             // we are subscribed
             // send out the request
             getterclient.xadd((0, utils_1.getKeyRequestedChannelName)(service), '*', 'request', request, 'messageid', messageid, 'data', JSON.stringify(data))

package/dist/index.d.ts

@@ -1,7 +1,6 @@
-import { Redis } from "ioredis";
 import { RedisConfig, RedisMessage } from "./types";
 import { sendMessageToStream, publishMessageResponse } from "./setters";
 import { getOrRequestData, subscribeToMessageResponse, requestAndWaitForList } from "./getters";
-declare const listenToStream: (client: Redis, groupname: string, channelname: string, consumername: string, callback: Function) => Promise<boolean>;
+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 };

package/dist/index.js

@@ -10,7 +10,8 @@ Object.defineProperty(exports, "subscribeToMessageResponse", { enumerable: true,
 Object.defineProperty(exports, "requestAndWaitForList", { enumerable: true, get: function () { return getters_1.requestAndWaitForList; } });
 var memdb_1 = require("./memdb");
 var utils_1 = require("./utils");
-var listenToStream = function (client, groupname, channelname, consumername, callback) { return new Promise(function (resolve, reject) {
+var listenToStream = function (config, groupname, channelname, consumername, callback) { return new Promise(function (resolve, reject) {
+    var client = (0, memdb_1.getRedisClient)(config);
     createGroup(client, groupname, channelname).then(function () {
         listenForMessage(client, groupname, channelname, consumername, callback);
         resolve(true);

package/dist/setters.d.ts

@@ -1,5 +1,11 @@
 import { Redis } from "ioredis";
-import { RedisMessage } from "./types";
+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>;
-export { publishMessageResponse, sendMessageToStream };
+export interface SocketToApiOptions {
+    endpoint: string;
+    data: Struct;
+    method: string;
+}
+declare const socketToApi: (config: RedisConfig, options?: SocketToApiOptions) => Promise<unknown>;
+export { publishMessageResponse, sendMessageToStream, socketToApi };

package/dist/setters.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 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)) {
@@ -9,16 +20,45 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendMessageToStream = exports.publishMessageResponse = void 0;
+exports.socketToApi = exports.sendMessageToStream = exports.publishMessageResponse = void 0;
+var memdb_1 = require("./memdb");
 var utils_1 = require("./utils");
+var uuid_1 = require("uuid");
+var data_1 = require("./data");
 var publishMessageResponse = function (client, messageid, message) {
-    console.log("publishing to ".concat(messageid, " at ").concat(new Date().toISOString()));
+    //console.log( `publishing to ${messageid} at ${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, []);
-    console.log('sendings message', channelname);
+    console.log('sending message', channelname);
     return client.xadd.apply(client, __spreadArray([channelname, '*'], arrayOfKeysAndValues, false));
 };
 exports.sendMessageToStream = sendMessageToStream;
+var timeout = 1500;
+// send a message from socket to api, creating a message id to publish the response on 
+var socketToApi = function (config, options) {
+    if (options === void 0) { options = { endpoint: '', method: 'GET', data: {}, }; }
+    return new Promise(function (resolve, reject) {
+        var client = (0, memdb_1.getRedisClient)(config), callbackclient = (0, memdb_1.getRedisClient)(config), messageid = (0, uuid_1.v4)();
+        (0, data_1.subscribeToMessageResponse)(callbackclient, messageid)
+            .then(function () {
+            callbackclient.once("message", function (_channel, message) {
+                resolve(message.length ? message : null);
+                callbackclient.disconnect();
+            });
+            // setup timeout 
+            setTimeout(function () {
+                if (callbackclient.status != "end") {
+                    console.log("sub timedout");
+                    reject('timeout');
+                    callbackclient.disconnect();
+                }
+            }, timeout);
+            return sendMessageToStream(client, 'api', __assign(__assign({}, options), { messageid: messageid }));
+        })
+            .catch(reject);
+    });
+};
+exports.socketToApi = socketToApi;

package/getters.ts

@@ -4,7 +4,7 @@ import { RedisConfig, Struct } from "./types"
 import { getRedisClient } from "./memdb"
 import { v4 as uuidv4 } from 'uuid';
 
-const timeout = 250;
+const timeout = 1500;
 
 const getOrRequestData = ( config:RedisConfig, request:string, service:string, data:Struct={} ) => new Promise((resolve, reject) => {
   const getterclient = getRedisClient( config )
@@ -36,7 +36,7 @@ const requestAndWaitForData = (
   subscribeToMessageResponse( listenerclient, messageid ).
   then(
     () => {      
-      console.log( `subscribed to ${messageid} at ${new Date().toISOString()}` )
+      //console.log( `subscribed to ${messageid} at ${new Date().toISOString()}` )
       // we are subscribed
       // send out the request
       getterclient.xadd( getKeyRequestedChannelName( service ), '*', 'request', request, 'messageid', messageid, 'data', JSON.stringify( data ) )

package/index.ts

@@ -5,7 +5,8 @@ import { getOrRequestData, subscribeToMessageResponse, requestAndWaitForList } f
 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) => { 
+const listenToStream = ( config:RedisConfig, groupname:string, channelname:string, consumername:string, callback:Function ):Promise<boolean> => new Promise((resolve,reject) => { 
+  const client = getRedisClient( config )
   createGroup( client, groupname, channelname ).then(
     ( ) => {
       listenForMessage( client, groupname, channelname, consumername, callback );

package/package.json

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

package/setters.ts

@@ -1,20 +1,61 @@
 
 import { Redis } from "ioredis"
-import { RedisMessage } from "./types"
+import { getRedisClient } from "./memdb"
+import { RedisConfig, RedisMessage, Struct } from "./types"
 import { getMessageReponseKey, redisMessageToArrayOfKeysAndValues, reduceArraysToArray } from "./utils"
+import { v4 as uuidv4 } from 'uuid';
+import { subscribeToMessageResponse } from "./data";
 
 const publishMessageResponse = ( client:Redis, messageid:string, message:string ) => {
-  console.log( `publishing to ${messageid} at ${new Date().toISOString()}` )
+  //console.log( `publishing to ${messageid} at ${new Date().toISOString()}` )
   return client.publish( getMessageReponseKey( messageid ), message )
 }
 
 
 const sendMessageToStream = ( client:Redis, channelname:string, message:RedisMessage) => {
   const arrayOfKeysAndValues = redisMessageToArrayOfKeysAndValues( message ).reduce( reduceArraysToArray, [] );
-  console.log( 'sendings message', channelname )
+  console.log( 'sending message', channelname )
   return client.xadd( channelname, '*', ...arrayOfKeysAndValues )
 }
 
+export interface SocketToApiOptions{
+  endpoint:string, 
+  data : Struct 
+  method:string 
+}
+
+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 client = getRedisClient( config ),
+        callbackclient = getRedisClient( config ),
+        messageid = uuidv4()
+  
+  subscribeToMessageResponse( callbackclient, messageid )
+  .then(() => {    
+    callbackclient.once( "message", ( _channel, message ) => {
+      resolve( message.length ? message : null )    
+      callbackclient.disconnect()
+    })
+
+    // setup timeout 
+    setTimeout( () => {
+      if( callbackclient.status != "end" ){
+        console.log( `sub timedout`)
+        reject( 'timeout' )
+        callbackclient.disconnect()
+      }        
+    }, timeout )
+
+    return sendMessageToStream( client, 'api', {
+      ...options,
+      messageid : messageid
+    })
+  })
+  .catch( reject )
+  
+})
 
 
-export { publishMessageResponse, sendMessageToStream }
+export { publishMessageResponse, sendMessageToStream, socketToApi }