@unchainedshop/plugins 4.0.0-rc.2 → 4.0.0-rc.21

package/src/payment/postfinance-checkout/handler-express.ts

@@ -3,7 +3,7 @@ import { createLogger } from '@unchainedshop/logger';
 import { WebhookData } from './types.js';
 import { getTransaction, getTransactionCompletion } from './api.js';
 
-const logger = createLogger('unchained:core-payment:postfinance-checkout');
+const logger = createLogger('unchained:postfinance-checkout:handler');
 
 export const postfinanceCheckoutHandler = async (req, res) => {
   const context = req.unchainedContext as Context;
@@ -13,7 +13,7 @@ export const postfinanceCheckoutHandler = async (req, res) => {
     try {
       const transactionCompletion = await getTransactionCompletion(data.entityId as unknown as string);
       const transaction = await getTransaction(
-        transactionCompletion.linkedTransaction as unknown as string,
+        transactionCompletion ? (transactionCompletion as any).linkedTransaction : data.entityId,
       );
       const { orderPaymentId } = transaction.metaData as { orderPaymentId: string };
       const orderPayment = await modules.orders.payments.findOrderPayment({
@@ -26,21 +26,19 @@ export const postfinanceCheckoutHandler = async (req, res) => {
           transactionId: transactionCompletion.linkedTransaction,
         },
       });
+
+      if (!order) throw new Error(`Order with id ${orderPayment.orderId} not found`);
+
       logger.info(
-        `PostFinance Checkout Webhook: Transaction ${transactionCompletion.linkedTransaction} marked order payment ID ${transaction.metaData.orderPaymentId} as paid`,
+        `Transaction ${transactionCompletion.linkedTransaction} marked order payment ID ${transaction.metaData?.orderPaymentId} as paid`,
       );
-      res.writeHead(200);
-      res.end(`Order marked as paid: ${order.orderNumber}`);
+      res.status(200).send(`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 }));
+      logger.error(e);
+      res.status(500).send({ 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();
+    logger.error(`Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`);
+    res.status(404).end();
   }
 };

package/src/payment/postfinance-checkout/handler-fastify.ts

@@ -4,7 +4,7 @@ import { WebhookData } from './types.js';
 import { getTransaction, getTransactionCompletion } from './api.js';
 import { FastifyRequest, RouteHandlerMethod } from 'fastify';
 
-const logger = createLogger('unchained:core-payment:postfinance-checkout');
+const logger = createLogger('unchained:postfinance-checkout:handler');
 
 export const postfinanceCheckoutHandler: RouteHandlerMethod = async (
   req: FastifyRequest & {
@@ -19,7 +19,7 @@ export const postfinanceCheckoutHandler: RouteHandlerMethod = async (
     try {
       const transactionCompletion = await getTransactionCompletion(data.entityId as unknown as string);
       const transaction = await getTransaction(
-        transactionCompletion.linkedTransaction as unknown as string,
+        transactionCompletion ? (transactionCompletion as any).linkedTransaction : data.entityId,
       );
       const { orderPaymentId } = transaction.metaData as { orderPaymentId: string };
       const orderPayment = await modules.orders.payments.findOrderPayment({
@@ -29,23 +29,24 @@ export const postfinanceCheckoutHandler: RouteHandlerMethod = async (
 
       const order = await services.orders.checkoutOrder(orderPayment.orderId, {
         paymentContext: {
-          transactionId: transactionCompletion.linkedTransaction,
+          transactionId: transaction.id,
         },
       });
+
+      if (!order) throw new Error(`Order with id ${orderPayment.orderId} not found`);
+
       logger.info(
-        `PostFinance Checkout Webhook: Transaction ${transactionCompletion.linkedTransaction} marked order payment ID ${transaction.metaData.orderPaymentId} as paid`,
+        `Transaction ${transaction.id} marked order payment ID ${transaction.metaData?.orderPaymentId} as paid`,
       );
       reply.status(200);
-      return reply.send(`Order marked as paid: ${order.orderNumber}`);
+      return reply.send({ success: true, orderNumber: order.orderNumber });
     } catch (e) {
-      logger.error(`PostFinance Checkout Webhook: Unchained rejected to checkout with message`, e);
+      logger.error(e);
       reply.status(500);
-      return reply.send({ name: e.name, code: e.code, message: e.message });
+      return reply.send({ success: false, name: e.name, code: e.code, message: e.message });
     }
   } else {
-    logger.error(
-      `PostFinance Checkout Webhook: Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`,
-    );
+    logger.error(`Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`);
     reply.status(404);
     return reply.send();
   }

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

@@ -8,7 +8,6 @@ import {
   PaymentDirector,
   PaymentError,
 } from '@unchainedshop/core';
-import * as pf from 'postfinancecheckout';
 
 import {
   confirmDeferredTransaction,
@@ -23,8 +22,15 @@ import {
 } from './api.js';
 import { orderIsPaid } from './utils.js';
 import { CompletionModes, IntegrationModes, SignResponse } from './types.js';
-
-const { PostFinanceCheckout } = pf;
+import {
+  TransactionCreate,
+  LineItem,
+  LineItemType,
+  TokenizationMode,
+  TransactionCompletionBehavior,
+  TransactionState,
+  CreationEntityState,
+} from './api-types.js';
 
 const {
   PFCHECKOUT_SPACE_ID,
@@ -34,7 +40,7 @@ const {
   PFCHECKOUT_FAILED_URL,
 } = process.env;
 
-const logger = createLogger('unchained:core-payment:postfinance');
+const logger = createLogger('unchained:postfinance-checkout');
 
 const newError = ({ code, message }: { code: string; message: string }) => {
   const error = new Error(message);
@@ -92,12 +98,16 @@ const PostfinanceCheckout: IPaymentAdapter = {
         if (!credentials.meta) return false;
         const { linkedSpaceId } = credentials.meta;
         const tokenData = await getToken(linkedSpaceId, credentials.token);
-        return tokenData.state === PostFinanceCheckout.model.CreationEntityState.ACTIVE;
+        return tokenData.state === CreationEntityState.ACTIVE;
       },
 
       sign: async (transactionContext: any = {}) => {
         const { orderPayment, order } = context;
 
+        if (!order) throw new Error('No order in context, can only sign with order context');
+        if (!orderPayment)
+          throw new Error('No order payment in context, can only sign with order payment context');
+
         const { integrationMode = IntegrationModes.PaymentPage }: { integrationMode: IntegrationModes } =
           transactionContext;
         const completionMode = adapter.getCompletionMode();
@@ -107,39 +117,43 @@ const PostfinanceCheckout: IPaymentAdapter = {
         });
 
         const totalAmount = pricing?.total({ useNetPrice: false }).amount;
-        const transaction = new PostFinanceCheckout.model.TransactionCreate();
-        const userId = order?.userId || context?.userId;
-        transaction.currency = order.currencyCode;
-        transaction.metaData = {
-          orderPaymentId: orderPayment._id,
+        const transaction: TransactionCreate = {
+          currency: order.currencyCode,
+          metaData: {
+            orderPaymentId: orderPayment._id,
+          },
+          successUrl: `${transactionContext?.successUrl || PFCHECKOUT_SUCCESS_URL}?order_id=${
+            orderPayment.orderId
+          }`,
+          failedUrl: `${transactionContext?.failedUrl || PFCHECKOUT_FAILED_URL}?order_id=${
+            orderPayment.orderId
+          }`,
+          customerId: order?.userId || context?.userId,
+          tokenizationMode: TokenizationMode.ALLOW_ONE_CLICK_PAYMENT,
         };
-        transaction.successUrl = `${transactionContext?.successUrl || PFCHECKOUT_SUCCESS_URL}?order_id=${
-          orderPayment.orderId
-        }`;
-        transaction.failedUrl = `${transactionContext?.failedUrl || PFCHECKOUT_FAILED_URL}?order_id=${
-          orderPayment.orderId
-        }`;
-        transaction.customerId = userId;
-        transaction.tokenizationMode =
-          PostFinanceCheckout.model.TokenizationMode.ALLOW_ONE_CLICK_PAYMENT;
+
         if (completionMode === CompletionModes.Immediate) {
-          transaction.completionBehavior =
-            PostFinanceCheckout.model.TransactionCompletionBehavior.COMPLETE_IMMEDIATELY;
+          transaction.completionBehavior = TransactionCompletionBehavior.COMPLETE_IMMEDIATELY;
         } else if (completionMode === CompletionModes.Deferred) {
-          transaction.completionBehavior =
-            PostFinanceCheckout.model.TransactionCompletionBehavior.COMPLETE_DEFERRED;
+          transaction.completionBehavior = TransactionCompletionBehavior.COMPLETE_DEFERRED;
         }
+
         if (totalAmount) {
-          const lineItemSum = new PostFinanceCheckout.model.LineItemCreate();
-          lineItemSum.name = `Bestellung ${orderPayment.orderId}`;
-          lineItemSum.type = PostFinanceCheckout.model.LineItemType.FEE;
-          lineItemSum.quantity = 1;
-          lineItemSum.uniqueId = orderPayment.orderId;
-          lineItemSum.amountIncludingTax = totalAmount / 100;
+          const lineItemSum: LineItem = {
+            name: `Bestellung ${orderPayment.orderId}`,
+            type: LineItemType.FEE,
+            quantity: 1,
+            uniqueId: orderPayment.orderId,
+            amountIncludingTax: totalAmount / 100,
+          };
           transaction.lineItems = [lineItemSum];
         }
+
         const transactionId = await createTransaction(transaction);
-        let location = null;
+
+        if (!transactionId) throw new Error('Could not create transaction');
+
+        let location: string | null = null;
         if (integrationMode === IntegrationModes.PaymentPage) {
           location = await getPaymentPageUrl(transactionId);
         } else if (integrationMode === IntegrationModes.Lightbox) {
@@ -178,7 +192,11 @@ const PostfinanceCheckout: IPaymentAdapter = {
           });
         }
 
-        const isPaid = await orderIsPaid(context.order, transaction);
+        const { order, orderPayment } = context;
+        if (!orderPayment) throw new Error('No order payment in context, cannot charge payment');
+        if (!order) throw new Error('No order in context, can only sign with order context');
+
+        const isPaid = await orderIsPaid(order, transaction);
         if (!isPaid) {
           logger.error(`Transaction #${transactionId}: Invalid state / Amount incorrect`);
           throw newError({
@@ -187,7 +205,7 @@ const PostfinanceCheckout: IPaymentAdapter = {
           });
         }
 
-        if (transaction.metaData.orderPaymentId !== context.orderPayment._id) {
+        if (transaction.metaData?.orderPaymentId !== orderPayment._id) {
           logger.error(`Transaction #${transactionId}: Invalid state / Amount incorrect`);
           throw newError({
             code: `TRANSACTION_ALREADY_USED`,
@@ -209,12 +227,13 @@ const PostfinanceCheckout: IPaymentAdapter = {
 
       cancel: async () => {
         const { orderPayment, order } = context;
-        const { transactionId } = orderPayment;
-        if (!transactionId) {
+        if (!order) throw new Error('No order in context, can only cancel with order context');
+        if (!orderPayment?.transactionId) {
           return false;
         }
+        const { transactionId } = orderPayment;
         const transaction = await getTransaction(transactionId);
-        const refund = transaction.state === PostFinanceCheckout.model.TransactionState.FULFILL;
+        const refund = transaction.state === TransactionState.FULFILL;
         const pricing = OrderPricingSheet({
           calculation: order.calculation,
           currencyCode: order.currencyCode,
@@ -230,12 +249,12 @@ const PostfinanceCheckout: IPaymentAdapter = {
 
       confirm: async () => {
         const { orderPayment } = context;
-        const { transactionId } = orderPayment;
-        if (!transactionId) {
+        if (!orderPayment?.transactionId) {
           return false;
         }
+        const { transactionId } = orderPayment;
         const transaction = await getTransaction(transactionId);
-        if (transaction.state === PostFinanceCheckout.model.TransactionState.AUTHORIZED) {
+        if (transaction.state === TransactionState.AUTHORIZED) {
           return confirmDeferredTransaction(transactionId);
         }
         return false;
@@ -247,3 +266,6 @@ const PostfinanceCheckout: IPaymentAdapter = {
 };
 
 PaymentDirector.registerAdapter(PostfinanceCheckout);
+
+export * from './types.js';
+export * from './api-types.js';

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

@@ -1,22 +1,20 @@
 import { OrderPricingSheet } from '@unchainedshop/core';
 import { Order } from '@unchainedshop/core-orders';
-import * as pf from 'postfinancecheckout';
-
-const { PostFinanceCheckout } = pf;
+import { Transaction, TransactionState } from './api-types.js';
 
 export const transactionIsPaid = async (
-  transaction: pf.PostFinanceCheckout.model.Transaction,
+  transaction: Transaction,
   expectedCurrency: string,
   expectedAmount: number,
 ): Promise<boolean> => {
-  if (transaction.state === PostFinanceCheckout.model.TransactionState.FULFILL) {
+  if (transaction.state === TransactionState.FULFILL) {
     return (
       transaction.completedAmount !== undefined &&
       transaction.completedAmount.toFixed(2) === expectedAmount.toFixed(2) &&
       transaction.currency === expectedCurrency
     );
   }
-  if (transaction.state === PostFinanceCheckout.model.TransactionState.AUTHORIZED) {
+  if (transaction.state === TransactionState.AUTHORIZED) {
     return (
       transaction.authorizationAmount !== undefined &&
       transaction.authorizationAmount.toFixed(2) === expectedAmount.toFixed(2) &&
@@ -26,10 +24,7 @@ export const transactionIsPaid = async (
   return false;
 };
 
-export const orderIsPaid = async (
-  order: Order,
-  transaction: pf.PostFinanceCheckout.model.Transaction,
-): Promise<boolean> => {
+export const orderIsPaid = async (order: Order, transaction: Transaction): Promise<boolean> => {
   const pricing = OrderPricingSheet({
     calculation: order.calculation,
     currencyCode: order.currencyCode,

package/src/payment/saferpay/adapter.ts

@@ -133,8 +133,8 @@ export const WordlineSaferpay: IPaymentAdapter = {
           saferpayTransactionId,
         );
 
-        paymentPageInitInput.Notification.SuccessNotifyUrl = addTransactionId(
-          paymentPageInitInput.Notification.SuccessNotifyUrl,
+        paymentPageInitInput.Notification!.SuccessNotifyUrl = addTransactionId(
+          paymentPageInitInput.Notification!.SuccessNotifyUrl,
           saferpayTransactionId,
         );
 
@@ -166,6 +166,10 @@ export const WordlineSaferpay: IPaymentAdapter = {
           mongodb.ObjectId.createFromHexString(transactionId),
         );
 
+        if (!saferpayTransaction?.token) {
+          throw new Error('No initialized transaction Token');
+        }
+
         const api = createSaferPayClient();
         const paymentPageAssert = await api.paymentPageAssert(orderPayment, {
           Token: saferpayTransaction.token,
@@ -205,6 +209,10 @@ export const WordlineSaferpay: IPaymentAdapter = {
           mongodb.ObjectId.createFromHexString(transactionId),
         );
 
+        if (!saferpayTransaction?.token) {
+          throw new Error('No initialized transaction Token');
+        }
+
         const api = createSaferPayClient();
         const paymentPageAssert = await api.paymentPageAssert(orderPayment, {
           Token: saferpayTransaction.token,
@@ -236,6 +244,10 @@ export const WordlineSaferpay: IPaymentAdapter = {
           mongodb.ObjectId.createFromHexString(transactionId),
         );
 
+        if (!saferpayTransaction?.token) {
+          throw new Error('No initialized transaction Token');
+        }
+
         const api = createSaferPayClient();
         const paymentPageAssert = await api.paymentPageAssert(orderPayment, {
           Token: saferpayTransaction.token,

package/src/payment/saferpay/handler-express.ts

@@ -3,7 +3,7 @@ import { createLogger } from '@unchainedshop/logger';
 import { buildSignature } from './buildSignature.js';
 import { SaferpayTransactionsModule } from './module.js';
 
-const logger = createLogger('unchained:core-payment:saferpay:handler');
+const logger = createLogger('unchained:saferpay:handler');
 
 export const saferpayHandler = async (request, response) => {
   const resolvedContext = request.unchainedContext as Context & {
@@ -22,8 +22,7 @@ export const saferpayHandler = async (request, response) => {
 
   if ((request.method !== 'GET' && request.method !== 'HEAD') || !isValidRequest) {
     logger.warn(`unhandled http method ${request.method} or orderPaymentId missing in query`);
-    response.writeHead(404);
-    response.end();
+    response.status(404).end();
     return;
   }
 
@@ -47,24 +46,26 @@ export const saferpayHandler = async (request, response) => {
         transactionId,
       },
     });
+
+    if (!order) throw new Error(`Order with id ${orderPayment.orderId} not found`);
+
     logger.info(`checkout successful`, {
       orderPaymentId,
       orderId: order._id,
     });
-    response.writeHead(200);
-    response.end(
-      JSON.stringify({
-        message: 'checkout successful',
-        orderPaymentId,
-        orderId: order._id,
-      }),
-    );
+    response.status(200).send({
+      message: 'checkout successful',
+      orderPaymentId,
+      orderId: order._id,
+    });
   } catch (error) {
     logger.error(error, {
       orderPaymentId,
       transactionId,
     });
-    response.writeHead(500);
-    response.end(error.message);
+    response.status(500).send({
+      message: error.message,
+      name: error.name,
+    });
   }
 };

package/src/payment/saferpay/handler-fastify.ts

@@ -4,7 +4,7 @@ import { buildSignature } from './buildSignature.js';
 import { SaferpayTransactionsModule } from './module.js';
 import { FastifyRequest, RouteHandlerMethod } from 'fastify';
 
-const logger = createLogger('unchained:core-payment:saferpay:handler');
+const logger = createLogger('unchained:saferpay:handler');
 
 export const saferpayHandler: RouteHandlerMethod = async (
   request: FastifyRequest & {
@@ -52,24 +52,29 @@ export const saferpayHandler: RouteHandlerMethod = async (
         transactionId,
       },
     });
+
+    if (!order) throw new Error(`Order with id ${orderPayment.orderId} not found`);
+
     logger.info(`checkout successful`, {
       orderPaymentId,
       orderId: order._id,
     });
     reply.status(200);
-    return reply.send(
-      JSON.stringify({
-        message: 'checkout successful',
-        orderPaymentId,
-        orderId: order._id,
-      }),
-    );
+    return reply.send({
+      success: true,
+      orderPaymentId,
+      orderId: order._id,
+    });
   } catch (error) {
     logger.error(error, {
       orderPaymentId,
       transactionId,
     });
     reply.status(500);
-    return reply.send(error.message);
+    return reply.send({
+      success: false,
+      message: error.message,
+      name: error.name,
+    });
   }
 };

package/src/payment/stripe/handler-express.ts

@@ -2,7 +2,7 @@ import { Context } from '@unchainedshop/api';
 import { createLogger } from '@unchainedshop/logger';
 import stripeClient from './stripe.js';
 
-const logger = createLogger('unchained:core-payment:stripe:handler');
+const logger = createLogger('unchained:stripe:handler');
 
 export const WebhookEventTypes = {
   PAYMENT_INTENT_SUCCEEDED: 'payment_intent.succeeded',
@@ -18,11 +18,19 @@ export const stripeHandler = async (request, response) => {
   try {
     const stripe = stripeClient();
     const sig = request.headers['stripe-signature'];
+    if (!sig) {
+      throw new Error('stripe-signature header was not provided for webhook');
+    }
+    if (!process.env.STRIPE_ENDPOINT_SECRET) {
+      throw new Error('env STRIPE_ENDPOINT_SECRET is required for webhook handling');
+    }
     event = stripe.webhooks.constructEvent(request.body, sig, process.env.STRIPE_ENDPOINT_SECRET);
   } catch (err) {
     logger.error(`Error constructing event: ${err.message}`);
-    response.writeHead(400);
-    response.end(err.message);
+    response.status(400).send({
+      message: err.message,
+      name: err.name,
+    });
     return;
   }
 
@@ -30,13 +38,10 @@ export const stripeHandler = async (request, response) => {
     logger.info(`unhandled event type`, {
       type: event.type,
     });
-    response.writeHead(200);
-    response.end(
-      JSON.stringify({
-        ignored: true,
-        message: `Unhandled event type: ${event.type}. Supported types: ${Object.values(WebhookEventTypes).join(', ')}`,
-      }),
-    );
+    response.status(200).send({
+      ignored: true,
+      message: `Unhandled event type: ${event.type}. Supported types: ${Object.values(WebhookEventTypes).join(', ')}`,
+    });
     return;
   }
 
@@ -47,13 +52,10 @@ export const stripeHandler = async (request, response) => {
       type: event.type,
       environment: environmentInMetadata,
     });
-    response.writeHead(200);
-    response.end(
-      JSON.stringify({
-        ignored: true,
-        message: `Unhandled event environment: ${environmentInMetadata}. Supported environment: ${environmentInEnv}`,
-      }),
-    );
+    response.status(200).send({
+      ignored: true,
+      message: `Unhandled event environment: ${environmentInMetadata}. Supported environment: ${environmentInEnv}`,
+    });
     return;
   }
 
@@ -84,18 +86,17 @@ export const stripeHandler = async (request, response) => {
         },
       });
 
+      if (!order) throw new Error(`Order with id ${orderPayment.orderId} not found`);
+
       logger.info(`checkout successful`, {
         orderPaymentId,
         orderId: order._id,
         type: event.type,
       });
-      response.writeHead(200);
-      response.end(
-        JSON.stringify({
-          message: 'checkout successful',
-          orderId: order._id,
-        }),
-      );
+      response.status(200).send({
+        message: 'checkout successful',
+        orderId: order._id,
+      });
     } else if (event.type === WebhookEventTypes.SETUP_INTENT_SUCCEEDED) {
       const setupIntent = event.data.object;
       const { paymentProviderId, userId } = setupIntent.metadata || {};
@@ -118,19 +119,18 @@ export const stripeHandler = async (request, response) => {
         paymentCredentialsId: paymentCredentials?._id,
         type: event.type,
       });
-      response.writeHead(200);
-      response.end(
-        JSON.stringify({
-          message: 'payment credentials registration successful',
-          paymentCredentialsId: paymentCredentials?._id,
-        }),
-      );
+      response.status(200).send({
+        message: 'payment credentials registration successful',
+        paymentCredentialsId: paymentCredentials?._id,
+      });
     }
   } catch (error) {
     logger.error(error, {
       type: event.type,
     });
-    response.writeHead(500);
-    response.end(error.message);
+    response.status(500).send({
+      message: error.message,
+      name: error.name,
+    });
   }
 };