@unchainedshop/plugins 4.3.5 → 4.4.0

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

@@ -1,67 +0,0 @@
-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

@@ -1,71 +0,0 @@
-import {
-  ProductPricingDirector,
-  ProductPricingAdapter,
-  IProductPricingAdapter,
-} from '@unchainedshop/core';
-import { ProductTypes } from '@unchainedshop/core-products';
-
-export const ProductPrice: IProductPricingAdapter = {
-  ...ProductPricingAdapter,
-
-  key: 'shop.unchained.pricing.product-price',
-  version: '1.0.0',
-  label: 'Add Gross Price to Product',
-  orderIndex: 0,
-
-  isActivatedFor: () => {
-    return true;
-  },
-
-  actions: (params) => {
-    const pricingAdapter = ProductPricingAdapter.actions(params);
-
-    return {
-      ...pricingAdapter,
-
-      calculate: async () => {
-        const { product, countryCode, currencyCode, quantity, modules } = params.context;
-        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 },
-          });
-        } 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();
-      },
-    };
-  },
-};
-
-ProductPricingDirector.registerAdapter(ProductPrice);

package/src/pricing/product-discount.ts

@@ -1,97 +0,0 @@
-import { calculation as calcUtils } from '@unchainedshop/utils';
-import {
-  ProductPricingDirector,
-  ProductPricingAdapter,
-  ProductDiscountConfiguration,
-  IProductPricingAdapter,
-  ProductPricingRowCategory,
-  Discount,
-} from '@unchainedshop/core';
-
-const ProductDiscount: IProductPricingAdapter<ProductDiscountConfiguration> = {
-  ...ProductPricingAdapter,
-
-  key: 'shop.unchained.pricing.product-discount',
-  version: '1.0.0',
-  label: 'Apply Discounts on Product Price',
-  orderIndex: 30,
-
-  isActivatedFor: () => {
-    return true;
-  },
-
-  actions: (params) => {
-    const pricingAdapter = ProductPricingAdapter.actions(params);
-
-    const addDiscounts = (
-      discount: Discount<ProductDiscountConfiguration>,
-      total: number,
-      resolvedConfiguration: ProductDiscountConfiguration,
-    ) => {
-      const { discountId } = discount;
-      const { isNetPrice = false, taxRate, ...meta } = resolvedConfiguration;
-      const amount = calcUtils.applyRate(resolvedConfiguration, total);
-      const isTaxable = taxRate === undefined || taxRate === null;
-
-      pricingAdapter.resultSheet().addDiscount({
-        amount: amount * -1,
-        discountId,
-        isNetPrice,
-        isTaxable,
-        meta: { adapter: ProductDiscount.key, ...meta },
-      });
-      if (!isTaxable && taxRate) {
-        const taxAmount = calcUtils.getTaxAmount(amount, taxRate, isNetPrice);
-        pricingAdapter.resultSheet().addTax({
-          amount: taxAmount * -1,
-          rate: taxRate,
-          discountId,
-          baseCategory: ProductPricingRowCategory.Discount,
-          meta: { adapter: ProductDiscount.key, discountId, ...meta },
-        });
-        if (!isNetPrice) {
-          pricingAdapter.resultSheet().addDiscount({
-            amount: taxAmount,
-            discountId,
-            isNetPrice: false,
-            isTaxable: false,
-            meta: { adapter: ProductDiscount.key, discountId, ...meta },
-          });
-        }
-      }
-    };
-
-    return {
-      ...pricingAdapter,
-
-      calculate: async () => {
-        params.discounts.forEach((discount) => {
-          if (!discount) return;
-
-          const { configuration } = discount;
-
-          const resolvedConfiguration = configuration.customPriceConfigurationResolver
-            ? configuration.customPriceConfigurationResolver(
-                params.context.product,
-                params.context.quantity,
-                params.context.configuration,
-              )
-            : configuration;
-
-          if (!resolvedConfiguration) return;
-
-          const total = params.calculationSheet.total({
-            category: ProductPricingRowCategory.Item,
-            useNetPrice: resolvedConfiguration.isNetPrice,
-          });
-
-          addDiscounts(discount, total.amount, resolvedConfiguration);
-        });
-
-        return pricingAdapter.calculate();
-      },
-    };
-  },
-};
-
-ProductPricingDirector.registerAdapter(ProductDiscount);

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

