@unchainedshop/core 4.3.6 → 4.4.0

package/src/directors/DeliveryDirector.ts

@@ -1,143 +0,0 @@
-import { BaseDirector, IBaseDirector } from '@unchainedshop/utils';
-import {
-  DeliveryAdapterActions,
-  DeliveryContext,
-  IDeliveryAdapter,
-  DeliveryError,
-} from './DeliveryAdapter.js';
-import { DeliveryProvider } from '@unchainedshop/core-delivery';
-import { Order, 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: (
-    order: Order,
-    transactionContext: Record<string, any>,
-    unchainedAPI: { modules: Modules },
-  ) => Promise<void>;
-  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);
-
-    if (!Adapter) {
-      throw new Error(`Delivery Plugin ${deliveryProvider.adapterKey} not available`);
-    }
-
-    const context = { ...deliveryContext, ...unchainedAPI, deliveryProvider };
-    const adapter = Adapter.actions(deliveryProvider.configuration, context);
-
-    return {
-      configurationError: () => {
-        if (!adapter) {
-          return DeliveryError.ADAPTER_NOT_FOUND;
-        }
-        return adapter.configurationError();
-      },
-
-      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: () => {
-        if (!adapter) return false;
-        try {
-          return adapter.isActive();
-        } catch (error) {
-          logger.warn('Delivery Director -> Error while checking if is active', {
-            ...error,
-          });
-          return false;
-        }
-      },
-
-      isAutoReleaseAllowed: () => {
-        if (!adapter) return false;
-        try {
-          return adapter.isAutoReleaseAllowed();
-        } catch (error) {
-          logger.warn('Delivery Director -> Error while checking if auto release is allowed', {
-            ...error,
-          });
-          return false;
-        }
-      },
-
-      send: async () => {
-        if (!adapter) throw new Error('Delivery adapter not found');
-        return adapter.send();
-      },
-
-      pickUpLocationById: async (locationId) => {
-        if (!adapter) throw new Error('Delivery adapter not found');
-        return adapter?.pickUpLocationById(locationId);
-      },
-
-      pickUpLocations: async () => {
-        if (!adapter) throw new Error('Delivery adapter not found');
-        return adapter.pickUpLocations();
-      },
-    };
-  },
-
-  sendOrderDelivery: async (order, transactionContext, unchainedAPI) => {
-    const orderDelivery = await unchainedAPI.modules.orders.deliveries.findDelivery({
-      orderDeliveryId: order.deliveryId!,
-    });
-
-    if (
-      unchainedAPI.modules.orders.deliveries.normalizedStatus(orderDelivery!) !==
-      OrderDeliveryStatus.OPEN
-    )
-      return;
-
-    const deliveryProvider = await unchainedAPI.modules.delivery.findProvider({
-      deliveryProviderId: orderDelivery!.deliveryProviderId,
-    });
-
-    const address = orderDelivery!.context?.address || order!.billingAddress;
-
-    const adapter = await DeliveryDirector.actions(
-      deliveryProvider!,
-      {
-        order: order!,
-        orderDelivery: orderDelivery!,
-        transactionContext: {
-          ...(transactionContext || {}),
-          ...(orderDelivery!.context || {}),
-          ...(address || {}),
-        },
-      },
-      unchainedAPI,
-    );
-
-    const arbitraryResponseData = await adapter.send();
-    if (arbitraryResponseData) {
-      await unchainedAPI.modules.orders.deliveries.updateStatus(orderDelivery!._id, {
-        status: OrderDeliveryStatus.DELIVERED,
-        info: JSON.stringify(arbitraryResponseData),
-      });
-    }
-  },
-};

package/src/directors/DeliveryPricingAdapter.ts

