@unchainedshop/core 4.0.0-rc.2 → 4.0.0-rc.21

package/src/directors/BaseWorker.ts

@@ -17,9 +17,9 @@ export interface IWorker<P extends { workerId?: string }> {
   ) => {
     autorescheduleTypes: (options: { referenceDate: Date }) => Promise<(Work | null)[]>;
     process: (options: { maxWorkItemCount?: number; referenceDate?: Date }) => Promise<void>;
-    reset: () => Promise<void>;
-    start: () => void;
-    stop: () => void;
+    reset: () => Promise<void> | void;
+    start: () => Promise<void> | void;
+    stop: () => Promise<void> | void;
   };
 }
 
@@ -42,11 +42,11 @@ export const BaseWorker: IWorker<WorkerParams> = {
 
   actions: ({ workerId }: WorkerParams, unchainedAPI) => {
     const workerActions = {
-      start() {
+      async start() {
         throw new Error(`Not implemented on ${this.constructor.key}`);
       },
 
-      stop() {
+      async stop() {
         throw new Error(`Not implemented on ${this.constructor.key}`);
       },
 
@@ -83,7 +83,7 @@ export const BaseWorker: IWorker<WorkerParams> = {
               retries: workConfig.retries || 0,
             };
             if (workConfig.input) {
-              workData.input = await workConfig.input(workData);
+              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;
@@ -93,19 +93,20 @@ export const BaseWorker: IWorker<WorkerParams> = {
         );
       },
 
-      process: async ({ maxWorkItemCount, referenceDate }) => {
+      process: async ({ maxWorkItemCount = 10, referenceDate }) => {
         await workerActions.autorescheduleTypes({
           referenceDate,
         });
 
-        const processRecursively = async (recursionCounter = 0) => {
-          if (maxWorkItemCount && maxWorkItemCount < recursionCounter) return null;
+        let processedCount = 0;
+        while (true) {
+          if (maxWorkItemCount && maxWorkItemCount <= processedCount) break;
+
           const doneWork = await WorkerDirector.processNextWork(unchainedAPI, workerId);
-          if (doneWork) return processRecursively(recursionCounter + 1);
-          return null;
-        };
+          if (!doneWork) break;
 
-        await processRecursively();
+          processedCount++;
+        }
       },
     };
 

package/src/directors/DeliveryAdapter.ts

@@ -7,7 +7,6 @@ import type { User } from '@unchainedshop/core-users';
 import {
   DeliveryConfiguration,
   DeliveryLocation,
-  DeliveryProvider,
   DeliveryProviderType,
 } from '@unchainedshop/core-delivery';
 import { Modules } from '../modules.js';
@@ -20,18 +19,17 @@ export enum DeliveryError {
 }
 
 export interface DeliveryAdapterActions {
-  configurationError: (transactionContext?: any) => DeliveryError;
-  estimatedDeliveryThroughput: (warehousingThroughputTime: number) => Promise<number>;
+  configurationError: (transactionContext?: any) => DeliveryError | null;
+  estimatedDeliveryThroughput: (warehousingThroughputTime: number) => Promise<number | null>;
   isActive: () => boolean;
   isAutoReleaseAllowed: () => boolean;
-  pickUpLocationById: (locationId: string) => Promise<DeliveryLocation>;
+  pickUpLocationById: (locationId: string) => Promise<DeliveryLocation | null>;
   pickUpLocations: () => Promise<DeliveryLocation[]>;
   send: () => Promise<boolean | Work>;
 }
 
 export interface DeliveryContext {
   countryCode?: string;
-  deliveryProvider?: DeliveryProvider;
   order?: Order;
   orderDelivery?: OrderDelivery;
   orderPosition?: OrderPosition;

package/src/directors/DeliveryDirector.ts

@@ -6,7 +6,7 @@ import {
   DeliveryError,
 } from './DeliveryAdapter.js';
 import { DeliveryProvider } from '@unchainedshop/core-delivery';
-import { OrderDelivery, OrderDeliveryStatus } from '@unchainedshop/core-orders';
+import { Order, OrderDeliveryStatus } from '@unchainedshop/core-orders';
 import { Modules } from '../modules.js';
 import { createLogger } from '@unchainedshop/logger';
 
@@ -14,10 +14,10 @@ const logger = createLogger('unchained:core');
 
 export type IDeliveryDirector = IBaseDirector<IDeliveryAdapter> & {
   sendOrderDelivery: (
-    orderDelivery: OrderDelivery,
+    order: Order,
     transactionContext: Record<string, any>,
     unchainedAPI: { modules: Modules },
-  ) => Promise<OrderDelivery>;
+  ) => Promise<void>;
   actions: (
     deliveryProvider: DeliveryProvider,
     deliveryContext: DeliveryContext,
@@ -33,21 +33,24 @@ export const DeliveryDirector: IDeliveryDirector = {
   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 };
-    const adapter = Adapter?.actions(deliveryProvider.configuration, context);
+    const adapter = Adapter.actions(deliveryProvider.configuration, context);
 
     return {
       configurationError: () => {
-        try {
-          return adapter.configurationError();
-        } catch {
+        if (!adapter) {
           return DeliveryError.ADAPTER_NOT_FOUND;
         }
+        return adapter.configurationError();
       },
 
       estimatedDeliveryThroughput: async (warehousingThroughputTime) => {
         try {
-          const throughput = await adapter.estimatedDeliveryThroughput(warehousingThroughputTime);
+          const throughput = await adapter?.estimatedDeliveryThroughput(warehousingThroughputTime);
           return throughput;
         } catch (error) {
           logger.warn('Delivery Director -> Error while estimating delivery throughput', {
@@ -58,6 +61,7 @@ export const DeliveryDirector: IDeliveryDirector = {
       },
 
       isActive: () => {
+        if (!adapter) return false;
         try {
           return adapter.isActive();
         } catch (error) {
@@ -69,6 +73,7 @@ export const DeliveryDirector: IDeliveryDirector = {
       },
 
       isAutoReleaseAllowed: () => {
+        if (!adapter) return false;
         try {
           return adapter.isAutoReleaseAllowed();
         } catch (error) {
@@ -80,39 +85,47 @@ export const DeliveryDirector: IDeliveryDirector = {
       },
 
       send: async () => {
+        if (!adapter) throw new Error('Delivery adapter not found');
         return adapter.send();
       },
 
       pickUpLocationById: async (locationId) => {
-        return adapter.pickUpLocationById(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 (orderDelivery, transactionContext, unchainedAPI) => {
+  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
+      unchainedAPI.modules.orders.deliveries.normalizedStatus(orderDelivery!) !==
+      OrderDeliveryStatus.OPEN
     )
-      return orderDelivery;
+      return;
 
-    const order = await unchainedAPI.modules.orders.findOrder({ orderId: orderDelivery.orderId });
     const deliveryProvider = await unchainedAPI.modules.delivery.findProvider({
-      deliveryProviderId: orderDelivery.deliveryProviderId,
+      deliveryProviderId: orderDelivery!.deliveryProviderId,
     });
-    const address = orderDelivery.context?.address || order || order.billingAddress;
+
+    const address = orderDelivery!.context?.address || order!.billingAddress;
 
     const adapter = await DeliveryDirector.actions(
-      deliveryProvider,
+      deliveryProvider!,
       {
-        order,
-        orderDelivery,
+        order: order!,
+        orderDelivery: orderDelivery!,
         transactionContext: {
           ...(transactionContext || {}),
-          ...(orderDelivery.context || {}),
+          ...(orderDelivery!.context || {}),
           ...(address || {}),
         },
       },
@@ -120,14 +133,11 @@ export const DeliveryDirector: IDeliveryDirector = {
     );
 
     const arbitraryResponseData = await adapter.send();
-
     if (arbitraryResponseData) {
-      return await unchainedAPI.modules.orders.deliveries.updateStatus(orderDelivery._id, {
+      await unchainedAPI.modules.orders.deliveries.updateStatus(orderDelivery!._id, {
         status: OrderDeliveryStatus.DELIVERED,
         info: JSON.stringify(arbitraryResponseData),
       });
     }
-
-    return orderDelivery;
   },
 };

package/src/directors/DeliveryPricingAdapter.ts

@@ -42,7 +42,7 @@ export interface DeliveryPricingAdapterContext extends BasePricingAdapterContext
   provider: DeliveryProvider;
   providerContext?: any;
   order: Order;
-  orderDelivery: OrderDelivery;
+  orderDelivery?: OrderDelivery;
   user: User;
   discounts: OrderDiscount[];
 }

package/src/directors/DeliveryPricingDirector.ts

@@ -52,18 +52,18 @@ export const DeliveryPricingDirector: IDeliveryPricingDirector<any> = {
       const provider = await modules.delivery.findProvider({
         deliveryProviderId: item.deliveryProviderId,
       });
-      const user = await modules.users.findUserById(order.userId);
+      const user = await modules.users.findUserById(order!.userId);
       const discounts = await modules.orders.discounts.findOrderDiscounts({
         orderId: item.orderId,
       });
 
       return {
         ...unchainedAPI,
-        countryCode: order.countryCode,
+        countryCode: order!.countryCode,
         currencyCode,
-        order,
-        provider,
-        user,
+        order: order!,
+        provider: provider!,
+        user: user!,
         discounts,
         orderDelivery: item,
         providerContext: null,
@@ -78,7 +78,6 @@ export const DeliveryPricingDirector: IDeliveryPricingDirector<any> = {
       provider: context.provider,
       user: context.user,
       discounts: [],
-      orderDelivery: null,
       providerContext: context.providerContext,
     };
   },

package/src/directors/DeliveryPricingSheet.ts

@@ -61,7 +61,8 @@ export const DeliveryPricingSheet = (
           category: DeliveryPricingRowCategory.Discount,
           discountId: explicitDiscountId,
         })
-        .map(({ discountId }) => discountId);
+        .map(({ discountId }) => discountId)
+        .filter(Boolean) as string[];
 
       return [...new Set(discountIds)]
         .map((discountId) => {
@@ -78,7 +79,7 @@ export const DeliveryPricingSheet = (
             currencyCode,
           };
         })
-        .filter(Boolean);
+        .filter(Boolean) as { discountId: string; amount: number; currencyCode: string }[];
     },
   };
 

package/src/directors/EnrollmentAdapter.ts

@@ -1,6 +1,7 @@
 import { BaseAdapter, IBaseAdapter } from '@unchainedshop/utils';
 import {
   Enrollment,
+  EnrollmentOrderPositionTemplate,
   EnrollmentPeriod,
   EnrollmentPlan,
   addToDate,
@@ -10,13 +11,17 @@ import type { OrderPosition } from '@unchainedshop/core-orders';
 
 export interface EnrollmentContext {
   enrollment: Enrollment;
+  product: Product;
 }
 
 export interface EnrollmentAdapterActions {
-  configurationForOrder: (params: { period: EnrollmentPeriod; products: Product[] }) => Promise<any>;
+  configurationForOrder: (params: { period: EnrollmentPeriod }) => Promise<{
+    orderContext?: Record<string, any>;
+    orderPositionTemplates: EnrollmentOrderPositionTemplate[];
+  } | null>;
   isOverdue: () => Promise<boolean>;
   isValidForActivation: () => Promise<boolean>;
-  nextPeriod: () => Promise<EnrollmentPeriod>;
+  nextPeriod: () => Promise<EnrollmentPeriod | null>;
 }
 
 export type IEnrollmentAdapter = IBaseAdapter & {
@@ -71,10 +76,8 @@ export const EnrollmentAdapter: Omit<IEnrollmentAdapter, 'key' | 'label' | 'vers
       isValidForActivation: async () => false,
 
       nextPeriod: async () => {
-        const { enrollment } = context;
-        const product = await (context as any).modules.products.findProduct({
-          productId: enrollment.productId,
-        });
+        const { enrollment, product } = context;
+
         const plan = product?.plan;
         const referenceDate = new Date();
         if (!plan) return null;

package/src/directors/EnrollmentDirector.ts

@@ -10,9 +10,15 @@ 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'>,
+    doc: Omit<
+      Enrollment,
+      'configuration' | 'productId' | 'quantity' | 'status' | 'periods' | 'log' | '_id' | 'created'
+    >,
     unchainedAPI,
-  ) => Promise<Omit<Enrollment, 'status' | 'periods' | 'log'>>;
+  ) => Promise<
+    Omit<Enrollment, 'status' | 'periods' | 'log' | '_id' | 'created'> &
+      Pick<Partial<Enrollment>, '_id' | 'created'>
+  >;
 
   actions: (enrollmentContext: EnrollmentContext, unchainedAPI) => Promise<EnrollmentAdapterActions>;
 };
@@ -53,12 +59,7 @@ export const EnrollmentDirector: IEnrollmentDirector = {
   actions: async (enrollmentContext, unchainedAPI) => {
     const context = { ...enrollmentContext, ...unchainedAPI };
 
-    // Resolve adapter
-    const product = await context.modules.products.findProduct({
-      productId: context.enrollment.productId,
-    });
-
-    const Adapter = findAppropriateAdapters(product?.plan)?.[0];
+    const Adapter = findAppropriateAdapters(enrollmentContext.product.plan)?.[0];
 
     if (!Adapter) {
       throw new Error('No suitable enrollment plugin available for this plan configuration');

package/src/directors/EventListenerWorker.ts

@@ -1,16 +1,52 @@
 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';
 
-function debounce<T extends (...args: any) => any>(func: T, wait) {
-  let timeout;
-  return (...args) => {
-    clearTimeout(timeout);
-    timeout = setTimeout(() => {
-      timeout = null;
-      func(...args);
-    }, wait);
+const logger = createLogger('unchained:worker');
+
+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 {
@@ -33,28 +69,32 @@ export const EventListenerWorker: IWorker<EventListenerWorkerParams> = {
 
     // Debounce in the event of many work queue events conflicting with each other
     const processWorkQueue = debounce<() => Promise<void>>(async () => {
-      await baseWorkerActions.process({
-        maxWorkItemCount: 1, // only one work item at a time, else we could end up in a loop
-        referenceDate: EventListenerWorker.getFloorDate(),
-      });
+      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,
 
-      start() {
+      async start() {
         subscribe(WorkerEventTypes.ADDED, processWorkQueue);
         subscribe(WorkerEventTypes.FINISHED, processWorkQueue);
 
-        setTimeout(async () => {
-          await baseWorkerActions.autorescheduleTypes({
-            referenceDate: EventListenerWorker.getFloorDate(),
-          });
-        }, 300);
+        await setTimeout(300);
+        await baseWorkerActions.autorescheduleTypes({
+          referenceDate: EventListenerWorker.getFloorDate(),
+        });
       },
 
       stop() {
-        /* */
+        processWorkQueue.cancel();
       },
     };
   },

package/src/directors/FailedRescheduler.ts

@@ -3,7 +3,7 @@ import { subscribe } from '@unchainedshop/events';
 import { Work, WorkData, WorkerEventTypes } from '@unchainedshop/core-worker';
 
 export interface FailedReschedulerParams {
-  transformRetry?: (workData: WorkData) => Promise<WorkData | null>;
+  transformRetry?: (workData: WorkData, lastFailedWork: Work) => Promise<WorkData | null>;
 }
 
 export interface IScheduler<P> {
@@ -55,7 +55,7 @@ export const FailedRescheduler: IScheduler<FailedReschedulerParams> = {
           scheduled,
         };
         await unchainedAPI.modules.worker.addWork(
-          transformRetry ? await transformRetry(newWorkData) : newWorkData,
+          transformRetry ? await transformRetry(newWorkData, work) : newWorkData,
         );
       }
     };

package/src/directors/FilterAdapter.ts

@@ -21,7 +21,7 @@ export interface FilterAdapterActions {
 
   searchAssortments: (
     params: {
-      assortmentIds: string[];
+      assortmentIds?: string[];
     },
     options: {
       filterSelector: mongodb.Filter<Filter>;
@@ -29,11 +29,11 @@ export interface FilterAdapterActions {
       sortStage: mongodb.FindOptions['sort'];
       locale: Intl.Locale;
     },
-  ) => Promise<string[]>;
+  ) => Promise<string[] | undefined>;
 
   searchProducts: (
     params: {
-      productIds: string[];
+      productIds?: string[];
     },
     options: {
       filterSelector: mongodb.Filter<Filter>;
@@ -41,7 +41,7 @@ export interface FilterAdapterActions {
       sortStage: mongodb.FindOptions['sort'];
       locale: Intl.Locale;
     },
-  ) => Promise<string[]>;
+  ) => Promise<string[] | undefined>;
 
   transformFilterSelector: (
     query: mongodb.Filter<Filter>,

package/src/directors/FilterDirector.ts

@@ -12,7 +12,7 @@ import {
 import { Product } from '@unchainedshop/core-products';
 import { Modules } from '../modules.js';
 
-export const parseQueryArray = (query: SearchFilterQuery): Record<string, string[]> =>
+export const parseQueryArray = (query?: SearchFilterQuery): Record<string, string[]> =>
   (query || []).reduce(
     (accumulator, { key, value }) => ({
       ...accumulator,
@@ -80,7 +80,7 @@ export const FilterDirector: IFilterDirector = {
       initialValue: V,
     ) => {
       if (adapters.length === 0) {
-        return null;
+        return initialValue;
       }
       return adapters.reduce(async (lastSearchPromise, adapter, index) => {
         return reducer(lastSearchPromise, adapter, index);
@@ -89,22 +89,21 @@ export const FilterDirector: IFilterDirector = {
 
     return {
       aggregateProductIds: (params) => {
-        const reducedProductIds = adapters.reduce(
+        return adapters.reduce(
           (productIds, adapter) => adapter.aggregateProductIds({ productIds }),
           params.productIds,
         );
-        return reducedProductIds;
       },
 
       searchAssortments: async (params, options) => {
-        return reduceAdapters<string[]>(async (lastSearchPromise, adapter) => {
+        return reduceAdapters<string[] | undefined>(async (lastSearchPromise, adapter) => {
           const assortmentIds = await lastSearchPromise;
           return adapter.searchAssortments({ assortmentIds }, options);
         }, params.assortmentIds);
       },
 
       searchProducts: async (params, options) => {
-        return reduceAdapters<string[]>(async (lastSearchPromise, adapter) => {
+        return reduceAdapters<string[] | undefined>(async (lastSearchPromise, adapter) => {
           const productIds = await lastSearchPromise;
           return adapter.searchProducts({ productIds }, options);
         }, params.productIds);
@@ -113,19 +112,19 @@ export const FilterDirector: IFilterDirector = {
       transformProductSelector: async (defaultSelector, options) => {
         return reduceAdapters<mongodb.Filter<Product>>(async (lastSelector, adapter) => {
           return adapter.transformProductSelector(await lastSelector, options);
-        }, defaultSelector || null);
+        }, defaultSelector);
       },
 
       transformSortStage: async (defaultStage, options) => {
         return reduceAdapters<mongodb.FindOptions<Product>['sort']>(async (lastSortStage, adapter) => {
           return adapter.transformSortStage(await lastSortStage, options);
-        }, defaultStage || null);
+        }, defaultStage);
       },
 
       transformFilterSelector: async (defaultSelector) => {
         return reduceAdapters<mongodb.Filter<Filter>>(async (lastSelector, adapter) => {
           return adapter.transformFilterSelector(await lastSelector);
-        }, defaultSelector || null);
+        }, defaultSelector);
       },
     };
   },
@@ -161,7 +160,7 @@ export const FilterDirector: IFilterDirector = {
       filter.type === FilterType.SWITCH
         ? {
             true: await this.findProductIds(filter, { value: true }, unchainedAPI),
-            false: await this.findProductIds(filter, { value: false }, unchainedAPI),
+            false: await this.findProductIds(filter, { value: { $in: [null, false] } }, unchainedAPI),
           }
         : await (filter.options || []).reduce(async (accumulatorPromise, option) => {
             const accumulator = await accumulatorPromise;
@@ -188,7 +187,7 @@ export const FilterDirector: IFilterDirector = {
       values,
       Object.keys(keyToProductIdMap),
     );
-    const result = [];
+    const result: string[] = [];
     for (const key of filteredKeys) {
       const additionalValues = key === undefined ? allProductIds : keyToProductIdMap[key];
       if (additionalValues) {
@@ -245,7 +244,7 @@ export const FilterDirector: IFilterDirector = {
   async filterFacets(filter, params, unchainedAPI) {
     const { allProductIds, searchQuery, forceLiveCollection, otherFilters } = params;
 
-    const filterQueryParsed = parseQueryArray(searchQuery?.filterQuery);
+    const filterQueryParsed = parseQueryArray(searchQuery.filterQuery);
 
     // The examinedProductIdSet is a set of product id's that:
     // - Fit this filter generally