@nlabs/reaktor 0.3.0 → 0.4.0

package/lib/data/subscription.js

@@ -0,0 +1,337 @@
+"use strict";
+
+require("core-js/modules/es.symbol");
+
+require("core-js/modules/es.symbol.description");
+
+require("core-js/modules/es.array.slice");
+
+require("core-js/modules/es.date.now");
+
+require("core-js/modules/es.date.to-string");
+
+require("core-js/modules/es.function.name");
+
+require("core-js/modules/es.object.define-properties");
+
+require("core-js/modules/es.object.freeze");
+
+require("core-js/modules/es.object.to-string");
+
+require("core-js/modules/es.promise");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deleteSubscription = exports.addSubscription = exports.addPlan = exports.getSubscription = exports.getPlanList = void 0;
+
+var _utils = require("@nlabs/utils");
+
+var _arangojs = require("arangojs");
+
+var _luxon = require("luxon");
+
+var _stripe = _interopRequireDefault(require("stripe"));
+
+var _config = require("../config");
+
+var _utils2 = require("../utils");
+
+var _users = require("./users");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _templateObject3() {
+  var data = _taggedTemplateLiteral(["UPDATE s WITH ", " IN subscriptions"]);
+
+  _templateObject3 = function _templateObject3() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject2() {
+  var data = _taggedTemplateLiteral(["INSERT ", " IN plans RETURN NEW"]);
+
+  _templateObject2 = function _templateObject2() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject() {
+  var data = _taggedTemplateLiteral(["INSERT ", " IN plans RETURN NEW"]);
+
+  _templateObject = function _templateObject() {
+    return data;
+  };
+
+  return data;
+}
+
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+
+var eventCategory = 'subscription';
+var apiVersion = '2020-03-02';
+
+var getPlanList = function getPlanList(context) {
+  var from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var to = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 30;
+  var action = 'getList';
+  var database = context.database;
+  var limit = (0, _utils2.getLimit)(from, to);
+  var aqlQry = "FOR p IN plans\n      ".concat(limit.aql, "\n      SORT p.amount\n      RETURN p");
+  return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.all();
+  }).then(function () {
+    var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    return list;
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, {}).then(function () {
+      return null;
+    })["catch"](function (error) {
+      return Promise.reject(error);
+    });
+  });
+};
+
+exports.getPlanList = getPlanList;
+
+var getSubscription = function getSubscription(context) {
+  var action = 'getItem';
+  var database = context.database,
+      sessionId = context.userId;
+  var aqlQry = "FOR s IN subscriptions\n      FILTER s.userId == ".concat(sessionId, " && s.cancelled > 0\n      LET plan = FIRST(\n        FOR p IN plans\n        FILTER p._key == s.planId\n      )\n      LIMIT 1\n      RETURN MERGE(s, {plan: plan})");
+  return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  }).then(function () {
+    var subscription = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return subscription;
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, {}).then(function () {
+      return null;
+    })["catch"](function (error) {
+      return Promise.reject(error);
+    });
+  });
+};
+
+exports.getSubscription = getSubscription;
+
+var addPlan = function addPlan(context, item) {
+  var action = 'addPlan';
+  var database = context.database,
+      sessionId = context.userId,
+      userAccess = context.userAccess;
+  var isAdmin = userAccess > 2;
+
+  if (!isAdmin) {
+    return (0, _utils2.logException)({
+      action: action,
+      category: eventCategory,
+      label: 'unauthorized',
+      value: 'invalid_session'
+    }, context).then(function () {
+      return null;
+    });
+  }
+
+  var now = Date.now();
+  var formatId = (0, _utils.parseId)(item.id);
+  var planId = formatId === '' ? (0, _utils.createHash)("tag-".concat(sessionId)) : formatId;
+  var amount = item.amount,
+      _item$currency = item.currency,
+      currency = _item$currency === void 0 ? 'USD' : _item$currency,
+      description = item.description,
+      interval = item.interval,
+      intervalCount = item.intervalCount,
+      name = item.name;
+  var formatAmount = (0, _utils.parseNum)(amount);
+  var formatInterval = (0, _utils.parseChar)(interval, 5).toLowerCase();
+  var formatIntervalCnt = (0, _utils.parseNum)(intervalCount, 5);
+  var formatName = (0, _utils.parseVarChar)(name, 32);
+  var formatDesc = (0, _utils.parseVarChar)(description, 32);
+  var insert = {
+    _key: planId,
+    added: now,
+    amount: formatAmount,
+    currency: currency,
+    description: formatDesc,
+    interval: formatInterval,
+    intervalCount: formatIntervalCnt,
+    modified: now,
+    name: formatName
+  };
+  var aqlQry = (0, _arangojs.aql)(_templateObject(), insert);
+  return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  }).then(function () {
+    var plan = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    // Stripe
+    var stripeClient = new _stripe["default"](_config.Config.get('stripe.token'), {
+      apiVersion: apiVersion,
+      typescript: true
+    });
+    var stripePlan = {
+      amount: formatAmount * 100,
+      currency: currency,
+      id: planId,
+      interval: formatInterval,
+      interval_count: formatIntervalCnt,
+      metadata: {},
+      name: formatName,
+      statement_descriptor: formatDesc
+    };
+    return stripeClient.plans.create(stripePlan).then(function () {
+      return plan;
+    });
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, {}).then(function () {
+      return null;
+    })["catch"](function (error) {
+      return Promise.reject(error);
+    });
+  });
+};
+
+exports.addPlan = addPlan;
+
+var addSubscription = function addSubscription(context, item) {
+  var action = 'addSubscription';
+  var database = context.database,
+      sessionId = context.userId,
+      userAccess = context.userAccess;
+  var isAdmin = userAccess > 2;
+
+  if (!isAdmin) {
+    return (0, _utils2.logException)({
+      action: action,
+      category: eventCategory,
+      label: 'unauthorized',
+      value: 'invalid_session'
+    }, context).then(function () {
+      return null;
+    });
+  }
+
+  var now = Date.now();
+  var formatId = (0, _utils.parseId)(item.id);
+  var subscriptionId = formatId === '' ? (0, _utils.createHash)("tag-".concat(sessionId)) : formatId;
+  var planId = item.planId,
+      trialEnd = item.trialEnd,
+      trialPeriod = item.trialPeriod;
+  var formatPlanId = (0, _utils.parseId)(planId);
+  var formatTrialPeriod = 0;
+  var formatTrialEnd = trialEnd || Date.now();
+
+  if (formatTrialPeriod) {
+    formatTrialEnd = _luxon.DateTime.local().plus({
+      days: trialPeriod
+    }).toMillis();
+  }
+
+  return (0, _users.getUser)(context, sessionId).then(function (user) {
+    var insert = {
+      _key: subscriptionId,
+      added: now,
+      cancelDate: 0,
+      modified: now,
+      planId: formatPlanId,
+      trialEnd: formatTrialEnd,
+      userId: sessionId
+    };
+    var aqlQry = (0, _arangojs.aql)(_templateObject2(), insert);
+    return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+      return cursor.next();
+    }).then(function () {
+      var subscription = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      // Stripe
+      var stripeClient = new _stripe["default"](_config.Config.get('stripe.token'), {
+        apiVersion: apiVersion,
+        typescript: true
+      });
+      return stripeClient.subscriptions.create({
+        customer: user.stripeCustomerId,
+        items: [{
+          plan: formatPlanId
+        }],
+        metadata: {
+          userId: sessionId
+        },
+        trial_end: formatTrialEnd
+      }).then(function () {
+        return subscription;
+      });
+    })["catch"](function (error) {
+      return (0, _utils2.logError)({
+        action: action,
+        category: eventCategory,
+        label: 'db_error'
+      }, error, {}).then(function () {
+        return null;
+      })["catch"](function (error) {
+        return Promise.reject(error);
+      });
+    });
+  });
+};
+
+exports.addSubscription = addSubscription;
+
+var deleteSubscription = function deleteSubscription(context) {
+  var action = 'deleteSubscription';
+  var database = context.database;
+  var now = Date.now();
+  return getSubscription(context).then(function (subscription) {
+    // Stripe
+    var stripeClient = new _stripe["default"](_config.Config.get('stripe.token'), {
+      apiVersion: apiVersion,
+      typescript: true
+    });
+    return stripeClient.subscriptions.del(subscription.transactionId).then(function (_ref) {
+      var cancelDate = _ref.canceled_at;
+
+      // Make sure we cancelled on Stripe before updating the db
+      if (cancelDate) {
+        var update = {
+          cancelDate: cancelDate,
+          modified: now,
+          planId: ''
+        };
+        var aqlQry = (0, _arangojs.aql)(_templateObject3(), update);
+        return (0, _utils2.useDb)(database).query(aqlQry).then(function () {
+          return true;
+        })["catch"](function (error) {
+          return (0, _utils2.logError)({
+            action: action,
+            category: eventCategory,
+            label: 'db_error'
+          }, error, {}).then(function () {
+            return null;
+          })["catch"](function (error) {
+            return Promise.reject(error);
+          });
+        });
+      }
+
+      return false;
+    });
+  });
+};
+
+exports.deleteSubscription = deleteSubscription;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/data/subscription.ts"],"names":["eventCategory","apiVersion","getPlanList","context","from","to","action","database","limit","aqlQry","aql","query","then","cursor","all","list","error","category","label","Promise","reject","getSubscription","sessionId","userId","next","subscription","addPlan","item","userAccess","isAdmin","value","now","Date","formatId","id","planId","amount","currency","description","interval","intervalCount","name","formatAmount","formatInterval","toLowerCase","formatIntervalCnt","formatName","formatDesc","insert","_key","added","modified","plan","stripeClient","Stripe","Config","get","typescript","stripePlan","interval_count","metadata","statement_descriptor","plans","create","addSubscription","subscriptionId","trialEnd","trialPeriod","formatPlanId","formatTrialPeriod","formatTrialEnd","DateTime","local","plus","days","toMillis","user","cancelDate","subscriptions","customer","stripeCustomerId","items","trial_end","deleteSubscription","del","transactionId","canceled_at","update"],"mappings":"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","sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {createHash, parseChar, parseId, parseNum, parseVarChar} from '@nlabs/utils';\nimport {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport {ArrayCursor} from 'arangojs/cursor';\nimport {DateTime} from 'luxon';\nimport Stripe from 'stripe';\n\nimport {Config} from '../config';\nimport {ArangoDBLimit} from '../types/arangodb';\nimport {ApiContext} from '../types/auth';\nimport {PaymentInterval, PaymentPlan, PaymentSubscription} from '../types/payments';\nimport {getLimit, logError, logException, useDb} from '../utils';\nimport {getUser} from './users';\n\nconst eventCategory: string = 'subscription';\nconst apiVersion: any = '2020-03-02';\n\nexport const getPlanList = (context: ApiContext, from: number = 0, to: number = 30): Promise<PaymentPlan[]> => {\n  const action: string = 'getList';\n  const {database} = context;\n  const limit: ArangoDBLimit = getLimit(from, to);\n  const aqlQry: string = `FOR p IN plans\n      ${limit.aql}\n      SORT p.amount\n      RETURN p`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .then((list = []) => list)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, {}).then(() => null).catch((error) => Promise.reject(error)));\n};\n\nexport const getSubscription = (context: ApiContext): Promise<PaymentSubscription> => {\n  const action: string = 'getItem';\n  const {database, userId: sessionId} = context;\n  const aqlQry: string = `FOR s IN subscriptions\n      FILTER s.userId == ${sessionId} && s.cancelled > 0\n      LET plan = FIRST(\n        FOR p IN plans\n        FILTER p._key == s.planId\n      )\n      LIMIT 1\n      RETURN MERGE(s, {plan: plan})`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((subscription = {}) => subscription)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, {}).then(() => null).catch((error) => Promise.reject(error)));\n};\n\nexport const addPlan = (context: ApiContext, item: PaymentPlan): Promise<PaymentPlan> => {\n  const action: string = 'addPlan';\n  const {database, userId: sessionId, userAccess} = context;\n  const isAdmin: boolean = userAccess > 2;\n\n  if(!isAdmin) {\n    return logException({\n      action,\n      category: eventCategory,\n      label: 'unauthorized',\n      value: 'invalid_session'\n    }, context).then(() => null);\n  }\n\n  const now: number = Date.now();\n  const formatId: string = parseId(item.id);\n  const planId: string = formatId === '' ? createHash(`tag-${sessionId}`) : formatId;\n  const {amount, currency = 'USD', description, interval, intervalCount, name} = item;\n  const formatAmount: number = parseNum(amount);\n  const formatInterval: PaymentInterval = parseChar(interval, 5).toLowerCase() as PaymentInterval;\n  const formatIntervalCnt: number = parseNum(intervalCount, 5);\n  const formatName: string = parseVarChar(name, 32);\n  const formatDesc: string = parseVarChar(description, 32);\n\n  const insert: PaymentPlan = {\n    _key: planId,\n    added: now,\n    amount: formatAmount,\n    currency,\n    description: formatDesc,\n    interval: formatInterval,\n    intervalCount: formatIntervalCnt,\n    modified: now,\n    name: formatName\n  };\n  const aqlQry: AqlQuery = aql`INSERT ${insert} IN plans RETURN NEW`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((plan: PaymentPlan = {}) => {\n      // Stripe\n      const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n      const stripePlan: any = {\n        amount: formatAmount * 100,\n        currency,\n        id: planId,\n        interval: formatInterval,\n        interval_count: formatIntervalCnt,\n        metadata: {\n        },\n        name: formatName,\n        statement_descriptor: formatDesc\n      };\n\n      return stripeClient.plans\n        .create(stripePlan)\n        .then(() => plan);\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, {}).then(() => null).catch((error) => Promise.reject(error)));\n};\n\nexport const addSubscription = (context: ApiContext, item): Promise<PaymentSubscription> => {\n  const action: string = 'addSubscription';\n  const {database, userId: sessionId, userAccess} = context;\n  const isAdmin: boolean = userAccess > 2;\n\n  if(!isAdmin) {\n    return logException({\n      action,\n      category: eventCategory,\n      label: 'unauthorized',\n      value: 'invalid_session'\n    }, context).then(() => null);\n  }\n\n  const now: number = Date.now();\n  const formatId: string = parseId(item.id);\n  const subscriptionId: string = formatId === '' ? createHash(`tag-${sessionId}`) : formatId;\n  const {planId, trialEnd, trialPeriod} = item;\n  const formatPlanId: string = parseId(planId);\n  const formatTrialPeriod: number = 0;\n  let formatTrialEnd: number = trialEnd || Date.now();\n\n  if(formatTrialPeriod) {\n    formatTrialEnd = DateTime.local().plus({days: trialPeriod}).toMillis();\n  }\n\n  return getUser(context, sessionId)\n    .then((user) => {\n      const insert: PaymentSubscription = {\n        _key: subscriptionId,\n        added: now,\n        cancelDate: 0,\n        modified: now,\n        planId: formatPlanId,\n        trialEnd: formatTrialEnd,\n        userId: sessionId\n      };\n      const aqlQry: AqlQuery = aql`INSERT ${insert} IN plans RETURN NEW`;\n\n      return useDb(database).query(aqlQry)\n        .then((cursor: ArrayCursor) => cursor.next())\n        .then((subscription: PaymentSubscription = {}) => {\n          // Stripe\n          const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n          return stripeClient.subscriptions\n            .create({\n              customer: user.stripeCustomerId,\n              items: [\n                {\n                  plan: formatPlanId\n                }\n              ],\n              metadata: {\n                userId: sessionId\n              },\n              trial_end: formatTrialEnd\n            })\n            .then(() => subscription);\n        })\n        .catch((error: Error) => logError({\n          action,\n          category: eventCategory,\n          label: 'db_error'\n        }, error, {}).then(() => null).catch((error) => Promise.reject(error)));\n    });\n};\n\nexport const deleteSubscription = (context: ApiContext): Promise<boolean> => {\n  const action: string = 'deleteSubscription';\n  const {database} = context;\n  const now: number = Date.now();\n\n  return getSubscription(context)\n    .then((subscription) => {\n      // Stripe\n      const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion, typescript: true});\n      return stripeClient.subscriptions\n        .del(subscription.transactionId)\n        .then(({canceled_at: cancelDate}) => {\n          // Make sure we cancelled on Stripe before updating the db\n          if(cancelDate) {\n            const update: PaymentSubscription = {\n              cancelDate,\n              modified: now,\n              planId: ''\n            };\n            const aqlQry: AqlQuery = aql`UPDATE s WITH ${update} IN subscriptions`;\n\n            return useDb(database).query(aqlQry)\n              .then(() => true)\n              .catch((error: Error) => logError({\n                action,\n                category: eventCategory,\n                label: 'db_error'\n              }, error, {}).then(() => null).catch((error) => Promise.reject(error)));\n          }\n          return false;\n        });\n    });\n};\n"]}