@@ -1,87 +0,0 @@
-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 {
-  countryCode?: string;
-  currencyCode?: string;
-  provider: DeliveryProvider;
-  providerContext?: any;
-  order: Order;
-  orderDelivery?: OrderDelivery;
-  user: User;
-  discounts: 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 { currencyCode } = context;
-    const baseActions = basePricingAdapter.actions(params);
-    const resultSheet = DeliveryPricingSheet({ currencyCode });
-
-    return {
-      ...baseActions,
-      calculate: async () => {
-        const resultRaw = resultSheet.getRawPricingSheet();
-        resultRaw.forEach(({ amount, category }) =>
-          basePricingAdapter.log(`Delivery Calculation -> ${category} ${amount}`),
-        );
-        return resultRaw;
-      },
-      resultSheet: () => resultSheet,
-    };
-  },
-};

package/src/directors/DeliveryPricingDirector.ts

@@ -1,91 +0,0 @@
-import { DeliveryPricingSheet, BasePricingDirector, IPricingDirector } from '../directors/index.js';
-
-import {
-  DeliveryPricingAdapterContext,
-  DeliveryPricingCalculation,
-  IDeliveryPricingAdapter,
-  IDeliveryPricingSheet,
-} from './DeliveryPricingAdapter.js';
-import { DeliveryProvider } from '@unchainedshop/core-delivery';
-
-import type { Order } from '@unchainedshop/core-orders';
-import type { User } from '@unchainedshop/core-users';
-import type { OrderDelivery } from '@unchainedshop/core-orders';
-
-export type DeliveryPricingContext =
-  | {
-      currencyCode: string;
-      countryCode?: string;
-      provider: DeliveryProvider;
-      providerContext?: any;
-      order: Order;
-      user: User;
-    }
-  | { currencyCode: string; item: OrderDelivery };
-
-export type IDeliveryPricingDirector<DiscountConfiguration = unknown> = IPricingDirector<
-  DeliveryPricingContext,
-  DeliveryPricingCalculation,
-  DeliveryPricingAdapterContext,
-  IDeliveryPricingSheet,
-  IDeliveryPricingAdapter<DiscountConfiguration>
->;
-
-const baseDirector = BasePricingDirector<
-  DeliveryPricingContext,
-  DeliveryPricingAdapterContext,
-  DeliveryPricingCalculation,
-  IDeliveryPricingAdapter
->('DeliveryPricingDirector');
-
-export const DeliveryPricingDirector: IDeliveryPricingDirector<any> = {
-  ...baseDirector,
-
-  async buildPricingContext(context, unchainedAPI) {
-    const { modules } = unchainedAPI;
-
-    if ('item' in context) {
-      const { item, currencyCode } = context;
-      const order = await modules.orders.findOrder({
-        orderId: item.orderId,
-      });
-      const provider = await modules.delivery.findProvider({
-        deliveryProviderId: item.deliveryProviderId,
-      });
-      const user = await modules.users.findUserById(order!.userId);
-      const discounts = await modules.orders.discounts.findOrderDiscounts({
-        orderId: item.orderId,
-      });
-
-      return {
-        ...unchainedAPI,
-        countryCode: order!.countryCode,
-        currencyCode,
-        order: order!,
-        provider: provider!,
-        user: user!,
-        discounts,
-        orderDelivery: item,
-        providerContext: null,
-      };
-    }
-
-    return {
-      ...unchainedAPI,
-      countryCode: context.countryCode,
-      currencyCode: context.currencyCode,
-      order: context.order,
-      provider: context.provider,
-      user: context.user,
-      discounts: [],
-      providerContext: context.providerContext,
-    };
-  },
-
-  calculationSheet(pricingContext, calculation) {
-    return DeliveryPricingSheet({
-      calculation,
-      currencyCode: pricingContext.currencyCode,
-    });
-  },
-};

package/src/directors/DeliveryPricingSheet.ts

