@unchainedshop/core 3.0.0-alpha7 → 3.0.0-rc2

package/src/directors/ProductPricingAdapter.ts

@@ -0,0 +1,56 @@
+import { Product, ProductConfiguration } from '@unchainedshop/core-products';
+import { Order } from '@unchainedshop/core-orders';
+import {
+  IProductPricingSheet,
+  ProductPricingCalculation,
+  ProductPricingSheet,
+  BasePricingAdapter,
+  BasePricingAdapterContext,
+  IPricingAdapter,
+} from '../directors/index.js';
+import { Modules } from '../modules.js';
+
+export interface ProductPricingAdapterContext extends BasePricingAdapterContext {
+  country: string;
+  currency: string;
+  product: Product;
+  quantity: number;
+  configuration: Array<ProductConfiguration>;
+  order?: Order;
+}
+
+export type IProductPricingAdapter<DiscountConfiguration = unknown> = IPricingAdapter<
+  ProductPricingAdapterContext & { modules: Modules },
+  ProductPricingCalculation,
+  IProductPricingSheet,
+  DiscountConfiguration
+>;
+
+const basePricingAdapter = BasePricingAdapter<ProductPricingAdapterContext, ProductPricingCalculation>();
+
+export const ProductPricingAdapter: IProductPricingAdapter = {
+  ...basePricingAdapter,
+
+  isActivatedFor: () => {
+    return false;
+  },
+
+  actions: (params) => {
+    const { context } = params;
+    const { currency, quantity } = context;
+    const baseActions = basePricingAdapter.actions(params);
+    const resultSheet = ProductPricingSheet({ currency, quantity });
+
+    return {
+      ...baseActions,
+      calculate: async () => {
+        const resultRaw = resultSheet.getRawPricingSheet();
+        resultRaw.forEach(({ amount, category }) =>
+          basePricingAdapter.log(`Product Item Calculation -> ${category} ${amount}`),
+        );
+        return resultRaw;
+      },
+      resultSheet: () => resultSheet,
+    };
+  },
+};

package/src/directors/ProductPricingDirector.ts

@@ -0,0 +1,100 @@
+import { Product, ProductConfiguration } from '@unchainedshop/core-products';
+import { User } from '@unchainedshop/core-users';
+import { Order, OrderDiscount, OrderPosition } from '@unchainedshop/core-orders';
+import {
+  IProductPricingSheet,
+  ProductPricingCalculation,
+  ProductPricingSheet,
+  IProductPricingAdapter,
+  ProductPricingAdapterContext,
+  BasePricingDirector,
+  IPricingDirector,
+} from '../directors/index.js';
+
+export type ProductPricingContext =
+  | {
+      currency: string;
+      quantity: number;
+      country?: string;
+      discounts?: Array<OrderDiscount>;
+      order?: Order;
+      product?: Product;
+      configuration?: Array<ProductConfiguration>;
+      user?: User;
+    }
+  | {
+      currency: string;
+      quantity: number;
+      item: OrderPosition;
+    };
+
+const baseDirector = BasePricingDirector<
+  ProductPricingContext,
+  ProductPricingAdapterContext,
+  ProductPricingCalculation,
+  IProductPricingAdapter
+>('ProductPricingDirector');
+
+export type IProductPricingDirector<DiscountConfiguration = unknown> = IPricingDirector<
+  ProductPricingContext,
+  ProductPricingCalculation,
+  ProductPricingAdapterContext,
+  IProductPricingSheet,
+  IProductPricingAdapter<DiscountConfiguration>
+>;
+
+export const ProductPricingDirector: IProductPricingDirector<any> = {
+  ...baseDirector,
+
+  async buildPricingContext(context, unchainedAPI) {
+    const { modules } = unchainedAPI;
+    const { quantity = 1, currency } = context;
+
+    if ('item' in context) {
+      const { item } = context;
+
+      const product = await modules.products.findProduct({
+        productId: item.productId,
+      });
+      const order = await modules.orders.findOrder({
+        orderId: item.orderId,
+      });
+      const user = await modules.users.findUserById(order.userId);
+      const discounts = await modules.orders.discounts.findOrderDiscounts({
+        orderId: item.orderId,
+      });
+
+      return {
+        ...unchainedAPI,
+        country: order.countryCode,
+        currency,
+        discounts,
+        order,
+        product,
+        quantity,
+        configuration: item.configuration,
+        user,
+      };
+    }
+
+    return {
+      ...unchainedAPI,
+      country: context.country,
+      currency,
+      discounts: [],
+      order: context.order,
+      product: context.product,
+      quantity,
+      configuration: context.configuration,
+      user: context.user,
+    };
+  },
+
+  calculationSheet(pricingContext, calculation) {
+    return ProductPricingSheet({
+      calculation,
+      currency: pricingContext.currency,
+      quantity: pricingContext.quantity ?? 1,
+    });
+  },
+};

