@unchainedshop/core 4.0.0-rc.16 → 4.0.0-rc.18

package/src/services/index.ts

@@ -45,6 +45,7 @@ import { simulateProductDispatchingService } from './simulateProductDispatching.
 import { simulateProductInventoryService } from './simulateProductInventory.js';
 import { findOrInitCartService } from './findOrInitCart.js';
 import { addMessageService } from './addMessage.js';
+import { generateOrderFromEnrollmentService } from './generateOrderFromEnrollment.js';
 
 // Auto-Inject Unchained API as last parameter
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy
@@ -135,6 +136,9 @@ export default function initServices(modules: Modules, customServices: CustomSer
       createEnrollmentFromCheckout: createEnrollmentFromCheckoutService as Bound<
         typeof createEnrollmentFromCheckoutService
       >,
+      generateOrderFromEnrollment: generateOrderFromEnrollmentService as Bound<
+        typeof generateOrderFromEnrollmentService
+      >,
       processEnrollment: processOrderService as Bound<typeof processOrderService>,
       initializeEnrollment: initializeEnrollmentService as Bound<typeof initializeEnrollmentService>,
       activateEnrollment: activateEnrollmentService as Bound<typeof activateEnrollmentService>,

package/src/services/initCartProviders.ts

@@ -14,7 +14,7 @@ export async function initCartProvidersService(this: Modules, order: Order) {
   });
 
   const orderDelivery = await this.orders.deliveries.findDelivery({
-    orderDeliveryId: updatedOrder.deliveryId,
+    orderDeliveryId: updatedOrder.deliveryId!,
   });
   const deliveryProviderId = orderDelivery?.deliveryProviderId;
 
@@ -45,7 +45,7 @@ export async function initCartProvidersService(this: Modules, order: Order) {
   });
 
   const orderPayment = await this.orders.payments.findOrderPayment({
-    orderPaymentId: updatedOrder.paymentId,
+    orderPaymentId: updatedOrder.paymentId!,
   });
   const paymentProviderId = orderPayment?.paymentProviderId;
 

package/src/services/initializeEnrollment.ts