@@ -1,87 +0,0 @@
-import { BasePricingSheet, IBasePricingSheet, PricingSheetParams } from '../directors/index.js';
-import { DeliveryPricingCalculation, IDeliveryPricingSheet } from './DeliveryPricingAdapter.js';
-
-export enum DeliveryPricingRowCategory {
-  Delivery = 'DELIVERY',
-  Discount = 'DISCOUNT',
-  Tax = 'TAX',
-  Item = 'ITEM', // Propably unused
-}
-
-export const DeliveryPricingSheet = (
-  params: PricingSheetParams<DeliveryPricingCalculation>,
-): IDeliveryPricingSheet => {
-  const basePricingSheet: IBasePricingSheet<DeliveryPricingCalculation> = BasePricingSheet(params);
-
-  const pricingSheet: IDeliveryPricingSheet = {
-    ...basePricingSheet,
-
-    addDiscount({ amount, isTaxable, isNetPrice, discountId, meta }) {
-      basePricingSheet.calculation.push({
-        category: DeliveryPricingRowCategory.Discount,
-        amount,
-        isTaxable,
-        isNetPrice,
-        discountId,
-        meta,
-      });
-    },
-
-    addFee({ amount, isTaxable, isNetPrice, meta }) {
-      basePricingSheet.calculation.push({
-        amount,
-        category: DeliveryPricingRowCategory.Delivery,
-        isNetPrice,
-        isTaxable,
-        meta,
-      });
-    },
-
-    addTax({ amount, rate, meta }) {
-      basePricingSheet.calculation.push({
-        amount,
-        category: DeliveryPricingRowCategory.Tax,
-        isNetPrice: false,
-        isTaxable: false,
-        meta,
-        rate,
-      });
-    },
-
-    taxSum(filter) {
-      return basePricingSheet.sum({
-        category: DeliveryPricingRowCategory.Tax,
-        ...(filter || {}),
-      });
-    },
-
-    discountPrices(explicitDiscountId) {
-      const discountIds = pricingSheet
-        .filterBy({
-          category: DeliveryPricingRowCategory.Discount,
-          discountId: explicitDiscountId,
-        })
-        .map(({ discountId }) => discountId)
-        .filter(Boolean) as string[];
-
-      return [...new Set(discountIds)]
-        .map((discountId) => {
-          const { currencyCode, amount } = basePricingSheet.total({
-            category: DeliveryPricingRowCategory.Discount,
-            discountId,
-          });
-          if (!amount) {
-            return null;
-          }
-          return {
-            discountId,
-            amount: Math.round(amount),
-            currencyCode,
-          };
-        })
-        .filter(Boolean) as { discountId: string; amount: number; currencyCode: string }[];
-    },
-  };
-
-  return pricingSheet;
-};

package/src/directors/EnrollmentAdapter.ts

