@nlabs/reaktor 0.10.5 → 0.10.7

package/lib/actions/search.js

@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { flatten } from '@nlabs/utils/arrays/flatten';
+import { uniqBy } from '@nlabs/utils/arrays/uniq';
+import { aql } from 'arangojs';
+import { ErrorTypes } from '../types/error.types.js';
+import { logException } from '../utils/analyticsUtils.js';
+import { getLimit, useDb } from '../utils/arangodbUtils.js';
+import { getDisplayName } from './users.js';
+const eventCategory = 'search';
+export const getSearchList = (context, query, from, to)=>{
+    const action = 'getList';
+    const { databaseName } = context;
+    const isString = true;
+    if (isString) {
+        const fields = [
+            {
+                collection: 'users',
+                field: 'first'
+            },
+            {
+                collection: 'users',
+                field: 'last'
+            },
+            {
+                collection: 'users',
+                field: 'email'
+            },
+            {
+                collection: 'users',
+                field: 'username'
+            },
+            {
+                collection: 'users',
+                field: 'name'
+            }
+        ];
+        return Promise.all(fields.map((obj)=>{
+            const qry = `prefix:${query}`;
+            const userQry = aql`FOR u IN FULLTEXT(${obj.collection}, ${obj.field}, ${qry}, 50) RETURN u`;
+            return useDb(databaseName).query(userQry).then((cursor)=>cursor.all());
+        })).then((results)=>{
+            const list = uniqBy(flatten(results), '_key');
+            return list.map((item)=>{
+                const { _id: itemId, name: itemName } = item || {};
+                const collectionIdList = itemId?.split('/') || [];
+                const collection = collectionIdList[0] || '';
+                const name = collection === 'users' ? getDisplayName(item) : itemName || '';
+                return {
+                    ...item,
+                    name
+                };
+            });
+        });
+    }
+    const limit = getLimit(from, to);
+    const aqlQry = `FOR u IN users
+        FILTER u.phone == "${query}"
+        ${limit.aql}
+        RETURN u`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).then((list = [])=>list.map((item)=>{
+            const { _id: itemId, name: itemName } = item;
+            const collectionIdList = itemId?.split('/') || [];
+            const collection = collectionIdList[0] || '';
+            const name = collection === 'users' ? getDisplayName(item) : itemName || '';
+            return {
+                ...item,
+                name
+            };
+        })).catch((error)=>{
+        throw logException({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR,
+            value: error.message
+        }, context);
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L3JlYWt0b3Ivc3JjL2FjdGlvbnMvc2VhcmNoLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29weXJpZ2h0IChjKSAyMDE5LVByZXNlbnQsIE5pdHJvZ2VuIExhYnMsIEluYy5cbiAqIENvcHlyaWdodHMgbGljZW5zZWQgdW5kZXIgdGhlIE1JVCBMaWNlbnNlLiBTZWUgdGhlIGFjY29tcGFueWluZyBMSUNFTlNFIGZpbGUgZm9yIHRlcm1zLlxuICovXG5pbXBvcnQge2ZsYXR0ZW59IGZyb20gJ0BubGFicy91dGlscy9hcnJheXMvZmxhdHRlbic7XG5pbXBvcnQge3VuaXFCeX0gZnJvbSAnQG5sYWJzL3V0aWxzL2FycmF5cy91bmlxJztcbmltcG9ydCB7YXFsfSBmcm9tICdhcmFuZ29qcyc7XG5cbmltcG9ydCB7RXJyb3JUeXBlc30gZnJvbSAnLi4vdHlwZXMvZXJyb3IudHlwZXMuanMnO1xuaW1wb3J0IHtsb2dFeGNlcHRpb259IGZyb20gJy4uL3V0aWxzL2FuYWx5dGljc1V0aWxzLmpzJztcbmltcG9ydCB7Z2V0TGltaXQsIHVzZURifSBmcm9tICcuLi91dGlscy9hcmFuZ29kYlV0aWxzLmpzJztcbmltcG9ydCB7Z2V0RGlzcGxheU5hbWV9IGZyb20gJy4vdXNlcnMuanMnO1xuXG5pbXBvcnQgdHlwZSB7QXFsUXVlcnl9IGZyb20gJ2FyYW5nb2pzL2FxbCc7XG5pbXBvcnQgdHlwZSB7QXJhbmdvRGJMaW1pdH0gZnJvbSAnLi4vdHlwZXMvYXJhbmdvZGIudHlwZXMuanMnO1xuaW1wb3J0IHR5cGUge0FwaUNvbnRleHR9IGZyb20gJy4uL3R5cGVzL2F1dGgudHlwZXMuanMnO1xuaW1wb3J0IHR5cGUge1VzZXJUeXBlfSBmcm9tICcuLi90eXBlcy91c2Vycy50eXBlcy5qcyc7XG5cbmNvbnN0IGV2ZW50Q2F0ZWdvcnk6IHN0cmluZyA9ICdzZWFyY2gnO1xuXG5leHBvcnQgY29uc3QgZ2V0U2VhcmNoTGlzdCA9IChjb250ZXh0OiBBcGlDb250ZXh0LCBxdWVyeTogc3RyaW5nLCBmcm9tOiBudW1iZXIsIHRvOiBudW1iZXIpOiBQcm9taXNlPFVzZXJUeXBlW10+ID0+IHtcbiAgY29uc3QgYWN0aW9uOiBzdHJpbmcgPSAnZ2V0TGlzdCc7XG4gIGNvbnN0IHtkYXRhYmFzZU5hbWV9ID0gY29udGV4dDtcbiAgY29uc3QgaXNTdHJpbmc6IGJvb2xlYW4gPSB0cnVlO1xuXG4gIGlmKGlzU3RyaW5nKSB7XG4gICAgY29uc3QgZmllbGRzOiB7Y29sbGVjdGlvbjogc3RyaW5nLCBmaWVsZDogc3RyaW5nfVtdID0gW1xuICAgICAge2NvbGxlY3Rpb246ICd1c2VycycsIGZpZWxkOiAnZmlyc3QnfSxcbiAgICAgIHtjb2xsZWN0aW9uOiAndXNlcnMnLCBmaWVsZDogJ2xhc3QnfSxcbiAgICAgIHtjb2xsZWN0aW9uOiAndXNlcnMnLCBmaWVsZDogJ2VtYWlsJ30sXG4gICAgICB7Y29sbGVjdGlvbjogJ3VzZXJzJywgZmllbGQ6ICd1c2VybmFtZSd9LFxuICAgICAge2NvbGxlY3Rpb246ICd1c2VycycsIGZpZWxkOiAnbmFtZSd9XG4gICAgXTtcblxuICAgIHJldHVybiBQcm9taXNlLmFsbChmaWVsZHMubWFwKChvYmopID0+IHtcbiAgICAgIGNvbnN0IHFyeTogc3RyaW5nID0gYHByZWZpeDoke3F1ZXJ5fWA7XG4gICAgICBjb25zdCB1c2VyUXJ5OiBBcWxRdWVyeSA9IGFxbGBGT1IgdSBJTiBGVUxMVEVYVCgke29iai5jb2xsZWN0aW9ufSwgJHtvYmouZmllbGR9LCAke3FyeX0sIDUwKSBSRVRVUk4gdWA7XG4gICAgICByZXR1cm4gdXNlRGIoZGF0YWJhc2VOYW1lKS5xdWVyeSh1c2VyUXJ5KS50aGVuKChjdXJzb3IpID0+IGN1cnNvci5hbGwoKSk7XG4gICAgfSkpXG4gICAgICAudGhlbigocmVzdWx0cykgPT4ge1xuICAgICAgICBjb25zdCBsaXN0ID0gdW5pcUJ5KGZsYXR0ZW4ocmVzdWx0cyksICdfa2V5JyBhcyBhbnkpO1xuXG4gICAgICAgIHJldHVybiBsaXN0Lm1hcCgoaXRlbTogYW55KSA9PiB7XG4gICAgICAgICAgY29uc3Qge19pZDogaXRlbUlkLCBuYW1lOiBpdGVtTmFtZX0gPSBpdGVtIHx8IHt9O1xuICAgICAgICAgIGNvbnN0IGNvbGxlY3Rpb25JZExpc3Q6IHN0cmluZ1tdID0gaXRlbUlkPy5zcGxpdCgnLycpIHx8IFtdO1xuICAgICAgICAgIGNvbnN0IGNvbGxlY3Rpb246IHN0cmluZyA9IGNvbGxlY3Rpb25JZExpc3RbMF0gfHwgJyc7XG4gICAgICAgICAgY29uc3QgbmFtZTogc3RyaW5nID0gY29sbGVjdGlvbiA9PT0gJ3VzZXJzJyA/IGdldERpc3BsYXlOYW1lKGl0ZW0pIDogaXRlbU5hbWUgfHwgJyc7XG5cbiAgICAgICAgICByZXR1cm4gey4uLml0ZW0sIG5hbWV9O1xuICAgICAgICB9KTtcbiAgICAgIH0pO1xuICB9XG5cbiAgY29uc3QgbGltaXQ6IEFyYW5nb0RiTGltaXQgPSBnZXRMaW1pdChmcm9tLCB0byk7XG4gIGNvbnN0IGFxbFFyeTogc3RyaW5nID0gYEZPUiB1IElOIHVzZXJzXG4gICAgICAgIEZJTFRFUiB1LnBob25lID09IFwiJHtxdWVyeX1cIlxuICAgICAgICAke2xpbWl0LmFxbH1cbiAgICAgICAgUkVUVVJOIHVgO1xuXG4gIHJldHVybiB1c2VEYihkYXRhYmFzZU5hbWUpLnF1ZXJ5KGFxbFFyeSlcbiAgICAudGhlbigoY3Vyc29yKSA9PiBjdXJzb3IuYWxsKCkpXG4gICAgLnRoZW4oKGxpc3Q6IFVzZXJUeXBlW10gPSBbXSkgPT4gbGlzdC5tYXAoKGl0ZW0pID0+IHtcbiAgICAgIGNvbnN0IHtfaWQ6IGl0ZW1JZCwgbmFtZTogaXRlbU5hbWV9ID0gaXRlbTtcbiAgICAgIGNvbnN0IGNvbGxlY3Rpb25JZExpc3Q6IHN0cmluZ1tdID0gaXRlbUlkPy5zcGxpdCgnLycpIHx8IFtdO1xuICAgICAgY29uc3QgY29sbGVjdGlvbjogc3RyaW5nID0gY29sbGVjdGlvbklkTGlzdFswXSB8fCAnJztcbiAgICAgIGNvbnN0IG5hbWU6IHN0cmluZyA9IGNvbGxlY3Rpb24gPT09ICd1c2VycycgPyBnZXREaXNwbGF5TmFtZShpdGVtKSA6IGl0ZW1OYW1lIHx8ICcnO1xuXG4gICAgICByZXR1cm4gey4uLml0ZW0sIG5hbWV9O1xuICAgIH0pKVxuICAgIC5jYXRjaCgoZXJyb3I6IEVycm9yKSA9PiB7XG4gICAgICB0aHJvdyBsb2dFeGNlcHRpb24oe1xuICAgICAgICBhY3Rpb24sXG4gICAgICAgIGNhdGVnb3J5OiBldmVudENhdGVnb3J5LFxuICAgICAgICBsYWJlbDogRXJyb3JUeXBlcy5EQVRBQkFTRV9FUlJPUixcbiAgICAgICAgdmFsdWU6IGVycm9yLm1lc3NhZ2VcbiAgICAgIH0sIGNvbnRleHQpO1xuICAgIH0pO1xufTtcbiJdLCJuYW1lcyI6WyJmbGF0dGVuIiwidW5pcUJ5IiwiYXFsIiwiRXJyb3JUeXBlcyIsImxvZ0V4Y2VwdGlvbiIsImdldExpbWl0IiwidXNlRGIiLCJnZXREaXNwbGF5TmFtZSIsImV2ZW50Q2F0ZWdvcnkiLCJnZXRTZWFyY2hMaXN0IiwiY29udGV4dCIsInF1ZXJ5IiwiZnJvbSIsInRvIiwiYWN0aW9uIiwiZGF0YWJhc2VOYW1lIiwiaXNTdHJpbmciLCJmaWVsZHMiLCJjb2xsZWN0aW9uIiwiZmllbGQiLCJQcm9taXNlIiwiYWxsIiwibWFwIiwib2JqIiwicXJ5IiwidXNlclFyeSIsInRoZW4iLCJjdXJzb3IiLCJyZXN1bHRzIiwibGlzdCIsIml0ZW0iLCJfaWQiLCJpdGVtSWQiLCJuYW1lIiwiaXRlbU5hbWUiLCJjb2xsZWN0aW9uSWRMaXN0Iiwic3BsaXQiLCJsaW1pdCIsImFxbFFyeSIsImNhdGNoIiwiZXJyb3IiLCJjYXRlZ29yeSIsImxhYmVsIiwiREFUQUJBU0VfRVJST1IiLCJ2YWx1ZSIsIm1lc3NhZ2UiXSwibWFwcGluZ3MiOiJBQUFBOzs7Q0FHQyxHQUNELFNBQVFBLE9BQU8sUUFBTyw4QkFBOEI7QUFDcEQsU0FBUUMsTUFBTSxRQUFPLDJCQUEyQjtBQUNoRCxTQUFRQyxHQUFHLFFBQU8sV0FBVztBQUU3QixTQUFRQyxVQUFVLFFBQU8sMEJBQTBCO0FBQ25ELFNBQVFDLFlBQVksUUFBTyw2QkFBNkI7QUFDeEQsU0FBUUMsUUFBUSxFQUFFQyxLQUFLLFFBQU8sNEJBQTRCO0FBQzFELFNBQVFDLGNBQWMsUUFBTyxhQUFhO0FBTzFDLE1BQU1DLGdCQUF3QjtBQUU5QixPQUFPLE1BQU1DLGdCQUFnQixDQUFDQyxTQUFxQkMsT0FBZUMsTUFBY0M7SUFDOUUsTUFBTUMsU0FBaUI7SUFDdkIsTUFBTSxFQUFDQyxZQUFZLEVBQUMsR0FBR0w7SUFDdkIsTUFBTU0sV0FBb0I7SUFFMUIsSUFBR0EsVUFBVTtRQUNYLE1BQU1DLFNBQWdEO1lBQ3BEO2dCQUFDQyxZQUFZO2dCQUFTQyxPQUFPO1lBQU87WUFDcEM7Z0JBQUNELFlBQVk7Z0JBQVNDLE9BQU87WUFBTTtZQUNuQztnQkFBQ0QsWUFBWTtnQkFBU0MsT0FBTztZQUFPO1lBQ3BDO2dCQUFDRCxZQUFZO2dCQUFTQyxPQUFPO1lBQVU7WUFDdkM7Z0JBQUNELFlBQVk7Z0JBQVNDLE9BQU87WUFBTTtTQUNwQztRQUVELE9BQU9DLFFBQVFDLEdBQUcsQ0FBQ0osT0FBT0ssR0FBRyxDQUFDLENBQUNDO1lBQzdCLE1BQU1DLE1BQWMsQ0FBQyxPQUFPLEVBQUViLE9BQU87WUFDckMsTUFBTWMsVUFBb0J2QixHQUFHLENBQUMsa0JBQWtCLEVBQUVxQixJQUFJTCxVQUFVLENBQUMsRUFBRSxFQUFFSyxJQUFJSixLQUFLLENBQUMsRUFBRSxFQUFFSyxJQUFJLGNBQWMsQ0FBQztZQUN0RyxPQUFPbEIsTUFBTVMsY0FBY0osS0FBSyxDQUFDYyxTQUFTQyxJQUFJLENBQUMsQ0FBQ0MsU0FBV0EsT0FBT04sR0FBRztRQUN2RSxJQUNHSyxJQUFJLENBQUMsQ0FBQ0U7WUFDTCxNQUFNQyxPQUFPNUIsT0FBT0QsUUFBUTRCLFVBQVU7WUFFdEMsT0FBT0MsS0FBS1AsR0FBRyxDQUFDLENBQUNRO2dCQUNmLE1BQU0sRUFBQ0MsS0FBS0MsTUFBTSxFQUFFQyxNQUFNQyxRQUFRLEVBQUMsR0FBR0osUUFBUSxDQUFDO2dCQUMvQyxNQUFNSyxtQkFBNkJILFFBQVFJLE1BQU0sUUFBUSxFQUFFO2dCQUMzRCxNQUFNbEIsYUFBcUJpQixnQkFBZ0IsQ0FBQyxFQUFFLElBQUk7Z0JBQ2xELE1BQU1GLE9BQWVmLGVBQWUsVUFBVVgsZUFBZXVCLFFBQVFJLFlBQVk7Z0JBRWpGLE9BQU87b0JBQUMsR0FBR0osSUFBSTtvQkFBRUc7Z0JBQUk7WUFDdkI7UUFDRjtJQUNKO0lBRUEsTUFBTUksUUFBdUJoQyxTQUFTTyxNQUFNQztJQUM1QyxNQUFNeUIsU0FBaUIsQ0FBQzsyQkFDQyxFQUFFM0IsTUFBTTtRQUMzQixFQUFFMEIsTUFBTW5DLEdBQUcsQ0FBQztnQkFDSixDQUFDO0lBRWYsT0FBT0ksTUFBTVMsY0FBY0osS0FBSyxDQUFDMkIsUUFDOUJaLElBQUksQ0FBQyxDQUFDQyxTQUFXQSxPQUFPTixHQUFHLElBQzNCSyxJQUFJLENBQUMsQ0FBQ0csT0FBbUIsRUFBRSxHQUFLQSxLQUFLUCxHQUFHLENBQUMsQ0FBQ1E7WUFDekMsTUFBTSxFQUFDQyxLQUFLQyxNQUFNLEVBQUVDLE1BQU1DLFFBQVEsRUFBQyxHQUFHSjtZQUN0QyxNQUFNSyxtQkFBNkJILFFBQVFJLE1BQU0sUUFBUSxFQUFFO1lBQzNELE1BQU1sQixhQUFxQmlCLGdCQUFnQixDQUFDLEVBQUUsSUFBSTtZQUNsRCxNQUFNRixPQUFlZixlQUFlLFVBQVVYLGVBQWV1QixRQUFRSSxZQUFZO1lBRWpGLE9BQU87Z0JBQUMsR0FBR0osSUFBSTtnQkFBRUc7WUFBSTtRQUN2QixJQUNDTSxLQUFLLENBQUMsQ0FBQ0M7UUFDTixNQUFNcEMsYUFBYTtZQUNqQlU7WUFDQTJCLFVBQVVqQztZQUNWa0MsT0FBT3ZDLFdBQVd3QyxjQUFjO1lBQ2hDQyxPQUFPSixNQUFNSyxPQUFPO1FBQ3RCLEdBQUduQztJQUNMO0FBQ0osRUFBRSJ9

package/lib/actions/sms.d.ts

@@ -1,2 +1,3 @@
 import { SMSParamsType } from '../types/notifications.types.js';
 export declare const sendSms: ({ context, text, user, variables }: SMSParamsType) => Promise<boolean>;
+//# sourceMappingURL=sms.d.ts.map

package/lib/actions/sms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sms.d.ts","sourceRoot":"","sources":["../../src/actions/sms.ts"],"names":[],"mappings":"AASA,OAAO,EAAC,aAAa,EAAC,MAAM,iCAAiC,CAAC;AAM9D,eAAO,MAAM,OAAO,GAAU,oCAK3B,aAAa,KAAG,OAAO,CAAC,OAAO,CAyCjC,CAAC"}

package/lib/actions/sms.js

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { PublishCommand, SNSClient } from '@aws-sdk/client-sns';
+import { parsePhone, parseTemplate } from '@nlabs/utils/parsers/strings';
+import { Config } from '../config.js';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError } from '../utils/analyticsUtils.js';
+const eventCategory = 'sms';
+export const sendSms = async ({ context, text, user, variables = {} })=>{
+    const action = 'sendSms';
+    const snsClient = new SNSClient({
+        credentials: Config.get('aws.credentials'),
+        region: Config.get('aws.region')
+    });
+    const { country = 'US', phone = '' } = user || {};
+    const phoneNumber = parsePhone(phone, country);
+    const templateContent = parseTemplate(text || '', variables);
+    return await snsClient.send(new PublishCommand({
+        Message: templateContent,
+        MessageAttributes: {
+            'AWS.SNS.SMS.SMSType': {
+                DataType: 'String',
+                StringValue: 'Transactional'
+            },
+            'AWS.SNS.SMS.SenderID': {
+                DataType: 'String',
+                StringValue: context.config?.details?.id?.trim().replace(/ /g, '').substring(0, 11) || ''
+            }
+        },
+        PhoneNumber: phoneNumber
+    })).then((res)=>{
+        console.log({
+            res
+        });
+        return true;
+    }).catch((error)=>{
+        console.log({
+            error
+        });
+        logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.SMS_ERROR
+        }, error, {
+            session: user
+        });
+        return false;
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/actions/statistics.d.ts

@@ -2,3 +2,4 @@ import type { ApiContext } from '../types/auth.types.js';
 import type { StatisticsType } from '../types/statistics.types.js';
 export declare const getGlobalStatistics: (context: ApiContext) => Promise<StatisticsType>;
 export declare const updateGlobalStatistics: (context: ApiContext) => Promise<StatisticsType>;
+//# sourceMappingURL=statistics.d.ts.map

package/lib/actions/statistics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.d.ts","sourceRoot":"","sources":["../../src/actions/statistics.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,8BAA8B,CAAC;AAIjE,eAAO,MAAM,mBAAmB,GAAI,SAAS,UAAU,KAAG,OAAO,CAAC,cAAc,CAiB/E,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,SAAS,UAAU,KAAG,OAAO,CAAC,cAAc,CAkBlF,CAAC"}

package/lib/actions/statistics.js

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { aql } from 'arangojs';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError } from '../utils/analyticsUtils.js';
+import { useDb } from '../utils/arangodbUtils.js';
+import { getActiveUserCount } from './users.js';
+const eventCategory = 'statistics';
+export const getGlobalStatistics = (context)=>{
+    const action = 'getGlobalStatistics';
+    const { databaseName } = context;
+    const statisticsQuery = aql`FOR s IN statistics
+    FILTER s.isGlobal == true
+    LIMIT 1
+    RETURN s`;
+    return useDb(databaseName).query(statisticsQuery).then((cursor)=>cursor.next()).catch((error)=>{
+        throw logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+    });
+};
+export const updateGlobalStatistics = (context)=>{
+    const action = 'updateGlobalStatistics';
+    const { databaseName } = context;
+    const activeUsers = getActiveUserCount(context);
+    const updatedData = {
+        activeUsers
+    };
+    const updateQuery = aql`UPSERT {isGlobal: true}
+  INSERT ${updatedData}
+  UPDATE ${updatedData}
+  IN statistics RETURN NEW`;
+    return useDb(databaseName).query(updateQuery).then((cursor)=>cursor.next()).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context));
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/actions/subscriptions.d.ts

