@nlabs/reaktor 0.10.5 → 0.10.7

package/lib/actions/index.d.ts

@@ -26,3 +26,4 @@ export * from './tags.js';
 export * from './users.js';
 export * from './videos.js';
 export * from './websockets.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/actions/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC"}

package/lib/actions/index.js

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ export * from './apps.js';
+export * from './connections.js';
+export * from './conversations.js';
+export * from './dynamodb.js';
+export * from './email.js';
+export * from './files.js';
+export * from './groups.js';
+export * from './images.js';
+export * from './ios.js';
+export * from './locations.js';
+export * from './messages.js';
+export * from './notifications.js';
+export * from './payments.js';
+export * from './posts.js';
+export * from './reactions.js';
+export * from './s3.js';
+export * from './search.js';
+export * from './sms.js';
+export * from './statistics.js';
+export * from './subscriptions.js';
+export * from './tags.js';
+export * from './users.js';
+export * from './videos.js';
+export * from './websockets.js';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L3JlYWt0b3Ivc3JjL2FjdGlvbnMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTktUHJlc2VudCwgTml0cm9nZW4gTGFicywgSW5jLlxuICogQ29weXJpZ2h0cyBsaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuIFNlZSB0aGUgYWNjb21wYW55aW5nIExJQ0VOU0UgZmlsZSBmb3IgdGVybXMuXG4gKi9cbmV4cG9ydCAqIGZyb20gJy4vYXBwcy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2Nvbm5lY3Rpb25zLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vY29udmVyc2F0aW9ucy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2R5bmFtb2RiLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vZW1haWwuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9maWxlcy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2dyb3Vwcy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2ltYWdlcy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2lvcy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2xvY2F0aW9ucy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL21lc3NhZ2VzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vbm90aWZpY2F0aW9ucy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3BheW1lbnRzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vcG9zdHMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9yZWFjdGlvbnMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9zMy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NlYXJjaC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3Ntcy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3N0YXRpc3RpY3MuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9zdWJzY3JpcHRpb25zLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vdGFncy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3VzZXJzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vdmlkZW9zLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vd2Vic29ja2V0cy5qcyc7XG5cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0NBR0MsR0FDRCxjQUFjLFlBQVk7QUFDMUIsY0FBYyxtQkFBbUI7QUFDakMsY0FBYyxxQkFBcUI7QUFDbkMsY0FBYyxnQkFBZ0I7QUFDOUIsY0FBYyxhQUFhO0FBQzNCLGNBQWMsYUFBYTtBQUMzQixjQUFjLGNBQWM7QUFDNUIsY0FBYyxjQUFjO0FBQzVCLGNBQWMsV0FBVztBQUN6QixjQUFjLGlCQUFpQjtBQUMvQixjQUFjLGdCQUFnQjtBQUM5QixjQUFjLHFCQUFxQjtBQUNuQyxjQUFjLGdCQUFnQjtBQUM5QixjQUFjLGFBQWE7QUFDM0IsY0FBYyxpQkFBaUI7QUFDL0IsY0FBYyxVQUFVO0FBQ3hCLGNBQWMsY0FBYztBQUM1QixjQUFjLFdBQVc7QUFDekIsY0FBYyxrQkFBa0I7QUFDaEMsY0FBYyxxQkFBcUI7QUFDbkMsY0FBYyxZQUFZO0FBQzFCLGNBQWMsYUFBYTtBQUMzQixjQUFjLGNBQWM7QUFDNUIsY0FBYyxrQkFBa0IifQ==

package/lib/actions/ios.d.ts

