@unchainedshop/core 3.1.13 → 4.0.0-rc.3

package/src/directors/IntervalWorker.ts

@@ -0,0 +1,75 @@
+import later, { ScheduleData } from '@breejs/later';
+import { BaseWorker, IWorker } from './BaseWorker.js';
+import { createLogger } from '@unchainedshop/logger';
+
+const { NODE_ENV } = process.env;
+
+const logger = createLogger('unchained:worker');
+
+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 nextDates = later.schedule(schedule).next(2, referenceDate) as Date[];
+
+  if (!nextDates || nextDates.length < 2) {
+    throw new Error('Schedule must produce at least 2 consecutive dates');
+  }
+
+  const [one, two] = nextDates;
+  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 = 10, schedule = defaultSchedule }, unchainedAPI) => {
+    const baseWorkerActions = BaseWorker.actions({ workerId, worker: IntervalWorker }, unchainedAPI);
+
+    const intervalDelay = scheduleToInterval(schedule);
+    let intervalHandle: NodeJS.Timeout | null = null;
+
+    return {
+      ...baseWorkerActions,
+
+      start() {
+        // Prevent multiple intervals from running
+        if (intervalHandle) {
+          return;
+        }
+
+        intervalHandle = setInterval(async () => {
+          try {
+            await baseWorkerActions.process({
+              maxWorkItemCount: batchCount,
+              referenceDate: IntervalWorker.getFloorDate(),
+            });
+          } catch (error) {
+            logger.error(error);
+          }
+        }, intervalDelay);
+      },
+
+      stop() {
+        if (intervalHandle) {
+          clearInterval(intervalHandle);
+          intervalHandle = null;
+        }
+      },
+    };
+  },
+};

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,
     });
   },

package/src/directors/ProductPricingSheet.test.ts

