@nlabs/reaktor 0.1.0

package/src/data/s3.ts

@@ -0,0 +1,117 @@
+/**
+ * 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 {
+  DeleteObjectOutput,
+  DeleteObjectRequest,
+  DeleteObjectsOutput,
+  DeleteObjectsRequest,
+  GetObjectOutput,
+  GetObjectRequest,
+  HeadObjectOutput,
+  HeadObjectRequest,
+  PutObjectOutput,
+  PutObjectRequest
+} from 'aws-sdk/clients/s3';
+
+import {Config} from '../config';
+
+// AWS S3
+// const eventCategory: string = 's3';
+
+export const s3Get = (params: GetObjectRequest): Promise<GetObjectOutput> => {
+  return new Promise((resolve, reject) => {
+    aws.config.update(Config.get('aws'));
+    const s3: S3 = new S3();
+
+    if(!params.Bucket) {
+      params.Bucket = Config.get('aws.Bucket');
+    }
+
+    s3.getObject(params, (error: Error, output: GetObjectOutput) => {
+      if(error) {
+        return reject(error);
+      }
+
+      return resolve(output);
+    });
+  });
+};
+
+export const s3Head = (params: HeadObjectRequest): Promise<HeadObjectOutput> => {
+  return new Promise((resolve, reject) => {
+    aws.config.update(Config.get('aws'));
+    const s3: S3 = new S3();
+
+    if(!params.Bucket) {
+      params.Bucket = Config.get('aws.Bucket');
+    }
+
+    s3.headObject(params, (error: Error, output: HeadObjectOutput) => {
+      if(error) {
+        return reject(error);
+      }
+      return resolve(output);
+    });
+  });
+};
+
+export const s3Put = (params: PutObjectRequest): Promise<PutObjectOutput> => {
+  return new Promise((resolve, reject) => {
+    aws.config.update(Config.get('aws'));
+    const s3 = new aws.S3();
+
+    if(!params.Bucket) {
+      params.Bucket = Config.get('aws.Bucket');
+    }
+
+    if(!params.StorageClass) {
+      params.StorageClass = 'REDUCED_REDUNDANCY';
+    }
+
+    s3.putObject(params, (error: Error, output: PutObjectOutput) => {
+      if(error) {
+        return reject(error);
+      }
+      return resolve(output);
+    });
+  });
+};
+
+export const s3Delete = (params: DeleteObjectRequest): Promise<DeleteObjectOutput> => {
+  return new Promise((resolve, reject) => {
+    aws.config.update(Config.get('aws'));
+    const s3: S3 = new S3();
+
+    if(!params.Bucket) {
+      params.Bucket = Config.get('aws.Bucket');
+    }
+
+    s3.deleteObject(params, (error, output: DeleteObjectOutput) => {
+      if(error) {
+        return reject(error);
+      }
+      return resolve(output);
+    });
+  });
+};
+
+export const s3DeleteList = (params: DeleteObjectsRequest): Promise<DeleteObjectsOutput> => {
+  return new Promise((resolve, reject) => {
+    aws.config.update(Config.get('aws'));
+    const s3: S3 = new S3();
+
+    if(!params.Bucket) {
+      params.Bucket = Config.get('aws.Bucket');
+    }
+
+    s3.deleteObjects(params, (error: Error, output: DeleteObjectsOutput) => {
+      if(error) {
+        return reject(error);
+      }
+      return resolve(output);
+    });
+  });
+};

package/src/data/search.ts

@@ -0,0 +1,74 @@
+/**
+ * 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 {AqlQuery} from 'arangojs/lib/cjs/aql-query';
+import {ArrayCursor} from 'arangojs/lib/cjs/cursor';
+import flatten from 'lodash/flatten';
+import uniqBy from 'lodash/uniqBy';
+
+import {ArangoDBLimit} from '../types/arangodb';
+import {ApiContext} from '../types/auth';
+import {UserType} from '../types/users';
+import {getLimit, logException, useDb} from '../utils';
+import {getDisplayName} from './users';
+
+const eventCategory: string = 'search';
+
+export const getSearchList = (context: ApiContext, query: string, from: number, to: number): Promise<UserType[]> => {
+  const action: string = 'getList';
+  const {database} = context;
+  const isString: boolean = true;
+
+  if(isString) {
+    const fields: any[] = [
+      {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((obj) => {
+      const qry: string = `prefix:${query}`;
+      const userQry: AqlQuery = aql`FOR u IN FULLTEXT(${obj.collection}, ${obj.field}, ${qry}, 50) RETURN u`;
+      return useDb(database).query(userQry).then((cursor: ArrayCursor) => cursor.all());
+    }))
+      .then((results) => {
+        const list = uniqBy(flatten(results), '_key');
+
+        return list.map((item: UserType) => {
+          const {_id: itemId, name: itemName} = item;
+          const collectionIdList: string[] = itemId.split('/');
+          const collection: string = collectionIdList[0];
+          const name: string = collection === 'users' ? getDisplayName(item) : itemName;
+
+          return {...item, name};
+        });
+      });
+  }
+
+  const limit: ArangoDBLimit = getLimit(from, to);
+  const aqlQry: string = `FOR u IN users
+        FILTER u.phone == "${query}"
+        ${limit.aql}
+        RETURN u`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.all())
+    .then((list: UserType[] = []) => list.map((item = {}) => {
+      const {_id: itemId, name: itemName} = item;
+      const collectionIdList: string[] = itemId.split('/');
+      const collection: string = collectionIdList[0];
+      const name: string = collection === 'users' ? getDisplayName(item) : itemName;
+
+      return {...item, name};
+    }))
+    .catch((error: Error) => logException({
+      action,
+      category: eventCategory,
+      label: 'db_error',
+      value: error.message
+    }, context).then(() => null));
+};

package/src/data/sms.ts

@@ -0,0 +1,60 @@
+/**
+ * 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 {SMSParamsType, TwilioOptionsType} from '../types/notifications';
+import {appTemplate} from './email';
+
+// const eventCategory: string = 'sms';
+
+// Twilio
+export const sendSms = (params: SMSParamsType): any => {
+  const {
+    app = {},
+    content,
+    user = {}
+  } = params;
+
+  const country = user.country || 'US';
+  const phone = parsePhone(user.phone, country);
+  const templateContent: string = appTemplate(app, content);
+
+  const twilio: any = twilioSdk(Config.get('twilio.sid'), Config.get('twilio.token'));
+  const cfg: TwilioOptionsType = {
+    body: templateContent,
+    from: Config.get('twilio.number'),
+    to: phone
+  };
+
+  return new Promise((resolve, reject) => {
+    twilio.sendMessage(cfg, (error, data) => {
+      if(error) {
+        reject(new Error(error.error_message));
+      } else {
+        resolve(data);
+      }
+    });
+  });
+}
+
+export const sendSmsTemplate = (templateName: string, smsParams: SMSParamsType): Promise<boolean> => {
+  const {app, user, vars} = smsParams;
+  try {
+    const data = fs.readFileSync(`./templates/sms/${templateName}.txt`, 'utf8');
+    const text = appTemplate(app, data, vars);
+    const params = {app, text, user};
+
+    return sendSms(params)
+      .then((res) => res.status === 'queued')
+      .catch((error: Error) => {
+        throw error;
+      });
+  } catch(error) {
+    return Promise.reject(error);
+  }
+};

package/src/data/subscription.ts

@@ -0,0 +1,228 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import {createHash, parseChar, parseId, parseNum, parseVarChar} from '@nlabs/utils';
+import {aql} from 'arangojs';
+import {AqlQuery} from 'arangojs/lib/cjs/aql-query';
+import {ArrayCursor} from 'arangojs/lib/cjs/cursor';
+import {DateTime} from 'luxon';
+import * as stripe from 'stripe';
+
+import {Config} from '../config';
+import {ArangoDBLimit} from '../types/arangodb';
+import {ApiContext} from '../types/auth';
+import {PaymentInterval, PaymentPlan, PaymentSubscription} from '../types/payments';
+import {getLimit, logError, logException, useDb} from '../utils';
+import {getUser} from './users';
+
+const eventCategory: string = 'subscription';
+
+export const getPlanList = (context: ApiContext, from: number = 0, to: number = 30): Promise<PaymentPlan[]> => {
+  const action: string = 'getList';
+  const {database} = context;
+  const limit: ArangoDBLimit = getLimit(from, to);
+  const aqlQry: string = `FOR p IN plans
+      ${limit.aql}
+      SORT p.amount
+      RETURN p`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.all())
+    .then((list = []) => list)
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, {}).then(() => null).catch((error) => Promise.reject(error)));
+};
+
+export const getSubscription = (context: ApiContext): Promise<PaymentSubscription> => {
+  const action: string = 'getItem';
+  const {database, userId: sessionId} = context;
+  const aqlQry: string = `FOR s IN subscriptions
+      FILTER s.userId == ${sessionId} && s.cancelled > 0
+      LET plan = FIRST(
+        FOR p IN plans
+        FILTER p._key == s.planId
+      )
+      LIMIT 1
+      RETURN MERGE(s, {plan: plan})`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.next())
+    .then((subscription = {}) => subscription)
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, {}).then(() => null).catch((error) => Promise.reject(error)));
+}
+
+export const addPlan = (context: ApiContext, item: PaymentPlan): Promise<PaymentPlan> => {
+  const action: string = 'addPlan';
+  const {database, userId: sessionId, userType} = context;
+  const isAdmin: boolean = userType > 2;
+
+  if(!isAdmin) {
+    return logException({
+      action,
+      category: eventCategory,
+      label: 'unauthorized',
+      value: 'invalid_session'
+    }, context).then(() => null);
+  }
+
+  const now: number = Date.now();
+  const formatId: string = parseId(item.id);
+  const planId: string = formatId === '' ? createHash(`tag-${sessionId}`) : formatId;
+  const {amount, currency = 'USD', description, interval, intervalCount, name} = item;
+  const formatAmount: number = parseNum(amount);
+  const formatInterval: PaymentInterval = parseChar(interval, 5).toLowerCase() as PaymentInterval;
+  const formatIntervalCnt: number = parseNum(intervalCount, 5);
+  const formatName: string = parseVarChar(name, 32);
+  const formatDesc: string = parseVarChar(description, 32);
+
+  const insert: PaymentPlan = {
+    _key: planId,
+    added: now,
+    amount: formatAmount,
+    currency,
+    description: formatDesc,
+    interval: formatInterval,
+    intervalCount: formatIntervalCnt,
+    modified: now,
+    name: formatName
+  };
+  const aqlQry: AqlQuery = aql`INSERT ${insert} IN plans RETURN NEW`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.next())
+    .then((plan: PaymentPlan = {}) => {
+      // Stripe
+      const stripeClient = stripe(Config.get('stripe.token'));
+      return stripeClient.plans
+        .create({
+          amount: formatAmount * 100,
+          currency,
+          id: planId,
+          interval: formatInterval,
+          interval_count: formatIntervalCnt,
+          metadata: {
+          },
+          name: formatName,
+          statement_descriptor: formatDesc
+        })
+        .then(() => plan);
+    })
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, {}).then(() => null).catch((error) => Promise.reject(error)));
+};
+
+export const addSubscription = (context: ApiContext, item): Promise<PaymentSubscription> => {
+  const action: string = 'addSubscription';
+  const {database, userId: sessionId, userType} = context;
+  const isAdmin: boolean = userType > 2;
+
+  if(!isAdmin) {
+    return logException({
+      action,
+      category: eventCategory,
+      label: 'unauthorized',
+      value: 'invalid_session'
+    }, context).then(() => null);
+  }
+
+  const now: number = Date.now();
+  const formatId: string = parseId(item.id);
+  const subscriptionId: string = formatId === '' ? createHash(`tag-${sessionId}`) : formatId;
+  const {planId, tax, trialEnd, trialPeriod} = item;
+  const formatPlanId: string = parseId(planId);
+  const formatTaxPercent: number = parseNum(tax) || 0;
+  const formatTrialPeriod: number = parseNum(tax) || 0;
+  let formatTrialEnd: number = trialEnd || Date.now();
+
+  if(formatTrialPeriod) {
+    formatTrialEnd = DateTime.local().plus({days: trialPeriod}).toMillis();
+  }
+
+  return getUser(context, sessionId)
+    .then((user) => {
+      const insert: PaymentSubscription = {
+        _key: subscriptionId,
+        added: now,
+        cancelDate: 0,
+        modified: now,
+        planId: formatPlanId,
+        tax: formatTaxPercent,
+        trialEnd: formatTrialEnd,
+        userId: sessionId
+      };
+      const aqlQry: AqlQuery = aql`INSERT ${insert} IN plans RETURN NEW`;
+
+      return useDb(database).query(aqlQry)
+        .then((cursor: ArrayCursor) => cursor.next())
+        .then((subscription: PaymentSubscription = {}) => {
+          // Stripe
+          const stripeClient = stripe(Config.get('stripe.token'));
+          return stripeClient.subscriptions
+            .create({
+              customer: user.stripeCustomerId,
+              items: [
+                {plan: formatPlanId}
+              ],
+              metadata: {
+                userId: sessionId
+              },
+              tax_percent: formatTaxPercent * 100,
+              trial_end: formatTrialEnd
+            })
+            .then(() => subscription);
+        })
+        .catch((error: Error) => logError({
+          action,
+          category: eventCategory,
+          label: 'db_error'
+        }, error, {}).then(() => null).catch((error) => Promise.reject(error)));
+    });
+};
+
+export const deleteSubscription = (context: ApiContext, endDate: number): Promise<boolean> => {
+  const action: string = 'deleteSubscription';
+  const {database} = context;
+  const now: number = Date.now();
+  const formatEndDate: number = parseNum(endDate) || now;
+
+  return getSubscription(context)
+    .then((subscription) => {
+      // Stripe
+      const stripeClient = stripe(Config.get('stripe.token'));
+      return stripeClient.subscriptions
+        .del(subscription.transactionId, {
+          subscription: formatEndDate
+        })
+        .then((stripeResponse) => {
+          // Make sure we cancelled on Stripe before updating the db
+          if(stripeResponse.cancelled || stripeResponse.cancel_at_period_end) {
+            const update: PaymentSubscription = {
+              cancelDate: formatEndDate,
+              modified: now,
+              planId: ''
+            };
+            const aqlQry: AqlQuery = aql`UPDATE s WITH ${update} IN subscriptions`;
+
+            return useDb(database).query(aqlQry)
+              .then(() => true)
+              .catch((error: Error) => logError({
+                action,
+                category: eventCategory,
+                label: 'db_error'
+              }, error, {}).then(() => null).catch((error) => Promise.reject(error)));
+          }
+          return false;
+        });
+    });
+};