@nlabs/reaktor 0.1.2 → 0.1.4

package/.eslintrc

@@ -0,0 +1,18 @@
+{
+  "extends": [
+    "styleguidejs/typescript"
+  ],
+  "rules": {
+    "import/no-extraneous-dependencies": [
+      "error",
+      {
+        "devDependencies": [
+          "**/*.test.js",
+          "**/*.spec.js",
+          "**/*.js",
+          "tasks/*.ts"
+        ]
+      }
+    ]
+  }
+}

package/lib/config.d.ts

@@ -0,0 +1,21 @@
+export interface AppConfig {
+    readonly app?: object;
+    readonly arangodb?: object;
+    readonly aws?: object;
+    readonly giphy?: object;
+    readonly google?: object;
+    readonly image?: object;
+    readonly redis?: object;
+    readonly stripe?: object;
+    readonly twilio?: object;
+}
+export interface EnvConfig {
+    readonly default: AppConfig;
+    readonly development: AppConfig;
+    readonly production: AppConfig;
+    readonly test: AppConfig;
+}
+export declare class Config {
+    static values: EnvConfig;
+    static get(path: string | string[]): any;
+}

package/lib/config.js

@@ -0,0 +1,130 @@
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import _get from 'lodash/get';
+import merge from 'lodash/merge';
+
+var appPackage = require('../package.json');
+
+var _process$env = process.env,
+    _process$env$arangodb = _process$env.arangodbDatabase,
+    arangodbDatabase = _process$env$arangodb === void 0 ? 'reaktor' : _process$env$arangodb,
+    arangodbPassword = _process$env.arangodbPassword,
+    _process$env$arangodb2 = _process$env.arangodbPort,
+    arangodbPort = _process$env$arangodb2 === void 0 ? '8529' : _process$env$arangodb2,
+    _process$env$arangodb3 = _process$env.arangodbUrl,
+    arangodbUrl = _process$env$arangodb3 === void 0 ? 'db.reaktor.io' : _process$env$arangodb3,
+    _process$env$arangodb4 = _process$env.arangodbUsername,
+    arangodbUsername = _process$env$arangodb4 === void 0 ? 'reaktor' : _process$env$arangodb4;
+export var Config =
+/*#__PURE__*/
+function () {
+  function Config() {
+    _classCallCheck(this, Config);
+  }
+
+  _createClass(Config, null, [{
+    key: "get",
+    value: function get(path) {
+      var environment = process.env.stage || 'development';
+      var configValues = merge(this.values.default, this.values[environment], {
+        environment: environment
+      });
+      return _get(configValues, path);
+    }
+  }]);
+
+  return Config;
+}();
+
+_defineProperty(Config, "values", {
+  default: {
+    app: {
+      name: 'reaktor',
+      url: 'reaktor.io',
+      version: appPackage.version
+    },
+    arangodb: {
+      apiUrl: "http://".concat(arangodbUrl, ":").concat(arangodbPort),
+      database: arangodbDatabase,
+      dump: '/Applications/ArangoDB-CLI.app/Contents/MacOS/arangodump',
+      password: arangodbPassword,
+      port: arangodbPort,
+      restore: '/Applications/ArangoDB-CLI.app/Contents/MacOS/arangorestore',
+      url: arangodbUrl,
+      username: arangodbUsername
+    },
+    aws: {
+      Bucket: 'dev.reaktor.io',
+      accessKeyId: 'AKIAJIYDT3EA2ZFMTJNA',
+      maxRetries: 3,
+      region: 'us-east-1',
+      secretAccessKey: 'bUssQRtJTZC7geF9RDH5KCn8CalVnf2VT34yqS+9',
+      signatureVersion: 'v4'
+    },
+    giphy: {
+      key: 'dc6zaTOxFJmzC'
+    },
+    google: {
+      analytics: {
+        accountId: '78158717',
+        trackingId: 'UA-78158717-1'
+      },
+      geocode: {
+        key: 'AIzaSyBwjmpBjWhiJoBCZiYzRurM9m4WnCxslv0',
+        url: 'https://maps.googleapis.com/maps/api/geocode/json'
+      },
+      key: 'AIzaSyC3_f2Us3y0qjbyMJ-4t5ObtCzfq_FHIgQ'
+    },
+    image: {
+      imgQuality: 90,
+      imgSize: 1500,
+      thmQuality: 80,
+      thmSize: 150
+    },
+    redis: {
+      host: '127.0.0.1',
+      port: 6379
+    },
+    stripe: {
+      token: 'sk_test_LS956be57YUXTB5a4sLGb5BQ'
+    },
+    twilio: {
+      number: '+15005550006',
+      sid: 'AC6bd7f513cbed2e5134c650be06cc732e',
+      token: '520ae739e761bab759b147f1ad28278f'
+    }
+  },
+  development: {},
+  production: {
+    arangodb: {
+      dump: '/usr/bin/arangodump',
+      restore: '/usr/bin/arangorestore'
+    },
+    aws: {
+      Bucket: 'box.reaktor.io'
+    },
+    redis: {
+      host: 'reaktor-redis.ehcvnt.0001.use1.cache.amazonaws.com'
+    },
+    stripe: {
+      token: 'sk_live_bElZl8RLhMCJy33KG4lyLD4o'
+    },
+    twilio: {
+      number: '+18554165227',
+      sid: 'AC90b0528a911e652d643329a4d7b4d2c7',
+      token: 'a7941d173bd4846d0966a186e9865b72'
+    }
+  },
+  test: {}
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/config.ts"],"names":["get","merge","appPackage","require","process","env","arangodbDatabase","arangodbPassword","arangodbPort","arangodbUrl","arangodbUsername","Config","path","environment","stage","configValues","values","default","app","name","url","version","arangodb","apiUrl","database","dump","password","port","restore","username","aws","Bucket","accessKeyId","maxRetries","region","secretAccessKey","signatureVersion","giphy","key","google","analytics","accountId","trackingId","geocode","image","imgQuality","imgSize","thmQuality","thmSize","redis","host","stripe","token","twilio","number","sid","development","production","test"],"mappings":"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","sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport get from 'lodash/get';\nimport merge from 'lodash/merge';\n\nexport interface AppConfig {\n  readonly app?: object;\n  readonly arangodb?: object;\n  readonly aws?: object;\n  readonly giphy?: object;\n  readonly google?: object;\n  readonly image?: object;\n  readonly redis?: object;\n  readonly stripe?: object;\n  readonly twilio?: object;\n}\n\nexport interface EnvConfig {\n  readonly default: AppConfig;\n  readonly development: AppConfig;\n  readonly production: AppConfig;\n  readonly test: AppConfig;\n}\n\nconst appPackage: any = require('../package.json');\n\nconst {\n  arangodbDatabase = 'reaktor',\n  arangodbPassword,\n  arangodbPort = '8529',\n  arangodbUrl = 'db.reaktor.io',\n  arangodbUsername = 'reaktor'\n} = process.env;\n\nexport class Config {\n  static values: EnvConfig = {\n    default: {\n      app: {\n        name: 'reaktor',\n        url: 'reaktor.io',\n        version: appPackage.version\n      },\n      arangodb: {\n        apiUrl: `http://${arangodbUrl}:${arangodbPort}`,\n        database: arangodbDatabase,\n        dump: '/Applications/ArangoDB-CLI.app/Contents/MacOS/arangodump',\n        password: arangodbPassword,\n        port: arangodbPort,\n        restore: '/Applications/ArangoDB-CLI.app/Contents/MacOS/arangorestore',\n        url: arangodbUrl,\n        username: arangodbUsername\n      },\n      aws: {\n        Bucket: 'dev.reaktor.io',\n        accessKeyId: 'AKIAJIYDT3EA2ZFMTJNA',\n        maxRetries: 3,\n        region: 'us-east-1',\n        secretAccessKey: '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',\n        signatureVersion: 'v4'\n      },\n      giphy: {\n        key: 'dc6zaTOxFJmzC'\n      },\n      google: {\n        analytics: {\n          accountId: '78158717',\n          trackingId: 'UA-78158717-1'\n        },\n        geocode: {\n          key: 'AIzaSyBwjmpBjWhiJoBCZiYzRurM9m4WnCxslv0',\n          url: 'https://maps.googleapis.com/maps/api/geocode/json'\n        },\n        key: 'AIzaSyC3_f2Us3y0qjbyMJ-4t5ObtCzfq_FHIgQ'\n      },\n      image: {\n        imgQuality: 90,\n        imgSize: 1500,\n        thmQuality: 80,\n        thmSize: 150\n      },\n      redis: {\n        host: '127.0.0.1',\n        port: 6379\n      },\n      stripe: {\n        token: 'sk_test_LS956be57YUXTB5a4sLGb5BQ'\n      },\n      twilio: {\n        number: '+15005550006',\n        sid: 'AC6bd7f513cbed2e5134c650be06cc732e',\n        token: '520ae739e761bab759b147f1ad28278f'\n      }\n    },\n    development: {\n    },\n    production: {\n      arangodb: {\n        dump: '/usr/bin/arangodump',\n        restore: '/usr/bin/arangorestore',\n      },\n      aws: {\n        Bucket: 'box.reaktor.io'\n      },\n      redis: {\n        host: 'reaktor-redis.ehcvnt.0001.use1.cache.amazonaws.com'\n      },\n      stripe: {\n        token: 'sk_live_bElZl8RLhMCJy33KG4lyLD4o'\n      },\n      twilio: {\n        number: '+18554165227',\n        sid: 'AC90b0528a911e652d643329a4d7b4d2c7',\n        token: 'a7941d173bd4846d0966a186e9865b72'\n      }\n    },\n    test: {\n    }\n  };\n\n  static get(path: string | string[]): any {\n    const environment: string = process.env.stage || 'development';\n    const configValues: object = merge(this.values.default, this.values[environment], {environment});\n    return get(configValues, path);\n  }\n}\n"]}

package/lib/data/conversations.d.ts

@@ -0,0 +1,6 @@
+import { ApiContext } from 'types/auth';
+import { ConversationType } from '../types';
+export declare const getConversationList: (context: ApiContext, from: number, to: number) => Promise<ConversationType[]>;
+export declare const getDirectConversation: (context: ApiContext, userId: string) => Promise<ConversationType>;
+export declare const getConversation: (context: ApiContext, convoId: string) => Promise<ConversationType>;
+export declare const updateConversation: (context: ApiContext, item: any) => Promise<ConversationType>;

package/lib/data/conversations.js

@@ -0,0 +1,197 @@
+function _templateObject3() {
+  var data = _taggedTemplateLiteral(["UPSERT {_key: ", "}\n    INSERT ", "\n    UPDATE ", "\n    IN conversations RETURN NEW"]);
+
+  _templateObject3 = function _templateObject3() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject2() {
+  var data = _taggedTemplateLiteral(["FOR c IN conversations\n    FILTER ", " == c._key && IS_LIST(c.users) && POSITION(c.users, ", ", false)\n    LET u = (\n      FOR g IN c.users\n      FOR u IN users\n      FILTER g == u._key\n      RETURN {_key:u._key, first:u.first, last:u.last, name:u.name, email:u.email, username:u.username, photo:u.photo }\n    )\n    FILTER LENGTH(u) > 1\n    LIMIT 1\n    RETURN MERGE(c, {users: u})"]);
+
+  _templateObject2 = function _templateObject2() {
+    return data;
+  };
+
+  return data;
+}
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _templateObject() {
+  var data = _taggedTemplateLiteral(["FOR c IN conversations\n    FILTER LENGTH(c.users) == 2 &&\n    POSITION(c.users, ", ", false) &&\n    POSITION(c.users, ", ", false)\n    LET u = (\n      FOR g IN c.users\n      FOR user IN users\n      FILTER user._key == g\n      RETURN user\n    )\n    LIMIT 1\n    RETURN MERGE(c, {users: u})"]);
+
+  _templateObject = function _templateObject() {
+    return data;
+  };
+
+  return data;
+}
+
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import { createHash, parseId } from '@nlabs/utils';
+import { aql } from 'arangojs';
+import cloneDeep from 'lodash/cloneDeep';
+import identity from 'lodash/identity';
+import isEmpty from 'lodash/isEmpty';
+import pick from 'lodash/pick';
+import { getLimit, useDb } from '../utils';
+import { logError } from '../utils/analytics';
+import { getUrlImages } from './images';
+import { getDisplayName } from './users';
+var eventCategory = 'conversations';
+export var getConversationList = function getConversationList(context, from, to) {
+  var action = 'getList';
+  var database = context.database,
+      sessionId = context.userId;
+  var limit = getLimit(from, to);
+  var aqlQry = "FOR c IN conversations\n    FILTER POSITION(c.users, \"".concat(sessionId, "\", false)\n    LET u = (\n      FOR g IN c.users\n      FOR u IN users\n      FILTER g == u._key\n      RETURN {_key:u._key, first:u.first, last:u.last, name:u.name, email:u.email, username:u.username, photo:u.photo }\n    )\n    FILTER LENGTH(u) > 1\n    ").concat(limit.aql, "\n    RETURN {_key:c._key, name: c.name, direct: c.direct, users: u}");
+  return useDb(database).query(aqlQry).then(function (cursor) {
+    return cursor.all();
+  }).catch(function (error) {
+    return logError({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(function () {
+      return null;
+    });
+  });
+};
+export var getDirectConversation = function getDirectConversation(context, userId) {
+  var action = 'getDirect';
+  var database = context.database,
+      sessionId = context.userId;
+  var formatUserId = parseId(userId);
+  var aqlQry = aql(_templateObject(), sessionId, formatUserId);
+  return useDb(database).query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  }).then(function () {
+    var conversation = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var _conversation$users = conversation.users,
+        users = _conversation$users === void 0 ? [] : _conversation$users;
+
+    if (users.length) {
+      conversation.users = users.map(function (user) {
+        var userKey = user._key,
+            imgId = user.imgId;
+        var thumbUrlData = {
+          directory: 'images',
+          imgId: imgId,
+          isThumb: true,
+          type: 'users',
+          typeId: userKey
+        };
+        return _objectSpread({}, user, {
+          name: getDisplayName(user),
+          thumb: getUrlImages(thumbUrlData)
+        });
+      });
+    }
+
+    return conversation;
+  }).catch(function (error) {
+    return logError({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(function () {
+      return null;
+    });
+  });
+};
+export var getConversation = function getConversation(context, convoId) {
+  var action = 'getItem';
+  var database = context.database,
+      sessionId = context.userId;
+  var formatConvoId = parseId(convoId);
+  var aqlQry = aql(_templateObject2(), formatConvoId, sessionId);
+  return useDb(database).query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  }).then(function () {
+    var conversation = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    if (!isEmpty(conversation)) {
+      conversation.users = conversation.users.map(function (user) {
+        var userKey = user._key,
+            imgId = user.imgId;
+        var thumbUrlData = {
+          directory: 'images',
+          imgId: imgId,
+          isThumb: true,
+          type: 'users',
+          typeId: userKey
+        };
+        return _objectSpread({}, user, {
+          name: getDisplayName(user),
+          thumb: getUrlImages(thumbUrlData)
+        });
+      });
+      return conversation;
+    }
+
+    return {};
+  }).catch(function (error) {
+    return logError({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(function () {
+      return null;
+    });
+  });
+};
+export var updateConversation = function updateConversation(context, item) {
+  var action = 'update';
+  var database = context.database,
+      sessionId = context.userId;
+
+  var _pick = pick(item, identity),
+      direct = _pick.direct,
+      id = _pick.id,
+      name = _pick.name,
+      users = _pick.users;
+
+  var rcpt = users || [];
+  var formatId = item.id || createHash("convo-".concat(sessionId, "-").concat(rcpt.join('')));
+  var now = Date.now();
+  var update = {
+    // Direct message
+    direct: !!direct ? direct : undefined,
+    modified: now,
+    name: !!name ? name : undefined,
+    // Users
+    users: !!users ? users : undefined
+  };
+
+  var insert = _objectSpread({}, cloneDeep(update), {
+    _key: formatId,
+    added: now
+  });
+
+  var aqlQry = aql(_templateObject3(), id, insert, update);
+  return useDb(database).query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  }).then(function () {
+    var conversation = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return conversation;
+  }).catch(function (error) {
+    return logError({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(function () {
+      return null;
+    });
+  });
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/data/conversations.ts"],"names":["createHash","parseId","aql","cloneDeep","identity","isEmpty","pick","getLimit","useDb","logError","getUrlImages","getDisplayName","eventCategory","getConversationList","context","from","to","action","database","sessionId","userId","limit","aqlQry","query","then","cursor","all","catch","error","category","label","getDirectConversation","formatUserId","next","conversation","users","length","map","user","userKey","_key","imgId","thumbUrlData","directory","isThumb","type","typeId","name","thumb","getConversation","convoId","formatConvoId","updateConversation","item","direct","id","rcpt","formatId","join","now","Date","update","undefined","modified","insert","added"],"mappings":"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","sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {createHash, parseId} from '@nlabs/utils';\nimport {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/lib/cjs/aql-query';\nimport {ArrayCursor} from 'arangojs/lib/cjs/cursor';\nimport cloneDeep from 'lodash/cloneDeep';\nimport identity from 'lodash/identity';\nimport isEmpty from 'lodash/isEmpty';\nimport pick from 'lodash/pick';\nimport {ApiContext} from 'types/auth';\n\nimport {ArangoDBLimit, ConversationType, ImageUrlData, UserType} from '../types';\nimport {getLimit, useDb} from '../utils';\nimport {logError} from '../utils/analytics';\nimport {getUrlImages} from './images';\nimport {getDisplayName} from './users';\n\nconst eventCategory: string = 'conversations';\n\nexport const getConversationList = (context: ApiContext, from: number, to: number): Promise<ConversationType[]> => {\n  const action: string = 'getList';\n  const {database, userId: sessionId} = context;\n  const limit: ArangoDBLimit = getLimit(from, to);\n  const aqlQry: string = `FOR c IN conversations\n    FILTER POSITION(c.users, \"${sessionId}\", false)\n    LET u = (\n      FOR g IN c.users\n      FOR u IN users\n      FILTER g == u._key\n      RETURN {_key:u._key, first:u.first, last:u.last, name:u.name, email:u.email, username:u.username, photo:u.photo }\n    )\n    FILTER LENGTH(u) > 1\n    ${limit.aql}\n    RETURN {_key:c._key, name: c.name, direct: c.direct, users: u}`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const getDirectConversation = (context: ApiContext, userId: string): Promise<ConversationType> => {\n  const action: string = 'getDirect';\n  const {database, userId: sessionId} = context;\n  const formatUserId: string = parseId(userId);\n\n  const aqlQry: AqlQuery = aql`FOR c IN conversations\n    FILTER LENGTH(c.users) == 2 &&\n    POSITION(c.users, ${sessionId}, false) &&\n    POSITION(c.users, ${formatUserId}, false)\n    LET u = (\n      FOR g IN c.users\n      FOR user IN users\n      FILTER user._key == g\n      RETURN user\n    )\n    LIMIT 1\n    RETURN MERGE(c, {users: u})`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((conversation: ConversationType = {}) => {\n      const {users = []} = conversation;\n\n      if(users.length) {\n        conversation.users = users.map((user: UserType) => {\n          const {_key: userKey, imgId} = user;\n          const thumbUrlData: ImageUrlData = {\n            directory: 'images',\n            imgId,\n            isThumb: true,\n            type: 'users',\n            typeId: userKey\n          };\n          return {\n            ...user,\n            name: getDisplayName(user),\n            thumb: getUrlImages(thumbUrlData)\n          };\n        });\n      }\n\n      return conversation;\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const getConversation = (context: ApiContext, convoId: string): Promise<ConversationType> => {\n  const action: string = 'getItem';\n  const {database, userId: sessionId} = context;\n  const formatConvoId: string = parseId(convoId);\n\n  const aqlQry: AqlQuery = aql`FOR c IN conversations\n    FILTER ${formatConvoId} == c._key && IS_LIST(c.users) && POSITION(c.users, ${sessionId}, false)\n    LET u = (\n      FOR g IN c.users\n      FOR u IN users\n      FILTER g == u._key\n      RETURN {_key:u._key, first:u.first, last:u.last, name:u.name, email:u.email, username:u.username, photo:u.photo }\n    )\n    FILTER LENGTH(u) > 1\n    LIMIT 1\n    RETURN MERGE(c, {users: u})`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((conversation: ConversationType = {}) => {\n      if(!isEmpty(conversation)) {\n        conversation.users = conversation.users.map((user: UserType) => {\n          const {_key: userKey, imgId} = user;\n          const thumbUrlData: ImageUrlData = {\n            directory: 'images',\n            imgId,\n            isThumb: true,\n            type: 'users',\n            typeId: userKey\n          };\n          return {\n            ...user,\n            name: getDisplayName(user),\n            thumb: getUrlImages(thumbUrlData)\n          };\n        });\n\n        return conversation;\n      }\n      return {};\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const updateConversation = (context: ApiContext, item): Promise<ConversationType> => {\n  const action: string = 'update';\n  const {database, userId: sessionId} = context;\n  const {direct, id, name, users} = pick(item, identity);\n  const rcpt: UserType[] = users || [];\n  const formatId: string = item.id || createHash(`convo-${sessionId}-${rcpt.join('')}`);\n  const now: number = Date.now();\n  const update: any = {\n    // Direct message\n    direct: !!direct ? direct : undefined,\n    modified: now,\n    name: !!name ? name : undefined,\n    // Users\n    users: !!users ? users : undefined\n  };\n\n  const insert: any = {\n    ...cloneDeep(update),\n    _key: formatId,\n    added: now\n  };\n\n  const aqlQry: AqlQuery = aql`UPSERT {_key: ${id}}\n    INSERT ${insert}\n    UPDATE ${update}\n    IN conversations RETURN NEW`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((conversation: ConversationType = {}) => conversation)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n"]}

package/lib/data/dynamodb.d.ts

@@ -0,0 +1,8 @@
+import { DynamoDB } from 'aws-sdk';
+export declare const dynamoGet: (params: DynamoDB.GetItemInput) => Promise<DynamoDB.GetItemOutput>;
+export declare const dynamoGetList: (params: DynamoDB.QueryInput, index: any) => Promise<DynamoDB.GetItemOutput[]>;
+export declare const dynamoPut: (params: DynamoDB.PutItemInput) => Promise<DynamoDB.PutItemOutput>;
+export declare const dynamoUpdate: (params: DynamoDB.UpdateItemInput) => Promise<DynamoDB.UpdateItemOutput>;
+export declare const dynamoPutList: (params: DynamoDB.BatchWriteItemInput) => Promise<DynamoDB.BatchWriteItemOutput>;
+export declare const dynamoDel: (params: DynamoDB.DeleteItemInput) => Promise<DynamoDB.DeleteItemOutput>;
+export declare const parseDynamo: (results: DynamoDB.QueryOutput) => any[];

package/lib/data/dynamodb.js

@@ -0,0 +1,139 @@
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import aws, { DynamoDB } from 'aws-sdk';
+import { Config } from '../config'; // const eventCategory: string = 'dynamodb';
+
+export var dynamoGet = function dynamoGet(params) {
+  return new Promise(function (resolve, reject) {
+    aws.config.update(Config.get('aws'));
+    var dynamodb = new DynamoDB();
+    params.ConsistentRead = false;
+    dynamodb.getItem(params, function (error, results) {
+      if (error) {
+        return reject(error);
+      }
+
+      return resolve(results);
+    });
+  });
+};
+export var dynamoGetList = function dynamoGetList(params, index) {
+  return new Promise(function (resolve, reject) {
+    aws.config.update(Config.get('aws'));
+    var dynamodb = new DynamoDB();
+    var consistentRead = params.ConsistentRead;
+
+    var updatedParams = _objectSpread({}, params);
+
+    if (index) {
+      updatedParams.ExclusiveStartKey = index;
+    }
+
+    if (!consistentRead) {
+      updatedParams.ConsistentRead = false;
+    }
+
+    dynamodb.query(updatedParams, function (error, output) {
+      if (error) {
+        return reject(error);
+      } // Save list of items
+
+
+      var list = parseDynamo(output);
+      var lastKey = output.LastEvaluatedKey;
+
+      if (lastKey !== undefined) {
+        // Save last index before looping
+        return dynamoGetList(params, lastKey);
+      } // Query complete, return final list
+
+
+      return resolve(list);
+    });
+  });
+};
+export var dynamoPut = function dynamoPut(params) {
+  return new Promise(function (resolve, reject) {
+    aws.config.update(Config.get('aws'));
+    var dynamodb = new DynamoDB();
+    dynamodb.putItem(params, function (error, output) {
+      if (error) {
+        return reject(error);
+      }
+
+      return resolve(output);
+    });
+  });
+};
+export var dynamoUpdate = function dynamoUpdate(params) {
+  return new Promise(function (resolve, reject) {
+    aws.config.update(Config.get('aws'));
+    var dynamodb = new DynamoDB();
+    dynamodb.updateItem(params, function (error, output) {
+      if (error) {
+        return reject(error);
+      }
+
+      return resolve(output);
+    });
+  });
+};
+export var dynamoPutList = function dynamoPutList(params) {
+  return new Promise(function (resolve, reject) {
+    aws.config.update(Config.get('aws'));
+    var dynamodb = new DynamoDB();
+    dynamodb.batchWriteItem(params, function (error, output) {
+      if (error) {
+        return reject(error);
+      }
+
+      return resolve(output);
+    });
+  });
+};
+export var dynamoDel = function dynamoDel(params) {
+  return new Promise(function (resolve, reject) {
+    aws.config.update(Config.get('aws'));
+    var dynamodb = new DynamoDB();
+    dynamodb.deleteItem(params, function (error, output) {
+      if (error) {
+        return reject(error);
+      }
+
+      return resolve(output);
+    });
+  });
+};
+export var parseDynamo = function parseDynamo(results) {
+  var items = results.Items;
+  var data = [];
+
+  for (var idx = 0, len = items.length; idx < len; idx++) {
+    var tmp = items[idx];
+    var obj = {};
+    var key = void 0;
+
+    for (key in tmp) {
+      if (tmp.hasOwnProperty(key)) {
+        if (tmp[key].S) {
+          obj[key] = tmp[key].S.toString();
+        } else if (tmp[key].N) {
+          obj[key] = parseFloat(tmp[key].N);
+        } else {
+          obj[key] = tmp[key].B;
+        }
+      }
+    }
+
+    data.push(obj);
+  }
+
+  return data;
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/data/dynamodb.ts"],"names":["aws","DynamoDB","Config","dynamoGet","params","Promise","resolve","reject","config","update","get","dynamodb","ConsistentRead","getItem","error","results","dynamoGetList","index","consistentRead","updatedParams","ExclusiveStartKey","query","output","list","parseDynamo","lastKey","LastEvaluatedKey","undefined","dynamoPut","putItem","dynamoUpdate","updateItem","dynamoPutList","batchWriteItem","dynamoDel","deleteItem","items","Items","data","idx","len","length","tmp","obj","key","hasOwnProperty","S","toString","N","parseFloat","B","push"],"mappings":"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","sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport aws, {DynamoDB} from 'aws-sdk';\nimport {\n  BatchWriteItemInput,\n  BatchWriteItemOutput,\n  DeleteItemInput,\n  DeleteItemOutput,\n  GetItemInput,\n  GetItemOutput,\n  PutItemInput,\n  PutItemOutput,\n  QueryInput,\n  QueryOutput,\n  UpdateItemInput,\n  UpdateItemOutput\n} from 'aws-sdk/clients/dynamodb';\n\nimport {Config} from '../config';\n\n// const eventCategory: string = 'dynamodb';\n\nexport const dynamoGet = (params: GetItemInput): Promise<GetItemOutput> => {\n  return new Promise((resolve, reject) => {\n    aws.config.update(Config.get('aws'));\n    const dynamodb: DynamoDB = new DynamoDB();\n    params.ConsistentRead = false;\n\n    dynamodb.getItem(params, (error: Error, results: GetItemOutput) => {\n      if(error) {\n        return reject(error);\n      }\n\n      return resolve(results);\n    });\n  });\n};\n\nexport const dynamoGetList = (params: QueryInput, index): Promise<GetItemOutput[]> => {\n  return new Promise((resolve, reject) => {\n    aws.config.update(Config.get('aws'));\n    const dynamodb: DynamoDB = new DynamoDB();\n    const {ConsistentRead: consistentRead} = params;\n    const updatedParams = {...params};\n\n    if(index) {\n      updatedParams.ExclusiveStartKey = index;\n    }\n\n    if(!consistentRead) {\n      updatedParams.ConsistentRead = false;\n    }\n\n    dynamodb.query(updatedParams, (error: Error, output: QueryOutput) => {\n      if(error) {\n        return reject(error);\n      }\n      // Save list of items\n      const list: any[] = parseDynamo(output);\n      const {LastEvaluatedKey: lastKey} = output;\n\n      if(lastKey !== undefined) {\n        // Save last index before looping\n        return dynamoGetList(params, lastKey);\n      }\n\n      // Query complete, return final list\n      return resolve(list);\n    });\n  });\n};\n\nexport const dynamoPut = (params: PutItemInput): Promise<PutItemOutput> => {\n  return new Promise((resolve, reject) => {\n    aws.config.update(Config.get('aws'));\n    const dynamodb: DynamoDB = new DynamoDB();\n\n    dynamodb.putItem(params, (error, output: PutItemOutput) => {\n      if(error) {\n        return reject(error);\n      }\n      return resolve(output);\n    });\n  });\n};\n\nexport const dynamoUpdate = (params: UpdateItemInput): Promise<UpdateItemOutput> => {\n  return new Promise((resolve, reject) => {\n    aws.config.update(Config.get('aws'));\n    const dynamodb: DynamoDB = new DynamoDB();\n\n    dynamodb.updateItem(params, (error: Error, output: UpdateItemOutput) => {\n      if(error) {\n        return reject(error);\n      }\n      return resolve(output);\n    });\n  });\n};\n\nexport const dynamoPutList = (params: BatchWriteItemInput): Promise<BatchWriteItemOutput> => {\n  return new Promise((resolve, reject) => {\n    aws.config.update(Config.get('aws'));\n    const dynamodb: DynamoDB = new DynamoDB();\n\n    dynamodb.batchWriteItem(params, (error: Error, output: BatchWriteItemOutput) => {\n      if(error) {\n        return reject(error);\n      }\n      return resolve(output);\n    });\n  });\n};\n\nexport const dynamoDel = (params: DeleteItemInput): Promise<DeleteItemOutput> => {\n  return new Promise((resolve, reject) => {\n    aws.config.update(Config.get('aws'));\n    const dynamodb: DynamoDB = new DynamoDB();\n\n    dynamodb.deleteItem(params, (error, output: DeleteItemOutput) => {\n      if(error) {\n        return reject(error);\n      }\n      return resolve(output);\n    });\n  });\n};\n\nexport const parseDynamo = (results: QueryOutput): any[] => {\n  const {Items: items} = results;\n  const data: any[] = [];\n\n  for(let idx: number = 0, len = items.length; idx < len; idx++) {\n    const tmp = items[idx];\n    const obj = {};\n    let key;\n\n    for(key in tmp) {\n      if(tmp.hasOwnProperty(key)) {\n        if(tmp[key].S) {\n          obj[key] = tmp[key].S.toString();\n        } else if(tmp[key].N) {\n          obj[key] = parseFloat(tmp[key].N);\n        } else {\n          obj[key] = tmp[key].B;\n        }\n      }\n    }\n\n    data.push(obj);\n  }\n\n  return data;\n};\n\n"]}

package/lib/data/email.d.ts

@@ -0,0 +1,7 @@
+import { SES } from 'aws-sdk';
+import { AppType } from '../types/apps';
+import { EmailType } from '../types/email';
+export declare const appTemplate: (app: AppType, message?: string, vars?: {}) => string;
+export declare const sendEmail: (params: EmailType) => Promise<boolean>;
+export declare const sendTemplate: (templateName: string, emailParams: EmailType) => Promise<boolean>;
+export declare const sesSend: (params: SES.SendEmailRequest) => Promise<SES.SendEmailResponse>;