@unchainedshop/utils 3.0.0-alpha2 → 3.0.0-alpha4

package/src/calculation.test.ts

@@ -1,4 +1,11 @@
-import { applyRate, resolveRatioAndTaxDivisorForPricingSheet, roundToNext, resolveAmountAndTax, applyDiscountToMultipleShares, calculateAmountToSplit } from "./calculation";
+import {
+  applyRate,
+  resolveRatioAndTaxDivisorForPricingSheet,
+  roundToNext,
+  resolveAmountAndTax,
+  applyDiscountToMultipleShares,
+  calculateAmountToSplit,
+} from './calculation';
 
 describe('roundToNext', () => {
   it('rounds to the next multiple of precision correctly when the value is positive', () => {
@@ -20,10 +27,9 @@ describe('roundToNext', () => {
   it('returns the same value when the precision is 1', () => {
     expect(roundToNext(5, 1)).toBe(5);
   });
-
 });
 
-describe("resolveRatioAndTaxDivisorForPricingSheet", () => {
+describe('resolveRatioAndTaxDivisorForPricingSheet', () => {
   it('total is 0 and pricing is provided', () => {
     const pricing: any = {
       taxSum: () => 10,
@@ -63,11 +69,9 @@ describe("resolveRatioAndTaxDivisorForPricingSheet", () => {
     const result = resolveRatioAndTaxDivisorForPricingSheet(pricing, 20);
     expect(result).toEqual({ ratio: 1, taxDivisor: 1 });
   });
+});
 
-})
-
-
-describe("resolveAmountAndTax", () => {
+describe('resolveAmountAndTax', () => {
   it('ratio is 0 and taxDivisor is 0', () => {
     const result = resolveAmountAndTax({ ratio: 0, taxDivisor: 0 }, 100);
     expect(result).toEqual([0, 0]);
@@ -83,7 +87,6 @@ describe("resolveAmountAndTax", () => {
     expect(result).toEqual([0, 0]);
   });
 
-
   it('ratio and taxDivisor are not 0', () => {
     const result = resolveAmountAndTax({ ratio: 0.5, taxDivisor: 2 }, 100);
     expect(result).toEqual([50, 25]);
@@ -93,9 +96,9 @@ describe("resolveAmountAndTax", () => {
     const result = resolveAmountAndTax({ ratio: Number.NaN, taxDivisor: Number.NaN }, 100);
     expect(result).toEqual([0, 0]);
   });
-})
+});
 
-describe("resolveAmountAndTax", () => {
+describe('resolveAmountAndTax', () => {
   it('shares are empty', () => {
     const result = applyDiscountToMultipleShares([], 100);
     expect(result).toEqual([0, 0]);
@@ -115,12 +118,12 @@ describe("resolveAmountAndTax", () => {
     const result = applyDiscountToMultipleShares(shares, 100);
     expect(result).toEqual([70, 31.666666666666664]);
   });
-})
+});
 
 describe('applyRate', () => {
   it('applies the rate correctly when a rate is provided', () => {
     const configuration = {
-      rate: 0.1
+      rate: 0.1,
     };
     const amount = 100;
     expect(applyRate(configuration, amount)).toBe(10);
@@ -128,7 +131,7 @@ describe('applyRate', () => {
 
   it('applies the fixed rate correctly when a fixed rate is provided', () => {
     const configuration = {
-      fixedRate: 50
+      fixedRate: 50,
     };
     const amount = 100;
     expect(applyRate(configuration, amount)).toBe(50);
@@ -136,7 +139,7 @@ describe('applyRate', () => {
 
   it('applies the fixed rate correctly when a fixed rate is provided and the amount is less than fixed rate', () => {
     const configuration = {
-      fixedRate: 150
+      fixedRate: 150,
     };
     const amount = 100;
     expect(applyRate(configuration, amount)).toBe(100);
@@ -144,48 +147,43 @@ describe('applyRate', () => {
 
   it('applies the rate correctly when rate is less than or equal to 0', () => {
     const configuration = {
-      rate: -0.1
+      rate: -0.1,
     };
     const amount = 100;
     expect(applyRate(configuration, amount)).toBe(-10);
   });
   it('applies the rate correctly when only rate is provided and amount is negative', () => {
     const configuration = {
-      rate: 0.1
+      rate: 0.1,
     };
     const amount = -100;
     expect(applyRate(configuration, amount)).toBe(-10);
   });
 
-
   it('applies the rate correctly when only rate is provided and amount is negative', () => {
     const configuration = {
-      rate: 0.1
+      rate: 0.1,
     };
     const amount = -100;
     expect(applyRate(configuration, amount)).toBe(-10);
   });
 
-
   it('applies the rate correctly when only rate is provided and amount is negative', () => {
     const configuration = {
-      rate: 0.1
+      rate: 0.1,
     };
     const amount = -100;
     expect(applyRate(configuration, amount)).toBe(-10);
   });
 
-
-
   it('applies the rate correctly when only rate is provided and amount is negative', () => {
     const configuration = {
-      rate: 0.1
+      rate: 0.1,
     };
     const amount = -100;
     expect(applyRate(configuration, amount)).toBe(-10);
   });
 
-
   it('returns 0 when rate and fixed rate are not provided', () => {
     const configuration = {};
     const amount = 100;
@@ -194,7 +192,7 @@ describe('applyRate', () => {
 
   it('applies the rate correctly when only rate is provided and amount is negative', () => {
     const configuration = {
-      rate: 0.1
+      rate: 0.1,
     };
     const amount = -100;
     expect(applyRate(configuration, amount)).toBe(-10);
@@ -205,11 +203,8 @@ describe('applyRate', () => {
     const amount = 100;
     expect(applyRate(configuration, amount)).toBe(0);
   });
-
-
 });
 
-
 describe('calculateAmountToSplit', () => {
   it('calculates the correct amount to split when using a rate', () => {
     const configuration = {
@@ -235,7 +230,6 @@ describe('calculateAmountToSplit', () => {
     expect(calculateAmountToSplit(configuration, amount)).toBe(0);
   });
 
-
   it('returns 0 when amount is negative', () => {
     const configuration = {
       rate: 0.1,
@@ -251,6 +245,4 @@ describe('calculateAmountToSplit', () => {
     const amount = 1000;
     expect(calculateAmountToSplit(configuration, amount)).toBe(0);
   });
-
-
-});
+});

package/src/calculation.ts

@@ -1,4 +1,4 @@
-import { IBasePricingSheet, PricingCalculation } from '@unchainedshop/types/pricing.js';
+import { IBasePricingSheet, PricingCalculation } from './director/BasePricingSheet.js';
 
 export const roundToNext = (value: number, precision: number) =>
   Math.ceil(value / precision) * precision;

package/src/director/BaseAdapter.ts

@@ -1,6 +1,18 @@
-import { IBaseAdapter } from '@unchainedshop/types/common.js';
 import { log, LogLevel } from '@unchainedshop/logger';
 
+export interface IBaseAdapter {
+  key: string;
+  label: string;
+  version: string;
+  log: (
+    message: string,
+    options?: {
+      level?: LogLevel;
+      [x: string]: any;
+    },
+  ) => void;
+}
+
 export const BaseAdapter: Omit<IBaseAdapter, 'key' | 'label' | 'version'> = {
   log(message: string, { level = LogLevel.Debug, ...options } = {}) {
     return log(message, { level, ...options });

package/src/director/BaseDirector.ts

@@ -1,5 +1,12 @@
-import { IBaseAdapter, IBaseDirector } from '@unchainedshop/types/common.js';
 import { log } from '@unchainedshop/logger';
+import { IBaseAdapter } from './BaseAdapter.js';
+
+export interface IBaseDirector<Adapter extends IBaseAdapter> {
+  getAdapters: (options?: { adapterFilter?: (adapter: Adapter) => boolean }) => Array<Adapter>;
+  getAdapter: (key: string) => Adapter;
+  registerAdapter: (A: Adapter) => void;
+  unregisterAdapter: (key: string) => boolean;
+}
 
 export const BaseDirector = <AdapterType extends IBaseAdapter>(
   directorName: string,

package/src/director/BaseDiscountAdapter.ts

@@ -1,6 +1,37 @@
 import { log, LogLevel } from '@unchainedshop/logger';
+import { UnchainedCore } from '@unchainedshop/core';
+import { IBaseAdapter } from './BaseAdapter.js';
+import { IPricingSheet, PricingCalculation } from './BasePricingSheet.js';
 
-import { IDiscountAdapter } from '@unchainedshop/types/discount.js';
+export interface DiscountContext {
+  code?: string;
+  orderDiscount?: { _id?: string; orderId: string };
+  order?: { _id?: string; userId: string };
+}
+
+export type IDiscountAdapter<DiscountConfiguration> = IBaseAdapter & {
+  orderIndex: number;
+
+  isManualAdditionAllowed: (code: string) => Promise<boolean>;
+  isManualRemovalAllowed: () => Promise<boolean>;
+
+  actions: (params: {
+    context: DiscountContext & UnchainedCore;
+  }) => 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>, 'key' | 'label' | 'version'> = {
   orderIndex: 0,

package/src/director/BaseDiscountDirector.ts

@@ -1,6 +1,19 @@
-import { IDiscountAdapter, IDiscountDirector } from '@unchainedshop/types/discount.js';
 import { log } from '@unchainedshop/logger';
-import { BaseDirector } from './BaseDirector.js';
+import { BaseDirector, IBaseDirector } from './BaseDirector.js';
+import { DiscountContext, IDiscountAdapter } from './BaseDiscountAdapter.js';
+import { UnchainedCore } from '@unchainedshop/core';
+
+export type IDiscountDirector<DiscountConfiguration> = IBaseDirector<
+  IDiscountAdapter<DiscountConfiguration>
+> & {
+  actions: (
+    discountContext: DiscountContext,
+    unchainedAPI: UnchainedCore,
+  ) => Promise<{
+    resolveDiscountKeyFromStaticCode: (params: { code: string }) => Promise<string | null>;
+    findSystemDiscounts: () => Promise<Array<string>>;
+  }>;
+};
 
 export const BaseDiscountDirector = <DiscountConfigurationType>(
   directorName: string,

package/src/director/BasePricingAdapter.ts

@@ -1,16 +1,64 @@
-import {
-  BasePricingAdapterContext,
-  IPricingSheet,
-  IPricingAdapter,
-  PricingCalculation,
-  IPricingAdapterActions,
-} from '@unchainedshop/types/pricing.js';
+import { UnchainedCore } from '@unchainedshop/core';
+import { User } from '@unchainedshop/core-users';
 import { log, LogLevel } from '@unchainedshop/logger';
+import { IPricingSheet, PricingCalculation } from './BasePricingSheet.js';
+import { IBaseAdapter } from './BaseAdapter.js';
+import { Discount } from './BasePricingDirector.js';
+
+type Order = { _id?: string };
+type OrderDiscount = { _id?: string };
+
+interface IDiscountableItem {
+  _id?: string;
+  orderId?: string;
+}
+
+export interface BasePricingAdapterContext extends UnchainedCore {
+  order?: Order;
+  user: User;
+  discounts: Array<OrderDiscount>;
+}
+
+export type BasePricingContext =
+  | {
+      order?: Order;
+      user?: User;
+      discounts?: Array<OrderDiscount>;
+    }
+  | {
+      item: IDiscountableItem;
+    };
+
+export interface IPricingAdapterActions<
+  Calculation extends PricingCalculation,
+  PricingAdapterContext extends BasePricingAdapterContext,
+> {
+  calculate: () => Promise<Array<Calculation>>;
+  getCalculation: () => Array<Calculation>;
+  getContext: () => PricingAdapterContext;
+}
+
+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, PricingAdapterContext> & { resultSheet: () => Sheet };
+};
 
 export const BasePricingAdapter = <
-  Context extends BasePricingAdapterContext,
+  PricingAdapterContext extends BasePricingAdapterContext,
   Calculation extends PricingCalculation,
->(): IPricingAdapter<Context, Calculation, IPricingSheet<Calculation>> => ({
+>(): IPricingAdapter<PricingAdapterContext, Calculation, IPricingSheet<Calculation>> => ({
   key: '',
   label: '',
   version: '',
@@ -22,7 +70,7 @@ export const BasePricingAdapter = <
 
   actions: (params) => {
     const calculation = [];
-    const actions: IPricingAdapterActions<Calculation, Context> = {
+    const actions: IPricingAdapterActions<Calculation, PricingAdapterContext> = {
       calculate: async () => {
         return [];
       },
@@ -30,7 +78,7 @@ export const BasePricingAdapter = <
       getContext: () => params.context,
     };
 
-    return actions as IPricingAdapterActions<Calculation, Context> & {
+    return actions as IPricingAdapterActions<Calculation, PricingAdapterContext> & {
       resultSheet: () => IPricingSheet<Calculation>;
     };
   },

package/src/director/BasePricingDirector.ts

@@ -1,15 +1,42 @@
-import { Discount } from '@unchainedshop/types/discount.js';
+import { log, LogLevel } from '@unchainedshop/logger';
+import { BaseDirector, IBaseDirector } from './BaseDirector.js';
+import { UnchainedCore } from '@unchainedshop/core';
 import {
   BasePricingAdapterContext,
   BasePricingContext,
-  IPricingDirector,
   IPricingAdapter,
-  IPricingSheet,
-  PricingCalculation,
   IPricingAdapterActions,
-} from '@unchainedshop/types/pricing.js';
-import { log, LogLevel } from '@unchainedshop/logger';
-import { BaseDirector } from './BaseDirector.js';
+} from './BasePricingAdapter.js';
+import { IPricingSheet, PricingCalculation } from './BasePricingSheet.js';
+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, Calculation, PricingAdapterSheet>,
+> = IBaseDirector<Adapter> & {
+  buildPricingContext: (
+    context: PricingContext,
+    unchainedAPI: UnchainedCore,
+  ) => Promise<PricingAdapterContext>;
+  actions: (
+    pricingContext: PricingContext,
+    unchainedAPI: UnchainedCore,
+    buildPricingContext?: (
+      pricingCtx: PricingContext,
+      _unchainedAPI: UnchainedCore,
+    ) => Promise<PricingAdapterContext>,
+  ) => Promise<
+    IPricingAdapterActions<Calculation, PricingAdapterContext> & {
+      calculationSheet: () => PricingAdapterSheet;
+    }
+  >;
+};
 
 export const BasePricingDirector = <
   DirectorContext extends BasePricingContext,
@@ -61,10 +88,10 @@ export const BasePricingDirector = <
               context.discounts.map(async (discount) => ({
                 discountId: discount._id,
                 configuration: await context.modules.orders.discounts.configurationForPricingAdapterKey(
-                  discount,
+                  discount as any,
                   Adapter.key,
                   this.calculationSheet(),
-                  context,
+                  context as any,
                 ),
               })),
             );

package/src/director/BasePricingSheet.ts

@@ -1,8 +1,48 @@
-import {
-  PricingCalculation,
-  IBasePricingSheet,
-  PricingSheetParams,
-} from '@unchainedshop/types/pricing.js';
+export interface PricingCalculation {
+  category: string;
+  amount: number;
+  baseCategory?: string;
+  meta?: any;
+}
+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>,

package/src/director/base-director.test.ts

@@ -1,4 +1,4 @@
-import { BaseDirector } from "./BaseDirector.js";
+import { BaseDirector } from './BaseDirector.js';
 
 const adapter1 = {
   key: 'adapter1',
@@ -31,99 +31,88 @@ describe('BaseDirector', () => {
     director.registerAdapter(adapter2);
   });
 
-  describe('registerAdapter',  ()=> {
-
+  describe('registerAdapter', () => {
     it('should add the adapter to the director', () => {
       director.registerAdapter(adapter1);
       expect(director.getAdapter(adapter1.key)).toBe(adapter1);
     });
-  
+
     xit('should generate a log message when an adapter is registered', () => {
-      const spy = import.meta.jest.spyOn(console, 'log')
-       expect(spy).toHaveBeenCalledWith(
-        'TestDirector -> Registered  adapter1 1.0.0 (Adapter 1)',
-      ); 
+      const spy = import.meta.jest.spyOn(console, 'log');
+      expect(spy).toHaveBeenCalledWith('TestDirector -> Registered  adapter1 1.0.0 (Adapter 1)');
     });
-  
+
     it('should allow multiple adapters to be registered', () => {
       expect(director.getAdapter(adapter1.key)).toBe(adapter1);
       expect(director.getAdapter(adapter2.key)).toBe(adapter2);
     });
-  
+
     it('should register an adapter and add it to the internal map', () => {
       expect(director.getAdapter(adapter1.key)).toEqual(adapter1);
     });
-  
+
     it('should use the adapterKeyField specified in the options to store the adapter in the internal map', () => {
-  
       director = BaseDirector('TestDirector', {
         adapterKeyField: 'label',
       });
       director.registerAdapter(adapter1);
       expect(director.getAdapter(adapter1.label)).toEqual(adapter1);
     });
-  
-      it('should return the correct Adapter object', () => {
-        const directorName = 'TestDirector';
-        const adapterKeyField = 'key';
-        director = BaseDirector(directorName, { adapterKeyField });
-        director.registerAdapter(adapter1);
-        
-        expect(director.getAdapter(adapter1.key)).toEqual(adapter1);
-      });
-  
-      it('should return undefined if the Adapter does not exist', () => {
-        const directorName = 'TestDirector';
-        const adapterKeyField = 'key';
-        director = BaseDirector(directorName, { adapterKeyField });
-        expect(director.getAdapter(adapter1.key)).toBeUndefined();
-      });
-  
-  })
 
+    it('should return the correct Adapter object', () => {
+      const directorName = 'TestDirector';
+      const adapterKeyField = 'key';
+      director = BaseDirector(directorName, { adapterKeyField });
+      director.registerAdapter(adapter1);
 
-describe('getAdapter', () => {
-  it('should return the correct Adapter object for a given key', () => {
-    // Expect that calling getAdapter with the key 'foo' returns the fooAdapter
-    expect(director.getAdapter(adapter1.key)).toBe(adapter1);
-  });
-
-  it('should return undefined if no Adapter is registered with the given key', () => {
-    // Expect that calling getAdapter with a key that has not been registered returns undefined
-    expect(director.getAdapter('invalid-key')).toBeUndefined();
-  });
+      expect(director.getAdapter(adapter1.key)).toEqual(adapter1);
+    });
 
-  it('should return the correct Adapter object when the keyField is set to a property other than "key"', () => {
-    // Create a director with the keyField option set to 'label'
-    director = BaseDirector('TestDirector', { adapterKeyField: 'label' });
-    director.registerAdapter(adapter1);
-    expect(director.getAdapter(adapter1.label)).toBe(adapter1);
+    it('should return undefined if the Adapter does not exist', () => {
+      const directorName = 'TestDirector';
+      const adapterKeyField = 'key';
+      director = BaseDirector(directorName, { adapterKeyField });
+      expect(director.getAdapter(adapter1.key)).toBeUndefined();
+    });
   });
-});
 
-describe('getAdapters', () => {
-  it('should return an array of registered Adapter objects', () => {
-    expect(director.getAdapters()).toEqual([adapter1, adapter3, adapter2]);
-  });
+  describe('getAdapter', () => {
+    it('should return the correct Adapter object for a given key', () => {
+      // Expect that calling getAdapter with the key 'foo' returns the fooAdapter
+      expect(director.getAdapter(adapter1.key)).toBe(adapter1);
+    });
 
-  it('should return an empty array if no Adapter objects have been registered', () => {
-    const directorName = 'TestDirector';
-    const adapterKeyField = 'key';
-    const baseDirector = BaseDirector(directorName, { adapterKeyField });
-    expect(baseDirector.getAdapters()).toEqual([]);
-  });
+    it('should return undefined if no Adapter is registered with the given key', () => {
+      // Expect that calling getAdapter with a key that has not been registered returns undefined
+      expect(director.getAdapter('invalid-key')).toBeUndefined();
+    });
 
-  it('should return an array of registered Adapter objects sorted by the adapterSortKey provided', () => {
-    director = BaseDirector('TestDirector', { adapterSortKey: 'version' });
-    director.registerAdapter(adapter1);
-    director.registerAdapter(adapter3);
-    director.registerAdapter(adapter2);
-    expect(director.getAdapters()).toEqual([adapter1, adapter2, adapter3]);
+    it('should return the correct Adapter object when the keyField is set to a property other than "key"', () => {
+      // Create a director with the keyField option set to 'label'
+      director = BaseDirector('TestDirector', { adapterKeyField: 'label' });
+      director.registerAdapter(adapter1);
+      expect(director.getAdapter(adapter1.label)).toBe(adapter1);
+    });
   });
 
-})
-  
-
-})
+  describe('getAdapters', () => {
+    it('should return an array of registered Adapter objects', () => {
+      expect(director.getAdapters()).toEqual([adapter1, adapter3, adapter2]);
+    });
 
+    it('should return an empty array if no Adapter objects have been registered', () => {
+      const directorName = 'TestDirector';
+      const adapterKeyField = 'key';
+      const baseDirector = BaseDirector(directorName, { adapterKeyField });
+      expect(baseDirector.getAdapters()).toEqual([]);
+    });
 
+    it('should return an array of registered Adapter objects sorted by the adapterSortKey provided', () => {
+      director = BaseDirector('TestDirector', { adapterSortKey: 'version' });
+      director.registerAdapter(adapter1);
+      director.registerAdapter(adapter3);
+      director.registerAdapter(adapter2);
+      expect(director.getAdapters()).toEqual([adapter1, adapter2, adapter3]);
+    });
+  });
+});