@unchainedshop/core 3.1.10 → 4.0.0-rc.2

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;

package/src/directors/IntervalWorker.ts

@@ -0,0 +1,54 @@
+import later, { ScheduleData } from '@breejs/later';
+import { BaseWorker, IWorker } from './BaseWorker.js';
+
+const { NODE_ENV } = process.env;
+
+export interface IntervalWorkerParams {
+  workerId?: string;
+  batchCount?: number;
+  schedule?: ScheduleData;
+}
+
+const defaultSchedule = later.parse.text(
+  NODE_ENV !== 'production' ? 'every 2 seconds' : 'every 30 seconds',
+);
+
+export const scheduleToInterval = (schedule: ScheduleData) => {
+  const referenceDate = new Date(1000);
+  const [one, two] = later.schedule(schedule).next(2, referenceDate) as Date[];
+  const diff = new Date(two).getTime() - new Date(one).getTime();
+  return Math.min(1000 * 60 * 60, diff); // at least once every hour!
+};
+
+export const IntervalWorker: IWorker<IntervalWorkerParams> = {
+  ...BaseWorker,
+
+  key: 'shop.unchained.worker.cron',
+  label: 'Allocates work on fixed intervals with native node setInterval',
+  version: '1.0.0',
+  type: 'CRON',
+
+  actions: ({ workerId, batchCount = 0, schedule = defaultSchedule }, unchainedAPI) => {
+    const baseWorkerActions = BaseWorker.actions({ workerId, worker: IntervalWorker }, unchainedAPI);
+
+    const intervalDelay = scheduleToInterval(schedule);
+    let intervalHandle: NodeJS.Timeout;
+
+    return {
+      ...baseWorkerActions,
+
+      start() {
+        intervalHandle = setInterval(() => {
+          baseWorkerActions.process({
+            maxWorkItemCount: batchCount,
+            referenceDate: IntervalWorker.getFloorDate(),
+          });
+        }, intervalDelay);
+      },
+
+      stop() {
+        clearInterval(intervalHandle);
+      },
+    };
+  },
+};

package/src/directors/MessagingDirector.ts

