@nlabs/reaktor 0.1.2 → 0.1.4

package/src/data/payments.ts

@@ -1,675 +0,0 @@
-import {createHash, parseChar, parseId, parseNum, parseString, parseVarChar} from '@nlabs/utils';
-import {aql} from 'arangojs';
-import {AqlQuery} from 'arangojs/lib/cjs/aql-query';
-import {ArrayCursor} from 'arangojs/lib/cjs/cursor';
-import {UserError} from 'graphql-errors';
-import isEmpty from 'lodash/isEmpty';
-import {DateTime} from 'luxon';
-import * as stripe from 'stripe';
-
-import {Config} from '../config';
-import {ApiContext, PaymentBankAccount, PaymentCardType, PaymentCharge, PaymentTransfer, UserType} from '../types';
-import {logError} from '../utils/analytics';
-import {useDb} from '../utils/arangodb';
-import {getUser} from './users';
-
-/**
- * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
- * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
- */
-const eventCategory: string = 'payments';
-
-export const addCustomerAccount = (context: ApiContext): Promise<boolean> => {
-  const action: string = 'addCustomerAccount';
-  const {database, userId: sessionId, username} = context;
-
-  // Stripe
-  const stripeClient = stripe(Config.get('stripe.token'));
-
-  return stripeClient.customers
-    .create({
-      metadata: {
-        userId: sessionId,
-        username
-      }
-    })
-    .then((customer) => {
-      // Create session
-      const now: number = Date.now();
-      const update: UserType = {
-        modified: now,
-        stripeCustomerId: customer.id
-      };
-
-      const aqlQry: AqlQuery = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;
-
-      return useDb(database).query(aqlQry)
-        .then((cursor: ArrayCursor) => cursor.next())
-        .then((updatedUser: UserType = {}) => !isEmpty(updatedUser))
-        .catch((error: Error) => logError({
-          action,
-          category: eventCategory,
-          label: 'db_error'
-        }, error, context).then(() => null));
-    });
-};
-
-export const addPaymentAccountBank = (context: ApiContext, bankAccount: PaymentBankAccount): Promise<boolean> => {
-  const action: string = 'addPaymentAccountBank';
-  const {database, userId: sessionId} = context;
-
-  // Params
-  const {
-    accountNumber,
-    fullName,
-    routing
-  } = bankAccount;
-
-  const formatAccount: string = parseString(accountNumber, 32);
-
-  if(formatAccount === '') {
-    throw new UserError('required_account_number');
-  }
-
-  const formatFullName: string = parseVarChar(fullName, 128);
-
-  if(formatFullName === '') {
-    throw new UserError('required_full_name');
-  }
-
-  const formatRouting: string = parseString(routing, 32);
-
-  if(formatRouting === '') {
-    throw new UserError('required_routing_number');
-  }
-
-  return getUser(context, sessionId)
-    .then((user: UserType) => {
-      // Stripe
-      const stripeClient = stripe(Config.get('stripe.token'));
-
-      return stripeClient.customers
-        .createSource(user.stripeAccountId, {
-          source: {
-            account_holder_name: formatFullName,
-            account_holder_type: 'individual',
-            account_number: formatAccount,
-            country: 'US',
-            currency: 'USD',
-            object: 'bank_account',
-            routing_number: formatRouting
-          }
-        })
-        .then((account) => {
-          const update: any = {
-            bankAccount: account.last4,
-            bankFullName: formatFullName,
-            bankId: account.id,
-            bankRouting: account.routing_number,
-            modified: Date.now()
-          };
-
-          const aqlQry: AqlQuery = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;
-
-          return useDb(database).query(aqlQry)
-            .then((cursor: ArrayCursor) => cursor.next())
-            .then((updatedUser: UserType = {}) => updatedUser);
-        })
-        .catch((error: Error) => {
-          const msg = error.message;
-
-          if(msg === 'A bank account with that routing number and account number ' +
-            'already exists for this customer.') {
-            return logError({
-              action,
-              category: eventCategory,
-              label: 'bank_account_exists'
-            }, error, context).then(() => null);
-          }
-          return logError({
-            action,
-            category: eventCategory,
-            label: 'payment_error'
-          }, error, context).then(() => null);
-        });
-    });
-};
-
-export const addPaymentAccountCard = (context: ApiContext, card: PaymentCardType, requestData): Promise<UserType> => {
-  const action: string = 'addPaymentAccountCard';
-  const {database, userId: sessionId} = context;
-
-  return getUser(context, sessionId)
-    .then((user: UserType) => {
-      // User
-      const {
-        _key: userKey,
-        country = 'US',
-        city,
-        currency = 'USD',
-        dob,
-        email,
-        first,
-        last,
-        username
-      }: UserType = user;
-
-      // Birthday
-      const dobDay: number = +(DateTime.fromMillis(dob).toFormat('d'));
-      const dobMonth: number = +(DateTime.fromMillis(dob).toFormat('M'));
-      const dobYear: number = +(DateTime.fromMillis(dob).toFormat('y'));
-
-      // Card
-      const {
-        accountNumber,
-        acceptedTerms,
-        expMonth,
-        expYear,
-        state,
-        street1,
-        zip
-      }: PaymentCardType = card;
-
-      // Acceptance
-      const accepted: number = acceptedTerms ? DateTime.local().millisecond : 0;
-
-      // Stripe
-      const stripeClient = stripe(Config.get('stripe.token'));
-
-      return stripeClient.accounts
-        .create({
-          country,
-          email,
-          external_account: {
-            currency,
-            exp_month: expMonth,
-            exp_year: expYear,
-            number: accountNumber,
-            object: 'card'
-          },
-          legal_entity: {
-            address: {
-              city,
-              line1: street1,
-              postal_code: zip,
-              state
-            },
-            dob: {
-              day: dobDay,
-              month: dobMonth,
-              year: dobYear
-            },
-            first_name: first,
-            last_name: last,
-            // ssn_last_4: ssn.substr(-4),
-            // personal_id_number: ssn,
-            type: 'individual'
-          },
-          managed: true,
-          metadata: {
-            userId: userKey,
-            username
-          },
-          tos_acceptance: {
-            date: accepted,
-            ip: requestData.ip,
-            user_agent: requestData.userAgent.source
-          }
-        })
-        .then((customer) => {
-          // Create session
-          const now: number = Date.now();
-          const update: UserType = {
-            modified: now,
-            stripeAccountId: customer.id
-          };
-
-          const aqlQry: AqlQuery = aql`UPDATE ${userKey} WITH ${update} IN users LIMIT 1 RETURN NEW`;
-
-          return useDb(database).query(aqlQry)
-            .then((cursor: ArrayCursor) => cursor.next())
-            .then((updatedUser: UserType = {}) => !isEmpty(updatedUser))
-            .catch((error: Error) => logError({
-              action,
-              category: eventCategory,
-              label: 'db_error'
-            }, error, context).then(() => null));
-        });
-    });
-};
-
-export const addCreditCard = (context: ApiContext, card: PaymentCardType): Promise<PaymentCardType> => {
-  const action: string = 'addCreditCard';
-  const {database, userId: sessionId} = context;
-
-  const {
-    accountNumber,
-    city,
-    country,
-    cvc,
-    expMonth,
-    expYear,
-    fullName,
-    street1,
-    state,
-    zip
-  }: PaymentCardType = card;
-  const formatNumber: number = parseNum(accountNumber, 16);
-
-  if(!formatNumber) {
-    throw new UserError('required_credit_card_number');
-  }
-
-  const formatExpMonth: number = parseNum(expMonth, 2);
-
-  if(!formatExpMonth) {
-    throw new UserError('required_credit_card_exp_month');
-  }
-
-  const formatExpYear: number = parseNum(expYear, 2);
-
-  if(!formatExpYear) {
-    throw new UserError('required_credit_card_exp_year');
-  }
-
-  const formatCvc: number = parseNum(cvc, 3);
-
-  if(!formatCvc) {
-    throw new UserError('required_credit_card_cvc');
-  }
-
-  const paymentCard: PaymentCardType = {};
-  const formatCity: string = parseVarChar(city, 32);
-
-  if(formatCity) {
-    paymentCard.city = formatCity;
-  }
-
-  const formatCountry: string = parseVarChar(country, 32);
-
-  if(formatCountry) {
-    paymentCard.country = formatCountry;
-  }
-
-  const formatFullName: string = parseVarChar(fullName, 32);
-
-  if(formatFullName) {
-    paymentCard.fullName = formatFullName;
-  }
-
-  const formatStreet: string = parseVarChar(street1, 32);
-
-  if(formatStreet) {
-    paymentCard.street1 = formatStreet;
-  }
-
-  const formatState: string = parseVarChar(state, 32);
-
-  if(formatState) {
-    paymentCard.state = formatState;
-  }
-
-  const formatZip: string = parseVarChar(zip, 32);
-
-  if(formatZip) {
-    paymentCard.zip = formatZip;
-  }
-
-  // Get stripe id
-  return getUser(context, sessionId)
-    .then((user: UserType = {}) => {
-      // Stripe
-      const stripeClient = stripe(Config.get('stripe.token'));
-
-      return stripeClient.customers
-        .createSource(user.stripeCustomerId, {
-          source: {
-            address_city: formatCity,
-            address_country: formatCountry,
-            address_line1: formatStreet,
-            address_state: formatState,
-            address_zip: formatZip,
-            currency: 'usd',
-            cvc: formatCvc,
-            exp_month: formatExpMonth,
-            exp_year: formatExpYear,
-            name: formatFullName,
-            number: formatNumber,
-            object: 'card'
-          }
-        })
-        .then((stripeObj) => {
-          const now: number = Date.now();
-          const insert = {
-            ...paymentCard,
-            _key: createHash(`user-payment-${sessionId}`),
-            accountNumber: stripeObj.last4,
-            added: now,
-            brand: stripeObj.brand,
-            cvc: stripeObj.cvc_check,
-            expMonth,
-            expYear,
-            modified: now,
-            userId: sessionId
-          };
-          const insertAqlQry: AqlQuery = aql`INSERT ${insert} IN creditCards RETURN NEW`;
-
-          return useDb(database).query(insertAqlQry)
-            .then((cursor: ArrayCursor) => cursor.next())
-            .then((newCard: PaymentCardType = {}) => {
-              if(!isEmpty(newCard)) {
-                // Add linked edge
-                const {_id: cardId, _key: cardKey} = card;
-                const edgeCollection = useDb(database).edgeCollection('hasPayment');
-                const edgeId = createHash(`payment-${cardKey}`);
-                const edge: any = {
-                  _key: edgeId
-                };
-
-                return edgeCollection.save(edge, `users/${sessionId}`, cardId).then(() => card);
-              }
-
-              return newCard;
-            });
-        })
-        .catch((error: Error) => logError({
-          action,
-          category: eventCategory,
-          label: 'payment_error'
-        }, error, context).then(() => null));
-    });
-};
-
-export const updateCreditCard = (context: ApiContext, card: PaymentCardType): Promise<PaymentCardType> => {
-  const {database, userId: sessionId} = context;
-
-  const {
-    city,
-    country,
-    expMonth,
-    expYear,
-    fullName,
-    id,
-    street1,
-    state,
-    zip
-  }: PaymentCardType = card;
-
-  const formatId: string = parseId(id);
-
-  if(formatId) {
-    throw new UserError('required_credit_card_id');
-  }
-
-  const paymentCard: PaymentCardType = {};
-  const formatExpMonth: number = parseNum(expMonth, 2);
-  const formatExpYear: number = parseNum(expYear, 2);
-  const formatCity: string = parseVarChar(city, 32);
-  const formatCountry: string = parseVarChar(country, 2);
-  const formatFullName: string = parseVarChar(fullName, 32);
-  const formatStreet1: string = parseString(street1, 32);
-  const formatState: string = parseVarChar(state, 2);
-  const formatZip: string = parseVarChar(zip, 10);
-
-  if(formatExpMonth) {
-    paymentCard.expMonth = formatExpMonth;
-  }
-
-  if(formatExpYear) {
-    paymentCard.expYear = formatExpYear;
-  }
-
-  if(formatCity) {
-    paymentCard.city = formatCity;
-  }
-
-  if(formatCountry) {
-    paymentCard.country = formatCountry;
-  }
-
-  if(formatFullName) {
-    paymentCard.fullName = formatFullName;
-  }
-
-  if(formatStreet1) {
-    paymentCard.street1 = formatStreet1;
-  }
-
-  if(formatState) {
-    paymentCard.state = formatState;
-  }
-
-  if(formatZip) {
-    paymentCard.zip = formatZip;
-  }
-
-  const update: any = paymentCard;
-  const aqlQry: AqlQuery = aql`
-      LET updatedCard = FIRST(
-        FOR c IN creditCards
-        FILTER c._key == ${formatId} && c.userId == ${sessionId}
-        UPDATE c WITH ${update} IN creditCards
-        LIMIT 1
-        RETURN NEW
-      )
-      LET user = FIRST(
-        FOR u IN users
-        FILTER u._key == ${sessionId}
-        LIMIT 1
-        RETURN u
-      )
-      RETURN {user: user, card: updatedCard}`;
-
-  return useDb(database).query(aqlQry)
-    .then((cursor: ArrayCursor) => cursor.next())
-    .then((results = {card: {}, user: {}}) => {
-      const updatedCard: PaymentCardType = results.card;
-      const {user} = results;
-
-      if(isEmpty(updatedCard)) {
-        throw new UserError('not_found');
-      }
-
-      // Stripe
-      const stripeClient = stripe(Config.get('stripe.token'));
-
-      return stripeClient.customers
-        .updateCard(user.stripeCustomerId, card.stripeId, {
-          address_city: formatCity,
-          address_country: formatCountry,
-          address_line1: formatStreet1,
-          address_state: formatState,
-          address_zip: formatZip,
-          exp_month: formatExpMonth,
-          exp_year: formatExpYear,
-          name: formatFullName
-        })
-        .then(() => card)
-        .catch((error: Error) => {
-          console.log('payments::updateCard::error', error);
-          throw new UserError('payment_error');
-        });
-    });
-};
-
-export const getCreditCards = (context: ApiContext): Promise<PaymentCardType[]> => {
-  const action: string = 'getCreditCards';
-  const {database, userId: sessionId} = context;
-  const aqlQry: AqlQuery = aql`FOR c IN creditCards
-        FILTER c.userId == ${sessionId}
-        RETURN c`;
-
-  return useDb(database).query(aqlQry)
-    .then((cursor: ArrayCursor) => cursor.all())
-    .then((list: PaymentCardType[] = []) => list)
-    .catch((error: Error) => logError({
-      action,
-      category: eventCategory,
-      label: 'db_error'
-    }, error, context).then(() => null));
-};
-
-export const deleteCreditCard = (context: ApiContext, cardId: string): Promise<boolean> => {
-  const {database, userId: sessionId} = context;
-  const formatCardId: string = parseId(cardId);
-  const aqlQry: AqlQuery = aql`
-      LET card = FIRST(
-        FOR c IN creditCards
-        FILTER c._key == ${formatCardId} && c.userId == ${sessionId}
-        LIMIT 1
-        REMOVE c IN creditCards
-        RETURN OLD
-      )
-      LET user = FIRST(
-        FOR u IN users
-        FILTER u._key == ${sessionId}
-        LIMIT 1
-        RETURN u
-      )
-      RETURN {user: user, card: card}`;
-
-  return useDb(database).query(aqlQry)
-    .then((cursor: ArrayCursor) => cursor.next())
-    .then((result = {card: {}, user: {}}) => {
-      if(isEmpty(result)) {
-        return false;
-      }
-
-      const {card, user} = result;
-      const {_key: cardKey} = card;
-
-      // Remove linked edges
-      const edgeCollection = useDb(database).edgeCollection('hasPayment');
-
-      return edgeCollection.outEdges(cardKey)
-        .then((edges) => {
-          if(edges.length) {
-            return Promise.all(
-              edges.map((edge) => {
-                const {_key: edgeKey} = edge;
-                const removeAqlQry: AqlQuery = aql`REMOVE {_key:${edgeKey}} IN hasPayment`;
-                return useDb(database).query(removeAqlQry);
-              }))
-              .then(() => {
-                // Stripe
-                const stripeClient = stripe(Config.get('stripe.token'));
-
-                return stripeClient.customers
-                  .deleteCard(user.stripeCustomerId, card.stripeId)
-                  .then(() => true)
-                  .catch((error: Error) => {
-                    console.log('payments::deleteCard::error', error);
-                    throw new UserError('payment_error');
-                  });
-              });
-          }
-
-          return false;
-        });
-    });
-};
-
-export const deletePaymentAccountBank = (context: ApiContext, bankId: string): Promise<boolean> => {
-  const {database, userId: sessionId} = context;
-
-  // Clean db
-  const update: UserType = {
-    bankAccount: '',
-    bankFullName: '',
-    bankId: '',
-    bankRouting: '',
-    modified: Date.now()
-  };
-  const aqlQry: AqlQuery = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;
-
-  return useDb(database).query(aqlQry)
-    .then((cursor: ArrayCursor) => cursor.next())
-    .then((user: UserType = {}) => {
-      // Stripe
-      const stripeClient = stripe(Config.get('stripe.token'));
-
-      return stripeClient.customers
-        .deleteSource(user.stripeAccountId, bankId)
-        .then((response = {deleted: false}) => response.deleted)
-        .catch(() => Promise.resolve(false));
-    });
-};
-
-export const createPaymentTransfer = (context: ApiContext, transfer: PaymentTransfer): Promise<PaymentTransfer> => {
-  const {database, userId: sessionId} = context;
-  const {amount, currency} = transfer;
-  const formatAmount: number = parseNum(amount);
-  const formatCurrency: string = parseChar(currency, 3, 'USD').toUpperCase();
-
-  return getUser(context, sessionId)
-    .then((user: UserType) => {
-      // Stripe
-      const stripeClient = stripe(Config.get('stripe.token'));
-
-      return stripeClient.transfers
-        .create({
-          amount: formatAmount,
-          currency: formatCurrency,
-          destination: user.stripeAccountId
-        })
-        .then((stripeTransfer) => {
-          console.log(stripeTransfer);
-          const now: number = Date.now();
-          const insert: PaymentTransfer = {
-            added: now,
-            amount: formatAmount,
-            currency: formatCurrency,
-            modified: now,
-            userId: sessionId
-          };
-          const aqlQry: AqlQuery = aql`INSERT ${insert} IN transfers RETURN NEW`;
-
-          return useDb(database).query(aqlQry)
-            .then((cursor: ArrayCursor) => cursor.next())
-            .then((newTransfer: PaymentTransfer) => newTransfer);
-        });
-    });
-};
-
-export const createPaymentHold = (context: ApiContext, payment: PaymentCharge): Promise<PaymentCharge> => {
-  const {database, userId: sessionId} = context;
-  const {amount, capture, cardId, currency, description} = payment;
-  const formatCurrency = parseChar(currency, 3, 'USD').toUpperCase();
-
-  const stripeClient = stripe(Config.get('stripe.token'));
-
-  return stripeClient.charges
-    .create({
-      amount,
-      capture,
-      currency: formatCurrency,
-      description,
-      source: cardId
-    })
-    .then((stripeCharge) => {
-      const now: number = Date.now();
-      const insert: PaymentCharge = {
-        added: now,
-        amount,
-        capture,
-        cardId,
-        chargeFailCode: stripeCharge.failure_code,
-        chargeFailMsg: stripeCharge.failure_message,
-        chargeId: stripeCharge.id,
-        chargeStatus: stripeCharge.status,
-        currency: formatCurrency,
-        description,
-        modified: now,
-        userId: sessionId
-      };
-      const aqlQry: AqlQuery = aql`INSERT ${insert} IN payments RETURN NEW`;
-
-      return useDb(database).query(aqlQry)
-        .then((cursor: ArrayCursor) => cursor.next())
-        .then((newPayment: PaymentCharge) => newPayment);
-    })
-    .catch((error: Error) => {
-      console.log('payments::createHold::error', error);
-      throw new UserError('payment_error');
-    });
-};