@unchainedshop/core 4.0.0-rc.9 → 4.0.1

package/src/modules.ts

@@ -69,17 +69,17 @@ export interface ModuleOptions {
   assortments?: AssortmentsSettingsOptions;
   products?: ProductsSettingsOptions;
   delivery?: DeliverySettingsOptions;
+  payment?: PaymentSettingsOptions;
   filters?: FiltersSettingsOptions;
   enrollments?: EnrollmentsSettingsOptions;
   orders?: OrdersSettingsOptions;
   quotations?: QuotationsSettingsOptions;
   files?: FilesSettingsOptions;
-  payment?: PaymentSettingsOptions;
   worker?: WorkerSettingsOptions;
   users?: UserSettingsOptions;
 }
 
-const initModules = async (
+export default async function initModules(
   {
     db,
     migrationRepository,
@@ -87,7 +87,7 @@ const initModules = async (
   }: {
     db: mongodb.Db;
     migrationRepository: MigrationRepository<unknown>;
-    options?: ModuleOptions;
+    options: ModuleOptions;
   },
   customModules: Record<
     string,
@@ -95,7 +95,7 @@ const initModules = async (
       configure: (params: ModuleInput<any>) => any;
     }
   >,
-): Promise<Modules> => {
+): Promise<Modules> {
   const assortments = await configureAssortmentsModule({
     db,
     options: options.assortments,
@@ -154,6 +154,7 @@ const initModules = async (
   const products = await configureProductsModule({
     db,
     migrationRepository,
+    options: options.products,
   });
   const quotations = await configureQuotationsModule({
     db,
@@ -203,6 +204,4 @@ const initModules = async (
   }
 
   return modules;
-};
-
-export default initModules;
+}

package/src/services/activateEnrollment.ts

@@ -1,30 +1,26 @@
 import { Enrollment, EnrollmentStatus } from '@unchainedshop/core-enrollments';
 import { Modules } from '../modules.js';
 import { processEnrollmentService } from './processEnrollment.js';
+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);
 
-  await this.worker.addWork({
-    type: 'MESSAGE',
-    retries: 0,
-    input: {
-      reason: 'status_change',
-      locale: locale.baseName,
-      template: 'ENROLLMENT_STATUS',
-      enrollmentId: updatedEnrollment._id,
-    },
+  await addMessageService.bind(this)('ENROLLMENT_STATUS', {
+    reason: 'status_change',
+    locale: locale.baseName,
+    enrollmentId: updatedEnrollment!._id,
   });
 
-  return updatedEnrollment;
+  return updatedEnrollment!;
 }

package/src/services/addMessage.ts

@@ -0,0 +1,20 @@
+import { Work } from '@unchainedshop/core-worker';
+import { MessagingDirector } from '../core-index.js';
+import { Modules } from '../modules.js';
+
+export async function addMessageService<T = Record<string, any>>(
+  this: Modules,
+  template: string,
+  input: T,
+): Promise<Work | null> {
+  const templateResolver = MessagingDirector.getTemplate(template); // Validate template exists
+  if (!templateResolver) return null;
+  return this.worker.addWork({
+    type: 'MESSAGE',
+    input: {
+      template,
+      ...input,
+    },
+    retries: 0,
+  });
+}

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,15 +27,18 @@ 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,
-      countryCode: locale.region,
+      countryCode: locale?.region || processedOrder.countryCode,
     });
 
     return processedOrder;

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

package/src/services/index.ts

@@ -44,6 +44,8 @@ import { simulateProductPricingService } from './simulateProductPricing.js';
 import { simulateProductDispatchingService } from './simulateProductDispatching.js';
 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
@@ -134,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>,
@@ -156,6 +161,9 @@ export default function initServices(modules: Modules, customServices: CustomSer
     warehousing: {
       ercMetadata: ercMetadataService as Bound<typeof ercMetadataService>,
     },
+    worker: {
+      addMessage: addMessageService as Bound<typeof addMessageService>,
+    },
   };
 
   // This Proxy Binds all services to the Modules Object

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;
 
@@ -33,10 +33,9 @@ export async function initCartProvidersService(this: Modules, order: Order) {
       { modules: this },
     );
     if (defaultOrderDeliveryProvider) {
-      updatedOrder = await this.orders.setDeliveryProvider(
-        updatedOrder._id,
-        defaultOrderDeliveryProvider._id,
-      );
+      updatedOrder =
+        (await this.orders.setDeliveryProvider(updatedOrder._id, defaultOrderDeliveryProvider._id)) ||
+        updatedOrder;
     }
   }
 
@@ -46,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;
 
@@ -76,10 +75,9 @@ export async function initCartProvidersService(this: Modules, order: Order) {
     );
 
     if (defaultOrderPaymentProvider) {
-      updatedOrder = await this.orders.setPaymentProvider(
-        updatedOrder._id,
-        defaultOrderPaymentProvider._id,
-      );
+      updatedOrder =
+        (await this.orders.setPaymentProvider(updatedOrder._id, defaultOrderPaymentProvider._id)) ||
+        updatedOrder;
     }
   }
   return updatedOrder;

package/src/services/initializeEnrollment.ts

@@ -2,36 +2,39 @@ import { Enrollment } from '@unchainedshop/core-enrollments';
 import { EnrollmentDirector } from '../core-index.js';
 import { processEnrollmentService } from './processEnrollment.js';
 import { Modules } from '../modules.js';
+import { addMessageService } from './addMessage.js';
 
 export async function initializeEnrollmentService(
   this: Modules,
   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 this.worker.addWork({
-    type: 'MESSAGE',
-    retries: 0,
-    input: {
-      reason: params.reason || 'status_change',
-      locale: locale.baseName,
-      template: 'ENROLLMENT_STATUS',
-      enrollmentId: processedEnrollment._id,
-    },
+  await addMessageService.bind(this)('ENROLLMENT_STATUS', {
+    reason: 'status_change',
+    locale: locale.baseName,
+    enrollmentId: processedEnrollment._id,
   });
 
   return processedEnrollment;

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