package/src/directors/ProductPricingSheet.test.ts

@@ -0,0 +1,129 @@
+import { ProductPricingSheet } from './ProductPricingSheet.js';
+
+const TAX = { category: 'TAX', amount: 50, isNetPrice: false, isTaxable: false };
+const TAX2 = { category: 'TAX', amount: 25, isNetPrice: false, isTaxable: false };
+const DISCOUNT = {
+  category: 'DISCOUNT',
+  amount: 20,
+  isNetPrice: false,
+  isTaxable: false,
+  discountId: 'for-all',
+};
+const DISCOUNT2 = {
+  category: 'DISCOUNT',
+  amount: 20,
+  isNetPrice: false,
+  isTaxable: false,
+  discountId: 'for-all',
+};
+const DISCOUNT3 = {
+  category: 'DISCOUNT',
+  amount: 20,
+  isNetPrice: false,
+  isTaxable: false,
+  discountId: 'special',
+};
+const ITEM1 = { category: 'ITEM', amount: 200, isNetPrice: true, isTaxable: false };
+const ITEM2 = { category: 'ITEM', amount: 200, isNetPrice: true, isTaxable: false };
+const calculations = [TAX, TAX2, DISCOUNT, DISCOUNT2, DISCOUNT3, ITEM1, ITEM2];
+
+describe('ProductPricingSheet', () => {
+  let pricingSheet;
+
+  const pricingSheetParams = {
+    calculation: calculations,
+    currency: 'CHF',
+    quantity: 2,
+  };
+  beforeEach(() => {
+    pricingSheet = ProductPricingSheet(pricingSheetParams);
+  });
+
+  it('should return an object that implements the IProductPricingSheet interface', () => {
+    expect(pricingSheet).toBeDefined();
+    expect(pricingSheet.quantity).toEqual(2);
+    expect(pricingSheet.currency).toEqual('CHF');
+    expect(typeof pricingSheet.addItem).toBe('function');
+    expect(typeof pricingSheet.addDiscount).toBe('function');
+    expect(typeof pricingSheet.addTax).toBe('function');
+    expect(typeof pricingSheet.taxSum).toBe('function');
+    expect(typeof pricingSheet.unitPrice).toBe('function');
+    expect(typeof pricingSheet.discountPrices).toBe('function');
+  });
+
+  it('gross() should return the GROSS sum of all ProductPricingCalculation', () => {
+    expect(pricingSheet.gross()).toEqual(535);
+  });
+
+  it('net() should return the NET sum of all ProductPricingCalculation (i.e before TAX)', () => {
+    expect(pricingSheet.net()).toEqual(460);
+  });
+
+  describe('total()', () => {
+    it('should return sum of all ProductPricingCalculations ', () => {
+      expect(pricingSheet.total()).toEqual({ amount: 535, currency: 'CHF' });
+      expect(pricingSheet.total()).toEqual({ amount: pricingSheet.gross(), currency: 'CHF' });
+    });
+
+    it('should return sum of all ProductPricingCalculations ', () => {
+      expect(pricingSheet.total({ useNetPrice: true })).toEqual({ amount: 460, currency: 'CHF' });
+      expect(pricingSheet.total({ useNetPrice: true })).toEqual({
+        amount: pricingSheet.net(),
+        currency: 'CHF',
+      });
+    });
+
+    it('should return sum of all ProductPricingCalculations for the provided category ', () => {
+      expect(pricingSheet.total({ category: 'ITEM' })).toEqual({ amount: 400, currency: 'CHF' });
+      expect(pricingSheet.total({ category: 'DISCOUNT' })).toEqual({ amount: 60, currency: 'CHF' });
+      expect(pricingSheet.total({ category: 'TAX' })).toEqual({ amount: 75, currency: 'CHF' });
+    });
+  });
+
+  describe('isValid()', () => {
+    it('should return true if there is at least 1 registered ProductPricingCalculation ', () => {
+      expect(pricingSheet.isValid()).toEqual(true);
+    });
+    it('should return false if there is no registered ProductPricingCalculation ', () => {
+      const sheet = ProductPricingSheet({ ...pricingSheetParams, calculation: [] });
+      expect(sheet.isValid()).toEqual(false);
+    });
+  });
+
+  describe('getRawPricingSheet', () => {
+    it('should return all registered ProductPricingCalculation', () => {
+      expect(pricingSheet.getRawPricingSheet()).toEqual(calculations);
+    });
+  });
+
+  describe('taxSum', () => {
+    it('should return the sum of TAX calculation registered on the adapter', () => {
+      expect(pricingSheet.taxSum()).toEqual(75);
+    });
+  });
+
+  describe('unitPrice', () => {
+    it('should return the GROSS sum for a  product price useNetPrice:false', () => {
+      expect(pricingSheet.unitPrice({ useNetPrice: false })).toEqual({ amount: 268, currency: 'CHF' });
+    });
+
+    it('should return the NET sum for a product price when useNetPrice:true', () => {
+      expect(pricingSheet.unitPrice({ useNetPrice: true })).toEqual({ amount: 230, currency: 'CHF' });
+    });
+  });
+
+  describe('discountPrices', () => {
+    it('should return the sum of all discounts registered on the price sheet based on discountId', () => {
+      expect(pricingSheet.discountPrices('for-all')).toEqual([
+        { amount: 40, currency: 'CHF', discountId: 'for-all' },
+      ]);
+      expect(pricingSheet.discountPrices('special')).toEqual([
+        { amount: 20, currency: 'CHF', discountId: 'special' },
+      ]);
+    });
+
+    it('should return empty array if discount with the provided discountId is not found', () => {
+      expect(pricingSheet.discountPrices('non-existing')).toEqual([]);
+    });
+  });
+});