@@ -5,3 +5,4 @@ export declare const getSubscription: (context: ApiContext) => Promise<PaymentSu
 export declare const addPlan: (context: ApiContext, item: PaymentPlan) => Promise<PaymentPlan>;
 export declare const addSubscription: (context: ApiContext, item: any) => Promise<PaymentSubscription>;
 export declare const deleteSubscription: (context: ApiContext) => Promise<boolean>;
+//# sourceMappingURL=subscriptions.d.ts.map

package/lib/actions/subscriptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions.d.ts","sourceRoot":"","sources":["../../src/actions/subscriptions.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAkB,WAAW,EAAE,mBAAmB,EAAC,MAAM,4BAA4B,CAAC;AAKlG,eAAO,MAAM,WAAW,GAAI,SAAS,UAAU,EAAE,OAAM,MAAU,EAAE,KAAI,MAAW,KAAG,OAAO,CAAC,WAAW,EAAE,CAmBzG,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,SAAS,UAAU,KAAG,OAAO,CAAC,mBAAmB,CAsBhF,CAAC;AAEF,eAAO,MAAM,OAAO,GAAI,SAAS,UAAU,EAAE,MAAM,WAAW,KAAG,OAAO,CAAC,WAAW,CAqEnF,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,SAAS,UAAU,EAAE,SAAI,KAAG,OAAO,CAAC,mBAAmB,CA0EtF,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,SAAS,UAAU,KAAG,OAAO,CAAC,OAAO,CAiCvE,CAAC"}

