@unchainedshop/core-orders 4.3.4 → 4.5.0

package/lib/module/configureOrderPositionsModule.js

@@ -1,5 +1,5 @@
 import { emit, registerEvents } from '@unchainedshop/events';
-import { generateDbFilterById, generateDbObjectId } from '@unchainedshop/mongodb';
+import { generateDbFilterById, generateDbObjectId, mongodb } from '@unchainedshop/mongodb';
 const ORDER_POSITION_EVENTS = [
     'ORDER_UPDATE_CART_ITEM',
     'ORDER_REMOVE_CART_ITEM',
@@ -10,7 +10,6 @@ export const buildFindOrderPositionByIdSelector = (orderPositionId, orderId) =>
 export const configureOrderPositionsModule = ({ OrderPositions, }) => {
     registerEvents(ORDER_POSITION_EVENTS);
     return {
-        // Queries
         findOrderPosition: async ({ itemId }, options) => {
             return OrderPositions.findOne(buildFindOrderPositionByIdSelector(itemId), options);
         },
@@ -102,7 +101,6 @@ export const configureOrderPositionsModule = ({ OrderPositions, }) => {
         },
         addProductItem: async (orderPosition) => {
             const { configuration, orderId, originalProductId, productId, quantity, ...scope } = orderPosition;
-            // Search for existing position
             const selector = {
                 orderId,
                 productId,
@@ -153,6 +151,52 @@ export const configureOrderPositionsModule = ({ OrderPositions, }) => {
                 stages.push({ $limit: limit });
             return OrderPositions.aggregate(stages).toArray();
         },
+        getTopProducts: async (orderIds, options) => {
+            const limit = options?.limit || 10;
+            const pipeline = [
+                { $match: { orderId: { $in: orderIds } } },
+                {
+                    $project: {
+                        productId: 1,
+                        quantity: 1,
+                        itemAmount: {
+                            $let: {
+                                vars: {
+                                    item: {
+                                        $first: {
+                                            $filter: {
+                                                input: '$calculation',
+                                                as: 'c',
+                                                cond: { $eq: ['$$c.category', 'ITEM'] },
+                                            },
+                                        },
+                                    },
+                                },
+                                in: '$$item.amount',
+                            },
+                        },
+                    },
+                },
+                {
+                    $group: {
+                        _id: '$productId',
+                        totalSold: { $sum: '$quantity' },
+                        totalRevenue: { $sum: '$itemAmount' },
+                    },
+                },
+                { $match: { totalSold: { $gt: 0 } } },
+                { $sort: { totalSold: -1 } },
+                { $limit: limit },
+                {
+                    $project: {
+                        _id: 0,
+                        productId: '$_id',
+                        totalSold: 1,
+                        totalRevenue: 1,
+                    },
+                },
+            ];
+            return OrderPositions.aggregate(pipeline, { allowDiskUse: true }).toArray();
+        },
     };
 };
-//# sourceMappingURL=configureOrderPositionsModule.js.map

package/lib/module/configureOrdersModule-mutations.d.ts

@@ -1,6 +1,6 @@
-import { Address, Contact, mongodb } from '@unchainedshop/mongodb';
-import { Order } from '../db/OrdersCollection.js';
-import { OrderPosition } from '../db/OrderPositionsCollection.js';
+import { type Address, type Contact, mongodb } from '@unchainedshop/mongodb';
+import { type Order } from '../db/OrdersCollection.ts';
+import type { OrderPosition } from '../db/OrderPositionsCollection.ts';
 export declare const configureOrderModuleMutations: ({ Orders, OrderPositions, }: {
     Orders: mongodb.Collection<Order>;
     OrderPositions: mongodb.Collection<OrderPosition>;
@@ -28,6 +28,10 @@ export declare const configureOrderModuleMutations: ({ Orders, OrderPositions, }
     updateContact: (orderId: string, contact: Contact) => Promise<mongodb.WithId<Order> | null>;
     updateCalculationSheet: (orderId: string, calculation: any) => Promise<mongodb.WithId<Order> | null>;
     updateContext: (orderId: string, context: any) => Promise<mongodb.WithId<Order> | null>;
+    updateCartFields: (orderId: string, updates: {
+        meta?: any;
+        billingAddress?: Address;
+        contact?: Contact;
+    }) => Promise<Order | null>;
 };
 export type OrderMutations = ReturnType<typeof configureOrderModuleMutations>;
-//# sourceMappingURL=configureOrdersModule-mutations.d.ts.map

package/lib/module/configureOrdersModule-mutations.js

@@ -1,6 +1,6 @@
 import { emit, registerEvents } from '@unchainedshop/events';
-import { generateDbFilterById, generateDbObjectId, } from '@unchainedshop/mongodb';
-import { OrderStatus } from '../db/OrdersCollection.js';
+import { generateDbFilterById, generateDbObjectId, mongodb, } from '@unchainedshop/mongodb';
+import { OrderStatus } from "../db/OrdersCollection.js";
 const ORDER_EVENTS = [
     'ORDER_CREATE',
     'ORDER_REMOVE',
@@ -107,6 +107,26 @@ export const configureOrderModuleMutations = ({ Orders, OrderPositions, }) => {
             await emit('ORDER_UPDATE', { order, field: 'context' });
             return order;
         },
+        updateCartFields: async (orderId, updates) => {
+            const $set = { updated: new Date() };
+            if (updates.billingAddress) {
+                $set.billingAddress = updates.billingAddress;
+            }
+            if (updates.contact) {
+                $set.contact = updates.contact;
+            }
+            if (updates.meta && Object.keys(updates.meta).length > 0) {
+                const contextSetters = Object.fromEntries(Object.entries(updates.meta).map(([key, value]) => [`context.${key}`, value]));
+                Object.assign($set, contextSetters);
+            }
+            if (Object.keys($set).length === 1) {
+                return Orders.findOne(generateDbFilterById(orderId), {});
+            }
+            const order = await Orders.findOneAndUpdate(generateDbFilterById(orderId), { $set }, { returnDocument: 'after' });
+            if (!order)
+                return null;
+            await emit('ORDER_UPDATE', { order, field: 'cartFields' });
+            return order;
+        },
     };
 };
-//# sourceMappingURL=configureOrdersModule-mutations.js.map

package/lib/module/configureOrdersModule-queries.d.ts

@@ -1,6 +1,6 @@
-import { SortOption } from '@unchainedshop/utils';
+import { type SortOption } from '@unchainedshop/utils';
 import { mongodb } from '@unchainedshop/mongodb';
-import { Order, OrderQuery } from '../db/OrdersCollection.js';
+import { type Order, type OrderQuery } from '../db/OrdersCollection.ts';
 export interface OrderReport {
     newCount: number;
     checkoutCount: number;
@@ -8,13 +8,27 @@ export interface OrderReport {
     confirmCount: number;
     fulfillCount: number;
 }
+export interface TopCustomerRecord {
+    userId: string;
+    currencyCode: string;
+    totalSpent: number;
+    orderCount: number;
+    lastOrderDate: Date;
+    averageOrderValue: number;
+}
 export interface OrderStatisticsRecord {
     date: string;
+    count: number;
     total: {
         amount: number;
-        currency: string;
+        currencyCode: string;
     };
 }
+export interface DateRange {
+    start?: string;
+    end?: string;
+}
+export type StatisticsDateField = 'created' | 'ordered' | 'rejected' | 'confirmed' | 'fullfilled';
 export interface OrderAggregateParams {
     match?: Record<string, any>;
     matchAfterGroup?: Record<string, any>;
@@ -49,6 +63,16 @@ export declare const configureOrdersModuleQueries: ({ Orders }: {
         orderId: string;
     }) => Promise<boolean>;
     aggregateOrders: ({ match, project, group, sort, limit, addFields, pipeline, }: OrderAggregateParams) => Promise<mongodb.Document[]>;
+    statistics: {
+        countByDateField(dateField: StatisticsDateField, dateRange?: DateRange, options?: {
+            includeCarts?: boolean;
+        }): Promise<number>;
+        aggregateByDateField(dateField: StatisticsDateField, dateRange?: DateRange, options?: {
+            includeCarts?: boolean;
+        }): Promise<OrderStatisticsRecord[]>;
+        getTopCustomers(orderIds: string[], options?: {
+            limit?: number;
+        }): Promise<TopCustomerRecord[]>;
+    };
 };
 export type OrderQueries = ReturnType<typeof configureOrdersModuleQueries>;
-//# sourceMappingURL=configureOrdersModule-queries.d.ts.map

package/lib/module/configureOrdersModule-queries.js

@@ -1,6 +1,17 @@
 import { SortDirection } from '@unchainedshop/utils';
-import { generateDbFilterById, buildSortOptions } from '@unchainedshop/mongodb';
-import buildFindSelector from './buildFindSelector.js';
+import { generateDbFilterById, buildSortOptions, mongodb } from '@unchainedshop/mongodb';
+import buildFindSelector from "./buildFindSelector.js";
+import {} from "../db/OrdersCollection.js";
+function buildDateMatch(dateField, dateRange) {
+    if (!dateRange?.start && !dateRange?.end)
+        return { [dateField]: { $exists: true } };
+    const rangeMatch = {};
+    if (dateRange?.start)
+        rangeMatch.$gte = new Date(dateRange.start);
+    if (dateRange?.end)
+        rangeMatch.$lte = new Date(dateRange.end);
+    return { [dateField]: rangeMatch };
+}
 export const configureOrdersModuleQueries = ({ Orders }) => {
     return {
         isCart: (order) => {
@@ -81,6 +92,119 @@ export const configureOrdersModuleQueries = ({ Orders }) => {
                 stages.push({ $limit: limit });
             return Orders.aggregate(stages, { allowDiskUse: true }).toArray();
         },
+        statistics: {
+            async countByDateField(dateField, dateRange, options) {
+                const match = buildDateMatch(dateField, dateRange);
+                if (options?.includeCarts) {
+                    match.status = null;
+                    match.orderNumber = null;
+                }
+                const pipeline = [{ $match: match }, { $count: 'count' }];
+                const result = await Orders.aggregate(pipeline).toArray();
+                return result[0]?.count ?? 0;
+            },
+            async aggregateByDateField(dateField, dateRange, options) {
+                const match = buildDateMatch(dateField, dateRange);
+                if (options?.includeCarts) {
+                    match.status = null;
+                    match.orderNumber = null;
+                }
+                const pipeline = [
+                    { $match: match },
+                    {
+                        $addFields: {
+                            orderTotal: {
+                                $reduce: {
+                                    input: { $ifNull: ['$calculation', []] },
+                                    initialValue: 0,
+                                    in: { $add: ['$$value', { $ifNull: ['$$this.amount', 0] }] },
+                                },
+                            },
+                        },
+                    },
+                    {
+                        $group: {
+                            _id: {
+                                date: { $dateToString: { format: '%Y-%m-%d', date: `$${dateField}` } },
+                                currency: '$currencyCode',
+                            },
+                            totalAmount: { $sum: '$orderTotal' },
+                            count: { $sum: 1 },
+                        },
+                    },
+                    {
+                        $project: {
+                            _id: 0,
+                            date: '$_id.date',
+                            total: { amount: '$totalAmount', currencyCode: '$_id.currency' },
+                            count: 1,
+                        },
+                    },
+                    { $sort: { date: 1 } },
+                ];
+                return Orders.aggregate(pipeline).toArray();
+            },
+            async getTopCustomers(orderIds, options) {
+                const limit = options?.limit || 10;
+                const pipeline = [
+                    { $match: { _id: { $in: orderIds } } },
+                    {
+                        $project: {
+                            userId: 1,
+                            created: 1,
+                            currencyCode: 1,
+                            itemAmount: {
+                                $let: {
+                                    vars: {
+                                        item: {
+                                            $first: {
+                                                $filter: {
+                                                    input: '$calculation',
+                                                    as: 'c',
+                                                    cond: { $eq: ['$$c.category', 'ITEMS'] },
+                                                },
+                                            },
+                                        },
+                                    },
+                                    in: '$$item.amount',
+                                },
+                            },
+                        },
+                    },
+                    {
+                        $group: {
+                            _id: { userId: '$userId', currencyCode: '$currencyCode' },
+                            totalSpent: { $sum: '$itemAmount' },
+                            orderCount: { $sum: 1 },
+                            lastOrderDate: { $max: '$created' },
+                        },
+                    },
+                    { $match: { totalSpent: { $gt: 0 } } },
+                    {
+                        $addFields: {
+                            averageOrderValue: {
+                                $cond: [{ $eq: ['$orderCount', 0] }, 0, { $divide: ['$totalSpent', '$orderCount'] }],
+                            },
+                            currencyCode: '$_id.currencyCode',
+                            userId: '$_id.userId',
+                        },
+                    },
+                    { $sort: { totalSpent: -1 } },
+                    { $limit: limit },
+                    {
+                        $project: {
+                            _id: 0,
+                            userId: 1,
+                            currencyCode: 1,
+                            totalSpent: 1,
+                            orderCount: 1,
+                            lastOrderDate: 1,
+                            averageOrderValue: 1,
+                        },
+                    },
+                ];
+                return Orders.aggregate(pipeline, { allowDiskUse: true }).toArray();
+            },
+        },
     };
 };
-//# sourceMappingURL=configureOrdersModule-queries.js.map

package/lib/module/configureOrdersModule.d.ts

@@ -1,53 +1,53 @@
-import { ModuleInput, mongodb } from '@unchainedshop/mongodb';
-import { Order, OrderStatus } from '../db/OrdersCollection.js';
-import { OrdersSettingsOptions } from '../orders-settings.js';
+import { type ModuleInput, mongodb } from '@unchainedshop/mongodb';
+import { type Order, OrderStatus } from '../db/OrdersCollection.ts';
+import { type OrdersSettingsOptions } from '../orders-settings.ts';
 export declare const configureOrdersModule: ({ db, migrationRepository, options: orderOptions, }: ModuleInput<OrdersSettingsOptions>) => Promise<{
     deliveries: {
         findDelivery: ({ orderDeliveryId }: {
             orderDeliveryId: string;
-        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderDeliveriesCollection.js").OrderDelivery | null>;
+        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderDeliveriesCollection.ts").OrderDelivery | null>;
         findDeliveryByProvidersId: ({ deliveryProviderIds }: {
             deliveryProviderIds: string[];
-        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderDeliveriesCollection.js").OrderDelivery[]>;
-        normalizedStatus: (orderDelivery: import("../db/OrderDeliveriesCollection.js").OrderDelivery) => import("../db/OrderDeliveriesCollection.js").OrderDeliveryStatus;
-        create: (doc: Omit<import("../db/OrderDeliveriesCollection.js").OrderDelivery, "_id" | "created"> & Pick<Partial<import("../db/OrderDeliveriesCollection.js").OrderDelivery>, "_id" | "created">) => Promise<import("../db/OrderDeliveriesCollection.js").OrderDelivery>;
+        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderDeliveriesCollection.ts").OrderDelivery[]>;
+        normalizedStatus: (orderDelivery: import("../db/OrderDeliveriesCollection.ts").OrderDelivery) => import("../db/OrderDeliveriesCollection.ts").OrderDeliveryStatus;
+        create: (doc: Omit<import("../db/OrderDeliveriesCollection.ts").OrderDelivery, "_id" | "created"> & Pick<Partial<import("../db/OrderDeliveriesCollection.ts").OrderDelivery>, "_id" | "created">) => Promise<import("../db/OrderDeliveriesCollection.ts").OrderDelivery>;
         delete: (orderDeliveryId: string) => Promise<number>;
-        markAsDelivered: (orderDelivery: import("../db/OrderDeliveriesCollection.js").OrderDelivery) => Promise<mongodb.WithId<import("../db/OrderDeliveriesCollection.js").OrderDelivery> | null | undefined>;
-        updateContext: (orderDeliveryId: string, context: any) => Promise<mongodb.WithId<import("../db/OrderDeliveriesCollection.js").OrderDelivery> | null>;
+        markAsDelivered: (orderDelivery: import("../db/OrderDeliveriesCollection.ts").OrderDelivery) => Promise<mongodb.WithId<import("../db/OrderDeliveriesCollection.ts").OrderDelivery> | null | undefined>;
+        updateContext: (orderDeliveryId: string, context: any) => Promise<mongodb.WithId<import("../db/OrderDeliveriesCollection.ts").OrderDelivery> | null>;
         updateStatus: (orderDeliveryId: string, { status, info }: {
-            status: import("../db/OrderDeliveriesCollection.js").OrderDeliveryStatus;
+            status: import("../db/OrderDeliveriesCollection.ts").OrderDeliveryStatus;
             info?: string;
-        }) => Promise<mongodb.WithId<import("../db/OrderDeliveriesCollection.js").OrderDelivery> | null>;
-        updateCalculation: <T extends import("@unchainedshop/utils").PricingCalculation>(orderDeliveryId: string, calculation: T[]) => Promise<mongodb.WithId<import("../db/OrderDeliveriesCollection.js").OrderDelivery> | null>;
+        }) => Promise<mongodb.WithId<import("../db/OrderDeliveriesCollection.ts").OrderDelivery> | null>;
+        updateCalculation: <T extends import("@unchainedshop/utils").PricingCalculation>(orderDeliveryId: string, calculation: T[]) => Promise<mongodb.WithId<import("../db/OrderDeliveriesCollection.ts").OrderDelivery> | null>;
         deleteOrderDeliveries: (orderId: string) => Promise<number>;
     };
     discounts: {
         findOrderDiscount: ({ discountId }: {
             discountId: string;
-        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderDiscountsCollection.js").OrderDiscount | null>;
+        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderDiscountsCollection.ts").OrderDiscount | null>;
         findOrderDiscounts: ({ orderId }: {
             orderId: string;
-        }) => Promise<import("../db/OrderDiscountsCollection.js").OrderDiscount[]>;
-        create: (doc: Omit<import("../db/OrderDiscountsCollection.js").OrderDiscount, "_id" | "created" | "trigger"> & Pick<Partial<import("../db/OrderDiscountsCollection.js").OrderDiscount>, "_id" | "created" | "trigger">) => Promise<import("../db/OrderDiscountsCollection.js").OrderDiscount>;
-        delete: (orderDiscountId: string) => Promise<mongodb.WithId<import("../db/OrderDiscountsCollection.js").OrderDiscount> | null>;
+        }) => Promise<import("../db/OrderDiscountsCollection.ts").OrderDiscount[]>;
+        create: (doc: Omit<import("../db/OrderDiscountsCollection.ts").OrderDiscount, "_id" | "created" | "trigger"> & Pick<Partial<import("../db/OrderDiscountsCollection.ts").OrderDiscount>, "_id" | "created" | "trigger">) => Promise<import("../db/OrderDiscountsCollection.ts").OrderDiscount>;
+        delete: (orderDiscountId: string) => Promise<mongodb.WithId<import("../db/OrderDiscountsCollection.ts").OrderDiscount> | null>;
         isDiscountCodeUsed: ({ code, orderId }: {
             code: any;
             orderId: any;
         }) => Promise<boolean>;
         findSpareDiscount: ({ code }: {
             code: any;
-        }) => Promise<mongodb.WithId<import("../db/OrderDiscountsCollection.js").OrderDiscount> | null>;
-        update: (orderDiscountId: string, doc: Partial<import("../db/OrderDiscountsCollection.js").OrderDiscount>) => Promise<mongodb.WithId<import("../db/OrderDiscountsCollection.js").OrderDiscount> | null>;
+        }) => Promise<mongodb.WithId<import("../db/OrderDiscountsCollection.ts").OrderDiscount> | null>;
+        update: (orderDiscountId: string, doc: Partial<import("../db/OrderDiscountsCollection.ts").OrderDiscount>) => Promise<mongodb.WithId<import("../db/OrderDiscountsCollection.ts").OrderDiscount> | null>;
         deleteOrderDiscounts: (orderId: string) => Promise<number>;
     };
     positions: {
         findOrderPosition: ({ itemId }: {
             itemId: string;
-        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPositionsCollection.js").OrderPosition | null>;
+        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPositionsCollection.ts").OrderPosition | null>;
         findOrderPositions: ({ orderId }: {
             orderId: string;
-        }) => Promise<import("../db/OrderPositionsCollection.js").OrderPosition[]>;
-        delete: (orderPositionId: string) => Promise<mongodb.WithId<import("../db/OrderPositionsCollection.js").OrderPosition> | null>;
+        }) => Promise<import("../db/OrderPositionsCollection.ts").OrderPosition[]>;
+        delete: (orderPositionId: string) => Promise<mongodb.WithId<import("../db/OrderPositionsCollection.ts").OrderPosition> | null>;
         removePositions: ({ orderId }: {
             orderId: string;
         }) => Promise<number>;
@@ -58,10 +58,10 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
                 value: string;
             }[] | null;
             quantity: number | null;
-        }) => Promise<mongodb.WithId<import("../db/OrderPositionsCollection.js").OrderPosition> | null>;
+        }) => Promise<mongodb.WithId<import("../db/OrderPositionsCollection.ts").OrderPosition> | null>;
         removeProductByIdFromAllOpenPositions: (productId: string) => Promise<string[]>;
-        updateScheduling: (orderPositionId: any, scheduling: any) => Promise<mongodb.WithId<import("../db/OrderPositionsCollection.js").OrderPosition> | null>;
-        updateCalculation: <T extends import("@unchainedshop/utils").PricingCalculation>(orderPositionId: string, calculation: T[]) => Promise<mongodb.WithId<import("../db/OrderPositionsCollection.js").OrderPosition> | null>;
+        updateScheduling: (orderPositionId: any, scheduling: any) => Promise<mongodb.WithId<import("../db/OrderPositionsCollection.ts").OrderPosition> | null>;
+        updateCalculation: <T extends import("@unchainedshop/utils").PricingCalculation>(orderPositionId: string, calculation: T[]) => Promise<mongodb.WithId<import("../db/OrderPositionsCollection.ts").OrderPosition> | null>;
         addProductItem: (orderPosition: {
             context?: any;
             configuration?: {
@@ -73,34 +73,37 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
             productId: string;
             quantity: number;
             quotationId?: string;
-        }) => Promise<import("../db/OrderPositionsCollection.js").OrderPosition>;
+        }) => Promise<import("../db/OrderPositionsCollection.ts").OrderPosition>;
         deleteOrderPositions: (orderId: string) => Promise<number>;
-        aggregatePositions: ({ match, project, group, addFields, sort, limit, pipeline, }: import("./configureOrderPositionsModule.js").OrderPositionAggregateParams) => Promise<mongodb.Document[]>;
+        aggregatePositions: ({ match, project, group, addFields, sort, limit, pipeline, }: import("./configureOrderPositionsModule.ts").OrderPositionAggregateParams) => Promise<mongodb.Document[]>;
+        getTopProducts: (orderIds: string[], options?: {
+            limit?: number;
+        }) => Promise<import("./configureOrderPositionsModule.ts").TopProductRecord[]>;
     };
     payments: {
         findOrderPayment: ({ orderPaymentId, }: {
             orderPaymentId: string;
-        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPaymentsCollection.js").OrderPayment | null>;
+        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPaymentsCollection.ts").OrderPayment | null>;
         findOrderPaymentsByProviderIds: ({ paymentProviderIds, }: {
             paymentProviderIds: string[];
-        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPaymentsCollection.js").OrderPayment[]>;
+        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPaymentsCollection.ts").OrderPayment[]>;
         findOrderPaymentByContextData: ({ context, }: {
             context: any;
-        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPaymentsCollection.js").OrderPayment | null>;
+        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPaymentsCollection.ts").OrderPayment | null>;
         countOrderPaymentsByContextData: ({ context, }: {
             context: any;
         }, options?: mongodb.FindOptions) => Promise<number>;
-        normalizedStatus: (orderPayment: import("../db/OrderPaymentsCollection.js").OrderPayment) => import("../db/OrderPaymentsCollection.js").OrderPaymentStatus;
-        create: (doc: Omit<import("../db/OrderPaymentsCollection.js").OrderPayment, "_id" | "created"> & Pick<Partial<import("../db/OrderPaymentsCollection.js").OrderPayment>, "_id" | "created">) => Promise<import("../db/OrderPaymentsCollection.js").OrderPayment>;
+        normalizedStatus: (orderPayment: import("../db/OrderPaymentsCollection.ts").OrderPayment) => import("../db/OrderPaymentsCollection.ts").OrderPaymentStatus;
+        create: (doc: Omit<import("../db/OrderPaymentsCollection.ts").OrderPayment, "_id" | "created"> & Pick<Partial<import("../db/OrderPaymentsCollection.ts").OrderPayment>, "_id" | "created">) => Promise<import("../db/OrderPaymentsCollection.ts").OrderPayment>;
         logEvent: (orderPaymentId: string, event: any) => Promise<boolean>;
-        markAsPaid: (orderPayment: import("../db/OrderPaymentsCollection.js").OrderPayment, meta: any) => Promise<void>;
-        updateContext: (orderPaymentId: string, context: any) => Promise<mongodb.WithId<import("../db/OrderPaymentsCollection.js").OrderPayment> | null>;
+        markAsPaid: (orderPayment: import("../db/OrderPaymentsCollection.ts").OrderPayment, meta: any) => Promise<void>;
+        updateContext: (orderPaymentId: string, context: any) => Promise<mongodb.WithId<import("../db/OrderPaymentsCollection.ts").OrderPayment> | null>;
         updateStatus: (orderPaymentId: string, { transactionId, status, info, }: {
             transactionId?: string;
-            status: import("../db/OrderPaymentsCollection.js").OrderPaymentStatus;
+            status: import("../db/OrderPaymentsCollection.ts").OrderPaymentStatus;
             info?: string;
-        }) => Promise<mongodb.WithId<import("../db/OrderPaymentsCollection.js").OrderPayment> | null>;
-        updateCalculation: <T extends import("@unchainedshop/utils").PricingCalculation>(orderPaymentId: string, calculation: T[]) => Promise<mongodb.WithId<import("../db/OrderPaymentsCollection.js").OrderPayment> | null>;
+        }) => Promise<mongodb.WithId<import("../db/OrderPaymentsCollection.ts").OrderPayment> | null>;
+        updateCalculation: <T extends import("@unchainedshop/utils").PricingCalculation>(orderPaymentId: string, calculation: T[]) => Promise<mongodb.WithId<import("../db/OrderPaymentsCollection.ts").OrderPayment> | null>;
         deleteOrderPayments: (orderId: string) => Promise<number>;
     };
     updateStatus: (orderId: string, { status, info }: {
@@ -133,19 +136,24 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
     updateContact: (orderId: string, contact: import("@unchainedshop/mongodb").Contact) => Promise<mongodb.WithId<Order> | null>;
     updateCalculationSheet: (orderId: string, calculation: any) => Promise<mongodb.WithId<Order> | null>;
     updateContext: (orderId: string, context: any) => Promise<mongodb.WithId<Order> | null>;
+    updateCartFields: (orderId: string, updates: {
+        meta?: any;
+        billingAddress?: import("@unchainedshop/mongodb").Address;
+        contact?: import("@unchainedshop/mongodb").Contact;
+    }) => Promise<Order | null>;
     isCart: (order: Order) => boolean;
     cart: ({ orderNumber, countryCode, userId, }: {
         countryCode?: string;
         orderNumber?: string;
         userId: string;
     }) => Promise<mongodb.WithId<Order> | null>;
-    count: (query: import("../db/OrdersCollection.js").OrderQuery) => Promise<number>;
+    count: (query: import("../db/OrdersCollection.ts").OrderQuery) => Promise<number>;
     findOrder: ({ orderId, orderNumber, }: {
         orderId?: string;
         orderNumber?: string;
     }, options?: mongodb.FindOptions) => Promise<Order | null>;
     findCartsToInvalidate: (maxAgeDays?: number) => Promise<mongodb.WithId<Order>[]>;
-    findOrders: ({ limit, offset, queryString, sort, ...query }: import("../db/OrdersCollection.js").OrderQuery & {
+    findOrders: ({ limit, offset, queryString, sort, ...query }: import("../db/OrdersCollection.ts").OrderQuery & {
         limit?: number;
         offset?: number;
         sort?: import("@unchainedshop/utils").SortOption[];
@@ -153,7 +161,17 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
     orderExists: ({ orderId }: {
         orderId: string;
     }) => Promise<boolean>;
-    aggregateOrders: ({ match, project, group, sort, limit, addFields, pipeline, }: import("./configureOrdersModule-queries.js").OrderAggregateParams) => Promise<mongodb.Document[]>;
+    aggregateOrders: ({ match, project, group, sort, limit, addFields, pipeline, }: import("./configureOrdersModule-queries.ts").OrderAggregateParams) => Promise<mongodb.Document[]>;
+    statistics: {
+        countByDateField(dateField: import("./configureOrdersModule-queries.ts").StatisticsDateField, dateRange?: import("./configureOrdersModule-queries.ts").DateRange, options?: {
+            includeCarts?: boolean;
+        }): Promise<number>;
+        aggregateByDateField(dateField: import("./configureOrdersModule-queries.ts").StatisticsDateField, dateRange?: import("./configureOrdersModule-queries.ts").DateRange, options?: {
+            includeCarts?: boolean;
+        }): Promise<import("./configureOrdersModule-queries.ts").OrderStatisticsRecord[]>;
+        getTopCustomers(orderIds: string[], options?: {
+            limit?: number;
+        }): Promise<import("./configureOrdersModule-queries.ts").TopCustomerRecord[]>;
+    };
 }>;
 export type OrdersModule = Awaited<ReturnType<typeof configureOrdersModule>>;
-//# sourceMappingURL=configureOrdersModule.d.ts.map

package/lib/module/configureOrdersModule.js

@@ -1,20 +1,19 @@
-import { generateDbFilterById } from '@unchainedshop/mongodb';
+import { generateDbFilterById, mongodb } from '@unchainedshop/mongodb';
 import { createRequire } from 'node:module';
-import { OrderDeliveriesCollection } from '../db/OrderDeliveriesCollection.js';
-import { OrderDiscountsCollection } from '../db/OrderDiscountsCollection.js';
-import { OrderPaymentsCollection } from '../db/OrderPaymentsCollection.js';
-import { OrderPositionsCollection } from '../db/OrderPositionsCollection.js';
-import { OrdersCollection, OrderStatus } from '../db/OrdersCollection.js';
-import { ordersSettings } from '../orders-settings.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 { OrderDeliveriesCollection } from "../db/OrderDeliveriesCollection.js";
+import { OrderDiscountsCollection } from "../db/OrderDiscountsCollection.js";
+import { OrderPaymentsCollection } from "../db/OrderPaymentsCollection.js";
+import { OrderPositionsCollection } from "../db/OrderPositionsCollection.js";
+import { OrdersCollection, OrderStatus } from "../db/OrdersCollection.js";
+import { ordersSettings } from "../orders-settings.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';
-// @kontsedal/locco uses a deprecated way of importing files in ESM (node16 behavior)
+import renameCurrencyCode from "../migrations/20250502111800-currency-code.js";
 const require = createRequire(import.meta.url);
 const { Locker, MongoAdapter } = require('@kontsedal/locco');
 const ORDER_EVENTS = [
@@ -24,7 +23,6 @@ const ORDER_EVENTS = [
     'ORDER_FULLFILLED',
 ];
 export const configureOrdersModule = async ({ db, migrationRepository, options: orderOptions = {}, }) => {
-    // Migration v3 -> v4
     renameCurrencyCode(migrationRepository);
     registerEvents(ORDER_EVENTS);
     ordersSettings.configureSettings(orderOptions);
@@ -69,7 +67,6 @@ export const configureOrdersModule = async ({ db, migrationRepository, options:
     return {
         ...orderQueries,
         ...orderMutations,
-        // Subentities
         deliveries: orderDeliveriesModule,
         discounts: orderDiscountsModule,
         positions: orderPositionsModule,
@@ -87,10 +84,9 @@ export const configureOrdersModule = async ({ db, migrationRepository, options:
                 updated: new Date(),
             };
             switch (status) {
-                // explicitly use fallthrough here!
                 case OrderStatus.FULLFILLED:
                     $set.fullfilled = order.fullfilled || date;
-                case OrderStatus.REJECTED: // eslint-disable-line no-fallthrough
+                case OrderStatus.REJECTED:
                 case OrderStatus.CONFIRMED:
                     if (status === OrderStatus.REJECTED) {
                         $set.rejected = order.rejected || date;
@@ -98,7 +94,7 @@ export const configureOrdersModule = async ({ db, migrationRepository, options:
                     else {
                         $set.confirmed = order.confirmed || date;
                     }
-                case OrderStatus.PENDING: // eslint-disable-line no-fallthrough
+                case OrderStatus.PENDING:
                     $set.ordered = order.ordered || date;
                     $set.orderNumber = order.orderNumber || (await findNewOrderNumber(order));
                     break;
@@ -117,14 +113,13 @@ export const configureOrdersModule = async ({ db, migrationRepository, options:
             };
             const modificationResult = await Orders.findOneAndUpdate({
                 ...selector,
-                status: { $ne: status }, // Only update if status is different
+                status: { $ne: status },
             }, modifier, {
                 returnDocument: 'after',
                 includeResultMetadata: true,
             });
             if (modificationResult.ok) {
                 if (order.status === null) {
-                    // The first time that an order transitions away from cart is a checkout event
                     await emit('ORDER_CHECKOUT', { order: modificationResult.value, oldStatus: order.status });
                 }
                 switch (status) {
@@ -199,4 +194,3 @@ export const configureOrdersModule = async ({ db, migrationRepository, options:
         },
     };
 };
-//# sourceMappingURL=configureOrdersModule.js.map