package/src/directors/ProductPricingSheet.ts

@@ -0,0 +1,127 @@
+import { PricingCalculation } from '@unchainedshop/utils';
+
+import { BasePricingSheet, IPricingSheet, PricingSheetParams } from '../directors/index.js';
+
+export interface ProductPricingCalculation extends PricingCalculation {
+  discountId?: string;
+  isTaxable: boolean;
+  isNetPrice: boolean;
+  rate?: number;
+}
+export enum ProductPricingRowCategory {
+  Item = 'ITEM',
+  Discount = 'DISCOUNT',
+  Tax = 'TAX',
+}
+
+export interface IProductPricingSheet extends IPricingSheet<ProductPricingCalculation> {
+  addItem: (params: Omit<ProductPricingCalculation, 'category' | 'discountId'>) => void;
+
+  addTax: (params: {
+    amount: number;
+    rate: number;
+    baseCategory?: string;
+    discountId?: string;
+    meta?: any;
+  }) => void;
+
+  addDiscount: (params: {
+    amount: number;
+    isTaxable: boolean;
+    isNetPrice: boolean;
+    discountId: string;
+    meta?: any;
+  }) => void;
+
+  unitPrice: (params?: { useNetPrice: boolean }) => {
+    amount: number;
+    currency: string;
+  };
+}
+
+export const ProductPricingSheet = (
+  params: PricingSheetParams<ProductPricingCalculation>,
+): IProductPricingSheet => {
+  const basePricingSheet = BasePricingSheet<ProductPricingCalculation>(params);
+
+  const pricingSheet: IProductPricingSheet = {
+    ...basePricingSheet,
+
+    addDiscount({ amount, isTaxable, isNetPrice, discountId, meta }) {
+      basePricingSheet.calculation.push({
+        category: ProductPricingRowCategory.Discount,
+        amount,
+        isTaxable,
+        isNetPrice,
+        discountId,
+        meta,
+      });
+    },
+
+    addItem({ amount, isTaxable, isNetPrice, meta }) {
+      basePricingSheet.calculation.push({
+        category: ProductPricingRowCategory.Item,
+        amount,
+        isTaxable,
+        isNetPrice,
+        meta,
+      });
+    },
+
+    addTax({ amount, baseCategory, rate, meta, discountId }) {
+      basePricingSheet.calculation.push({
+        category: ProductPricingRowCategory.Tax,
+        baseCategory,
+        discountId,
+        amount,
+        isTaxable: false,
+        isNetPrice: false,
+        rate,
+        meta,
+      });
+    },
+
+    taxSum(filter) {
+      return basePricingSheet.sum({
+        category: ProductPricingRowCategory.Tax,
+        ...(filter || {}),
+      });
+    },
+
+    unitPrice(unitPriceParams) {
+      const amount = unitPriceParams?.useNetPrice ? this.net() : this.gross();
+      return {
+        amount: Math.round(amount / (this.quantity ?? 1)),
+        currency: this.currency,
+      };
+    },
+
+    discountPrices(explicitDiscountId) {
+      const discountIds = pricingSheet
+        .filterBy({
+          category: ProductPricingRowCategory.Discount,
+          discountId: explicitDiscountId,
+        })
+        .map(({ discountId }) => discountId);
+
+      return [...new Set(discountIds)]
+        .map((discountId) => {
+          const amount = basePricingSheet.sum({
+            category: ProductPricingRowCategory.Discount,
+            discountId,
+          });
+          if (!amount) {
+            return null;
+          }
+          return {
+            discountId,
+            amount: Math.round(amount),
+            currency: basePricingSheet.currency,
+          };
+        })
+        .filter(Boolean);
+    },
+  };
+
+  return pricingSheet;
+};