@@ -5,3 +5,4 @@ export declare const iosSubscriptionUpdate: (databaseName: string, subscriptionU
 export declare const getIosSubscription: (context: ApiContext) => Promise<PaymentSubscription>;
 export declare const addIosInApp: (context: ApiContext, subscription: PaymentSubscription) => Promise<PaymentSubscription>;
 export declare const getIosInApp: (context: ApiContext) => Promise<PaymentSubscription>;
+//# sourceMappingURL=ios.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ios.d.ts","sourceRoot":"","sources":["../../src/actions/ios.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC;AAElD,OAAO,EACL,oBAAoB,EAEpB,4BAA4B,EAC5B,mBAAmB,EACpB,MAAM,4BAA4B,CAAC;AAMpC,eAAO,MAAM,gBAAgB,GAAI,YAAY,MAAM,KAAG,oBAkCrD,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,cAAc,MAAM,EACpB,oBAAoB,4BAA4B,KAC/C,OAAO,CAAC,IAAI,CA2Cd,CAAC;AA0FF,eAAO,MAAM,kBAAkB,GAAI,SAAS,UAAU,KAAG,OAAO,CAAC,mBAAmB,CAgBnF,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,SAAS,UAAU,EAAE,cAAc,mBAAmB,KAAG,OAAO,CAAC,mBAAmB,CA2B/G,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,SAAS,UAAU,KAAG,OAAO,CAAC,mBAAmB,CAgB5E,CAAC"}

package/lib/actions/ios.js

@@ -0,0 +1,230 @@
+import { createHash } from '@nlabs/utils/parsers/strings';
+import { aql } from 'arangojs';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError } from '../utils/analyticsUtils.js';
+import { useDb } from '../utils/arangodbUtils.js';
+const eventCategory = 'ios';
+export const getIosInAppError = (statusCode)=>{
+    const codes = {
+        [0]: {
+            error: false,
+            message: 'Active',
+            valid: true
+        },
+        [21000]: {
+            error: true,
+            id: 'payment_receipt_unreadable',
+            message: 'App store could not read',
+            valid: false
+        },
+        [21002]: {
+            error: true,
+            id: 'payment_data_malformed',
+            message: 'Data was malformed',
+            valid: false
+        },
+        [21003]: {
+            error: true,
+            id: 'payment_receipt_unauthorized',
+            message: 'Receipt not authenticated',
+            valid: false
+        },
+        [21004]: {
+            error: true,
+            id: 'payment_invalid_secret',
+            message: 'Shared secret does not match',
+            valid: false
+        },
+        [21005]: {
+            error: true,
+            id: 'payment_server_unavailable',
+            message: 'Receipt server unavailable',
+            valid: false
+        },
+        [21006]: {
+            error: false,
+            id: 'payment_subscription_expired',
+            message: 'Receipt valid but sub expired',
+            valid: true
+        },
+        /**
+     * special case for app review handling - forward any request that is intended for the Sandbox but was sent to
+     * Production, this is what the app review team does
+     */ [21007]: {
+            error: true,
+            id: 'payment_invalid_server',
+            message: 'Sandbox receipt sent to Production environment',
+            redirect: true,
+            valid: false
+        },
+        [21008]: {
+            error: true,
+            id: 'payment_invalid_server',
+            message: 'Production receipt sent to Sandbox environment',
+            valid: false
+        }
+    };
+    return codes[statusCode] || {};
+};
+export const iosSubscriptionUpdate = (databaseName, subscriptionUpdate)=>{
+    const action = 'iosSubscriptionUpdate';
+    const { auto_renew_adam_id: planId, cancellation_date: cancelDate, notification_type: status, latest_receipt: latestReceipt, latest_receipt_info: latestInfo, latest_expired_receipt: expiredReceipt, latest_expired_receipt_info: expiredInfo, original_transaction_id: transactionId } = subscriptionUpdate;
+    const formatStatus = (status || '').toLowerCase();
+    const now = Date.now();
+    const receiptInfo = latestInfo || expiredInfo;
+    const id = createHash(`payment-${transactionId}`);
+    const update = {
+        cancelDate,
+        isValid: receiptInfo[0].expires_date_ms > now,
+        modified: now,
+        planId,
+        receipt: latestReceipt || expiredReceipt,
+        status: formatStatus
+    };
+    const insert = {
+        ...update,
+        _key: id,
+        added: now,
+        type: 'ios_payment'
+    };
+    const aqlQry = aql`UPSERT {transactionId: ${transactionId}}
+     INSERT ${insert}
+     UPDATE ${update} IN subscriptions
+     LIMIT 1`;
+    return useDb(databaseName).query(aqlQry).then(()=>null).catch((dbError)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, dbError, {}).then(()=>null));
+};
+// export const addIosInApp = (
+//   context: ApiContext,
+//   app,
+//   subscription: PaymentSubscription
+// ): Promise<PaymentSubscription> => {
+//   const action: string = 'addIosInApp';
+//   const {isProduction, receipt} = subscription;
+//   const {database, userId: sessionId} = context;
+//   const productionHost: string = 'buy.itunes.apple.com';
+//   const sandboxHost: string = 'sandbox.itunes.apple.com';
+//   const endpoint: string = isProduction ? productionHost : sandboxHost;
+//   const verifyUrl: string = `https://${endpoint}/verifyReceipt`;
+//   const payload: object = {
+//     password: app.iap,
+//     'receipt-data': decodeURIComponent(receipt)
+//   };
+//   const options: object = {
+//     headers: {
+//       'Content-Type': 'application/x-www-form-urlencoded'
+//     }
+//   };
+//   return post(verifyUrl, payload, options)
+//     .then((results) => {
+//       const json = JSON.parse(results);
+//       const {
+//         latest_receipt: latestReceipt,
+//         latest_receipt_info: latestInfo,
+//         status
+//       } = json;
+//       const {
+//         is_trial_period: trialPeriod,
+//         original_purchase_date_ms: added,
+//         expires_date: expires,
+//         product_id: planId,
+//         transaction_id: transactionId
+//       } = latestInfo;
+//       if(status === 0 || status === 21006) {
+//         const id: string = createHash(`payment-${transactionId}`);
+//         const now: number = Date.now();
+//         const update: PaymentSubscription = {
+//           expires,
+//           isTrial: trialPeriod === 'true',
+//           isValid: expires > now,
+//           modified: now,
+//           planId,
+//           receipt: latestReceipt,
+//           transactionId,
+//           userId: sessionId
+//         };
+//         const insert: PaymentSubscription = {
+//           ...update,
+//           _key: id,
+//           added,
+//           type: 'ios_payment'
+//         };
+//         const aqlQry: AqlQuery = aql`UPSERT {transactionId: ${transactionId}}
+//               INSERT ${insert}
+//               UPDATE ${update} IN subscriptions
+//               RETURN NEW`;
+//         return database.query(aqlQry)
+//           .then((cursor) => cursor.next())
+//           .then((updatedSubscription: PaymentSubscription = {}) => updatedSubscription)
+//           .catch((dbError: Error) => logError({
+//             action,
+//             category: eventCategory,
+//             label: ErrorTypes.DATABASE_ERROR
+//           }, dbError, context).then(() => null));
+//       }
+//       // Errors
+//       const error: PaymentIOSInAppError = getIosInAppError(results.status);
+//       return logException({
+//         action,
+//         category: eventCategory,
+//         label: 'payment_error',
+//         message: error.message,
+//         value: error.id
+//       }, context).then(() => null);
+//     });
+// };
+export const getIosSubscription = (context)=>{
+    const action = 'getIosSubscription';
+    const { databaseName, session: { userId: sessionId } } = context;
+    const aqlQry = aql`FOR s IN subscriptions
+      FILTER s.userId == ${sessionId} && s.type == "ios_payment"
+      LIMIT 1
+      RETURN s`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((subscription)=>subscription).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context).then(()=>null));
+};
+export const addIosInApp = (context, subscription)=>{
+    const action = 'addIosInApp';
+    const { databaseName, session: { userId: sessionId } } = context;
+    const now = Date.now();
+    const { added = now, planId, receipt, transactionId, trialEnd } = subscription;
+    const subscriptionId = createHash(`subscription-${transactionId}`);
+    const insert = {
+        _key: subscriptionId,
+        added,
+        modified: now,
+        planId,
+        receipt,
+        transactionId,
+        trialEnd,
+        type: 'ios_subscription',
+        userId: sessionId
+    };
+    const aqlQry = aql`INSERT ${insert} IN subscriptions RETURN NEW`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((updatedSubscription)=>updatedSubscription).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context).then(()=>null));
+};
+export const getIosInApp = (context)=>{
+    const action = 'getIosInApp';
+    const { databaseName, session: { userId: sessionId } } = context;
+    const aqlQry = aql`FOR s IN subscription
+      FILTER s.userId == ${sessionId} && s.type == "ios"
+      LIMIT 1
+      RETURN s`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((subscription)=>subscription).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context).then(()=>null));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/actions/ios.ts"],"sourcesContent":["import {createHash} from '@nlabs/utils/parsers/strings';\nimport {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\n\nimport {ApiContext} from '../types/auth.types.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport {\n  PaymentIOSInAppError,\n  PaymentIOSSubscriptionInfo,\n  PaymentIOSSubscriptionUpdate,\n  PaymentSubscription\n} from '../types/payments.types.js';\nimport {logError} from '../utils/analyticsUtils.js';\nimport {useDb} from '../utils/arangodbUtils.js';\n\nconst eventCategory: string = 'ios';\n\nexport const getIosInAppError = (statusCode: string): PaymentIOSInAppError => {\n  const codes = {\n    [0]: {error: false, message: 'Active', valid: true},\n    [21000]: {error: true, id: 'payment_receipt_unreadable', message: 'App store could not read', valid: false},\n    [21002]: {error: true, id: 'payment_data_malformed', message: 'Data was malformed', valid: false},\n    [21003]: {error: true, id: 'payment_receipt_unauthorized', message: 'Receipt not authenticated', valid: false},\n    [21004]: {error: true, id: 'payment_invalid_secret', message: 'Shared secret does not match', valid: false},\n    [21005]: {error: true, id: 'payment_server_unavailable', message: 'Receipt server unavailable', valid: false},\n    [21006]: {\n      error: false,\n      id: 'payment_subscription_expired',\n      message: 'Receipt valid but sub expired',\n      valid: true\n    },\n    /**\n     * special case for app review handling - forward any request that is intended for the Sandbox but was sent to\n     * Production, this is what the app review team does\n     */\n    [21007]: {\n      error: true,\n      id: 'payment_invalid_server',\n      message: 'Sandbox receipt sent to Production environment',\n      redirect: true,\n      valid: false\n    },\n    [21008]: {\n      error: true,\n      id: 'payment_invalid_server',\n      message: 'Production receipt sent to Sandbox environment',\n      valid: false\n    }\n  };\n\n  return codes[statusCode] || {};\n};\n\nexport const iosSubscriptionUpdate = (\n  databaseName: string,\n  subscriptionUpdate: PaymentIOSSubscriptionUpdate\n): Promise<void> => {\n  const action: string = 'iosSubscriptionUpdate';\n  const {\n    auto_renew_adam_id: planId,\n    cancellation_date: cancelDate,\n    notification_type: status,\n    latest_receipt: latestReceipt,\n    latest_receipt_info: latestInfo,\n    latest_expired_receipt: expiredReceipt,\n    latest_expired_receipt_info: expiredInfo,\n    original_transaction_id: transactionId\n  } = subscriptionUpdate;\n  const formatStatus: string = (status || '').toLowerCase();\n  const now: number = Date.now();\n  const receiptInfo: PaymentIOSSubscriptionInfo[] = latestInfo || expiredInfo;\n  const id: string = createHash(`payment-${transactionId}`);\n\n  const update: PaymentSubscription = {\n    cancelDate,\n    isValid: receiptInfo[0].expires_date_ms > now,\n    modified: now,\n    planId,\n    receipt: latestReceipt || expiredReceipt,\n    status: formatStatus\n  };\n  const insert: PaymentSubscription = {\n    ...update,\n    _key: id,\n    added: now,\n    type: 'ios_payment'\n  };\n  const aqlQry: AqlQuery = aql`UPSERT {transactionId: ${transactionId}}\n     INSERT ${insert}\n     UPDATE ${update} IN subscriptions\n     LIMIT 1`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then(() => null)\n    .catch((dbError: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, dbError, {}).then(() => null));\n};\n\n// export const addIosInApp = (\n//   context: ApiContext,\n//   app,\n//   subscription: PaymentSubscription\n// ): Promise<PaymentSubscription> => {\n//   const action: string = 'addIosInApp';\n//   const {isProduction, receipt} = subscription;\n//   const {database, userId: sessionId} = context;\n\n//   const productionHost: string = 'buy.itunes.apple.com';\n//   const sandboxHost: string = 'sandbox.itunes.apple.com';\n//   const endpoint: string = isProduction ? productionHost : sandboxHost;\n//   const verifyUrl: string = `https://${endpoint}/verifyReceipt`;\n//   const payload: object = {\n//     password: app.iap,\n//     'receipt-data': decodeURIComponent(receipt)\n//   };\n//   const options: object = {\n//     headers: {\n//       'Content-Type': 'application/x-www-form-urlencoded'\n//     }\n//   };\n\n//   return post(verifyUrl, payload, options)\n//     .then((results) => {\n//       const json = JSON.parse(results);\n//       const {\n//         latest_receipt: latestReceipt,\n//         latest_receipt_info: latestInfo,\n//         status\n//       } = json;\n\n//       const {\n//         is_trial_period: trialPeriod,\n//         original_purchase_date_ms: added,\n//         expires_date: expires,\n//         product_id: planId,\n//         transaction_id: transactionId\n//       } = latestInfo;\n\n//       if(status === 0 || status === 21006) {\n//         const id: string = createHash(`payment-${transactionId}`);\n//         const now: number = Date.now();\n//         const update: PaymentSubscription = {\n//           expires,\n//           isTrial: trialPeriod === 'true',\n//           isValid: expires > now,\n//           modified: now,\n//           planId,\n//           receipt: latestReceipt,\n//           transactionId,\n//           userId: sessionId\n//         };\n//         const insert: PaymentSubscription = {\n//           ...update,\n//           _key: id,\n//           added,\n//           type: 'ios_payment'\n//         };\n\n//         const aqlQry: AqlQuery = aql`UPSERT {transactionId: ${transactionId}}\n//               INSERT ${insert}\n//               UPDATE ${update} IN subscriptions\n//               RETURN NEW`;\n\n//         return database.query(aqlQry)\n//           .then((cursor) => cursor.next())\n//           .then((updatedSubscription: PaymentSubscription = {}) => updatedSubscription)\n//           .catch((dbError: Error) => logError({\n//             action,\n//             category: eventCategory,\n//             label: ErrorTypes.DATABASE_ERROR\n//           }, dbError, context).then(() => null));\n//       }\n\n//       // Errors\n//       const error: PaymentIOSInAppError = getIosInAppError(results.status);\n\n//       return logException({\n//         action,\n//         category: eventCategory,\n//         label: 'payment_error',\n//         message: error.message,\n//         value: error.id\n//       }, context).then(() => null);\n//     });\n// };\n\nexport const getIosSubscription = (context: ApiContext): Promise<PaymentSubscription> => {\n  const action: string = 'getIosSubscription';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const aqlQry: AqlQuery = aql`FOR s IN subscriptions\n      FILTER s.userId == ${sessionId} && s.type == \"ios_payment\"\n      LIMIT 1\n      RETURN s`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((subscription: PaymentSubscription) => subscription)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const addIosInApp = (context: ApiContext, subscription: PaymentSubscription): Promise<PaymentSubscription> => {\n  const action: string = 'addIosInApp';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const now: number = Date.now();\n  const {added = now, planId, receipt, transactionId, trialEnd} = subscription;\n  const subscriptionId: string = createHash(`subscription-${transactionId}`);\n  const insert: PaymentSubscription = {\n    _key: subscriptionId,\n    added,\n    modified: now,\n    planId,\n    receipt,\n    transactionId,\n    trialEnd,\n    type: 'ios_subscription',\n    userId: sessionId\n  };\n  const aqlQry: AqlQuery = aql`INSERT ${insert} IN subscriptions RETURN NEW`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((updatedSubscription: PaymentSubscription) => updatedSubscription)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const getIosInApp = (context: ApiContext): Promise<PaymentSubscription> => {\n  const action: string = 'getIosInApp';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const aqlQry: AqlQuery = aql`FOR s IN subscription\n      FILTER s.userId == ${sessionId} && s.type == \"ios\"\n      LIMIT 1\n      RETURN s`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((subscription: PaymentSubscription) => subscription)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n"],"names":["createHash","aql","ErrorTypes","logError","useDb","eventCategory","getIosInAppError","statusCode","codes","error","message","valid","id","redirect","iosSubscriptionUpdate","databaseName","subscriptionUpdate","action","auto_renew_adam_id","planId","cancellation_date","cancelDate","notification_type","status","latest_receipt","latestReceipt","latest_receipt_info","latestInfo","latest_expired_receipt","expiredReceipt","latest_expired_receipt_info","expiredInfo","original_transaction_id","transactionId","formatStatus","toLowerCase","now","Date","receiptInfo","update","isValid","expires_date_ms","modified","receipt","insert","_key","added","type","aqlQry","query","then","catch","dbError","category","label","DATABASE_ERROR","getIosSubscription","context","session","userId","sessionId","cursor","next","subscription","addIosInApp","trialEnd","subscriptionId","updatedSubscription","getIosInApp"],"mappings":"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"}

package/lib/actions/locations.d.ts

@@ -4,3 +4,4 @@ import { LocationType } from '../types/locations.types.js';
 export declare const getFieldVal: (addressComponents: GoogleMapsAddressType[], name: string) => string;
 export declare const addLocation: (context: ApiContext, location: LocationType) => Promise<LocationType>;
 export declare const getLocation: (context: ApiContext, locationId: string) => Promise<LocationType>;
+//# sourceMappingURL=locations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"locations.d.ts","sourceRoot":"","sources":["../../src/actions/locations.ts"],"names":[],"mappings":"AAUA,OAAO,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC;AAElD,OAAO,EAAC,qBAAqB,EAAuB,MAAM,0BAA0B,CAAC;AACrF,OAAO,EAAC,YAAY,EAAC,MAAM,6BAA6B,CAAC;AASzD,eAAO,MAAM,WAAW,GAAI,mBAAmB,qBAAqB,EAAE,EAAE,MAAM,MAAM,KAAG,MAOtF,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,SAAS,UAAU,EAAE,UAAU,YAAY,KAAG,OAAO,CAAC,YAAY,CAsF7F,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,SAAS,UAAU,EAAE,YAAY,MAAM,KAAG,OAAO,CAAC,YAAY,CAazF,CAAC"}

package/lib/actions/locations.js

@@ -0,0 +1,111 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { get as httpGet, queryString } from '@nlabs/rip-hunter';
+import { createHash, parseChar, parseId } from '@nlabs/utils/parsers/strings';
+import { aql } from 'arangojs';
+import { Config } from '../config.js';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError } from '../utils/analyticsUtils.js';
+import { useDb } from '../utils/arangodbUtils.js';
+const eventCategory = 'locations';
+export const getFieldVal = (addressComponents, name)=>{
+    const { short_name: shortName = '' } = addressComponents.find((addressField)=>{
+        const types = addressField.types || [];
+        return types.findIndex((fieldType)=>fieldType === name) >= 0;
+    }) || {};
+    return shortName;
+};
+export const addLocation = (context, location)=>{
+    const action = 'add';
+    const { databaseName, session: { userId: sessionId } } = context;
+    const { address, itemId, itemType } = location;
+    const geocodeUrl = Config.get('google.geocode.url');
+    const params = {
+        address,
+        key: Config.get('google.geocode.key')
+    };
+    const url = `${geocodeUrl}?${queryString(params)}`;
+    return httpGet(url).then((json)=>{
+        const { results = [], status = '' } = json;
+        if (status === 'OK' && results.length) {
+            const geodata = results[0];
+            const addressComponents = geodata?.address_components || [];
+            // Street
+            const streetNumber = getFieldVal(addressComponents, 'street_number');
+            const route = getFieldVal(addressComponents, 'route');
+            // Location
+            const now = Date.now();
+            // Item
+            const formatItemType = parseChar(itemType).toLowerCase();
+            const formatItemId = parseId(itemId);
+            const googleId = geodata?.place_id || '';
+            const update = {};
+            const insert = {
+                _key: createHash(`post-${sessionId}`),
+                added: now,
+                city: getFieldVal(addressComponents, 'locality'),
+                country: getFieldVal(addressComponents, 'country'),
+                formatted: geodata?.formatted_address,
+                googleId,
+                latitude: geodata?.geometry.location.lat,
+                longitude: geodata?.geometry.location.lng,
+                state: getFieldVal(addressComponents, 'administrative_area_level_1'),
+                street: [
+                    streetNumber,
+                    route
+                ].filter((obj)=>obj).join(' '),
+                zip: getFieldVal(addressComponents, 'postal_code')
+            };
+            const aqlQry = aql`UPSERT {googleId: ${googleId}}
+            INSERT ${insert}
+            UPDATE ${update}
+            IN locations RETURN NEW`;
+            return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((updatedLocation)=>{
+                let itemDocId;
+                const { _key: updatedLocationKey } = updatedLocation;
+                switch(formatItemType){
+                    case 'posts':
+                        itemDocId = `posts/${formatItemId}`;
+                        break;
+                    default:
+                        itemDocId = '';
+                }
+                // If there is a valid item doc id, create an edge
+                if (itemDocId) {
+                    const edgeCollection = useDb(databaseName).collection('hasLocation');
+                    const locationId = updatedLocationKey;
+                    const locationDocId = `locations/${locationId}`;
+                    const edgeId = createHash(`hasLocation-${locationId}-${sessionId}`);
+                    const edge = {
+                        _from: itemDocId,
+                        _key: edgeId,
+                        _to: locationDocId
+                    };
+                    return edgeCollection.save(edge, {
+                        returnNew: true
+                    }).then(()=>updatedLocation);
+                }
+                // Otherwise just return the new location
+                return updatedLocation;
+            }).catch((error)=>logError({
+                    action,
+                    category: eventCategory,
+                    label: ErrorTypes.DATABASE_ERROR
+                }, error, context).then(()=>null));
+        }
+        return null;
+    });
+};
+export const getLocation = (context, locationId)=>{
+    const { databaseName } = context;
+    const formatId = parseId(locationId);
+    const aqlQry = aql`FOR l IN locations
+    FILTER l._key == ${formatId}
+    RETURN l`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>{
+        throw error;
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/actions/locations.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 {get as httpGet, queryString} from '@nlabs/rip-hunter';\nimport {createHash, parseChar, parseId} from '@nlabs/utils/parsers/strings';\nimport {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\n\nimport {Config} from '../config.js';\nimport {ApiContext} from '../types/auth.types.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport {GoogleMapsAddressType, GoogleMapsResultType} from '../types/google.types.js';\nimport {LocationType} from '../types/locations.types.js';\nimport {logError} from '../utils/analyticsUtils.js';\nimport {useDb} from '../utils/arangodbUtils.js';\n\nimport type {EdgeCollection} from 'arangojs/collections';\nimport type {EdgeType} from '../types/arangodb.types.js';\n\nconst eventCategory: string = 'locations';\n\nexport const getFieldVal = (addressComponents: GoogleMapsAddressType[], name: string): string => {\n  const {short_name: shortName = ''} = addressComponents.find((addressField: GoogleMapsAddressType) => {\n    const types = addressField.types || [];\n    return types.findIndex((fieldType: string) => fieldType === name) >= 0;\n  }) || {};\n\n  return shortName;\n};\n\nexport const addLocation = (context: ApiContext, location: LocationType): Promise<LocationType> => {\n  const action: string = 'add';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const {address, itemId, itemType} = location;\n  const geocodeUrl: string = Config.get('google.geocode.url');\n  const params: object = {\n    address,\n    key: Config.get('google.geocode.key')\n  };\n  const url: string = `${geocodeUrl}?${queryString(params)}`;\n\n  return httpGet(url)\n    .then((json) => {\n      const {results = [], status = ''} = json;\n\n      if(status === 'OK' && results.length) {\n        const geodata: GoogleMapsResultType = results[0];\n        const addressComponents: GoogleMapsAddressType[] = geodata?.address_components || [];\n\n        // Street\n        const streetNumber: string = getFieldVal(addressComponents, 'street_number');\n        const route: string = getFieldVal(addressComponents, 'route');\n\n        // Location\n        const now: number = Date.now();\n\n        // Item\n        const formatItemType: string = parseChar(itemType).toLowerCase();\n        const formatItemId: string = parseId(itemId);\n        const googleId: string = geodata?.place_id || '';\n        const update: LocationType = {};\n        const insert: LocationType = {\n          _key: createHash(`post-${sessionId}`),\n          added: now,\n          city: getFieldVal(addressComponents, 'locality'),\n          country: getFieldVal(addressComponents, 'country'),\n          formatted: geodata?.formatted_address,\n          googleId,\n          latitude: geodata?.geometry.location.lat,\n          longitude: geodata?.geometry.location.lng,\n          state: getFieldVal(addressComponents, 'administrative_area_level_1'),\n          street: [streetNumber, route].filter((obj) => obj).join(' '),\n          zip: getFieldVal(addressComponents, 'postal_code')\n        };\n        const aqlQry: AqlQuery = aql`UPSERT {googleId: ${googleId}}\n            INSERT ${insert}\n            UPDATE ${update}\n            IN locations RETURN NEW`;\n\n        return useDb(databaseName).query(aqlQry)\n          .then((cursor) => cursor.next())\n          .then((updatedLocation: LocationType) => {\n            let itemDocId: string;\n            const {_key: updatedLocationKey} = updatedLocation;\n\n            switch(formatItemType) {\n              case 'posts':\n                itemDocId = `posts/${formatItemId}`;\n                break;\n              default:\n                itemDocId = '';\n            }\n\n            // If there is a valid item doc id, create an edge\n            if(itemDocId) {\n              const edgeCollection: EdgeCollection = useDb(databaseName).collection('hasLocation');\n              const locationId: string = updatedLocationKey;\n              const locationDocId: string = `locations/${locationId}`;\n              const edgeId = createHash(`hasLocation-${locationId}-${sessionId}`);\n              const edge: EdgeType = {_from: itemDocId, _key: edgeId, _to: locationDocId};\n\n              return edgeCollection.save(edge, {returnNew: true}).then(() => updatedLocation);\n            }\n\n            // Otherwise just return the new location\n            return updatedLocation;\n          })\n          .catch((error: Error) => logError({\n            action,\n            category: eventCategory,\n            label: ErrorTypes.DATABASE_ERROR\n          }, error, context).then(() => null));\n      }\n\n      return null;\n    });\n};\n\nexport const getLocation = (context: ApiContext, locationId: string): Promise<LocationType> => {\n  const {databaseName} = context;\n  const formatId: string = parseId(locationId);\n\n  const aqlQry: AqlQuery = aql`FOR l IN locations\n    FILTER l._key == ${formatId}\n    RETURN l`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n"],"names":["get","httpGet","queryString","createHash","parseChar","parseId","aql","Config","ErrorTypes","logError","useDb","eventCategory","getFieldVal","addressComponents","name","short_name","shortName","find","addressField","types","findIndex","fieldType","addLocation","context","location","action","databaseName","session","userId","sessionId","address","itemId","itemType","geocodeUrl","params","key","url","then","json","results","status","length","geodata","address_components","streetNumber","route","now","Date","formatItemType","toLowerCase","formatItemId","googleId","place_id","update","insert","_key","added","city","country","formatted","formatted_address","latitude","geometry","lat","longitude","lng","state","street","filter","obj","join","zip","aqlQry","query","cursor","next","updatedLocation","itemDocId","updatedLocationKey","edgeCollection","collection","locationId","locationDocId","edgeId","edge","_from","_to","save","returnNew","catch","error","category","label","DATABASE_ERROR","getLocation","formatId"],"mappings":"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"}

package/lib/actions/messages.d.ts

@@ -11,3 +11,4 @@ export declare const unsaveMessage: (context: ApiContext, messageId: string, con
 export declare const deleteMessage: (context: ApiContext, messageId: string, conversationId: string) => Promise<MessageType>;
 export declare const getMessage: (context: ApiContext, messageId: string) => Promise<MessageType>;
 export declare const cleanMessages: (databaseName: string) => Promise<number>;
+//# sourceMappingURL=messages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/actions/messages.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC;AAEvD,OAAO,KAAK,EAAC,gBAAgB,EAAE,WAAW,EAAC,MAAM,4BAA4B,CAAC;AAI9E,eAAO,MAAM,WAAW,GAAI,SAAS,UAAU,EAAE,gBAAgB,MAAM,EAAE;;;CAAU,KAAG,OAAO,CAAC,WAAW,EAAE,CAqC1G,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,UAAU,EAAE,SAAS,gBAAgB,KAAG,OAAO,CAAC,WAAW,CAuCjG,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,SAAS,UAAU,EAAE,SAAS,gBAAgB,KAAG,OAAO,CAAC,WAAW,CAY9F,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,SAAS,UAAU,EAAE,WAAW,MAAM,EAAE,gBAAgB,MAAM,KAAG,OAAO,CAAC,WAAW,CA2B/G,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,UAAU,EAAE,WAAW,MAAM,EAAE,gBAAgB,MAAM,KAAG,OAAO,CAAC,WAAW,CA2BjH,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,UAAU,EAAE,WAAW,MAAM,EAAE,gBAAgB,MAAM,KAAG,OAAO,CAAC,WAAW,CA2BjH,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,SAAS,UAAU,EAAE,WAAW,MAAM,KAAG,OAAO,CAAC,WAAW,CAatF,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,cAAc,MAAM,KAAG,OAAO,CAAC,MAAM,CAalE,CAAC"}