@unchainedshop/utils 3.0.0-alpha7 → 3.0.0-rc10

package/src/director/BasePricingAdapter.ts

@@ -1,89 +0,0 @@
-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 = <
-  PricingAdapterContext extends BasePricingAdapterContext,
-  Calculation extends PricingCalculation,
->(): IPricingAdapter<PricingAdapterContext, Calculation, IPricingSheet<Calculation>> => ({
-  key: '',
-  label: '',
-  version: '',
-  orderIndex: 0,
-
-  isActivatedFor: () => {
-    return false;
-  },
-
-  actions: (params) => {
-    const calculation = [];
-    const actions: IPricingAdapterActions<Calculation, PricingAdapterContext> = {
-      calculate: async () => {
-        return [];
-      },
-      getCalculation: () => calculation,
-      getContext: () => params.context,
-    };
-
-    return actions as IPricingAdapterActions<Calculation, PricingAdapterContext> & {
-      resultSheet: () => IPricingSheet<Calculation>;
-    };
-  },
-
-  log(message: string, { level = LogLevel.Debug, ...options } = {}) {
-    return log(message, { level, ...options });
-  },
-});

package/src/director/BasePricingDirector.ts

@@ -1,133 +0,0 @@
-import { log, LogLevel } from '@unchainedshop/logger';
-import { BaseDirector, IBaseDirector } from './BaseDirector.js';
-import { UnchainedCore } from '@unchainedshop/core';
-import {
-  BasePricingAdapterContext,
-  BasePricingContext,
-  IPricingAdapter,
-  IPricingAdapterActions,
-} 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,
-  AdapterContext extends BasePricingAdapterContext,
-  Calculation extends PricingCalculation,
-  PricingAdapter extends IPricingAdapter<AdapterContext, Calculation, IPricingSheet<Calculation>>,
->(
-  directorName: string,
-): IPricingDirector<
-  DirectorContext,
-  Calculation,
-  AdapterContext,
-  IPricingSheet<Calculation>,
-  PricingAdapter
-> => {
-  const baseDirector = BaseDirector<PricingAdapter>(directorName, {
-    adapterSortKey: 'orderIndex',
-  });
-
-  const director: IPricingDirector<
-    DirectorContext,
-    Calculation,
-    AdapterContext,
-    IPricingSheet<Calculation>,
-    PricingAdapter
-  > = {
-    ...baseDirector,
-    buildPricingContext: async () => {
-      return {} as AdapterContext;
-    },
-    actions: async (pricingContext, unchainedAPI, buildPricingContext) => {
-      const context = await buildPricingContext(pricingContext, unchainedAPI);
-
-      let calculation: Array<Calculation> = [];
-
-      const actions: IPricingAdapterActions<Calculation, AdapterContext> = {
-        async calculate() {
-          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 (discount) => ({
-                discountId: discount._id,
-                configuration: await context.modules.orders.discounts.configurationForPricingAdapterKey(
-                  discount as any,
-                  Adapter.key,
-                  this.calculationSheet(),
-                  context as any,
-                ),
-              })),
-            );
-
-            try {
-              const adapter = Adapter.actions({
-                context,
-                calculationSheet: this.calculationSheet(),
-                discounts: discounts.filter(({ configuration }) => configuration !== null),
-              });
-
-              const nextCalculationResult = await adapter.calculate();
-              if (!nextCalculationResult) return null;
-              calculation = resolvedCalculation.concat(nextCalculationResult);
-              return calculation;
-            } catch (error) {
-              log(error, { level: LogLevel.Error });
-            }
-            return resolvedCalculation;
-          }, Promise.resolve([]));
-
-          return calculation;
-        },
-        getCalculation() {
-          return calculation;
-        },
-        getContext() {
-          return context;
-        },
-      };
-
-      return actions as IPricingAdapterActions<Calculation, AdapterContext> & {
-        calculationSheet: () => IPricingSheet<Calculation>;
-      };
-    },
-  };
-
-  return director;
-};

package/src/director/BasePricingSheet.ts

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

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

