@nlabs/reaktor 0.1.2 → 0.1.4

package/lib/data/subscription.js

@@ -0,0 +1,284 @@
+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) } })); }
+
+/**
+ * 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 { DateTime } from 'luxon';
+import * as stripe from 'stripe';
+import { Config } from '../config';
+import { getLimit, logError, logException, useDb } from '../utils';
+import { getUser } from './users';
+var eventCategory = 'subscription';
+export 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 = getLimit(from, to);
+  var aqlQry = "FOR p IN plans\n      ".concat(limit.aql, "\n      SORT p.amount\n      RETURN p");
+  return 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 logError({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, {}).then(function () {
+      return null;
+    }).catch(function (error) {
+      return Promise.reject(error);
+    });
+  });
+};
+export 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 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 logError({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, {}).then(function () {
+      return null;
+    }).catch(function (error) {
+      return Promise.reject(error);
+    });
+  });
+};
+export var addPlan = function addPlan(context, item) {
+  var action = 'addPlan';
+  var database = context.database,
+      sessionId = context.userId,
+      userType = context.userType;
+  var isAdmin = userType > 2;
+
+  if (!isAdmin) {
+    return logException({
+      action: action,
+      category: eventCategory,
+      label: 'unauthorized',
+      value: 'invalid_session'
+    }, context).then(function () {
+      return null;
+    });
+  }
+
+  var now = Date.now();
+  var formatId = parseId(item.id);
+  var planId = formatId === '' ? 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 = parseNum(amount);
+  var formatInterval = parseChar(interval, 5).toLowerCase();
+  var formatIntervalCnt = parseNum(intervalCount, 5);
+  var formatName = parseVarChar(name, 32);
+  var formatDesc = 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 = aql(_templateObject(), insert);
+  return 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 = stripe(Config.get('stripe.token'));
+    return stripeClient.plans.create({
+      amount: formatAmount * 100,
+      currency: currency,
+      id: planId,
+      interval: formatInterval,
+      interval_count: formatIntervalCnt,
+      metadata: {},
+      name: formatName,
+      statement_descriptor: formatDesc
+    }).then(function () {
+      return plan;
+    });
+  }).catch(function (error) {
+    return logError({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, {}).then(function () {
+      return null;
+    }).catch(function (error) {
+      return Promise.reject(error);
+    });
+  });
+};
+export var addSubscription = function addSubscription(context, item) {
+  var action = 'addSubscription';
+  var database = context.database,
+      sessionId = context.userId,
+      userType = context.userType;
+  var isAdmin = userType > 2;
+
+  if (!isAdmin) {
+    return logException({
+      action: action,
+      category: eventCategory,
+      label: 'unauthorized',
+      value: 'invalid_session'
+    }, context).then(function () {
+      return null;
+    });
+  }
+
+  var now = Date.now();
+  var formatId = parseId(item.id);
+  var subscriptionId = formatId === '' ? createHash("tag-".concat(sessionId)) : formatId;
+  var planId = item.planId,
+      tax = item.tax,
+      trialEnd = item.trialEnd,
+      trialPeriod = item.trialPeriod;
+  var formatPlanId = parseId(planId);
+  var formatTaxPercent = parseNum(tax) || 0;
+  var formatTrialPeriod = parseNum(tax) || 0;
+  var formatTrialEnd = trialEnd || Date.now();
+
+  if (formatTrialPeriod) {
+    formatTrialEnd = DateTime.local().plus({
+      days: trialPeriod
+    }).toMillis();
+  }
+
+  return getUser(context, sessionId).then(function (user) {
+    var insert = {
+      _key: subscriptionId,
+      added: now,
+      cancelDate: 0,
+      modified: now,
+      planId: formatPlanId,
+      tax: formatTaxPercent,
+      trialEnd: formatTrialEnd,
+      userId: sessionId
+    };
+    var aqlQry = aql(_templateObject2(), insert);
+    return 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 = 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(function () {
+        return subscription;
+      });
+    }).catch(function (error) {
+      return logError({
+        action: action,
+        category: eventCategory,
+        label: 'db_error'
+      }, error, {}).then(function () {
+        return null;
+      }).catch(function (error) {
+        return Promise.reject(error);
+      });
+    });
+  });
+};
+export var deleteSubscription = function deleteSubscription(context, endDate) {
+  var action = 'deleteSubscription';
+  var database = context.database;
+  var now = Date.now();
+  var formatEndDate = parseNum(endDate) || now;
+  return getSubscription(context).then(function (subscription) {
+    // Stripe
+    var stripeClient = stripe(Config.get('stripe.token'));
+    return stripeClient.subscriptions.del(subscription.transactionId, {
+      subscription: formatEndDate
+    }).then(function (stripeResponse) {
+      // Make sure we cancelled on Stripe before updating the db
+      if (stripeResponse.cancelled || stripeResponse.cancel_at_period_end) {
+        var update = {
+          cancelDate: formatEndDate,
+          modified: now,
+          planId: ''
+        };
+        var aqlQry = aql(_templateObject3(), update);
+        return useDb(database).query(aqlQry).then(function () {
+          return true;
+        }).catch(function (error) {
+          return logError({
+            action: action,
+            category: eventCategory,
+            label: 'db_error'
+          }, error, {}).then(function () {
+            return null;
+          }).catch(function (error) {
+            return Promise.reject(error);
+          });
+        });
+      }
+
+      return false;
+    });
+  });
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/data/subscription.ts"],"names":["createHash","parseChar","parseId","parseNum","parseVarChar","aql","DateTime","stripe","Config","getLimit","logError","logException","useDb","getUser","eventCategory","getPlanList","context","from","to","action","database","limit","aqlQry","query","then","cursor","all","list","catch","error","category","label","Promise","reject","getSubscription","sessionId","userId","next","subscription","addPlan","item","userType","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","get","plans","create","interval_count","metadata","statement_descriptor","addSubscription","subscriptionId","tax","trialEnd","trialPeriod","formatPlanId","formatTaxPercent","formatTrialPeriod","formatTrialEnd","local","plus","days","toMillis","user","cancelDate","subscriptions","customer","stripeCustomerId","items","tax_percent","trial_end","deleteSubscription","endDate","formatEndDate","del","transactionId","stripeResponse","cancelled","cancel_at_period_end","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/lib/cjs/aql-query';\nimport {ArrayCursor} from 'arangojs/lib/cjs/cursor';\nimport {DateTime} from 'luxon';\nimport * as 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';\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, userType} = context;\n  const isAdmin: boolean = userType > 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 = stripe(Config.get('stripe.token'));\n      return stripeClient.plans\n        .create({\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        .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, userType} = context;\n  const isAdmin: boolean = userType > 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, tax, trialEnd, trialPeriod} = item;\n  const formatPlanId: string = parseId(planId);\n  const formatTaxPercent: number = parseNum(tax) || 0;\n  const formatTrialPeriod: number = parseNum(tax) || 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        tax: formatTaxPercent,\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 = stripe(Config.get('stripe.token'));\n          return stripeClient.subscriptions\n            .create({\n              customer: user.stripeCustomerId,\n              items: [\n                {plan: formatPlanId}\n              ],\n              metadata: {\n                userId: sessionId\n              },\n              tax_percent: formatTaxPercent * 100,\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, endDate: number): Promise<boolean> => {\n  const action: string = 'deleteSubscription';\n  const {database} = context;\n  const now: number = Date.now();\n  const formatEndDate: number = parseNum(endDate) || now;\n\n  return getSubscription(context)\n    .then((subscription) => {\n      // Stripe\n      const stripeClient = stripe(Config.get('stripe.token'));\n      return stripeClient.subscriptions\n        .del(subscription.transactionId, {\n          subscription: formatEndDate\n        })\n        .then((stripeResponse) => {\n          // Make sure we cancelled on Stripe before updating the db\n          if(stripeResponse.cancelled || stripeResponse.cancel_at_period_end) {\n            const update: PaymentSubscription = {\n              cancelDate: formatEndDate,\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"]}

package/lib/data/tags.d.ts

@@ -0,0 +1,14 @@
+import { Database } from 'arangojs';
+import { ApiContext } from '../types/auth';
+import { PostType } from '../types/posts';
+import { TagType } from '../types/tags';
+export declare const getTagList: (context: ApiContext, from?: number, to?: number) => Promise<TagType[]>;
+export declare const getTag: (context: ApiContext, tagId: string) => Promise<TagType>;
+export declare const addTag: (context: ApiContext, tag: TagType) => Promise<TagType>;
+export declare const tagPost: (context: ApiContext, tagId: any, postId: any) => Promise<PostType>;
+export declare const updateTag: (context: ApiContext, item?: TagType) => Promise<TagType>;
+export declare const deleteTag: (context: ApiContext, tagId: string) => Promise<TagType>;
+export declare const extractTags: (db: Database, itemType: string, itemId: any, content: any) => Promise<TagType[]>;
+export declare const createTag: (db: Database, tagName: string) => Promise<TagType>;
+export declare const createTagEdge: (db: Database, tag: TagType, itemType: string, itemId: string) => Promise<TagType>;
+export declare const linkTags: (db: Database, tagNames: string[], itemType: string, itemId: string) => Promise<TagType[]>;