package/src/directors/QuotationAdapter.ts

@@ -0,0 +1,86 @@
+import {
+  Quotation,
+  QuotationItemConfiguration,
+  QuotationProposal,
+} from '@unchainedshop/core-quotations';
+import { log, LogLevel } from '@unchainedshop/logger';
+import { IBaseAdapter } from '@unchainedshop/utils';
+
+export type QuotationContext = {
+  quotation?: Quotation;
+};
+
+export interface QuotationAdapterActions {
+  configurationError: () => QuotationError;
+  isManualProposalRequired: () => Promise<boolean>;
+  isManualRequestVerificationRequired: () => Promise<boolean>;
+  quote: () => Promise<QuotationProposal>;
+  rejectRequest: (unchainedAPI?: any) => Promise<boolean>;
+  submitRequest: (unchainedAPI?: any) => Promise<boolean>;
+  verifyRequest: (unchainedAPI?: any) => Promise<boolean>;
+
+  transformItemConfiguration: (
+    params: QuotationItemConfiguration,
+  ) => Promise<QuotationItemConfiguration>;
+}
+
+export type IQuotationAdapter = IBaseAdapter & {
+  orderIndex: number;
+  isActivatedFor: (quotationContext: QuotationContext, unchainedAPI) => boolean;
+  actions: (params: QuotationContext) => QuotationAdapterActions;
+};
+
+export enum QuotationError {
+  ADAPTER_NOT_FOUND = 'ADAPTER_NOT_FOUND',
+  NOT_IMPLEMENTED = 'NOT_IMPLEMENTED',
+  INCOMPLETE_CONFIGURATION = 'INCOMPLETE_CONFIGURATION',
+  WRONG_CREDENTIALS = 'WRONG_CREDENTIALS',
+}
+
+export const QuotationAdapter: Omit<IQuotationAdapter, 'key' | 'label' | 'version'> = {
+  orderIndex: 0,
+
+  isActivatedFor: () => {
+    return false;
+  },
+
+  actions: () => {
+    return {
+      configurationError: () => {
+        return QuotationError.NOT_IMPLEMENTED;
+      },
+
+      isManualRequestVerificationRequired: async () => {
+        return true;
+      },
+
+      isManualProposalRequired: async () => {
+        return true;
+      },
+
+      quote: async () => {
+        return {};
+      },
+
+      rejectRequest: async () => {
+        return true;
+      },
+
+      submitRequest: async () => {
+        return true;
+      },
+
+      verifyRequest: async () => {
+        return true;
+      },
+
+      transformItemConfiguration: async ({ quantity, configuration }) => {
+        return { quantity, configuration };
+      },
+    };
+  },
+
+  log(message: string, { level = LogLevel.Debug, ...options } = {}) {
+    return log(message, { level, ...options });
+  },
+};