@@ -1,49 +0,0 @@
-import { BaseDiscountAdapter } from './BaseDiscountAdapter.js';
-
-describe('BaseDiscountAdapter instantiation', () => {
-  const adapter = BaseDiscountAdapter;
-  const context = null as any;
-  it('should initialize with default values', async () => {
-    expect(adapter.orderIndex).toEqual(0);
-    expect(adapter.log).toEqual(expect.any(Function));
-    expect(await adapter.isManualAdditionAllowed('')).toEqual(false);
-    expect(await adapter.isManualRemovalAllowed()).toEqual(false);
-    expect(await adapter.actions(context)).toEqual({
-      isValidForSystemTriggering: expect.any(Function),
-      reserve: expect.any(Function),
-      release: expect.any(Function),
-      isValidForCodeTriggering: expect.any(Function),
-      discountForPricingAdapterKey: expect.any(Function),
-    });
-  });
-
-  describe('actions', () => {
-    it('isValidForSystemTriggering', async () => {
-      const result = await adapter.actions(context);
-      expect(await result.isValidForSystemTriggering()).toEqual(false);
-    });
-
-    it('reserve', async () => {
-      const result = await adapter.actions(context);
-      expect(await result.reserve({ code: '' })).toEqual({});
-    });
-
-    it('release', async () => {
-      const result = await adapter.actions(context);
-      expect(await result.release()).toEqual(null);
-    });
-
-    it('isValidForCodeTriggering', async () => {
-      const result = await adapter.actions(context);
-      expect(await result.isValidForCodeTriggering({ code: '' })).toEqual(false);
-    });
-
-    it('discountForPricingAdapterKey', async () => {
-      const result = await adapter.actions(context);
-      const calculationSheet = {};
-      expect(
-        await result.discountForPricingAdapterKey({ calculationSheet, pricingAdapterKey: 'key' } as any),
-      ).toEqual(null);
-    });
-  });
-});

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

@@ -1,100 +0,0 @@
-import { BasePricingSheet } from './BasePricingSheet.js';
-
-describe('BasePricingSheet', () => {
-  let pricingSheet;
-  const TAX = { category: 'tax', amount: 100 };
-  const DISCOUNT = { category: 'discount', amount: 50 };
-  const ITEM1 = { category: 'item', amount: 200 };
-  const ITEM2 = { category: 'item', amount: 200 };
-  const calculations = [TAX, DISCOUNT, ITEM1, ITEM2];
-
-  beforeEach(() => {
-    pricingSheet = BasePricingSheet({
-      calculation: calculations,
-    });
-  });
-
-  it('gross() calculates the sum of the amounts in the calculations', () => {
-    expect(pricingSheet.gross()).toEqual(550);
-  });
-
-  it('gross() returns 0 if the calculation is empty', () => {
-    expect(BasePricingSheet({ calculation: [] }).gross()).toEqual(0);
-  });
-
-  it('total() calculates the sum of the amounts in the calculations by default', () => {
-    expect(pricingSheet.total()).toEqual({ amount: 550, currency: undefined });
-  });
-
-  it('total() calculates the sum of the amounts in the calculations for a given category', () => {
-    expect(pricingSheet.total({ category: 'item' })).toEqual({ amount: 400, currency: undefined });
-  });
-
-  it('total() calculates the net sum of the amounts in the calculations if useNetPrice is true', () => {
-    expect(pricingSheet.total({ useNetPrice: true })).toEqual({ amount: 550, currency: undefined });
-  });
-
-  it('total() returns 0 if the calculation is empty', () => {
-    expect(BasePricingSheet({ calculation: [] }).total()).toEqual({ amount: 0, currency: undefined });
-  });
-
-  it('calculates the correct net amount', () => {
-    expect(pricingSheet.net()).toEqual(550);
-  });
-
-  it('calculates the correct sum for a given category', () => {
-    expect(pricingSheet.sum({ category: 'item' })).toEqual(400);
-  });
-
-  it('calculates the correct tax amount', () => {
-    expect(pricingSheet.taxSum()).toEqual(0);
-  });
-
-  describe('getRawPricingSheet', () => {
-    it('returns the correct list of calculations', () => {
-      expect(pricingSheet.getRawPricingSheet()).toEqual(calculations);
-    });
-
-    it('returns an empty list of calculations if none are provided', () => {
-      expect(BasePricingSheet({}).getRawPricingSheet()).toEqual([]);
-    });
-  });
-
-  describe('isValid', () => {
-    it('returns true if the sheet has calculations', () => {
-      expect(pricingSheet.isValid()).toEqual(true);
-    });
-
-    it('returns false if the sheet does not have calculations', () => {
-      expect(BasePricingSheet({}).isValid()).toEqual(false);
-    });
-  });
-
-  describe('filterBy', () => {
-    it('filters the list of calculations correctly', () => {
-      expect(pricingSheet.filterBy({ category: 'item' })).toEqual([ITEM1, ITEM2]);
-    });
-
-    it('returns the full list of calculations if no filter is provided', () => {
-      expect(pricingSheet.filterBy()).toEqual(calculations);
-    });
-  });
-
-  describe('resetCalculation', () => {
-    it('resets the list of calculations correctly', () => {
-      const expectedCalculations = calculations.reduce(
-        (prev, { amount, ...row }) => {
-          return [
-            ...prev,
-            {
-              ...row,
-              amount: -amount,
-            },
-          ];
-        },
-        [...calculations],
-      );
-      expect(pricingSheet.resetCalculation(pricingSheet)).toEqual(expectedCalculations);
-    });
-  });
-});

package/src/random-value-hex.ts

@@ -1,8 +0,0 @@
-import crypto from 'crypto';
-
-export default function randomValueHex(len: number): string {
-  return crypto
-    .randomBytes(Math.ceil(len / 2))
-    .toString('hex') // convert to hexadecimal format
-    .slice(0, len); // return required number of characters
-}