@@ -1,108 +0,0 @@
-import { BaseAdapter, IBaseAdapter } from '@unchainedshop/utils';
-import {
-  Enrollment,
-  EnrollmentOrderPositionTemplate,
-  EnrollmentPeriod,
-  EnrollmentPlan,
-  addToDate,
-} from '@unchainedshop/core-enrollments';
-import type { Product, ProductPlan } from '@unchainedshop/core-products';
-import type { OrderPosition } from '@unchainedshop/core-orders';
-
-export interface EnrollmentContext {
-  enrollment: Enrollment;
-  product: Product;
-}
-
-export interface EnrollmentAdapterActions {
-  configurationForOrder: (params: { period: EnrollmentPeriod }) => Promise<{
-    orderContext?: Record<string, any>;
-    orderPositionTemplates: EnrollmentOrderPositionTemplate[];
-  } | null>;
-  isOverdue: () => Promise<boolean>;
-  isValidForActivation: () => Promise<boolean>;
-  nextPeriod: () => Promise<EnrollmentPeriod | null>;
-}
-
-export type IEnrollmentAdapter = IBaseAdapter & {
-  isActivatedFor: (productPlan?: ProductPlan) => boolean;
-
-  transformOrderItemToEnrollmentPlan: (
-    orderPosition: OrderPosition,
-    unchainedAPI,
-  ) => Promise<EnrollmentPlan>;
-
-  actions: (params: EnrollmentContext) => EnrollmentAdapterActions;
-};
-export const periodForReferenceDate = (referenceDate: Date, intervalCount = 1, interval = 'WEEKS') => {
-  const lowerCaseInterval = interval.toLowerCase();
-
-  const start = new Date(referenceDate);
-  if (lowerCaseInterval === 'hours') {
-    start.setMinutes(0, 0, 0);
-  } else {
-    start.setSeconds(0, 0);
-  }
-
-  return {
-    start,
-    end: addToDate(start, {
-      [lowerCaseInterval]: intervalCount,
-    }),
-  };
-};
-
-export const EnrollmentAdapter: Omit<IEnrollmentAdapter, 'key' | 'label' | 'version'> = {
-  ...BaseAdapter,
-  isActivatedFor: () => {
-    return false;
-  },
-
-  transformOrderItemToEnrollmentPlan: async (item) => {
-    return {
-      configuration: item.configuration,
-      productId: item.productId,
-      quantity: item.quantity,
-    };
-  },
-
-  actions: (context) => {
-    return {
-      configurationForOrder: async () => {
-        throw new Error(`Not implemented on EnrollmentAdapter`);
-      },
-
-      isOverdue: async () => false,
-      isValidForActivation: async () => false,
-
-      nextPeriod: async () => {
-        const { enrollment, product } = context;
-
-        const plan = product?.plan;
-        const referenceDate = new Date();
-        if (!plan) return null;
-
-        if (plan.trialIntervalCount && !enrollment?.periods?.length) {
-          return {
-            ...periodForReferenceDate(referenceDate, plan.trialIntervalCount, plan.trialInterval),
-            isTrial: true,
-          };
-        }
-
-        const lastEnd = enrollment?.periods?.reduce((acc, item) => {
-          if (!acc) return item.end;
-          const endDate = new Date(item.end);
-          if (acc.getTime() < endDate.getTime()) {
-            return endDate;
-          }
-          return acc;
-        }, referenceDate);
-
-        return {
-          ...periodForReferenceDate(lastEnd, plan.billingIntervalCount, plan.billingInterval),
-          isTrial: false,
-        };
-      },
-    };
-  },
-};

package/src/directors/EnrollmentDirector.ts

@@ -1,71 +0,0 @@
-import { BaseDirector, IBaseDirector } from '@unchainedshop/utils';
-import { EnrollmentAdapterActions, EnrollmentContext, IEnrollmentAdapter } from './EnrollmentAdapter.js';
-import type { OrderPosition } from '@unchainedshop/core-orders';
-import type { Product, ProductPlan } from '@unchainedshop/core-products';
-import { Enrollment } from '@unchainedshop/core-enrollments';
-import { createLogger } from '@unchainedshop/logger';
-
-const logger = createLogger('unchained:core');
-
-export type IEnrollmentDirector = IBaseDirector<IEnrollmentAdapter> & {
-  transformOrderItemToEnrollment: (
-    item: { orderPosition: OrderPosition; product: Product },
-    doc: Omit<
-      Enrollment,
-      'configuration' | 'productId' | 'quantity' | 'status' | 'periods' | 'log' | '_id' | 'created'
-    >,
-    unchainedAPI,
-  ) => Promise<
-    Omit<Enrollment, 'status' | 'periods' | 'log' | '_id' | 'created'> &
-      Pick<Partial<Enrollment>, '_id' | 'created'>
-  >;
-
-  actions: (enrollmentContext: EnrollmentContext, unchainedAPI) => Promise<EnrollmentAdapterActions>;
-};
-
-const baseDirector = BaseDirector<IEnrollmentAdapter>('EnrollmentDirector', {
-  adapterSortKey: 'orderIndex',
-});
-
-const findAppropriateAdapters = (productPlan?: ProductPlan) =>
-  baseDirector.getAdapters({
-    adapterFilter: (Adapter: IEnrollmentAdapter) => {
-      const activated = Adapter.isActivatedFor(productPlan);
-      if (!activated) {
-        logger.warn(`Enrollment Director -> ${Adapter.key} (${Adapter.version}) skipped`);
-      }
-      return activated;
-    },
-  });
-
-export const EnrollmentDirector: IEnrollmentDirector = {
-  ...baseDirector,
-
-  transformOrderItemToEnrollment: async ({ orderPosition, product }, doc, unchainedAPI) => {
-    const Adapter = findAppropriateAdapters(product.plan)?.[0];
-    if (!Adapter) {
-      throw new Error('No suitable enrollment plugin available for this item');
-    }
-
-    const enrollmentPlan = await Adapter.transformOrderItemToEnrollmentPlan(orderPosition, unchainedAPI);
-
-    return {
-      ...doc,
-      ...enrollmentPlan,
-      configuration: [],
-    };
-  },
-
-  actions: async (enrollmentContext, unchainedAPI) => {
-    const context = { ...enrollmentContext, ...unchainedAPI };
-
-    const Adapter = findAppropriateAdapters(enrollmentContext.product.plan)?.[0];
-
-    if (!Adapter) {
-      throw new Error('No suitable enrollment plugin available for this plan configuration');
-    }
-    const adapter = Adapter.actions(context);
-
-    return adapter;
-  },
-};