@@ -9,20 +9,27 @@ export async function initializeEnrollmentService(
   enrollment: Enrollment,
   params: { orderIdForFirstPeriod?: string; reason: string },
 ) {
-  const director = await EnrollmentDirector.actions({ enrollment }, { modules: this });
+  const product = await this.products.findProduct({
+    productId: enrollment.productId,
+  });
+
+  const director = await EnrollmentDirector.actions(
+    { enrollment, product: product! },
+    { modules: this },
+  );
   const period = await director.nextPeriod();
 
   let updatedEnrollment = enrollment;
   if (period && (params.orderIdForFirstPeriod || period.isTrial)) {
-    updatedEnrollment = await this.enrollments.addEnrollmentPeriod(enrollment._id, {
+    updatedEnrollment = (await this.enrollments.addEnrollmentPeriod(enrollment._id, {
       ...period,
       orderId: params.orderIdForFirstPeriod,
-    });
+    })) as Enrollment;
   }
 
   const processedEnrollment = await processEnrollmentService.bind(this)(updatedEnrollment);
   const user = await this.users.findUserById(enrollment.userId);
-  const locale = this.users.userLocale(user);
+  const locale = this.users.userLocale(user!);
 
   await addMessageService.bind(this)('ENROLLMENT_STATUS', {
     reason: 'status_change',

package/src/services/linkFileService.ts

@@ -6,11 +6,13 @@ export async function linkFileService(
   { fileId, size, type }: { fileId: string; size?: number; type?: string },
 ) {
   const file = await this.files.findFile({ fileId });
+  if (!file) return null;
+
   await this.files.update(file._id, {
     size: size || file.size,
     type: type || file.type,
-    expires: null,
   });
+  await this.files.unexpire(file._id);
   if (file?.expires) {
     const callback = FileDirector.getFileUploadCallback(file.path);
     if (callback) {

package/src/services/nextUserCart.ts

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

package/src/services/processEnrollment.ts

@@ -2,9 +2,18 @@ import { Enrollment, EnrollmentStatus } from '@unchainedshop/core-enrollments';
 import { Modules } from '../modules.js';
 import { EnrollmentDirector } from '../core-index.js';
 
-const findNextStatus = async (enrollment: Enrollment, modules: Modules): Promise<EnrollmentStatus> => {
+const findNextStatus = async (
+  enrollment: Enrollment,
+  modules: Modules,
+): Promise<EnrollmentStatus | null> => {
   let status = enrollment.status;
-  const director = await EnrollmentDirector.actions({ enrollment }, { modules });
+  const product = await modules.products.findProduct({
+    productId: enrollment.productId,
+  });
+
+  if (!product) throw new Error('Product not found for enrollment');
+
+  const director = await EnrollmentDirector.actions({ enrollment, product }, { modules });
 
   if (status === EnrollmentStatus.INITIAL || status === EnrollmentStatus.PAUSED) {
     if (await director.isValidForActivation()) {
@@ -30,8 +39,11 @@ export async function processEnrollmentService(this: Modules, enrollment: Enroll
     // status = await findNextStatus(nextEnrollment, unchainedAPI);
   }
 
-  return this.enrollments.updateStatus(enrollment._id, {
-    status,
-    info: 'enrollment processed',
-  });
+  if (status) {
+    return this.enrollments.updateStatus(enrollment._id, {
+      status,
+      info: 'enrollment processed',
+    }) as Promise<Enrollment>;
+  }
+  return enrollment;
 }

package/src/services/processOrder.ts

@@ -4,11 +4,12 @@ import {
   OrderDeliveryStatus,
   OrderPayment,
   OrderPaymentStatus,
+  OrderPosition,
   OrderStatus,
 } from '@unchainedshop/core-orders';
 import { Modules } from '../modules.js';
 import { createEnrollmentFromCheckoutService } from './createEnrollmentFromCheckout.js';
-import { ProductTypes } from '@unchainedshop/core-products';
+import { Product, ProductTypes } from '@unchainedshop/core-products';
 import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
 import { WarehousingDirector, DeliveryDirector, PaymentDirector } from '../directors/index.js';
 import { fullfillQuotationService } from './fullfillQuotation.js';
@@ -24,10 +25,12 @@ const isAutoConfirmationEnabled = async (
   modules: Modules,
 ) => {
   if (orderPayment.status !== OrderPaymentStatus.PAID) {
-    const provider = await modules.payment.paymentProviders.findProvider({
+    const paymentProvider = await modules.payment.paymentProviders.findProvider({
       paymentProviderId: orderPayment.paymentProviderId,
     });
-    const actions = await PaymentDirector.actions(provider, {}, { modules });
+    if (!paymentProvider)
+      throw new Error('Payment provider not found: ' + orderPayment.paymentProviderId);
+    const actions = await PaymentDirector.actions(paymentProvider, {}, { modules });
     if (!actions.isPayLaterAllowed()) return false;
   }
 
@@ -35,6 +38,8 @@ const isAutoConfirmationEnabled = async (
     const deliveryProvider = await modules.delivery.findProvider({
       deliveryProviderId: orderDelivery.deliveryProviderId,
     });
+    if (!deliveryProvider)
+      throw new Error('Delivery provider not found: ' + orderDelivery.deliveryProviderId);
     const director = await DeliveryDirector.actions(deliveryProvider, {}, { modules });
     if (!director.isAutoReleaseAllowed()) return false;
   }
@@ -56,14 +61,18 @@ const findNextStatus = async (
     return status;
   }
 
-  const orderPayment = await modules.orders.payments.findOrderPayment({
-    orderPaymentId: order.paymentId,
-  });
+  const orderPayment =
+    order.paymentId &&
+    (await modules.orders.payments.findOrderPayment({
+      orderPaymentId: order.paymentId,
+    }));
   if (!orderPayment) return status;
 
-  const orderDelivery = await modules.orders.deliveries.findDelivery({
-    orderDeliveryId: order.deliveryId,
-  });
+  const orderDelivery =
+    order.deliveryId &&
+    (await modules.orders.deliveries.findDelivery({
+      orderDeliveryId: order.deliveryId,
+    }));
   if (!orderDelivery) return status;
 
   // Ok, we have a payment and a delivery and the correct status,
@@ -108,26 +117,18 @@ export async function processOrderService(
 
   if (nextStatus === OrderStatus.PENDING) {
     // auto charge during transition to pending
-    const orderPayment = await this.orders.payments.findOrderPayment({
-      orderPaymentId: order.paymentId,
-    });
-
     await PaymentDirector.chargeOrderPayment(
-      orderPayment,
+      order,
       { userId: order.userId, transactionContext: paymentContext },
       { modules: this },
     );
-
     nextStatus = await findNextStatus(nextStatus, order, this);
   }
 
   if (nextStatus === OrderStatus.REJECTED) {
     // auto cancel during transition to rejected
-    const orderPayment = await this.orders.payments.findOrderPayment({
-      orderPaymentId: order.paymentId,
-    });
     await PaymentDirector.cancelOrderPayment(
-      orderPayment,
+      order,
       { userId: order.userId, transactionContext: paymentContext },
       { modules: this },
     );
@@ -135,11 +136,8 @@ export async function processOrderService(
 
   if (nextStatus === OrderStatus.CONFIRMED) {
     // confirm pre-authorized payments
-    const orderPayment = await this.orders.payments.findOrderPayment({
-      orderPaymentId: order.paymentId,
-    });
     await PaymentDirector.confirmOrderPayment(
-      orderPayment,
+      order,
       { userId: order.userId, transactionContext: paymentContext },
       { modules: this },
     );
@@ -147,27 +145,23 @@ export async function processOrderService(
       // we have to stop here shortly to complete the confirmation
       // before auto delivery is started, else we have no chance to create
       // numbers that are needed for delivery
-      order = await this.orders.updateStatus(orderId, {
+      order = (await this.orders.updateStatus(orderId, {
         status: OrderStatus.CONFIRMED,
         info: comment,
-      });
-
-      const orderDelivery = await this.orders.deliveries.findDelivery({
-        orderDeliveryId: order.deliveryId,
-      });
+      })) as Order;
 
       // TODO: What happens if this THROWS?
       // Tokenization would be skipped?
       // Enrollments will not be there?
       // Quotations would not fulfil?
-      await DeliveryDirector.sendOrderDelivery(orderDelivery, deliveryContext, { modules: this });
+      await DeliveryDirector.sendOrderDelivery(order, deliveryContext, { modules: this });
 
       const orderPositions = await this.orders.positions.findOrderPositions({ orderId });
       const mappedProductOrderPositions = await Promise.all(
         orderPositions.map(async (orderPosition) => {
-          const product = await this.products.findProduct({
+          const product = (await this.products.findProduct({
             productId: orderPosition.productId,
-          });
+          })) as Product;
           return {
             orderPosition,
             product,
@@ -176,7 +170,8 @@ export async function processOrderService(
       );
       const tokenizedItems = mappedProductOrderPositions.filter(
         (item) => item.product?.type === ProductTypes.TokenizedProduct,
-      );
+      ) as { orderPosition: OrderPosition; product: Product }[];
+
       if (tokenizedItems.length > 0) {
         // Give virtual warehouse a chance to instantiate new virtual objects
         const virtualProviders = (await this.warehousing.allProviders()).filter(
@@ -184,7 +179,7 @@ export async function processOrderService(
         );
 
         // 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
+        // TODO: Actually, only createTokens should decide on the unique tokenSerialNumber
         // and the tokens should be created with a distributed Lock to not assign the same id multiple times!
         for (const { orderPosition, product } of tokenizedItems) {
           for (const virtualProvider of virtualProviders) {
@@ -225,12 +220,14 @@ export async function processOrderService(
       // Quotations: If we came here, the checkout succeeded, so we can fullfill underlying quotations
       const quotationItems = mappedProductOrderPositions.filter(
         (item) => item.orderPosition.quotationId,
-      );
+      ) as { orderPosition: OrderPosition & { quotationId: string }; product: Product }[];
+
       await Promise.all(
         quotationItems.map(async ({ orderPosition }) => {
           const quotation = await this.quotations.findQuotation({
             quotationId: orderPosition.quotationId,
           });
+          if (!quotation) return; // TODO: What happens then?
           await fullfillQuotationService.bind(this)(quotation, {
             orderId,
             orderPositionId: orderPosition._id,
@@ -242,5 +239,5 @@ export async function processOrderService(
     nextStatus = await findNextStatus(nextStatus, order, this);
   }
 
-  return this.orders.updateStatus(order._id, { status: nextStatus, info: comment });
+  return (await this.orders.updateStatus(order._id, { status: nextStatus, info: comment })) as Order;
 }

package/src/services/processQuotation.ts

@@ -34,30 +34,30 @@ export async function processQuotationService(
     await director.submitRequest(params.quotationContext);
   }
 
-  quotation = await this.quotations.findQuotation({ quotationId });
+  quotation = (await this.quotations.findQuotation({ quotationId })) as Quotation;
   nextStatus = await findNextStatus(quotation, this);
   if (nextStatus !== QuotationStatus.PROCESSING) {
     await director.verifyRequest(params.quotationContext);
   }
 
-  quotation = await this.quotations.findQuotation({ quotationId });
+  quotation = (await this.quotations.findQuotation({ quotationId })) as Quotation;
   nextStatus = await findNextStatus(quotation, this);
   if (nextStatus === QuotationStatus.REJECTED) {
     await director.rejectRequest(params.quotationContext);
   }
 
-  quotation = await this.quotations.findQuotation({ quotationId });
+  quotation = (await this.quotations.findQuotation({ quotationId })) as Quotation;
   nextStatus = await findNextStatus(quotation, this);
   if (nextStatus === QuotationStatus.PROPOSED) {
     const proposal = await director.quote();
-    quotation = await this.quotations.updateProposal(quotation._id, proposal);
+    quotation = (await this.quotations.updateProposal(quotation._id, proposal)) as Quotation;
     nextStatus = await findNextStatus(quotation, this);
   }
 
-  const updatedQuotation = await this.quotations.updateStatus(quotation._id, {
+  const updatedQuotation = (await this.quotations.updateStatus(quotation._id, {
     status: nextStatus,
     info: 'quotation processed',
-  });
+  })) as Quotation;
 
   const user = await this.users.findUserById(updatedQuotation.userId);
   const locale = this.users.userLocale(user);

package/src/services/proposeQuotation.ts

@@ -9,10 +9,10 @@ export async function proposeQuotationService(
 ) {
   if (quotation.status !== QuotationStatus.PROCESSING) return quotation;
 
-  const updatedQuotation = await this.quotations.updateStatus(quotation._id, {
+  const updatedQuotation = (await this.quotations.updateStatus(quotation._id, {
     status: QuotationStatus.PROPOSED,
     info: 'proposed manually',
-  });
+  })) as Quotation;
 
   return processQuotationService.bind(this)(updatedQuotation, { quotationContext });
 }

package/src/services/registerPaymentCredentials.ts

@@ -1,4 +1,3 @@
-import { PaymentCredentials } from '@unchainedshop/core-payment';
 import { PaymentContext } from '../directors/PaymentAdapter.js';
 import { PaymentDirector } from '../directors/PaymentDirector.js';
 import { Modules } from '../modules.js';
@@ -7,24 +6,23 @@ export async function registerPaymentCredentialsService(
   this: Modules,
   paymentProviderId: string,
   paymentContext: PaymentContext,
-): Promise<PaymentCredentials> {
+) {
   const paymentProvider = await this.payment.paymentProviders.findProvider({
     paymentProviderId,
   });
+
+  if (!paymentProvider) return null;
+
   const actions = await PaymentDirector.actions(paymentProvider, paymentContext, { modules: this });
   const registration = await actions.register();
 
   if (!registration) return null;
 
-  const paymentCredentialsId = await this.payment.paymentCredentials.upsertCredentials({
+  const paymentCredentials = await this.payment.paymentCredentials.upsertCredentials({
     userId: paymentContext.userId,
     paymentProviderId,
     ...registration,
   });
 
-  return this.payment.paymentCredentials.findPaymentCredential({
-    paymentCredentialsId,
-    userId: paymentContext.userId,
-    paymentProviderId,
-  });
+  return paymentCredentials;
 }

package/src/services/rejectQuotation.ts

@@ -9,10 +9,10 @@ export async function rejectQuotationService(
 ) {
   if (quotation.status === QuotationStatus.FULLFILLED) return quotation;
 
-  const updatedQuotation = await this.quotations.updateStatus(quotation._id, {
+  const updatedQuotation = (await this.quotations.updateStatus(quotation._id, {
     status: QuotationStatus.REJECTED,
     info: 'rejected manually',
-  });
+  })) as Quotation;
 
   return processQuotationService.bind(this)(updatedQuotation, { quotationContext });
 }

package/src/services/removeProduct.ts

@@ -8,7 +8,7 @@ export async function removeProductService(
 ): Promise<boolean> {
   const product = await this.products.findProduct({ productId });
 
-  switch (product.status) {
+  switch (product?.status) {
     case ProductStatus.ACTIVE:
       await this.products.unpublish(product);
     // falls through
@@ -16,7 +16,7 @@ export async function removeProductService(
     case ProductStatus.DRAFT:
       {
         await this.bookmarks.deleteByProductId(productId);
-        await this.assortments.products.delete(productId);
+        await this.assortments.products.deleteMany({ productId });
         await this.products.removeAllAssignmentsAndBundleItems(productId);
         const orderIdsToRecalculate =
           await this.orders.positions.removeProductByIdFromAllOpenPositions(productId);
@@ -29,7 +29,7 @@ export async function removeProductService(
       }
       break;
     default:
-      throw new Error(`Invalid status', ${product.status}`);
+      throw new Error(`Invalid status: ${product?.status}`);
   }
 
   return true;

package/src/services/searchAssortments.ts

@@ -29,7 +29,7 @@ export async function searchAssortmentsService(
     filterSelector,
     assortmentSelector,
     sortStage,
-    forceLiveCollection,
+    forceLiveCollection: !!forceLiveCollection,
     locale,
   };
 

package/src/services/searchProducts.ts

@@ -32,7 +32,7 @@ export async function searchProductsService(
     filterSelector,
     productSelector,
     sortStage,
-    forceLiveCollection,
+    forceLiveCollection: !!forceLiveCollection,
     locale,
   };
 

package/src/services/simulateProductDispatching.ts

@@ -13,7 +13,7 @@ export async function simulateProductDispatchingService(
     referenceDate,
   }: {
     product: Product;
-    quantity?: number;
+    quantity: number;
     referenceDate?: Date;
   },
 ) {

package/src/services/simulateProductInventory.ts

@@ -1,7 +1,7 @@
 import { Modules } from '../modules.js';
 import { supportedWarehousingProvidersService } from './supportedWarehousingProviders.js';
 import { Product } from '@unchainedshop/core-products';
-import { EstimatedStock, WarehousingDirector } from '../directors/WarehousingDirector.js';
+import { WarehousingDirector } from '../directors/WarehousingDirector.js';
 import { WarehousingContext } from '../directors/WarehousingAdapter.js';
 import { WarehousingProvider } from '@unchainedshop/core-warehousing';
 
@@ -18,7 +18,11 @@ export async function simulateProductInventoryService(
   const deliveryProviders = await this.delivery.allProviders();
 
   return deliveryProviders.reduce<
-    Promise<(WarehousingContext & EstimatedStock & { warehousingProvider: WarehousingProvider })[]>
+    Promise<
+      (WarehousingContext & { quantity?: number } & {
+        warehousingProvider: WarehousingProvider;
+      })[]
+    >
   >(async (oldResult, deliveryProvider) => {
     const result = await oldResult;
 
@@ -31,7 +35,7 @@ export async function simulateProductInventoryService(
 
     const mappedWarehousingProviders = await Promise.all(
       warehousingProviders.map(async (warehousingProvider) => {
-        const warehousingContext: WarehousingContext = {
+        const warehousingContext = {
           deliveryProvider,
           product,
           referenceDate,

package/src/services/simulateProductPricing.ts

@@ -2,16 +2,19 @@ import { Product, ProductConfiguration } from '@unchainedshop/core-products';
 import { ProductPricingDirector } from '../core-index.js';
 import { User } from '@unchainedshop/core-users';
 import { Modules } from '../modules.js';
+import { Order, OrderDiscount } from '@unchainedshop/core-orders';
 
 export async function simulateProductPricingService(
   this: Modules,
   pricingContext: {
-    product: Product;
-    user: User;
-    countryCode: string;
     currencyCode: string;
+    countryCode: string;
     quantity: number;
+    discounts: OrderDiscount[];
+    order?: Order;
+    product: Product;
     configuration?: ProductConfiguration[];
+    user?: User;
   },
 ) {
   const calculated = await ProductPricingDirector.rebuildCalculation(pricingContext, { modules: this });

package/src/services/updateCalculation.ts

@@ -1,4 +1,10 @@
-import { OrderDiscountTrigger } from '@unchainedshop/core-orders';
+import {
+  OrderDelivery,
+  OrderDiscountTrigger,
+  OrderPayment,
+  Order,
+  OrderPosition,
+} from '@unchainedshop/core-orders';
 import { initCartProvidersService } from './initCartProviders.js';
 import { Modules } from '../modules.js';
 import { updateSchedulingService } from './updateScheduling.js';
@@ -12,6 +18,7 @@ import {
 
 export async function updateCalculationService(this: Modules, orderId: string) {
   let order = await this.orders.findOrder({ orderId });
+  if (!order) throw new Error('Order not found');
 
   // Don't recalculate orders, only carts
   if (order.status !== null) return order;
@@ -27,15 +34,17 @@ export async function updateCalculationService(this: Modules, orderId: string) {
       const Adapter = OrderDiscountDirector.getAdapter(orderDiscount.discountKey);
       if (!Adapter) return null;
       const adapter = await Adapter.actions({
-        context: { order, orderDiscount, code: orderDiscount.code, modules: this },
+        context: { order: order!, orderDiscount, code: orderDiscount.code, modules: this },
       });
 
-      const isValid =
-        orderDiscount.trigger === OrderDiscountTrigger.SYSTEM
-          ? await adapter.isValidForSystemTriggering()
-          : await adapter.isValidForCodeTriggering({
-              code: orderDiscount.code,
-            });
+      let isValid = false;
+      if (orderDiscount.trigger === OrderDiscountTrigger.SYSTEM) {
+        isValid = await adapter.isValidForSystemTriggering();
+      } else if (orderDiscount.trigger === OrderDiscountTrigger.USER && orderDiscount.code) {
+        isValid = await adapter.isValidForCodeTriggering({
+          code: orderDiscount.code,
+        });
+      }
 
       if (!isValid) {
         if (orderDiscount.trigger === OrderDiscountTrigger.USER) {
@@ -52,14 +61,14 @@ export async function updateCalculationService(this: Modules, orderId: string) {
   });
 
   const currentDiscountKeys = cleanedDiscounts.map(({ discountKey }) => discountKey);
-  const director = await OrderDiscountDirector.actions({ order, code: null }, { modules: this });
+  const director = await OrderDiscountDirector.actions({ order }, { modules: this });
   const systemDiscounts = await director.findSystemDiscounts();
   await Promise.all(
     systemDiscounts
       .filter((key) => currentDiscountKeys.indexOf(key) === -1)
       .map(async (discountKey) =>
         this.orders.discounts.create({
-          orderId: order._id,
+          orderId: order!._id,
           discountKey,
           trigger: OrderDiscountTrigger.SYSTEM,
         }),
@@ -73,18 +82,21 @@ export async function updateCalculationService(this: Modules, orderId: string) {
     orderPositions.map(async (orderPosition) => {
       const positionCalculation = await ProductPricingDirector.rebuildCalculation(
         {
-          currencyCode: order.currencyCode,
+          currencyCode: order!.currencyCode,
           quantity: orderPosition.quantity,
           item: orderPosition,
         },
         { modules: this },
       );
-      return this.orders.positions.updateCalculation(orderPosition._id, positionCalculation);
+      return (await this.orders.positions.updateCalculation(
+        orderPosition._id,
+        positionCalculation,
+      )) as OrderPosition;
     }),
   );
 
   let orderDelivery = await this.orders.deliveries.findDelivery({
-    orderDeliveryId: order.deliveryId,
+    orderDeliveryId: order.deliveryId!,
   });
   if (orderDelivery) {
     const deliveryCalculation = await DeliveryPricingDirector.rebuildCalculation(
@@ -94,13 +106,13 @@ export async function updateCalculationService(this: Modules, orderId: string) {
       },
       { modules: this },
     );
-    orderDelivery = await this.orders.deliveries.updateCalculation(
+    orderDelivery = (await this.orders.deliveries.updateCalculation(
       orderDelivery._id,
       deliveryCalculation,
-    );
+    )) as OrderDelivery;
   }
   let orderPayment = await this.orders.payments.findOrderPayment({
-    orderPaymentId: order.paymentId,
+    orderPaymentId: order.paymentId!,
   });
   if (orderPayment) {
     const paymentCalculation = await PaymentPricingDirector.rebuildCalculation(
@@ -110,7 +122,10 @@ export async function updateCalculationService(this: Modules, orderId: string) {
       },
       { modules: this },
     );
-    orderPayment = await this.orders.payments.updateCalculation(orderPayment._id, paymentCalculation);
+    orderPayment = (await this.orders.payments.updateCalculation(
+      orderPayment._id,
+      paymentCalculation,
+    )) as OrderPayment;
   }
 
   orderPositions = await updateSchedulingService.bind(this)({
@@ -125,7 +140,7 @@ export async function updateCalculationService(this: Modules, orderId: string) {
   );
 
   if (JSON.stringify(order.calculation) !== JSON.stringify(calculation)) {
-    order = await this.orders.updateCalculationSheet(orderId, calculation);
+    order = (await this.orders.updateCalculationSheet(orderId, calculation)) as Order;
   }
 
   /*