@unchainedshop/core 3.0.0-alpha7 → 3.0.0-rc10

package/src/directors/BasePricingDirector.ts

@@ -0,0 +1,137 @@
+import { BaseDirector, IBaseDirector, PricingCalculation } from '@unchainedshop/utils';
+import { BasePricingAdapterContext, BasePricingContext, IPricingAdapter } from './BasePricingAdapter.js';
+import { IPricingSheet } from './BasePricingSheet.js';
+import { OrderDiscountDirector } from './OrderDiscountDirector.js';
+import { createLogger } from '@unchainedshop/logger';
+import { Modules } from '../modules.js';
+
+const logger = createLogger('unchained:core');
+
+export interface Discount<DiscountConfiguration> {
+  discountId: string;
+  configuration: DiscountConfiguration;
+}
+
+export type IPricingDirector<
+  PricingContext extends BasePricingContext,
+  Calculation extends PricingCalculation,
+  PricingAdapterContext extends BasePricingAdapterContext,
+  PricingAdapterSheet extends IPricingSheet<Calculation>,
+  Adapter extends IPricingAdapter<PricingAdapterContext & Context, Calculation, PricingAdapterSheet>,
+  Context = { modules: Modules },
+> = IBaseDirector<Adapter> & {
+  buildPricingContext: (
+    pricingContext: PricingContext,
+    unchainedAPI: Context,
+  ) => Promise<PricingAdapterContext>;
+
+  rebuildCalculation: (
+    pricingContext: PricingContext,
+    unchainedAPI: Context,
+  ) => Promise<Array<Calculation>>;
+
+  calculationSheet: (
+    pricingContext: PricingContext,
+    calculation: Array<Calculation>,
+  ) => PricingAdapterSheet;
+};
+
+export const BasePricingDirector = <
+  DirectorContext extends BasePricingContext,
+  AdapterContext extends BasePricingAdapterContext,
+  Calculation extends PricingCalculation,
+  PricingAdapter extends IPricingAdapter<AdapterContext, Calculation, IPricingSheet<Calculation>>,
+>(
+  directorName: string,
+): IPricingDirector<
+  DirectorContext,
+  Calculation,
+  AdapterContext,
+  IPricingSheet<Calculation>,
+  PricingAdapter,
+  any
+> => {
+  const baseDirector = BaseDirector<PricingAdapter>(directorName, {
+    adapterSortKey: 'orderIndex',
+  });
+
+  const director: IPricingDirector<
+    DirectorContext,
+    Calculation,
+    AdapterContext,
+    IPricingSheet<Calculation>,
+    PricingAdapter,
+    any
+  > = {
+    ...baseDirector,
+
+    buildPricingContext: async () => {
+      throw new Error('Method not implemented');
+    },
+
+    calculationSheet() {
+      throw new Error('Method not implemented');
+    },
+
+    async rebuildCalculation(pricingContext, unchainedAPI) {
+      const context = await director.buildPricingContext(pricingContext, unchainedAPI);
+
+      let calculation: Array<Calculation> = [];
+
+      const Adapters = baseDirector.getAdapters({
+        adapterFilter: (Adapter) => {
+          return Adapter.isActivatedFor(context);
+        },
+      });
+
+      calculation = await Adapters.reduce(async (previousPromise, Adapter) => {
+        const resolvedCalculation = await previousPromise;
+        if (!resolvedCalculation) return null;
+
+        const discounts: Array<Discount<any>> = await Promise.all(
+          context.discounts.map(async (orderDiscount) => {
+            const order = await unchainedAPI.modules.orders.findOrder({
+              orderId: orderDiscount.orderId,
+            });
+            const DiscountAdapter = OrderDiscountDirector.getAdapter(orderDiscount.discountKey);
+            if (!DiscountAdapter) return null;
+
+            const adapter = await DiscountAdapter.actions({
+              context: { order, orderDiscount, code: orderDiscount.code, ...unchainedAPI },
+            });
+
+            const configuration = adapter.discountForPricingAdapterKey({
+              pricingAdapterKey: Adapter.key,
+              calculationSheet: this.calculationSheet(pricingContext, calculation),
+            });
+
+            return {
+              discountId: orderDiscount._id,
+              configuration,
+            };
+          }),
+        );
+
+        try {
+          const adapter = Adapter.actions({
+            context,
+            calculationSheet: this.calculationSheet(pricingContext, calculation),
+            discounts: discounts.filter((d) => d?.configuration !== null),
+          });
+
+          const nextCalculationResult = await adapter.calculate();
+          if (!nextCalculationResult) return null;
+          calculation = resolvedCalculation.concat(nextCalculationResult);
+          return calculation;
+        } catch (error) {
+          logger.error(error);
+        }
+        return resolvedCalculation;
+      }, Promise.resolve([]));
+
+      return calculation;
+    },
+  };
+
+  return director;
+};