package/lib/actions/subscriptions.js

@@ -0,0 +1,202 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { aql } from 'arangojs';
+import { DateTime } from 'luxon';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError, logException } from '../utils/analyticsUtils.js';
+import { getLimit, useDb } from '../utils/arangodbUtils.js';
+import { isAdminUser } from '../utils/sessionUtils.js';
+import { getStripeClient } from '../utils/stripeUtils.js';
+import { getUser } from './users.js';
+import { parseNum } from '@nlabs/utils/parsers/numbers';
+import { createHash, parseChar, parseId, parseVarChar } from '@nlabs/utils/parsers/strings';
+const eventCategory = 'subscription';
+export const getPlanList = (context, from = 0, to = 30)=>{
+    const action = 'getList';
+    const { databaseName } = context;
+    const limit = getLimit(from, to);
+    const aqlQry = `FOR p IN plans
+      ${limit.aql}
+      SORT p.amount
+      RETURN p`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).then((list = [])=>list).catch((error)=>{
+        throw logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, {});
+    });
+};
+export const getSubscription = (context)=>{
+    const action = 'getItem';
+    const { databaseName, session: { userId: sessionId } = {} } = context;
+    const aqlQry = `FOR s IN subscriptions
+      FILTER s.userId == ${sessionId} && s.cancelled > 0
+      LET plan = FIRST(
+        FOR p IN plans
+        FILTER p._key == s.planId
+      )
+      LIMIT 1
+      RETURN MERGE(s, {plan: plan})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((subscription = {})=>subscription).catch((error)=>{
+        throw logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, {});
+    });
+};
+export const addPlan = (context, item)=>{
+    const action = 'addPlan';
+    const { databaseName, session } = context;
+    const isAdmin = isAdminUser(session);
+    if (!isAdmin) {
+        throw logException({
+            action,
+            category: eventCategory,
+            label: 'unauthorized',
+            value: ErrorTypes.INVALID_SESSION
+        }, context);
+    }
+    const now = Date.now();
+    const formatId = parseId(item.id);
+    const planId = formatId === '' ? createHash(`subscription-${session?.userId}`) : formatId;
+    const { amount, currency = 'USD', description = '', interval, intervalCount, name } = item;
+    const formatAmount = parseNum(amount);
+    const formatInterval = parseChar(interval, 5).toLowerCase();
+    const formatIntervalCnt = parseNum(intervalCount, 5);
+    const formatName = parseVarChar(name, 32);
+    const formatDesc = parseVarChar(description, 32);
+    const insert = {
+        _key: planId,
+        added: now,
+        amount: formatAmount,
+        currency,
+        description: formatDesc,
+        interval: formatInterval,
+        intervalCount: formatIntervalCnt,
+        modified: now,
+        name: formatName
+    };
+    const aqlQry = aql`INSERT ${insert} IN plans RETURN NEW`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((plan)=>{
+        if (!plan) {
+            throw new Error('Plan not found');
+        }
+        const stripeClient = getStripeClient();
+        const stripePlan = {
+            amount: formatAmount * 100,
+            currency,
+            id: planId,
+            interval: formatInterval,
+            interval_count: formatIntervalCnt,
+            metadata: {},
+            product: {
+                name: formatName,
+                statement_descriptor: formatDesc
+            }
+        };
+        return stripeClient.plans.create(stripePlan).then(()=>plan);
+    }).catch((error)=>{
+        throw logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, {});
+    });
+};
+export const addSubscription = (context, item)=>{
+    const action = 'addSubscription';
+    const { databaseName, session: { userId: sessionId, userAccess } = {} } = context;
+    const isAdmin = !!userAccess && userAccess > 2;
+    if (!isAdmin) {
+        throw logException({
+            action,
+            category: eventCategory,
+            label: 'unauthorized',
+            value: 'invalid_session'
+        }, context);
+    }
+    const now = Date.now();
+    const formatId = parseId(item.id);
+    const subscriptionId = formatId === '' ? createHash(`subscription-${sessionId}`) : formatId;
+    const { planId, trialEnd, trialPeriod } = item;
+    const formatPlanId = parseId(planId);
+    const formatTrialPeriod = 0;
+    let formatTrialEnd = trialEnd || Date.now();
+    if (formatTrialPeriod) {
+        formatTrialEnd = DateTime.local().plus({
+            days: trialPeriod
+        }).toMillis();
+    }
+    return getUser(context, {
+        userId: sessionId || ''
+    }).then((user)=>{
+        if (!user) {
+            throw new Error('User not found');
+        }
+        const insert = {
+            _key: subscriptionId,
+            added: now,
+            cancelDate: 0,
+            modified: now,
+            planId: formatPlanId,
+            trialEnd: formatTrialEnd,
+            userId: sessionId
+        };
+        const aqlQry = aql`INSERT ${insert} IN plans RETURN NEW`;
+        return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((subscription)=>{
+            if (!subscription) {
+                throw new Error('Subscription not found');
+            }
+            const stripeClient = getStripeClient();
+            return stripeClient.subscriptions.create({
+                customer: user.stripeCustomerId || '',
+                items: [
+                    {
+                        plan: formatPlanId
+                    }
+                ],
+                metadata: {
+                    userId: sessionId || ''
+                },
+                trial_end: formatTrialEnd
+            }).then(()=>subscription);
+        }).catch((error)=>{
+            throw logError({
+                action,
+                category: eventCategory,
+                label: ErrorTypes.DATABASE_ERROR
+            }, error, {});
+        });
+    });
+};
+export const deleteSubscription = (context)=>{
+    const action = 'deleteSubscription';
+    const { databaseName } = context;
+    const now = Date.now();
+    return getSubscription(context).then((subscription)=>{
+        const stripeClient = getStripeClient();
+        return stripeClient.subscriptions.cancel(subscription?.transactionId || '').then(({ canceled_at: cancelDate })=>{
+            if (cancelDate) {
+                const update = {
+                    cancelDate,
+                    modified: now,
+                    planId: ''
+                };
+                const aqlQry = aql`UPDATE s WITH ${update} IN subscriptions`;
+                return useDb(databaseName).query(aqlQry).then(()=>true).catch((error)=>{
+                    throw logError({
+                        action,
+                        category: eventCategory,
+                        label: ErrorTypes.DATABASE_ERROR
+                    }, error, {});
+                });
+            }
+            return false;
+        });
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/actions/subscriptions.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 {aql} from 'arangojs';\nimport type {AqlQuery} from 'arangojs/aql';\nimport {DateTime} from 'luxon';\nimport stripe from 'stripe';\n\nimport {ErrorTypes} from '../types/error.types.js';\nimport {logError, logException} from '../utils/analyticsUtils.js';\nimport {getLimit, useDb} from '../utils/arangodbUtils.js';\nimport {isAdminUser} from '../utils/sessionUtils.js';\nimport {getStripeClient} from '../utils/stripeUtils.js';\nimport {getUser} from './users.js';\n\nimport {parseNum} from '@nlabs/utils/parsers/numbers';\nimport {createHash, parseChar, parseId, parseVarChar} from '@nlabs/utils/parsers/strings';\nimport type {ArangoDbLimit} from '../types/arangodb.types.js';\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {PaymentInterval, PaymentPlan, PaymentSubscription} from '../types/payments.types.js';\n\n\nconst eventCategory = 'subscription';\n\nexport const getPlanList = (context: ApiContext, from: number = 0, to: number = 30): Promise<PaymentPlan[]> => {\n  const action: string = 'getList';\n  const {databaseName} = 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(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .then((list = []) => list)\n    .catch((error: Error) => {\n      throw logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, {});\n    });\n};\n\nexport const getSubscription = (context: ApiContext): Promise<PaymentSubscription> => {\n  const action: string = 'getItem';\n  const {databaseName, session: {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(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((subscription = {}) => subscription)\n    .catch((error: Error) => {\n      throw logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, {});\n    });\n};\n\nexport const addPlan = (context: ApiContext, item: PaymentPlan): Promise<PaymentPlan> => {\n  const action: string = 'addPlan';\n  const {databaseName, session} = context;\n  const isAdmin: boolean = isAdminUser(session);\n\n  if(!isAdmin) {\n    throw logException({\n      action,\n      category: eventCategory,\n      label: 'unauthorized',\n      value: ErrorTypes.INVALID_SESSION\n    }, context);\n  }\n\n  const now: number = Date.now();\n  const formatId: string = parseId(item.id);\n  const planId: string = formatId === '' ? createHash(`subscription-${session?.userId}`) : 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  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(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((plan: PaymentPlan | null) => {\n      if(!plan) {\n        throw new Error('Plan not found');\n      }\n\n      const stripeClient = getStripeClient();\n      const stripePlan: stripe.PlanCreateParams = {\n        amount: formatAmount * 100,\n        currency,\n        id: planId,\n        interval: formatInterval,\n        interval_count: formatIntervalCnt,\n        metadata: {\n        },\n        product: {\n          name: formatName,\n          statement_descriptor: formatDesc\n        }\n      };\n\n      return stripeClient.plans\n        .create(stripePlan)\n        .then(() => plan);\n    })\n    .catch((error: Error) => {\n      throw logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, {});\n    });\n};\n\nexport const addSubscription = (context: ApiContext, item): Promise<PaymentSubscription> => {\n  const action: string = 'addSubscription';\n  const {databaseName, session: {userId: sessionId, userAccess} = {}} = context;\n  const isAdmin: boolean = !!userAccess && userAccess > 2;\n\n  if(!isAdmin) {\n    throw logException({\n      action,\n      category: eventCategory,\n      label: 'unauthorized',\n      value: 'invalid_session'\n    }, context);\n  }\n\n  const now: number = Date.now();\n  const formatId: string = parseId(item.id);\n  const subscriptionId: string = formatId === '' ? createHash(`subscription-${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, {userId: sessionId || ''})\n    .then((user) => {\n      if(!user) {\n        throw new Error('User not found');\n      }\n\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(databaseName).query(aqlQry)\n        .then((cursor) => cursor.next())\n        .then((subscription: PaymentSubscription | null) => {\n          if(!subscription) {\n            throw new Error('Subscription not found');\n          }\n\n          const stripeClient = getStripeClient();\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) => {\n          throw logError({\n            action,\n            category: eventCategory,\n            label: ErrorTypes.DATABASE_ERROR\n          }, error, {});\n        });\n    });\n};\n\nexport const deleteSubscription = (context: ApiContext): Promise<boolean> => {\n  const action: string = 'deleteSubscription';\n  const {databaseName} = context;\n  const now: number = Date.now();\n\n  return getSubscription(context)\n    .then((subscription) => {\n      const stripeClient = getStripeClient();\n\n      return stripeClient.subscriptions\n        .cancel(subscription?.transactionId || '')\n        .then(({canceled_at: cancelDate}) => {\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(databaseName).query(aqlQry)\n              .then(() => true)\n              .catch((error: Error) => {\n                throw logError({\n                  action,\n                  category: eventCategory,\n                  label: ErrorTypes.DATABASE_ERROR\n                }, error, {});\n              });\n          }\n          return false;\n        });\n    });\n};\n"],"names":["aql","DateTime","ErrorTypes","logError","logException","getLimit","useDb","isAdminUser","getStripeClient","getUser","parseNum","createHash","parseChar","parseId","parseVarChar","eventCategory","getPlanList","context","from","to","action","databaseName","limit","aqlQry","query","then","cursor","all","list","catch","error","category","label","DATABASE_ERROR","getSubscription","session","userId","sessionId","next","subscription","addPlan","item","isAdmin","value","INVALID_SESSION","now","Date","formatId","id","planId","amount","currency","description","interval","intervalCount","name","formatAmount","formatInterval","toLowerCase","formatIntervalCnt","formatName","formatDesc","insert","_key","added","modified","plan","Error","stripeClient","stripePlan","interval_count","metadata","product","statement_descriptor","plans","create","addSubscription","userAccess","subscriptionId","trialEnd","trialPeriod","formatPlanId","formatTrialPeriod","formatTrialEnd","local","plus","days","toMillis","user","cancelDate","subscriptions","customer","stripeCustomerId","items","trial_end","deleteSubscription","cancel","transactionId","canceled_at","update"],"mappings":"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"}

