@unchainedshop/plugins 4.0.0-rc.14 → 4.0.0-rc.16

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

@@ -20,24 +20,22 @@ export const payrexxHandler: RouteHandlerMethod = async (
       type: Object.keys(request.body).join(','),
     });
     reply.status(200);
-    return reply.send(
-      JSON.stringify({
-        ignored: true,
-        message: `Unhandled event type: ${Object.keys(request.body).join(',')}. Supported type: transaction`,
-      }),
-    );
+    return reply.send({
+      success: false,
+      ignored: true,
+      message: `Unhandled event type: ${Object.keys(request.body).join(',')}. Supported type: transaction`,
+    });
   }
   if (transaction.referenceId === '__IGNORE_WEBHOOK__' || transaction.status === 'waiting') {
     // Ignore confirmed transactions, because those hooks are generated through calling the confirm()
     // method in the payment adapter and could lead to double bookings.
     logger.info(`unhandled transaction state: ${transaction.status}`);
     reply.status(200);
-    return reply.send(
-      JSON.stringify({
-        ignored: true,
-        message: `Unhandled transaction state: ${transaction.status}`,
-      }),
-    );
+    return reply.send({
+      success: false,
+      ignored: true,
+      message: `Unhandled transaction state: ${transaction.status}`,
+    });
   }
 
   logger.info(`Processing event`, {
@@ -58,19 +56,14 @@ export const payrexxHandler: RouteHandlerMethod = async (
         userId,
       });
       reply.status(200);
-      return reply.send(
-        JSON.stringify({
-          message: 'registration successful',
-          paymentProviderId,
-          userId,
-        }),
-      );
+      return reply.send({
+        success: true,
+        paymentProviderId,
+        userId,
+      });
     } else {
       const { referenceId: orderPaymentId, invoice } = transaction;
       logger.info(`checkout with orderPaymentId: ${orderPaymentId}`);
-      await modules.orders.payments.logEvent(orderPaymentId, {
-        transactionId: transaction.id,
-      });
       const orderPayment = await modules.orders.payments.findOrderPayment({
         orderPaymentId,
       });
@@ -78,6 +71,10 @@ export const payrexxHandler: RouteHandlerMethod = async (
         throw new Error(`order payment not found with orderPaymentId: ${orderPaymentId}`);
       }
 
+      await modules.orders.payments.logEvent(orderPaymentId, {
+        transactionId: transaction.id,
+      });
+
       const order = await services.orders.checkoutOrder(orderPayment.orderId, {
         paymentContext: {
           gatewayId: invoice.paymentRequestId,
@@ -88,18 +85,20 @@ export const payrexxHandler: RouteHandlerMethod = async (
         orderId: order._id,
       });
       reply.status(200);
-      return reply.send(
-        JSON.stringify({
-          message: 'checkout successful',
-          orderId: order._id,
-        }),
-      );
+      return reply.send({
+        success: true,
+        orderId: order._id,
+      });
     }
   } catch (error) {
     logger.error(error, {
       transactionId: transaction.id,
     });
     reply.status(500);
-    return reply.send(error.message);
+    return reply.send({
+      success: false,
+      message: error.message,
+      name: error.name,
+    });
   }
 };

package/src/payment/postfinance-checkout/api-client.ts