package/src/directors/BasePricingSheet.test.ts

@@ -0,0 +1,43 @@
+import { resolveRatioAndTaxDivisorForPricingSheet } from './BasePricingSheet';
+
+describe('resolveRatioAndTaxDivisorForPricingSheet', () => {
+  it('total is 0 and pricing is provided', () => {
+    const pricing: any = {
+      taxSum: () => 10,
+      gross: () => 20,
+      net: () => 10,
+    };
+    const result = resolveRatioAndTaxDivisorForPricingSheet(pricing, 0);
+    expect(result).toEqual({ ratio: 1, taxDivisor: 1 });
+  });
+
+  it('gross - tax is 0', () => {
+    const pricing: any = {
+      taxSum: () => 10,
+      gross: () => 10,
+      net: () => 0,
+    };
+    const result = resolveRatioAndTaxDivisorForPricingSheet(pricing, 20);
+    expect(result).toEqual({ ratio: 0, taxDivisor: 0 });
+  });
+
+  it('gross - tax is not 0', () => {
+    const pricing: any = {
+      taxSum: () => 10,
+      gross: () => 20,
+      net: () => 10,
+    };
+    const result = resolveRatioAndTaxDivisorForPricingSheet(pricing, 20);
+    expect(result).toEqual({ ratio: 1, taxDivisor: 2 });
+  });
+
+  it('taxSum is 0', () => {
+    const pricing: any = {
+      taxSum: () => 0,
+      gross: () => 20,
+      net: () => 20,
+    };
+    const result = resolveRatioAndTaxDivisorForPricingSheet(pricing, 20);
+    expect(result).toEqual({ ratio: 1, taxDivisor: 1 });
+  });
+});

package/src/directors/BasePricingSheet.ts

