@unchainedshop/plugins 1.1.7 → 1.2.1

package/src/payment/braintree.ts

@@ -91,7 +91,7 @@ const BraintreeDirect: IPaymentAdapter = {
       },
 
       sign: async () => {
-        const braintree = require('braintree'); // eslint-disable-line
+        const braintree = (await import('braintree')).default; // eslint-disable-line
         const gateway = getGateway(braintree);
         const result = await gateway.clientToken.generate({});
         if (result.success) {
@@ -105,7 +105,7 @@ const BraintreeDirect: IPaymentAdapter = {
         const { order } = params.paymentContext;
         if (!paypalPaymentMethodNonce)
           throw new Error('You have to provide paypalPaymentMethodNonce in paymentContext');
-        const braintree = require('braintree'); // eslint-disable-line
+        const braintree = (await import('braintree')).default; // eslint-disable-line
         const gateway = getGateway(braintree);
         const address = order.billingAddress || {};
         const pricing = modules.orders.pricingSheet(order);

package/src/payment/cryptopay.ts

@@ -14,7 +14,7 @@ const logger = createLogger('unchained:core-payment:cryptopay');
 
 const {
   CRYPTOPAY_SECRET,
-  CRYPTOPAY_WEBHOOK_PATH = '/graphql/cryptopay',
+  CRYPTOPAY_WEBHOOK_PATH = '/payment/cryptopay',
   CRYPTOPAY_BTC_XPUB,
   CRYPTOPAY_ETH_XPUB,
   CRYPTOPAY_BTC_TESTNET = false,
@@ -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 orderPayment = await resolvedContext.modules.orders.payments.findOrderPaymentByContextData({
+      context: { currency, address },
     });
-    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 (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;

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

@@ -17,131 +17,137 @@ const logger = createLogger('unchained:core-payment:datatrans');
 
 const { postUrl, cancelUrl, errorUrl, successUrl, returnUrl } = getPaths(true);
 
-useMiddlewareWithCurrentContext(
-  postUrl,
-  bodyParser.text({
-    type: 'application/json',
-  }),
-);
-
-useMiddlewareWithCurrentContext(cancelUrl, bodyParser.urlencoded({ extended: false }));
-
-useMiddlewareWithCurrentContext(errorUrl, bodyParser.urlencoded({ extended: false }));
-
-useMiddlewareWithCurrentContext(successUrl, bodyParser.urlencoded({ extended: false }));
-
-useMiddlewareWithCurrentContext(returnUrl, bodyParser.urlencoded({ extended: false }));
-
-useMiddlewareWithCurrentContext(postUrl, async (req, res) => {
-  const resolvedContext = req.unchainedContext as Context;
-  const { services, modules } = resolvedContext;
-  const signature = req.headers['datatrans-signature'];
-  if (req.method === 'POST' && signature) {
-    const [rawTimestamp, rawHash] = signature.split(',');
-    const [, hash] = rawHash.split('=');
-    const [, timestamp] = rawTimestamp.split('=');
-
-    const comparableSignature = generateSignature({
-      security: DATATRANS_SECURITY,
-      signKey: DATATRANS_SIGN2_KEY || DATATRANS_SIGN_KEY,
-    })(timestamp, req.body);
-
-    if (hash !== comparableSignature) {
-      logger.error(`Datatrans Plugin: Hash mismatch: ${signature} / ${comparableSignature}`, req.body);
-      res.writeHead(403);
-      res.end('Hash mismatch');
-      return;
-    }
+export default (app) => {
+  useMiddlewareWithCurrentContext(
+    app,
+    postUrl,
+    bodyParser.text({
+      type: 'application/json',
+    }),
+  );
+
+  useMiddlewareWithCurrentContext(app, cancelUrl, bodyParser.urlencoded({ extended: false }));
+
+  useMiddlewareWithCurrentContext(app, errorUrl, bodyParser.urlencoded({ extended: false }));
+
+  useMiddlewareWithCurrentContext(app, successUrl, bodyParser.urlencoded({ extended: false }));
+
+  useMiddlewareWithCurrentContext(app, returnUrl, bodyParser.urlencoded({ extended: false }));
+
+  useMiddlewareWithCurrentContext(app, postUrl, async (req, res) => {
+    const resolvedContext = req.unchainedContext as Context;
+    const { services, modules } = resolvedContext;
+    const signature = req.headers['datatrans-signature'];
+    if (req.method === 'POST' && signature) {
+      const [rawTimestamp, rawHash] = signature.split(',');
+      const [, hash] = rawHash.split('=');
+      const [, timestamp] = rawTimestamp.split('=');
+
+      const comparableSignature = generateSignature({
+        security: DATATRANS_SECURITY,
+        signKey: DATATRANS_SIGN2_KEY || DATATRANS_SIGN_KEY,
+      })(timestamp, req.body);
+
+      if (hash !== comparableSignature) {
+        logger.error(`Datatrans Plugin: Hash mismatch: ${signature} / ${comparableSignature}`, req.body);
+        res.writeHead(403);
+        res.end('Hash mismatch');
+        return;
+      }
 
-    const transaction: StatusResponseSuccess = JSON.parse(req.body) as StatusResponseSuccess;
-
-    if (transaction.status === 'authorized') {
-      const userId = transaction.refno2;
-      const referenceId = Buffer.from(transaction.refno, 'base64').toString('hex');
-
-      try {
-        if (transaction.type === 'card_check') {
-          const paymentProviderId = referenceId;
-          const paymentCredentials = await services.payment.registerPaymentCredentials(
-            paymentProviderId,
-            { transactionContext: { transactionId: transaction.transactionId } },
-            { ...resolvedContext, userId },
-          );
-          logger.info(`Datatrans Webhook: Unchained registered payment credentials for ${userId}`, {
-            userId,
-          });
-          res.writeHead(200);
-          res.end(JSON.stringify(paymentCredentials));
+      const transaction: StatusResponseSuccess = JSON.parse(req.body) as StatusResponseSuccess;
+
+      if (transaction.status === 'authorized') {
+        const userId = transaction.refno2;
+        const referenceId = Buffer.from(transaction.refno, 'base64').toString('hex');
+
+        try {
+          if (transaction.type === 'card_check') {
+            const paymentProviderId = referenceId;
+            const paymentCredentials = await services.payment.registerPaymentCredentials(
+              paymentProviderId,
+              { transactionContext: { transactionId: transaction.transactionId } },
+              { ...resolvedContext, userId },
+            );
+            logger.info(`Datatrans Webhook: Unchained registered payment credentials for ${userId}`, {
+              userId,
+            });
+            res.writeHead(200);
+            res.end(JSON.stringify(paymentCredentials));
+            return;
+          }
+          if (transaction.type === 'payment') {
+            const orderPaymentId = referenceId;
+            const orderPayment = await modules.orders.payments.findOrderPayment({
+              orderPaymentId,
+            });
+            if (!orderPayment) throw new Error(`Order Payment with id ${orderPaymentId} not found`);
+
+            const order = await modules.orders.checkout(
+              orderPayment.orderId,
+              { paymentContext: { transactionId: transaction.transactionId } },
+              { ...resolvedContext, userId },
+            );
+            res.writeHead(200);
+            logger.info(
+              `Datatrans Webhook: Unchained confirmed checkout for order ${order.orderNumber}`,
+              {
+                orderId: order._id,
+              },
+            );
+            res.end(JSON.stringify(order));
+            return;
+          }
+        } catch (e) {
+          logger.error(`Datatrans Webhook: Unchained rejected to checkout with message`, e);
+          res.writeHead(500);
+          res.end(JSON.stringify(e));
           return;
         }
-        if (transaction.type === 'payment') {
-          const orderPaymentId = referenceId;
-          const orderPayment = await modules.orders.payments.findOrderPayment({
-            orderPaymentId,
-          });
-          if (!orderPayment) throw new Error(`Order Payment with id ${orderPaymentId} not found`);
-
-          const order = await modules.orders.checkout(
-            orderPayment.orderId,
-            { paymentContext: { transactionId: transaction.transactionId } },
-            resolvedContext,
-          );
-          res.writeHead(200);
-          logger.info(`Datatrans Webhook: Unchained confirmed checkout for order ${order.orderNumber}`, {
-            orderId: order._id,
-          });
-          res.end(JSON.stringify(order));
-          return;
-        }
-      } catch (e) {
-        logger.error(`Datatrans Webhook: Unchained rejected to checkout with message`, e);
-        res.writeHead(500);
-        res.end(JSON.stringify(e));
-        return;
       }
     }
-  }
-  res.writeHead(404);
-  res.end();
-});
-
-useMiddlewareWithCurrentContext(successUrl, async (req, res) => {
-  if (req.method === 'GET') {
-    const { datatransTrxId } = req.query;
-    res.end(`Payment successful\nTransaction ID: ${datatransTrxId}`);
-    return;
-  }
-  res.writeHead(404);
-  res.end();
-});
-
-useMiddlewareWithCurrentContext(errorUrl, async (req, res) => {
-  if (req.method === 'GET') {
-    const { datatransTrxId } = req.query;
-    res.end(`Payment error\nTransaction ID: ${datatransTrxId}`);
-    return;
-  }
-  res.writeHead(404);
-  res.end();
-});
-
-useMiddlewareWithCurrentContext(cancelUrl, async (req, res) => {
-  if (req.method === 'GET') {
-    const { datatransTrxId } = req.query;
-    res.end(`Payment cancelled\nTransaction ID: ${datatransTrxId}`);
-    return;
-  }
-  res.writeHead(404);
-  res.end();
-});
-
-useMiddlewareWithCurrentContext(returnUrl, async (req, res) => {
-  if (req.method === 'GET') {
-    const { datatransTrxId } = req.query;
-    res.end(
-      `Secure Fields Payment authenticated\nTransaction ID: ${datatransTrxId}\nNeeds authorization`,
-    );
-  }
-  res.writeHead(404);
-  res.end();
-});
+    res.writeHead(404);
+    res.end();
+  });
+
+  useMiddlewareWithCurrentContext(app, successUrl, async (req, res) => {
+    if (req.method === 'GET') {
+      const { datatransTrxId } = req.query;
+      res.end(`Payment successful\nTransaction ID: ${datatransTrxId}`);
+      return;
+    }
+    res.writeHead(404);
+    res.end();
+  });
+
+  useMiddlewareWithCurrentContext(app, errorUrl, async (req, res) => {
+    if (req.method === 'GET') {
+      const { datatransTrxId } = req.query;
+      res.end(`Payment error\nTransaction ID: ${datatransTrxId}`);
+      return;
+    }
+    res.writeHead(404);
+    res.end();
+  });
+
+  useMiddlewareWithCurrentContext(app, cancelUrl, async (req, res) => {
+    if (req.method === 'GET') {
+      const { datatransTrxId } = req.query;
+      res.end(`Payment cancelled\nTransaction ID: ${datatransTrxId}`);
+      return;
+    }
+    res.writeHead(404);
+    res.end();
+  });
+
+  useMiddlewareWithCurrentContext(app, returnUrl, async (req, res) => {
+    if (req.method === 'GET') {
+      const { datatransTrxId } = req.query;
+      res.end(
+        `Secure Fields Payment authenticated\nTransaction ID: ${datatransTrxId}\nNeeds authorization`,
+      );
+    }
+    res.writeHead(404);
+    res.end();
+  });
+};

package/src/payment/paypal-checkout.ts

@@ -2,7 +2,7 @@ import { IPaymentAdapter } from '@unchainedshop/types/payments';
 import { PaymentDirector, PaymentAdapter, PaymentError } from '@unchainedshop/core-payment';
 import { createLogger } from '@unchainedshop/logger';
 
-const checkoutNodeJssdk = require('@paypal/checkout-server-sdk'); // eslint-disable-line
+import checkoutNodeJssdk from '@paypal/checkout-server-sdk'; // eslint-disable-line
 
 const logger = createLogger('unchained:core-payment');
 

package/src/payment/postfinance-checkout/index.ts

@@ -17,9 +17,11 @@ import {
   voidTransaction,
 } from './api';
 import { orderIsPaid } from './utils';
-import './middleware';
+import setupPostfinance from './middleware';
 import { CompletionModes, IntegrationModes, SignResponse } from './types';
 
+export default setupPostfinance;
+
 const {
   PFCHECKOUT_SPACE_ID,
   PFCHECKOUT_USER_ID,

package/src/payment/postfinance-checkout/middleware.ts

@@ -5,50 +5,52 @@ import { createLogger } from '@unchainedshop/logger';
 import { WebhookData } from './types';
 import { getTransaction, getTransactionCompletion } from './api';
 
-const { PFCHECKOUT_WEBHOOK_PATH = '/graphql/postfinance-checkout' } = process.env;
+const { PFCHECKOUT_WEBHOOK_PATH = '/payment/postfinance-checkout' } = process.env;
 
 const logger = createLogger('unchained:core-payment:postfinance-checkout');
 
-useMiddlewareWithCurrentContext(PFCHECKOUT_WEBHOOK_PATH, bodyParser.json());
+export default (app) => {
+  useMiddlewareWithCurrentContext(app, PFCHECKOUT_WEBHOOK_PATH, bodyParser.json());
 
-useMiddlewareWithCurrentContext(PFCHECKOUT_WEBHOOK_PATH, async (req, res) => {
-  const context = req.unchainedContext as Context;
-  const data = req.body as WebhookData;
-  if (data.listenerEntityTechnicalName === 'TransactionCompletion') {
-    try {
-      const transactionCompletion = await getTransactionCompletion(data.entityId as unknown as string);
-      const transaction = await getTransaction(
-        transactionCompletion.linkedTransaction as unknown as string,
-      );
-      const { orderPaymentId } = transaction.metaData as { orderPaymentId: string };
-      const orderPayment = await context.modules.orders.payments.findOrderPayment({
-        orderPaymentId,
-      });
-      if (!orderPayment) throw new Error('Order Payment not found');
-      const order = await context.modules.orders.checkout(
-        orderPayment.orderId,
-        {
-          paymentContext: {
-            transactionId: transactionCompletion.linkedTransaction,
+  useMiddlewareWithCurrentContext(app, PFCHECKOUT_WEBHOOK_PATH, async (req, res) => {
+    const context = req.unchainedContext as Context;
+    const data = req.body as WebhookData;
+    if (data.listenerEntityTechnicalName === 'TransactionCompletion') {
+      try {
+        const transactionCompletion = await getTransactionCompletion(data.entityId as unknown as string);
+        const transaction = await getTransaction(
+          transactionCompletion.linkedTransaction as unknown as string,
+        );
+        const { orderPaymentId } = transaction.metaData as { orderPaymentId: string };
+        const orderPayment = await context.modules.orders.payments.findOrderPayment({
+          orderPaymentId,
+        });
+        if (!orderPayment) throw new Error('Order Payment not found');
+        const order = await context.modules.orders.checkout(
+          orderPayment.orderId,
+          {
+            paymentContext: {
+              transactionId: transactionCompletion.linkedTransaction,
+            },
           },
-        },
-        context,
-      );
-      logger.info(
-        `PostFinance Checkout Webhook: Transaction ${transactionCompletion.linkedTransaction} marked order payment ID ${transaction.metaData.orderPaymentId} as paid`,
+          context,
+        );
+        logger.info(
+          `PostFinance Checkout Webhook: Transaction ${transactionCompletion.linkedTransaction} marked order payment ID ${transaction.metaData.orderPaymentId} as paid`,
+        );
+        res.writeHead(200);
+        res.end(`Order marked as paid: ${order.orderNumber}`);
+      } catch (e) {
+        logger.error(`PostFinance Checkout Webhook: Unchained rejected to checkout with message`, e);
+        res.writeHead(500);
+        res.end(JSON.stringify(e));
+      }
+    } else {
+      logger.error(
+        `PostFinance Checkout Webhook: Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`,
       );
-      res.writeHead(200);
-      res.end(`Order marked as paid: ${order.orderNumber}`);
-    } catch (e) {
-      logger.error(`PostFinance Checkout Webhook: Unchained rejected to checkout with message`, e);
-      res.writeHead(500);
-      res.end(JSON.stringify(e));
+      res.writeHead(404);
+      res.end();
     }
-  } else {
-    logger.error(
-      `PostFinance Checkout Webhook: Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`,
-    );
-    res.writeHead(404);
-    res.end();
-  }
-});
+  });
+};