package/src/directors/EventListenerWorker.ts

@@ -1,101 +0,0 @@
-import { subscribe } from '@unchainedshop/events';
-import { BaseWorker, IWorker } from './BaseWorker.js';
-import { WorkerEventTypes } from '@unchainedshop/core-worker';
-import { setTimeout } from 'node:timers/promises';
-import { createLogger } from '@unchainedshop/logger';
-
-const logger = createLogger('unchained:worker:event-listener');
-
-function debounce<T extends (...args: any[]) => Promise<any>>(
-  func: T,
-  wait: number,
-): T & { cancel: () => void } {
-  let abortController: AbortController | null = null;
-
-  const debounced = (async (...args: Parameters<T>) => {
-    // Cancel any pending execution
-    if (abortController) {
-      abortController.abort();
-    }
-
-    // Create new abort controller for this execution
-    abortController = new AbortController();
-
-    try {
-      // Wait for the debounce period
-      await setTimeout(wait, undefined, { signal: abortController.signal });
-
-      // If we reach here, the timeout completed without being aborted
-      const result = await func(...args);
-      abortController = null;
-      return result;
-    } catch (error) {
-      // If the operation was aborted, don't execute the function
-      if (error.name === 'AbortError') {
-        return;
-      }
-      // Re-throw any other errors
-      throw error;
-    }
-  }) as T & { cancel: () => void };
-
-  debounced.cancel = () => {
-    if (abortController) {
-      abortController.abort();
-      abortController = null;
-    }
-  };
-
-  return debounced;
-}
-
-export interface EventListenerWorkerParams {
-  workerId?: string;
-}
-
-export const EventListenerWorker: IWorker<EventListenerWorkerParams> = {
-  ...BaseWorker,
-
-  key: 'shop.unchained.worker.event-listener',
-  label: 'Allocates work on events. This worker does not make sense on multiple containers.',
-  version: '1.0.0',
-  type: 'EVENT_LISTENER',
-
-  actions: ({ workerId }, unchainedAPI) => {
-    const baseWorkerActions = BaseWorker.actions(
-      { workerId, worker: EventListenerWorker },
-      unchainedAPI,
-    );
-
-    // Debounce in the event of many work queue events conflicting with each other
-    const processWorkQueue = debounce<() => Promise<void>>(async () => {
-      try {
-        await baseWorkerActions.process({
-          maxWorkItemCount: 1, // only one work item at a time, else we could end up in a loop
-          referenceDate: EventListenerWorker.getFloorDate(),
-        });
-      } catch (error) {
-        // Log error but don't crash the worker
-        logger.error(error);
-      }
-    }, 300);
-
-    return {
-      ...baseWorkerActions,
-
-      async start() {
-        subscribe(WorkerEventTypes.ADDED, processWorkQueue);
-        subscribe(WorkerEventTypes.FINISHED, processWorkQueue);
-
-        await setTimeout(300);
-        await baseWorkerActions.autorescheduleTypes({
-          referenceDate: EventListenerWorker.getFloorDate(),
-        });
-      },
-
-      stop() {
-        processWorkQueue.cancel();
-      },
-    };
-  },
-};