@@ -1,74 +0,0 @@
-import {
-  IProductPricingAdapter,
-  ProductPricingDirector,
-  ProductPricingAdapter,
-} from '@unchainedshop/core';
-
-export const ProductPriceRateConversion: IProductPricingAdapter = {
-  ...ProductPricingAdapter,
-
-  key: 'shop.unchained.pricing.rate-conversion',
-  version: '1.0.0',
-  label: 'Generic rate conversion plugin that converts between rates if entry in DB exists.',
-  orderIndex: 10,
-
-  isActivatedFor: () => {
-    return true;
-  },
-
-  actions: (params) => {
-    const pricingAdapter = ProductPricingAdapter.actions(params);
-    const { modules } = params.context;
-    return {
-      ...pricingAdapter,
-
-      calculate: async () => {
-        const { product, countryCode, quantity, currencyCode: targetCurrency } = params.context;
-
-        const { calculation = [] } = params.calculationSheet;
-        if (calculation?.length) {
-          // If we already have a price for the product,
-          // we skip this plugin because we don't need to convert
-          return pricingAdapter.calculate();
-        }
-
-        const productPrice = await modules.products.prices.price(product, {
-          countryCode,
-          quantity,
-        });
-
-        if (!productPrice) {
-          // We were not able to find a price for quantity & country
-          return pricingAdapter.calculate();
-        }
-
-        const fromCurrencyObj = await modules.currencies.findCurrency({
-          isoCode: productPrice.currencyCode,
-        });
-        const targetCurrencyObj = await modules.currencies.findCurrency({
-          isoCode: targetCurrency,
-        });
-
-        if (!targetCurrencyObj?.isActive || !fromCurrencyObj?.isActive)
-          return pricingAdapter.calculate();
-
-        const rateData = await modules.products.prices.rates.getRate(fromCurrencyObj, targetCurrencyObj);
-
-        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: Boolean(productPrice?.isTaxable),
-            isNetPrice: Boolean(productPrice?.isNetPrice),
-            meta: { adapter: ProductPriceRateConversion.key, rate: rateData.rate },
-          });
-        }
-
-        return pricingAdapter.calculate();
-      },
-    };
-  },
-};
-
-ProductPricingDirector.registerAdapter(ProductPriceRateConversion);

package/src/pricing/product-round.ts

@@ -1,66 +0,0 @@
-import {
-  ProductPricingAdapter,
-  ProductPricingDirector,
-  IProductPricingAdapter,
-} from '@unchainedshop/core';
-
-interface PriceRoundSettings {
-  defaultPrecision: number;
-  roundTo: (value: number, precision: number, currencyCode: string) => number;
-}
-
-export const ProductRound: IProductPricingAdapter & {
-  configure: (params: PriceRoundSettings) => void;
-  settings: PriceRoundSettings;
-} = {
-  ...ProductPricingAdapter,
-
-  key: 'shop.unchained.pricing.product-round',
-  version: '1.0.0',
-  label: 'Round product price',
-  orderIndex: 90,
-
-  isActivatedFor: () => {
-    return true;
-  },
-
-  settings: {
-    defaultPrecision: 5,
-    roundTo: (value: number, precision: number) => Math.round(value / precision) * precision,
-  },
-
-  configure({ defaultPrecision, roundTo }) {
-    if (defaultPrecision) this.settings.defaultPrecision = defaultPrecision;
-    if (roundTo) this.settings.roundTo = roundTo;
-  },
-
-  actions: (params) => {
-    const pricingAdapter = ProductPricingAdapter.actions(params);
-
-    return {
-      ...pricingAdapter,
-
-      calculate: async () => {
-        const { currencyCode } = params.context;
-        const { defaultPrecision, roundTo } = ProductRound.settings;
-        const { calculation = [] } = params.calculationSheet;
-
-        if (calculation?.length) {
-          pricingAdapter.resultSheet().resetCalculation(params.calculationSheet);
-
-          calculation.forEach((item) => {
-            const newAmount = roundTo(item.amount, defaultPrecision, currencyCode);
-            pricingAdapter.resultSheet().calculation.push({
-              ...item,
-              amount: newAmount,
-            });
-          });
-        }
-
-        return pricingAdapter.calculate();
-      },
-    };
-  },
-};
-
-ProductPricingDirector.registerAdapter(ProductRound);

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

