@unchainedshop/plugins 1.1.3 → 1.1.7

package/src/filters/local-search.ts

@@ -0,0 +1,105 @@
+import { FilterDirector, FilterAdapter } from '@unchainedshop/core-filters';
+import { IFilterAdapter } from '@unchainedshop/types/filters';
+import { Query } from '@unchainedshop/types/common';
+
+const { AMAZON_DOCUMENTDB_COMPAT_MODE } = process.env;
+
+const LocalSearch: IFilterAdapter = {
+  ...FilterAdapter,
+
+  key: 'shop.unchained.filters.local-search',
+  label: 'Simple Fulltext search with MongoDB',
+  version: '0.1',
+  orderIndex: 1,
+
+  actions: (params) => {
+    return {
+      ...FilterAdapter.actions(params),
+
+      searchProducts: async ({ productIds }) => {
+        // Search Products
+        const { queryString } = params.searchQuery;
+
+        if (!queryString) return productIds;
+
+        const selector: Query = AMAZON_DOCUMENTDB_COMPAT_MODE
+          ? {
+              $or: [
+                { title: { $regex: `${queryString}`, $options: 'im' } },
+                { subtitle: { $regex: `${queryString}`, $options: 'im' } },
+                { vendor: { $regex: `${queryString}`, $options: 'im' } },
+                { brand: { $regex: `${queryString}`, $options: 'im' } },
+                { description: { $regex: `${queryString}`, $options: 'im' } },
+                { labels: { $regex: `${queryString}`, $options: 'im' } },
+              ],
+            }
+          : {
+              $text: { $search: queryString },
+            };
+
+        if (productIds) {
+          selector.productId = { $in: [...new Set(productIds)] };
+        }
+
+        const products = await params.modules.products.texts.findTexts(selector, {
+          projection: {
+            productId: 1,
+          },
+        });
+
+        return products.map(({ productId }) => productId);
+      },
+
+      // eslint-disable-next-line
+      searchAssortments: async ({ assortmentIds }) => {
+        const { queryString } = params.searchQuery;
+
+        if (!queryString) {
+          return assortmentIds;
+        }
+
+        const selector: Query = {
+          $text: { $search: queryString },
+        };
+
+        if (assortmentIds) {
+          selector.assortmentId = { $in: assortmentIds };
+        }
+
+        const assortments = await params.modules.assortments.texts.findTexts(selector, {
+          projection: {
+            assortmentId: 1,
+          },
+        });
+
+        return assortments.map(({ assortmentId }) => assortmentId);
+      },
+
+      async transformFilterSelector(last) {
+        const { query = {} } = params.searchQuery;
+        const { queryString, filterIds, includeInactive } = query;
+
+        if (queryString && !filterIds) {
+          // Global search without assortment scope:
+          // Return all filters
+          const selector = { ...last };
+          if (selector?.key) {
+            // Do not restrict to keys
+            delete selector.key;
+          }
+          if (!includeInactive) {
+            // Include only active filters
+            selector.isActive = true;
+          }
+          return selector;
+        }
+
+        return last;
+      },
+    };
+  },
+};
+
+export default LocalSearch;
+
+FilterDirector.registerAdapter(LocalSearch);

package/src/filters/strict-equal.ts

@@ -0,0 +1,31 @@
+import { IFilterAdapter } from '@unchainedshop/types/filters';
+import { FilterDirector, FilterAdapter } from '@unchainedshop/core-filters';
+
+const StrictQualFilter: IFilterAdapter = {
+  ...FilterAdapter,
+
+  key: 'shop.unchained.filters.strict-qual',
+  label: 'Simple Strict Equal DB Filter',
+  version: '0.1',
+  orderIndex: 0,
+
+  actions: (params) => {
+    return {
+      ...FilterAdapter.actions(params),
+
+      transformProductSelector: async (lastSelector, options) => {
+        const { key, value } = options || {};
+
+        if (key) {
+          return {
+            ...lastSelector,
+            [key]: value !== undefined ? value : { $exists: true },
+          };
+        }
+        return lastSelector;
+      },
+    };
+  },
+};
+
+FilterDirector.registerAdapter(StrictQualFilter);

package/src/payment/apple-iap/adapter.ts