@@ -1,5 +1,3 @@
-import crypto from 'crypto';
-
 const API_BASE_URL = 'https://checkout.postfinance.ch/api';
 
 interface ApiConfig {
@@ -22,7 +20,7 @@ export class PostFinanceApiClient {
     this.config = config;
   }
 
-  private generateMacHeaders(method: string, path: string): MacHeaders {
+  private async generateMacHeaders(method: string, path: string): Promise<MacHeaders> {
     const version = '1';
     const timestamp = Math.floor(Date.now() / 1000).toString();
     const userId = this.config.userId.toString();
@@ -32,10 +30,17 @@ export class PostFinanceApiClient {
 
     const dataToSign = [version, userId, timestamp, method, resourcePath].join('|');
 
-    const macValue = crypto
-      .createHmac('sha512', Buffer.from(this.config.apiSecret, 'base64'))
-      .update(dataToSign, 'utf8')
-      .digest('base64');
+    // Use Web Crypto API instead of crypto.createHmac
+    const secretBytes = Uint8Array.from(atob(this.config.apiSecret), (c) => c.charCodeAt(0));
+    const key = await crypto.subtle.importKey(
+      'raw',
+      secretBytes,
+      { name: 'HMAC', hash: 'SHA-512' },
+      false,
+      ['sign'],
+    );
+    const signature = await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(dataToSign));
+    const macValue = btoa(String.fromCharCode(...new Uint8Array(signature)));
 
     return {
       'x-mac-version': version,
@@ -50,7 +55,7 @@ export class PostFinanceApiClient {
     const urlObj = new URL(url);
     // Include both pathname and search (query parameters) for MAC signature
     const pathWithQuery = urlObj.pathname + urlObj.search;
-    const macHeaders = this.generateMacHeaders(method, pathWithQuery);
+    const macHeaders = await this.generateMacHeaders(method, pathWithQuery);
 
     const headers: Record<string, string> = {
       ...macHeaders,

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

@@ -29,16 +29,13 @@ export const postfinanceCheckoutHandler = async (req, res) => {
       logger.info(
         `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(e);
-      res.writeHead(500);
-      res.end(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+      res.status(500).send({ name: e.name, code: e.code, message: e.message });
     }
   } else {
     logger.error(`Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`);
-    res.writeHead(404);
-    res.end();
+    res.status(404).end();
   }
 };

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

@@ -36,11 +36,11 @@ export const postfinanceCheckoutHandler: RouteHandlerMethod = async (
         `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(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(`Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`);

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

@@ -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;
   }
 
@@ -51,20 +50,19 @@ export const saferpayHandler = async (request, response) => {
       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

@@ -57,19 +57,21 @@ export const saferpayHandler: RouteHandlerMethod = async (
       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

@@ -21,8 +21,10 @@ export const stripeHandler = async (request, response) => {
     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 +32,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 +46,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;
   }
 
@@ -89,13 +85,10 @@ export const stripeHandler = async (request, response) => {
         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 +111,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,
+    });
   }
 };

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

@@ -28,7 +28,11 @@ export const stripeHandler: RouteHandlerMethod = async (
   } catch (err) {
     logger.error(`Error constructing event: ${err.message}`);
     reply.status(400);
-    return reply.send(err.message);
+    return reply.send({
+      success: false,
+      message: err.message,
+      name: err.name,
+    });
   }
 
   if (!Object.values(WebhookEventTypes).includes(event.type)) {
@@ -36,12 +40,12 @@ export const stripeHandler: RouteHandlerMethod = async (
       type: event.type,
     });
     reply.status(200);
-    return reply.send(
-      JSON.stringify({
-        ignored: true,
-        message: `Unhandled event type: ${event.type}. Supported types: ${Object.values(WebhookEventTypes).join(', ')}`,
-      }),
-    );
+    return reply.send({
+      success: false,
+      ignored: true,
+      name: 'UNHANDLED_EVENT_TYPE',
+      message: `Unhandled event type: ${event.type}. Supported types: ${Object.values(WebhookEventTypes).join(', ')}`,
+    });
   }
 
   const environmentInMetadata = event.data?.object?.metadata?.environment || '';
@@ -52,12 +56,12 @@ export const stripeHandler: RouteHandlerMethod = async (
       environment: environmentInMetadata,
     });
     reply.status(200);
-    return reply.send(
-      JSON.stringify({
-        ignored: true,
-        message: `Unhandled event environment: ${environmentInMetadata}. Supported environment: ${environmentInEnv}`,
-      }),
-    );
+    return reply.send({
+      success: false,
+      ignored: true,
+      name: 'UNHANDLED_EVENT_ENVIRONMENT',
+      message: `Unhandled event environment: ${environmentInMetadata}. Supported environment: ${environmentInEnv}`,
+    });
   }
 
   logger.info(`Processing event`, {
@@ -93,12 +97,10 @@ export const stripeHandler: RouteHandlerMethod = async (
         type: event.type,
       });
       reply.status(200);
-      return reply.send(
-        JSON.stringify({
-          message: 'checkout successful',
-          orderId: order._id,
-        }),
-      );
+      return reply.send({
+        success: true,
+        orderId: order._id,
+      });
     } else if (event.type === WebhookEventTypes.SETUP_INTENT_SUCCEEDED) {
       const setupIntent = event.data.object;
       const { paymentProviderId, userId } = setupIntent.metadata || {};
@@ -122,18 +124,21 @@ export const stripeHandler: RouteHandlerMethod = async (
         type: event.type,
       });
       reply.status(200);
-      return reply.send(
-        JSON.stringify({
-          message: 'payment credentials registration successful',
-          paymentCredentialsId: paymentCredentials?._id,
-        }),
-      );
+      return reply.send({
+        success: true,
+        message: 'payment credentials registration successful',
+        paymentCredentialsId: paymentCredentials?._id,
+      });
     }
   } catch (error) {
     logger.error(error, {
       type: event.type,
     });
     reply.status(500);
-    return reply.send(error.message);
+    return reply.send({
+      success: false,
+      message: error.message,
+      name: error.name,
+    });
   }
 };

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

@@ -3,6 +3,7 @@ import {
   ProductPricingAdapter,
   IProductPricingAdapter,
 } from '@unchainedshop/core';
+import { ProductTypes } from '@unchainedshop/core-products';
 
 export const ProductPrice: IProductPricingAdapter = {
   ...ProductPricingAdapter,
@@ -37,6 +38,28 @@ export const ProductPrice: IProductPricingAdapter = {
             isNetPrice: price.isNetPrice,
             meta: { adapter: ProductPrice.key },
           });
+        } else if (product.type === ProductTypes.BundleProduct) {
+          for (const bundleItem of product.bundleItems || []) {
+            const bundledProduct = await modules.products.findProduct({
+              productId: bundleItem.productId,
+            });
+            if (bundledProduct) {
+              const bundleItemPrice = await modules.products.prices.price(bundledProduct, {
+                countryCode,
+                currencyCode,
+                quantity: bundleItem.quantity * quantity,
+              });
+              if (bundleItemPrice) {
+                const bundleItemTotal = bundleItemPrice.amount * bundleItem.quantity * quantity;
+                pricingAdapter.resultSheet().addItem({
+                  amount: bundleItemTotal,
+                  isTaxable: bundleItemPrice.isTaxable,
+                  isNetPrice: bundleItemPrice.isNetPrice,
+                  meta: { adapter: ProductPrice.key },
+                });
+              }
+            }
+          }
         }
 
         return pricingAdapter.calculate();

