chat-platform 1.2.3

package/helpers/lcd.js

@@ -0,0 +1,120 @@
+var clc = require('cli-color');
+var _ = require('underscore');
+var prettyjson = require('prettyjson');
+var moment = require('moment');
+
+var warn = clc.yellow;
+var grey = clc.blackBright;
+var green = clc.greenBright;
+var white = clc.white;
+var orange = clc.xterm(214);
+var whiteBright = clc.whiteBright;
+var red = clc.red;
+
+var LCD = {
+
+  warn: warn,
+  error: orange,
+  grey: grey,
+  green: green,
+  white: white,
+  orange: orange,
+  red: red,
+
+  dump: function(e, title) {
+    this.title(!_.isEmpty(title) ? title : 'Error');
+    if (e instanceof Error) {
+      Error.captureStackTrace(e);
+      var lines = e.stack.split('\n');
+      lines.shift();
+      lines.shift();
+      // is there a better way to get this?
+      var reference = e.toString().replace(e.message, '').replace(': ', '');
+      // eslint-disable-next-line no-console
+      console.log(whiteBright(reference) + ': ' + red(e.message));
+      // eslint-disable-next-line no-console
+      console.log(this.grey(lines.join('\n')));
+    } else {
+      // eslint-disable-next-line no-console
+      console.log(e);
+    }
+    // eslint-disable-next-line no-console
+    console.log('');
+  },
+
+  beautify: function(payload) {
+    if (payload == null) {
+      return payload;
+    }
+    payload = _.clone(payload);
+    _(payload).each(function(value, key) {
+      if (value instanceof Buffer) {
+        payload[key] = '<Buffer>';
+      } else if (value instanceof moment) {
+        payload[key] = value.toString();
+      }
+    });
+    return payload;
+  },
+
+  title: function(title) {
+    title = ' ' + title + ' ';
+    var padding = Math.floor((80 - title.length)/2);
+    _.times(padding, function() {
+      title = '-' + title;
+    });
+    while (title.length < 80) {
+      title += '-';
+    }
+    // eslint-disable-next-line no-console
+    console.log(grey(title));
+  },
+
+  node: function(obj, options) {
+
+    options = _.extend({
+      nodeId: null,
+      title: null,
+      color: function(value) {
+        return value;
+      }
+    }, options);
+
+    // eslint-disable-next-line no-console
+    console.log('');
+
+    var title = '';
+    if (!_.isEmpty(options.title)) {
+      title += options.title;
+    }
+    if (options.node != null) {
+      title += ' (id:' + options.node.id + ')';
+    }
+
+    if (!_.isEmpty(title)) {
+      title = ' ' + title + ' ';
+      var padding = Math.floor((80 - title.length)/2);
+      _.times(padding, function() {
+        title = '-' + title;
+      });
+      while (title.length < 80) {
+        title += '-';
+      }
+      // eslint-disable-next-line no-console
+      console.log(grey(title));
+    }
+
+    if (_.isString(obj)) {
+      // eslint-disable-next-line no-console
+      console.log(options.color(obj));
+    } else {
+      // eslint-disable-next-line no-console
+      console.log(prettyjson.render(LCD.beautify(obj)));
+    }
+    // eslint-disable-next-line no-console
+    console.log('');
+  }
+
+};
+
+module.exports = LCD;

package/helpers/promises-queue.js

@@ -0,0 +1,41 @@
+var _ = require('underscore');
+
+var FileQueue = function() {
+  var tasks = [];
+  function removeTask(promise) {
+    tasks = _(tasks).reject(function(task) {
+      return task === promise;
+    });
+  }
+
+  return {
+
+    count: function() {
+      return tasks.length;
+    },
+
+    add: function(task) {
+      var current = null;
+      if (tasks.length === 0) {
+        // if it's just one task then launch it
+        current = new Promise(task);
+      } else {
+        // only chain when all the current promises are fulfilled, it's ok since tasks is immutable
+        // even if some other task is chained after this
+        current = Promise.all(tasks)
+          .then(function() {
+            return new Promise(task);
+          });
+      }
+      // create new task list with the new one, it's important to create a new instance
+      tasks = tasks.concat(current);
+      // return the promise, when is done remove from the current task
+      return current
+        .then(function() {
+          removeTask(current);
+        });
+    }
+  };
+};
+
+module.exports = FileQueue;

