@unchainedshop/plugins 2.0.0-beta6 → 2.0.0-beta8

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();
+  }
 };

package/src/payment/stripe.ts

@@ -1,7 +1,5 @@
 import { Context } from '@unchainedshop/types/api';
 import { IPaymentAdapter } from '@unchainedshop/types/payments';
-import bodyParser from 'body-parser';
-import { useMiddlewareWithCurrentContext } from '@unchainedshop/api';
 import { PaymentAdapter, PaymentDirector, PaymentError } from '@unchainedshop/core-payment';
 import { createLogger } from '@unchainedshop/logger';
 
@@ -18,96 +16,83 @@ import createStripeClient from 'stripe';
 
 const logger = createLogger('unchained:core-payment:stripe');
 
-const {
-  STRIPE_SECRET,
-  STRIPE_ENDPOINT_SECRET,
-  EMAIL_WEBSITE_NAME,
-  STRIPE_WEBHOOK_PATH = '/payment/stripe',
-} = process.env;
+const { STRIPE_SECRET, STRIPE_ENDPOINT_SECRET, EMAIL_WEBSITE_NAME } = process.env;
 
 // eslint-disable-next-line
 // @ts-ignore
 const stripe = createStripeClient(STRIPE_SECRET);
 
-export default (app) => {
-  useMiddlewareWithCurrentContext(
-    app,
-    STRIPE_WEBHOOK_PATH,
-    bodyParser.raw({ type: 'application/json' }),
-  );
-
-  useMiddlewareWithCurrentContext(app, STRIPE_WEBHOOK_PATH, async (request, response) => {
-    const sig = request.headers['stripe-signature'];
-    const resolvedContext = request.unchainedContext as Context;
-    const { modules, services } = resolvedContext;
-
-    let event;
-
-    try {
-      event = stripe.webhooks.constructEvent(request.body, sig, STRIPE_ENDPOINT_SECRET);
-    } catch (err) {
-      response.writeHead(400);
-      response.end(`Webhook Error: ${err.message}`);
-      return;
-    }
-
-    try {
-      if (event.type === 'payment_intent.succeeded') {
-        const paymentIntent = event.data.object;
-        const orderPaymentId = paymentIntent.metadata?.orderPaymentId;
-
-        await modules.orders.payments.logEvent(orderPaymentId, event, resolvedContext.userId);
-
-        const orderPayment = await modules.orders.payments.findOrderPayment({
-          orderPaymentId,
-        });
-
-        const order = await modules.orders.checkout(
-          orderPayment.orderId,
-          {
-            transactionContext: {
-              paymentIntentId: paymentIntent.id,
-            },
-            paymentContext: {
-              paymentIntentId: paymentIntent.id,
-            },
+export const stripeHandler = async (request, response) => {
+  const sig = request.headers['stripe-signature'];
+  const resolvedContext = request.unchainedContext as Context;
+  const { modules, services } = resolvedContext;
+
+  let event;
+
+  try {
+    event = stripe.webhooks.constructEvent(request.body, sig, STRIPE_ENDPOINT_SECRET);
+  } catch (err) {
+    response.writeHead(400);
+    response.end(`Webhook Error: ${err.message}`);
+    return;
+  }
+
+  try {
+    if (event.type === 'payment_intent.succeeded') {
+      const paymentIntent = event.data.object;
+      const orderPaymentId = paymentIntent.metadata?.orderPaymentId;
+
+      await modules.orders.payments.logEvent(orderPaymentId, event, resolvedContext.userId);
+
+      const orderPayment = await modules.orders.payments.findOrderPayment({
+        orderPaymentId,
+      });
+
+      const order = await modules.orders.checkout(
+        orderPayment.orderId,
+        {
+          transactionContext: {
+            paymentIntentId: paymentIntent.id,
           },
-          resolvedContext,
-        );
-
-        logger.info(`Stripe Webhook: Unchained confirmed checkout for order ${order.orderNumber}`, {
-          orderId: order._id,
-        });
-      } else if (event.type === 'setup_intent.succeeded') {
-        const setupIntent = event.data.object;
-        const { paymentProviderId, userId } = setupIntent.metadata;
-
-        await services.payment.registerPaymentCredentials(
-          paymentProviderId,
-          {
-            transactionContext: {
-              setupIntentId: setupIntent.id,
-            },
+          paymentContext: {
+            paymentIntentId: paymentIntent.id,
           },
-          resolvedContext,
-        );
-
-        logger.info(`Stripe Webhook: Unchained registered payment credentials for ${userId}`, {
-          userId,
-        });
-      } else {
-        response.writeHead(404);
-        response.end();
-        return;
-      }
-    } catch (err) {
-      response.writeHead(400);
-      response.end(`Webhook Error: ${err.message}`);
+        },
+        resolvedContext,
+      );
+
+      logger.info(`Stripe Webhook: Unchained confirmed checkout for order ${order.orderNumber}`, {
+        orderId: order._id,
+      });
+    } else if (event.type === 'setup_intent.succeeded') {
+      const setupIntent = event.data.object;
+      const { paymentProviderId, userId } = setupIntent.metadata;
+
+      await services.payment.registerPaymentCredentials(
+        paymentProviderId,
+        {
+          transactionContext: {
+            setupIntentId: setupIntent.id,
+          },
+        },
+        resolvedContext,
+      );
+
+      logger.info(`Stripe Webhook: Unchained registered payment credentials for ${userId}`, {
+        userId,
+      });
+    } else {
+      response.writeHead(404);
+      response.end();
       return;
     }
-    // Return a 200 response to acknowledge receipt of the event
-    response.end(JSON.stringify({ received: true }));
-  });
+  } catch (err) {
+    response.writeHead(400);
+    response.end(`Webhook Error: ${err.message}`);
+    return;
+  }
+  // Return a 200 response to acknowledge receipt of the event
+  response.end(JSON.stringify({ received: true }));
 };
 
 const createRegistrationIntent = async ({ userId, name, email, paymentProviderId }, options = {}) => {

package/src/payment/worldline-saferpay/worldline-saferpay-client/api/SaferpayConnection.ts

@@ -1,5 +1,4 @@
-import fetch from 'node-fetch';
-
+/// <reference lib="dom" />
 export class SaferpayConnection {
   private baseUrl: string;
 
@@ -27,10 +26,11 @@ export class SaferpayConnection {
   }
 
   public async post(uri: string, data: object): Promise<any> {
-    return fetch(this.buildUrl(uri), {
+    const res = await fetch(this.buildUrl(uri), {
       method: 'POST',
       body: JSON.stringify(data),
       headers: this.getHeaders(),
-    }).then((res: any) => res.json());
+    });
+    return res.json();
   }
 }

package/src/plugins-index.ts

@@ -0,0 +1,151 @@
+import { useMiddlewareWithCurrentContext } from '@unchainedshop/api/express';
+import { UnchainedCore } from '@unchainedshop/types/core';
+import express from 'express';
+
+// Delivery
+import './delivery/post';
+import './delivery/pick-mup';
+import './delivery/send-message';
+import './delivery/stores';
+
+// Payment
+import './payment/invoice';
+import './payment/invoice-prepaid';
+import './payment/paypal-checkout';
+import './payment/worldline-saferpay';
+import { datatransHandler } from './payment/datatrans-v2';
+import { configureCryptopayModule, cryptopayHandler } from './payment/cryptopay';
+import { appleIAPHandler, configureAppleTransactionsModule } from './payment/apple-iap';
+import { stripeHandler } from './payment/stripe';
+import { postfinanceCheckoutHandler } from './payment/postfinance-checkout';
+
+// Warehousing
+import './warehousing/store';
+import './warehousing/eth-minter';
+
+// Pricing
+import './pricing/discount-half-price-manual';
+import './pricing/discount-100-off';
+import './pricing/free-payment';
+import './pricing/free-delivery';
+import './pricing/order-items';
+import './pricing/order-discount';
+import './pricing/order-delivery';
+import './pricing/order-payment';
+import './pricing/product-catalog-price';
+import './pricing/product-price-rateconversion';
+import './pricing/product-discount';
+import './pricing/product-swiss-tax';
+import './pricing/delivery-swiss-tax';
+
+// Filter & Search
+import './filters/strict-equal';
+import './filters/local-search';
+
+// Quotations
+import './quotations/manual';
+
+// Enrollments
+import './enrollments/licensed';
+
+// Event Queue
+import './events/node-event-emitter';
+
+// Workers
+import './worker/bulk-import';
+import './worker/zombie-killer';
+import './worker/message';
+import './worker/external';
+import './worker/http-request';
+import './worker/heartbeat';
+import './worker/email';
+import './worker/sms';
+import './worker/update-ecb-rates';
+import './worker/update-coinbase-rates';
+import { configureExportToken } from './worker/export-token';
+import { configureGenerateOrderAutoscheduling } from './worker/enrollment-order-generator';
+import { configureUpdateTokenOwnership } from './worker/update-token-ownership';
+
+// Asset Management
+import './files/gridfs/gridfs-adapter';
+import { gridfsHandler } from './files/gridfs/gridfs-webhook';
+import { configureGridFSFileUploadModule } from './files/gridfs';
+
+const {
+  CRYPTOPAY_WEBHOOK_PATH = '/payment/cryptopay',
+  STRIPE_WEBHOOK_PATH = '/payment/stripe',
+  PFCHECKOUT_WEBHOOK_PATH = '/payment/postfinance-checkout',
+  DATATRANS_WEBHOOK_PATH = '/payment/datatrans/webhook',
+  APPLE_IAP_WEBHOOK_PATH = '/payment/apple-iap',
+  // MINIO_PUT_SERVER_PATH = '/minio',
+  GRIDFS_PUT_SERVER_PATH = '/gridfs',
+} = process.env;
+
+// import './files/minio/minio-adapter';
+// import { minioHandler } from './files/minio/minio-webhook';
+
+export const defaultModules = {
+  appleTransactions: {
+    configure: configureAppleTransactionsModule,
+  },
+  gridfsFileUploads: {
+    configure: configureGridFSFileUploadModule,
+  },
+  cryptopay: {
+    configure: configureCryptopayModule,
+  },
+};
+
+export const connectDefaultPluginsToExpress4 = (
+  app,
+  { unchainedAPI }: { unchainedAPI: UnchainedCore },
+) => {
+  useMiddlewareWithCurrentContext(app, GRIDFS_PUT_SERVER_PATH, gridfsHandler);
+
+  useMiddlewareWithCurrentContext(app, CRYPTOPAY_WEBHOOK_PATH, express.json(), cryptopayHandler);
+
+  useMiddlewareWithCurrentContext(
+    app,
+    STRIPE_WEBHOOK_PATH,
+    express.raw({ type: 'application/json' }),
+    stripeHandler,
+  );
+
+  useMiddlewareWithCurrentContext(
+    app,
+    PFCHECKOUT_WEBHOOK_PATH,
+    express.json(),
+    postfinanceCheckoutHandler,
+  );
+
+  useMiddlewareWithCurrentContext(
+    app,
+    DATATRANS_WEBHOOK_PATH,
+    express.text({
+      type: 'application/json',
+    }),
+    datatransHandler,
+  );
+
+  useMiddlewareWithCurrentContext(
+    app,
+    APPLE_IAP_WEBHOOK_PATH,
+    express.json({
+      strict: false,
+    }),
+    appleIAPHandler,
+  );
+
+  // useMiddlewareWithCurrentContext(
+  //   app,
+  //   MINIO_PUT_SERVER_PATH,
+  //   express.json({
+  //     strict: false,
+  //   }),
+  //   minioHandler
+  // );
+
+  configureExportToken(unchainedAPI);
+  configureUpdateTokenOwnership(unchainedAPI);
+  configureGenerateOrderAutoscheduling();
+};