@nlabs/reaktor 0.1.0

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@nlabs/reaktor",
+  "version": "0.1.0",
+  "description": "Reaktor",
+  "main": "./index.js",
+  "types": "./lib/index.d.js",
+  "keywords": [
+    "reaktor",
+    "nitrogenlabs",
+    "react",
+    "arkhamjs",
+    "graphql"
+  ],
+  "author": {
+    "name": "Giraldo Rosales",
+    "email": "giraldo@nitrogenlabs.com",
+    "url": "http://nitrogenlabs.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nitrogenlabs/reaktor-api"
+  },
+  "homepage": "https://github.com/nitrogenlabs/reaktor-api",
+  "bugs": {
+    "url": "https://github.com/nitrogenlabs/reaktor-api/issues"
+  },
+  "scripts": {
+    "build": "lex compile -r",
+    "clean": "lex clean",
+    "lint": "eslint ./src --ext .ts,.tsx",
+    "pretest": "stage=test npm run lint",
+    "test": "stage=test jest",
+    "update": "lex update -i"
+  },
+  "dependencies": {
+    "@nlabs/arkhamjs": "^3.11.11",
+    "@nlabs/rip-hunter": "^2.0.0",
+    "@nlabs/utils": "^1.2.0",
+    "apn": "^2.2.0",
+    "arangojs": "^6.0.0",
+    "aws-sdk": "^2.411.0",
+    "gm": "^1.23.1",
+    "google-libphonenumber": "^3.0.10",
+    "googleapis": "^37.2.0",
+    "graphql": "^14.0.2",
+    "graphql-errors": "^2.1.0",
+    "graphql-fields": "^2.0.1",
+    "hiredis": "^0.5.0",
+    "lodash": "^4.17.4",
+    "luxon": "^1.3.3",
+    "node-yelp": "0.0.3",
+    "numeral": "^2.0.6",
+    "redis": "^2.8.0",
+    "request-promise": "^4.2.2",
+    "stripe": "^6.12.1",
+    "to": "^0.2.9",
+    "twilio": "^3.11.0",
+    "typed-promisify": "^0.4.0",
+    "universal-analytics": "^0.4.16",
+    "update": "^0.7.4"
+  },
+  "devDependencies": {
+    "@types/graphql": "^14.0.1",
+    "@types/history": "^4.6.2",
+    "@types/jest": "^24.0.9",
+    "@types/luxon": "^1.11.0",
+    "@types/node": "^11.9.4",
+    "@types/twilio": "^0.0.10",
+    "eslint": "^5.13.0",
+    "eslint-config-styleguidejs": "^1.0.3",
+    "graphql-tools": "^4.0.0",
+    "source-map-loader": "^0.2.4",
+    "typescript": "^3.0.3"
+  }
+}

package/src/config.ts

