@unchainedshop/core 4.3.6 → 4.4.0

package/src/directors/BaseDiscountDirector.ts

@@ -1,73 +0,0 @@
-import { BaseDirector, IBaseDirector } from '@unchainedshop/utils';
-import { DiscountContext, IDiscountAdapter } from './BaseDiscountAdapter.js';
-import { Modules } from '../modules.js';
-
-export type IDiscountDirector<DiscountConfiguration> = IBaseDirector<
-  IDiscountAdapter<DiscountConfiguration>
-> & {
-  actions: (
-    discountContext: DiscountContext,
-    unchainedAPI: { modules: Modules },
-  ) => Promise<{
-    resolveDiscountAdapterFromStaticCode: (params: {
-      code: string;
-    }) => Promise<IDiscountAdapter<DiscountConfiguration> | null>;
-    findSystemDiscounts: () => Promise<string[]>;
-  }>;
-};
-
-export const BaseDiscountDirector = <DiscountConfigurationType>(
-  directorName: string,
-): IDiscountDirector<DiscountConfigurationType> => {
-  const baseDirector = BaseDirector<IDiscountAdapter<DiscountConfigurationType>>(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 || null;
-        },
-
-        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

@@ -1,74 +0,0 @@
-import { IPricingSheet } from './BasePricingSheet.js';
-import { BaseAdapter, IBaseAdapter, PricingCalculation } from '@unchainedshop/utils';
-import { Discount } from './BasePricingDirector.js';
-import { Order, OrderDiscount } from '@unchainedshop/core-orders';
-
-interface IDiscountableItem {
-  _id: string;
-  orderId?: string;
-}
-
-export interface BasePricingAdapterContext {
-  order?: Order;
-  discounts: OrderDiscount[];
-}
-
-export type BasePricingContext =
-  | {
-      order?: Order;
-      discounts?: OrderDiscount[];
-    }
-  | {
-      item: IDiscountableItem;
-    };
-
-export interface IPricingAdapterActions<
-  Calculation extends PricingCalculation,
-  Sheet extends IPricingSheet<Calculation>,
-> {
-  calculate: () => Promise<Calculation[] | null>;
-  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: Discount<DiscountConfiguration>[];
-  }) => IPricingAdapterActions<Calculation, Sheet>;
-};
-
-export const BasePricingAdapter = <
-  PricingAdapterContext extends BasePricingAdapterContext,
-  Calculation extends PricingCalculation,
->(): IPricingAdapter<PricingAdapterContext, Calculation, IPricingSheet<Calculation>> => ({
-  ...BaseAdapter,
-  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
-    };
-  },
-});

package/src/directors/BasePricingDirector.ts

@@ -1,136 +0,0 @@
-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<Calculation[]>;
-
-  calculationSheet: (pricingContext: PricingContext, calculation: 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
-> => {
-  const baseDirector = BaseDirector<PricingAdapter>(directorName, {
-    adapterSortKey: 'orderIndex',
-  });
-
-  const director: IPricingDirector<
-    DirectorContext,
-    Calculation,
-    AdapterContext,
-    IPricingSheet<Calculation>,
-    PricingAdapter
-  > = {
-    ...baseDirector,
-
-    buildPricingContext: async () => {
-      throw new Error('Method not implemented');
-    },
-
-    calculationSheet() {
-      throw new Error('Method not implemented');
-    },
-
-    async rebuildCalculation(this: typeof director, pricingContext, unchainedAPI) {
-      const context = await this.buildPricingContext(pricingContext, unchainedAPI);
-
-      let calculation: Calculation[] | null = [];
-
-      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: (Discount<any> | null)[] = await Promise.all(
-            context.discounts.map(async (orderDiscount) => {
-              // TODO: We shouldn't need to fetch this here, most probably we already have an order in context
-              // 1. it should propably be required to pass an order
-              // 2. we should pass the order in the pricing context or pricing adapter context
-              // 3. it can't be different orders for different discounts in the same calculation rebuild
-              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: order!, orderDiscount, code: orderDiscount.code, ...unchainedAPI },
-              });
-
-              const configuration = adapter.discountForPricingAdapterKey({
-                pricingAdapterKey: Adapter.key,
-                calculationSheet: this.calculationSheet(pricingContext, resolvedCalculation),
-              });
-
-              return {
-                discountId: orderDiscount._id,
-                configuration,
-              };
-            }),
-          );
-
-          try {
-            const adapter = Adapter.actions({
-              context,
-              calculationSheet: this.calculationSheet(pricingContext, resolvedCalculation),
-              discounts: discounts.filter((d) => d?.configuration !== null) as Discount<any>[],
-            });
-
-            const nextCalculationResult = await adapter.calculate();
-            if (!nextCalculationResult) return null;
-            calculation = resolvedCalculation.concat(nextCalculationResult);
-            return calculation;
-          } catch (error) {
-            logger.error(error);
-          }
-          return resolvedCalculation;
-        },
-        Promise.resolve([] as Calculation[]),
-      );
-
-      return calculation || ([] as Calculation[]);
-    },
-  };
-
-  return director;
-};

