@unchainedshop/plugins 4.0.0-rc.9 → 4.0.0

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

@@ -3,7 +3,7 @@ import { createLogger } from '@unchainedshop/logger';
 import stripeClient from './stripe.js';
 import { FastifyRequest, RouteHandlerMethod } from 'fastify';
 
-const logger = createLogger('unchained:core-payment:stripe:handler');
+const logger = createLogger('unchained:stripe:handler');
 
 export const WebhookEventTypes = {
   PAYMENT_INTENT_SUCCEEDED: 'payment_intent.succeeded',
@@ -24,11 +24,21 @@ export const stripeHandler: RouteHandlerMethod = async (
   try {
     const stripe = stripeClient();
     const sig = req.headers['stripe-signature'];
+    if (!process.env.STRIPE_ENDPOINT_SECRET) {
+      throw new Error('env STRIPE_ENDPOINT_SECRET is required for webhook handling');
+    }
+    if (!sig) {
+      throw new Error('stripe-signature header was not provided for webhook');
+    }
     event = stripe.webhooks.constructEvent(req.body as string, sig, process.env.STRIPE_ENDPOINT_SECRET);
   } 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 +46,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 +62,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`, {
@@ -87,18 +97,18 @@ export const stripeHandler: RouteHandlerMethod = async (
         },
       });
 
+      if (!order) throw new Error(`Order with id ${orderPayment.orderId} not found`);
+
       logger.info(`checkout successful`, {
         orderPaymentId,
         orderId: order._id,
         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 +132,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/payment/stripe/index.ts

@@ -8,7 +8,7 @@ import {
   PaymentError,
 } from '@unchainedshop/core';
 
-const logger = createLogger('unchained:core-payment:stripe');
+const logger = createLogger('unchained:stripe');
 
 const Stripe: IPaymentAdapter = {
   ...PaymentAdapter,
@@ -24,13 +24,14 @@ const Stripe: IPaymentAdapter = {
   actions: (config, context) => {
     const { modules } = context;
 
-    const descriptorPrefix = config.find(({ key }) => key === 'descriptorPrefix')?.value;
+    const descriptorPrefix = config.find(({ key }) => key === 'descriptorPrefix')?.value || '';
 
-    const getUserData = async (forcedUserId) => {
+    const assertUserData = async (forcedUserId) => {
       const userId = forcedUserId || context?.userId;
       const user = await modules.users.findUserById(userId);
+      if (!user) throw new Error('User not found');
       const email = modules.users.primaryEmail(user)?.address;
-      const name = user.profile.displayName || user.username || email;
+      const name = user.profile?.displayName || user.username || email;
       return {
         email,
         name,
@@ -41,8 +42,9 @@ const Stripe: IPaymentAdapter = {
       ...PaymentAdapter.actions(config, context),
 
       configurationError() {
-        const stripe = stripeClient();
-        if (!stripe) {
+        try {
+          stripeClient();
+        } catch {
           return PaymentError.INCOMPLETE_CONFIGURATION;
         }
         return null;
@@ -86,13 +88,13 @@ const Stripe: IPaymentAdapter = {
 
       sign: async (transactionContext = {}) => {
         const { orderPayment, order, paymentProviderId } = context;
-
+        const { userId, name, email } = await assertUserData(order?.userId);
         if (orderPayment) {
+          if (!order) throw new Error('order not found in context');
           const pricing = OrderPricingSheet({
-            calculation: order.calculation,
-            currencyCode: order.currencyCode,
+            calculation: order?.calculation,
+            currencyCode: order?.currencyCode,
           });
-          const { userId, name, email } = await getUserData(order?.userId);
           const paymentIntent = await createOrderPaymentIntent(
             { userId, name, email, order, orderPayment, pricing, descriptorPrefix },
             transactionContext,
@@ -100,7 +102,6 @@ const Stripe: IPaymentAdapter = {
           return paymentIntent.client_secret;
         }
 
-        const { userId, name, email } = await getUserData(order?.userId);
         const paymentIntent = await createRegistrationIntent(
           { userId, name, email, paymentProviderId, descriptorPrefix },
           transactionContext,
@@ -114,11 +115,12 @@ const Stripe: IPaymentAdapter = {
           throw new Error('You have to provide paymentIntentId or paymentCredentials');
         }
 
-        const { order } = context;
-        const orderPayment = await modules.orders.payments.findOrderPayment({
-          orderPaymentId: order.paymentId,
-        });
-        const { userId, name, email } = await getUserData(order?.userId);
+        const { order, orderPayment } = context;
+
+        if (!order) throw new Error('order not found in context');
+        if (!orderPayment) throw new Error('orderPayment not found in context');
+
+        const { userId, name, email } = await assertUserData(order?.userId);
         const pricing = OrderPricingSheet({
           calculation: order.calculation,
           currencyCode: order.currencyCode,

package/src/payment/stripe/stripe.ts

@@ -3,29 +3,32 @@ import { Order, OrderPayment } from '@unchainedshop/core-orders';
 import { createLogger } from '@unchainedshop/logger';
 import { Stripe as StripeType } from 'stripe';
 
-const logger = createLogger('unchained:plugins:payment:stripe');
+const logger = createLogger('unchained:stripe');
 
 const { STRIPE_SECRET, STRIPE_WEBHOOK_ENVIRONMENT, EMAIL_WEBSITE_NAME } = process.env;
 
 let stripe: Awaited<ReturnType<typeof initStripeClient>> | null;
 
-export const initStripeClient = async (): Promise<StripeType> => {
+export const initStripeClient = async (): Promise<StripeType | null> => {
   if (!STRIPE_SECRET) {
     logger.warn('STRIPE_SECRET is not set, skipping initialization');
-    return null;
+    return Promise.resolve(null);
   }
   // eslint-disable-next-line
   // @ts-ignore
   const { default: Stripe } = await import('stripe');
   stripe = new Stripe(STRIPE_SECRET, {
-    apiVersion: '2025-06-30.basil',
+    apiVersion: '2025-09-30.clover',
   });
   return stripe;
 };
 
 initStripeClient().catch(logger.warn);
 
-export default function () {
+export default function getStripe() {
+  if (!stripe) {
+    throw new Error('Stripe client not initialized');
+  }
   return stripe;
 }
 
@@ -33,7 +36,7 @@ const environment = STRIPE_WEBHOOK_ENVIRONMENT ?? null;
 
 export const upsertCustomer = async ({ userId, name, email }): Promise<string> => {
   try {
-    const { data } = await stripe.customers.search({ query: `metadata["userId"]:"${userId}"` });
+    const { data } = await getStripe().customers.search({ query: `metadata["userId"]:"${userId}"` });
     const existingCustomer = data[0];
 
     if (
@@ -41,7 +44,7 @@ export const upsertCustomer = async ({ userId, name, email }): Promise<string> =
       existingCustomer.email !== email ||
       existingCustomer.metadata.environment !== environment
     ) {
-      const updatedCustomer = await stripe.customers.update(existingCustomer.id, {
+      const updatedCustomer = await getStripe().customers.update(existingCustomer.id, {
         metadata: {
           userId,
           environment,
@@ -54,7 +57,7 @@ export const upsertCustomer = async ({ userId, name, email }): Promise<string> =
 
     return existingCustomer.id;
   } catch {
-    const customer = await stripe.customers.create({
+    const customer = await getStripe().customers.create({
       metadata: {
         userId,
         environment: STRIPE_WEBHOOK_ENVIRONMENT ?? null,
@@ -83,9 +86,10 @@ export const createRegistrationIntent = async (
   options: Record<string, any> = {},
 ) => {
   const customer = options?.customer || (await upsertCustomer({ userId, name, email }));
-  const description = `${descriptorPrefix || EMAIL_WEBSITE_NAME || 'Unchained'}`.trim();
+  const description =
+    `${options?.description || descriptorPrefix || EMAIL_WEBSITE_NAME || 'Unchained'}`.trim();
 
-  const setupIntent = await stripe.setupIntents.create({
+  const setupIntent = await getStripe().setupIntents.create({
     description,
     customer,
     metadata: {
@@ -119,12 +123,13 @@ export const createOrderPaymentIntent = async (
   },
   options: Record<string, any> = {},
 ) => {
-  const description = `${descriptorPrefix || EMAIL_WEBSITE_NAME || 'Unchained'}`.trim();
+  const description =
+    `${options?.description || descriptorPrefix || EMAIL_WEBSITE_NAME || 'Unchained'}`.trim();
   const customer = options?.customer || (await upsertCustomer({ userId, name, email }));
 
   const { currencyCode, amount } = pricing.total({ useNetPrice: false });
 
-  const paymentIntent = await stripe.paymentIntents.create({
+  const paymentIntent = await getStripe().paymentIntents.create({
     amount: Math.round(amount),
     currency: currencyCode.toLowerCase(),
     description,

package/src/pricing/delivery-swiss-tax.ts

@@ -5,35 +5,8 @@ import {
   DeliveryPricingDirector,
 } from '@unchainedshop/core';
 
-import { Order } from '@unchainedshop/core-orders';
-import { DeliveryProvider } from '@unchainedshop/core-delivery';
-import { SwissTaxCategories } from './tax/ch.js';
-
-const getTaxRate = ({ order, provider }: { order?: Order; provider?: DeliveryProvider }) => {
-  const taxCategoryFromProvider = provider?.configuration?.find(({ key }) => {
-    if (key === 'swiss-tax-category') return true;
-    return null;
-  })?.value;
-
-  const taxCategory = SwissTaxCategories[taxCategoryFromProvider] || SwissTaxCategories.DEFAULT;
-  return taxCategory.rate(order?.ordered);
-};
-
-const isDeliveryAddressInSwitzerland = ({
-  orderDelivery,
-  order,
-  countryCode: forceCountryCode = null,
-}) => {
-  let countryCode = forceCountryCode?.toUpperCase().trim() || order.countryCode;
-
-  const address = orderDelivery?.context?.address || order?.billingAddress;
-
-  if (address?.countryCode > '') {
-    countryCode = address.countryCode?.toUpperCase().trim();
-  }
-
-  return countryCode === 'CH' || countryCode === 'LI';
-};
+import { resolveTaxCategoryFromDeliveryProvider, SwissTaxCategories } from './tax/ch.js';
+import isDeliveryAddressInCountry from './utils/isDeliveryAddressInCountry.js';
 
 export const DeliverySwissTax: IDeliveryPricingAdapter = {
   ...DeliveryPricingAdapter,
@@ -44,7 +17,16 @@ export const DeliverySwissTax: IDeliveryPricingAdapter = {
   orderIndex: 80,
 
   isActivatedFor: (context) => {
-    return isDeliveryAddressInSwitzerland(context);
+    if (!context.order) return false;
+    if (!context.orderDelivery) return false;
+    return isDeliveryAddressInCountry(
+      {
+        order: context.order,
+        orderDelivery: context.orderDelivery,
+        countryCode: context.countryCode,
+      },
+      ['CH', 'LI'],
+    );
   },
 
   actions: (params) => {
@@ -55,7 +37,10 @@ export const DeliverySwissTax: IDeliveryPricingAdapter = {
       ...pricingAdapter,
 
       calculate: async () => {
-        const taxRate = getTaxRate(context);
+        const taxCategory =
+          resolveTaxCategoryFromDeliveryProvider(context.provider) || SwissTaxCategories.DEFAULT;
+        const taxRate = taxCategory.rate(context.order?.ordered);
+
         DeliveryPricingAdapter.log(`DeliverySwissTax -> Tax Multiplicator: ${taxRate}`);
         params.calculationSheet.filterBy({ isTaxable: true }).forEach(({ isNetPrice, ...row }) => {
           if (!isNetPrice) {

package/src/pricing/order-discount.ts

@@ -31,6 +31,8 @@ export const OrderDiscount: IOrderPricingAdapter<OrderDiscountConfiguration> = {
       ...pricingAdapter,
 
       calculate: async () => {
+        if (!order) return pricingAdapter.calculate();
+
         const totalAmountOfItems = params.calculationSheet.total({
           category: OrderPricingRowCategory.Items,
           useNetPrice: false,
@@ -57,7 +59,7 @@ export const OrderDiscount: IOrderPricingAdapter<OrderDiscountConfiguration> = {
 
         const deliveryShare = resolveRatioAndTaxDivisorForPricingSheet(
           DeliveryPricingSheet({
-            calculation: orderDelivery.calculation || [],
+            calculation: orderDelivery?.calculation || [],
             currencyCode: order.currencyCode,
           }),
           totalAmountOfPaymentAndDelivery,
@@ -65,7 +67,7 @@ export const OrderDiscount: IOrderPricingAdapter<OrderDiscountConfiguration> = {
 
         const paymentShare = resolveRatioAndTaxDivisorForPricingSheet(
           PaymentPricingSheet({
-            calculation: orderPayment.calculation || [],
+            calculation: orderPayment?.calculation || [],
             currencyCode: order.currencyCode,
           }),
           totalAmountOfPaymentAndDelivery,
@@ -86,8 +88,8 @@ export const OrderDiscount: IOrderPricingAdapter<OrderDiscountConfiguration> = {
           // If it's a fixed rate we need to deduct the already deducted amount from the fixed rate
           // before we hand it over to the split calculation
           const fixedRate =
-            configuration.fixedRate > 0
-              ? Math.max(0, configuration.fixedRate - itemsDiscountAmount)
+            Number(configuration.fixedRate) > 0
+              ? Math.max(0, configuration.fixedRate! - itemsDiscountAmount)
               : undefined;
           const leftInFeesToSplit = calcUtils.calculateAmountToSplit(
             { ...configuration, fixedRate },

package/src/pricing/order-round.ts

@@ -54,6 +54,8 @@ export const OrderPriceRound: IOrderPricingAdapter & {
       calculate: async () => {
         const { currencyCode } = params.context;
 
+        if (!currencyCode) return pricingAdapter.calculate();
+
         const { amount: deliveryAmount } = params.calculationSheet.total({
           category: OrderPricingRowCategory.Delivery,
           useNetPrice: true,
@@ -73,13 +75,12 @@ export const OrderPriceRound: IOrderPricingAdapter & {
           useNetPrice: true,
         });
         if (discountAmount) {
-          pricingAdapter.resultSheet().addDiscount({
+          pricingAdapter.resultSheet().calculation.push({
+            category: OrderPricingRowCategory.Discounts,
             amount: calculateDifference(discountAmount, currencyCode),
-            taxAmount: 0,
             meta: {
               adapter: OrderPriceRound.key,
             },
-            discountId: null,
           });
         }
 
@@ -126,7 +127,7 @@ export const OrderPriceRound: IOrderPricingAdapter & {
           // WORKAROUND BECAUSE ORDER TOTAL GROSS PRICE IS CALCULATED WITH A SUM OF EVERYTHING EXCEPT TAXES
           // AS OF UNCHAINED <= 2.6
           pricingAdapter.resultSheet().calculation.push({
-            category: null,
+            category: null as any as string,
             amount: taxDifference,
             meta: {
               adapter: OrderPriceRound.key,

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

@@ -0,0 +1,67 @@
+import {
+  ProductPricingDirector,
+  ProductPricingAdapter,
+  type IProductPricingAdapter,
+} from '@unchainedshop/core';
+
+const ProductPrice: IProductPricingAdapter = {
+  ...ProductPricingAdapter,
+
+  key: 'shop.unchained.pricing.product-price-options',
+  version: '1.0',
+  label: 'Add Gross Price of Options',
+  orderIndex: 1,
+
+  isActivatedFor: () => {
+    return true;
+  },
+
+  actions: (params) => {
+    const pricingAdapter = ProductPricingAdapter.actions(params);
+    const { countryCode, currencyCode, quantity, modules } = params.context;
+
+    return {
+      ...pricingAdapter,
+
+      async calculatePriceForProduct(product) {
+        const price = await modules.products.prices.price(product, {
+          countryCode,
+          currencyCode,
+          quantity,
+        });
+        if (price) {
+          const itemTotal = price.amount * quantity;
+          pricingAdapter.resultSheet().addItem({
+            amount: itemTotal,
+            isTaxable: Boolean(price.isTaxable),
+            isNetPrice: Boolean(price.isNetPrice),
+            meta: { adapter: ProductPrice.key },
+          });
+        }
+      },
+
+      async calculate() {
+        const { configuration } = params.context;
+
+        const productIds = configuration?.flatMap(({ key, value }) => {
+          if (key === 'option') return [value];
+          return [];
+        });
+
+        if (!productIds?.length) {
+          return pricingAdapter.calculate();
+        }
+
+        const options = await modules.products.findProducts({
+          productIds,
+        });
+
+        await Promise.all(options.map(this.calculatePriceForProduct));
+
+        return pricingAdapter.calculate();
+      },
+    };
+  },
+};
+
+ProductPricingDirector.registerAdapter(ProductPrice);

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,
@@ -33,10 +34,32 @@ export const ProductPrice: IProductPricingAdapter = {
           const itemTotal = price.amount * quantity;
           pricingAdapter.resultSheet().addItem({
             amount: itemTotal,
-            isTaxable: price.isTaxable,
-            isNetPrice: price.isNetPrice,
+            isTaxable: Boolean(price.isTaxable),
+            isNetPrice: Boolean(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: Boolean(bundleItemPrice.isTaxable),
+                  isNetPrice: Boolean(bundleItemPrice.isNetPrice),
+                  meta: { adapter: ProductPrice.key },
+                });
+              }
+            }
+          }
         }
 
         return pricingAdapter.calculate();

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

@@ -54,13 +54,13 @@ export const ProductPriceRateConversion: IProductPricingAdapter = {
 
         const rateData = await modules.products.prices.rates.getRate(fromCurrencyObj, targetCurrencyObj);
 
-        if (rateData?.rate > 0) {
+        if (rateData && rateData.rate > 0) {
           const convertedAmount = Math.round(productPrice.amount * rateData.rate);
           pricingAdapter.resultSheet().resetCalculation(params.calculationSheet);
           pricingAdapter.resultSheet().addItem({
             amount: convertedAmount * quantity,
-            isTaxable: productPrice?.isTaxable,
-            isNetPrice: productPrice?.isNetPrice,
+            isTaxable: Boolean(productPrice?.isTaxable),
+            isNetPrice: Boolean(productPrice?.isNetPrice),
             meta: { adapter: ProductPriceRateConversion.key, rate: rateData.rate },
           });
         }

package/src/pricing/product-swiss-tax.ts

@@ -1,47 +1,16 @@
 import {
   ProductPricingDirector,
   ProductPricingAdapter,
-  ProductPricingAdapterContext,
   IProductPricingAdapter,
   ProductPricingRowCategory,
-  UnchainedCore,
 } from '@unchainedshop/core';
-import { SwissTaxCategories } from './tax/ch.js';
-
-export const getTaxRate = (context: ProductPricingAdapterContext) => {
-  const { product, order } = context;
-
-  const productSpecialTaxTag = product.tags?.find((tag) =>
-    tag?.trim().toLowerCase().startsWith('swiss-tax-category:'),
-  );
-  const taxCategory =
-    Object.values(SwissTaxCategories).find(
-      (t) => `swiss-tax-category:${t.value}` === productSpecialTaxTag?.trim().toLowerCase(),
-    ) || SwissTaxCategories.DEFAULT;
-
-  return taxCategory.rate(order?.ordered);
-};
-
-export const isDeliveryAddressInSwitzerland = async ({
-  order,
-  countryCode: forceCountryCode,
-  modules,
-}: ProductPricingAdapterContext & { modules: UnchainedCore['modules'] }) => {
-  let countryCode = forceCountryCode?.toUpperCase().trim() || order.countryCode;
-
-  if (order) {
-    const orderDelivery = await modules.orders.deliveries.findDelivery({
-      orderDeliveryId: order.deliveryId,
-    });
-    const address = orderDelivery?.context?.address || order.billingAddress;
-
-    if (address?.countryCode > '') {
-      countryCode = address.countryCode?.toUpperCase().trim();
-    }
-  }
-
-  return countryCode === 'CH' || countryCode === 'LI';
-};
+import {
+  resolveTaxCategoryFromDeliveryProvider,
+  resolveTaxCategoryFromProduct,
+  SwissTaxCategories,
+  SwissTaxCategoryResolver,
+} from './tax/ch.js';
+import isDeliveryAddressInCountry from './utils/isDeliveryAddressInCountry.js';
 
 export const ProductSwissTax: IProductPricingAdapter = {
   ...ProductPricingAdapter,
@@ -63,10 +32,40 @@ export const ProductSwissTax: IProductPricingAdapter = {
       ...pricingAdapter,
 
       calculate: async () => {
-        if (!(await isDeliveryAddressInSwitzerland(context))) {
+        const orderDelivery = context.order?.deliveryId
+          ? await context.modules.orders.deliveries.findDelivery({
+              orderDeliveryId: context.order?.deliveryId,
+            })
+          : null;
+        if (
+          !isDeliveryAddressInCountry(
+            {
+              ...context,
+              orderDelivery,
+            },
+            ['CH', 'LI'],
+          )
+        ) {
           return pricingAdapter.calculate();
         }
-        const taxRate = getTaxRate(context);
+
+        let taxCategory: SwissTaxCategoryResolver | null = resolveTaxCategoryFromProduct(
+          context.product,
+        );
+        if (!taxCategory) {
+          // No special tax category found, use default from delivery provider
+          const provider = orderDelivery?.deliveryProviderId
+            ? await context.modules.delivery.findProvider({
+                deliveryProviderId: orderDelivery?.deliveryProviderId,
+              })
+            : null;
+          if (provider) taxCategory = resolveTaxCategoryFromDeliveryProvider(provider);
+        }
+        // If still no tax category found, use default
+        if (!taxCategory) taxCategory = SwissTaxCategories.DEFAULT;
+
+        const taxRate = taxCategory.rate(context.order?.ordered);
+
         ProductPricingAdapter.log(`ProductSwissTax -> Tax Multiplicator: ${taxRate}`);
         params.calculationSheet.filterBy({ isTaxable: true }).forEach(({ isNetPrice, ...row }) => {
           if (!isNetPrice) {