@@ -1,4 +1,4 @@
-export type EmailTemplateType = {
+export interface EmailTemplateType {
   type: 'EMAIL';
   input: {
     from: string;
@@ -7,7 +7,7 @@ export type EmailTemplateType = {
     subject: string;
     text: string;
     html?: string;
-    attachments?: Array<
+    attachments?: (
       | { filename: string; path: string }
       | {
           filename: string;
@@ -16,28 +16,28 @@ export type EmailTemplateType = {
           encoding: string;
         }
       | { href: string; filename: string }
-    >;
+    )[];
   };
-};
+}
 
-export type SMSTemplateType = {
+export interface SMSTemplateType {
   type: 'SMS';
   input: {
     from: string;
     to: string;
     text: string;
   };
-};
+}
 
-export type ArbitraryTemplateType = {
+export interface ArbitraryTemplateType {
   type: string;
   input: any;
-};
+}
 
-export type TemplateResolver<T = { [x: string]: any }> = (
+export type TemplateResolver<T = Record<string, any>> = (
   params: { template: string } & T,
   unchainedAPI,
-) => Promise<Array<EmailTemplateType | SMSTemplateType | ArbitraryTemplateType>>;
+) => Promise<(EmailTemplateType | SMSTemplateType | ArbitraryTemplateType)[]>;
 
 const TemplateResolvers = new Map<string, TemplateResolver>();
 

package/src/directors/OrderPricingAdapter.ts

@@ -17,11 +17,11 @@ import { User } from '@unchainedshop/core-users';
 import { Modules } from '../modules.js';
 
 export interface OrderPricingAdapterContext extends BasePricingAdapterContext {
-  currency?: string;
-  discounts: Array<OrderDiscount>;
+  currencyCode?: string;
+  discounts: OrderDiscount[];
   order: Order;
   orderDelivery: OrderDelivery;
-  orderPositions: Array<OrderPosition>;
+  orderPositions: OrderPosition[];
   orderPayment: OrderPayment;
   user: User;
 }
@@ -44,9 +44,9 @@ export const OrderPricingAdapter: IOrderPricingAdapter = {
 
   actions: (params) => {
     const { context } = params;
-    const { currency } = context;
+    const { currencyCode } = context;
     const baseActions = basePricingAdapter.actions(params);
-    const resultSheet = OrderPricingSheet({ currency });
+    const resultSheet = OrderPricingSheet({ currencyCode });
 
     return {
       ...baseActions,

package/src/directors/OrderPricingDirector.ts

@@ -11,10 +11,10 @@ import {
 import { Order, OrderDelivery, OrderPayment, OrderPosition } from '@unchainedshop/core-orders';
 
 export interface OrderPricingContext {
-  currency: string;
+  currencyCode: string;
   order: Order;
   orderDelivery: OrderDelivery;
-  orderPositions: Array<OrderPosition>;
+  orderPositions: OrderPosition[];
   orderPayment: OrderPayment;
 }
 
@@ -45,7 +45,7 @@ export const OrderPricingDirector: IOrderPricingDirector<any> = {
 
   buildPricingContext: async (context, unchainedAPI) => {
     const { modules } = unchainedAPI;
-    const { order, currency } = context;
+    const { order, currencyCode } = context;
 
     const user = await modules.users.findUserById(order.userId);
     const discounts = await modules.orders.discounts.findOrderDiscounts({
@@ -54,8 +54,8 @@ export const OrderPricingDirector: IOrderPricingDirector<any> = {
 
     return {
       ...unchainedAPI,
-      country: order.countryCode,
-      currency,
+      countryCode: order.countryCode,
+      currencyCode,
       discounts,
       order,
       orderDelivery: context.orderDelivery,
@@ -68,7 +68,7 @@ export const OrderPricingDirector: IOrderPricingDirector<any> = {
   calculationSheet(pricingContext, calculation) {
     return OrderPricingSheet({
       calculation,
-      currency: pricingContext.currency,
+      currencyCode: pricingContext.currencyCode,
     });
   },
 };

package/src/directors/OrderPricingSheet.ts

@@ -112,7 +112,7 @@ export const OrderPricingSheet = (
 
       return {
         amount: Math.round(useNetPrice ? netAmount : netAmount + taxAmount),
-        currency: this.currency,
+        currencyCode: this.currencyCode,
       };
     },
 
@@ -136,7 +136,7 @@ export const OrderPricingSheet = (
           return {
             discountId,
             amount: Math.round(amount),
-            currency: basePricingSheet.currency,
+            currencyCode: basePricingSheet.currencyCode,
           };
         })
         .filter(Boolean);

package/src/directors/PaymentAdapter.ts

@@ -10,10 +10,10 @@ export enum PaymentError {
   WRONG_CREDENTIALS = 'WRONG_CREDENTIALS',
 }
 
-export type ChargeResult = {
+export interface ChargeResult {
   transactionId?: string;
   [key: string]: any;
-};
+}
 
 export type PaymentChargeActionResult = ChargeResult & {
   credentials?: {

package/src/directors/PaymentPricingAdapter.ts

@@ -18,13 +18,13 @@ export interface PaymentPricingCalculation extends PricingCalculation {
   rate?: number;
 }
 export interface PaymentPricingAdapterContext extends BasePricingAdapterContext {
-  country?: string;
+  countryCode?: string;
   currency?: string;
   user: User;
   orderPayment: OrderPayment;
   order: Order;
   provider: PaymentProvider;
-  discounts: Array<OrderDiscount>;
+  discounts: OrderDiscount[];
 }
 
 export type IPaymentPricingSheet = IPricingSheet<PaymentPricingCalculation> & {
@@ -67,9 +67,9 @@ export const PaymentPricingAdapter: IPricingAdapter<
 
   actions: (params) => {
     const { context } = params;
-    const { currency } = context.order;
+    const { currencyCode } = context.order;
     const baseActions = basePricingAdapter.actions(params);
-    const resultSheet = PaymentPricingSheet({ currency });
+    const resultSheet = PaymentPricingSheet({ currencyCode });
 
     return {
       ...baseActions,

package/src/directors/PaymentPricingDirector.ts

@@ -13,15 +13,15 @@ import { User } from '@unchainedshop/core-users';
 
 export type PaymentPricingContext =
   | {
-      country?: string;
-      currency?: string;
+      countryCode?: string;
+      currencyCode?: string;
       user: User;
       order: Order;
       provider: PaymentProvider;
       providerContext?: any;
     }
   | {
-      currency: string;
+      currencyCode: string;
       item: OrderPayment;
     };
 
@@ -47,7 +47,7 @@ export const PaymentPricingDirector: IPaymentPricingDirector<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,
       });
@@ -61,8 +61,8 @@ export const PaymentPricingDirector: IPaymentPricingDirector<any> = {
 
       return {
         ...unchainedAPI,
-        country: order.countryCode,
-        currency,
+        countryCode: order.countryCode,
+        currencyCode,
         order,
         provider,
         user,
@@ -74,8 +74,8 @@ export const PaymentPricingDirector: IPaymentPricingDirector<any> = {
 
     return {
       ...unchainedAPI,
-      country: context.country,
-      currency: context.currency,
+      countryCode: context.countryCode,
+      currencyCode: context.currencyCode,
       order: context.order,
       provider: context.provider,
       user: context.user,
@@ -88,7 +88,7 @@ export const PaymentPricingDirector: IPaymentPricingDirector<any> = {
   calculationSheet(pricingContext, calculation) {
     return PaymentPricingSheet({
       calculation,
-      currency: pricingContext.currency,
+      currencyCode: pricingContext.currencyCode,
     });
   },
 };

package/src/directors/PaymentPricingSheet.ts

@@ -80,7 +80,7 @@ export const PaymentPricingSheet = (
           return {
             discountId,
             amount: Math.round(amount),
-            currency: basePricingSheet.currency,
+            currencyCode: basePricingSheet.currencyCode,
           };
         })
         .filter(Boolean);

package/src/directors/ProductDiscountConfiguration.ts

@@ -10,7 +10,7 @@ type ResolvedConfiguration = {
 export type PriceConfigurationResolver = (
   product: Product,
   quantity: number,
-  configuration: Array<ProductConfiguration>,
+  configuration: ProductConfiguration[],
 ) => ResolvedConfiguration | null;
 
 export interface ProductDiscountConfiguration extends ResolvedConfiguration {

package/src/directors/ProductPricingAdapter.ts

@@ -12,11 +12,11 @@ import { Modules } from '../modules.js';
 import { User } from '@unchainedshop/core-users';
 
 export interface ProductPricingAdapterContext extends BasePricingAdapterContext {
-  country: string;
-  currency: string;
+  countryCode: string;
+  currencyCode: string;
   product: Product;
   quantity: number;
-  configuration: Array<ProductConfiguration>;
+  configuration: ProductConfiguration[];
   order?: Order;
   user?: User;
 }
@@ -39,9 +39,9 @@ export const ProductPricingAdapter: IProductPricingAdapter = {
 
   actions: (params) => {
     const { context } = params;
-    const { currency, quantity } = context;
+    const { currencyCode, quantity } = context;
     const baseActions = basePricingAdapter.actions(params);
-    const resultSheet = ProductPricingSheet({ currency, quantity });
+    const resultSheet = ProductPricingSheet({ currencyCode, quantity });
 
     return {
       ...baseActions,

package/src/directors/ProductPricingDirector.ts

@@ -13,17 +13,17 @@ import {
 
 export type ProductPricingContext =
   | {
-      currency: string;
+      currencyCode: string;
+      countryCode: string;
       quantity: number;
-      country?: string;
-      discounts?: Array<OrderDiscount>;
+      discounts?: OrderDiscount[];
       order?: Order;
       product?: Product;
-      configuration?: Array<ProductConfiguration>;
+      configuration?: ProductConfiguration[];
       user?: User;
     }
   | {
-      currency: string;
+      currencyCode: string;
       quantity: number;
       item: OrderPosition;
     };
@@ -48,7 +48,7 @@ export const ProductPricingDirector: IProductPricingDirector<any> = {
 
   async buildPricingContext(context, unchainedAPI) {
     const { modules } = unchainedAPI;
-    const { quantity = 1, currency } = context;
+    const { quantity = 1, currencyCode } = context;
 
     if ('item' in context) {
       const { item } = context;
@@ -66,8 +66,8 @@ export const ProductPricingDirector: IProductPricingDirector<any> = {
 
       return {
         ...unchainedAPI,
-        country: order.countryCode,
-        currency,
+        countryCode: order.countryCode,
+        currencyCode,
         discounts,
         order,
         product,
@@ -79,8 +79,8 @@ export const ProductPricingDirector: IProductPricingDirector<any> = {
 
     return {
       ...unchainedAPI,
-      country: context.country,
-      currency,
+      countryCode: context.countryCode,
+      currencyCode,
       discounts: [],
       order: context.order,
       product: context.product,
@@ -93,7 +93,7 @@ export const ProductPricingDirector: IProductPricingDirector<any> = {
   calculationSheet(pricingContext, calculation) {
     return ProductPricingSheet({
       calculation,
-      currency: pricingContext.currency,
+      currencyCode: pricingContext.currencyCode,
       quantity: pricingContext.quantity ?? 1,
     });
   },