@@ -34,7 +34,7 @@ describe('ProductPricingSheet', () => {
 
   const pricingSheetParams = {
     calculation: calculations,
-    currency: 'CHF',
+    currencyCode: 'CHF',
     quantity: 2,
   };
   beforeEach(() => {
@@ -44,7 +44,7 @@ describe('ProductPricingSheet', () => {
   it('should return an object that implements the IProductPricingSheet interface', () => {
     assert(pricingSheet);
     assert.equal(pricingSheet.quantity, 2);
-    assert.equal(pricingSheet.currency, 'CHF');
+    assert.equal(pricingSheet.currencyCode, 'CHF');
     assert.equal(typeof pricingSheet.addItem, 'function');
     assert.equal(typeof pricingSheet.addDiscount, 'function');
     assert.equal(typeof pricingSheet.addTax, 'function');
@@ -63,22 +63,25 @@ describe('ProductPricingSheet', () => {
 
   describe('total()', () => {
     it('should return sum of all ProductPricingCalculations ', () => {
-      assert.deepEqual(pricingSheet.total(), { amount: 535, currency: 'CHF' });
-      assert.deepEqual(pricingSheet.total(), { amount: pricingSheet.gross(), currency: 'CHF' });
+      assert.deepEqual(pricingSheet.total(), { amount: 535, currencyCode: 'CHF' });
+      assert.deepEqual(pricingSheet.total(), { amount: pricingSheet.gross(), currencyCode: 'CHF' });
     });
 
     it('should return sum of all ProductPricingCalculations ', () => {
-      assert.deepEqual(pricingSheet.total({ useNetPrice: true }), { amount: 460, currency: 'CHF' });
+      assert.deepEqual(pricingSheet.total({ useNetPrice: true }), { amount: 460, currencyCode: 'CHF' });
       assert.deepEqual(pricingSheet.total({ useNetPrice: true }), {
         amount: pricingSheet.net(),
-        currency: 'CHF',
+        currencyCode: 'CHF',
       });
     });
 
     it('should return sum of all ProductPricingCalculations for the provided category ', () => {
-      assert.deepEqual(pricingSheet.total({ category: 'ITEM' }), { amount: 400, currency: 'CHF' });
-      assert.deepEqual(pricingSheet.total({ category: 'DISCOUNT' }), { amount: 60, currency: 'CHF' });
-      assert.deepEqual(pricingSheet.total({ category: 'TAX' }), { amount: 75, currency: 'CHF' });
+      assert.deepEqual(pricingSheet.total({ category: 'ITEM' }), { amount: 400, currencyCode: 'CHF' });
+      assert.deepEqual(pricingSheet.total({ category: 'DISCOUNT' }), {
+        amount: 60,
+        currencyCode: 'CHF',
+      });
+      assert.deepEqual(pricingSheet.total({ category: 'TAX' }), { amount: 75, currencyCode: 'CHF' });
     });
   });
 
@@ -106,21 +109,27 @@ describe('ProductPricingSheet', () => {
 
   describe('unitPrice', () => {
     it('should return the GROSS sum for a  product price useNetPrice:false', () => {
-      assert.deepEqual(pricingSheet.unitPrice({ useNetPrice: false }), { amount: 268, currency: 'CHF' });
+      assert.deepEqual(pricingSheet.unitPrice({ useNetPrice: false }), {
+        amount: 268,
+        currencyCode: 'CHF',
+      });
     });
 
     it('should return the NET sum for a product price when useNetPrice:true', () => {
-      assert.deepEqual(pricingSheet.unitPrice({ useNetPrice: true }), { amount: 230, currency: 'CHF' });
+      assert.deepEqual(pricingSheet.unitPrice({ useNetPrice: true }), {
+        amount: 230,
+        currencyCode: 'CHF',
+      });
     });
   });
 
   describe('discountPrices', () => {
     it('should return the sum of all discounts registered on the price sheet based on discountId', () => {
       assert.deepEqual(pricingSheet.discountPrices('for-all'), [
-        { amount: 40, currency: 'CHF', discountId: 'for-all' },
+        { amount: 40, currencyCode: 'CHF', discountId: 'for-all' },
       ]);
       assert.deepEqual(pricingSheet.discountPrices('special'), [
-        { amount: 20, currency: 'CHF', discountId: 'special' },
+        { amount: 20, currencyCode: 'CHF', discountId: 'special' },
       ]);
     });
 

package/src/directors/ProductPricingSheet.ts

@@ -89,7 +89,7 @@ export const ProductPricingSheet = (
       const amount = unitPriceParams?.useNetPrice ? this.net() : this.gross();
       return {
         amount: Math.round(amount / (this.quantity ?? 1)),
-        currency: this.currency,
+        currencyCode: this.currencyCode,
       };
     },
 
@@ -113,7 +113,7 @@ export const ProductPricingSheet = (
           return {
             discountId,
             amount: Math.round(amount),
-            currency: basePricingSheet.currency,
+            currencyCode: basePricingSheet.currencyCode,
           };
         })
         .filter(Boolean);

package/src/directors/QuotationAdapter.ts

@@ -5,9 +5,9 @@ import {
 } from '@unchainedshop/core-quotations';
 import { BaseAdapter, IBaseAdapter } from '@unchainedshop/utils';
 
-export type QuotationContext = {
+export interface QuotationContext {
   quotation?: Quotation;
-};
+}
 
 export interface QuotationAdapterActions {
   configurationError: () => QuotationError;

package/src/directors/WarehousingAdapter.ts

@@ -15,16 +15,16 @@ export enum WarehousingError {
   WRONG_CREDENTIALS = 'WRONG_CREDENTIALS',
 }
 
-export type WarehousingAdapterActions = {
+export interface WarehousingAdapterActions {
   configurationError: () => WarehousingError;
   isActive: () => boolean;
   stock: (referenceDate: Date) => Promise<number>;
   productionTime: (quantityToProduce: number) => Promise<number>;
   commissioningTime: (quantity: number) => Promise<number>;
-  tokenize: () => Promise<Array<Omit<TokenSurrogate, 'userId' | 'productId' | 'orderPositionId'>>>;
+  tokenize: () => Promise<Omit<TokenSurrogate, 'userId' | 'productId' | 'orderPositionId'>[]>;
   tokenMetadata: (chainTokenId: string, referenceDate: Date) => Promise<any>;
   isInvalidateable: (chainTokenId: string, referenceDate: Date) => Promise<boolean>;
-};
+}
 
 export interface WarehousingContext {
   deliveryProvider?: DeliveryProvider;

package/src/directors/WarehousingDirector.ts

@@ -12,10 +12,10 @@ import {
 } from '../directors/index.js';
 import { Modules } from '../modules.js';
 
-export type EstimatedDispatch = {
+export interface EstimatedDispatch {
   shipping?: Date;
   earliestDelivery?: Date;
-};
+}
 
 export type EstimatedStock = { quantity: number } | null;
 
@@ -47,7 +47,7 @@ export type IWarehousingDirector = IBaseDirector<IWarehousingAdapter> & {
     isActive: () => boolean;
     estimatedStock: () => Promise<EstimatedStock>;
     estimatedDispatch: () => Promise<EstimatedDispatch>;
-    tokenize: () => Promise<Array<TokenSurrogate>>;
+    tokenize: () => Promise<TokenSurrogate[]>;
     tokenMetadata: (chainTokenId: string) => Promise<any>;
     isInvalidateable: (chainTokenId: string) => Promise<boolean>;
   }>;

package/src/directors/WorkerDirector.ts

@@ -18,11 +18,11 @@ export type WorkScheduleConfiguration = Pick<
 };
 
 export type IWorkerDirector = IBaseDirector<IWorkerAdapter<any, any>> & {
-  getActivePluginTypes: (options?: { external?: boolean }) => Array<string>;
+  getActivePluginTypes: (options?: { external?: boolean }) => string[];
   getAdapterByType: (type: string) => IWorkerAdapter<any, any>;
   disableAutoscheduling: (scheduleId: string) => void;
   configureAutoscheduling: (workScheduleConfiguration: WorkScheduleConfiguration) => void;
-  getAutoSchedules: () => Array<[string, WorkScheduleConfiguration]>;
+  getAutoSchedules: () => [string, WorkScheduleConfiguration][];
   doWork: (work: Work, unchainedAPI) => Promise<WorkResult>;
   processNextWork: (unchainedAPI: { modules: Modules }, workerId?: string) => Promise<Work>;
 };

package/src/directors/index.ts

@@ -42,6 +42,10 @@ export * from './WarehousingAdapter.js';
 
 export * from './WorkerAdapter.js';
 export * from './WorkerDirector.js';
+export * from './EventListenerWorker.js';
+export * from './IntervalWorker.js';
+export * from './FailedRescheduler.js';
+export * from './BaseWorker.js';
 
 export * from './QuotationAdapter.js';
 export * from './QuotationDirector.js';

package/src/services/calculateDiscountTotal.ts

@@ -24,7 +24,7 @@ export async function calculateDiscountTotalService(
   });
   const orderDeliveryDiscountSum = DeliveryPricingSheet({
     calculation: orderDelivery.calculation || [],
-    currency: order.currency,
+    currencyCode: order.currencyCode,
   }).total({ category: DeliveryPricingRowCategory.Discount, discountId: orderDiscountId });
 
   // Payment discounts
@@ -33,7 +33,7 @@ export async function calculateDiscountTotalService(
   });
   const orderPaymentDiscountSum = PaymentPricingSheet({
     calculation: orderPayment.calculation || [],
-    currency: order.currency,
+    currencyCode: order.currencyCode,
   }).total({ category: PaymentPricingRowCategory.Discount, discountId: orderDiscountId });
 
   // Position discounts
@@ -43,7 +43,7 @@ export async function calculateDiscountTotalService(
   const orderPositionDiscounts = orderPositions.map((orderPosition) =>
     ProductPricingSheet({
       calculation: orderPosition.calculation || [],
-      currency: order.currency,
+      currencyCode: order.currencyCode,
       quantity: orderPosition.quantity,
     }).total({
       category: ProductPricingRowCategory.Discount,
@@ -54,7 +54,7 @@ export async function calculateDiscountTotalService(
   // order discounts
   const orderDiscountSum = OrderPricingSheet({
     calculation: order.calculation,
-    currency: order.currency,
+    currencyCode: order.currencyCode,
   }).total({ category: OrderPricingRowCategory.Discounts, discountId: orderDiscountId });
 
   const prices = [
@@ -66,6 +66,6 @@ export async function calculateDiscountTotalService(
   const amount = prices.reduce((oldValue, price) => oldValue + (price || 0), 0);
   return {
     amount,
-    currency: order.currency,
+    currencyCode: order.currencyCode,
   };
 }