@unchainedshop/plugins 1.1.5 → 1.2.0

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

package/src/payment/stripe.ts

@@ -5,100 +5,108 @@ 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:
 
 brew install stripe/stripe-cli/stripe
 stripe login --api-key sk_....
-stripe listen --forward-to http://localhost:3000/graphql/stripe
+stripe listen --forward-to http://localhost:3000/payment/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 = '/payment/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,
+        const order = await modules.orders.checkout(
+          orderPayment.orderId,
+          {
+            transactionContext: {
+              paymentIntentId: paymentIntent.id,
+            },
+            paymentContext: {
+              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/payment/worldline-saferpay/worldline-saferpay-client/index.ts

@@ -1,8 +1,8 @@
 export { SaferpayClient } from './api/SaferpayClient';
 
-export {
+export type {
   PaymentPageInitializeInput,
   PaymentPageInitializeResponse,
 } from './models/PaymentPageInitialize';
-export { PaymentPageAssertInput, PaymentPageAssertResponse } from './models/PaymentPageAssert';
-export { TransactionCancelInput, TransactionCancelResponse } from './models/TransactionCancel';
+export type { PaymentPageAssertInput, PaymentPageAssertResponse } from './models/PaymentPageAssert';
+export type { TransactionCancelInput, TransactionCancelResponse } from './models/TransactionCancel';

package/src/pricing/product-discount.ts

@@ -1,4 +1,4 @@
-import { Discount, DiscountConfiguration } from '@unchainedshop/types/discount';
+import type { Discount, DiscountConfiguration } from '@unchainedshop/types/discount';
 import {
   IProductPricingAdapter,
   ProductPricingRowCategory,

package/src/pricing/product-price-ECB-interbank-exchange.ts

@@ -1,6 +1,7 @@
 import { IProductPricingAdapter } from '@unchainedshop/types/products.pricing';
 import fetch from 'isomorphic-unfetch';
 import { ProductPricingDirector, ProductPricingAdapter } from '@unchainedshop/core-products';
+import xmlJs from 'xml-js';
 
 import Cache from './utils/cache';
 
@@ -42,7 +43,6 @@ const SUPPORTED_CURRENCIES = [
 ];
 
 const cache = new Cache(CACHE_PERIOD);
-const xmlJs = require('xml-js'); // eslint-disable-line
 
 const getEURexchangeRateForCurrency = async (currency) => {
   const response = cache.get(currency, () =>

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

@@ -3,23 +3,25 @@ import { ProductPriceRate } from '@unchainedshop/types/products.pricing';
 import bodyParser from 'body-parser';
 import { useMiddlewareWithCurrentContext } from '@unchainedshop/api';
 
-const { CRYPTOPAY_SECRET, CRYPTOPAY_PRICING_WEBHOOK_PATH = '/graphql/cryptopay-pricing' } = process.env;
+const { CRYPTOPAY_SECRET, CRYPTOPAY_PRICING_WEBHOOK_PATH = '/payment/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

package/src/worker/email.ts

@@ -5,6 +5,7 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import open from 'open';
+import nodemailer from 'nodemailer';
 
 const logger = createLogger('unchained:plugins:worker:email');
 

package/tsconfig.json

@@ -1,8 +1,29 @@
 {
-  "extends": "./tsconfig.build.json",
   "compilerOptions": {
-    "noEmit": true,
-    "types": ["node"]
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "forceConsistentCasingInFileNames": true,
+    "lib": [
+      "esnext"
+    ],
+    "module": "esnext",
+    "moduleResolution": "node",
+    "noImplicitReturns": true,
+    "noUnusedLocals": false,
+    "outDir": "lib",
+    "preserveWatchOutput": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "target": "esnext",
+    "types": [
+      "node",
+      "jest"
+    ]
   },
-  "include": ["src"]
-}
+  "include": [
+    "src"
+  ]
+}

package/src/files/gridfs/gridfs-webhook.js

@@ -1,60 +0,0 @@
-import { useMiddlewareWithCurrentContext } from '@unchainedshop/api';
-import { log, LogLevel } from '@unchainedshop/logger';
-import sign from './sign';
-import promisePipe from './promisePipe';
-import buildHashedFilename from '@unchainedshop/file-upload/lib/buildHashedFilename';
-
-const { ROOT_URL } = process.env;
-
-/*
-curl -vvv -X PUT -T /Users/pozylon/Downloads/grafik.png http://localhost:4010/gridfs/user-avatars/hans.png?e=1653059591506&s=df8626a1c9b9006249d7f1928fd530579fed57216f1bdcb83c28a8322cdc90b1
-*/
-
-useMiddlewareWithCurrentContext('/gridfs', async (req, res) => {
-  try {
-    const { services, modules } = req.unchainedContext;
-    const url = new URL(req.url, ROOT_URL);
-    const [, directoryName, fileName] = url.pathname.split('/');
-
-    if (req.method === 'PUT') {
-      const { s: signature, e: expiryTimestamp } = req.query;
-      const expiryDate = new Date(parseInt(expiryTimestamp, 10));
-      const fileId = buildHashedFilename(directoryName, fileName, expiryDate);
-      if (sign(directoryName, fileId, expiryDate.getTime()) === signature) {
-        const file = await modules.files.findFile({ fileId });
-        if (file.expires === null) {
-          res.writeHead(503);
-          res.end('File already linked');
-        }
-        const writeStream = await modules.gridfsFileUploads.createWriteStream(
-          directoryName,
-          fileId,
-          fileName,
-        );
-        const { length } = await promisePipe(req, writeStream);
-        await services.files.linkFile({ fileId, size: length }, req.unchainedContext);
-        res.writeHead(200);
-        res.end();
-        return;
-      }
-      res.writeHead(403);
-      res.end();
-      return;
-    }
-    if (req.method === 'GET') {
-      const fileId = fileName;
-      const readStream = await modules.gridfsFileUploads.createReadStream(directoryName, fileId);
-      await promisePipe(readStream, res);
-      res.writeHead(200);
-      res.end();
-      return;
-    }
-    res.writeHead(404);
-    res.end();
-    return;
-  } catch (e) {
-    log(e.message, { level: LogLevel.Error });
-    res.writeHead(503);
-    res.end(JSON.stringify(e));
-  }
-});

package/tsconfig.build.json

@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {
-    "allowJs": true,
-    "allowSyntheticDefaultImports": true,
-    "declaration": true,
-    "esModuleInterop": true,
-    "experimentalDecorators": true,
-    "forceConsistentCasingInFileNames": true,
-    "lib": ["esnext"],
-    "module": "esnext",
-    "moduleResolution": "node",
-    "noImplicitReturns": true,
-    "noUnusedLocals": false,
-    "outDir": "lib",
-    "preserveWatchOutput": true,
-    "skipLibCheck": true,
-    "sourceMap": true,
-    "target": "esnext",
-    "types": ["node"],
-    "baseUrl": ".", // This must be specified if "paths" is.
-    "paths": {
-      "meteor/unchained:*": ["node_modules/@unchainedshop/types/index.d.ts"]
-    }
-  },
-  "include": ["src"]
-}