@unchainedshop/core 3.1.13 → 4.0.0-rc.3

package/src/directors/BasePricingSheet.ts

@@ -2,22 +2,22 @@ import { PricingCalculation } from '@unchainedshop/utils';
 export interface PricingDiscount {
   discountId: string;
   amount: number;
-  currency: string;
+  currencyCode: string;
 }
 
 export interface IPricingSheet<Calculation extends PricingCalculation>
   extends IBasePricingSheet<Calculation> {
-  discountPrices: (discountId?: string) => Array<PricingDiscount>;
+  discountPrices: (discountId?: string) => PricingDiscount[];
   addDiscount: (params: { amount: number; discountId: string; meta?: any }) => void;
 }
 
 export interface IBasePricingSheet<Calculation extends PricingCalculation> {
-  calculation: Array<Calculation>;
-  currency?: string;
+  calculation: Calculation[];
+  currencyCode?: string;
   quantity?: number;
 
-  getRawPricingSheet: () => Array<Calculation>;
-  filterBy: (filter?: Partial<Calculation>) => Array<Calculation>;
+  getRawPricingSheet: () => Calculation[];
+  filterBy: (filter?: Partial<Calculation>) => Calculation[];
   isValid: () => boolean;
 
   gross: () => number;
@@ -25,17 +25,17 @@ export interface IBasePricingSheet<Calculation extends PricingCalculation> {
   sum: (filter?: Partial<Calculation>) => number;
   total: (params?: { category?: string; discountId?: string; useNetPrice?: boolean }) => {
     amount: number;
-    currency: string;
+    currencyCode: string;
   };
 
   taxSum: (filter?: Partial<Calculation>) => number;
 
-  resetCalculation: (sheetToInvert: IBasePricingSheet<Calculation>) => Array<Calculation>;
+  resetCalculation: (sheetToInvert: IBasePricingSheet<Calculation>) => Calculation[];
 }
 
 export interface PricingSheetParams<Calculation extends PricingCalculation> {
-  calculation?: Array<Calculation>;
-  currency?: string;
+  calculation?: Calculation[];
+  currencyCode?: string;
   quantity?: number;
 }
 
@@ -44,7 +44,7 @@ export const BasePricingSheet = <Calculation extends PricingCalculation>(
 ): IBasePricingSheet<Calculation> => {
   const pricingSheet: IBasePricingSheet<Calculation> = {
     calculation: params.calculation || [],
-    currency: params.currency,
+    currencyCode: params.currencyCode,
     quantity: params.quantity,
 
     getRawPricingSheet() {
@@ -84,7 +84,7 @@ export const BasePricingSheet = <Calculation extends PricingCalculation>(
 
       return {
         amount: Math.round(useNetPrice ? netAmount : netAmount + taxAmountForCategory),
-        currency: this.currency,
+        currencyCode: this.currencyCode,
       };
     },
 

package/src/directors/BaseWorker.ts

@@ -0,0 +1,117 @@
+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

@@ -25,12 +25,12 @@ export interface DeliveryAdapterActions {
   isActive: () => boolean;
   isAutoReleaseAllowed: () => boolean;
   pickUpLocationById: (locationId: string) => Promise<DeliveryLocation>;
-  pickUpLocations: () => Promise<Array<DeliveryLocation>>;
+  pickUpLocations: () => Promise<DeliveryLocation[]>;
   send: () => Promise<boolean | Work>;
 }
 
 export interface DeliveryContext {
-  country?: string;
+  countryCode?: string;
   deliveryProvider?: DeliveryProvider;
   order?: Order;
   orderDelivery?: OrderDelivery;

package/src/directors/DeliveryDirector.ts

@@ -103,12 +103,10 @@ export const DeliveryDirector: IDeliveryDirector = {
     const deliveryProvider = await unchainedAPI.modules.delivery.findProvider({
       deliveryProviderId: orderDelivery.deliveryProviderId,
     });
-    const deliveryProviderId = deliveryProvider._id;
     const address = orderDelivery.context?.address || order || order.billingAddress;
-    const provider = await await unchainedAPI.modules.delivery.findProvider({ deliveryProviderId });
 
     const adapter = await DeliveryDirector.actions(
-      provider,
+      deliveryProvider,
       {
         order,
         orderDelivery,

package/src/directors/DeliveryPricingAdapter.ts

@@ -37,14 +37,14 @@ export type IDeliveryPricingSheet = IPricingSheet<DeliveryPricingCalculation> &
 };
 
 export interface DeliveryPricingAdapterContext extends BasePricingAdapterContext {
-  country?: string;
-  currency?: string;
+  countryCode?: string;
+  currencyCode?: string;
   provider: DeliveryProvider;
   providerContext?: any;
   order: Order;
   orderDelivery: OrderDelivery;
   user: User;
-  discounts: Array<OrderDiscount>;
+  discounts: OrderDiscount[];
 }
 
 export type IDeliveryPricingAdapter<DiscountConfiguration = unknown> = IPricingAdapter<
@@ -68,9 +68,9 @@ export const DeliveryPricingAdapter: IDeliveryPricingAdapter = {
 
   actions: (params) => {
     const { context } = params;
-    const { currency } = context;
+    const { currencyCode } = context;
     const baseActions = basePricingAdapter.actions(params);
-    const resultSheet = DeliveryPricingSheet({ currency });
+    const resultSheet = DeliveryPricingSheet({ currencyCode });
 
     return {
       ...baseActions,

package/src/directors/DeliveryPricingDirector.ts

@@ -14,14 +14,14 @@ import type { OrderDelivery } from '@unchainedshop/core-orders';
 
 export type DeliveryPricingContext =
   | {
-      currency: string;
-      country?: string;
+      currencyCode: string;
+      countryCode?: string;
       provider: DeliveryProvider;
       providerContext?: any;
       order: Order;
       user: User;
     }
-  | { currency: string; item: OrderDelivery };
+  | { currencyCode: string; item: OrderDelivery };
 
 export type IDeliveryPricingDirector<DiscountConfiguration = unknown> = IPricingDirector<
   DeliveryPricingContext,
@@ -45,7 +45,7 @@ export const DeliveryPricingDirector: IDeliveryPricingDirector<any> = {
     const { modules } = unchainedAPI;
 
     if ('item' in context) {
-      const { item, currency } = context;
+      const { item, currencyCode } = context;
       const order = await modules.orders.findOrder({
         orderId: item.orderId,
       });
@@ -59,8 +59,8 @@ export const DeliveryPricingDirector: IDeliveryPricingDirector<any> = {
 
       return {
         ...unchainedAPI,
-        country: order.countryCode,
-        currency,
+        countryCode: order.countryCode,
+        currencyCode,
         order,
         provider,
         user,
@@ -72,8 +72,8 @@ export const DeliveryPricingDirector: IDeliveryPricingDirector<any> = {
 
     return {
       ...unchainedAPI,
-      country: context.country,
-      currency: context.currency,
+      countryCode: context.countryCode,
+      currencyCode: context.currencyCode,
       order: context.order,
       provider: context.provider,
       user: context.user,
@@ -86,7 +86,7 @@ export const DeliveryPricingDirector: IDeliveryPricingDirector<any> = {
   calculationSheet(pricingContext, calculation) {
     return DeliveryPricingSheet({
       calculation,
-      currency: pricingContext.currency,
+      currencyCode: pricingContext.currencyCode,
     });
   },
 };

package/src/directors/DeliveryPricingSheet.ts

@@ -65,7 +65,7 @@ export const DeliveryPricingSheet = (
 
       return [...new Set(discountIds)]
         .map((discountId) => {
-          const { currency, amount } = basePricingSheet.total({
+          const { currencyCode, amount } = basePricingSheet.total({
             category: DeliveryPricingRowCategory.Discount,
             discountId,
           });
@@ -75,7 +75,7 @@ export const DeliveryPricingSheet = (
           return {
             discountId,
             amount: Math.round(amount),
-            currency,
+            currencyCode,
           };
         })
         .filter(Boolean);

package/src/directors/EnrollmentAdapter.ts

@@ -8,15 +8,12 @@ import {
 import type { Product, ProductPlan } from '@unchainedshop/core-products';
 import type { OrderPosition } from '@unchainedshop/core-orders';
 
-export type EnrollmentContext = {
+export interface EnrollmentContext {
   enrollment: Enrollment;
-};
+}
 
 export interface EnrollmentAdapterActions {
-  configurationForOrder: (params: {
-    period: EnrollmentPeriod;
-    products: Array<Product>;
-  }) => Promise<any>;
+  configurationForOrder: (params: { period: EnrollmentPeriod; products: Product[] }) => Promise<any>;
   isOverdue: () => Promise<boolean>;
   isValidForActivation: () => Promise<boolean>;
   nextPeriod: () => Promise<EnrollmentPeriod>;

package/src/directors/EventListenerWorker.ts

@@ -0,0 +1,101 @@
+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');
+
+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();
+      },
+    };
+  },
+};

package/src/directors/FailedRescheduler.ts

@@ -0,0 +1,73 @@
+import { defaultLogger } from '@unchainedshop/logger';
+import { subscribe } from '@unchainedshop/events';
+import { Work, WorkData, WorkerEventTypes } from '@unchainedshop/core-worker';
+
+export interface FailedReschedulerParams {
+  transformRetry?: (workData: WorkData) => Promise<WorkData | null>;
+}
+
+export interface IScheduler<P> {
+  key: string;
+  label: string;
+  version: string;
+
+  actions: (
+    params: P,
+    unchainedAPI,
+  ) => {
+    start: () => void;
+    stop: () => void;
+  };
+}
+
+export const FailedRescheduler: IScheduler<FailedReschedulerParams> = {
+  key: 'shop.unchained.scheduler.failed',
+  label: 'Reschedule failed works',
+  version: '1.0.0',
+
+  actions: ({ transformRetry }, unchainedAPI) => {
+    const handleFinishedWork = async ({ payload: work }: { payload: Work }) => {
+      if (!work.success && work.retries > 0) {
+        const now = new Date();
+        const workDelayMs = work.scheduled.getTime() - work.created.getTime();
+
+        // In short: Double the delay of the old work or delay for 5 seconds
+        const scheduled =
+          workDelayMs > 1000
+            ? new Date(now.getTime() + workDelayMs * 2)
+            : new Date(now.setSeconds(now.getSeconds() + 5));
+
+        defaultLogger.error(
+          `${FailedRescheduler.key} -> Reschedule failed work ${work._id} ${
+            work.type
+          } for ${scheduled.toISOString()} (in ${Math.round(workDelayMs / 1000)}). Remaining retries: ${
+            work.retries
+          }`,
+        );
+
+        const newWorkData = {
+          type: work.type,
+          priority: work.priority,
+          originalWorkId: work.originalWorkId || work._id,
+          retries: work.retries - 1,
+          timeout: work.timeout,
+          input: work.input,
+          scheduled,
+        };
+        await unchainedAPI.modules.worker.addWork(
+          transformRetry ? await transformRetry(newWorkData) : newWorkData,
+        );
+      }
+    };
+
+    return {
+      start() {
+        subscribe<Work>(WorkerEventTypes.FINISHED, handleFinishedWork);
+      },
+
+      stop() {
+        /* */
+      },
+    };
+  },
+};

package/src/directors/FilterAdapter.ts

@@ -5,23 +5,23 @@ import { Product } from '@unchainedshop/core-products';
 import { Filter, SearchQuery } from '@unchainedshop/core-filters';
 import { Modules } from '../modules.js';
 
-export type FilterInputText = { locale: string; title: string; subtitle?: string };
-
-export enum FilterError {
-  NOT_IMPLEMENTED = 'NOT_IMPLEMENTED',
+export interface FilterInputText {
+  locale: string;
+  title: string;
+  subtitle?: string;
 }
 
-export type FilterContext = {
+export interface FilterContext {
   filter?: Filter;
   searchQuery: SearchQuery;
-};
+}
 
 export interface FilterAdapterActions {
-  aggregateProductIds: (params: { productIds: Array<string> }) => Array<string>;
+  aggregateProductIds: (params: { productIds: string[] }) => string[];
 
   searchAssortments: (
     params: {
-      assortmentIds: Array<string>;
+      assortmentIds: string[];
     },
     options: {
       filterSelector: mongodb.Filter<Filter>;
@@ -29,11 +29,11 @@ export interface FilterAdapterActions {
       sortStage: mongodb.FindOptions['sort'];
       locale: Intl.Locale;
     },
-  ) => Promise<Array<string>>;
+  ) => Promise<string[]>;
 
   searchProducts: (
     params: {
-      productIds: Array<string>;
+      productIds?: string[];
     },
     options: {
       filterSelector: mongodb.Filter<Filter>;
@@ -41,7 +41,7 @@ export interface FilterAdapterActions {
       sortStage: mongodb.FindOptions['sort'];
       locale: Intl.Locale;
     },
-  ) => Promise<Array<string>>;
+  ) => Promise<string[]>;
 
   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, Array<string>> =>
+export const parseQueryArray = (query: SearchFilterQuery): Record<string, string[]> =>
   (query || []).reduce(
     (accumulator, { key, value }) => ({
       ...accumulator,
@@ -31,24 +31,24 @@ export type IFilterDirector = IBaseDirector<IFilterAdapter> & {
     filter: Filter,
     { value }: { value?: boolean | string },
     unchainedAPI: { modules: Modules },
-  ) => Promise<Array<string>>;
+  ) => Promise<string[]>;
   buildProductIdMap: (
     filter: Filter,
     unchainedAPI: { modules: Modules },
-  ) => Promise<[Array<string>, Record<string, Array<string>>]>;
+  ) => Promise<[string[], Record<string, string[]>]>;
   filterProductIds: (
     filter: Filter,
-    { values, forceLiveCollection }: { values: Array<string>; forceLiveCollection?: boolean },
+    { values, forceLiveCollection }: { values: string[]; forceLiveCollection?: boolean },
     unchainedAPI: { modules: Modules },
-  ) => Promise<Array<string>>;
+  ) => Promise<string[]>;
 
   filterFacets: (
     filter: Filter,
     params: {
       searchQuery: SearchQuery;
       forceLiveCollection?: boolean;
-      allProductIds: Array<string>;
-      otherFilters: Array<Filter>;
+      allProductIds: string[];
+      otherFilters: Filter[];
     },
     unchainedAPI: { modules: Modules },
   ) => Promise<{
@@ -58,10 +58,10 @@ export type IFilterDirector = IBaseDirector<IFilterAdapter> & {
   }>;
 
   productFacetedSearch: (
-    productIds: Array<string>,
+    productIds: string[],
     searchConfiguration: SearchConfiguration,
     unchainedAPI: { modules: Modules },
-  ) => Promise<Array<string>>;
+  ) => Promise<string[]>;
 };
 
 const baseDirector = BaseDirector<IFilterAdapter>('FilterDirector', {
@@ -97,14 +97,14 @@ export const FilterDirector: IFilterDirector = {
       },
 
       searchAssortments: async (params, options) => {
-        return reduceAdapters<Array<string>>(async (lastSearchPromise, adapter) => {
+        return reduceAdapters<string[]>(async (lastSearchPromise, adapter) => {
           const assortmentIds = await lastSearchPromise;
           return adapter.searchAssortments({ assortmentIds }, options);
         }, params.assortmentIds);
       },
 
       searchProducts: async (params, options) => {
-        return reduceAdapters<Array<string>>(async (lastSearchPromise, adapter) => {
+        return reduceAdapters<string[]>(async (lastSearchPromise, adapter) => {
           const productIds = await lastSearchPromise;
           return adapter.searchProducts({ productIds }, options);
         }, params.productIds);
@@ -155,7 +155,7 @@ export const FilterDirector: IFilterDirector = {
   async buildProductIdMap(
     filter: Filter,
     unchainedAPI: { modules: Modules },
-  ): Promise<[Array<string>, Record<string, Array<string>>]> {
+  ): Promise<[string[], Record<string, string[]>]> {
     const allProductIds = await this.findProductIds(filter, {}, unchainedAPI);
     const productIdsMap =
       filter.type === FilterType.SWITCH
@@ -176,10 +176,10 @@ export const FilterDirector: IFilterDirector = {
 
   async filterProductIds(
     filter: Filter,
-    { values, forceLiveCollection }: { values: Array<string>; forceLiveCollection?: boolean },
+    { values, forceLiveCollection }: { values: string[]; forceLiveCollection?: boolean },
     unchainedAPI: { modules: Modules },
   ) {
-    const [allProductIds, keyToProductIdMap]: [Array<string>, Record<string, Array<string>>] =
+    const [allProductIds, keyToProductIdMap]: [string[], Record<string, string[]>] =
       (!forceLiveCollection && (await filtersSettings.getCachedProductIds(filter._id))) ||
       (await this.buildProductIdMap(filter, unchainedAPI));
 
@@ -199,10 +199,10 @@ export const FilterDirector: IFilterDirector = {
   },
 
   async productFacetedSearch(
-    productIds: Array<string>,
+    productIds: string[],
     searchConfiguration: SearchConfiguration,
     unchainedAPI: { modules: Modules },
-  ): Promise<Array<string>> {
+  ): Promise<string[]> {
     const { searchQuery, filterSelector, forceLiveCollection } = searchConfiguration;
     const { modules } = unchainedAPI;
     if (!searchQuery || !searchQuery.filterQuery) return productIds;