package/src/directors/BasePricingSheet.test.ts

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

package/src/directors/BasePricingSheet.ts

@@ -1,141 +0,0 @@
-import { PricingCalculation } from '@unchainedshop/utils';
-export interface PricingDiscount {
-  discountId: string;
-  amount: number;
-  currencyCode: string;
-}
-
-export interface IPricingSheet<
-  Calculation extends PricingCalculation,
-> extends IBasePricingSheet<Calculation> {
-  discountPrices: (discountId?: string) => PricingDiscount[];
-  addDiscount: (params: { amount: number; discountId: string; meta?: any }) => void;
-}
-
-export interface IBasePricingSheet<Calculation extends PricingCalculation> {
-  calculation: Calculation[];
-  currencyCode?: string;
-  quantity?: number;
-
-  getRawPricingSheet: () => Calculation[];
-  filterBy: (filter?: Partial<Calculation>) => Calculation[];
-  isValid: () => boolean;
-
-  gross: () => number;
-  net: () => number;
-  sum: (filter?: Partial<Calculation>) => number;
-  total: (params?: { category?: string; discountId?: string; useNetPrice?: boolean }) => {
-    amount: number;
-    currencyCode: string;
-  };
-
-  taxSum: (filter?: Partial<Calculation>) => number;
-
-  resetCalculation: (sheetToInvert: IBasePricingSheet<Calculation>) => Calculation[];
-}
-
-export interface PricingSheetParams<Calculation extends PricingCalculation> {
-  calculation?: Calculation[];
-  currencyCode?: string;
-  quantity?: number;
-}
-
-export const BasePricingSheet = <Calculation extends PricingCalculation>(
-  params: PricingSheetParams<Calculation>,
-): IBasePricingSheet<Calculation> => {
-  const pricingSheet: IBasePricingSheet<Calculation> = {
-    calculation: params.calculation || [],
-    currencyCode: params.currencyCode,
-    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),
-        currencyCode: this.currencyCode,
-      };
-    },
-
-    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/BaseWorker.ts