@@ -0,0 +1,390 @@
+import { Context } from '@unchainedshop/types/api';
+import { IPaymentAdapter } from '@unchainedshop/types/payments';
+import bodyParser from 'body-parser';
+import fetch from 'isomorphic-unfetch';
+import { useMiddlewareWithCurrentContext } from '@unchainedshop/api';
+import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
+import { PaymentAdapter, PaymentDirector, PaymentError } from '@unchainedshop/core-payment';
+import { createLogger } from '@unchainedshop/logger';
+import { AppleTransactionsModule } from './module/configureAppleTransactionsModule';
+
+const logger = createLogger('unchained:core-payment:iap');
+
+const {
+  APPLE_IAP_SHARED_SECRET,
+  APPLE_IAP_ENVIRONMENT = 'sandbox',
+  APPLE_IAP_WEBHOOK_PATH = '/graphql/apple-iap',
+} = process.env;
+
+// https://developer.apple.com/documentation/storekit/in-app_purchase/validating_receipts_with_the_app_store
+const environments = {
+  sandbox: 'https://sandbox.itunes.apple.com/verifyReceipt',
+  production: 'https://buy.itunes.apple.com/verifyReceipt',
+};
+
+const verifyReceipt = async ({ receiptData, password }) => {
+  const payload: any = {
+    'receipt-data': receiptData,
+  };
+  if (password) {
+    payload.password = password;
+  }
+  const result = await fetch(environments[APPLE_IAP_ENVIRONMENT], {
+    body: JSON.stringify(payload),
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  });
+  return result.json();
+};
+
+const AppleNotificationTypes = {
+  INITIAL_BUY: 'INITIAL_BUY',
+  DID_RECOVER: 'DID_RECOVER',
+  DID_CHANGE_RENEWAL_STATUS: 'DID_CHANGE_RENEWAL_STATUS',
+  DID_FAIL_TO_RENEW: 'DID_FAIL_TO_RENEW',
+  DID_CHANGE_RENEWAL_PREF: 'DID_CHANGE_RENEWAL_PREF',
+};
+
+const fixPeriods = async (
+  { transactionId, enrollmentId, orderId, transactions },
+  requestContext: Context,
+) => {
+  const relevantTransactions = transactions.filter(
+    // eslint-disable-next-line
+    ({ original_transaction_id }) => {
+      return original_transaction_id === transactionId; // eslint-disable-line
+    },
+  );
+
+  const adjustedEnrollmentPeriods = relevantTransactions
+    .map((transaction) => {
+      return {
+        isTrial: transaction.is_trial_period === 'true', // eslint-disable-line
+        start: new Date(parseInt(transaction.purchase_date_ms, 10)),
+        end: new Date(parseInt(transaction.expires_date_ms, 10)),
+        orderId: transaction.transaction_id === transactionId ? orderId : null,
+      };
+    })
+    .sort((left, right) => {
+      return left.end.getTime() - right.end.getTime();
+    });
+
+  await requestContext.modules.enrollments.removeEnrollmentPeriodByOrderId(
+    enrollmentId,
+    orderId,
+    requestContext.userId,
+  );
+
+  return Promise.all(
+    adjustedEnrollmentPeriods.map((period) =>
+      requestContext.modules.enrollments.addEnrollmentPeriod(
+        enrollmentId,
+        period,
+        requestContext.userId,
+      ),
+    ),
+  );
+};
+
+useMiddlewareWithCurrentContext(
+  APPLE_IAP_WEBHOOK_PATH,
+  bodyParser.json({
+    strict: false,
+  }),
+);
+
+useMiddlewareWithCurrentContext(APPLE_IAP_WEBHOOK_PATH, async (req, res) => {
+  if (req.method === 'POST') {
+    try {
+      const resolvedContext = req.unchainedContext as Context;
+      const { modules, services } = resolvedContext;
+      const responseBody = req.body || {};
+      if (responseBody.password !== APPLE_IAP_SHARED_SECRET) {
+        throw new Error('shared secret not valid');
+      }
+
+      const transactions = responseBody?.unified_receipt?.latest_receipt_info; // eslint-disable-line
+      const latestTransaction = transactions[0];
+
+      if (responseBody.notification_type === AppleNotificationTypes.INITIAL_BUY) {
+        // Find the cart to checkout
+        const orderPayment = await modules.orders.payments.findOrderPaymentByContextData({
+          context: {
+            'meta.transactionIdentifier': latestTransaction.transaction_id,
+          },
+        });
+
+        if (!orderPayment) throw new Error('Could not find any matching order payment');
+        const order = await modules.orders.findOrder({
+          orderId: orderPayment.orderId,
+        });
+
+        if (modules.orders.isCart(order)) {
+          // checkout if is cart, else just ignore because the cart is already checked out
+          // through submission of the receipt with GraphQL
+          const checkedOut = await modules.orders.checkout(
+            order._id,
+            {
+              transactionContext: {
+                receiptData: responseBody?.unified_receipt?.latest_receipt, // eslint-disable-line
+              },
+            },
+            resolvedContext,
+          );
+          const orderId = checkedOut._id;
+          const enrollment = await modules.enrollments.findEnrollment({
+            orderId,
+          });
+          await fixPeriods(
+            {
+              transactionId: latestTransaction.original_transaction_id,
+              transactions,
+              enrollmentId: enrollment._id,
+              orderId,
+            },
+            resolvedContext,
+          );
+
+          logger.info(`Apple IAP Webhook: Confirmed checkout for order ${checkedOut.orderNumber}`, {
+            orderId: checkedOut._id,
+          });
+        }
+      } else {
+        // Just store payment credentials, use the enrollments paymentProvider reference and
+        // let the job do the rest
+        const originalOrderPayment = await modules.orders.payments.findOrderPaymentByContextData({
+          context: {
+            'meta.transactionIdentifier': latestTransaction.original_transaction_id,
+          },
+        });
+        if (!originalOrderPayment) throw new Error('Could not find any matching order payment');
+        const originalOrder = await modules.orders.findOrder({
+          orderId: originalOrderPayment.orderId,
+        });
+        const enrollment = await modules.enrollments.findEnrollment({
+          orderId: originalOrder._id,
+        });
+
+        await services.payment.registerPaymentCredentials(
+          enrollment.payment.paymentProviderId,
+          {
+            transactionContext: {
+              receiptData: responseBody?.unified_receipt?.latest_receipt, // eslint-disable-line
+            },
+          },
+          resolvedContext,
+        );
+
+        await fixPeriods(
+          {
+            transactionId: latestTransaction.original_transaction_id,
+            transactions,
+            enrollmentId: enrollment._id,
+            orderId: originalOrder._id,
+          },
+          resolvedContext,
+        );
+
+        logger.info(
+          `Apple IAP Webhook: Processed notification for ${latestTransaction.original_transaction_id} and type ${responseBody.notification_type}`,
+        );
+
+        if (responseBody.notification_type === AppleNotificationTypes.DID_RECOVER) {
+          if (
+            enrollment.status !== EnrollmentStatus.TERMINATED &&
+            responseBody.auto_renew_status === 'false'
+          ) {
+            await modules.enrollments.terminateEnrollment(enrollment, {}, resolvedContext);
+          }
+        }
+
+        if (responseBody.notification_type === AppleNotificationTypes.DID_CHANGE_RENEWAL_STATUS) {
+          if (
+            enrollment.status !== EnrollmentStatus.TERMINATED &&
+            responseBody.auto_renew_status === 'false'
+          ) {
+            await modules.enrollments.terminateEnrollment(enrollment, {}, resolvedContext);
+          }
+        }
+        logger.info(`Apple IAP Webhook: Updated enrollment from Apple`);
+      }
+
+      res.writeHead(200);
+      res.end();
+      return;
+    } catch (e) {
+      logger.warn(`Apple IAP Webhook: ${e.message}`, e);
+      res.writeHead(503);
+      res.end(JSON.stringify(e));
+      return;
+    }
+  }
+  res.writeHead(404);
+  res.end();
+});
+
+const AppleIAP: IPaymentAdapter = {
+  ...PaymentAdapter,
+
+  key: 'shop.unchained.apple-iap',
+  label: 'Apple In-App-Purchase',
+  version: '1.0',
+  initialConfiguration: [],
+
+  typeSupported: (type) => {
+    return type === 'GENERIC';
+  },
+
+  actions: (params) => {
+    const { modules, userId } = params.context;
+
+    const adapterActions = {
+      ...PaymentAdapter.actions(params),
+
+      configurationError() {
+        // eslint-disable-line
+        if (!APPLE_IAP_SHARED_SECRET) {
+          return PaymentError.INCOMPLETE_CONFIGURATION;
+        }
+        return null;
+      },
+
+      isActive() {
+        if (adapterActions.configurationError() === null) return true;
+        return false;
+      },
+
+      // eslint-disable-next-line
+      isPayLaterAllowed() {
+        return false;
+      },
+
+      // eslint-disable-next-line
+      async sign() {
+        throw new Error('Apple IAP does not support payment signing');
+      },
+
+      // eslint-disable-next-line
+      async validate() {
+        // once registered receipt transactions are valid by default!
+        return true;
+      },
+
+      // eslint-disable-next-line
+      async register(transactionContext) {
+        const { receiptData } = transactionContext;
+
+        const response = await verifyReceipt({
+          receiptData,
+          password: APPLE_IAP_SHARED_SECRET,
+        });
+        const { status, latest_receipt_info: latestReceiptInfo } = response; // eslint-disable-line
+
+        if (status === 0) {
+          logger.info('Apple IAP Plugin: Receipt validated and updated for the user', {
+            level: 'verbose',
+          });
+          const latestTransaction = latestReceiptInfo[latestReceiptInfo.length - 1]; // eslint-disable-line
+          return {
+            token: latestTransaction.web_order_line_item_id, // eslint-disable-line
+            latestReceiptInfo,
+          };
+        }
+
+        logger.warn('Apple IAP Plugin: Receipt invalid', {
+          level: 'warn',
+          status: response.status,
+        });
+        return null;
+      },
+
+      // eslint-disable-next-line
+      async charge(transactionContext) {
+        const { order } = params.paymentContext;
+        const { meta, paymentCredentials, receiptData } = transactionContext || {};
+        const { transactionIdentifier } = meta || {};
+        const appleTransactions = (params.context.modules as any)
+          .appleTransactions as AppleTransactionsModule;
+
+        if (!transactionIdentifier) {
+          throw new Error('Apple IAP Plugin: You have to set the transaction id on the order payment');
+        }
+
+        const receiptResponse =
+          receiptData &&
+          (await verifyReceipt({
+            receiptData,
+            password: APPLE_IAP_SHARED_SECRET,
+          }));
+
+        if (receiptResponse && receiptResponse.status !== 0) {
+          throw new Error('Apple IAP Plugin: Receipt invalid');
+        }
+
+        const transactions =
+          receiptResponse?.latest_receipt_info || // eslint-disable-line
+          paymentCredentials?.meta?.latestReceiptInfo;
+        const matchedTransaction = transactions?.find(
+          (transaction) => transaction?.transaction_id === transactionIdentifier, // eslint-disable-line
+        );
+        if (!matchedTransaction) {
+          throw new Error(
+            `Apple IAP Plugin: Cannot match transaction with identifier ${transactionIdentifier}`,
+          );
+        }
+
+        const orderPositions = await modules.orders.positions.findOrderPositions({
+          orderId: order._id,
+        });
+        const items = Object.entries(
+          orderPositions.reduce((acc, item) => {
+            return {
+              ...acc,
+              [item.productId]: (acc[item.productId] || 0) + item.quantity,
+            };
+          }, {}),
+        );
+
+        if (items.length !== 1) {
+          throw new Error('Apple IAP Plugin: You can only checkout 1 unique product at once');
+        }
+
+        const [[productId, quantity]] = items;
+
+        const isMatchesTransaction =
+          parseInt(matchedTransaction.quantity, 10) === quantity &&
+          matchedTransaction.product_id === productId; // eslint-disable-line
+
+        if (!isMatchesTransaction)
+          throw new Error('Apple IAP Plugin: Product in order does not match transaction');
+
+        const alreadyProcessedTransaction = await appleTransactions.findTransactionById(
+          transactionIdentifier,
+        );
+
+        if (alreadyProcessedTransaction)
+          throw new Error('Apple IAP Plugin: Transaction already processed');
+
+        // All good
+        await appleTransactions.createTransaction(
+          {
+            _id: transactionIdentifier,
+            matchedTransaction,
+            orderId: order._id,
+          },
+          userId,
+        );
+
+        return {
+          transactionIdentifier,
+        };
+      },
+    };
+
+    return adapterActions;
+  },
+};
+
+PaymentDirector.registerAdapter(AppleIAP);