package/helpers/utils.js

@@ -0,0 +1,25 @@
+const _ = require('underscore');
+
+module.exports = {
+
+  /**
+   * @method when
+   * If an object is thenable, then return the object itself, otherwise wrap it into a promise
+   * @param param {any}
+   * @deferred
+   */
+  when(param) {
+    if (param != null && _.isFunction(param.then)) {
+      return param;
+      // eslint-disable-next-line no-undefined
+    } else if (param !== undefined) {
+      return new Promise(function(resolve) {
+        resolve(param);
+      });
+    }
+    return new Promise(function(resolve, reject) {
+      reject();
+    });
+  }
+
+};

package/index.js

@@ -0,0 +1,6 @@
+const ChatExpress = require('./chat-platform');
+const ContextProviders = require('./chat-context-factory');
+const ChatLog = require('./chat-log');
+const UniversalPlatform = require('./universal');
+
+module.exports = { ChatExpress, ContextProviders, ChatLog, UniversalPlatform };

package/jest.config.js

@@ -0,0 +1,5 @@
+// jest.config.js
+module.exports = {
+  verbose: true,
+  testURL: 'http://localhost'
+};

package/lib/lcd.js

@@ -0,0 +1,151 @@
+var clc = require('cli-color');
+var _ = require('underscore');
+var prettyjson = require('prettyjson');
+var moment = require('moment');
+
+var warn = clc.yellow;
+var grey = clc.blackBright;
+var green = clc.greenBright;
+var white = clc.white;
+var orange = clc.xterm(214);
+var whiteBright = clc.whiteBright;
+var red = clc.red;
+
+var LCD = {
+
+  warn: warn,
+  error: orange,
+  grey: grey,
+  green: green,
+  white: white,
+  orange: orange,
+  red: red,
+
+  timestamp() {
+    return LCD.white(moment().format('DD MMM HH:mm:ss') + ' - [info] ');
+  },
+
+  dump: function(e, title) {
+    this.title(!_.isEmpty(title) ? title : 'Error');
+    if (e instanceof Error) {
+      Error.captureStackTrace(e);
+      var lines = e.stack.split('\n');
+      lines.shift();
+      lines.shift();
+      // is there a better way to get this?
+      var reference = e.toString().replace(e.message, '').replace(': ', '');
+      // eslint-disable-next-line no-console
+      console.log(whiteBright(reference) + ': ' + red(e.message));
+      // eslint-disable-next-line no-console
+      console.log(this.grey(lines.join('\n')));
+    } else if (_.isArray(e)) {
+      // eslint-disable-next-line no-console
+      console.log(prettyjson.render(LCD.beautify(e)));
+    } else {
+      // eslint-disable-next-line no-console
+      console.log(e);
+    }
+    // eslint-disable-next-line no-console
+    console.log('');
+  },
+
+  beautify: function(payload) {
+    if (payload == null) {
+      return payload;
+    }
+    payload = _.clone(payload);
+    _(payload).each(function(value, key) {
+      if (value instanceof Buffer) {
+        payload[key] = '<Buffer>';
+      } else if (value instanceof moment) {
+        payload[key] = value.toString();
+      }
+    });
+    return payload;
+  },
+
+  title: function(title) {
+    title = ' ' + title + ' ';
+    var padding = Math.floor((80 - title.length)/2);
+    _.times(padding, function() {
+      title = '-' + title;
+    });
+    while (title.length < 80) {
+      title += '-';
+    }
+    // eslint-disable-next-line no-console
+    console.log(grey(title));
+  },
+
+  prettify: function(obj, { indent = 0 } = {}) {
+    let rendered = prettyjson.render(LCD.beautify(obj));
+    if (_.isNumber(indent) && indent != 0) {
+      rendered = '  ' + rendered.replace(/[\n]/g, "\n  ");
+    }
+    return rendered;
+  },
+
+  node: function(obj, options) {
+
+    options = _.extend({
+      nodeId: null,
+      title: null,
+      color: function(value) {
+        return value;
+      }
+    }, options);
+
+    // eslint-disable-next-line no-console
+    console.log('');
+
+    var title = '';
+    if (!_.isEmpty(options.title)) {
+      title += options.title;
+    }
+    if (options.node != null) {
+      title += ' (id:' + options.node.id + ')';
+    }
+
+    if (!_.isEmpty(title)) {
+      title = ' ' + title + ' ';
+      var padding = Math.floor((80 - title.length)/2);
+      _.times(padding, function() {
+        title = '-' + title;
+      });
+      while (title.length < 80) {
+        title += '-';
+      }
+      // eslint-disable-next-line no-console
+      console.log(grey(title));
+    }
+
+    if (_.isString(obj)) {
+      // eslint-disable-next-line no-console
+      console.log(options.color(obj));
+    } else {
+      // eslint-disable-next-line no-console
+      console.log(prettyjson.render(LCD.beautify(obj)));
+    }
+    // eslint-disable-next-line no-console
+    console.log('');
+  },
+
+  graphQLError: (error, node) => {
+    if (error != null && error.networkError != null && error.networkError.result != null && error.networkError.result.errors != null) {
+      let errors = error.networkError.result.errors.map(error => {
+        let errorMsg = error.message;
+        if (error.locations != null) {
+          errorMsg += ` (line: ${error.locations[0].line})`;
+        }
+        return errorMsg;
+      });
+      LCD.dump(errors, `GraphQL Error (id: ${node.id}${!_.isEmpty(node.name) ? ', name: ' + node.name : ''})`);
+    } else {
+      LCD.dump('Unknown GraphQL error', `GraphQL Error (id: ${node.id}${!_.isEmpty(node.name) ? ', name: ' + node.name : ''})`);
+      console.log(error);
+    }
+  }
+
+};
+
+module.exports = LCD;

