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

package/src/module/configureOrdersModule-mutations.ts

@@ -9,28 +9,6 @@ import {
 import { Order, OrderStatus } from '../db/OrdersCollection.js';
 import { OrderPosition } from '../db/OrderPositionsCollection.js';
 
-export interface OrderMutations {
-  create: (doc: {
-    userId: string;
-    billingAddress?: Address;
-    contact?: Contact;
-    countryCode: string;
-    currencyCode: string;
-    orderNumber?: string;
-    originEnrollmentId?: string;
-  }) => Promise<Order>;
-
-  delete: (orderId: string) => Promise<number>;
-
-  setCartOwner: (params: { orderId: string; userId: string }) => Promise<void>;
-  moveCartPositions: (params: { fromOrderId: string; toOrderId: string }) => Promise<void>;
-
-  updateBillingAddress: (orderId: string, billingAddress: Address) => Promise<Order>;
-  updateContact: (orderId: string, contact: Contact) => Promise<Order>;
-  updateContext: (orderId: string, context: any) => Promise<Order>;
-  updateCalculationSheet: (orderId: string, calculation) => Promise<Order>;
-}
-
 const ORDER_EVENTS: string[] = [
   'ORDER_CREATE',
   'ORDER_REMOVE',
@@ -45,11 +23,28 @@ export const configureOrderModuleMutations = ({
 }: {
   Orders: mongodb.Collection<Order>;
   OrderPositions: mongodb.Collection<OrderPosition>;
-}): OrderMutations => {
+}) => {
   registerEvents(ORDER_EVENTS);
 
   return {
-    create: async ({ userId, orderNumber, currencyCode, countryCode, billingAddress, contact }) => {
+    create: async ({
+      userId,
+      orderNumber,
+      currencyCode,
+      countryCode,
+      billingAddress,
+      contact,
+      context,
+    }: {
+      userId: string;
+      billingAddress?: Address;
+      contact?: Contact;
+      countryCode: string;
+      currencyCode: string;
+      orderNumber?: string;
+      originEnrollmentId?: string;
+      context?: Record<string, any>;
+    }) => {
       const { insertedId: orderId } = await Orders.insertOne({
         _id: generateDbObjectId(),
         created: new Date(),
@@ -62,21 +57,23 @@ export const configureOrderModuleMutations = ({
         calculation: [],
         log: [],
         orderNumber,
+        context: context || {},
       });
 
-      const order = await Orders.findOne(generateDbFilterById(orderId), {});
+      const order = (await Orders.findOne(generateDbFilterById(orderId), {})) as Order;
 
       await emit('ORDER_CREATE', { order });
       return order;
     },
 
-    delete: async (orderId) => {
+    delete: async (orderId: string) => {
       const { deletedCount } = await Orders.deleteOne({ _id: orderId });
+      if (!deletedCount) return 0;
       await emit('ORDER_REMOVE', { orderId });
       return deletedCount;
     },
 
-    setCartOwner: async ({ orderId, userId }) => {
+    setCartOwner: async ({ orderId, userId }: { orderId: string; userId: string }) => {
       await Orders.updateOne(generateDbFilterById(orderId), {
         $set: {
           userId,
@@ -84,7 +81,13 @@ export const configureOrderModuleMutations = ({
       });
     },
 
-    moveCartPositions: async ({ fromOrderId, toOrderId }) => {
+    moveCartPositions: async ({
+      fromOrderId,
+      toOrderId,
+    }: {
+      fromOrderId: string;
+      toOrderId: string;
+    }) => {
       await OrderPositions.updateMany(
         { orderId: fromOrderId },
         {
@@ -95,7 +98,7 @@ export const configureOrderModuleMutations = ({
       );
     },
 
-    updateBillingAddress: async (orderId, billingAddress) => {
+    updateBillingAddress: async (orderId: string, billingAddress: Address) => {
       const selector = generateDbFilterById(orderId);
       const order = await Orders.findOneAndUpdate(
         selector,
@@ -107,12 +110,12 @@ export const configureOrderModuleMutations = ({
         },
         { returnDocument: 'after' },
       );
-
+      if (!order) return null;
       await emit('ORDER_UPDATE', { order, field: 'billingAddress' });
       return order;
     },
 
-    updateContact: async (orderId, contact) => {
+    updateContact: async (orderId: string, contact: Contact) => {
       const selector = generateDbFilterById(orderId);
       const order = await Orders.findOneAndUpdate(
         selector,
@@ -124,12 +127,12 @@ export const configureOrderModuleMutations = ({
         },
         { returnDocument: 'after' },
       );
-
+      if (!order) return null;
       await emit('ORDER_UPDATE', { order, field: 'contact' });
       return order;
     },
 
-    updateCalculationSheet: async (orderId, calculation) => {
+    updateCalculationSheet: async (orderId: string, calculation: any) => {
       const selector = generateDbFilterById(orderId);
       const order = await Orders.findOneAndUpdate(
         selector,
@@ -141,12 +144,12 @@ export const configureOrderModuleMutations = ({
         },
         { returnDocument: 'after' },
       );
-
+      if (!order) return null;
       await emit('ORDER_UPDATE', { order, field: 'calculation' });
       return order;
     },
 
-    updateContext: async (orderId, context) => {
+    updateContext: async (orderId: string, context: any) => {
       const selector = generateDbFilterById<Order>(orderId);
       selector.status = { $in: [null, OrderStatus.PENDING] };
 
@@ -165,12 +168,11 @@ export const configureOrderModuleMutations = ({
         },
         { returnDocument: 'after' },
       );
-
-      if (order) {
-        await emit('ORDER_UPDATE', { order, field: 'context' });
-        return order;
-      }
-      return null;
+      if (!order) return null;
+      await emit('ORDER_UPDATE', { order, field: 'context' });
+      return order;
     },
   };
 };
+
+export type OrderMutations = ReturnType<typeof configureOrderModuleMutations>;

package/src/module/configureOrdersModule-queries.ts

@@ -2,7 +2,6 @@ import { SortDirection, SortOption } from '@unchainedshop/utils';
 import { generateDbFilterById, buildSortOptions, mongodb } from '@unchainedshop/mongodb';
 import buildFindSelector from './buildFindSelector.js';
 import { Order, OrderQuery } from '../db/OrdersCollection.js';
-import { Document } from 'mongodb';
 
 export interface OrderReport {
   newCount: number;
@@ -18,8 +17,7 @@ export interface OrderStatisticsRecord {
     currency: string;
   };
 }
-
-interface OrderAggregateParams {
+export interface OrderAggregateParams {
   match?: Record<string, any>;
   matchAfterGroup?: Record<string, any>;
   project?: Record<string, any>;
@@ -44,7 +42,7 @@ export const configureOrdersModuleQueries = ({ Orders }: { Orders: mongodb.Colle
       countryCode?: string;
       orderNumber?: string;
       userId: string;
-    }): Promise<Order> => {
+    }) => {
       const selector: mongodb.Filter<Order> = {
         countryCode,
         status: { $eq: null },
@@ -76,7 +74,7 @@ export const configureOrdersModuleQueries = ({ Orders }: { Orders: mongodb.Colle
         orderNumber?: string;
       },
       options?: mongodb.FindOptions,
-    ): Promise<Order> => {
+    ) => {
       const selector = orderId ? generateDbFilterById(orderId) : { orderNumber };
       return Orders.findOne(selector, options);
     },
@@ -140,8 +138,8 @@ export const configureOrdersModuleQueries = ({ Orders }: { Orders: mongodb.Colle
       limit,
       addFields,
       pipeline,
-    }: OrderAggregateParams): Promise<Document[]> => {
-      const stages: Document[] = [];
+    }: OrderAggregateParams): Promise<mongodb.Document[]> => {
+      const stages: mongodb.Document[] = [];
       if (pipeline?.length) {
         return await Orders.aggregate(pipeline).toArray();
       }

package/src/module/configureOrdersModule.ts

@@ -6,37 +6,16 @@ import { OrderPaymentsCollection } from '../db/OrderPaymentsCollection.js';
 import { OrderPositionsCollection } from '../db/OrderPositionsCollection.js';
 import { OrdersCollection, Order, OrderStatus } from '../db/OrdersCollection.js';
 import { ordersSettings, OrdersSettingsOptions } from '../orders-settings.js';
-import {
-  configureOrderDeliveriesModule,
-  OrderDeliveriesModule,
-} from './configureOrderDeliveriesModule.js';
-import { configureOrderDiscountsModule, OrderDiscountsModule } from './configureOrderDiscountsModule.js';
-import { configureOrderPaymentsModule, OrderPaymentsModule } from './configureOrderPaymentsModule.js';
-import { configureOrderPositionsModule, OrderPositionsModule } from './configureOrderPositionsModule.js';
-import { configureOrderModuleMutations, OrderMutations } from './configureOrdersModule-mutations.js';
-import { configureOrdersModuleQueries, OrderQueries } from './configureOrdersModule-queries.js';
+import { configureOrderDeliveriesModule } from './configureOrderDeliveriesModule.js';
+import { configureOrderDiscountsModule } from './configureOrderDiscountsModule.js';
+import { configureOrderPaymentsModule } from './configureOrderPaymentsModule.js';
+import { configureOrderPositionsModule } from './configureOrderPositionsModule.js';
+import { configureOrderModuleMutations } from './configureOrdersModule-mutations.js';
+import { configureOrdersModuleQueries } from './configureOrdersModule-queries.js';
 import { emit, registerEvents } from '@unchainedshop/events';
 
 import renameCurrencyCode from '../migrations/20250502111800-currency-code.js';
 
-export type OrdersModule = OrderQueries &
-  OrderMutations & {
-    // Sub entities
-    deliveries: OrderDeliveriesModule;
-    discounts: OrderDiscountsModule;
-    positions: OrderPositionsModule;
-    payments: OrderPaymentsModule;
-
-    updateStatus: (orderId: string, params: { status: OrderStatus; info?: string }) => Promise<Order>;
-    acquireLock: (
-      orderId: string,
-      identifier: string,
-      timeout?: number,
-    ) => Promise<{ release: () => void }>;
-    setDeliveryProvider: (orderId: string, deliveryProviderId: string) => Promise<Order | null>;
-    setPaymentProvider: (orderId: string, paymentProviderId: string) => Promise<Order | null>;
-  };
-
 // @kontsedal/locco uses a deprecated way of importing files in ESM (node16 behavior)
 const require = createRequire(import.meta.url);
 const { Locker, MongoAdapter } = require('@kontsedal/locco');
@@ -52,7 +31,7 @@ export const configureOrdersModule = async ({
   db,
   migrationRepository,
   options: orderOptions = {},
-}: ModuleInput<OrdersSettingsOptions>): Promise<OrdersModule> => {
+}: ModuleInput<OrdersSettingsOptions>) => {
   // Migration v3 -> v4
   renameCurrencyCode(migrationRepository);
 
@@ -117,10 +96,14 @@ export const configureOrdersModule = async ({
     positions: orderPositionsModule,
     payments: orderPaymentsModule,
 
-    updateStatus: async (orderId, { status, info }) => {
+    updateStatus: async (
+      orderId: string,
+      { status, info }: { status: OrderStatus | null; info?: string },
+    ) => {
       const selector = generateDbFilterById(orderId);
       const order = await Orders.findOne(selector, {});
 
+      if (!order) return null;
       if (order.status === status) return order;
 
       const date = new Date();
@@ -197,7 +180,7 @@ export const configureOrdersModule = async ({
       return await locker.lock(`order:${identifier}:${orderId}`, timeout).acquire();
     },
 
-    setDeliveryProvider: async (orderId, deliveryProviderId) => {
+    setDeliveryProvider: async (orderId: string, deliveryProviderId: string) => {
       const delivery = await OrderDeliveries.findOne({
         orderId,
         deliveryProviderId,
@@ -225,19 +208,16 @@ export const configureOrdersModule = async ({
         { returnDocument: 'after' },
       );
 
-      if (order) {
-        await emit('ORDER_SET_DELIVERY_PROVIDER', {
-          order,
-          deliveryProviderId,
-        });
-
-        return order;
-      }
+      if (!order) return null;
+      await emit('ORDER_SET_DELIVERY_PROVIDER', {
+        order,
+        deliveryProviderId,
+      });
 
-      return null;
+      return order;
     },
 
-    setPaymentProvider: async (orderId, paymentProviderId) => {
+    setPaymentProvider: async (orderId: string, paymentProviderId: string) => {
       const payment = await OrderPayments.findOne({
         orderId,
         paymentProviderId,
@@ -263,16 +243,15 @@ export const configureOrdersModule = async ({
         { returnDocument: 'after' },
       );
 
-      if (order) {
-        await emit('ORDER_SET_PAYMENT_PROVIDER', {
-          order,
-          paymentProviderId,
-        });
-
-        return order;
-      }
+      if (!order) return null;
+      await emit('ORDER_SET_PAYMENT_PROVIDER', {
+        order,
+        paymentProviderId,
+      });
 
-      return null;
+      return order;
     },
   };
 };
+
+export type OrdersModule = Awaited<ReturnType<typeof configureOrdersModule>>;

package/src/orders-settings.ts

@@ -8,15 +8,17 @@ export interface OrderSettingsOrderPositionValidation<Product = unknown> {
   configuration?: { key: string; value: string }[];
 }
 
-export interface OrdersSettingsOptions {
-  ensureUserHasCart?: boolean;
-  orderNumberHashFn?: (order: Order, index: number) => string;
-  validateOrderPosition?: <UnchainedAPI = unknown>(
+export interface OrdersSettings {
+  ensureUserHasCart: boolean;
+  orderNumberHashFn: (order: Order, index: number) => string;
+  validateOrderPosition: <UnchainedAPI = unknown>(
     validationParams: OrderSettingsOrderPositionValidation,
     unchainedAPI: UnchainedAPI,
   ) => Promise<void>;
-  lockOrderDuringCheckout?: boolean;
+  lockOrderDuringCheckout: boolean;
+  configureSettings: (options?: OrdersSettingsOptions) => void;
 }
+export type OrdersSettingsOptions = Omit<Partial<OrdersSettings>, 'configureSettings'>;
 
 export const defaultValidateOrderPosition = async ({ product }, { modules }: any) => {
   if (!modules.products.isActive(product)) {
@@ -24,21 +26,20 @@ export const defaultValidateOrderPosition = async ({ product }, { modules }: any
   }
 };
 
-export const ordersSettings = {
-  ensureUserHasCart: null,
-  orderNumberHashFn: null,
-  validateOrderPosition: null,
+export const ordersSettings: OrdersSettings = {
+  ensureUserHasCart: false,
+  orderNumberHashFn: generateRandomHash,
+  validateOrderPosition: defaultValidateOrderPosition,
   lockOrderDuringCheckout: false,
-
   configureSettings({
-    ensureUserHasCart = false,
-    orderNumberHashFn = generateRandomHash,
-    validateOrderPosition = defaultValidateOrderPosition,
-    lockOrderDuringCheckout = false,
-  }: OrdersSettingsOptions = {}) {
-    this.ensureUserHasCart = ensureUserHasCart;
-    this.orderNumberHashFn = orderNumberHashFn;
-    this.validateOrderPosition = validateOrderPosition;
-    this.lockOrderDuringCheckout = lockOrderDuringCheckout;
+    ensureUserHasCart,
+    orderNumberHashFn,
+    validateOrderPosition,
+    lockOrderDuringCheckout,
+  } = {}) {
+    this.ensureUserHasCart = ensureUserHasCart || false;
+    this.orderNumberHashFn = orderNumberHashFn || generateRandomHash;
+    this.validateOrderPosition = validateOrderPosition || defaultValidateOrderPosition;
+    this.lockOrderDuringCheckout = lockOrderDuringCheckout || false;
   },
 };