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

package/src/directors/ProductPricingDirector.ts

@@ -16,9 +16,9 @@ export type ProductPricingContext =
       currencyCode: string;
       countryCode: string;
       quantity: number;
-      discounts?: OrderDiscount[];
+      discounts: OrderDiscount[];
       order?: Order;
-      product?: Product;
+      product: Product;
       configuration?: ProductConfiguration[];
       user?: User;
     }
@@ -59,21 +59,21 @@ export const ProductPricingDirector: IProductPricingDirector<any> = {
       const order = await modules.orders.findOrder({
         orderId: item.orderId,
       });
-      const user = await modules.users.findUserById(order.userId);
+      const user = await modules.users.findUserById(order!.userId);
       const discounts = await modules.orders.discounts.findOrderDiscounts({
         orderId: item.orderId,
       });
 
       return {
         ...unchainedAPI,
-        countryCode: order.countryCode,
+        countryCode: order!.countryCode,
         currencyCode,
         discounts,
-        order,
-        product,
+        order: order!,
+        product: product!,
         quantity,
         configuration: item.configuration,
-        user,
+        user: user!,
       };
     }
 

package/src/directors/ProductPricingSheet.ts

@@ -33,7 +33,7 @@ export interface IProductPricingSheet extends IPricingSheet<ProductPricingCalcul
     meta?: any;
   }) => void;
 
-  unitPrice: (params?: { useNetPrice: boolean }) => Price;
+  unitPrice: (params: { useNetPrice?: boolean }) => Price;
 }
 
 export const ProductPricingSheet = (
@@ -99,7 +99,8 @@ export const ProductPricingSheet = (
           category: ProductPricingRowCategory.Discount,
           discountId: explicitDiscountId,
         })
-        .map(({ discountId }) => discountId);
+        .map(({ discountId }) => discountId)
+        .filter(Boolean) as string[];
 
       return [...new Set(discountIds)]
         .map((discountId) => {
@@ -116,7 +117,7 @@ export const ProductPricingSheet = (
             currencyCode: basePricingSheet.currencyCode,
           };
         })
-        .filter(Boolean);
+        .filter(Boolean) as { discountId: string; amount: number; currencyCode: string }[];
     },
   };
 

package/src/directors/QuotationAdapter.ts

@@ -10,7 +10,7 @@ export interface QuotationContext {
 }
 
 export interface QuotationAdapterActions {
-  configurationError: () => QuotationError;
+  configurationError: () => QuotationError | null;
   isManualProposalRequired: () => Promise<boolean>;
   isManualRequestVerificationRequired: () => Promise<boolean>;
   quote: () => Promise<QuotationProposal>;
@@ -20,7 +20,7 @@ export interface QuotationAdapterActions {
 
   transformItemConfiguration: (
     params: QuotationItemConfiguration,
-  ) => Promise<QuotationItemConfiguration>;
+  ) => Promise<QuotationItemConfiguration | null>;
 }
 
 export type IQuotationAdapter = IBaseAdapter & {

package/src/directors/QuotationDirector.ts

@@ -65,7 +65,7 @@ export const QuotationDirector: IQuotationDirector = {
               ...error,
             },
           );
-          return null;
+          return true;
         }
       },
 
@@ -77,7 +77,7 @@ export const QuotationDirector: IQuotationDirector = {
           logger.error('QuotationDirector -> Error while checking if is manual proposal required', {
             ...error,
           });
-          return null;
+          return true;
         }
       },
 

package/src/directors/WarehousingAdapter.ts