@@ -0,0 +1,140 @@
+import { PricingCalculation } from '@unchainedshop/utils';
+export interface PricingDiscount {
+  discountId: string;
+  amount: number;
+  currency: string;
+}
+
+export interface IPricingSheet<Calculation extends PricingCalculation>
+  extends IBasePricingSheet<Calculation> {
+  discountPrices: (discountId?: string) => Array<PricingDiscount>;
+  addDiscount: (params: { amount: number; discountId: string; meta?: any }) => void;
+}
+
+export interface IBasePricingSheet<Calculation extends PricingCalculation> {
+  calculation: Array<Calculation>;
+  currency?: string;
+  quantity?: number;
+
+  getRawPricingSheet: () => Array<Calculation>;
+  filterBy: (filter?: Partial<Calculation>) => Array<Calculation>;
+  isValid: () => boolean;
+
+  gross: () => number;
+  net: () => number;
+  sum: (filter?: Partial<Calculation>) => number;
+  total: (params?: { category?: string; discountId?: string; useNetPrice?: boolean }) => {
+    amount: number;
+    currency: string;
+  };
+
+  taxSum: (filter?: Partial<Calculation>) => number;
+
+  resetCalculation: (sheetToInvert: IBasePricingSheet<Calculation>) => Array<Calculation>;
+}
+
+export interface PricingSheetParams<Calculation extends PricingCalculation> {
+  calculation?: Array<Calculation>;
+  currency?: string;
+  quantity?: number;
+}
+
+export const BasePricingSheet = <Calculation extends PricingCalculation>(
+  params: PricingSheetParams<Calculation>,
+): IBasePricingSheet<Calculation> => {
+  const pricingSheet: IBasePricingSheet<Calculation> = {
+    calculation: params.calculation || [],
+    currency: params.currency,
+    quantity: params.quantity,
+
+    getRawPricingSheet() {
+      return this.calculation;
+    },
+
+    isValid() {
+      return this.calculation.length > 0;
+    },
+
+    sum(filter) {
+      return this.filterBy(filter)
+        .filter(Boolean)
+        .reduce((sum: number, calculationRow: Calculation) => sum + calculationRow.amount, 0);
+    },
+
+    taxSum() {
+      return 0;
+    },
+
+    gross() {
+      // Sum contains taxes, thus it's gross when just suming everything
+      return this.sum();
+    },
+
+    net() {
+      // Remove all taxes from gross to get net
+      return this.sum() - this.taxSum();
+    },
+
+    total({ category, useNetPrice, discountId } = { useNetPrice: false }) {
+      const amount = this.sum({ category, discountId });
+      const taxAmountForCategory = this.taxSum({ baseCategory: category, discountId });
+
+      // Sum does not contain taxes when filtering by category, it's net in that case and gross if there is no category
+      const netAmount = !category ? amount - taxAmountForCategory : amount;
+
+      return {
+        amount: Math.round(useNetPrice ? netAmount : netAmount + taxAmountForCategory),
+        currency: this.currency,
+      };
+    },
+
+    filterBy(filter) {
+      const filteredCalculation = Object.keys(filter || {}).reduce(
+        (oldCalculation, filterKey) =>
+          oldCalculation.filter(
+            (row: Calculation) =>
+              !!row && (filter[filterKey] === undefined || row[filterKey] === filter[filterKey]),
+          ),
+        this.calculation,
+      );
+
+      return filteredCalculation;
+    },
+
+    resetCalculation(calculationSheet) {
+      calculationSheet.filterBy().forEach(({ amount, ...row }: Calculation) => {
+        this.calculation.push({
+          ...row,
+          amount: amount * -1,
+        } as Calculation);
+      });
+      return this.calculation;
+    },
+  };
+
+  return pricingSheet;
+};
+
+export const resolveRatioAndTaxDivisorForPricingSheet = (
+  pricing: IBasePricingSheet<PricingCalculation>,
+  total: number,
+) => {
+  if (total === 0 || !pricing) {
+    return {
+      ratio: 1,
+      taxDivisor: 1,
+    };
+  }
+  const tax = pricing.taxSum();
+  const gross = pricing.gross();
+  if (gross - tax === 0) {
+    return {
+      ratio: 0,
+      taxDivisor: 0,
+    };
+  }
+  return {
+    ratio: gross / total,
+    taxDivisor: gross / (gross - tax),
+  };
+};

package/src/directors/DeliveryAdapter.ts

@@ -0,0 +1,110 @@
+import { log, LogLevel } from '@unchainedshop/logger';
+import { IBaseAdapter } from '@unchainedshop/utils';
+import type { Order, OrderPosition, OrderDelivery } from '@unchainedshop/core-orders';
+import type { Product } from '@unchainedshop/core-products';
+import type { WarehousingProvider } from '@unchainedshop/core-warehousing';
+import type { Work } from '@unchainedshop/core-worker';
+import type { User } from '@unchainedshop/core-users';
+import {
+  DeliveryConfiguration,
+  DeliveryLocation,
+  DeliveryProvider,
+  DeliveryProviderType,
+} from '@unchainedshop/core-delivery';
+import { Modules } from '../modules.js';
+
+export enum DeliveryError {
+  ADAPTER_NOT_FOUND = 'ADAPTER_NOT_FOUND',
+  NOT_IMPLEMENTED = 'NOT_IMPLEMENTED',
+  INCOMPLETE_CONFIGURATION = 'INCOMPLETE_CONFIGURATION',
+  WRONG_CREDENTIALS = 'WRONG_CREDENTIALS',
+}
+
+export interface DeliveryAdapterActions {
+  configurationError: (transactionContext?: any) => DeliveryError;
+  estimatedDeliveryThroughput: (warehousingThroughputTime: number) => Promise<number>;
+  isActive: () => boolean;
+  isAutoReleaseAllowed: () => boolean;
+  pickUpLocationById: (locationId: string) => Promise<DeliveryLocation>;
+  pickUpLocations: () => Promise<Array<DeliveryLocation>>;
+  send: () => Promise<boolean | Work>;
+}
+
+export interface DeliveryContext {
+  country?: string;
+  deliveryProvider?: DeliveryProvider;
+  order?: Order;
+  orderDelivery?: OrderDelivery;
+  orderPosition?: OrderPosition;
+  product?: Product;
+  quantity?: number;
+  referenceDate?: Date;
+  transactionContext?: any;
+  user?: User;
+  warehousingProvider?: WarehousingProvider;
+  warehousingThroughputTime?: number;
+}
+
+export type IDeliveryAdapter = IBaseAdapter & {
+  initialConfiguration: DeliveryConfiguration;
+
+  typeSupported: (type: DeliveryProviderType) => boolean;
+
+  actions: (
+    config: DeliveryConfiguration,
+    context: DeliveryContext & { modules: Modules },
+  ) => DeliveryAdapterActions;
+};
+
+export const DeliveryAdapter: Omit<IDeliveryAdapter, 'key' | 'label' | 'version'> = {
+  initialConfiguration: [],
+
+  typeSupported: () => {
+    return false;
+  },
+
+  actions: () => {
+    return {
+      configurationError: () => {
+        return DeliveryError.NOT_IMPLEMENTED;
+      },
+
+      estimatedDeliveryThroughput: async () => {
+        return 0;
+      },
+
+      isActive: () => {
+        return false;
+      },
+
+      isAutoReleaseAllowed: () => {
+        // if you return false here,
+        // the order will need manual confirmation before
+        // unchained will try to invoke send()
+        return true;
+      },
+
+      send: async () => {
+        // if you return true, the status will be changed to DELIVERED
+
+        // if you return false, the order delivery status stays the
+        // same but the order status might change
+
+        // if you throw an error, you cancel the whole checkout process
+        return false;
+      },
+
+      pickUpLocationById: async () => {
+        return null;
+      },
+
+      pickUpLocations: async () => {
+        return [];
+      },
+    };
+  },
+
+  log: (message: string, { level = LogLevel.Debug, ...options } = {}) => {
+    return log(message, { level, ...options });
+  },
+};

