@nlabs/reaktor 0.3.0 → 0.4.1

package/lib/actions/notifications.js

@@ -0,0 +1,63 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  clearBadges: () => clearBadges,
+  getApnProvider: () => getApnProvider,
+  pushNotification: () => pushNotification
+});
+var import_apn = __toModule(require("apn"));
+var import_config = __toModule(require("../config"));
+const getApnProvider = () => new import_apn.Provider({
+  ca: import_config.Config.get("app.apn.ca"),
+  cert: import_config.Config.get("app.apn.cert"),
+  key: import_config.Config.get("app.apn.key"),
+  production: import_config.Config.get("environment") === "prod"
+});
+const pushNotification = (deviceTokens, note) => {
+  const provider = getApnProvider();
+  const notification = new import_apn.Notification();
+  notification.topic = import_config.Config.get("app.apn.id");
+  notification.alert = note.message;
+  if (note.data) {
+    notification.mutableContent = true;
+    notification.payload = note.data;
+  }
+  if (note.badge !== void 0) {
+    notification.badge = note.badge;
+  }
+  return provider.send(notification, deviceTokens);
+};
+const clearBadges = (deviceTokens) => {
+  const provider = getApnProvider();
+  const notification = new import_apn.Notification();
+  notification.badge = 0;
+  return provider.send(notification, deviceTokens);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearBadges,
+  getApnProvider,
+  pushNotification
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/{data → actions}/payments.d.ts

@@ -1,7 +1,7 @@
-import { ApiContext, PaymentBankAccount, PaymentCardType, PaymentCharge, PaymentTransfer, UserType } from '../types';
+import { ApiContext, PaymentBankAccount, PaymentCardType, PaymentCharge, PaymentTransfer, User } from '../types';
 export declare const addCustomerAccount: (context: ApiContext) => Promise<boolean>;
 export declare const addBankAccount: (context: ApiContext, bankAccount: PaymentBankAccount) => Promise<boolean>;
-export declare const addCreditCard: (context: ApiContext, card: PaymentCardType) => Promise<UserType>;
+export declare const addCreditCard: (context: ApiContext, card: PaymentCardType) => Promise<User>;
 export declare const updateCreditCard: (context: ApiContext, card: PaymentCardType) => Promise<PaymentCardType>;
 export declare const getCreditCards: (context: ApiContext) => Promise<PaymentCardType[]>;
 export declare const deleteCreditCard: (context: ApiContext, cardId: string) => Promise<boolean>;

package/lib/actions/payments.js

@@ -0,0 +1,491 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  addBankAccount: () => addBankAccount,
+  addCreditCard: () => addCreditCard,
+  addCustomerAccount: () => addCustomerAccount,
+  createPaymentHold: () => createPaymentHold,
+  createPaymentTransfer: () => createPaymentTransfer,
+  deleteBankAccount: () => deleteBankAccount,
+  deleteCreditCard: () => deleteCreditCard,
+  getCreditCards: () => getCreditCards,
+  updateCreditCard: () => updateCreditCard
+});
+var import_utils = __toModule(require("@nlabs/utils"));
+var import_arangojs = __toModule(require("arangojs"));
+var import_graphql_errors = __toModule(require("graphql-errors"));
+var import_isEmpty = __toModule(require("lodash/isEmpty"));
+var import_stripe = __toModule(require("stripe"));
+var import_config = __toModule(require("../config"));
+var import_analytics = __toModule(require("../utils/analytics"));
+var import_users = __toModule(require("./users"));
+const eventCategory = "payments";
+const apiVersion = "2020-03-02";
+const addCustomerAccount = (context) => {
+  const action = "addCustomerAccount";
+  const { database, session: { userId: sessionId, username } } = context;
+  const stripeClient = new import_stripe.default(import_config.Config.get("stripe.token"), { apiVersion, typescript: true });
+  return stripeClient.customers.create({
+    metadata: {
+      userId: sessionId,
+      username
+    }
+  }).then((customer) => {
+    const now = Date.now();
+    const update = {
+      modified: now,
+      stripeCustomerId: customer.id
+    };
+    const aqlQry = import_arangojs.aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;
+    return database.query(aqlQry).then((cursor) => cursor.next()).then((updatedUser = {}) => !(0, import_isEmpty.default)(updatedUser)).catch((error) => (0, import_analytics.logError)({
+      action,
+      category: eventCategory,
+      label: "db_error"
+    }, error, context).then(() => null));
+  });
+};
+const addBankAccount = (context, bankAccount) => {
+  const action = "addPaymentAccountBank";
+  const { database, session: { userId: sessionId } } = context;
+  const {
+    accountNumber,
+    fullName,
+    routing
+  } = bankAccount;
+  const formatAccount = (0, import_utils.parseString)(accountNumber, 32);
+  if (formatAccount === "") {
+    throw new import_graphql_errors.UserError("required_account_number");
+  }
+  const formatFullName = (0, import_utils.parseVarChar)(fullName, 128);
+  if (formatFullName === "") {
+    throw new import_graphql_errors.UserError("required_full_name");
+  }
+  const formatRouting = (0, import_utils.parseString)(routing, 32);
+  if (formatRouting === "") {
+    throw new import_graphql_errors.UserError("required_routing_number");
+  }
+  return (0, import_users.getUser)(context, sessionId).then((user) => {
+    const { stripeAccountId } = user;
+    const stripeClient = new import_stripe.default(import_config.Config.get("stripe.token"), { apiVersion, typescript: true });
+    const source = {
+      account_holder_name: formatFullName,
+      account_holder_type: "individual",
+      account_number: formatAccount,
+      country: "US",
+      currency: "USD",
+      object: "bank_account",
+      routing_number: formatRouting
+    };
+    return stripeClient.customers.createSource(stripeAccountId, { source }).then((account) => {
+      const { id: bankId, last4: bankAccount2, routing_number: bankRouting } = account;
+      const update = {
+        bankAccount: bankAccount2,
+        bankFullName: formatFullName,
+        bankId,
+        bankRouting,
+        modified: Date.now()
+      };
+      const aqlQry = import_arangojs.aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;
+      return database.query(aqlQry).then((cursor) => cursor.next()).then((updatedUser = {}) => updatedUser);
+    }).catch((error) => {
+      const msg = error.message;
+      if (msg === "A bank account with that routing number and account number already exists for this customer.") {
+        return (0, import_analytics.logError)({
+          action,
+          category: eventCategory,
+          label: "bank_account_exists"
+        }, error, context).then(() => null);
+      }
+      return (0, import_analytics.logError)({
+        action,
+        category: eventCategory,
+        label: "payment_error"
+      }, error, context).then(() => null);
+    });
+  });
+};
+const addCreditCard = (context, card) => {
+  const action = "addCreditCard";
+  const { database, session: { userId: sessionId } } = context;
+  return (0, import_users.getUser)(context, sessionId).then((user) => {
+    const { stripeAccountId } = user;
+    const {
+      accountNumber,
+      city,
+      country,
+      cvc,
+      expMonth,
+      expYear,
+      fullName,
+      street1,
+      street2,
+      state,
+      zip
+    } = card;
+    const formatNumber = (0, import_utils.parseNum)(accountNumber, 16);
+    if (!formatNumber) {
+      throw new import_graphql_errors.UserError("required_credit_card_number");
+    }
+    const formatExpMonth = (0, import_utils.parseNum)(expMonth, 2);
+    if (!formatExpMonth) {
+      throw new import_graphql_errors.UserError("required_credit_card_exp_month");
+    }
+    const formatExpYear = (0, import_utils.parseNum)(expYear, 2);
+    if (!formatExpYear) {
+      throw new import_graphql_errors.UserError("required_credit_card_exp_year");
+    }
+    const formatCvc = (0, import_utils.parseNum)(cvc, 3);
+    const paymentCard = {};
+    const formatCity = (0, import_utils.parseVarChar)(city, 32);
+    if (formatCity) {
+      paymentCard.city = formatCity;
+    }
+    const formatCountry = (0, import_utils.parseChar)(country, 2);
+    if (formatCountry) {
+      paymentCard.country = formatCountry;
+    }
+    const formatFullName = (0, import_utils.parseVarChar)(fullName, 32);
+    if (formatFullName) {
+      paymentCard.fullName = formatFullName;
+    }
+    const formatStreet1 = (0, import_utils.parseVarChar)(street1, 32);
+    if (formatStreet1) {
+      paymentCard.street1 = formatStreet1;
+    }
+    const formatStreet2 = (0, import_utils.parseVarChar)(street2, 32);
+    if (formatStreet2) {
+      paymentCard.street2 = formatStreet2;
+    }
+    const formatState = (0, import_utils.parseChar)(state, 2);
+    if (formatState) {
+      paymentCard.state = formatState;
+    }
+    const formatZip = (0, import_utils.parseVarChar)(zip, 10);
+    if (formatZip) {
+      paymentCard.zip = formatZip;
+    }
+    const stripeClient = new import_stripe.default(import_config.Config.get("stripe.token"), { apiVersion, typescript: true });
+    const source = {
+      address_city: formatCity,
+      address_country: formatCountry,
+      address_line1: formatStreet1,
+      address_line2: formatStreet2,
+      address_state: formatState,
+      address_zip: formatZip,
+      cvc: formatCvc,
+      exp_month: formatExpMonth,
+      exp_year: formatExpYear,
+      name: fullName,
+      number: formatNumber,
+      object: "card"
+    };
+    return stripeClient.customers.createSource(stripeAccountId, { source }).then((newSource) => {
+      const { brand, cvc_check: cvcCheck, last4 } = newSource;
+      const now = Date.now();
+      const insert = __spreadProps(__spreadValues({}, paymentCard), {
+        _key: (0, import_utils.createHash)(`user-payment-${sessionId}`),
+        accountNumber: last4,
+        added: now,
+        brand,
+        cvcCheck,
+        expMonth,
+        expYear,
+        modified: now,
+        userId: sessionId
+      });
+      const insertAqlQry = import_arangojs.aql`INSERT ${insert} IN creditCards RETURN NEW`;
+      return database.query(insertAqlQry).then((cursor) => cursor.next()).then((newCard = {}) => {
+        if (!(0, import_isEmpty.default)(newCard)) {
+          const { _id: cardId, _key: cardKey } = card;
+          const edgeCollection = database.collection("hasPayment");
+          const edgeId = (0, import_utils.createHash)(`payment-${cardKey}`);
+          const edge = {
+            _from: `users/${sessionId}`,
+            _key: edgeId,
+            _to: cardId
+          };
+          return edgeCollection.save(edge, { returnNew: true }).then(() => card);
+        }
+        return newCard;
+      }).catch((error) => (0, import_analytics.logError)({
+        action,
+        category: eventCategory,
+        label: "payment_error"
+      }, error, context).then(() => null));
+    });
+  });
+};
+const updateCreditCard = (context, card) => {
+  const { database, session: { userId: sessionId } } = context;
+  const {
+    city,
+    country,
+    expMonth,
+    expYear,
+    fullName,
+    id,
+    street1,
+    state,
+    zip
+  } = card;
+  const formatId = (0, import_utils.parseId)(id);
+  if (formatId) {
+    throw new import_graphql_errors.UserError("required_credit_card_id");
+  }
+  const paymentCard = {};
+  const formatExpMonth = (0, import_utils.parseNum)(expMonth, 2);
+  const formatExpYear = (0, import_utils.parseNum)(expYear, 2);
+  const formatCity = (0, import_utils.parseVarChar)(city, 32);
+  const formatCountry = (0, import_utils.parseChar)(country, 2);
+  const formatFullName = (0, import_utils.parseVarChar)(fullName, 32);
+  const formatStreet1 = (0, import_utils.parseString)(street1, 32);
+  const formatState = (0, import_utils.parseChar)(state, 2);
+  const formatZip = (0, import_utils.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 = paymentCard;
+  const aqlQry = import_arangojs.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 database.query(aqlQry).then((cursor) => cursor.next()).then((results = { card: {}, user: {} }) => {
+    const updatedCard = results.card;
+    const { user } = results;
+    if ((0, import_isEmpty.default)(updatedCard)) {
+      throw new import_graphql_errors.UserError("not_found");
+    }
+    const { stripeCustomerId } = user;
+    const { stripeId } = card;
+    const stripeClient = new import_stripe.default(import_config.Config.get("stripe.token"), { apiVersion, typescript: true });
+    const update2 = {
+      address_city: formatCity,
+      address_country: formatCountry,
+      address_line1: formatStreet1,
+      address_state: formatState,
+      address_zip: formatZip,
+      exp_month: formatExpMonth,
+      exp_year: formatExpYear,
+      name: formatFullName
+    };
+    return stripeClient.customers.updateSource(stripeCustomerId, stripeId, update2).then(() => card).catch((error) => {
+      console.log("payments::updateCard::error", error);
+      throw new import_graphql_errors.UserError("payment_error");
+    });
+  });
+};
+const getCreditCards = (context) => {
+  const action = "getCreditCards";
+  const { database, session: { userId: sessionId } } = context;
+  const aqlQry = import_arangojs.aql`FOR c IN creditCards
+    FILTER c.userId == ${sessionId}
+    RETURN c`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).then((list = []) => list).catch((error) => (0, import_analytics.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => null));
+};
+const deleteCreditCard = (context, cardId) => {
+  const { database, session: { userId: sessionId } } = context;
+  const formatCardId = (0, import_utils.parseId)(cardId);
+  const aqlQry = import_arangojs.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 database.query(aqlQry).then((cursor) => cursor.next()).then((result = { card: {}, user: {} }) => {
+    if ((0, import_isEmpty.default)(result)) {
+      return false;
+    }
+    const { card, user } = result;
+    const { _key: cardKey } = card;
+    const edgeCollection = database.collection("hasPayment");
+    return edgeCollection.outEdges(cardKey).then((edges) => {
+      if (edges.length) {
+        return Promise.all(edges.map((edge) => {
+          const { _key: edgeKey } = edge;
+          const removeAqlQry = import_arangojs.aql`REMOVE {_key:${edgeKey}} IN hasPayment`;
+          return database.query(removeAqlQry);
+        })).then(() => {
+          const stripeClient = new import_stripe.default(import_config.Config.get("stripe.token"), { apiVersion, typescript: true });
+          return stripeClient.customers.deleteSource(user.stripeCustomerId, card.stripeId).then(() => true).catch((error) => {
+            console.log("payments::deleteCard::error", error);
+            throw new import_graphql_errors.UserError("payment_error");
+          });
+        });
+      }
+      return false;
+    });
+  });
+};
+const deleteBankAccount = (context, bankId) => {
+  const { database, session: { userId: sessionId } } = context;
+  const update = {
+    bankAccount: "",
+    bankFullName: "",
+    bankId: "",
+    bankRouting: "",
+    modified: Date.now()
+  };
+  const aqlQry = import_arangojs.aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;
+  return database.query(aqlQry).then((cursor) => cursor.next()).then((user = {}) => {
+    const { stripeAccountId } = user;
+    const stripeClient = new import_stripe.default(import_config.Config.get("stripe.token"), { apiVersion, typescript: true });
+    return stripeClient.customers.deleteSource(stripeAccountId, bankId).then((response = { deleted: false }) => response.deleted).catch(() => Promise.resolve(false));
+  });
+};
+const createPaymentTransfer = (context, transfer) => {
+  const { database, session: { userId: sessionId } } = context;
+  const { amount, currency } = transfer;
+  const formatAmount = (0, import_utils.parseNum)(amount);
+  const formatCurrency = (0, import_utils.parseChar)(currency, 3, "USD").toUpperCase();
+  return (0, import_users.getUser)(context, sessionId).then((user) => {
+    const { stripeAccountId } = user;
+    const stripeClient = new import_stripe.default(import_config.Config.get("stripe.token"), { apiVersion, typescript: true });
+    return stripeClient.transfers.create({
+      amount: formatAmount,
+      currency: formatCurrency,
+      destination: stripeAccountId
+    }).then((stripeTransfer) => {
+      console.log(stripeTransfer);
+      const now = Date.now();
+      const insert = {
+        added: now,
+        amount: formatAmount,
+        currency: formatCurrency,
+        modified: now,
+        userId: sessionId
+      };
+      const aqlQry = import_arangojs.aql`INSERT ${insert} IN transfers RETURN NEW`;
+      return database.query(aqlQry).then((cursor) => cursor.next()).then((newTransfer) => newTransfer);
+    });
+  });
+};
+const createPaymentHold = (context, payment) => {
+  const { database, session: { userId: sessionId } } = context;
+  const { amount, capture, cardId, currency, description } = payment;
+  const formatCurrency = (0, import_utils.parseChar)(currency, 3, "USD").toUpperCase();
+  const stripeClient = new import_stripe.default(import_config.Config.get("stripe.token"), { apiVersion, typescript: true });
+  return stripeClient.charges.create({
+    amount,
+    capture,
+    currency: formatCurrency,
+    description,
+    source: cardId
+  }).then((stripeCharge) => {
+    const now = Date.now();
+    const insert = {
+      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 = import_arangojs.aql`INSERT ${insert} IN payments RETURN NEW`;
+    return database.query(aqlQry).then((cursor) => cursor.next()).then((newPayment) => newPayment);
+  }).catch((error) => {
+    console.log("payments::createHold::error", error);
+    throw new import_graphql_errors.UserError("payment_error");
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addBankAccount,
+  addCreditCard,
+  addCustomerAccount,
+  createPaymentHold,
+  createPaymentTransfer,
+  deleteBankAccount,
+  deleteCreditCard,
+  getCreditCards,
+  updateCreditCard
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/actions/payments.ts"],
  "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, parseChar, parseId, parseNum, parseString, parseVarChar} from '@nlabs/utils';\nimport {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport {EdgeCollection} from 'arangojs/collection';\nimport {ArrayCursor} from 'arangojs/cursor';\nimport {UserError} from 'graphql-errors';\nimport isEmpty from 'lodash/isEmpty';\nimport Stripe from 'stripe';\n\nimport {Config} from '../config';\nimport {ApiContext, PaymentBankAccount, PaymentCardType, PaymentCharge, PaymentTransfer, User} from '../types';\nimport {logError} from '../utils/analytics';\nimport {getUser} from './users';\n\nconst eventCategory: string = 'payments';\nconst apiVersion: any = '2020-03-02';\n\nexport const addCustomerAccount = (context: ApiContext): Promise<boolean> => {\n  const action: string = 'addCustomerAccount';\n  const {database, session: {userId: sessionId, username}} = context;\n\n  // Stripe\n  const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n\n  return stripeClient.customers\n    .create({\n      metadata: {\n        userId: sessionId,\n        username\n      }\n    })\n    .then((customer) => {\n      // Create session\n      const now: number = Date.now();\n      const update: User = {\n        modified: now,\n        stripeCustomerId: customer.id\n      };\n\n      const aqlQry: AqlQuery = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;\n\n      return database.query(aqlQry)\n        .then((cursor: ArrayCursor) => cursor.next())\n        .then((updatedUser: User = {}) => !isEmpty(updatedUser))\n        .catch((error: Error) => logError({\n          action,\n          category: eventCategory,\n          label: 'db_error'\n        }, error, context).then(() => null));\n    });\n};\n\nexport const addBankAccount = (context: ApiContext, bankAccount: PaymentBankAccount): Promise<boolean> => {\n  const action: string = 'addPaymentAccountBank';\n  const {database, session: {userId: sessionId}} = context;\n\n  // Params\n  const {\n    accountNumber,\n    fullName,\n    routing\n  } = bankAccount;\n\n  const formatAccount: string = parseString(accountNumber, 32);\n\n  if(formatAccount === '') {\n    throw new UserError('required_account_number');\n  }\n\n  const formatFullName: string = parseVarChar(fullName, 128);\n\n  if(formatFullName === '') {\n    throw new UserError('required_full_name');\n  }\n\n  const formatRouting: string = parseString(routing, 32);\n\n  if(formatRouting === '') {\n    throw new UserError('required_routing_number');\n  }\n\n  return getUser(context, sessionId)\n    .then((user: User) => {\n      const {stripeAccountId}: User = user;\n\n      // Stripe\n      const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n      const source: any = {\n        account_holder_name: formatFullName,\n        account_holder_type: 'individual',\n        account_number: formatAccount,\n        country: 'US',\n        currency: 'USD',\n        object: 'bank_account',\n        routing_number: formatRouting\n      };\n\n      return stripeClient.customers\n        .createSource(stripeAccountId, {source})\n        .then((account: any) => {\n          const {id: bankId, last4: bankAccount, routing_number: bankRouting} = account;\n          const update: any = {\n            bankAccount,\n            bankFullName: formatFullName,\n            bankId,\n            bankRouting,\n            modified: Date.now()\n          };\n\n          const aqlQry: AqlQuery = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;\n\n          return database.query(aqlQry)\n            .then((cursor: ArrayCursor) => cursor.next())\n            .then((updatedUser: User = {}) => updatedUser);\n        })\n        .catch((error: Error) => {\n          const msg = error.message;\n\n          if(msg === 'A bank account with that routing number and account number ' +\n            'already exists for this customer.') {\n            return logError({\n              action,\n              category: eventCategory,\n              label: 'bank_account_exists'\n            }, error, context).then(() => null);\n          }\n          return logError({\n            action,\n            category: eventCategory,\n            label: 'payment_error'\n          }, error, context).then(() => null);\n        });\n    });\n};\n\nexport const addCreditCard = (context: ApiContext, card: PaymentCardType): Promise<User> => {\n  const action: string = 'addCreditCard';\n  const {database, session: {userId: sessionId}} = context;\n\n  return getUser(context, sessionId)\n    .then((user: User) => {\n      // User\n      const {stripeAccountId}: User = user;\n\n      // Card\n      const {\n        accountNumber,\n        city,\n        country,\n        cvc,\n        expMonth,\n        expYear,\n        fullName,\n        street1,\n        street2,\n        state,\n        zip\n      }: PaymentCardType = card;\n\n      const formatNumber: number = parseNum(accountNumber, 16);\n\n      if(!formatNumber) {\n        throw new UserError('required_credit_card_number');\n      }\n\n      const formatExpMonth: number = parseNum(expMonth, 2);\n\n      if(!formatExpMonth) {\n        throw new UserError('required_credit_card_exp_month');\n      }\n\n      const formatExpYear: number = parseNum(expYear, 2);\n\n      if(!formatExpYear) {\n        throw new UserError('required_credit_card_exp_year');\n      }\n\n      const formatCvc: number = parseNum(cvc, 3);\n\n      // Address\n      const paymentCard: PaymentCardType = {};\n      const formatCity: string = parseVarChar(city, 32);\n\n      if(formatCity) {\n        paymentCard.city = formatCity;\n      }\n\n      const formatCountry: string = parseChar(country, 2);\n\n      if(formatCountry) {\n        paymentCard.country = formatCountry;\n      }\n\n      const formatFullName: string = parseVarChar(fullName, 32);\n\n      if(formatFullName) {\n        paymentCard.fullName = formatFullName;\n      }\n\n      const formatStreet1: string = parseVarChar(street1, 32);\n\n      if(formatStreet1) {\n        paymentCard.street1 = formatStreet1;\n      }\n\n      const formatStreet2: string = parseVarChar(street2, 32);\n\n      if(formatStreet2) {\n        paymentCard.street2 = formatStreet2;\n      }\n\n      const formatState: string = parseChar(state, 2);\n\n      if(formatState) {\n        paymentCard.state = formatState;\n      }\n\n      const formatZip: string = parseVarChar(zip, 10);\n\n      if(formatZip) {\n        paymentCard.zip = formatZip;\n      }\n\n      // Stripe\n      const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n      const source: any = {\n        address_city: formatCity,\n        address_country: formatCountry,\n        address_line1: formatStreet1,\n        address_line2: formatStreet2,\n        address_state: formatState,\n        address_zip: formatZip,\n        cvc: formatCvc,\n        exp_month: formatExpMonth,\n        exp_year: formatExpYear,\n        name: fullName,\n        number: formatNumber,\n        object: 'card'\n      };\n\n      return stripeClient.customers\n        .createSource(stripeAccountId, {source})\n        .then((newSource: any) => {\n          const {brand, cvc_check: cvcCheck, last4} = newSource;\n\n          // Create session\n          const now: number = Date.now();\n          const insert = {\n            ...paymentCard,\n            _key: createHash(`user-payment-${sessionId}`),\n            accountNumber: last4,\n            added: now,\n            brand,\n            cvcCheck,\n            expMonth,\n            expYear,\n            modified: now,\n            userId: sessionId\n          };\n          const insertAqlQry: AqlQuery = aql`INSERT ${insert} IN creditCards RETURN NEW`;\n\n          return database.query(insertAqlQry)\n            .then((cursor: ArrayCursor) => cursor.next())\n            .then((newCard: PaymentCardType = {}) => {\n              if(!isEmpty(newCard)) {\n                // Add linked edge\n                const {_id: cardId, _key: cardKey} = card;\n                const edgeCollection: EdgeCollection = database.collection('hasPayment');\n                const edgeId = createHash(`payment-${cardKey}`);\n                const edge: any = {\n                  _from: `users/${sessionId}`,\n                  _key: edgeId,\n                  _to: cardId\n                };\n\n                return edgeCollection.save(edge, {returnNew: true}).then(() => card);\n              }\n\n              return newCard;\n            })\n            .catch((error: Error) => logError({\n              action,\n              category: eventCategory,\n              label: 'payment_error'\n            }, error, context).then(() => null));\n        });\n    });\n};\n\nexport const updateCreditCard = (context: ApiContext, card: PaymentCardType): Promise<PaymentCardType> => {\n  const {database, session: {userId: sessionId}} = context;\n\n  const {\n    city,\n    country,\n    expMonth,\n    expYear,\n    fullName,\n    id,\n    street1,\n    state,\n    zip\n  }: PaymentCardType = card;\n\n  const formatId: string = parseId(id);\n\n  if(formatId) {\n    throw new UserError('required_credit_card_id');\n  }\n\n  const paymentCard: PaymentCardType = {};\n  const formatExpMonth: number = parseNum(expMonth, 2);\n  const formatExpYear: number = parseNum(expYear, 2);\n  const formatCity: string = parseVarChar(city, 32);\n  const formatCountry: string = parseChar(country, 2);\n  const formatFullName: string = parseVarChar(fullName, 32);\n  const formatStreet1: string = parseString(street1, 32);\n  const formatState: string = parseChar(state, 2);\n  const formatZip: string = parseVarChar(zip, 10);\n\n  if(formatExpMonth) {\n    paymentCard.expMonth = formatExpMonth;\n  }\n\n  if(formatExpYear) {\n    paymentCard.expYear = formatExpYear;\n  }\n\n  if(formatCity) {\n    paymentCard.city = formatCity;\n  }\n\n  if(formatCountry) {\n    paymentCard.country = formatCountry;\n  }\n\n  if(formatFullName) {\n    paymentCard.fullName = formatFullName;\n  }\n\n  if(formatStreet1) {\n    paymentCard.street1 = formatStreet1;\n  }\n\n  if(formatState) {\n    paymentCard.state = formatState;\n  }\n\n  if(formatZip) {\n    paymentCard.zip = formatZip;\n  }\n\n  const update: any = paymentCard;\n  const aqlQry: AqlQuery = aql`\n      LET updatedCard = FIRST(\n        FOR c IN creditCards\n        FILTER c._key == ${formatId} && c.userId == ${sessionId}\n        UPDATE c WITH ${update} IN creditCards\n        LIMIT 1\n        RETURN NEW\n      )\n      LET user = FIRST(\n        FOR u IN users\n        FILTER u._key == ${sessionId}\n        LIMIT 1\n        RETURN u\n      )\n      RETURN {user: user, card: updatedCard}`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((results = {card: {}, user: {}}) => {\n      const updatedCard: PaymentCardType = results.card;\n      const {user} = results;\n\n      if(isEmpty(updatedCard)) {\n        throw new UserError('not_found');\n      }\n\n      const {stripeCustomerId} = user;\n      const {stripeId} = card;\n\n      // Stripe\n      const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n      const update: any = {\n        address_city: formatCity,\n        address_country: formatCountry,\n        address_line1: formatStreet1,\n        address_state: formatState,\n        address_zip: formatZip,\n        exp_month: formatExpMonth,\n        exp_year: formatExpYear,\n        name: formatFullName\n      };\n\n      return stripeClient.customers\n        .updateSource(stripeCustomerId, stripeId, update)\n        .then(() => card)\n        .catch((error: Error) => {\n          console.log('payments::updateCard::error', error);\n          throw new UserError('payment_error');\n        });\n    });\n};\n\nexport const getCreditCards = (context: ApiContext): Promise<PaymentCardType[]> => {\n  const action: string = 'getCreditCards';\n  const {database, session: {userId: sessionId}} = context;\n  const aqlQry: AqlQuery = aql`FOR c IN creditCards\n    FILTER c.userId == ${sessionId}\n    RETURN c`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .then((list: PaymentCardType[] = []) => list)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const deleteCreditCard = (context: ApiContext, cardId: string): Promise<boolean> => {\n  const {database, session: {userId: sessionId}} = context;\n  const formatCardId: string = parseId(cardId);\n  const aqlQry: AqlQuery = aql`\n    LET card = FIRST(\n      FOR c IN creditCards\n      FILTER c._key == ${formatCardId} && c.userId == ${sessionId}\n      LIMIT 1\n      REMOVE c IN creditCards\n      RETURN OLD\n    )\n    LET user = FIRST(\n      FOR u IN users\n      FILTER u._key == ${sessionId}\n      LIMIT 1\n      RETURN u\n    )\n    RETURN {user: user, card: card}`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((result = {card: {}, user: {}}) => {\n      if(isEmpty(result)) {\n        return false;\n      }\n\n      const {card, user} = result;\n      const {_key: cardKey} = card;\n\n      // Remove linked edges\n      const edgeCollection = database.collection('hasPayment');\n\n      return edgeCollection.outEdges(cardKey)\n        .then((edges: any) => {\n          if(edges.length) {\n            return Promise.all(\n              edges.map((edge) => {\n                const {_key: edgeKey} = edge;\n                const removeAqlQry: AqlQuery = aql`REMOVE {_key:${edgeKey}} IN hasPayment`;\n                return database.query(removeAqlQry);\n              }))\n              .then(() => {\n                // Stripe\n                const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n\n                return stripeClient.customers\n                  .deleteSource(user.stripeCustomerId, card.stripeId)\n                  .then(() => true)\n                  .catch((error: Error) => {\n                    console.log('payments::deleteCard::error', error);\n                    throw new UserError('payment_error');\n                  });\n              });\n          }\n\n          return false;\n        });\n    });\n};\n\nexport const deleteBankAccount = (context: ApiContext, bankId: string): Promise<boolean> => {\n  const {database, session: {userId: sessionId}} = context;\n\n  // Clean db\n  const update: User = {\n    bankAccount: '',\n    bankFullName: '',\n    bankId: '',\n    bankRouting: '',\n    modified: Date.now()\n  };\n  const aqlQry: AqlQuery = aql`UPDATE ${sessionId} WITH ${update} IN users LIMIT 1 RETURN NEW`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((user: User = {}) => {\n      const {stripeAccountId} = user;\n\n      // Stripe\n      const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n\n      return stripeClient.customers\n        .deleteSource(stripeAccountId, bankId)\n        .then((response: any = {deleted: false}) => response.deleted)\n        .catch(() => Promise.resolve(false));\n    });\n};\n\nexport const createPaymentTransfer = (context: ApiContext, transfer: PaymentTransfer): Promise<PaymentTransfer> => {\n  const {database, session: {userId: sessionId}} = context;\n  const {amount, currency} = transfer;\n  const formatAmount: number = parseNum(amount);\n  const formatCurrency: string = parseChar(currency, 3, 'USD').toUpperCase();\n\n  return getUser(context, sessionId)\n    .then((user: User) => {\n      const {stripeAccountId} = user;\n\n      // Stripe\n      const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n\n      return stripeClient.transfers\n        .create({\n          amount: formatAmount,\n          currency: formatCurrency,\n          destination: stripeAccountId\n        })\n        .then((stripeTransfer) => {\n          console.log(stripeTransfer);\n          const now: number = Date.now();\n          const insert: PaymentTransfer = {\n            added: now,\n            amount: formatAmount,\n            currency: formatCurrency,\n            modified: now,\n            userId: sessionId\n          };\n          const aqlQry: AqlQuery = aql`INSERT ${insert} IN transfers RETURN NEW`;\n\n          return database.query(aqlQry)\n            .then((cursor: ArrayCursor) => cursor.next())\n            .then((newTransfer: PaymentTransfer) => newTransfer);\n        });\n    });\n};\n\nexport const createPaymentHold = (context: ApiContext, payment: PaymentCharge): Promise<PaymentCharge> => {\n  const {database, session: {userId: sessionId}} = context;\n  const {amount, capture, cardId, currency, description} = payment;\n  const formatCurrency = parseChar(currency, 3, 'USD').toUpperCase();\n\n  const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n\n  return stripeClient.charges\n    .create({\n      amount,\n      capture,\n      currency: formatCurrency,\n      description,\n      source: cardId\n    })\n    .then((stripeCharge) => {\n      const now: number = Date.now();\n      const insert: PaymentCharge = {\n        added: now,\n        amount,\n        capture,\n        cardId,\n        chargeFailCode: stripeCharge.failure_code,\n        chargeFailMsg: stripeCharge.failure_message,\n        chargeId: stripeCharge.id,\n        chargeStatus: stripeCharge.status,\n        currency: formatCurrency,\n        description,\n        modified: now,\n        userId: sessionId\n      };\n      const aqlQry: AqlQuery = aql`INSERT ${insert} IN payments RETURN NEW`;\n\n      return database.query(aqlQry)\n        .then((cursor: ArrayCursor) => cursor.next())\n        .then((newPayment: PaymentCharge) => newPayment);\n    })\n    .catch((error: Error) => {\n      console.log('payments::createHold::error', error);\n      throw new UserError('payment_error');\n    });\n};\n"],
  "mappings": "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",
  "names": []
}


package/lib/actions/posts.d.ts

@@ -0,0 +1,19 @@
+import { Database } from 'arangojs';
+import { ApiContext, FileType, PostInputType, PostOptions, PostType } from '../types';
+export declare const parsePostOptions: (options?: PostOptions) => {
+    latitude: number;
+    limit: import("../types").ArangoDBLimit;
+    longitude: number;
+    type: string;
+};
+export declare const getPostOptional: (fields: string[], sessionId: string) => any;
+export declare const getPost: (context: ApiContext, itemId: string, options: PostOptions) => Promise<Partial<PostType>>;
+export declare const getPostsByReactions: (context: ApiContext, reactions?: string[], options?: PostOptions) => Promise<PostType[]>;
+export declare const getPostsByTags: (context: ApiContext, tags?: string[], options?: PostOptions) => Promise<PostType[]>;
+export declare const getPostsByUser: (context: ApiContext, userId: string, options?: PostOptions) => Promise<PostType[]>;
+export declare const getPostComments: (context: ApiContext, itemId: string, options?: PostOptions) => Promise<PostType[]>;
+export declare const addPost: (context: ApiContext, post: PostInputType) => Promise<PostType>;
+export declare const updatePost: (context: ApiContext, post: PostInputType) => Promise<PostType>;
+export declare const deletePost: (context: ApiContext, postId: string) => Promise<PostType>;
+export declare const cleanPosts: (database: Database) => Promise<number>;
+export declare const createPostEdge: (db: Database, file: FileType, postId: string) => Promise<FileType>;