@@ -0,0 +1,121 @@
+/**
+ * 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';
+
+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;
+}
+
+const appPackage: any = require('../package.json');
+
+const {arangodbDatabase, arangodbPassword, arangodbPort = '8529', arangodbUrl, arangodbUsername} = process.env;
+
+export class Config {
+  static values: EnvConfig = {
+    default: {
+      app: {
+        name: 'reaktor',
+        url: 'reaktor.io',
+        version: appPackage.version
+      },
+      arangodb: {
+        apiUrl: `http://${arangodbUsername}:${arangodbPassword}@${arangodbUrl}:${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: {
+    }
+  };
+
+  static get(path: string | string[]): any {
+    const environment: string = process.env.stage || 'development';
+    const configValues: object = merge(this.values.default, this.values[environment], {environment});
+    return get(configValues, path);
+  }
+}

package/src/data/conversations.ts

@@ -0,0 +1,183 @@
+/**
+ * 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 {AqlQuery} from 'arangojs/lib/cjs/aql-query';
+import {ArrayCursor} from 'arangojs/lib/cjs/cursor';
+import cloneDeep from 'lodash/cloneDeep';
+import identity from 'lodash/identity';
+import isEmpty from 'lodash/isEmpty';
+import pick from 'lodash/pick';
+import {ApiContext} from 'types/auth';
+
+import {ArangoDBLimit, ConversationType, ImageUrlData, UserType} from '../types';
+import {getLimit, useDb} from '../utils';
+import {logError} from '../utils/analytics';
+import {getUrlImages} from './images';
+import {getDisplayName} from './users';
+
+const eventCategory: string = 'conversations';
+
+export const getConversationList = (context: ApiContext, from: number, to: number): Promise<ConversationType[]> => {
+  const action: string = 'getList';
+  const {database, userId: sessionId} = context;
+  const limit: ArangoDBLimit = getLimit(from, to);
+  const aqlQry: string = `FOR c IN conversations
+    FILTER POSITION(c.users, "${sessionId}", false)
+    LET u = (
+      FOR g IN c.users
+      FOR u IN users
+      FILTER g == u._key
+      RETURN {_key:u._key, first:u.first, last:u.last, name:u.name, email:u.email, username:u.username, photo:u.photo }
+    )
+    FILTER LENGTH(u) > 1
+    ${limit.aql}
+    RETURN {_key:c._key, name: c.name, direct: c.direct, users: u}`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.all())
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(() => null));
+};
+
+export const getDirectConversation = (context: ApiContext, userId: string): Promise<ConversationType> => {
+  const action: string = 'getDirect';
+  const {appId: sessionApp, database, userId: sessionId} = context;
+  const formatUserId: string = parseId(userId);
+
+  const aqlQry: AqlQuery = aql`FOR c IN conversations
+    FILTER LENGTH(c.users) == 2 &&
+    POSITION(c.users, ${sessionId}, false) &&
+    POSITION(c.users, ${formatUserId}, false)
+    LET u = (
+      FOR g IN c.users
+      FOR user IN users
+      FILTER user._key == g
+      RETURN user
+    )
+    LIMIT 1
+    RETURN MERGE(c, {users: u})`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.next())
+    .then((conversation: ConversationType = {}) => {
+      const {users = []} = conversation;
+
+      if(users.length) {
+        conversation.users = users.map((user: UserType) => {
+          const {_key: userKey, imgId} = user;
+          const thumbUrlData: ImageUrlData = {
+            appId: sessionApp,
+            directory: 'images',
+            imgId,
+            isThumb: true,
+            type: 'users',
+            typeId: userKey
+          };
+          return {
+            ...user,
+            name: getDisplayName(user),
+            thumb: getUrlImages(thumbUrlData)
+          };
+        });
+      }
+
+      return conversation;
+    })
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(() => null));
+};
+
+export const getConversation = (context: ApiContext, convoId: string): Promise<ConversationType> => {
+  const action: string = 'getItem';
+  const {appId: sessionApp, database, userId: sessionId} = context;
+  const formatConvoId: string = parseId(convoId);
+
+  const aqlQry: AqlQuery = aql`FOR c IN conversations
+    FILTER ${formatConvoId} == c._key && IS_LIST(c.users) && POSITION(c.users, ${sessionId}, false)
+    LET u = (
+      FOR g IN c.users
+      FOR u IN users
+      FILTER g == u._key
+      RETURN {_key:u._key, first:u.first, last:u.last, name:u.name, email:u.email, username:u.username, photo:u.photo }
+    )
+    FILTER LENGTH(u) > 1
+    LIMIT 1
+    RETURN MERGE(c, {users: u})`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.next())
+    .then((conversation: ConversationType = {}) => {
+      if(!isEmpty(conversation)) {
+        conversation.users = conversation.users.map((user: UserType) => {
+          const {_key: userKey, imgId} = user;
+          const thumbUrlData: ImageUrlData = {
+            appId: sessionApp,
+            directory: 'images',
+            imgId,
+            isThumb: true,
+            type: 'users',
+            typeId: userKey
+          };
+          return {
+            ...user,
+            name: getDisplayName(user),
+            thumb: getUrlImages(thumbUrlData)
+          };
+        });
+
+        return conversation;
+      }
+      return {};
+    })
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(() => null));
+};
+
+export const updateConversation = (context: ApiContext, item): Promise<ConversationType> => {
+  const action: string = 'update';
+  const {database, userId: sessionId} = context;
+  const {direct, id, name, users} = pick(item, identity);
+  const rcpt: UserType[] = users || [];
+  const formatId: string = item.id || createHash(`convo-${sessionId}-${rcpt.join('')}`);
+  const now: number = Date.now();
+  const update: any = {
+    // Direct message
+    direct: !!direct ? direct : undefined,
+    modified: now,
+    name: !!name ? name : undefined,
+    // Users
+    users: !!users ? users : undefined
+  };
+
+  const insert: any = {
+    ...cloneDeep(update),
+    _key: formatId,
+    added: now
+  };
+
+  const aqlQry: AqlQuery = aql`UPSERT {_key: ${id}}
+    INSERT ${insert}
+    UPDATE ${update}
+    IN conversations RETURN NEW`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.next())
+    .then((conversation: ConversationType = {}) => conversation)
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(() => null));
+};

package/src/data/dynamodb.ts

@@ -0,0 +1,157 @@
+/**
+ * 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 {
+  BatchWriteItemInput,
+  BatchWriteItemOutput,
+  DeleteItemInput,
+  DeleteItemOutput,
+  GetItemInput,
+  GetItemOutput,
+  PutItemInput,
+  PutItemOutput,
+  QueryInput,
+  QueryOutput,
+  UpdateItemInput,
+  UpdateItemOutput
+} from 'aws-sdk/clients/dynamodb';
+
+import {Config} from '../config';
+
+// const eventCategory: string = 'dynamodb';
+
+export const dynamoGet = (params: GetItemInput): Promise<GetItemOutput> => {
+  return new Promise((resolve, reject) => {
+    aws.config.update(Config.get('aws'));
+    const dynamodb: DynamoDB = new DynamoDB();
+    params.ConsistentRead = false;
+
+    dynamodb.getItem(params, (error: Error, results: GetItemOutput) => {
+      if(error) {
+        return reject(error);
+      }
+
+      return resolve(results);
+    });
+  });
+};
+
+export const dynamoGetList = (params: QueryInput, index): Promise<GetItemOutput[]> => {
+  return new Promise((resolve, reject) => {
+    aws.config.update(Config.get('aws'));
+    const dynamodb: DynamoDB = new DynamoDB();
+    const {ConsistentRead: consistentRead} = params;
+    const updatedParams = {...params};
+
+    if(index) {
+      updatedParams.ExclusiveStartKey = index;
+    }
+
+    if(!consistentRead) {
+      updatedParams.ConsistentRead = false;
+    }
+
+    dynamodb.query(updatedParams, (error: Error, output: QueryOutput) => {
+      if(error) {
+        return reject(error);
+      }
+      // Save list of items
+      const list: any[] = parseDynamo(output);
+      const {LastEvaluatedKey: lastKey} = output;
+
+      if(lastKey !== undefined) {
+        // Save last index before looping
+        return dynamoGetList(params, lastKey);
+      }
+
+      // Query complete, return final list
+      return resolve(list);
+    });
+  });
+};
+
+export const dynamoPut = (params: PutItemInput): Promise<PutItemOutput> => {
+  return new Promise((resolve, reject) => {
+    aws.config.update(Config.get('aws'));
+    const dynamodb: DynamoDB = new DynamoDB();
+
+    dynamodb.putItem(params, (error, output: PutItemOutput) => {
+      if(error) {
+        return reject(error);
+      }
+      return resolve(output);
+    });
+  });
+};
+
+export const dynamoUpdate = (params: UpdateItemInput): Promise<UpdateItemOutput> => {
+  return new Promise((resolve, reject) => {
+    aws.config.update(Config.get('aws'));
+    const dynamodb: DynamoDB = new DynamoDB();
+
+    dynamodb.updateItem(params, (error: Error, output: UpdateItemOutput) => {
+      if(error) {
+        return reject(error);
+      }
+      return resolve(output);
+    });
+  });
+};
+
+export const dynamoPutList = (params: BatchWriteItemInput): Promise<BatchWriteItemOutput> => {
+  return new Promise((resolve, reject) => {
+    aws.config.update(Config.get('aws'));
+    const dynamodb: DynamoDB = new DynamoDB();
+
+    dynamodb.batchWriteItem(params, (error: Error, output: BatchWriteItemOutput) => {
+      if(error) {
+        return reject(error);
+      }
+      return resolve(output);
+    });
+  });
+};
+
+export const dynamoDel = (params: DeleteItemInput): Promise<DeleteItemOutput> => {
+  return new Promise((resolve, reject) => {
+    aws.config.update(Config.get('aws'));
+    const dynamodb: DynamoDB = new DynamoDB();
+
+    dynamodb.deleteItem(params, (error, output: DeleteItemOutput) => {
+      if(error) {
+        return reject(error);
+      }
+      return resolve(output);
+    });
+  });
+};
+
+export const parseDynamo = (results: QueryOutput): any[] => {
+  const {Items: items} = results;
+  const data: any[] = [];
+
+  for(let idx: number = 0, len = items.length; idx < len; idx++) {
+    const tmp = items[idx];
+    const obj = {};
+    let key;
+
+    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;
+};
+

package/src/data/email.ts

@@ -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 {GetObjectRequest} from 'aws-sdk/clients/s3';
+import {SendEmailRequest, SendEmailResponse} from 'aws-sdk/clients/ses';
+import fs from 'fs';
+import isEmpty from 'lodash/isEmpty';
+
+import {Config} from '../config';
+import {AppType} from '../types/apps';
+import {EmailType} from '../types/email';
+import {s3Get} from './s3';
+
+// const eventCategory: string = 'email';
+
+export const appTemplate = (app: AppType, message: string = '', vars = {}): string => {
+  let updatedMessage: string = '';
+
+  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((key: string) => {
+    if(vars[key]) {
+      updatedMessage = message.replace(new RegExp(`\\[${key}\\]`, 'g'), vars[key]);
+    }
+  });
+
+  return updatedMessage;
+};
+
+export const sendEmail = (params: EmailType): Promise<boolean> => {
+  const {
+    app = {},
+    html,
+    subject,
+    subTitle = '',
+    text,
+    title = '',
+    user = {}
+  } = params;
+
+  const to = [user.email];
+  let promise;
+
+  const formatSubject: string = appTemplate(app, subject);
+  const formatSubTitle: string = appTemplate(app, subTitle);
+  const formatTitle: string = appTemplate(app, title);
+  const formatText: string = appTemplate(app, text);
+  const formatHtml: string = appTemplate(app, html);
+  const {_key: appId, hasCustomEmail, urlFacebook, urlTwitter} = app;
+
+  const parseTemplate = (body: string) => {
+    const templateBody: string = appTemplate(app, body || '');
+
+    // Links
+    let links: string = '';
+    const 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="${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="${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) {
+    const s3Params: GetObjectRequest = {Bucket: null, Key: `apps/${appId}/templates/email.html`};
+    promise = s3Get(s3Params).then((results) => parseTemplate(results.Body.toString()));
+  } else {
+    promise = new Promise((resolve, reject) => {
+      fs.readFile('./templates/email/layout.html', 'utf8', (err, data) => {
+        if(err) {
+          return reject(err);
+        }
+
+        return resolve(parseTemplate(data));
+      });
+    });
+  }
+
+  return promise.then((parsedHtml: string) => {
+    const emailParams: SendEmailRequest = {
+      Destination: {ToAddresses: to},
+      Message: {
+        Body: {
+          Html: {Data: parsedHtml},
+          Text: {Data: formatText}
+        },
+        Subject: {Data: formatSubject}
+      },
+      Source: `"${app.supportName}" <noreply@${Config.get('app.url')}>`
+    };
+
+    return sesSend(emailParams);
+  });
+};
+
+export const sendTemplate = (templateName: string, emailParams: EmailType): Promise<boolean> => {
+  const {app, user, subject, subTitle, title, vars}: EmailType = emailParams;
+
+  try {
+    const html: string = fs.readFileSync(`./templates/email/${templateName}.html`, 'utf8');
+    const templateHtml: string = appTemplate(app, html, vars);
+    const text: string = fs.readFileSync(`./templates/sms/${templateName}.txt`, 'utf8');
+    const templateText: string = appTemplate(app, text, vars);
+
+    const params = {
+      app,
+      html: templateHtml,
+      subTitle,
+      subject,
+      text: templateText,
+      title,
+      user
+    };
+
+    return sendEmail(params)
+      .then(() => true)
+      .catch(() => false);
+  } catch(error) {
+    return Promise.reject(error);
+  }
+};
+
+// AWS::SES
+export const sesSend = (params: SendEmailRequest): Promise<SendEmailResponse> => {
+  return new Promise((resolve, reject) => {
+    aws.config.update(Config.get('aws'));
+    const ses: SES = new SES();
+
+    ses.sendEmail(params, (error: Error, response: SendEmailResponse) => {
+      if(error) {
+        return reject(error);
+      }
+
+      return resolve(response);
+    });
+  });
+};