@unchainedshop/plugins 4.0.0-rc.8 → 4.0.0

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/presets/all.ts

@@ -21,7 +21,9 @@ import '../filters/strict-equal.js';
 import '../filters/local-search.js';
 
 // Workers
-import '../worker/sms.js';
+import '../worker/twilio.js';
+import '../worker/bulkgate.js';
+import '../worker/budgetsms.js';
 import '../worker/push-notification.js';
 import '../worker/enrollment-order-generator.js';
 

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) {

package/src/pricing/tax/ch.ts

@@ -1,14 +1,16 @@
+import { DeliveryProvider } from '@unchainedshop/core-delivery';
+import { Product } from '@unchainedshop/core-products';
+
 const startOf2024 = new Date('2024-01-01T00:00:00.000+0100');
 
 // https://www.estv.admin.ch/estv/en/home/value-added-tax/vat-rates-switzerland.html
 
-export const SwissTaxCategories: Record<
-  string,
-  {
-    value: string;
-    rate: (referenceDate?: Date) => number;
-  }
-> = {
+export interface SwissTaxCategoryResolver {
+  value: string;
+  rate: (referenceDate?: Date) => number;
+}
+
+export const SwissTaxCategories: Record<string, SwissTaxCategoryResolver> = {
   DEFAULT: {
     value: 'default',
     rate: (referenceDate = new Date()) => {
@@ -37,3 +39,27 @@ export const SwissTaxCategories: Record<
     },
   },
 };
+
+export const resolveTaxCategoryFromDeliveryProvider = (
+  provider: DeliveryProvider,
+): SwissTaxCategoryResolver | null => {
+  const taxCategoryFromProvider = provider?.configuration
+    ?.find(({ key }) => {
+      if (key === 'swiss-tax-category') return true;
+      return null;
+    })
+    ?.value?.toUpperCase();
+
+  const taxCategory = taxCategoryFromProvider ? SwissTaxCategories[taxCategoryFromProvider] : null;
+  return taxCategory;
+};
+
+export const resolveTaxCategoryFromProduct = (product: Product): SwissTaxCategoryResolver | null => {
+  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(),
+  );
+  return taxCategory || null;
+};

package/src/pricing/utils/isDeliveryAddressInCountry.test.ts

@@ -0,0 +1,106 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import isDeliveryAddressInCountry from './isDeliveryAddressInCountry.js';
+
+describe('isDeliveryAddressInCountry', () => {
+  const context = {
+    modules: {
+      orders: {
+        deliveries: {
+          findDelivery: async ({ orderDeliveryId }: any) => {
+            if (orderDeliveryId === 'CH' || orderDeliveryId === 'LI')
+              return { context: { address: { countryCode: 'CH' } } };
+            if (orderDeliveryId === null) return { context: { address: null } };
+            return { context: { address: { countryCode: 'RT' } } };
+          },
+        },
+      },
+    },
+    order: {
+      deliveryId: 'CH',
+      billingAddress: { countryCode: 'LI' },
+    },
+    countryCode: 'CH',
+  };
+  it('Should return true when passed country code CH', async () => {
+    assert.strictEqual(
+      await isDeliveryAddressInCountry({ ...context, countryCode: 'ch', order: null } as any, [
+        'CH',
+        'LI',
+      ]),
+      true,
+    );
+  });
+
+  it('Should return true when passed country code LI', async () => {
+    assert.strictEqual(
+      await isDeliveryAddressInCountry({ ...context, countryCode: 'LI', order: null } as any, [
+        'CH',
+        'LI',
+      ]),
+      true,
+    );
+  });
+
+  it('Should return false when country is neither CH nor LI and order is null', async () => {
+    assert.strictEqual(
+      await isDeliveryAddressInCountry({ ...context, countryCode: 'ET', order: null } as any, [
+        'CH',
+        'LI',
+      ]),
+      false,
+    );
+  });
+
+  it('Order should take precedence over country parameter', async () => {
+    // not CH or LI order so returns false
+    assert.strictEqual(
+      await isDeliveryAddressInCountry(
+        {
+          ...context,
+          countryCode: 'CH',
+          order: {
+            deliveryId: 'ET',
+            billingAddress: { countryCode: 'ET' },
+          },
+        } as any,
+        ['CH', 'LI'],
+      ),
+      false,
+    );
+  });
+
+  it('If order is not from CH and LI but billingAddress is, it should take precedence over country ', async () => {
+    assert.strictEqual(
+      await isDeliveryAddressInCountry(
+        {
+          ...context,
+          countryCode: 'IT',
+          order: {
+            deliveryId: null,
+            billingAddress: { countryCode: 'CH' },
+          },
+        } as any,
+        ['CH', 'LI'],
+      ),
+      true,
+    );
+  });
+
+  it('Should return false if billingAddress is neither CH or LI and order does not have address', async () => {
+    assert.strictEqual(
+      await isDeliveryAddressInCountry(
+        {
+          ...context,
+          country: null,
+          order: {
+            deliveryId: null,
+            billingAddress: { countryCode: 'HH' },
+          },
+        } as any,
+        ['CH', 'LI'],
+      ),
+      false,
+    );
+  });
+});

package/src/pricing/utils/isDeliveryAddressInCountry.ts

@@ -0,0 +1,26 @@
+import { Order, OrderDelivery } from '@unchainedshop/core-orders';
+
+export default function isDeliveryAddressInCountry(
+  {
+    orderDelivery,
+    order,
+    countryCode: forceCountryCode = null,
+  }: {
+    orderDelivery?: OrderDelivery | null;
+    order?: Order | null;
+    countryCode?: string | null;
+  },
+  allowedCountryCodes: string[],
+) {
+  let countryCode = forceCountryCode?.toUpperCase().trim() || order?.countryCode;
+
+  if (orderDelivery || order) {
+    const address = orderDelivery?.context?.address || order?.billingAddress;
+    if (address?.countryCode > '') {
+      countryCode = address.countryCode?.toUpperCase().trim();
+    }
+  }
+
+  if (!countryCode) return false;
+  return allowedCountryCodes.includes(countryCode);
+}