@nlabs/reaktor 0.1.0

package/lib/data/conversations.js

@@ -0,0 +1,201 @@
+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 sessionApp = context.appId,
+      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 = {
+          appId: sessionApp,
+          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 sessionApp = context.appId,
+      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 = {
+          appId: sessionApp,
+          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","sessionApp","appId","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 {appId: sessionApp, 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            appId: sessionApp,\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 {appId: sessionApp, 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            appId: sessionApp,\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>;

package/lib/data/email.js

@@ -0,0 +1,164 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import aws, { SES } from 'aws-sdk';
+import fs from 'fs';
+import isEmpty from 'lodash/isEmpty';
+import { Config } from '../config';
+import { s3Get } from './s3'; // const eventCategory: string = 'email';
+
+export var appTemplate = function appTemplate(app) {
+  var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  var vars = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var updatedMessage = '';
+
+  if (!isEmpty(app)) {
+    updatedMessage = message.replace(/\[appName\]/g, app.name).replace(/\[appUrl\]/g, app.url).replace(/\[appEmail\]/g, app.email).replace(/\[appId\]/g, app.id);
+  }
+
+  Object.keys(vars).forEach(function (key) {
+    if (vars[key]) {
+      updatedMessage = message.replace(new RegExp("\\[".concat(key, "\\]"), 'g'), vars[key]);
+    }
+  });
+  return updatedMessage;
+};
+export var sendEmail = function sendEmail(params) {
+  var _params$app = params.app,
+      app = _params$app === void 0 ? {} : _params$app,
+      html = params.html,
+      subject = params.subject,
+      _params$subTitle = params.subTitle,
+      subTitle = _params$subTitle === void 0 ? '' : _params$subTitle,
+      text = params.text,
+      _params$title = params.title,
+      title = _params$title === void 0 ? '' : _params$title,
+      _params$user = params.user,
+      user = _params$user === void 0 ? {} : _params$user;
+  var to = [user.email];
+  var promise;
+  var formatSubject = appTemplate(app, subject);
+  var formatSubTitle = appTemplate(app, subTitle);
+  var formatTitle = appTemplate(app, title);
+  var formatText = appTemplate(app, text);
+  var formatHtml = appTemplate(app, html);
+  var appId = app._key,
+      hasCustomEmail = app.hasCustomEmail,
+      urlFacebook = app.urlFacebook,
+      urlTwitter = app.urlTwitter;
+
+  var parseTemplate = function parseTemplate(body) {
+    var templateBody = appTemplate(app, body || ''); // Links
+
+    var links = '';
+    var spacer = '<td width="5"><img width="1" height="1" border="0" title="" alt="" ' + 'src="https://box.reaktor.io/images/email/spacer.gif"/></td>';
+
+    if (urlFacebook) {
+      links = "<td width=\"30\"><a href=\"".concat(urlFacebook, "\"><img width=\"30\" height=\"30\" border=\"0\" ") + 'title="Facebook" alt="Facebook" src="https://box.reaktor.io/images/email/icon-facebook.png"/></a></td>';
+    }
+
+    if (urlTwitter) {
+      if (urlFacebook) {
+        links += spacer;
+      }
+
+      links += "<td width=\"30\"><a href=\"".concat(urlTwitter, "\"><img width=\"30\" height=\"30\" border=\"0\" ") + 'title="Twitter" alt="Twitter" src="https://box.reaktor.io/images/email/icon-twitter.png"/></a></td>';
+    }
+
+    if (!links.length) {
+      links += spacer;
+    }
+
+    return templateBody.replace(/\[title\]/g, formatTitle).replace(/\[subTitle\]/g, formatSubTitle).replace(/\[subject\]/g, formatSubject).replace(/\[message\]/g, formatHtml).replace(/\[links\]/g, links);
+  };
+
+  if (hasCustomEmail) {
+    var s3Params = {
+      Bucket: null,
+      Key: "apps/".concat(appId, "/templates/email.html")
+    };
+    promise = s3Get(s3Params).then(function (results) {
+      return parseTemplate(results.Body.toString());
+    });
+  } else {
+    promise = new Promise(function (resolve, reject) {
+      fs.readFile('./templates/email/layout.html', 'utf8', function (err, data) {
+        if (err) {
+          return reject(err);
+        }
+
+        return resolve(parseTemplate(data));
+      });
+    });
+  }
+
+  return promise.then(function (parsedHtml) {
+    var emailParams = {
+      Destination: {
+        ToAddresses: to
+      },
+      Message: {
+        Body: {
+          Html: {
+            Data: parsedHtml
+          },
+          Text: {
+            Data: formatText
+          }
+        },
+        Subject: {
+          Data: formatSubject
+        }
+      },
+      Source: "\"".concat(app.supportName, "\" <noreply@").concat(Config.get('app.url'), ">")
+    };
+    return sesSend(emailParams);
+  });
+};
+export var sendTemplate = function sendTemplate(templateName, emailParams) {
+  var app = emailParams.app,
+      user = emailParams.user,
+      subject = emailParams.subject,
+      subTitle = emailParams.subTitle,
+      title = emailParams.title,
+      vars = emailParams.vars;
+
+  try {
+    var html = fs.readFileSync("./templates/email/".concat(templateName, ".html"), 'utf8');
+    var templateHtml = appTemplate(app, html, vars);
+    var text = fs.readFileSync("./templates/sms/".concat(templateName, ".txt"), 'utf8');
+    var templateText = appTemplate(app, text, vars);
+    var params = {
+      app: app,
+      html: templateHtml,
+      subTitle: subTitle,
+      subject: subject,
+      text: templateText,
+      title: title,
+      user: user
+    };
+    return sendEmail(params).then(function () {
+      return true;
+    }).catch(function () {
+      return false;
+    });
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}; // AWS::SES
+
+export var sesSend = function sesSend(params) {
+  return new Promise(function (resolve, reject) {
+    aws.config.update(Config.get('aws'));
+    var ses = new SES();
+    ses.sendEmail(params, function (error, response) {
+      if (error) {
+        return reject(error);
+      }
+
+      return resolve(response);
+    });
+  });
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/data/email.ts"],"names":["aws","SES","fs","isEmpty","Config","s3Get","appTemplate","app","message","vars","updatedMessage","replace","name","url","email","id","Object","keys","forEach","key","RegExp","sendEmail","params","html","subject","subTitle","text","title","user","to","promise","formatSubject","formatSubTitle","formatTitle","formatText","formatHtml","appId","_key","hasCustomEmail","urlFacebook","urlTwitter","parseTemplate","body","templateBody","links","spacer","length","s3Params","Bucket","Key","then","results","Body","toString","Promise","resolve","reject","readFile","err","data","parsedHtml","emailParams","Destination","ToAddresses","Message","Html","Data","Text","Subject","Source","supportName","get","sesSend","sendTemplate","templateName","readFileSync","templateHtml","templateText","catch","error","config","update","ses","response"],"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, {SES} from 'aws-sdk';\nimport {GetObjectRequest} from 'aws-sdk/clients/s3';\nimport {SendEmailRequest, SendEmailResponse} from 'aws-sdk/clients/ses';\nimport fs from 'fs';\nimport isEmpty from 'lodash/isEmpty';\n\nimport {Config} from '../config';\nimport {AppType} from '../types/apps';\nimport {EmailType} from '../types/email';\nimport {s3Get} from './s3';\n\n// const eventCategory: string = 'email';\n\nexport const appTemplate = (app: AppType, message: string = '', vars = {}): string => {\n  let updatedMessage: string = '';\n\n  if(!isEmpty(app)) {\n    updatedMessage = message.replace(/\\[appName\\]/g, app.name)\n      .replace(/\\[appUrl\\]/g, app.url)\n      .replace(/\\[appEmail\\]/g, app.email)\n      .replace(/\\[appId\\]/g, app.id);\n  }\n\n  Object.keys(vars).forEach((key: string) => {\n    if(vars[key]) {\n      updatedMessage = message.replace(new RegExp(`\\\\[${key}\\\\]`, 'g'), vars[key]);\n    }\n  });\n\n  return updatedMessage;\n};\n\nexport const sendEmail = (params: EmailType): Promise<boolean> => {\n  const {\n    app = {},\n    html,\n    subject,\n    subTitle = '',\n    text,\n    title = '',\n    user = {}\n  } = params;\n\n  const to = [user.email];\n  let promise;\n\n  const formatSubject: string = appTemplate(app, subject);\n  const formatSubTitle: string = appTemplate(app, subTitle);\n  const formatTitle: string = appTemplate(app, title);\n  const formatText: string = appTemplate(app, text);\n  const formatHtml: string = appTemplate(app, html);\n  const {_key: appId, hasCustomEmail, urlFacebook, urlTwitter} = app;\n\n  const parseTemplate = (body: string) => {\n    const templateBody: string = appTemplate(app, body || '');\n\n    // Links\n    let links: string = '';\n    const spacer = '<td width=\"5\"><img width=\"1\" height=\"1\" border=\"0\" title=\"\" alt=\"\" ' +\n      'src=\"https://box.reaktor.io/images/email/spacer.gif\"/></td>';\n\n    if(urlFacebook) {\n      links = `<td width=\"30\"><a href=\"${urlFacebook}\"><img width=\"30\" height=\"30\" border=\"0\" ` +\n        'title=\"Facebook\" alt=\"Facebook\" src=\"https://box.reaktor.io/images/email/icon-facebook.png\"/></a></td>';\n    }\n\n    if(urlTwitter) {\n      if(urlFacebook) {\n        links += spacer;\n      }\n\n      links += `<td width=\"30\"><a href=\"${urlTwitter}\"><img width=\"30\" height=\"30\" border=\"0\" ` +\n        'title=\"Twitter\" alt=\"Twitter\" src=\"https://box.reaktor.io/images/email/icon-twitter.png\"/></a></td>';\n    }\n\n    if(!links.length) {\n      links += spacer;\n    }\n\n    return templateBody.replace(/\\[title\\]/g, formatTitle)\n      .replace(/\\[subTitle\\]/g, formatSubTitle)\n      .replace(/\\[subject\\]/g, formatSubject)\n      .replace(/\\[message\\]/g, formatHtml)\n      .replace(/\\[links\\]/g, links);\n  };\n\n  if(hasCustomEmail) {\n    const s3Params: GetObjectRequest = {Bucket: null, Key: `apps/${appId}/templates/email.html`};\n    promise = s3Get(s3Params).then((results) => parseTemplate(results.Body.toString()));\n  } else {\n    promise = new Promise((resolve, reject) => {\n      fs.readFile('./templates/email/layout.html', 'utf8', (err, data) => {\n        if(err) {\n          return reject(err);\n        }\n\n        return resolve(parseTemplate(data));\n      });\n    });\n  }\n\n  return promise.then((parsedHtml: string) => {\n    const emailParams: SendEmailRequest = {\n      Destination: {ToAddresses: to},\n      Message: {\n        Body: {\n          Html: {Data: parsedHtml},\n          Text: {Data: formatText}\n        },\n        Subject: {Data: formatSubject}\n      },\n      Source: `\"${app.supportName}\" <noreply@${Config.get('app.url')}>`\n    };\n\n    return sesSend(emailParams);\n  });\n};\n\nexport const sendTemplate = (templateName: string, emailParams: EmailType): Promise<boolean> => {\n  const {app, user, subject, subTitle, title, vars}: EmailType = emailParams;\n\n  try {\n    const html: string = fs.readFileSync(`./templates/email/${templateName}.html`, 'utf8');\n    const templateHtml: string = appTemplate(app, html, vars);\n    const text: string = fs.readFileSync(`./templates/sms/${templateName}.txt`, 'utf8');\n    const templateText: string = appTemplate(app, text, vars);\n\n    const params = {\n      app,\n      html: templateHtml,\n      subTitle,\n      subject,\n      text: templateText,\n      title,\n      user\n    };\n\n    return sendEmail(params)\n      .then(() => true)\n      .catch(() => false);\n  } catch(error) {\n    return Promise.reject(error);\n  }\n};\n\n// AWS::SES\nexport const sesSend = (params: SendEmailRequest): Promise<SendEmailResponse> => {\n  return new Promise((resolve, reject) => {\n    aws.config.update(Config.get('aws'));\n    const ses: SES = new SES();\n\n    ses.sendEmail(params, (error: Error, response: SendEmailResponse) => {\n      if(error) {\n        return reject(error);\n      }\n\n      return resolve(response);\n    });\n  });\n};\n"]}

package/lib/data/files.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { Database } from 'arangojs';
+import { ApiContext } from 'types/auth';
+import { FileType } from '../types/files';
+export declare const addFile: (context: ApiContext, item?: FileType) => Promise<FileType>;
+export declare const getGiphyTrends: (context: ApiContext, limit?: number) => Promise<any[]>;
+export declare const getGiphySearch: (context: ApiContext, query: string, limit?: number) => Promise<any[]>;
+export declare const getYouTubeTrends: (context: ApiContext, limit?: number) => Promise<any[]>;
+export declare const getYouTubeSearch: (context: ApiContext, query: string, limit?: number) => Promise<any[]>;
+export declare const getPathUserFiles: (userId: string, filename: string) => string;
+export declare const getUrlUserFiles: (userId: string, filename: string, dir?: string, type?: string) => string;
+export declare const linkFiles: (db: Database, files: FileType[], postId: string) => Promise<any>;
+export declare const updateFiles: (db: Database, postId: string, files: FileType[]) => Promise<any>;
+export declare const createFile: (db: Database, file: FileType) => Promise<FileType>;
+export declare const encodeBase64: (buffer: Buffer) => string;
+export declare const decodeBase64: (dataString: string) => object;