package/lib/actions/tags.d.ts

@@ -32,3 +32,4 @@ export declare const updateTagsInItem: (context: ApiContext, { itemDocId, tags }
     itemDocId: any;
     tags: any;
 }) => Promise<TagType[]>;
+//# sourceMappingURL=tags.d.ts.map

package/lib/actions/tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags.d.ts","sourceRoot":"","sources":["../../src/actions/tags.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAe,OAAO,EAAC,MAAM,wBAAwB,CAAC;AAGlE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,OAAO,GAClB,SAAS,UAAU,EACnB,UAAS,UAAe,KACvB,OAAO,CAAC,OAAO,EAAE,CAiCnB,CAAC;AAEF,eAAO,MAAM,aAAa,GACxB,SAAS,UAAU,EACnB,WAAW,MAAM,EACjB,UAAS,UAAe,KACvB,OAAO,CAAC,OAAO,EAAE,CAsBnB,CAAC;AAEF,eAAO,MAAM,MAAM,GAAI,SAAS,UAAU,EAAE,OAAO,MAAM,KAAG,OAAO,CAAC,OAAO,CAgB1E,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,UAAU,EAAE,UAAU,MAAM,EAAE,KAAG,OAAO,CAAC,OAAO,EAAE,CA0BxF,CAAC;AAEF,eAAO,MAAM,MAAM,GAAI,SAAS,UAAU,EAAE,KAAK,OAAO,KAAG,OAAO,CAAC,OAAO,CAsBzE,CAAC;AAEF,eAAO,MAAM,YAAY,GACvB,SAAS,UAAU,EACnB,gCAAmC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,KACvF,OAAO,CAAC,OAAO,CAkCjB,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,SAAS,UAAU,EAAE,KAAK,OAAO,KAAG,OAAO,CAAC,OAAO,CA+B5E,CAAC;AAEF,eAAO,MAAM,SAAS,GAAU,SAAS,UAAU,EAAE,KAAK,OAAO,KAAG,OAAO,CAAC,OAAO,CA4BlF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAU,SAAS,UAAU,EAAE;;;CAAqB,KAAG,OAAO,CAAC,OAAO,CAwBnG,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAU,SAAS,UAAU,EAAE;;;;CAAyB,KAAG,OAAO,CAAC,OAAO,CAqBvG,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,SAAS,MAAM,KAAG,MAAM,EACiB,CAAC;AAEtE,eAAO,MAAM,gBAAgB,GAAI,SAAS,UAAU,EAAE;;;CAAiB,KAAG,OAAO,CAAC,OAAO,EAAE,CAqB1F,CAAC"}