@unchainedshop/plugins 1.1.4 → 1.1.9

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

@@ -1,4 +1,4 @@
-import { useMiddlewareWithCurrentContext } from 'meteor/unchained:api';
+import { useMiddlewareWithCurrentContext } from '@unchainedshop/api';
 import bodyParser from 'body-parser';
 import { createLogger } from '@unchainedshop/logger';
 import { Context } from '@unchainedshop/types/api';
@@ -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,
+            );
+            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

@@ -1,5 +1,5 @@
 import bodyParser from 'body-parser';
-import { useMiddlewareWithCurrentContext } from 'meteor/unchained:api';
+import { useMiddlewareWithCurrentContext } from '@unchainedshop/api';
 import { Context } from '@unchainedshop/types/api';
 import { createLogger } from '@unchainedshop/logger';
 import { WebhookData } from './types';
@@ -9,46 +9,48 @@ const { PFCHECKOUT_WEBHOOK_PATH = '/graphql/postfinance-checkout' } = process.en
 
 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();
-  }
-});
+  });
+};

package/src/payment/stripe.ts

@@ -1,19 +1,10 @@
 import { Context } from '@unchainedshop/types/api';
 import { IPaymentAdapter } from '@unchainedshop/types/payments';
 import bodyParser from 'body-parser';
-import { useMiddlewareWithCurrentContext } from 'meteor/unchained:api';
+import { useMiddlewareWithCurrentContext } from '@unchainedshop/api';
 import { PaymentAdapter, PaymentDirector, PaymentError } from '@unchainedshop/core-payment';
 import { createLogger } from '@unchainedshop/logger';
 
-const logger = createLogger('unchained:core-payment:stripe');
-
-const {
-  STRIPE_SECRET,
-  STRIPE_ENDPOINT_SECRET,
-  EMAIL_WEBSITE_NAME,
-  STRIPE_WEBHOOK_PATH = '/graphql/stripe',
-} = process.env;
-
 /*
 Test Webhooks:
 
@@ -23,82 +14,99 @@ stripe listen --forward-to http://localhost:3000/graphql/stripe
 stripe trigger payment_intent.succeeded
 */
 
-const stripe = require('stripe')(STRIPE_SECRET); // eslint-disable-line
+import createStripeClient from 'stripe';
+
+const logger = createLogger('unchained:core-payment:stripe');
+
+const {
+  STRIPE_SECRET,
+  STRIPE_ENDPOINT_SECRET,
+  EMAIL_WEBSITE_NAME,
+  STRIPE_WEBHOOK_PATH = '/graphql/stripe',
+} = process.env;
+
+const stripe = createStripeClient(STRIPE_SECRET);
 
-useMiddlewareWithCurrentContext(STRIPE_WEBHOOK_PATH, bodyParser.raw({ type: 'application/json' }));
+export default (app) => {
+  useMiddlewareWithCurrentContext(
+    app,
+    STRIPE_WEBHOOK_PATH,
+    bodyParser.raw({ type: 'application/json' }),
+  );
 
-useMiddlewareWithCurrentContext(STRIPE_WEBHOOK_PATH, async (request, response) => {
-  const sig = request.headers['stripe-signature'];
-  const resolvedContext = request.unchainedContext as Context;
-  const { modules, services } = resolvedContext;
+  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;
+    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 {
+      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;
+    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);
+        await modules.orders.payments.logEvent(orderPaymentId, event, resolvedContext.userId);
 
-      const orderPayment = await modules.orders.payments.findOrderPayment({
-        orderPaymentId,
-      });
+        const orderPayment = await modules.orders.payments.findOrderPayment({
+          orderPaymentId,
+        });
 
-      const order = await modules.orders.checkout(
-        orderPayment.orderId,
-        {
-          transactionContext: {
-            paymentIntentId: paymentIntent.id,
-          },
-          paymentContext: {
-            paymentIntentId: paymentIntent.id,
+        const order = await modules.orders.checkout(
+          orderPayment.orderId,
+          {
+            transactionContext: {
+              paymentIntentId: paymentIntent.id,
+            },
+            paymentContext: {
+              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,
+          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();
+          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}`);
       return;
     }
-  } 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 }));
-});
+    // Return a 200 response to acknowledge receipt of the event
+    response.end(JSON.stringify({ received: true }));
+  });
+};
 
 const createRegistrationIntent = async ({ userId, name, email, paymentProviderId }, options = {}) => {
   const customer = await stripe.customers.create({

package/src/pricing/product-price-cryptopay.ts

@@ -1,25 +1,27 @@
 import { Context } from '@unchainedshop/types/api';
 import { ProductPriceRate } from '@unchainedshop/types/products.pricing';
 import bodyParser from 'body-parser';
-import { useMiddlewareWithCurrentContext } from 'meteor/unchained:api';
+import { useMiddlewareWithCurrentContext } from '@unchainedshop/api';
 
 const { CRYPTOPAY_SECRET, CRYPTOPAY_PRICING_WEBHOOK_PATH = '/graphql/cryptopay-pricing' } = process.env;
 
-useMiddlewareWithCurrentContext(CRYPTOPAY_PRICING_WEBHOOK_PATH, bodyParser.json());
+export default (app) => {
+  useMiddlewareWithCurrentContext(app, CRYPTOPAY_PRICING_WEBHOOK_PATH, bodyParser.json());
 
-useMiddlewareWithCurrentContext(CRYPTOPAY_PRICING_WEBHOOK_PATH, async (request, response) => {
-  const resolvedContext = request.unchainedContext as Context;
-  const { baseCurrency, token, rate, timestamp, secret } = request.body;
-  if (secret !== CRYPTOPAY_SECRET) {
-    response.end(JSON.stringify({ success: false }));
-    return;
-  }
-  const rateData: ProductPriceRate = {
-    baseCurrency,
-    quoteCurrency: token,
-    rate,
-    timestamp,
-  };
-  const success = await resolvedContext.modules.products.prices.rates.updateRate(rateData);
-  response.end(JSON.stringify({ success }));
-});
+  useMiddlewareWithCurrentContext(app, CRYPTOPAY_PRICING_WEBHOOK_PATH, async (request, response) => {
+    const resolvedContext = request.unchainedContext as Context;
+    const { baseCurrency, token, rate, timestamp, secret } = request.body;
+    if (secret !== CRYPTOPAY_SECRET) {
+      response.end(JSON.stringify({ success: false }));
+      return;
+    }
+    const rateData: ProductPriceRate = {
+      baseCurrency,
+      quoteCurrency: token,
+      rate,
+      timestamp,
+    };
+    const success = await resolvedContext.modules.products.prices.rates.updateRate(rateData);
+    response.end(JSON.stringify({ success }));
+  });
+};

package/src/worker/ZombieKillerWorker.ts

@@ -70,11 +70,11 @@ export const ZombieKillerWorker: IWorkerAdapter<
       const deletedFilesCount =
         fileIdsToRemove.length > 0
           ? await services.files.removeFiles(
-            {
-              fileIds: fileIdsToRemove,
-            },
-            unchainedAPI,
-          )
+              {
+                fileIds: fileIdsToRemove,
+              },
+              unchainedAPI,
+            )
           : 0;
 
       // Return delete count