package/src/directors/DeliveryDirector.ts

@@ -0,0 +1,135 @@
+import { BaseDirector, IBaseDirector } from '@unchainedshop/utils';
+import {
+  DeliveryAdapterActions,
+  DeliveryContext,
+  IDeliveryAdapter,
+  DeliveryError,
+} from './DeliveryAdapter.js';
+import { DeliveryProvider } from '@unchainedshop/core-delivery';
+import { OrderDelivery, OrderDeliveryStatus } from '@unchainedshop/core-orders';
+import { Modules } from '../modules.js';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:core');
+
+export type IDeliveryDirector = IBaseDirector<IDeliveryAdapter> & {
+  sendOrderDelivery: (
+    orderDelivery: OrderDelivery,
+    transactionContext: Record<string, any>,
+    unchainedAPI: { modules: Modules },
+  ) => Promise<OrderDelivery>;
+  actions: (
+    deliveryProvider: DeliveryProvider,
+    deliveryContext: DeliveryContext,
+    unchainedAPI: { modules: Modules },
+  ) => Promise<DeliveryAdapterActions>;
+};
+
+const baseDirector = BaseDirector<IDeliveryAdapter>('DeliveryDirector');
+
+export const DeliveryDirector: IDeliveryDirector = {
+  ...baseDirector,
+
+  actions: async (deliveryProvider, deliveryContext, unchainedAPI) => {
+    const Adapter = baseDirector.getAdapter(deliveryProvider.adapterKey);
+
+    const context = { ...deliveryContext, ...unchainedAPI };
+    const adapter = Adapter?.actions(deliveryProvider.configuration, context);
+
+    return {
+      configurationError: () => {
+        try {
+          return adapter.configurationError();
+        } catch {
+          return DeliveryError.ADAPTER_NOT_FOUND;
+        }
+      },
+
+      estimatedDeliveryThroughput: async (warehousingThroughputTime) => {
+        try {
+          const throughput = await adapter.estimatedDeliveryThroughput(warehousingThroughputTime);
+          return throughput;
+        } catch (error) {
+          logger.warn('Delivery Director -> Error while estimating delivery throughput', {
+            ...error,
+          });
+          return null;
+        }
+      },
+
+      isActive: () => {
+        try {
+          return adapter.isActive();
+        } catch (error) {
+          logger.warn('Delivery Director -> Error while checking if is active', {
+            ...error,
+          });
+          return false;
+        }
+      },
+
+      isAutoReleaseAllowed: () => {
+        try {
+          return adapter.isAutoReleaseAllowed();
+        } catch (error) {
+          logger.warn('Delivery Director -> Error while checking if auto release is allowed', {
+            ...error,
+          });
+          return false;
+        }
+      },
+
+      send: async () => {
+        return adapter.send();
+      },
+
+      pickUpLocationById: async (locationId) => {
+        return adapter.pickUpLocationById(locationId);
+      },
+
+      pickUpLocations: async () => {
+        return adapter.pickUpLocations();
+      },
+    };
+  },
+
+  sendOrderDelivery: async (orderDelivery, transactionContext, unchainedAPI) => {
+    if (
+      unchainedAPI.modules.orders.deliveries.normalizedStatus(orderDelivery) !== OrderDeliveryStatus.OPEN
+    )
+      return orderDelivery;
+
+    const order = await unchainedAPI.modules.orders.findOrder({ orderId: orderDelivery.orderId });
+    const deliveryProvider = await unchainedAPI.modules.delivery.findProvider({
+      deliveryProviderId: orderDelivery.deliveryProviderId,
+    });
+    const deliveryProviderId = deliveryProvider._id;
+    const address = orderDelivery.context?.address || order || order.billingAddress;
+    const provider = await await unchainedAPI.modules.delivery.findProvider({ deliveryProviderId });
+
+    const adapter = await DeliveryDirector.actions(
+      provider,
+      {
+        order,
+        orderDelivery,
+        transactionContext: {
+          ...(transactionContext || {}),
+          ...(orderDelivery.context || {}),
+          ...(address || {}),
+        },
+      },
+      unchainedAPI,
+    );
+
+    const arbitraryResponseData = await adapter.send();
+
+    if (arbitraryResponseData) {
+      return await unchainedAPI.modules.orders.deliveries.updateStatus(orderDelivery._id, {
+        status: OrderDeliveryStatus.DELIVERED,
+        info: JSON.stringify(arbitraryResponseData),
+      });
+    }
+
+    return orderDelivery;
+  },
+};

