@unchainedshop/plugins 2.0.0-beta6 → 2.0.0-beta7

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,
+        };
+        console.log('update rate', price, 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 } =

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

@@ -1,8 +1,5 @@
-import { useMiddlewareWithCurrentContext } from '@unchainedshop/api';
-import bodyParser from 'body-parser';
 import { createLogger } from '@unchainedshop/logger';
 import { Context } from '@unchainedshop/types/api';
-import getPaths from './getPaths';
 import generateSignature, { Security } from './generateSignature';
 
 import type { StatusResponseSuccess } from './api/types';
@@ -15,139 +12,75 @@ const {
 
 const logger = createLogger('unchained:core-payment:datatrans');
 
-const { postUrl, cancelUrl, errorUrl, successUrl, returnUrl } = getPaths(true);
-
-export default (app: any) => {
-  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 as any,
-        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));
-            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`);
+export const datatransHandler = 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 as any,
+      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 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({ name: e.name, code: e.code, message: e.message }));
+    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({ name: e.name, code: e.code, message: e.message }));
+        return;
       }
     }
-    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();
-  });
+  }
+  res.writeHead(404);
+  res.end();
 };

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

@@ -19,12 +19,11 @@ import {
   voidTransaction,
 } from './api';
 import { orderIsPaid } from './utils';
-import setupPostfinance from './middleware';
 import { CompletionModes, IntegrationModes, SignResponse } from './types';
 
-const { PostFinanceCheckout } = pf;
+export * from './middleware';
 
-export default setupPostfinance;
+const { PostFinanceCheckout } = pf;
 
 const {
   PFCHECKOUT_SPACE_ID,

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

@@ -1,56 +1,48 @@
-import bodyParser from 'body-parser';
-import { useMiddlewareWithCurrentContext } from '@unchainedshop/api';
 import { Context } from '@unchainedshop/types/api';
 import { createLogger } from '@unchainedshop/logger';
 import { WebhookData } from './types';
 import { getTransaction, getTransactionCompletion } from './api';
 
-const { PFCHECKOUT_WEBHOOK_PATH = '/payment/postfinance-checkout' } = process.env;
-
 const logger = createLogger('unchained:core-payment:postfinance-checkout');
 
-export default (app) => {
-  useMiddlewareWithCurrentContext(app, PFCHECKOUT_WEBHOOK_PATH, bodyParser.json());
-
-  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,
-            },
+export const postfinanceCheckoutHandler = 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`,
-        );
-        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({ name: e.name, code: e.code, message: e.message }));
-      }
-    } else {
-      logger.error(
-        `PostFinance Checkout Webhook: Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`,
+        },
+        context,
+      );
+      logger.info(
+        `PostFinance Checkout Webhook: Transaction ${transactionCompletion.linkedTransaction} marked order payment ID ${transaction.metaData.orderPaymentId} as paid`,
       );
-      res.writeHead(404);
-      res.end();
+      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({ name: e.name, code: e.code, message: e.message }));
     }
-  });
+  } else {
+    logger.error(
+      `PostFinance Checkout Webhook: Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`,
+    );
+    res.writeHead(404);
+    res.end();
+  }
 };