@unchainedshop/plugins 1.1.7 → 1.1.9

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

@@ -88,44 +88,89 @@ const fixPeriods = async (
   );
 };
 
-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');
-      }
+export default (app) => {
+  useMiddlewareWithCurrentContext(
+    app,
+    APPLE_IAP_WEBHOOK_PATH,
+    bodyParser.json({
+      strict: false,
+    }),
+  );
 
-      const transactions = responseBody?.unified_receipt?.latest_receipt_info; // eslint-disable-line
-      const latestTransaction = transactions[0];
+  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');
+        }
 
-      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,
-          },
-        });
+        const transactions = responseBody?.unified_receipt?.latest_receipt_info; // eslint-disable-line
+        const latestTransaction = transactions[0];
 
-        if (!orderPayment) throw new Error('Could not find any matching order payment');
-        const order = await modules.orders.findOrder({
-          orderId: orderPayment.orderId,
-        });
+        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,
+            );
 
-        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,
+            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
@@ -133,97 +178,55 @@ useMiddlewareWithCurrentContext(APPLE_IAP_WEBHOOK_PATH, async (req, res) => {
             },
             resolvedContext,
           );
-          const orderId = checkedOut._id;
-          const enrollment = await modules.enrollments.findEnrollment({
-            orderId,
-          });
+
           await fixPeriods(
             {
               transactionId: latestTransaction.original_transaction_id,
               transactions,
               enrollmentId: enrollment._id,
-              orderId,
+              orderId: originalOrder._id,
             },
             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}`,
-        );
+          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_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);
+          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`);
         }
