@unchainedshop/plugins 2.0.0-beta6 → 2.0.0-beta8

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

@@ -1,8 +1,6 @@
+/// <reference lib="dom" />
 import { Context } from '@unchainedshop/types/api';
 import { IPaymentAdapter } from '@unchainedshop/types/payments';
-import bodyParser from 'body-parser';
-import fetch from 'node-fetch';
-import { useMiddlewareWithCurrentContext } from '@unchainedshop/api';
 import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
 import { PaymentAdapter, PaymentDirector, PaymentError } from '@unchainedshop/core-payment';
 import { createLogger } from '@unchainedshop/logger';
@@ -10,11 +8,7 @@ import { AppleTransactionsModule } from './module/configureAppleTransactionsModu
 
 const logger = createLogger('unchained:core-payment:iap');
 
-const {
-  APPLE_IAP_SHARED_SECRET,
-  APPLE_IAP_ENVIRONMENT = 'sandbox',
-  APPLE_IAP_WEBHOOK_PATH = '/payment/apple-iap',
-} = process.env;
+const { APPLE_IAP_SHARED_SECRET, APPLE_IAP_ENVIRONMENT = 'sandbox' } = process.env;
 
 // https://developer.apple.com/documentation/storekit/in-app_purchase/validating_receipts_with_the_app_store
 const environments = {
@@ -88,144 +82,134 @@ const fixPeriods = async (
   );
 };
 
-export default (app) => {
-  useMiddlewareWithCurrentContext(
-    app,
-    APPLE_IAP_WEBHOOK_PATH,
-    bodyParser.json({
-      strict: false,
-    }),
-  );
-
-  useMiddlewareWithCurrentContext(app, 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,
-            },
-          });
+export const appleIAPHandler = 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');
+      }
 
-          if (!orderPayment) throw new Error('Could not find any matching order payment');
-          const order = await modules.orders.findOrder({
-            orderId: orderPayment.orderId,
-          });
+      const transactions = responseBody?.unified_receipt?.latest_receipt_info; // eslint-disable-line
+      const latestTransaction = transactions[0];
 
-          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,
-              {
-                paymentContext: {
-                  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,
-            );
+      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,
+          },
+        });
 
-            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,
-          });
+        if (!orderPayment) throw new Error('Could not find any matching order payment');
+        const order = await modules.orders.findOrder({
+          orderId: orderPayment.orderId,
+        });
 
-          await services.payment.registerPaymentCredentials(
-            enrollment.payment.paymentProviderId,
+        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: {
+              paymentContext: {
                 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: originalOrder._id,
+              orderId,
             },
             resolvedContext,
           );
 
-          logger.info(
-            `Apple IAP Webhook: Processed notification for ${latestTransaction.original_transaction_id} and type ${responseBody.notification_type}`,
-          );
+          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,
+        });
 
-          if (responseBody.notification_type === AppleNotificationTypes.DID_RECOVER) {
-            if (
-              enrollment.status !== EnrollmentStatus.TERMINATED &&
-              responseBody.auto_renew_status === 'false'
-            ) {
-              await modules.enrollments.terminateEnrollment(enrollment, {}, resolvedContext);
-            }
-          }
+        await services.payment.registerPaymentCredentials(
+          enrollment.payment.paymentProviderId,
+          {
+            transactionContext: {
+              receiptData: responseBody?.unified_receipt?.latest_receipt, // eslint-disable-line
+            },
+          },
+          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);
-            }
+        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);
           }
-          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({ name: e.name, code: e.code, message: e.message }));
-        return;
+        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({ name: e.name, code: e.code, message: e.message }));
+      return;
     }