package/lib/red-stub.js

@@ -0,0 +1,212 @@
+/* eslint-disable */
+var _ = require('underscore');
+var ChatContextFactory = require('../chat-context-factory')({});
+var ChatContextProvider = ChatContextFactory.getProvider('memory', {});
+
+module.exports = function() {
+
+  var _cbInput = null;
+  var _type = null;
+  var _factory = null;
+  var _node = null;
+  var _config = null;
+  var _message = null;
+  var _flow = {};
+  var _global = {};
+  var _chatContext = null;
+  var _nodecontext = {};
+  var _error = null;
+  var _nodes = {};
+
+  var RED = {
+
+    global:  {
+      get: function(key) {
+        return _global[key];
+      },
+      set: function(key, value) {
+        _global[key] = value;
+        return this;
+      }
+    },
+
+    util: {
+      cloneMessage: function(msg) {
+        return msg
+      }
+    },
+
+    environment: {
+      chat: function(chatId, obj) {
+        _(obj).map(function(value, key) {
+          _chatContext.set(key, value);
+        });
+      }
+    },
+
+    createMessage: function(payload, transport, global) {
+      var chatId = 42;
+      // create a chat context if doesn't exists
+
+      var msg = {
+        originalMessage: {
+          chatId: chatId,
+          transport: transport != null ? transport : 'telegram',
+          chat: {
+            id: chatId
+          },
+          message_id: 72
+        },
+        chat: function() {
+          return ChatContextProvider.getOrCreate(chatId);
+        },
+        payload: payload != null ? payload : 'I am the original message'
+      };
+      _global = _.extend({}, global);
+      //_chatContext = ChatContext(chatId);
+      //_chatContext.clear();
+      msg.chat().clear();
+      // store it
+      //ChatContextStore.set(chatId, _chatContext);
+      if (payload != null) {
+        msg.payload = payload;
+      }
+      return msg;
+    },
+
+    events: {
+      on: function() {
+        // do nothing
+      }
+    },
+
+    node: {
+      config: function(config) {
+        _config = config;
+      },
+      clear: function() {
+        _nodecontext = {};
+      },
+      message: function(idx) {
+        if (_.isArray(_message)) {
+          return idx != null ? _message[idx] : _message[0];
+        } else {
+          return _message;
+        }
+      },
+      error: function() {
+        return _error;
+      },
+      get: function(idx) {
+        return idx != null ? _node[idx] : _node;
+      },
+      context: function() {
+        return _node.context();
+      }
+    },
+
+    nodes: {
+      registerType: function(type, factory) {
+        _type = type;
+        _factory = factory;
+        factory(_config);
+      },
+
+      getNode: function(nodeId) {
+        return _nodes[nodeId];
+      },
+
+      setNode: function(nodeId, node) {
+        _nodes[nodeId] = node;
+      },
+
+      /**
+       * @method createNode
+       * Mock createdNode called when initializing a custom node
+       */
+      createNode: function(node, config) {
+
+        node.on = function(eventName, cb) {
+          if (eventName === 'input') {
+            _cbInput = cb;
+          }
+        };
+        node.emit = function(eventName, msg) {
+          if (eventName === 'input') {
+            _message = null;
+            _cbInput(msg);
+          }
+        };
+        node.await = function() {
+          var retries = 0;
+          var intervalId = null;
+          return new Promise(function(resolve, reject) {
+            intervalId = setInterval(function() {
+              if (_message !== null) {
+                clearInterval(intervalId);
+                resolve();
+              } else if (_error != null) {
+                clearInterval(intervalId);
+                reject(_error);
+              } else if (retries > 20) {
+                clearInterval(intervalId);
+                reject();
+              } else {
+                retries++;
+              }
+            }, 30);
+          });
+        };
+        node.send = function(msg) {
+          _message = msg;
+        };
+        node.error = function(msg) {
+          _error = msg;
+        };
+        node.context = function() {
+          return {
+            flow: {
+              get: function(key) {
+                return _flow[key];
+              },
+              set: function(key, value) {
+                _flow[key] = value;
+                return this;
+              }
+            },
+            global: _.extend({}, _global, {
+              get: function(key) {
+                return _global[key];
+              },
+              set: function(key, value) {
+                _global[key] = value;
+                return this;
+              }
+            }),
+            chat: {
+              get: function(key) {
+                return _chatContext.get(key);
+              },
+              set: function(key, value) {
+                _chatContext.set(key, value);
+              }
+            },
+            get: function(key) {
+              return _nodecontext[key];
+            },
+            set: function(key, value) {
+              _nodecontext[key] = value;
+              return this;
+            }
+          };
+        };
+        node.wires = [{}, null];
+        _node = node;
+      }
+    }
+
+  };
+
+  return RED;
+};
+/* eslint-enable */

package/lib/utils.js

@@ -0,0 +1,29 @@
+const _ = require('underscore');
+
+module.exports = {
+
+  isEmpty(value) {
+    return value == null || value === '';
+  },
+
+  /**
+   * @method when
+   * If an object is thenable, then return the object itself, otherwise wrap it into a promise
+   * @param {any}
+   * @deferred
+   */
+  when(param) {
+    if (param != null && _.isFunction(param.then)) {
+      return param;
+      // eslint-disable-next-line no-undefined
+    } else if (param !== undefined) {
+      return new Promise(function (resolve) {
+        resolve(param);
+      });
+    }
+    return new Promise(function (resolve, reject) {
+      reject();
+    });
+  }
+
+};