@unchainedshop/core 3.1.11 → 4.0.0-rc.2

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

package/src/services/createEnrollmentFromCheckout.ts

@@ -12,16 +12,16 @@ export async function createEnrollmentFromCheckoutService(
     items,
     context,
   }: {
-    items: Array<{
+    items: {
       orderPosition: OrderPosition;
       product: Product;
-    }>;
+    }[];
     context: {
       paymentContext?: any;
       deliveryContext?: any;
     };
   },
-): Promise<Array<Enrollment>> {
+): Promise<Enrollment[]> {
   const orderId = order._id;
 
   const payment = await this.orders.payments.findOrderPayment({
@@ -35,7 +35,7 @@ export async function createEnrollmentFromCheckoutService(
     billingAddress: order.billingAddress,
     contact: order.contact,
     countryCode: order.countryCode,
-    currencyCode: order.currency,
+    currencyCode: order.currencyCode,
     delivery: {
       deliveryProviderId: delivery.deliveryProviderId,
       context: delivery.context,

package/src/services/discountedEntities.ts

@@ -12,7 +12,7 @@ export async function discountedEntitiesService(
   this: Modules,
   order: Order,
   orderDiscount: OrderDiscount,
-): Promise<Array<OrderPricingDiscount>> {
+): Promise<OrderPricingDiscount[]> {
   // Delivery discounts
   const orderDelivery = await this.orders.deliveries.findDelivery({
     orderDeliveryId: order.deliveryId,
@@ -20,7 +20,7 @@ export async function discountedEntitiesService(
 
   const deliveryPricingSheet = DeliveryPricingSheet({
     calculation: orderDelivery.calculation || [],
-    currency: order.currency,
+    currencyCode: order.currencyCode,
   });
   const orderDeliveryDiscounts = deliveryPricingSheet
     .discountPrices(orderDiscount._id)
@@ -35,7 +35,7 @@ export async function discountedEntitiesService(
   });
   const paymentPricingSheet = PaymentPricingSheet({
     calculation: orderPayment.calculation || [],
-    currency: order.currency,
+    currencyCode: order.currencyCode,
   });
   const orderPaymentDiscounts = paymentPricingSheet
     .discountPrices(orderDiscount._id)
@@ -51,7 +51,7 @@ export async function discountedEntitiesService(
   const orderPositionDiscounts = orderPositions.flatMap((orderPosition) =>
     ProductPricingSheet({
       calculation: orderPosition.calculation,
-      currency: order.currency,
+      currencyCode: order.currencyCode,
       quantity: orderPosition.quantity,
     })
       .discountPrices(orderDiscount._id)
@@ -64,7 +64,7 @@ export async function discountedEntitiesService(
   // order discounts
   const orderDiscounts = OrderPricingSheet({
     calculation: order.calculation || [],
-    currency: order.currency,
+    currencyCode: order.currencyCode,
   })
     .discountPrices(orderDiscount._id)
     .map((discount) => ({ order, ...discount }));

package/src/services/ercMetadata.ts

@@ -1,23 +1,15 @@
-import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
+import { TokenSurrogate, WarehousingProviderType } from '@unchainedshop/core-warehousing';
+import { Product } from '@unchainedshop/core-products';
 import { WarehousingDirector } from '../directors/WarehousingDirector.js';
 import { Modules } from '../modules.js';
 
 export async function ercMetadataService(
   this: Modules,
-  { productId, chainTokenId, locale }: { productId: string; chainTokenId: string; locale: Intl.Locale },
+  { product, token, locale }: { product: Product; token: TokenSurrogate; locale: Intl.Locale },
 ) {
-  const product = await this.products.findProduct({
-    productId,
-  });
-
-  const [token] = await this.warehousing.findTokens({
-    chainTokenId,
-    contractAddress: product?.tokenization?.contractAddress,
-  });
-
-  const virtualProviders = await this.warehousing.findProviders({
-    type: WarehousingProviderType.VIRTUAL,
-  });
+  const virtualProviders = (await this.warehousing.allProviders()).filter(
+    ({ type }) => type === WarehousingProviderType.VIRTUAL,
+  );
 
   return await WarehousingDirector.tokenMetadata(
     virtualProviders,

package/src/services/index.ts

@@ -62,9 +62,7 @@ function bindMethodsToModules(modules: Modules) {
   };
 }
 
-export interface ServiceInterface {
-  (this: Modules, ...args: any[]): Promise<any> | any;
-}
+export type ServiceInterface = (this: Modules, ...args: any[]) => Promise<any> | any;
 
 export type Bound<T extends ServiceInterface> = OmitThisParameter<T>;
 

package/src/services/loadFilters.ts

@@ -5,7 +5,7 @@ import { FilterDirector } from '../directors/FilterDirector.js';
 export async function loadFiltersService(
   this: Modules,
   searchQuery: SearchQuery,
-  { productIds, forceLiveCollection }: { productIds: Array<string>; forceLiveCollection: boolean },
+  { productIds, forceLiveCollection }: { productIds: string[]; forceLiveCollection: boolean },
 ) {
   const filterActions = await FilterDirector.actions({ searchQuery }, { modules: this });
   const filterSelector = await filterActions.transformFilterSelector(defaultFilterSelector(searchQuery));

package/src/services/migrateBookmarks.ts

@@ -14,7 +14,7 @@ export async function migrateBookmarksService(
     fromUserId: string;
     toUserId: string;
     shouldMerge: boolean;
-    countryContext: string;
+    countryCode: string;
   },
 ) {
   const fromBookmarks = await this.bookmarks.findBookmarks({ userId: fromUserId });

package/src/services/migrateOrderCart.ts

@@ -7,20 +7,20 @@ export async function migrateOrderCartsService(
     fromUserId,
     toUserId,
     shouldMerge,
-    countryContext,
+    countryCode,
   }: {
     fromUserId: string;
     toUserId: string;
     shouldMerge: boolean;
-    countryContext: string;
+    countryCode: string;
   },
 ) {
   const fromCart = await this.orders.cart({
-    countryCode: countryContext,
+    countryCode,
     userId: fromUserId,
   });
   const toCart = await this.orders.cart({
-    countryCode: countryContext,
+    countryCode,
     userId: toUserId,
   });
 

package/src/services/migrateUserData.ts

@@ -10,13 +10,13 @@ export async function migrateUserDataService(userIdBeforeLogin: string, userId:
     fromUserId: userIdBeforeLogin,
     toUserId: userId,
     shouldMerge: userSettings.mergeUserCartsOnLogin,
-    countryContext: userBeforeLogin?.lastLogin?.countryCode || user?.lastLogin?.countryCode,
+    countryCode: userBeforeLogin?.lastLogin?.countryCode || user?.lastLogin?.countryCode,
   });
 
   await migrateBookmarksService.bind(this)({
     fromUserId: userIdBeforeLogin,
     toUserId: userId,
     shouldMerge: userSettings.mergeUserCartsOnLogin,
-    countryContext: userBeforeLogin?.lastLogin?.countryCode || user?.lastLogin?.countryCode,
+    countryCode: userBeforeLogin?.lastLogin?.countryCode || user?.lastLogin?.countryCode,
   });
 }

package/src/services/nextUserCart.ts

@@ -30,12 +30,12 @@ export async function nextUserCartService(
 
   const countryObject = await this.countries.findCountry({ isoCode: countryCode });
   const currencies = await this.currencies.findCurrencies({ includeInactive: false });
-  const currency = resolveBestCurrency(countryObject.defaultCurrencyCode, currencies);
+  const currencyCode = resolveBestCurrency(countryObject.defaultCurrencyCode, currencies);
 
   const order = await this.orders.create({
     userId: user._id,
     orderNumber,
-    currency,
+    currencyCode,
     countryCode,
     billingAddress: user.lastBillingAddress || user.profile?.address,
     contact:

package/src/services/processOrder.ts

@@ -175,9 +175,10 @@ export async function processOrderService(
       );
       if (tokenizedItems.length > 0) {
         // Give virtual warehouse a chance to instantiate new virtual objects
-        const virtualProviders = await this.warehousing.findProviders({
-          type: WarehousingProviderType.VIRTUAL,
-        });
+        const virtualProviders = (await this.warehousing.allProviders()).filter(
+          ({ type }) => type === WarehousingProviderType.VIRTUAL,
+        );
+
         // It's very important to do this in a series and not in Promise.all
         // TODO: Actually, only createTokens should decide on the unique chainTokenId
         // and the tokens should be created with a distributed Lock to not assign the same id multiple times!

package/src/services/removeFiles.ts

@@ -1,7 +1,7 @@
 import { getFileAdapter } from '@unchainedshop/core-files';
 import { Modules } from '../modules.js';
 
-export async function removeFilesService(this: Modules, { fileIds }: { fileIds: Array<string> }) {
+export async function removeFilesService(this: Modules, { fileIds }: { fileIds: string[] }) {
   if (fileIds && typeof fileIds !== 'string' && !Array.isArray(fileIds))
     throw Error('Media id/s to be removed not provided as a string or array');
 
@@ -14,7 +14,7 @@ export async function removeFilesService(this: Modules, { fileIds }: { fileIds:
   try {
     await fileUploadAdapter.removeFiles(fileObjects, { modules: this });
   } catch (e) {
-    console.warn(e); // eslint-disable-line
+    console.warn(e);
   }
 
   const fileIdsToDelete = fileObjects.map((f) => f._id).filter(Boolean);

package/src/services/simulateProductDispatching.ts

@@ -1,4 +1,3 @@
-import { DeliveryProvider } from '@unchainedshop/core-delivery';
 import { Modules } from '../modules.js';
 import { supportedWarehousingProvidersService } from './supportedWarehousingProviders.js';
 import { Product } from '@unchainedshop/core-products';
@@ -9,19 +8,19 @@ import { WarehousingProvider } from '@unchainedshop/core-warehousing';
 export async function simulateProductDispatchingService(
   this: Modules,
   {
-    deliveryProviders,
     product,
     quantity,
     referenceDate,
   }: {
     product: Product;
-    deliveryProviders: DeliveryProvider[];
     quantity?: number;
     referenceDate?: Date;
   },
 ) {
+  const deliveryProviders = await this.delivery.allProviders();
+
   return deliveryProviders.reduce<
-    Promise<Array<WarehousingContext & EstimatedDispatch & { warehousingProvider: WarehousingProvider }>>
+    Promise<(WarehousingContext & EstimatedDispatch & { warehousingProvider: WarehousingProvider })[]>
   >(async (oldResult, deliveryProvider) => {
     const result = await oldResult;
 

package/src/services/simulateProductInventory.ts

@@ -1,4 +1,3 @@
-import { DeliveryProvider } from '@unchainedshop/core-delivery';
 import { Modules } from '../modules.js';
 import { supportedWarehousingProvidersService } from './supportedWarehousingProviders.js';
 import { Product } from '@unchainedshop/core-products';
@@ -9,17 +8,17 @@ import { WarehousingProvider } from '@unchainedshop/core-warehousing';
 export async function simulateProductInventoryService(
   this: Modules,
   {
-    deliveryProviders,
     product,
     referenceDate,
   }: {
     product: Product;
-    deliveryProviders: DeliveryProvider[];
     referenceDate?: Date;
   },
 ) {
+  const deliveryProviders = await this.delivery.allProviders();
+
   return deliveryProviders.reduce<
-    Promise<Array<WarehousingContext & EstimatedStock & { warehousingProvider: WarehousingProvider }>>
+    Promise<(WarehousingContext & EstimatedStock & { warehousingProvider: WarehousingProvider })[]>
   >(async (oldResult, deliveryProvider) => {
     const result = await oldResult;
 

package/src/services/simulateProductPricing.ts

@@ -8,10 +8,10 @@ export async function simulateProductPricingService(
   pricingContext: {
     product: Product;
     user: User;
-    country: string;
-    currency: string;
+    countryCode: string;
+    currencyCode: string;
     quantity: number;
-    configuration?: Array<ProductConfiguration>;
+    configuration?: ProductConfiguration[];
   },
 ) {
   const calculated = await ProductPricingDirector.rebuildCalculation(pricingContext, { modules: this });

package/src/services/supportedDeliveryProviders.ts

@@ -3,7 +3,7 @@ import { Modules } from '../modules.js';
 import { DeliveryContext, DeliveryDirector } from '../directors/index.js';
 
 export async function supportedDeliveryProvidersService(this: Modules, params: DeliveryContext) {
-  const allProviders = await this.delivery.findProviders({});
+  const allProviders = await this.delivery.allProviders();
 
   const providers = (
     await Promise.all(

package/src/services/supportedPaymentProviders.ts

@@ -4,7 +4,7 @@ import { PaymentContext } from '../directors/PaymentAdapter.js';
 import { Modules } from '../modules.js';
 
 export async function supportedPaymentProvidersService(this: Modules, params: PaymentContext) {
-  const allProviders = await this.payment.paymentProviders.findProviders({});
+  const allProviders = await this.payment.paymentProviders.allProviders();
 
   const providers = (
     await Promise.all(

package/src/services/supportedWarehousingProviders.ts

@@ -3,7 +3,7 @@ import { WarehousingContext, WarehousingDirector } from '../directors/index.js';
 import { Modules } from '../modules.js';
 
 export async function supportedWarehousingProvidersService(this: Modules, params: WarehousingContext) {
-  const allProviders = await this.warehousing.findProviders({});
+  const allProviders = await this.warehousing.allProviders();
 
   const providers = (
     await Promise.all(

package/src/services/updateCalculation.ts

@@ -73,10 +73,9 @@ export async function updateCalculationService(this: Modules, orderId: string) {
     orderPositions.map(async (orderPosition) => {
       const positionCalculation = await ProductPricingDirector.rebuildCalculation(
         {
-          currency: order.currency,
+          currencyCode: order.currencyCode,
           quantity: orderPosition.quantity,
           item: orderPosition,
-          configuration: orderPosition.configuration,
         },
         { modules: this },
       );
@@ -90,7 +89,7 @@ export async function updateCalculationService(this: Modules, orderId: string) {
   if (orderDelivery) {
     const deliveryCalculation = await DeliveryPricingDirector.rebuildCalculation(
       {
-        currency: order.currency,
+        currencyCode: order.currencyCode,
         item: orderDelivery,
       },
       { modules: this },
@@ -106,7 +105,7 @@ export async function updateCalculationService(this: Modules, orderId: string) {
   if (orderPayment) {
     const paymentCalculation = await PaymentPricingDirector.rebuildCalculation(
       {
-        currency: order.currency,
+        currencyCode: order.currencyCode,
         item: orderPayment,
       },
       { modules: this },
@@ -121,7 +120,7 @@ export async function updateCalculationService(this: Modules, orderId: string) {
   });
 
   const calculation = await OrderPricingDirector.rebuildCalculation(
-    { currency: order.currency, order, orderPositions, orderDelivery, orderPayment },
+    { currencyCode: order.currencyCode, order, orderPositions, orderDelivery, orderPayment },
     { modules: this },
   );
 

package/src/services/updateScheduling.ts

@@ -41,7 +41,7 @@ export async function updateSchedulingService(
             delivery: deliveryProvider,
             order,
             userId,
-            country: countryCode,
+            countryCode,
             referenceDate: order.ordered,
             quantity: orderPosition.quantity,
           };
@@ -60,5 +60,5 @@ export async function updateSchedulingService(
 
       return this.orders.positions.updateScheduling(orderPosition._id, scheduling);
     }),
-  )) as Array<OrderPosition>;
+  )) as OrderPosition[];
 }