@unchainedshop/core-orders 4.4.0 → 4.5.0

package/lib/db/OrdersCollection.d.ts

@@ -26,7 +26,7 @@ export type Order = {
     status: OrderStatus | null;
     userId: string;
 } & LogFields & TimestampFields;
-export interface OrderQuery extends mongodb.Filter<Order> {
+export interface OrderQuery {
     includeCarts?: boolean;
     queryString?: string;
     status?: OrderStatus[];
@@ -34,5 +34,8 @@ export interface OrderQuery extends mongodb.Filter<Order> {
     deliveryIds?: string[];
     paymentIds?: string[];
     dateRange?: DateFilterInput;
+    orderIds?: string[];
+    paymentProviderIds?: string[];
+    deliveryProviderIds?: string[];
 }
 export declare const OrdersCollection: (db: mongodb.Db) => Promise<mongodb.Collection<Order>>;

package/lib/module/buildFindSelector.d.ts

@@ -1,4 +1,4 @@
 import type { OrderQuery, Order } from '../db/OrdersCollection.ts';
 import { mongodb } from '@unchainedshop/mongodb';
-export declare const buildFindSelector: ({ includeCarts, status, userId, queryString, paymentIds, deliveryIds, dateRange, ...rest }: OrderQuery) => mongodb.Filter<Order>;
+export declare const buildFindSelector: ({ includeCarts, status, userId, queryString, paymentIds, deliveryIds, dateRange, orderIds, }: OrderQuery) => mongodb.Filter<Order>;
 export default buildFindSelector;

package/lib/module/buildFindSelector.js

@@ -1,9 +1,12 @@
 import { assertDocumentDBCompatMode, mongodb } from '@unchainedshop/mongodb';
-export const buildFindSelector = ({ includeCarts, status, userId, queryString, paymentIds, deliveryIds, dateRange, ...rest }) => {
-    const selector = { ...rest };
+export const buildFindSelector = ({ includeCarts, status, userId, queryString, paymentIds, deliveryIds, dateRange, orderIds, }) => {
+    const selector = {};
     if (userId) {
         selector.userId = userId;
     }
+    if (orderIds) {
+        selector._id = { $in: orderIds };
+    }
     if (dateRange) {
         const dateFilter = {};
         if (dateRange.start)

package/lib/module/configureOrderPositionsModule.d.ts

@@ -11,6 +11,11 @@ export interface OrderPositionAggregateParams {
     limit?: number;
     pipeline?: mongodb.Document[];
 }
+export interface TopProductRecord {
+    productId: string;
+    totalSold: number;
+    totalRevenue: number;
+}
 export declare const buildFindOrderPositionByIdSelector: (orderPositionId: string, orderId?: string) => mongodb.Filter<OrderPosition>;
 export declare const configureOrderPositionsModule: ({ OrderPositions, }: {
     OrderPositions: mongodb.Collection<OrderPosition>;
@@ -50,5 +55,8 @@ export declare const configureOrderPositionsModule: ({ OrderPositions, }: {
     }) => Promise<OrderPosition>;
     deleteOrderPositions: (orderId: string) => Promise<number>;
     aggregatePositions: ({ match, project, group, addFields, sort, limit, pipeline, }: OrderPositionAggregateParams) => Promise<mongodb.Document[]>;
+    getTopProducts: (orderIds: string[], options?: {
+        limit?: number;
+    }) => Promise<TopProductRecord[]>;
 };
 export type OrderPositionsModule = ReturnType<typeof configureOrderPositionsModule>;

package/lib/module/configureOrderPositionsModule.js

@@ -151,5 +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();
+        },
     };
 };

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

@@ -28,5 +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>;

package/lib/module/configureOrdersModule-mutations.js

@@ -107,5 +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;
+        },
     };
 };

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

@@ -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,5 +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>;

package/lib/module/configureOrdersModule-queries.js

@@ -2,6 +2,16 @@ import { SortDirection } from '@unchainedshop/utils';
 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) => {
@@ -82,5 +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();
+            },
+        },
     };
 };

package/lib/module/configureOrdersModule.d.ts

@@ -76,6 +76,9 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
         }) => Promise<import("../db/OrderPositionsCollection.ts").OrderPosition>;
         deleteOrderPositions: (orderId: string) => Promise<number>;
         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, }: {
@@ -133,6 +136,11 @@ 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;
@@ -154,5 +162,16 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
         orderId: string;
     }) => Promise<boolean>;
     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>>;

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@unchainedshop/core-orders",
-  "version": "4.4.0",
+  "version": "4.5.0",
   "main": "lib/orders-index.js",
   "types": "lib/orders-index.d.ts",
   "type": "module",
+  "sideEffects": false,
   "scripts": {
     "clean": "tsc -b --clean",
     "build": "tsc -b",
@@ -34,9 +35,9 @@
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "dependencies": {
     "@kontsedal/locco": "0.1.0",
-    "@unchainedshop/events": "^4.4.0",
-    "@unchainedshop/logger": "^4.4.0",
-    "@unchainedshop/utils": "^4.4.0"
+    "@unchainedshop/events": "^4.5.0",
+    "@unchainedshop/logger": "^4.5.0",
+    "@unchainedshop/utils": "^4.5.0"
   },
   "devDependencies": {
     "@types/node": "^25.0.0",