@@ -1,117 +0,0 @@
-import later from '@breejs/later';
-import { Work, WorkData } from '@unchainedshop/core-worker';
-import { WorkerDirector } from './WorkerDirector.js';
-
-export interface IWorker<P extends { workerId?: string }> {
-  key: string;
-  label: string;
-  version: string;
-  type: string;
-  external: boolean;
-
-  getFloorDate: (date?: Date) => Date;
-
-  actions: (
-    params: P,
-    unchainedAPI,
-  ) => {
-    autorescheduleTypes: (options: { referenceDate: Date }) => Promise<(Work | null)[]>;
-    process: (options: { maxWorkItemCount?: number; referenceDate?: Date }) => Promise<void>;
-    reset: () => Promise<void> | void;
-    start: () => Promise<void> | void;
-    stop: () => Promise<void> | void;
-  };
-}
-
-interface WorkerParams {
-  workerId?: string;
-  worker: IWorker<any>;
-}
-
-export const BaseWorker: IWorker<WorkerParams> = {
-  key: 'shop.unchained.worker.base',
-  label: 'Base worker. Do not use this directly.',
-  version: '1.0.0',
-  type: 'BASE',
-  external: false,
-
-  getFloorDate: (date = new Date()) => {
-    const floored = new Date(Math.floor(date.getTime() / 1000) * 1000);
-    return floored;
-  },
-
-  actions: ({ workerId }: WorkerParams, unchainedAPI) => {
-    const workerActions = {
-      async start() {
-        throw new Error(`Not implemented on ${this.constructor.key}`);
-      },
-
-      async stop() {
-        throw new Error(`Not implemented on ${this.constructor.key}`);
-      },
-
-      reset: async (referenceDate = new Date()) => {
-        await unchainedAPI.modules.worker.markOldWorkAsFailed({
-          types: WorkerDirector.getActivePluginTypes({ external: false }),
-          worker: workerId,
-          referenceDate,
-        });
-      },
-
-      autorescheduleTypes: async ({ referenceDate }) => {
-        return Promise.all(
-          WorkerDirector.getAutoSchedules().map(async ([scheduleId, workConfig]) => {
-            if (!workConfig.schedule) {
-              await unchainedAPI.modules.worker.ensureNoWork({
-                type: workConfig.type,
-                priority: workConfig.priority || 0,
-                scheduleId,
-              });
-              return null;
-            }
-
-            const fixedSchedule = { ...workConfig.schedule };
-            fixedSchedule.schedules[0].s = [0]; // ignore seconds, always run on second 0
-            const nextDate = later.schedule(fixedSchedule).next(1, referenceDate) as Date;
-            nextDate.setMilliseconds(0);
-            const workData: WorkData = {
-              type: workConfig.type,
-              scheduleId,
-              scheduled: nextDate,
-              timeout: workConfig.timeout,
-              priority: workConfig.priority || 0,
-              retries: workConfig.retries || 0,
-            };
-            if (workConfig.input) {
-              workData.input = (await workConfig.input(workData)) || {};
-              // A work input fn can skip auto scheduling a new record
-              // when it explicitly returns a falsish input instead of a dictionary
-              if (!workData.input) return null;
-            }
-            return unchainedAPI.modules.worker.ensureOneWork(workData);
-          }),
-        );
-      },
-
-      process: async ({ maxWorkItemCount = 10, referenceDate }) => {
-        await workerActions.autorescheduleTypes({
-          referenceDate,
-        });
-
-        let processedCount = 0;
-        while (true) {
-          if (maxWorkItemCount && maxWorkItemCount <= processedCount) break;
-
-          const doneWork = await WorkerDirector.processNextWork(unchainedAPI, workerId);
-          if (!doneWork) break;
-
-          processedCount++;
-        }
-      },
-    };
-
-    workerActions.reset();
-
-    return workerActions;
-  },
-};

package/src/directors/DeliveryAdapter.ts

@@ -1,106 +0,0 @@
-import { BaseAdapter } from '@unchainedshop/utils';
-import type { 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 type {
-  DeliveryConfiguration,
-  DeliveryLocation,
-  DeliveryProvider,
-  DeliveryProviderType,
-} from '@unchainedshop/core-delivery';
-import type { 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 | null;
-  estimatedDeliveryThroughput: (warehousingThroughputTime: number) => Promise<number | null>;
-  isActive: () => boolean;
-  isAutoReleaseAllowed: () => boolean;
-  pickUpLocationById: (locationId: string) => Promise<DeliveryLocation | null>;
-  pickUpLocations: () => Promise<DeliveryLocation[]>;
-  send: () => Promise<boolean | Work>;
-}
-
-export interface DeliveryContext {
-  countryCode?: string;
-  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; deliveryProvider: DeliveryProvider },
-  ) => DeliveryAdapterActions;
-};
-
-export const DeliveryAdapter: Omit<IDeliveryAdapter, 'key' | 'label' | 'version'> = {
-  ...BaseAdapter,
-  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 [];
-      },
-    };
-  },
-};