package/src/worker/bulk-import.ts

@@ -1,56 +1,8 @@
 import { WorkerDirector, WorkerAdapter, IWorkerAdapter } from '@unchainedshop/core';
 import { createLogger } from '@unchainedshop/logger';
-import JSONStream from 'JSONStream';
-import { EventIterator } from 'event-iterator';
-import { UnchainedCore } from '@unchainedshop/core';
 
 const logger = createLogger('unchained:worker:bulk-import');
 
-const streamPayloadToBulkImporter = async (
-  bulkImporter,
-  payloadId,
-  unchainedAPI: Pick<UnchainedCore, 'bulkImporter' | 'modules' | 'services'>,
-) => {
-  logger.trace(`parseAsync start`);
-
-  const readStream = await unchainedAPI.services.files.createDownloadStream({ fileId: payloadId });
-
-  if (!readStream) {
-    throw new Error(
-      'The current file adapter does not support streams when downloading required for streamed events. Please use a different file adapter.',
-    );
-  }
-
-  const eventIterator = new EventIterator(
-    (queue) => {
-      const jsonStream = JSONStream.parse('events.*'); // rows, ANYTHING, doc
-      jsonStream.on('data', queue.push);
-      jsonStream.on('close', queue.stop);
-      jsonStream.on('error', queue.fail);
-
-      queue.on('highWater', () => readStream.pause());
-      queue.on('lowWater', () => readStream.resume());
-
-      readStream.pipe(jsonStream);
-      readStream.on('error', queue.fail);
-
-      return () => {
-        jsonStream.removeListener('data', queue.push);
-        jsonStream.removeListener('close', queue.stop);
-        jsonStream.removeListener('error', queue.fail);
-        jsonStream.destroy();
-      };
-    },
-    { highWaterMark: 100, lowWaterMark: 5 },
-  );
-
-  for await (const event of eventIterator) {
-    await bulkImporter.prepare(event, unchainedAPI);
-  }
-
-  logger.trace(`parseAsync done`);
-};
-
 export const BulkImportWorker: IWorkerAdapter<any, Record<string, unknown>> = {
   ...WorkerAdapter,
 
@@ -76,7 +28,15 @@ export const BulkImportWorker: IWorkerAdapter<any, Record<string, unknown>> = {
 
       if (rawPayload.payloadId) {
         // stream payload from gridfs
-        await streamPayloadToBulkImporter(bulkImporter, rawPayload.payloadId, unchainedAPI);
+        const readStream = await unchainedAPI.services.files.createDownloadStream({
+          fileId: rawPayload.payloadId,
+        });
+        if (!readStream) {
+          throw new Error(
+            'The current file adapter does not support streams when downloading required for streamed events. Please use a different file adapter.',
+          );
+        }
+        await unchainedAPI.bulkImporter.pipeEventStream(readStream, bulkImporter, unchainedAPI);
       } else {
         const { events } = rawPayload;
         if (!events?.length) throw new Error('No events submitted');