-    res.writeHead(404);
-    res.end();
-  });
+  }
+  res.writeHead(404);
+  res.end();
 };
 
 const AppleIAP: IPaymentAdapter = {

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

@@ -1,4 +1,2 @@
-import setupAppleIAP from './adapter';
-
-export default setupAppleIAP;
-export { configureAppleTransactionsModule } from './module/configureAppleTransactionsModule';
+export * from './adapter';
+export * from './module/configureAppleTransactionsModule';

package/src/payment/braintree.ts

@@ -112,7 +112,7 @@ const BraintreeDirect: IPaymentAdapter = {
         // @ts-ignore
         const braintree = (await import('braintree')).default; // eslint-disable-line
         const gateway = getGateway(braintree);
-        const address = order.billingAddress || {};
+        const address = order.billingAddress;
         const pricing = modules.orders.pricingSheet(order);
         const rounded = Math.round(pricing.total({ useNetPrice: false }).amount / 10 || 0) * 10;
         const saleRequest = {
@@ -120,17 +120,19 @@ const BraintreeDirect: IPaymentAdapter = {
           merchantAccountId: order.currency,
           paymentMethodNonce: paypalPaymentMethodNonce,
           orderId: order.orderNumber || order._id,
-          shipping: {
-            firstName: address.firstName,
-            lastName: address.lastName,
-            company: address.company,
-            streetAddress: address.addressLine,
-            extendedAddress: address.addressLine2,
-            locality: address.city,
-            region: address.regionCode,
-            postalCode: address.postalCode,
-            countryCodeAlpha2: address.countryCode,
-          },
+          shipping: address
+            ? {
+                firstName: address.firstName,
+                lastName: address.lastName,
+                company: address.company,
+                streetAddress: address.addressLine,
+                extendedAddress: address.addressLine2,
+                locality: address.city,
+                region: address.regionCode,
+                postalCode: address.postalCode,
+                countryCodeAlpha2: address.countryCode,
+              }
+            : undefined,
           options: {
             submitForSettlement: true,
           },

package/src/payment/cryptopay/index.ts

@@ -1,8 +1,6 @@
-import setupCryptopayWebhooks from './middleware';
 import CryptopayPlugin from './plugin';
 
-export { configureCryptopayModule } from './module/configureCryptopayModule';
-
-export { setupCryptopayWebhooks };
+export * from './middleware';
+export * from './module/configureCryptopayModule';
 
 export default CryptopayPlugin;

package/src/payment/cryptopay/middleware.ts

@@ -1,95 +1,86 @@
-import { useMiddlewareWithCurrentContext } from '@unchainedshop/api';
-import bodyParser from 'body-parser';
 import { createLogger } from '@unchainedshop/logger';
 import { Context } from '@unchainedshop/types/api';
 
 import { UnchainedCore } from '@unchainedshop/types/core';
 import { OrderStatus } from '@unchainedshop/core-orders';
 import { ProductPriceRate } from '@unchainedshop/types/products.pricing';
-import { CryptopayModule } from './module/configureCryptopayModule';
+import type { CryptopayModule } from './module/configureCryptopayModule';
 
-const {
-  CRYPTOPAY_WEBHOOK_PATH = '/payment/cryptopay',
-  CRYPTOPAY_SECRET,
-  CRYPTOPAY_MAX_RATE_AGE,
-} = process.env;
+const { CRYPTOPAY_SECRET, CRYPTOPAY_MAX_RATE_AGE } = process.env;
 
 const logger = createLogger('unchained:core-payment:cryptopay');
 
-export default (app: any) => {
-  useMiddlewareWithCurrentContext(app, CRYPTOPAY_WEBHOOK_PATH, bodyParser.json());
-  useMiddlewareWithCurrentContext(app, CRYPTOPAY_WEBHOOK_PATH, async (req, res) => {
-    const resolvedContext = req.unchainedContext as Context;
-    const modules = resolvedContext.modules as UnchainedCore['modules'] & { cryptopay: CryptopayModule };
-    if (req.method === 'POST') {
-      try {
-        const { secret, price, wallet, ping } = req.body;
-        if (secret !== CRYPTOPAY_SECRET) {
-          logger.warn(`Cryptopay Plugin: Invalid Cryptopay Secret provided`);
-          throw new Error('Secret invalid');
-        }
+export const cryptopayHandler = async (req, res) => {
+  const resolvedContext = req.unchainedContext as Context;
+  const modules = resolvedContext.modules as UnchainedCore['modules'] & { cryptopay: CryptopayModule };
+  if (req.method === 'POST') {
+    try {
+      const { secret, price, wallet, ping } = req.body;
+      if (secret !== CRYPTOPAY_SECRET) {
+        logger.warn(`Cryptopay Plugin: Invalid Cryptopay Secret provided`);
+        throw new Error('Secret invalid');
+      }
 
-        if (wallet) {
-          const { address, blockHeight, amount, contract, decimals, currency } = wallet;
-          const { orderPaymentId } = await modules.cryptopay.updateWalletAddress({
-            addressId: address,
-            blockHeight,
-            amount,
-            contract,
-            decimals,
-            currency,
-          });
-          const orderPayment =
-            orderPaymentId &&
-            (await modules.orders.payments.findOrderPayment({
-              orderPaymentId,
-            }));
+      if (wallet) {
+        const { address, blockHeight, amount, contract, decimals, currency } = wallet;
+        const { orderPaymentId } = await modules.cryptopay.updateWalletAddress({
+          addressId: address,
+          blockHeight,
+          amount,
+          contract,
+          decimals,
+          currency,
+        });
+        const orderPayment =
+          orderPaymentId &&
+          (await modules.orders.payments.findOrderPayment({
+            orderPaymentId,
+          }));
 
-          if (orderPayment) {
-            // Try to process order to next status
-            const order = await modules.orders.findOrder({ orderId: orderPayment.orderId });
-            if (order.status === null) {
-              await modules.orders.checkout(order._id, {}, resolvedContext);
-            } else if (order.status === OrderStatus.PENDING) {
-              await modules.orders.processOrder(order, {}, resolvedContext);
-            } else {
-              throw new Error('Already processed');
-            }
+        if (orderPayment) {
+          // Try to process order to next status
+          const order = await modules.orders.findOrder({ orderId: orderPayment.orderId });
+          if (order.status === null) {
+            await modules.orders.checkout(order._id, {}, resolvedContext);
+          } else if (order.status === OrderStatus.PENDING) {
+            await modules.orders.processOrder(order, {}, resolvedContext);
+          } else {
+            throw new Error('Already processed');
           }
         }
+      }
 
-        if (price) {
-          const { baseCurrency, token, rate, timestamp } = price;
-
-          const timestampDate = new Date(timestamp);
-          const expiresAt = new Date(new Date().getTime() + parseInt(CRYPTOPAY_MAX_RATE_AGE, 10) * 1000);
+      if (price) {
+        const { baseCurrency, token, rate, timestamp } = price;
 
-          const rateData: ProductPriceRate = {
-            baseCurrency,
-            quoteCurrency: token,
-            rate,
-            expiresAt,
-            timestamp: timestampDate,
-          };
-          console.log('update rate', price, rateData);
-          await resolvedContext.modules.products.prices.rates.updateRates([rateData]);
-        }
+        const timestampDate = new Date(timestamp);
+        const expiresAt = new Date(new Date().getTime() + parseInt(CRYPTOPAY_MAX_RATE_AGE, 10) * 1000);
 
-        if (ping) {
-          const { blockHeight, currency } = ping;
-          await modules.cryptopay.updateMostRecentBlock(currency, blockHeight);
-        }
+        const rateData: ProductPriceRate = {
+          baseCurrency,
+          quoteCurrency: token,
+          rate,
+          expiresAt,
+          timestamp: timestampDate,
+        };
+        logger.verbose(`update rate ${JSON.stringify(price)}, ${JSON.stringify(rateData)}`);
+        await resolvedContext.modules.products.prices.rates.updateRates([rateData]);
+      }
 
-        res.writeHead(200);
-        res.end(JSON.stringify({ success: true }));
-        return;
-      } catch (e) {
-        res.writeHead(500);
-        res.end(JSON.stringify({ success: false, error: e.message }));
-        return;
+      if (ping) {
+        const { blockHeight, currency } = ping;
+        await modules.cryptopay.updateMostRecentBlock(currency, blockHeight);
       }
+
+      res.writeHead(200);
+      res.end(JSON.stringify({ success: true }));
+      return;
+    } catch (e) {
+      res.writeHead(500);
+      res.end(JSON.stringify({ success: false, error: e.message }));
+      return;
     }
-    res.writeHead(404);
-    res.end(JSON.stringify({ success: false }));
-  });
+  }
+  res.writeHead(404);
+  res.end(JSON.stringify({ success: false }));
 };

package/src/payment/datatrans-v2/api/makeFetcher.ts

@@ -1,8 +1,8 @@
+/// <reference lib="dom" />
 import fs from 'fs';
 import util from 'util';
 import { resolve } from 'path';
 import { createLogger } from '@unchainedshop/logger';
-import fetch, { Response } from 'node-fetch';
 
 const readFile = util.promisify(fs.readFile);
 

package/src/payment/datatrans-v2/getPaths.ts

@@ -1,10 +1,11 @@
 const {
   ROOT_URL,
-  DATATRANS_WEBHOOK_PATH,
-  DATATRANS_SUCCESS_PATH,
-  DATATRANS_ERROR_PATH,
-  DATATRANS_CANCEL_PATH,
-  DATATRANS_RETURN_PATH,
+  EMAIL_WEBSITE_URL,
+  DATATRANS_WEBHOOK_PATH = '/payment/datatrans/webhook',
+  DATATRANS_SUCCESS_PATH = '/datatrans/success',
+  DATATRANS_ERROR_PATH = '/datatrans/error',
+  DATATRANS_CANCEL_PATH = '/datatrans/cancel',
+  DATATRANS_RETURN_PATH = '/datatrans/return',
 } = process.env;
 
 type Paths = {
@@ -15,10 +16,10 @@ type Paths = {
   returnUrl: string;
 };
 
-export default (relative = false): Paths => ({
-  postUrl: `${relative ? '' : ROOT_URL}${DATATRANS_WEBHOOK_PATH || '/payment/datatrans/webhook'}`,
-  successUrl: `${relative ? '' : ROOT_URL}${DATATRANS_SUCCESS_PATH || '/payment/datatrans/success'}`,
-  cancelUrl: `${relative ? '' : ROOT_URL}${DATATRANS_CANCEL_PATH || '/payment/datatrans/cancel'}`,
-  errorUrl: `${relative ? '' : ROOT_URL}${DATATRANS_ERROR_PATH || '/payment/datatrans/error'}`,
-  returnUrl: `${relative ? '' : ROOT_URL}${DATATRANS_RETURN_PATH || '/payment/datatrans/return'}`,
+export default (): Paths => ({
+  postUrl: `${ROOT_URL}${DATATRANS_WEBHOOK_PATH}`,
+  successUrl: `${EMAIL_WEBSITE_URL}${DATATRANS_SUCCESS_PATH}`,
+  cancelUrl: `${EMAIL_WEBSITE_URL}${DATATRANS_CANCEL_PATH}`,
+  errorUrl: `${EMAIL_WEBSITE_URL}${DATATRANS_ERROR_PATH}`,
+  returnUrl: `${EMAIL_WEBSITE_URL}${DATATRANS_RETURN_PATH}`,
 });

package/src/payment/datatrans-v2/index.ts

@@ -10,13 +10,12 @@ import type {
   StatusResponseSuccess,
   ValidateResponseSuccess,
 } from './api/types';
-import setupDatatrans from './middleware';
 import parseRegistrationData from './parseRegistrationData';
 import roundedAmountFromOrder from './roundedAmountFromOrder';
 
-const logger = createLogger('unchained:core-payment:datatrans');
+export * from './middleware';
 
-export default setupDatatrans;
+const logger = createLogger('unchained:core-payment:datatrans');
 
 // v2
 const { DATATRANS_SECRET, DATATRANS_SIGN_KEY, DATATRANS_API_ENDPOINT, DATATRANS_MERCHANT_ID } =