-        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(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();
-});
+    res.writeHead(404);
+    res.end();
+  });
+};
 
 const AppleIAP: IPaymentAdapter = {
   ...PaymentAdapter,

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

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

package/src/payment/bity/adapter.ts

@@ -185,56 +185,58 @@ const estimateBityOrder = async (data: any, context: Context) => {
   return response.json();
 };
 
-useMiddlewareWithCurrentContext(BITY_OAUTH_INIT_PATH, async (req, res) => {
-  if (req.method === 'GET') {
-    try {
-      const resolvedContext = req.unchainedContext;
-      await checkAction(resolvedContext, actions.managePaymentProviders);
-
-      const bityAuthClient = createBityAuth();
-      const uri = bityAuthClient.code.getUri();
-      logger.info(`Bity Webhook: Login ${uri}`);
-      res.writeHead(302, {
-        Location: uri,
-      });
-      res.end();
-      return;
-    } catch (e) {
-      logger.warn(`Bity Webhook: Failed with ${e.message}`);
-      res.writeHead(503);
-      res.end(JSON.stringify(e));
-      return;
+export default (app) => {
+  useMiddlewareWithCurrentContext(app, BITY_OAUTH_INIT_PATH, async (req, res) => {
+    if (req.method === 'GET') {
+      try {
+        const resolvedContext = req.unchainedContext;
+        await checkAction(resolvedContext, actions.managePaymentProviders);
+
+        const bityAuthClient = createBityAuth();
+        const uri = bityAuthClient.code.getUri();
+        logger.info(`Bity Webhook: Login ${uri}`);
+        res.writeHead(302, {
+          Location: uri,
+        });
+        res.end();
+        return;
+      } catch (e) {
+        logger.warn(`Bity Webhook: Failed with ${e.message}`);
+        res.writeHead(503);
+        res.end(JSON.stringify(e));
+        return;
+      }
     }
-  }
-  res.writeHead(404);
-  res.end();
-});
-
-useMiddlewareWithCurrentContext(BITY_OAUTH_PATH, async (req, res, next) => {
-  bodyParser.urlencoded({ extended: false })(req, res, next);
-});
-
-useMiddlewareWithCurrentContext(BITY_OAUTH_PATH, async (req, res) => {
-  if (req.method === 'GET') {
-    try {
-      const resolvedContext = req.unchainedContext as Context;
-      await checkAction(resolvedContext, actions.managePaymentProviders);
-      const bityAuthClient = createBityAuth();
-      const user = await bityAuthClient.code.getToken(req.originalUrl);
-      await upsertBityCredentials(user, resolvedContext);
-      res.writeHead(200);
-      res.end('Bity Credentials Setup Complete');
-      return;
-    } catch (e) {
-      logger.warn(`Bity Webhook: Failed with ${e.message}`);
-      res.writeHead(503);
-      res.end(JSON.stringify(e));
-      return;
+    res.writeHead(404);
+    res.end();
+  });
+
+  useMiddlewareWithCurrentContext(app, BITY_OAUTH_PATH, async (req, res, next) => {
+    bodyParser.urlencoded({ extended: false })(req, res, next);
+  });
+
+  useMiddlewareWithCurrentContext(app, BITY_OAUTH_PATH, async (req, res) => {
+    if (req.method === 'GET') {
+      try {
+        const resolvedContext = req.unchainedContext as Context;
+        await checkAction(resolvedContext, actions.managePaymentProviders);
+        const bityAuthClient = createBityAuth();
+        const user = await bityAuthClient.code.getToken(req.originalUrl);
+        await upsertBityCredentials(user, resolvedContext);
+        res.writeHead(200);
+        res.end('Bity Credentials Setup Complete');
+        return;
+      } catch (e) {
+        logger.warn(`Bity Webhook: Failed with ${e.message}`);
+        res.writeHead(503);
+        res.end(JSON.stringify(e));
+        return;
+      }
     }
-  }
-  res.writeHead(404);
-  res.end();
-});
+    res.writeHead(404);
+    res.end();
+  });
+};
 
 let bityAuthClient;
 const loadToken = async (context: Context) => {

package/src/payment/bity/index.ts

@@ -1,3 +1,4 @@
-import './adapter';
+import setupBity from './adapter';
 
+export default setupBity;
 export { configureBityModule } from './module/configureBityModule';

package/src/payment/cryptopay.ts

@@ -30,79 +30,81 @@ enum CryptopayCurrencies { // eslint-disable-line
 const MAX_RATE_AGE = parseInt(CRYPTOPAY_MAX_RATE_AGE, 10);
 const MAX_ALLOWED_DIFF = parseFloat(CRYPTOPAY_MAX_CONV_DIFF); // Accept payments when the converted amount differs by adapterActions much (in percent)
 
-useMiddlewareWithCurrentContext(CRYPTOPAY_WEBHOOK_PATH, bodyParser.json());
-
-useMiddlewareWithCurrentContext(CRYPTOPAY_WEBHOOK_PATH, async (request, response) => {
-  // Return a 200 response to acknowledge receipt of the event
-  const resolvedContext = request.unchainedContext as Context;
-  const { currency, contract, decimals, address, amount, secret } = request.body;
-  if (secret !== CRYPTOPAY_SECRET) {
-    logger.warn(`Cryptopay Plugin: Invalid Cryptopay Secret provided`);
-    response.end(JSON.stringify({ success: false }));
-    return;
-  }
-  const orderPayment = await resolvedContext.modules.orders.payments.findOrderPaymentByContextData({
-    context: { currency, address },
-  });
-  if (orderPayment) {
-    if (currency === CryptopayCurrencies.ETH && contract && contract !== '') {
-      const ERC20CurrencyCount = await resolvedContext.modules.currencies.count({
-        includeInactive: false,
-        contractAddress: contract,
-      });
-      if (!ERC20CurrencyCount) {
-        logger.warn(`Cryptopay Plugin: ERC20 token address ${contract} not whitelisted.`);
-        response.end(JSON.stringify({ success: false }));
-        return;
-      }
+export default (app) => {
+  useMiddlewareWithCurrentContext(app, CRYPTOPAY_WEBHOOK_PATH, bodyParser.json());
+
+  useMiddlewareWithCurrentContext(app, CRYPTOPAY_WEBHOOK_PATH, async (request, response) => {
+    // Return a 200 response to acknowledge receipt of the event
+    const resolvedContext = request.unchainedContext as Context;
+    const { currency, contract, decimals, address, amount, secret } = request.body;
+    if (secret !== CRYPTOPAY_SECRET) {
+      logger.warn(`Cryptopay Plugin: Invalid Cryptopay Secret provided`);
+      response.end(JSON.stringify({ success: false }));
+      return;
     }
-    const order = await resolvedContext.modules.orders.findOrder({
-      orderId: orderPayment.orderId,
-    });
-    const pricing = OrderPricingSheet({
-      calculation: order.calculation,
-      currency: order.currency,
+    const orderPayment = await resolvedContext.modules.orders.payments.findOrderPaymentByContextData({
+      context: { currency, address },
     });
-    const totalAmount = pricing?.total({ useNetPrice: false }).amount;
-    let convertedAmount: number;
-    if (order.currency === currency) {
-      convertedAmount = amount / 10 ** (decimals - 8); // All crypto native prices denoted with 8 decimals
-    } else {
-      // Need to convert
-      const rate = await resolvedContext.modules.products.prices.rates.getRate(
-        order.currency,
-        contract && contract !== '' ? contract : currency, // Convert to the smart contract if given
-        MAX_RATE_AGE,
-      );
-      if (rate) {
-        // We assume that we are converting to a fiat currency here (with 2 decimals).
-        // Paying an order with prices in crypto in another crypto is not supported.
-        convertedAmount = Math.round((amount / 10 ** decimals) * rate * 100);
+    if (orderPayment) {
+      if (currency === CryptopayCurrencies.ETH && contract && contract !== '') {
+        const ERC20CurrencyCount = await resolvedContext.modules.currencies.count({
+          includeInactive: false,
+          contractAddress: contract,
+        });
+        if (!ERC20CurrencyCount) {
+          logger.warn(`Cryptopay Plugin: ERC20 token address ${contract} not whitelisted.`);
+          response.end(JSON.stringify({ success: false }));
+          return;
+        }
+      }
+      const order = await resolvedContext.modules.orders.findOrder({
+        orderId: orderPayment.orderId,
+      });
+      const pricing = OrderPricingSheet({
+        calculation: order.calculation,
+        currency: order.currency,
+      });
+      const totalAmount = pricing?.total({ useNetPrice: false }).amount;
+      let convertedAmount: number;
+      if (order.currency === currency) {
+        convertedAmount = amount / 10 ** (decimals - 8); // All crypto native prices denoted with 8 decimals
+      } else {
+        // Need to convert
+        const rate = await resolvedContext.modules.products.prices.rates.getRate(
+          order.currency,
+          contract && contract !== '' ? contract : currency, // Convert to the smart contract if given
+          MAX_RATE_AGE,
+        );
+        if (rate) {
+          // We assume that we are converting to a fiat currency here (with 2 decimals).
+          // Paying an order with prices in crypto in another crypto is not supported.
+          convertedAmount = Math.round((amount / 10 ** decimals) * rate * 100);
+        }
+      }
+      if (convertedAmount && convertedAmount >= totalAmount * (1 - MAX_ALLOWED_DIFF)) {
+        await resolvedContext.modules.orders.checkout(
+          order._id,
+          {
+            transactionContext: { address },
+            paymentContext: { address },
+          },
+          resolvedContext,
+        );
+        response.end(JSON.stringify({ success: true }));
+      } else {
+        logger.warn(
+          `Cryptopay Plugin: OrderPayment ${orderPayment._id} not marked as paid. Converted amount is ${convertedAmount}`,
+        );
+        response.end(JSON.stringify({ success: false }));
       }
-    }
-    if (convertedAmount && convertedAmount >= totalAmount * (1 - MAX_ALLOWED_DIFF)) {
-      await resolvedContext.modules.orders.checkout(
-        order._id,
-        {
-          transactionContext: { address },
-          paymentContext: { address },
-        },
-        resolvedContext,
-      );
-      response.end(JSON.stringify({ success: true }));
     } else {
-      logger.warn(
-        `Cryptopay Plugin: OrderPayment ${orderPayment._id} not marked as paid. Converted amount is ${convertedAmount}`,
+      logger.info(
+        `Cryptopay Plugin: No orderPayment with address ${address} and currency ${currency} found`,
       );
       response.end(JSON.stringify({ success: false }));
     }
-  } else {
-    logger.info(
-      `Cryptopay Plugin: No orderPayment with address ${address} and currency ${currency} found`,
-    );
-    response.end(JSON.stringify({ success: false }));
-  }
-});
+  });
+};
 
 const Cryptopay: IPaymentAdapter = {
   ...PaymentAdapter,

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

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