@@ -1,102 +0,0 @@
-import {
-  ProductPricingDirector,
-  ProductPricingAdapter,
-  IProductPricingAdapter,
-  ProductPricingRowCategory,
-} from '@unchainedshop/core';
-import {
-  resolveTaxCategoryFromDeliveryProvider,
-  resolveTaxCategoryFromProduct,
-  SwissTaxCategories,
-  SwissTaxCategoryResolver,
-} from './tax/ch.js';
-import isDeliveryAddressInCountry from './utils/isDeliveryAddressInCountry.js';
-
-export const ProductSwissTax: IProductPricingAdapter = {
-  ...ProductPricingAdapter,
-
-  key: 'shop.unchained.pricing.product-swiss-tax',
-  version: '1.0.0',
-  label: 'Apply Swiss Tax on Product',
-  orderIndex: 80,
-
-  isActivatedFor: () => {
-    return true;
-  },
-
-  actions: (params) => {
-    const pricingAdapter = ProductPricingAdapter.actions(params);
-    const { context } = params;
-
-    return {
-      ...pricingAdapter,
-
-      calculate: async () => {
-        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();
-        }
-
-        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) {
-            const taxAmount = row.amount - row.amount / (1 + taxRate);
-            pricingAdapter.resultSheet().calculation.push({
-              ...row,
-              amount: -taxAmount,
-              isTaxable: false,
-              isNetPrice: false,
-              meta: { adapter: ProductSwissTax.key },
-            });
-            pricingAdapter.resultSheet().addTax({
-              amount: taxAmount,
-              rate: taxRate,
-              baseCategory: ProductPricingRowCategory.Item,
-              meta: { adapter: ProductSwissTax.key },
-            });
-          } else {
-            const taxAmount = row.amount * taxRate;
-            pricingAdapter.resultSheet().addTax({
-              amount: taxAmount,
-              rate: taxRate,
-              baseCategory: ProductPricingRowCategory.Item,
-              meta: { adapter: ProductSwissTax.key },
-            });
-          }
-        });
-        return pricingAdapter.calculate();
-      },
-    };
-  },
-};
-
-ProductPricingDirector.registerAdapter(ProductSwissTax);

package/src/pricing/tax/ch.test.ts

@@ -1,20 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import { SwissTaxCategories } from './ch';
-
-describe('SwissTaxCategories', () => {
-  it('DEFAULT rate', () => {
-    assert.strictEqual(SwissTaxCategories.DEFAULT.rate(new Date(2023, 1, 1)), 0.077);
-    assert.strictEqual(SwissTaxCategories.DEFAULT.rate(new Date(2024, 1, 1)), 0.081);
-  });
-
-  it('REDUCED rate', () => {
-    assert.strictEqual(SwissTaxCategories.REDUCED.rate(new Date(2023, 1, 1)), 0.025);
-    assert.strictEqual(SwissTaxCategories.REDUCED.rate(new Date(2024, 1, 1)), 0.026);
-  });
-
-  it('SPECIAL rate', () => {
-    assert.strictEqual(SwissTaxCategories.SPECIAL.rate(new Date(2023, 1, 1)), 0.037);
-    assert.strictEqual(SwissTaxCategories.SPECIAL.rate(new Date(2024, 1, 1)), 0.038);
-  });
-});

package/src/pricing/tax/ch.ts

@@ -1,65 +0,0 @@
-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 interface SwissTaxCategoryResolver {
-  value: string;
-  rate: (referenceDate?: Date) => number;
-}
-
-export const SwissTaxCategories: Record<string, SwissTaxCategoryResolver> = {
-  DEFAULT: {
-    value: 'default',
-    rate: (referenceDate = new Date()) => {
-      if (referenceDate.getTime() < startOf2024.getTime()) {
-        return 0.077;
-      }
-      return 0.081;
-    },
-  },
-  REDUCED: {
-    value: 'reduced',
-    rate: (referenceDate = new Date()) => {
-      if (referenceDate.getTime() < startOf2024.getTime()) {
-        return 0.025;
-      }
-      return 0.026;
-    },
-  },
-  SPECIAL: {
-    value: 'special',
-    rate: (referenceDate = new Date()) => {
-      if (referenceDate.getTime() < startOf2024.getTime()) {
-        return 0.037;
-      }
-      return 0.038;
-    },
-  },
-};
-
-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

@@ -1,106 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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);
-}