@nlabs/reaktor 0.1.2 → 0.1.4

package/lib/data/reactions.d.ts

@@ -0,0 +1,6 @@
+import { ApiContext, ReactionType, UserReactionQuery, UserReactionType, UserType } from '../types';
+export declare const addGroupReaction: (context: ApiContext, params?: UserReactionType) => Promise<boolean>;
+export declare const getGroupReactions: (context: ApiContext, params?: UserReactionType) => Promise<UserReactionType>;
+export declare const getReactionsByUser: (context: ApiContext, groupId: string) => Promise<UserReactionType[]>;
+export declare const getUsersByReaction: (context: ApiContext, params?: UserReactionQuery) => Promise<UserType[]>;
+export declare const postReaction: (context: ApiContext, postId: string, type?: string) => Promise<ReactionType>;

package/lib/data/reactions.js

@@ -0,0 +1,218 @@
+function _templateObject4() {
+  var data = _taggedTemplateLiteral(["LET reactions = (\n            FOR post, r IN INBOUND p._id reactions\n            COLLECT reactionName = r.value INTO reactionItems\n            RETURN {id: p._id, type: reactionName, count: LENGTH(reactionItems[*].r.value)}\n          )\n          RETURN reactions"]);
+
+  _templateObject4 = function _templateObject4() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject3() {
+  var data = _taggedTemplateLiteral(["FOR p, r IN INBOUND ", " reaction\n    FILTER r.type == \"posts\" && r._from == ", "\n    REMOVE r IN reactions\n    RETURN r"]);
+
+  _templateObject3 = function _templateObject3() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject2() {
+  var data = _taggedTemplateLiteral(["FOR g, r IN INBOUND ", " hasReaction\n      FILTER r._from == ", "\n      COLLECT reactionName = r.value INTO reactionItems\n      RETURN {value: reactionName, count: LENGTH(reactionItems[*].r.value)}"]);
+
+  _templateObject2 = function _templateObject2() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject() {
+  var data = _taggedTemplateLiteral(["FOR g, r IN INBOUND ", " hasReaction\n      COLLECT reactionName = r.value INTO reactionItems\n      RETURN {value: reactionName, count: LENGTH(reactionItems[*].r.value)}"]);
+
+  _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) } })); }
+
+import { createHash, parseChar, parseId, parseNum } from '@nlabs/utils';
+import { aql } from 'arangojs';
+import { logError, logException, useDb } from '../utils';
+var eventCategory = 'reactions';
+export var addGroupReaction = function addGroupReaction(context) {
+  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var action = 'reaction';
+  var database = context.database,
+      sessionId = context.userId;
+
+  if (!sessionId) {
+    return logException({
+      action: action,
+      category: eventCategory,
+      label: 'unauthorized',
+      value: 'invalid_session'
+    }, context).then(function () {
+      return null;
+    });
+  }
+
+  var itemId = params.id,
+      _params$value = params.value,
+      itemValue = _params$value === void 0 ? 'like' : _params$value;
+  var formatItemId = parseId(itemId);
+  var formatValue = parseChar(itemValue, 32);
+  var edgeCollection = useDb(database).edgeCollection('hasReaction'); // Remove existing likes
+
+  var groupDocId = "groups/".concat(formatItemId);
+  var userDocId = "users/".concat(sessionId);
+  var edgeId = createHash("reaction-".concat(formatItemId, "-").concat(sessionId));
+  var edge = {
+    _key: edgeId,
+    added: Date.now(),
+    type: 'group',
+    value: formatValue
+  };
+  return edgeCollection.save(edge, userDocId, groupDocId).then(function () {
+    return true;
+  });
+};
+export var getGroupReactions = function getGroupReactions(context) {
+  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var action = 'getReactions';
+  var database = context.database;
+  var groupId = params.id;
+  var groupDocId = "groups/".concat(parseId(groupId)); // Query
+
+  var aqlQry = aql(_templateObject(), groupDocId);
+  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 getReactionsByUser = function getReactionsByUser(context, groupId) {
+  var action = 'getReactionsByUser';
+  var database = context.database,
+      sessionId = context.userId;
+  var groupDocId = "groups/".concat(parseId(groupId));
+  var userDocId = "users/".concat(sessionId); // Query
+
+  var aqlQry = aql(_templateObject2(), groupDocId, userDocId);
+  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 getUsersByReaction = function getUsersByReaction(context) {
+  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var action = 'getUsersByReaction';
+  var database = context.database,
+      sessionId = context.userId;
+
+  if (!sessionId) {
+    return logException({
+      action: action,
+      category: eventCategory,
+      label: 'unauthorized',
+      value: 'invalid_session'
+    }, context).then(function () {
+      return null;
+    });
+  }
+
+  var _params$filters = params.filters,
+      filters = _params$filters === void 0 ? [] : _params$filters,
+      groupId = params.id,
+      value = params.value;
+  var reaction = parseChar(value, 32);
+  var groupDocId = "groups/".concat(parseId(groupId));
+  var filterStr = filters.map(function (filter) {
+    var conditional = filter.conditional,
+        name = filter.name,
+        queryValue = filter.value;
+    var filterCond = conditional;
+
+    if (conditional !== '>=' && conditional !== '<=' && conditional !== '>' && conditional !== '<') {
+      filterCond = '==';
+    }
+
+    switch (name) {
+      case 'added':
+        return "r.added ".concat(filterCond, " ").concat(parseNum(queryValue));
+
+      default:
+        return '';
+    }
+  }).concat(["r.value == \"".concat(reaction, "\""), 'u._id == r._from']).join(' && '); // Query
+
+  var aqlQry = "FOR g, r IN INBOUND \"".concat(groupDocId, "\" hasReaction\n      FOR u IN users\n      FILTER  ").concat(filterStr, "\n      RETURN 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 postReaction = function postReaction(context, postId) {
+  var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'like';
+  var database = context.database,
+      sessionId = context.userId;
+  var formatItemId = parseId(postId);
+  var db = useDb(database);
+  var edgeCollection = db.edgeCollection('reactions');
+  var now = Date.now(); // Remove existing reaction to post
+
+  var postDocId = "posts/".concat(formatItemId);
+  var userDocId = "users/".concat(sessionId);
+  var aqlQry = aql(_templateObject3(), postDocId, userDocId);
+  return db.query(aqlQry).then(function () {
+    var edgeId = createHash("reaction-".concat(postId, "-").concat(sessionId));
+    var edge = {
+      _key: edgeId,
+      added: now,
+      type: 'posts',
+      value: type
+    };
+    return edgeCollection.save(edge, userDocId, postDocId).then(function () {
+      var reactionAqlQry = aql(_templateObject4());
+      return db.query(reactionAqlQry).then(function (cursor) {
+        return cursor.next();
+      }).then(function () {
+        var result = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+          reactions: []
+        };
+        return result;
+      }).catch(function (error) {
+        throw error;
+      });
+    }).catch(function (error) {
+      throw error;
+    });
+  }).catch(function (error) {
+    throw error;
+  });
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/data/reactions.ts"],"names":["createHash","parseChar","parseId","parseNum","aql","logError","logException","useDb","eventCategory","addGroupReaction","context","params","action","database","sessionId","userId","category","label","value","then","itemId","id","itemValue","formatItemId","formatValue","edgeCollection","groupDocId","userDocId","edgeId","edge","_key","added","Date","now","type","save","getGroupReactions","groupId","aqlQry","query","cursor","all","catch","error","getReactionsByUser","getUsersByReaction","filters","reaction","filterStr","map","filter","conditional","name","queryValue","filterCond","concat","join","postReaction","postId","db","postDocId","reactionAqlQry","next","result","reactions"],"mappings":"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","sourcesContent":["import {createHash, parseChar, parseId, parseNum} from '@nlabs/utils';\nimport {aql, Database, EdgeCollection} from 'arangojs';\nimport {AqlQuery} from 'arangojs/lib/cjs/aql-query';\nimport {ArrayCursor} from 'arangojs/lib/cjs/cursor';\n\nimport {ApiContext, QueryFilter, ReactionType, UserReactionQuery, UserReactionType, UserType} from '../types';\nimport {logError, logException, useDb} from '../utils';\n\nconst eventCategory: string = 'reactions';\n\nexport const addGroupReaction = (context: ApiContext, params: UserReactionType = {}): Promise<boolean> => {\n  const action: string = 'reaction';\n  const {database, userId: sessionId} = context;\n\n  if(!sessionId) {\n    return logException({\n      action,\n      category: eventCategory,\n      label: 'unauthorized',\n      value: 'invalid_session'\n    }, context).then(() => null);\n  }\n\n  const {id: itemId, value: itemValue = 'like'} = params;\n  const formatItemId: string = parseId(itemId);\n  const formatValue: string = parseChar(itemValue, 32);\n  const edgeCollection = useDb(database).edgeCollection('hasReaction');\n\n  // Remove existing likes\n  const groupDocId: string = `groups/${formatItemId}`;\n  const userDocId: string = `users/${sessionId}`;\n  const edgeId: string = createHash(`reaction-${formatItemId}-${sessionId}`);\n  const edge: any = {\n    _key: edgeId,\n    added: Date.now(),\n    type: 'group',\n    value: formatValue\n  };\n\n  return edgeCollection.save(edge, userDocId, groupDocId).then(() => true);\n};\n\nexport const getGroupReactions = (context: ApiContext, params: UserReactionType = {}): Promise<UserReactionType> => {\n  const action: string = 'getReactions';\n  const {database} = context;\n  const {id: groupId}: UserReactionType = params;\n  const groupDocId: string = `groups/${parseId(groupId)}`;\n\n  // Query\n  const aqlQry: AqlQuery = aql`FOR g, r IN INBOUND ${groupDocId} hasReaction\n      COLLECT reactionName = r.value INTO reactionItems\n      RETURN {value: reactionName, count: LENGTH(reactionItems[*].r.value)}`;\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 getReactionsByUser = (context: ApiContext, groupId: string): Promise<UserReactionType[]> => {\n  const action: string = 'getReactionsByUser';\n  const {database, userId: sessionId} = context;\n  const groupDocId: string = `groups/${parseId(groupId)}`;\n  const userDocId: string = `users/${sessionId}`;\n\n  // Query\n  const aqlQry: AqlQuery = aql`FOR g, r IN INBOUND ${groupDocId} hasReaction\n      FILTER r._from == ${userDocId}\n      COLLECT reactionName = r.value INTO reactionItems\n      RETURN {value: reactionName, count: LENGTH(reactionItems[*].r.value)}`;\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 getUsersByReaction = (context: ApiContext, params: UserReactionQuery = {}): Promise<UserType[]> => {\n  const action: string = 'getUsersByReaction';\n  const {database, userId: sessionId} = context;\n\n  if(!sessionId) {\n    return logException({\n      action,\n      category: eventCategory,\n      label: 'unauthorized',\n      value: 'invalid_session'\n    }, context).then(() => null);\n  }\n\n  const {filters = [], id: groupId, value}: UserReactionQuery = params;\n  const reaction = parseChar(value, 32);\n  const groupDocId = `groups/${parseId(groupId)}`;\n  const filterStr: string = filters\n    .map((filter: QueryFilter) => {\n      const {conditional, name, value: queryValue}: QueryFilter = filter;\n      let filterCond: string = conditional;\n\n      if(conditional !== '>=' && conditional !== '<=' && conditional !== '>' && conditional !== '<') {\n        filterCond = '==';\n      }\n\n      switch(name) {\n        case 'added':\n          return `r.added ${filterCond} ${parseNum(queryValue)}`;\n        default:\n          return '';\n      }\n    })\n    .concat([\n      `r.value == \"${reaction}\"`,\n      'u._id == r._from'\n    ])\n    .join(' && ');\n\n  // Query\n  const aqlQry: string = `FOR g, r IN INBOUND \"${groupDocId}\" hasReaction\n      FOR u IN users\n      FILTER  ${filterStr}\n      RETURN 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\n\nexport const postReaction = (context: ApiContext, postId: string, type: string = 'like'): Promise<ReactionType> => {\n  const {database, userId: sessionId} = context;\n  const formatItemId: string = parseId(postId);\n  const db: Database = useDb(database);\n  const edgeCollection: EdgeCollection = db.edgeCollection('reactions');\n  const now: number = Date.now();\n\n  // Remove existing reaction to post\n  const postDocId: string = `posts/${formatItemId}`;\n  const userDocId: string = `users/${sessionId}`;\n  const aqlQry: AqlQuery = aql`FOR p, r IN INBOUND ${postDocId} reaction\n    FILTER r.type == \"posts\" && r._from == ${userDocId}\n    REMOVE r IN reactions\n    RETURN r`;\n\n  return db.query(aqlQry)\n    .then(() => {\n      const edgeId = createHash(`reaction-${postId}-${sessionId}`);\n      const edge: any = {\n        _key: edgeId,\n        added: now,\n        type: 'posts',\n        value: type\n      };\n\n      return edgeCollection.save(edge, userDocId, postDocId)\n        .then(() => {\n          const reactionAqlQry: AqlQuery = aql`LET reactions = (\n            FOR post, r IN INBOUND p._id reactions\n            COLLECT reactionName = r.value INTO reactionItems\n            RETURN {id: p._id, type: reactionName, count: LENGTH(reactionItems[*].r.value)}\n          )\n          RETURN reactions`;\n\n          return db.query(reactionAqlQry)\n            .then((cursor: ArrayCursor) => cursor.next())\n            .then((result = {reactions: []}) => result)\n            .catch((error: Error) => {\n              throw error;\n            });\n        })\n        .catch((error: Error) => {\n          throw error;\n        });\n    })\n    .catch((error: Error) => {\n      throw error;\n    });\n};"]}

package/lib/data/s3.d.ts

@@ -0,0 +1,6 @@
+import { S3 } from 'aws-sdk';
+export declare const s3Get: (params: S3.GetObjectRequest) => Promise<S3.GetObjectOutput>;
+export declare const s3Head: (params: S3.HeadObjectRequest) => Promise<S3.HeadObjectOutput>;
+export declare const s3Put: (params: S3.PutObjectRequest) => Promise<S3.PutObjectOutput>;
+export declare const s3Delete: (params: S3.DeleteObjectRequest) => Promise<S3.DeleteObjectOutput>;
+export declare const s3DeleteList: (params: S3.DeleteObjectsRequest) => Promise<S3.DeleteObjectsOutput>;

package/lib/data/s3.js

@@ -0,0 +1,103 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import aws, { S3 } from 'aws-sdk';
+import { Config } from '../config'; // AWS S3
+// const eventCategory: string = 's3';
+
+export var s3Get = function s3Get(params) {
+  return new Promise(function (resolve, reject) {
+    aws.config.update(Config.get('aws'));
+    var s3 = new S3();
+
+    if (!params.Bucket) {
+      params.Bucket = Config.get('aws.Bucket');
+    }
+
+    s3.getObject(params, function (error, output) {
+      if (error) {
+        return reject(error);
+      }
+
+      return resolve(output);
+    });
+  });
+};
+export var s3Head = function s3Head(params) {
+  return new Promise(function (resolve, reject) {
+    aws.config.update(Config.get('aws'));
+    var s3 = new S3();
+
+    if (!params.Bucket) {
+      params.Bucket = Config.get('aws.Bucket');
+    }
+
+    s3.headObject(params, function (error, output) {
+      if (error) {
+        return reject(error);
+      }
+
+      return resolve(output);
+    });
+  });
+};
+export var s3Put = function s3Put(params) {
+  return new Promise(function (resolve, reject) {
+    aws.config.update(Config.get('aws'));
+    var s3 = new aws.S3();
+
+    if (!params.Bucket) {
+      params.Bucket = Config.get('aws.Bucket');
+    }
+
+    if (!params.StorageClass) {
+      params.StorageClass = 'REDUCED_REDUNDANCY';
+    }
+
+    s3.putObject(params, function (error, output) {
+      if (error) {
+        return reject(error);
+      }
+
+      return resolve(output);
+    });
+  });
+};
+export var s3Delete = function s3Delete(params) {
+  return new Promise(function (resolve, reject) {
+    aws.config.update(Config.get('aws'));
+    var s3 = new S3();
+
+    if (!params.Bucket) {
+      params.Bucket = Config.get('aws.Bucket');
+    }
+
+    s3.deleteObject(params, function (error, output) {
+      if (error) {
+        return reject(error);
+      }
+
+      return resolve(output);
+    });
+  });
+};
+export var s3DeleteList = function s3DeleteList(params) {
+  return new Promise(function (resolve, reject) {
+    aws.config.update(Config.get('aws'));
+    var s3 = new S3();
+
+    if (!params.Bucket) {
+      params.Bucket = Config.get('aws.Bucket');
+    }
+
+    s3.deleteObjects(params, function (error, output) {
+      if (error) {
+        return reject(error);
+      }
+
+      return resolve(output);
+    });
+  });
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/data/s3.ts"],"names":["aws","S3","Config","s3Get","params","Promise","resolve","reject","config","update","get","s3","Bucket","getObject","error","output","s3Head","headObject","s3Put","StorageClass","putObject","s3Delete","deleteObject","s3DeleteList","deleteObjects"],"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, {S3} from 'aws-sdk';\nimport {\n  DeleteObjectOutput,\n  DeleteObjectRequest,\n  DeleteObjectsOutput,\n  DeleteObjectsRequest,\n  GetObjectOutput,\n  GetObjectRequest,\n  HeadObjectOutput,\n  HeadObjectRequest,\n  PutObjectOutput,\n  PutObjectRequest\n} from 'aws-sdk/clients/s3';\n\nimport {Config} from '../config';\n\n// AWS S3\n// const eventCategory: string = 's3';\n\nexport const s3Get = (params: GetObjectRequest): Promise<GetObjectOutput> => {\n  return new Promise((resolve, reject) => {\n    aws.config.update(Config.get('aws'));\n    const s3: S3 = new S3();\n\n    if(!params.Bucket) {\n      params.Bucket = Config.get('aws.Bucket');\n    }\n\n    s3.getObject(params, (error: Error, output: GetObjectOutput) => {\n      if(error) {\n        return reject(error);\n      }\n\n      return resolve(output);\n    });\n  });\n};\n\nexport const s3Head = (params: HeadObjectRequest): Promise<HeadObjectOutput> => {\n  return new Promise((resolve, reject) => {\n    aws.config.update(Config.get('aws'));\n    const s3: S3 = new S3();\n\n    if(!params.Bucket) {\n      params.Bucket = Config.get('aws.Bucket');\n    }\n\n    s3.headObject(params, (error: Error, output: HeadObjectOutput) => {\n      if(error) {\n        return reject(error);\n      }\n      return resolve(output);\n    });\n  });\n};\n\nexport const s3Put = (params: PutObjectRequest): Promise<PutObjectOutput> => {\n  return new Promise((resolve, reject) => {\n    aws.config.update(Config.get('aws'));\n    const s3 = new aws.S3();\n\n    if(!params.Bucket) {\n      params.Bucket = Config.get('aws.Bucket');\n    }\n\n    if(!params.StorageClass) {\n      params.StorageClass = 'REDUCED_REDUNDANCY';\n    }\n\n    s3.putObject(params, (error: Error, output: PutObjectOutput) => {\n      if(error) {\n        return reject(error);\n      }\n      return resolve(output);\n    });\n  });\n};\n\nexport const s3Delete = (params: DeleteObjectRequest): Promise<DeleteObjectOutput> => {\n  return new Promise((resolve, reject) => {\n    aws.config.update(Config.get('aws'));\n    const s3: S3 = new S3();\n\n    if(!params.Bucket) {\n      params.Bucket = Config.get('aws.Bucket');\n    }\n\n    s3.deleteObject(params, (error, output: DeleteObjectOutput) => {\n      if(error) {\n        return reject(error);\n      }\n      return resolve(output);\n    });\n  });\n};\n\nexport const s3DeleteList = (params: DeleteObjectsRequest): Promise<DeleteObjectsOutput> => {\n  return new Promise((resolve, reject) => {\n    aws.config.update(Config.get('aws'));\n    const s3: S3 = new S3();\n\n    if(!params.Bucket) {\n      params.Bucket = Config.get('aws.Bucket');\n    }\n\n    s3.deleteObjects(params, (error: Error, output: DeleteObjectsOutput) => {\n      if(error) {\n        return reject(error);\n      }\n      return resolve(output);\n    });\n  });\n};\n"]}

package/lib/data/search.d.ts

@@ -0,0 +1,3 @@
+import { ApiContext } from '../types/auth';
+import { UserType } from '../types/users';
+export declare const getSearchList: (context: ApiContext, query: string, from: number, to: number) => Promise<UserType[]>;

package/lib/data/search.js

@@ -0,0 +1,98 @@
+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 u IN FULLTEXT(", ", ", ", ", ", 50) RETURN 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 { aql } from 'arangojs';
+import flatten from 'lodash/flatten';
+import uniqBy from 'lodash/uniqBy';
+import { getLimit, logException, useDb } from '../utils';
+import { getDisplayName } from './users';
+var eventCategory = 'search';
+export var getSearchList = function getSearchList(context, query, from, to) {
+  var action = 'getList';
+  var database = context.database;
+  var isString = true;
+
+  if (isString) {
+    var fields = [{
+      collection: 'users',
+      field: 'first'
+    }, {
+      collection: 'users',
+      field: 'last'
+    }, {
+      collection: 'users',
+      field: 'email'
+    }, {
+      collection: 'users',
+      field: 'username'
+    }, {
+      collection: 'users',
+      field: 'name'
+    }];
+    return Promise.all(fields.map(function (obj) {
+      var qry = "prefix:".concat(query);
+      var userQry = aql(_templateObject(), obj.collection, obj.field, qry);
+      return useDb(database).query(userQry).then(function (cursor) {
+        return cursor.all();
+      });
+    })).then(function (results) {
+      var list = uniqBy(flatten(results), '_key');
+      return list.map(function (item) {
+        var itemId = item._id,
+            itemName = item.name;
+        var collectionIdList = itemId.split('/');
+        var collection = collectionIdList[0];
+        var name = collection === 'users' ? getDisplayName(item) : itemName;
+        return _objectSpread({}, item, {
+          name: name
+        });
+      });
+    });
+  }
+
+  var limit = getLimit(from, to);
+  var aqlQry = "FOR u IN users\n        FILTER u.phone == \"".concat(query, "\"\n        ").concat(limit.aql, "\n        RETURN u");
+  return useDb(database).query(aqlQry).then(function (cursor) {
+    return cursor.all();
+  }).then(function () {
+    var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    return list.map(function () {
+      var item = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var itemId = item._id,
+          itemName = item.name;
+      var collectionIdList = itemId.split('/');
+      var collection = collectionIdList[0];
+      var name = collection === 'users' ? getDisplayName(item) : itemName;
+      return _objectSpread({}, item, {
+        name: name
+      });
+    });
+  }).catch(function (error) {
+    return logException({
+      action: action,
+      category: eventCategory,
+      label: 'db_error',
+      value: error.message
+    }, context).then(function () {
+      return null;
+    });
+  });
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/data/sms.d.ts

@@ -0,0 +1,3 @@
+import { SMSParamsType } from '../types/notifications';
+export declare const sendSms: (params: SMSParamsType) => any;
+export declare const sendSmsTemplate: (templateName: string, smsParams: SMSParamsType) => Promise<boolean>;

package/lib/data/sms.js

@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import { parsePhone } from '@nlabs/utils';
+import fs from 'fs';
+import twilioSdk from 'twilio';
+import { Config } from '../config';
+import { appTemplate } from './email'; // const eventCategory: string = 'sms';
+// Twilio
+
+export var sendSms = function sendSms(params) {
+  var _params$app = params.app,
+      app = _params$app === void 0 ? {} : _params$app,
+      content = params.content,
+      _params$user = params.user,
+      user = _params$user === void 0 ? {} : _params$user;
+  var country = user.country || 'US';
+  var phone = parsePhone(user.phone, country);
+  var templateContent = appTemplate(app, content);
+  var twilio = twilioSdk(Config.get('twilio.sid'), Config.get('twilio.token'));
+  var cfg = {
+    body: templateContent,
+    from: Config.get('twilio.number'),
+    to: phone
+  };
+  return new Promise(function (resolve, reject) {
+    twilio.sendMessage(cfg, function (error, data) {
+      if (error) {
+        reject(new Error(error.error_message));
+      } else {
+        resolve(data);
+      }
+    });
+  });
+};
+export var sendSmsTemplate = function sendSmsTemplate(templateName, smsParams) {
+  var app = smsParams.app,
+      user = smsParams.user,
+      vars = smsParams.vars;
+
+  try {
+    var data = fs.readFileSync("./templates/sms/".concat(templateName, ".txt"), 'utf8');
+    var text = appTemplate(app, data, vars);
+    var params = {
+      app: app,
+      text: text,
+      user: user
+    };
+    return sendSms(params).then(function (res) {
+      return res.status === 'queued';
+    }).catch(function (error) {
+      throw error;
+    });
+  } catch (error) {
+    return Promise.reject(error);
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/data/subscription.d.ts

@@ -0,0 +1,7 @@
+import { ApiContext } from '../types/auth';
+import { PaymentPlan, PaymentSubscription } from '../types/payments';
+export declare const getPlanList: (context: ApiContext, from?: number, to?: number) => Promise<PaymentPlan[]>;
+export declare const getSubscription: (context: ApiContext) => Promise<PaymentSubscription>;
+export declare const addPlan: (context: ApiContext, item: PaymentPlan) => Promise<PaymentPlan>;
+export declare const addSubscription: (context: ApiContext, item: any) => Promise<PaymentSubscription>;
+export declare const deleteSubscription: (context: ApiContext, endDate: number) => Promise<boolean>;