@@ -16,14 +16,14 @@ export enum WarehousingError {
 }
 
 export interface WarehousingAdapterActions {
-  configurationError: () => WarehousingError;
+  configurationError: () => WarehousingError | null;
   isActive: () => boolean;
   stock: (referenceDate: Date) => Promise<number>;
   productionTime: (quantityToProduce: number) => Promise<number>;
   commissioningTime: (quantity: number) => Promise<number>;
   tokenize: () => Promise<Omit<TokenSurrogate, 'userId' | 'productId' | 'orderPositionId'>[]>;
-  tokenMetadata: (chainTokenId: string, referenceDate: Date) => Promise<any>;
-  isInvalidateable: (chainTokenId: string, referenceDate: Date) => Promise<boolean>;
+  tokenMetadata: (tokenSerialNumber: string, referenceDate: Date) => Promise<any>;
+  isInvalidateable: (tokenSerialNumber: string, referenceDate: Date) => Promise<boolean>;
 }
 
 export interface WarehousingContext {
@@ -34,7 +34,6 @@ export interface WarehousingContext {
   referenceDate?: Date;
   locale?: Intl.Locale;
   order?: Order;
-  warehousingProviderId?: string;
   orderPosition?: OrderPosition;
 }
 

package/src/directors/WarehousingDirector.ts

@@ -28,13 +28,13 @@ export interface WarehousingInterface {
 export type IWarehousingDirector = IBaseDirector<IWarehousingAdapter> & {
   tokenMetadata: (
     virtualProviders: WarehousingProvider[],
-    warehousingContext: WarehousingContext & { token: { chainTokenId: string } },
+    warehousingContext: WarehousingContext & { token: { tokenSerialNumber: string } },
     unchainedAPI,
   ) => Promise<any>;
 
   isInvalidateable: (
     virtualProviders: WarehousingProvider[],
-    warehousingContext: WarehousingContext & { token: { chainTokenId: string } },
+    warehousingContext: WarehousingContext & { token: { tokenSerialNumber: string } },
     unchainedAPI,
   ) => Promise<any>;
 
@@ -43,13 +43,13 @@ export type IWarehousingDirector = IBaseDirector<IWarehousingAdapter> & {
     warehousingContext: WarehousingContext,
     unchainedAPI: { modules: Modules },
   ) => Promise<{
-    configurationError: () => WarehousingError;
+    configurationError: () => WarehousingError | null;
     isActive: () => boolean;
     estimatedStock: () => Promise<EstimatedStock>;
     estimatedDispatch: () => Promise<EstimatedDispatch>;
     tokenize: () => Promise<TokenSurrogate[]>;
-    tokenMetadata: (chainTokenId: string) => Promise<any>;
-    isInvalidateable: (chainTokenId: string) => Promise<boolean>;
+    tokenMetadata: (tokenSerialNumber: string) => Promise<any>;
+    isInvalidateable: (tokenSerialNumber: string) => Promise<boolean>;
   }>;
 };
 
@@ -81,9 +81,9 @@ export const WarehousingDirector: IWarehousingDirector = {
       try {
         const { quantity } = context;
         const stock = await adapter.stock(referenceDate);
-        const notInStockQuantity = Math.max(quantity - stock, 0);
+        const notInStockQuantity = Math.max((quantity || 1) - stock, 0);
         const productionTime = await adapter.productionTime(notInStockQuantity);
-        const commissioningTime = await adapter.commissioningTime(quantity);
+        const commissioningTime = await adapter.commissioningTime(quantity || 1);
         return Math.max(commissioningTime + productionTime, 0);
       } catch (error) {
         logger.error(error);
@@ -130,10 +130,7 @@ export const WarehousingDirector: IWarehousingDirector = {
 
           const warehousingThroughputTime = await throughputTime(referenceDate);
           if (!Number.isFinite(warehousingThroughputTime)) {
-            return {
-              shipping: null,
-              earliestDelivery: null,
-            };
+            return {};
           }
 
           // Calculate shipping date
@@ -141,12 +138,12 @@ export const WarehousingDirector: IWarehousingDirector = {
           const shipping = new Date(shippingTimestamp);
 
           // Calculate earliest delivery date
-          const actions = await DeliveryDirector.actions(deliveryProvider, context, unchainedAPI);
+          const actions = await DeliveryDirector.actions(deliveryProvider!, context, unchainedAPI);
           const deliveryThroughputTime =
             await actions.estimatedDeliveryThroughput(warehousingThroughputTime);
           const earliestDelivery = Number.isFinite(deliveryThroughputTime)
-            ? new Date(shippingTimestamp + deliveryThroughputTime)
-            : null;
+            ? new Date(shippingTimestamp + deliveryThroughputTime!)
+            : undefined;
 
           return {
             shipping,
@@ -158,10 +155,10 @@ export const WarehousingDirector: IWarehousingDirector = {
         }
       },
 
-      tokenMetadata: async (chainTokenId) => {
+      tokenMetadata: async (tokenSerialNumber) => {
         try {
           const referenceDate = getReferenceDate(context);
-          const tokenMetadata = await adapter.tokenMetadata(chainTokenId, referenceDate);
+          const tokenMetadata = await adapter.tokenMetadata(tokenSerialNumber, referenceDate);
           return tokenMetadata;
         } catch (error) {
           logger.error(error);
@@ -169,10 +166,10 @@ export const WarehousingDirector: IWarehousingDirector = {
         }
       },
 
-      isInvalidateable: async (chainTokenId) => {
+      isInvalidateable: async (tokenSerialNumber) => {
         try {
           const referenceDate = getReferenceDate(context);
-          const isInvalidateable = await adapter.isInvalidateable(chainTokenId, referenceDate);
+          const isInvalidateable = await adapter.isInvalidateable(tokenSerialNumber, referenceDate);
           return isInvalidateable;
         } catch (error) {
           logger.error(error);
@@ -187,9 +184,9 @@ export const WarehousingDirector: IWarehousingDirector = {
           return tokens.map((token) => {
             return {
               ...token,
-              userId: order.userId,
-              productId: orderPosition.productId,
-              orderPositionId: orderPosition._id,
+              userId: order!.userId,
+              productId: orderPosition!.productId,
+              orderPositionId: orderPosition!._id,
             };
           });
         } catch (error) {
@@ -211,7 +208,7 @@ export const WarehousingDirector: IWarehousingDirector = {
       );
       const isActive = await currentDirector.isActive();
       if (isActive) {
-        return currentDirector.tokenMetadata(warehousingContext.token.chainTokenId);
+        return currentDirector.tokenMetadata(warehousingContext.token.tokenSerialNumber);
       }
       return null;
     }, Promise.resolve(null));
@@ -228,7 +225,7 @@ export const WarehousingDirector: IWarehousingDirector = {
       );
       const isActive = await currentDirector.isActive();
       if (isActive) {
-        return currentDirector.isInvalidateable(warehousingContext.token.chainTokenId);
+        return currentDirector.isInvalidateable(warehousingContext.token.tokenSerialNumber);
       }
       return null;
     }, Promise.resolve(null));

package/src/directors/WorkerAdapter.ts

@@ -2,7 +2,7 @@ import { BaseAdapter, IBaseAdapter } from '@unchainedshop/utils';
 import { WorkResult } from '@unchainedshop/core-worker';
 import { ModuleOptions, Modules } from '../modules.js';
 import { Services } from '../services/index.js';
-import { BulkImporter } from '../bulk-importer/createBulkImporter.js';
+import { BulkImporter } from '../bulk-importer/index.js';
 
 export type IWorkerAdapter<Input, Output> = IBaseAdapter & {
   type: string;
@@ -26,6 +26,6 @@ export const WorkerAdapter: Omit<IWorkerAdapter<any, void>, 'key' | 'label' | 't
   external: false,
 
   async doWork() {
-    return { success: false, result: null };
+    return { success: false };
   },
 };

package/src/directors/WorkerDirector.ts

@@ -13,7 +13,7 @@ export type WorkScheduleConfiguration = Pick<
 > & {
   type: string;
   input?: (workData: Omit<WorkData, 'input'>) => Promise<Record<string, any> | null>;
-  schedule: ScheduleData;
+  schedule?: ScheduleData;
   scheduleId?: string;
 };
 
@@ -24,7 +24,7 @@ export type IWorkerDirector = IBaseDirector<IWorkerAdapter<any, any>> & {
   configureAutoscheduling: (workScheduleConfiguration: WorkScheduleConfiguration) => void;
   getAutoSchedules: () => [string, WorkScheduleConfiguration][];
   doWork: (work: Work, unchainedAPI) => Promise<WorkResult>;
-  processNextWork: (unchainedAPI: { modules: Modules }, workerId?: string) => Promise<Work>;
+  processNextWork: (unchainedAPI: { modules: Modules }, workerId?: string) => Promise<Work | null>;
 };
 
 const AutoScheduleMap = new Map<string, WorkScheduleConfiguration>();
@@ -36,7 +36,7 @@ const baseDirector = BaseDirector<IWorkerAdapter<any, any>>('WorkerDirector', {
 export const WorkerDirector: IWorkerDirector = {
   ...baseDirector,
 
-  getActivePluginTypes: ({ external } = { external: null }) => {
+  getActivePluginTypes: ({ external } = {}) => {
     return WorkerDirector.getAdapters()
       .filter((adapter) => {
         if (external === null || external === undefined) return true;
@@ -55,8 +55,7 @@ export const WorkerDirector: IWorkerDirector = {
   },
 
   disableAutoscheduling: (type) => {
-    const config = AutoScheduleMap.get(type);
-    AutoScheduleMap.set(type, { ...config, schedule: null });
+    AutoScheduleMap.delete(type);
   },
 
   unregisterAdapter: (key) => {
@@ -110,7 +109,7 @@ export const WorkerDirector: IWorkerDirector = {
     }
   },
 
-  processNextWork: async (unchainedAPI: { modules: Modules }, workerId?: string): Promise<Work> => {
+  processNextWork: async (unchainedAPI: { modules: Modules }, workerId?: string) => {
     const adapters = WorkerDirector.getAdapters();
 
     const allocationMap = await unchainedAPI.modules.worker.allocationMap();

package/src/modules.ts

@@ -87,7 +87,7 @@ const initModules = async (
   }: {
     db: mongodb.Db;
     migrationRepository: MigrationRepository<unknown>;
-    options?: ModuleOptions;
+    options: ModuleOptions;
   },
   customModules: Record<
     string,

package/src/services/activateEnrollment.ts

@@ -6,12 +6,12 @@ import { addMessageService } from './addMessage.js';
 export async function activateEnrollmentService(this: Modules, enrollment: Enrollment) {
   if (enrollment.status === EnrollmentStatus.TERMINATED) return enrollment;
 
-  let updatedEnrollment = await this.enrollments.updateStatus(enrollment._id, {
+  let updatedEnrollment = (await this.enrollments.updateStatus(enrollment._id, {
     status: EnrollmentStatus.ACTIVE,
     info: 'activated manually',
-  });
+  })) as Enrollment;
 
-  updatedEnrollment = await processEnrollmentService.bind(this)(updatedEnrollment);
+  updatedEnrollment = (await processEnrollmentService.bind(this)(updatedEnrollment)) as Enrollment;
 
   const user = await this.users.findUserById(enrollment.userId);
   const locale = this.users.userLocale(user);
@@ -19,8 +19,8 @@ export async function activateEnrollmentService(this: Modules, enrollment: Enrol
   await addMessageService.bind(this)('ENROLLMENT_STATUS', {
     reason: 'status_change',
     locale: locale.baseName,
-    enrollmentId: updatedEnrollment._id,
+    enrollmentId: updatedEnrollment!._id,
   });
 
-  return updatedEnrollment;
+  return updatedEnrollment!;
 }

package/src/services/calculateDiscountTotal.ts

@@ -20,19 +20,19 @@ export async function calculateDiscountTotalService(
 
   // Delivery discounts
   const orderDelivery = await this.orders.deliveries.findDelivery({
-    orderDeliveryId: order.deliveryId,
+    orderDeliveryId: order.deliveryId!,
   });
   const orderDeliveryDiscountSum = DeliveryPricingSheet({
-    calculation: orderDelivery.calculation || [],
+    calculation: orderDelivery?.calculation || [],
     currencyCode: order.currencyCode,
   }).total({ category: DeliveryPricingRowCategory.Discount, discountId: orderDiscountId });
 
   // Payment discounts
   const orderPayment = await this.orders.payments.findOrderPayment({
-    orderPaymentId: order.paymentId,
+    orderPaymentId: order.paymentId!,
   });
   const orderPaymentDiscountSum = PaymentPricingSheet({
-    calculation: orderPayment.calculation || [],
+    calculation: orderPayment?.calculation || [],
     currencyCode: order.currencyCode,
   }).total({ category: PaymentPricingRowCategory.Discount, discountId: orderDiscountId });
 

package/src/services/checkoutOrder.ts

@@ -3,6 +3,7 @@ import { Modules } from '../modules.js';
 import { nextUserCartService } from './nextUserCart.js';
 import { validateOrderService } from './validateOrder.js';
 import { processOrderService } from './processOrder.js';
+import { User } from '@unchainedshop/core-users';
 
 export async function checkoutOrderService(
   this: Modules,
@@ -15,6 +16,7 @@ export async function checkoutOrderService(
   },
 ) {
   const order = await this.orders.findOrder({ orderId });
+  if (!order) return null;
   if (order.status !== null) return order;
 
   await validateOrderService.bind(this)(order);
@@ -25,11 +27,14 @@ export async function checkoutOrderService(
     const processedOrder = await processOrderService.bind(this)(order, transactionContext);
 
     // After checkout, store last checkout information on user
-    await this.users.updateLastBillingAddress(processedOrder.userId, processedOrder.billingAddress);
-    await this.users.updateLastContact(processedOrder.userId, processedOrder.contact);
-
+    if (processedOrder.billingAddress) {
+      await this.users.updateLastBillingAddress(processedOrder.userId, processedOrder.billingAddress);
+    }
+    if (processedOrder.contact) {
+      await this.users.updateLastContact(processedOrder.userId, processedOrder.contact);
+    }
     // Then eventually build next cart
-    const user = await this.users.findUserById(processedOrder.userId);
+    const user = (await this.users.findUserById(processedOrder.userId)) as User;
     const locale = this.users.userLocale(user);
     await nextUserCartService.bind(this)({
       user,

package/src/services/createDownloadStream.ts

@@ -11,6 +11,7 @@ export async function createDownloadStreamService(
 ) {
   const fileAdapter = getFileAdapter();
   const file = await this.files.findFile({ fileId });
+  if (!file) return null;
   const stream = fileAdapter.createDownloadStream(file, { modules: this });
   return stream;
 }

package/src/services/createEnrollmentFromCheckout.ts

@@ -25,42 +25,44 @@ export async function createEnrollmentFromCheckoutService(
   const orderId = order._id;
 
   const payment = await this.orders.payments.findOrderPayment({
-    orderPaymentId: order.paymentId,
+    orderPaymentId: order.paymentId!,
   });
   const delivery = await this.orders.deliveries.findDelivery({
-    orderDeliveryId: order.deliveryId,
+    orderDeliveryId: order.deliveryId!,
   });
 
   const template = {
-    billingAddress: order.billingAddress,
-    contact: order.contact,
+    billingAddress: order.billingAddress!,
+    contact: order.contact!,
     countryCode: order.countryCode,
     currencyCode: order.currencyCode,
     delivery: {
-      deliveryProviderId: delivery.deliveryProviderId,
-      context: delivery.context,
+      deliveryProviderId: delivery!.deliveryProviderId,
+      context: delivery!.context,
     },
     orderIdForFirstPeriod: orderId,
     payment: {
-      paymentProviderId: payment.paymentProviderId,
-      context: payment.context,
+      paymentProviderId: payment!.paymentProviderId,
+      context: payment!.context,
     },
     userId: order.userId,
     meta: order.context,
     ...context,
   };
 
-  return Promise.all(
-    items.map(async (item) => {
-      const enrollmentData = await EnrollmentDirector.transformOrderItemToEnrollment(item, template, {
-        modules: this,
-      });
+  return (
+    await Promise.all(
+      items.map(async (item) => {
+        const enrollmentData = await EnrollmentDirector.transformOrderItemToEnrollment(item, template, {
+          modules: this,
+        });
 
-      const enrollment = await this.enrollments.create(enrollmentData);
-      return await initializeEnrollmentService.bind(this)(enrollment, {
-        orderIdForFirstPeriod: enrollment.orderIdForFirstPeriod,
-        reason: 'new_enrollment',
-      });
-    }),
-  );
+        const enrollment = await this.enrollments.create(enrollmentData);
+        return await initializeEnrollmentService.bind(this)(enrollment, {
+          orderIdForFirstPeriod: enrollment.orderIdForFirstPeriod,
+          reason: 'new_enrollment',
+        });
+      }),
+    )
+  ).filter(Boolean) as Enrollment[];
 }

package/src/services/createManualOrderDiscount.ts

@@ -1,11 +1,11 @@
-import { Order, OrderDiscount } from '@unchainedshop/core-orders';
+import { Order } from '@unchainedshop/core-orders';
 import { OrderDiscountDirector } from '../directors/OrderDiscountDirector.js';
 import { Modules } from '../modules.js';
 
 export async function createManualOrderDiscountService(
   this: Modules,
   { order, code }: { code: string; order: Order },
-): Promise<OrderDiscount> {
+) {
   // Use an already existing discount if available!
   const spareDiscount = await this.orders.discounts.findSpareDiscount({ code });
   if (spareDiscount) {

package/src/services/createSignedURL.ts

@@ -9,6 +9,7 @@ export async function createSignedURLService(
   const preparedFileData = await fileUploadAdapter.createSignedURL(directoryName, fileName, {
     modules: this,
   });
+  if (!preparedFileData) throw new Error('Could not prepare signed URL');
   const fileData = getFileFromFileData(preparedFileData, meta);
   const fileId = await this.files.create(fileData);
   const file = await this.files.findFile({ fileId });

package/src/services/deleteUser.ts

@@ -9,9 +9,14 @@ export async function deleteUserService(this: Modules, { userId }: { userId: str
   await this.quotations.deleteRequestedUserQuotations(userId);
   await this.enrollments.deleteInactiveUserEnrollments(userId);
   await this.payment.paymentCredentials.deleteUserPaymentCredentials(userId);
-  await this.users.webAuthn.deleteUserWebAuthnCredentials(user.username);
 
-  const carts = await this.orders.findOrders({ userId, status: null });
+  if (user.username) {
+    await this.users.webAuthn.deleteUserWebAuthnCredentials(user.username);
+  }
+
+  const carts = (await this.orders.findOrders({ userId, includeCarts: true })).filter(
+    (c) => c.status === null,
+  );
 
   await Array.fromAsync(carts, async (userCart) => {
     await this.orders.positions.deleteOrderPositions(userCart?._id);

package/src/services/discountedEntities.ts

@@ -15,32 +15,32 @@ export async function discountedEntitiesService(
 ): Promise<OrderPricingDiscount[]> {
   // Delivery discounts
   const orderDelivery = await this.orders.deliveries.findDelivery({
-    orderDeliveryId: order.deliveryId,
+    orderDeliveryId: order.deliveryId!,
   });
 
   const deliveryPricingSheet = DeliveryPricingSheet({
-    calculation: orderDelivery.calculation || [],
+    calculation: orderDelivery!.calculation || [],
     currencyCode: order.currencyCode,
   });
   const orderDeliveryDiscounts = deliveryPricingSheet
     .discountPrices(orderDiscount._id)
     .map((discount) => ({
-      delivery: orderDelivery,
+      delivery: orderDelivery!,
       ...discount,
     }));
 
   // Payment discounts
   const orderPayment = await this.orders.payments.findOrderPayment({
-    orderPaymentId: order.paymentId,
+    orderPaymentId: order.paymentId!,
   });
   const paymentPricingSheet = PaymentPricingSheet({
-    calculation: orderPayment.calculation || [],
+    calculation: orderPayment!.calculation || [],
     currencyCode: order.currencyCode,
   });
   const orderPaymentDiscounts = paymentPricingSheet
     .discountPrices(orderDiscount._id)
     .map((discount) => ({
-      payment: orderPayment,
+      payment: orderPayment!,
       ...discount,
     }));
 

package/src/services/findOrInitCart.ts

@@ -1,5 +1,4 @@
 import { User } from '@unchainedshop/core-users';
-import { Order } from '@unchainedshop/core-orders';
 import { Modules } from '../modules.js';
 import { nextUserCartService } from './nextUserCart.js';
 
@@ -25,5 +24,5 @@ export async function findOrInitCartService(
     user,
     countryCode,
     forceCartCreation: true,
-  }) as Order;
+  });
 }

package/src/services/fullfillQuotation.ts

@@ -10,5 +10,5 @@ export async function fullfillQuotationService(this: Modules, quotation: Quotati
     info: JSON.stringify(info),
   });
 
-  return processQuotationService.bind(this)(updatedQuotation, {});
+  return processQuotationService.bind(this)(updatedQuotation!, {});
 }

package/src/services/generateOrderFromEnrollment.ts

@@ -0,0 +1,54 @@
+import { Modules } from '../modules.js';
+import { Enrollment, EnrollmentOrderPositionTemplate } from '@unchainedshop/core-enrollments';
+import { updateCalculationService } from './updateCalculation.js';
+import { checkoutOrderService } from './checkoutOrder.js';
+
+export async function generateOrderFromEnrollmentService(
+  this: Modules,
+  enrollment: Enrollment,
+  {
+    orderPositionTemplates,
+    orderContext,
+  }: {
+    orderPositionTemplates: EnrollmentOrderPositionTemplate[];
+    orderContext?: any;
+  },
+) {
+  if (!enrollment.payment || !enrollment.delivery) return null;
+
+  const order = await this.orders.create({
+    userId: enrollment.userId,
+    currencyCode: enrollment.currencyCode,
+    countryCode: enrollment.countryCode,
+    contact: enrollment.contact,
+    billingAddress: enrollment.billingAddress,
+    originEnrollmentId: enrollment._id,
+    context: orderContext,
+  });
+  const orderId = order._id;
+
+  await Promise.all(
+    orderPositionTemplates.map((orderPositionTemplate) =>
+      this.orders.positions.addProductItem({
+        ...orderPositionTemplate,
+        orderId: order._id,
+      }),
+    ),
+  );
+
+  const { paymentProviderId, context: paymentContext } = enrollment.payment;
+  if (paymentProviderId) {
+    await this.orders.setPaymentProvider(orderId, paymentProviderId);
+  }
+
+  const { deliveryProviderId, context: deliveryContext } = enrollment.delivery;
+  if (deliveryProviderId) {
+    await this.orders.setDeliveryProvider(orderId, deliveryProviderId);
+  }
+
+  await updateCalculationService.bind(this)(orderId);
+  return checkoutOrderService.bind(this)(order._id, {
+    deliveryContext,
+    paymentContext,
+  });
+}