package/src/directors/DeliveryPricingAdapter.ts

@@ -0,0 +1,87 @@
+import { DeliveryPricingSheet } from './DeliveryPricingSheet.js';
+import {
+  BasePricingAdapterContext,
+  IPricingAdapter,
+  IPricingSheet,
+  BasePricingAdapter,
+} from '../directors/index.js';
+import { DeliveryProvider } from '@unchainedshop/core-delivery';
+import { PricingCalculation } from '@unchainedshop/utils';
+import { OrderDelivery, OrderDiscount, Order } from '@unchainedshop/core-orders';
+import { User } from '@unchainedshop/core-users';
+import { Modules } from '../modules.js';
+
+export interface DeliveryPricingCalculation extends PricingCalculation {
+  discountId?: string;
+  isNetPrice: boolean;
+  isTaxable: boolean;
+  rate?: number;
+}
+
+export type IDeliveryPricingSheet = IPricingSheet<DeliveryPricingCalculation> & {
+  addFee: (params: { amount: number; isTaxable: boolean; isNetPrice: boolean; meta?: any }) => 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;
+};
+
+export interface DeliveryPricingAdapterContext extends BasePricingAdapterContext {
+  country?: string;
+  currency?: string;
+  provider: DeliveryProvider;
+  providerContext?: any;
+  order: Order;
+  orderDelivery: OrderDelivery;
+  user: User;
+  discounts: Array<OrderDiscount>;
+}
+
+export type IDeliveryPricingAdapter<DiscountConfiguration = unknown> = IPricingAdapter<
+  DeliveryPricingAdapterContext & { modules: Modules },
+  DeliveryPricingCalculation,
+  IDeliveryPricingSheet,
+  DiscountConfiguration
+>;
+
+const basePricingAdapter = BasePricingAdapter<
+  DeliveryPricingAdapterContext,
+  DeliveryPricingCalculation
+>();
+
+export const DeliveryPricingAdapter: IDeliveryPricingAdapter = {
+  ...basePricingAdapter,
+
+  isActivatedFor: () => {
+    return false;
+  },
+
+  actions: (params) => {
+    const { context } = params;
+    const { currency } = context;
+    const baseActions = basePricingAdapter.actions(params);
+    const resultSheet = DeliveryPricingSheet({ currency });
+
+    return {
+      ...baseActions,
+      calculate: async () => {
+        const resultRaw = resultSheet.getRawPricingSheet();
+        resultRaw.forEach(({ amount, category }) =>
+          basePricingAdapter.log(`Delivery Calculation -> ${category} ${amount}`),
+        );
+        return resultRaw;
+      },
+      resultSheet: () => resultSheet,
+    };
+  },
+};