package/src/directors/QuotationDirector.ts

@@ -0,0 +1,105 @@
+import { BaseDirector, IBaseDirector } from '@unchainedshop/utils';
+import {
+  QuotationError,
+  IQuotationAdapter,
+  QuotationAdapterActions,
+  QuotationContext,
+} from './QuotationAdapter.js';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:core');
+
+export type IQuotationDirector = IBaseDirector<IQuotationAdapter> & {
+  actions: (quotationContext: QuotationContext, unchainedAPI) => Promise<QuotationAdapterActions>;
+};
+
+const baseDirector = BaseDirector<IQuotationAdapter>('QuotationDirector', {
+  adapterSortKey: 'orderIndex',
+});
+
+const findAppropriateAdapters = (quotationContext: QuotationContext, unchainedAPI) =>
+  baseDirector.getAdapters({
+    adapterFilter: (Adapter: IQuotationAdapter) => {
+      const activated = Adapter.isActivatedFor(quotationContext, unchainedAPI);
+      if (!activated) {
+        logger.warn(`Quotation Director -> ${Adapter.key} (${Adapter.version}) skipped`);
+      }
+      return activated;
+    },
+  });
+
+export const QuotationDirector: IQuotationDirector = {
+  ...baseDirector,
+
+  actions: async (quotationContext, unchainedAPI) => {
+    const context = { ...quotationContext, ...unchainedAPI };
+
+    const Adapter = findAppropriateAdapters(quotationContext, unchainedAPI)?.shift();
+
+    if (!Adapter) {
+      throw new Error('No suitable quotation plugin available for this context');
+    }
+
+    const adapter = Adapter.actions(context);
+
+    return {
+      configurationError: () => {
+        try {
+          return adapter.configurationError();
+        } catch (error) {
+          logger.warn('QuotationDirector -> Error while checking for configurationError', {
+            ...error,
+          });
+          return QuotationError.ADAPTER_NOT_FOUND;
+        }
+      },
+
+      isManualRequestVerificationRequired: async () => {
+        try {
+          const isRequired = await adapter.isManualRequestVerificationRequired();
+          return isRequired;
+        } catch (error) {
+          logger.error(
+            'QuotationDirector -> Error while checking if is manual request verification required',
+            {
+              ...error,
+            },
+          );
+          return null;
+        }
+      },
+
+      isManualProposalRequired: async () => {
+        try {
+          const isRequired = await adapter.isManualProposalRequired();
+          return isRequired;
+        } catch (error) {
+          logger.error('QuotationDirector -> Error while checking if is manual proposal required', {
+            ...error,
+          });
+          return null;
+        }
+      },
+
+      quote: adapter.quote,
+      rejectRequest: adapter.rejectRequest,
+      submitRequest: adapter.submitRequest,
+      verifyRequest: adapter.verifyRequest,
+
+      transformItemConfiguration: async ({ quantity, configuration }) => {
+        try {
+          const itemConfiguration = await adapter.transformItemConfiguration({
+            quantity,
+            configuration,
+          });
+          return itemConfiguration;
+        } catch (error) {
+          logger.error('QuotationDirector -> Error while transforming item configuration', {
+            ...error,
+          });
+          return null;
+        }
+      },
+    };
+  },
+};