package/src/payment/apple-iap/db/AppleTransactionsCollection.ts

@@ -0,0 +1,13 @@
+import { Db, TimestampFields, _ID } from '@unchainedshop/types/common';
+
+export type AppleTransaction = {
+  _id?: _ID;
+  matchedTransaction: any;
+  orderId: string;
+} & TimestampFields;
+
+export const AppleTransactionsCollection = async (db: Db) => {
+  const AppleTransactions = db.collection<AppleTransaction>('payment_apple_iap_processed_transactions');
+
+  return AppleTransactions;
+};

package/src/payment/apple-iap/index.ts

@@ -0,0 +1,3 @@
+import './adapter';
+
+export { configureAppleTransactionsModule } from './module/configureAppleTransactionsModule';

package/src/payment/apple-iap/module/configureAppleTransactionsModule.ts

@@ -0,0 +1,31 @@
+import { Db } from '@unchainedshop/types/common';
+import { AppleTransaction, AppleTransactionsCollection } from '../db/AppleTransactionsCollection';
+
+export interface AppleTransactionsModule {
+  findTransactionById: (transactionIdentifier: string) => Promise<AppleTransaction>;
+
+  createTransaction: (doc: AppleTransaction, userId: string) => Promise<string | null>;
+}
+
+export const configureAppleTransactionsModule = async ({
+  db,
+}: {
+  db: Db;
+}): Promise<AppleTransactionsModule> => {
+  const AppleTransactions = await AppleTransactionsCollection(db);
+
+  return {
+    findTransactionById: async (transactionIdentifier) => {
+      return AppleTransactions.findOne({ _id: transactionIdentifier });
+    },
+
+    createTransaction: async (doc, userId) => {
+      await AppleTransactions.insertOne({
+        ...doc,
+        created: new Date(),
+        createdBy: userId,
+      });
+      return doc._id;
+    },
+  };
+};