@unchainedshop/core-orders 4.0.0-rc.2 → 4.0.0-rc.21

package/src/module/configureOrderPositionsModule.ts

@@ -10,6 +10,17 @@ const ORDER_POSITION_EVENTS: string[] = [
   'ORDER_ADD_PRODUCT',
 ];
 
+export interface OrderPositionAggregateParams {
+  match?: mongodb.Document;
+  matchAfterGroup?: mongodb.Document;
+  project?: mongodb.Document;
+  group?: mongodb.Document;
+  addFields?: mongodb.Document;
+  sort?: mongodb.Document;
+  limit?: number;
+  pipeline?: mongodb.Document[];
+}
+
 export const buildFindOrderPositionByIdSelector = (orderPositionId: string, orderId?: string) =>
   generateDbFilterById(
     orderPositionId,
@@ -25,10 +36,7 @@ export const configureOrderPositionsModule = ({
 
   return {
     // Queries
-    findOrderPosition: async (
-      { itemId }: { itemId: string },
-      options?: mongodb.FindOptions,
-    ): Promise<OrderPosition> => {
+    findOrderPosition: async ({ itemId }: { itemId: string }, options?: mongodb.FindOptions) => {
       return OrderPositions.findOne(buildFindOrderPositionByIdSelector(itemId), options);
     },
 
@@ -37,13 +45,13 @@ export const configureOrderPositionsModule = ({
       return positions.toArray();
     },
 
-    delete: async (orderPositionId: string): Promise<OrderPosition> => {
+    delete: async (orderPositionId: string) => {
       const selector = buildFindOrderPositionByIdSelector(orderPositionId);
       const orderPosition = await OrderPositions.findOneAndDelete(selector, {});
       await emit('ORDER_REMOVE_CART_ITEM', {
         orderPosition,
       });
-      return { ...orderPosition, calculation: [] };
+      return orderPosition;
     },
 
     removePositions: async ({ orderId }: { orderId: string }): Promise<number> => {
@@ -60,7 +68,7 @@ export const configureOrderPositionsModule = ({
       orderPositionId: string;
       configuration?: { key: string; value: string }[];
       quantity?: number;
-    }): Promise<OrderPosition> => {
+    }) => {
       const modifier: any = {
         $set: {
           updated: new Date(),
@@ -85,6 +93,7 @@ export const configureOrderPositionsModule = ({
         },
       );
 
+      if (!updatedOrderPosition) return null;
       await emit('ORDER_UPDATE_CART_ITEM', {
         orderPosition: updatedOrderPosition,
       });
@@ -128,7 +137,7 @@ export const configureOrderPositionsModule = ({
       return orderIdsToRecalculate;
     },
 
-    updateScheduling: async (orderPositionId, scheduling): Promise<OrderPosition> => {
+    updateScheduling: async (orderPositionId, scheduling) => {
       return OrderPositions.findOneAndUpdate(
         generateDbFilterById(orderPositionId),
         {
@@ -143,7 +152,7 @@ export const configureOrderPositionsModule = ({
     updateCalculation: async <T extends PricingCalculation>(
       orderPositionId: string,
       calculation: T[],
-    ): Promise<OrderPosition> => {
+    ) => {
       return OrderPositions.findOneAndUpdate(
         { _id: orderPositionId },
         {
@@ -171,11 +180,11 @@ export const configureOrderPositionsModule = ({
         orderId,
         productId,
         originalProductId,
-        configuration: configuration || { $in: [null, undefined] },
+        configuration: configuration || { $exists: false },
         ...scope,
       };
 
-      await OrderPositions.updateOne(
+      const upsertedOrderPosition = (await OrderPositions.findOneAndUpdate(
         selector,
         {
           $set: {
@@ -194,19 +203,41 @@ export const configureOrderPositionsModule = ({
             ...scope,
           },
         },
-        { upsert: true },
-      );
-
-      const upsertedOrderPosition = await OrderPositions.findOne(selector);
+        { upsert: true, returnDocument: 'after' },
+      )) as OrderPosition;
 
       await emit('ORDER_ADD_PRODUCT', { orderPosition: upsertedOrderPosition });
-
       return upsertedOrderPosition;
     },
     deleteOrderPositions: async (orderId: string) => {
       const { deletedCount } = await OrderPositions.deleteMany({ orderId });
       return deletedCount;
     },
+
+    aggregatePositions: async ({
+      match,
+      project,
+      group,
+      addFields,
+      sort,
+      limit,
+      pipeline,
+    }: OrderPositionAggregateParams): Promise<mongodb.Document[]> => {
+      const stages: mongodb.Document[] = [];
+
+      if (pipeline?.length) {
+        return await OrderPositions.aggregate(pipeline).toArray();
+      }
+
+      if (match) stages.push({ $match: match });
+      if (project) stages.push({ $project: project });
+      if (group) stages.push({ $group: group });
+      if (addFields) stages.push({ $addFields: addFields });
+      if (sort) stages.push({ $sort: sort });
+      if (typeof limit === 'number') stages.push({ $limit: limit });
+
+      return OrderPositions.aggregate(stages).toArray();
+    },
   };
 };
 

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' },
       );
-
-      await emit('ORDER_UPDATE', { order, field: 'billing' });
+      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] };
 
@@ -155,7 +158,7 @@ export const configureOrderModuleMutations = ({
       const contextSetters = Object.fromEntries(
         Object.entries(context).map(([key, value]) => [`context.${key}`, value]),
       );
-      const result = await Orders.findOneAndUpdate(
+      const order = await Orders.findOneAndUpdate(
         selector,
         {
           $set: {
@@ -163,14 +166,13 @@ export const configureOrderModuleMutations = ({
             updated: new Date(),
           },
         },
-        { includeResultMetadata: true, returnDocument: 'after' },
+        { returnDocument: 'after' },
       );
-
-      if (result.ok) {
-        await emit('ORDER_UPDATE', { order: result.value, field: 'context' });
-        return result.value;
-      }
-      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

@@ -1,4 +1,4 @@
-import { SortDirection, SortOption, DateFilterInput } from '@unchainedshop/utils';
+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';
@@ -10,21 +10,23 @@ export interface OrderReport {
   confirmCount: number;
   fulfillCount: number;
 }
-
-const normalizeOrderAggregateResult = (data = {}): OrderReport => {
-  const statusToFieldMap = {
-    newCount: 0,
-    checkoutCount: 0,
-    rejectCount: 0,
-    confirmCount: 0,
-    fulfillCount: 0,
+export interface OrderStatisticsRecord {
+  date: string;
+  total: {
+    amount: number;
+    currency: string;
   };
-
-  Object.entries(data).forEach(([key, value]) => {
-    statusToFieldMap[key] = value;
-  });
-  return statusToFieldMap;
-};
+}
+export interface OrderAggregateParams {
+  match?: Record<string, any>;
+  matchAfterGroup?: Record<string, any>;
+  project?: Record<string, any>;
+  group?: Record<string, any>;
+  sort?: Record<string, number>;
+  limit?: number;
+  addFields?: Record<string, any>;
+  pipeline?: any[];
+}
 
 export const configureOrdersModuleQueries = ({ Orders }: { Orders: mongodb.Collection<Order> }) => {
   return {
@@ -40,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 },
@@ -72,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);
     },
@@ -122,86 +124,35 @@ export const configureOrdersModuleQueries = ({ Orders }: { Orders: mongodb.Colle
 
       return Orders.find(selector, findOptions).toArray();
     },
-
-    getReport: async (params: { dateRange?: DateFilterInput }): Promise<OrderReport> => {
-      const { dateRange } = params || {};
-      const selector: any = { $exists: true };
-      if (dateRange?.end || dateRange?.start) {
-        if (dateRange?.start) {
-          const fromDate = new Date(dateRange?.start);
-          selector.$gte = fromDate;
-        }
-        if (dateRange?.end) {
-          const toDate = new Date(dateRange?.end);
-          selector.$lte = toDate;
-        }
-      }
-
-      const pipeline = [
-        {
-          $facet: {
-            checkoutCount: [
-              {
-                $match: {
-                  ordered: selector,
-                },
-              },
-              { $count: 'count' },
-            ],
-            fulfillCount: [
-              {
-                $match: {
-                  fullfilled: selector,
-                },
-              },
-              { $count: 'count' },
-            ],
-            rejectCount: [
-              {
-                $match: {
-                  rejected: selector,
-                },
-              },
-              { $count: 'count' },
-            ],
-            newCount: [
-              {
-                $match: {
-                  created: selector,
-                },
-              },
-              { $count: 'count' },
-            ],
-            confirmCount: [
-              {
-                $match: {
-                  confirmed: selector,
-                },
-              },
-              { $count: 'count' },
-            ],
-          },
-        },
-        {
-          $project: {
-            checkoutCount: { $arrayElemAt: ['$checkoutCount.count', 0] },
-            fulfillCount: { $arrayElemAt: ['$fulfillCount.count', 0] },
-            rejectCount: { $arrayElemAt: ['$rejectCount.count', 0] },
-            newCount: { $arrayElemAt: ['$newCount.count', 0] },
-            confirmCount: { $arrayElemAt: ['$confirmCount.count', 0] },
-          },
-        },
-      ];
-      const [facetedResult] = await Orders.aggregate(pipeline).toArray();
-      return normalizeOrderAggregateResult(facetedResult);
-    },
-
     orderExists: async ({ orderId }: { orderId: string }): Promise<boolean> => {
       const orderCount = await Orders.countDocuments(generateDbFilterById(orderId), {
         limit: 1,
       });
       return !!orderCount;
     },
+    aggregateOrders: async ({
+      match,
+      project,
+      group,
+      sort,
+      limit,
+      addFields,
+      pipeline,
+    }: OrderAggregateParams): Promise<mongodb.Document[]> => {
+      const stages: mongodb.Document[] = [];
+      if (pipeline?.length) {
+        return await Orders.aggregate(pipeline).toArray();
+      }
+
+      if (match) stages.push({ $match: match });
+      if (project) stages.push({ $project: project });
+      if (group) stages.push({ $group: group });
+      if (addFields) stages.push({ $addFields: addFields });
+      if (sort) stages.push({ $sort: sort });
+      if (typeof limit === 'number') stages.push({ $limit: limit });
+
+      return Orders.aggregate(stages, { allowDiskUse: true }).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>;
-    setPaymentProvider: (orderId: string, paymentProviderId: string) => Promise<Order>;
-  };
-
 // @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,
@@ -215,7 +198,7 @@ export const configureOrdersModule = async ({
         )._id;
 
       const order = await Orders.findOneAndUpdate(
-        { _id: orderId },
+        { _id: orderId, deliveryId: { $ne: deliveryId } },
         {
           $set: {
             deliveryId,
@@ -225,6 +208,7 @@ export const configureOrdersModule = async ({
         { returnDocument: 'after' },
       );
 
+      if (!order) return null;
       await emit('ORDER_SET_DELIVERY_PROVIDER', {
         order,
         deliveryProviderId,
@@ -233,7 +217,7 @@ export const configureOrdersModule = async ({
       return order;
     },
 
-    setPaymentProvider: async (orderId, paymentProviderId) => {
+    setPaymentProvider: async (orderId: string, paymentProviderId: string) => {
       const payment = await OrderPayments.findOne({
         orderId,
         paymentProviderId,
@@ -250,14 +234,16 @@ export const configureOrdersModule = async ({
             status: null,
           })
         )._id;
+
       const order = await Orders.findOneAndUpdate(
-        { _id: orderId },
+        { _id: orderId, paymentId: { $ne: paymentId } },
         {
           $set: { paymentId, updated: new Date() },
         },
         { returnDocument: 'after' },
       );
 
+      if (!order) return null;
       await emit('ORDER_SET_PAYMENT_PROVIDER', {
         order,
         paymentProviderId,
@@ -267,3 +253,5 @@ export const configureOrdersModule = async ({
     },
   };
 };
+
+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;
   },
 };