package/src/directors/WarehousingAdapter.ts

@@ -0,0 +1,83 @@
+import { log, LogLevel } from '@unchainedshop/logger';
+import { IBaseAdapter } from '@unchainedshop/utils';
+import { DeliveryProvider } from '@unchainedshop/core-delivery';
+import { Product } from '@unchainedshop/core-products';
+import { Order, OrderPosition } from '@unchainedshop/core-orders';
+import {
+  TokenSurrogate,
+  WarehousingConfiguration,
+  WarehousingProviderType,
+} from '@unchainedshop/core-warehousing';
+
+export enum WarehousingError {
+  ADAPTER_NOT_FOUND = 'ADAPTER_NOT_FOUND',
+  NOT_IMPLEMENTED = 'NOT_IMPLEMENTED',
+  INCOMPLETE_CONFIGURATION = 'INCOMPLETE_CONFIGURATION',
+  WRONG_CREDENTIALS = 'WRONG_CREDENTIALS',
+}
+
+export type WarehousingAdapterActions = {
+  configurationError: () => WarehousingError;
+  isActive: () => boolean;
+  stock: (referenceDate: Date) => Promise<number>;
+  productionTime: (quantityToProduce: number) => Promise<number>;
+  commissioningTime: (quantity: number) => Promise<number>;
+  tokenize: () => Promise<Array<Omit<TokenSurrogate, 'userId' | 'productId' | 'orderPositionId'>>>;
+  tokenMetadata: (chainTokenId: string, referenceDate: Date) => Promise<any>;
+  isInvalidateable: (chainTokenId: string, referenceDate: Date) => Promise<boolean>;
+};
+
+export interface WarehousingContext {
+  deliveryProvider?: DeliveryProvider;
+  product?: Product;
+  token?: TokenSurrogate;
+  quantity?: number;
+  referenceDate?: Date;
+  locale?: Intl.Locale;
+  order?: Order;
+  warehousingProviderId?: string;
+  orderPosition?: OrderPosition;
+}
+
+export type IWarehousingAdapter = IBaseAdapter & {
+  orderIndex: number;
+  initialConfiguration: WarehousingConfiguration;
+  typeSupported: (type: WarehousingProviderType) => boolean;
+
+  actions: (config: WarehousingConfiguration, context: WarehousingContext) => WarehousingAdapterActions;
+};
+
+export const WarehousingAdapter: Omit<IWarehousingAdapter, 'key' | 'label' | 'version'> = {
+  orderIndex: 0,
+
+  typeSupported: () => {
+    return false;
+  },
+
+  initialConfiguration: [],
+
+  actions: () => {
+    return {
+      configurationError: () => WarehousingError.NOT_IMPLEMENTED,
+
+      isActive: () => false,
+
+      stock: async () => 0,
+
+      productionTime: async () => 0,
+
+      commissioningTime: async () => 0,
+
+      tokenize: async () => [],
+
+      tokenMetadata: async () => ({}),
+
+      isInvalidateable: async () => true,
+    };
+  },
+
+  log(message, { level = LogLevel.Debug, ...options } = {}) {
+    // eslint-disable-line
+    return log(message, { level, ...options });
+  },
+};