@unchainedshop/core 3.0.0-alpha7 → 3.0.0-rc2

package/src/directors/BaseDiscountAdapter.ts

@@ -0,0 +1,91 @@
+import { log, LogLevel } from '@unchainedshop/logger';
+import { IBaseAdapter } from '@unchainedshop/utils';
+import { IPricingSheet } from './BasePricingSheet.js';
+import { PricingCalculation } from '@unchainedshop/utils';
+export interface DiscountContext {
+  code?: string;
+  orderDiscount?: { _id?: string; orderId: string };
+  order?: { _id?: string; userId: string };
+}
+
+export type IDiscountAdapter<DiscountConfiguration, Context> = IBaseAdapter & {
+  orderIndex: number;
+
+  isManualAdditionAllowed: (code: string) => Promise<boolean>;
+  isManualRemovalAllowed: () => Promise<boolean>;
+
+  actions: (params: {
+    context: DiscountContext & Context;
+  }) => Promise<DiscountAdapterActions<DiscountConfiguration>>;
+};
+
+export interface DiscountAdapterActions<DiscountConfiguration> {
+  isValidForSystemTriggering: () => Promise<boolean>;
+  isValidForCodeTriggering: (params: { code: string }) => Promise<boolean>;
+
+  discountForPricingAdapterKey: (params: {
+    pricingAdapterKey: string;
+    calculationSheet: IPricingSheet<PricingCalculation>;
+  }) => DiscountConfiguration;
+
+  reserve: (params: { code: string }) => Promise<any>;
+  release: () => Promise<void>;
+}
+
+export const BaseDiscountAdapter: Omit<
+  IDiscountAdapter<unknown, unknown>,
+  'key' | 'label' | 'version'
+> = {
+  orderIndex: 0,
+
+  isManualAdditionAllowed: async () => {
+    return false;
+  },
+
+  // return true if a discount is allowed to get removed manually by a user
+  isManualRemovalAllowed: async () => {
+    return false;
+  },
+
+  actions: async () => ({
+    // return true if a discount is valid to be part of the order
+    // without input of a user. that could be a time based global discount
+    // like a 10% discount day
+    // if you return false, this discount will
+    // get removed from the order before any price calculation
+    // takes place.
+    // eslint-disable-next-line
+    isValidForSystemTriggering: async () => {
+      return false;
+    },
+
+    // return an arbitrary JSON serializable object with reservation data
+    // this method is called when a discount is added through a manual code and let's
+    // you manually deduct expendable discounts (coupon balances for ex.) before checkout
+    reserve: async () => {
+      return {};
+    },
+
+    // return void, allows you to free up any reservations in backend systems
+    release: async () => {
+      return null;
+    },
+
+    // return true if a discount is valid to be part of the order.
+    // if you return false, this discount will
+    // get removed from the order before any price calculation
+    // takes place.
+    isValidForCodeTriggering: async () => {
+      return false;
+    },
+
+    // returns the appropriate discount context for a calculation adapter
+    discountForPricingAdapterKey() {
+      return null;
+    },
+  }),
+
+  log(message: string, { level = LogLevel.Debug, ...options } = {}) {
+    return log(message, { level, ...options });
+  },
+};

package/src/directors/BaseDiscountDirector.ts

@@ -0,0 +1,72 @@
+import { BaseDirector, IBaseDirector } from '@unchainedshop/utils';
+import { DiscountContext, IDiscountAdapter } from './BaseDiscountAdapter.js';
+
+export type IDiscountDirector<DiscountConfiguration, Context> = IBaseDirector<
+  IDiscountAdapter<DiscountConfiguration, Context>
+> & {
+  actions: (
+    discountContext: DiscountContext,
+    unchainedAPI: Context,
+  ) => Promise<{
+    resolveDiscountAdapterFromStaticCode: (params: {
+      code: string;
+    }) => Promise<IDiscountAdapter<DiscountConfiguration, Context>>;
+    findSystemDiscounts: () => Promise<Array<string>>;
+  }>;
+};
+
+export const BaseDiscountDirector = <DiscountConfigurationType, Context>(
+  directorName: string,
+): IDiscountDirector<DiscountConfigurationType, Context> => {
+  const baseDirector = BaseDirector<IDiscountAdapter<DiscountConfigurationType, Context>>(directorName, {
+    adapterSortKey: 'orderIndex',
+  });
+
+  return {
+    ...baseDirector,
+
+    actions: async (discountContext, unchainedAPI) => {
+      const context = { ...discountContext, ...unchainedAPI };
+
+      return {
+        resolveDiscountAdapterFromStaticCode: async (options) => {
+          if (!context.order) return null;
+
+          const discounts = await Promise.all(
+            baseDirector
+              .getAdapters()
+              .filter((Adapter) => Adapter.isManualAdditionAllowed(options?.code))
+              .map(async (Adapter) => {
+                const adapter = await Adapter.actions({ context });
+                return {
+                  Adapter,
+                  isValid: await adapter.isValidForCodeTriggering(options),
+                };
+              }),
+          );
+
+          return discounts.find(({ isValid }) => isValid === true)?.Adapter;
+        },
+
+        async findSystemDiscounts() {
+          if (!context.order) return [];
+          const discounts = await Promise.all(
+            baseDirector.getAdapters().map(async (Adapter) => {
+              const adapter = await Adapter.actions({ context });
+              return {
+                key: Adapter.key,
+                isValid: await adapter.isValidForSystemTriggering(),
+              };
+            }),
+          );
+
+          const validDiscounts = discounts
+            .filter(({ isValid }) => isValid === true)
+            .map(({ key }) => key);
+
+          return validDiscounts;
+        },
+      };
+    },
+  };
+};

package/src/directors/BasePricingAdapter.ts

@@ -0,0 +1,82 @@
+import { createLogger } from '@unchainedshop/logger';
+import { IPricingSheet } from './BasePricingSheet.js';
+import { IBaseAdapter, PricingCalculation } from '@unchainedshop/utils';
+import { Discount } from './BasePricingDirector.js';
+
+const logger = createLogger('unchained:core');
+
+type Order = { _id?: string };
+type OrderDiscount = { _id?: string };
+
+interface IDiscountableItem {
+  _id?: string;
+  orderId?: string;
+}
+
+export interface BasePricingAdapterContext {
+  order?: Order;
+  discounts: Array<OrderDiscount>;
+}
+
+export type BasePricingContext =
+  | {
+      order?: Order;
+      discounts?: Array<OrderDiscount>;
+    }
+  | {
+      item: IDiscountableItem;
+    };
+
+export interface IPricingAdapterActions<
+  Calculation extends PricingCalculation,
+  Sheet extends IPricingSheet<Calculation>,
+> {
+  calculate: () => Promise<Array<Calculation>>;
+  resultSheet: () => Sheet;
+}
+
+export type IPricingAdapter<
+  PricingAdapterContext extends BasePricingAdapterContext,
+  Calculation extends PricingCalculation,
+  Sheet extends IPricingSheet<Calculation>,
+  DiscountConfiguration = unknown,
+> = IBaseAdapter & {
+  orderIndex: number;
+
+  isActivatedFor: (context: PricingAdapterContext) => boolean;
+
+  actions: (params: {
+    context: PricingAdapterContext;
+    calculationSheet: Sheet;
+    discounts: Array<Discount<DiscountConfiguration>>;
+  }) => IPricingAdapterActions<Calculation, Sheet>;
+};
+
+export const BasePricingAdapter = <
+  PricingAdapterContext extends BasePricingAdapterContext,
+  Calculation extends PricingCalculation,
+>(): IPricingAdapter<PricingAdapterContext, Calculation, IPricingSheet<Calculation>> => ({
+  key: '',
+  label: '',
+  version: '',
+  orderIndex: 0,
+
+  isActivatedFor: () => {
+    return false;
+  },
+
+  actions: () => {
+    return {
+      calculate: async () => {
+        throw new Error('Method not implemented.');
+      },
+      resultSheet: () => {
+        throw new Error('Method not implemented.');
+      }, // abstract
+    };
+  },
+
+  log(message: string, options) {
+    return logger.debug(message, options);
+  },
+});

package/src/directors/BasePricingDirector.ts

@@ -0,0 +1,136 @@
+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 this.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(({ configuration }) => 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 });
+  },
+};