@unchainedshop/core-orders 4.4.0 → 4.6.0

package/README.md

@@ -103,7 +103,7 @@ await ordersModule.checkout(orderId, { paymentContext: {} });
 
 | Export | Description |
 |--------|-------------|
-| `OrderStatus` | Order status values (OPEN, PENDING, CONFIRMED, FULLFILLED, REJECTED) |
+| `OrderStatus` | Order status values (OPEN, PENDING, CONFIRMED, FULFILLED, REJECTED) |
 
 ### Settings
 
@@ -132,7 +132,7 @@ await ordersModule.checkout(orderId, { paymentContext: {} });
 | `ORDER_CHECKOUT` | Order checked out |
 | `ORDER_CONFIRMED` | Order confirmed |
 | `ORDER_REJECTED` | Order rejected |
-| `ORDER_FULLFILLED` | Order fulfilled |
+| `ORDER_FULFILLED` | Order fulfilled |
 
 ## License
 

package/lib/db/OrdersCollection.d.ts

@@ -3,7 +3,7 @@ import type { DateFilterInput } from '@unchainedshop/utils';
 export declare const OrderStatus: {
     readonly PENDING: "PENDING";
     readonly CONFIRMED: "CONFIRMED";
-    readonly FULLFILLED: "FULLFILLED";
+    readonly FULFILLED: "FULFILLED";
     readonly REJECTED: "REJECTED";
 };
 export type OrderStatus = (typeof OrderStatus)[keyof typeof OrderStatus];
@@ -18,7 +18,7 @@ export type Order = {
     countryCode: string;
     currencyCode: string;
     deliveryId?: string;
-    fullfilled?: Date;
+    fulfilled?: Date;
     ordered?: Date;
     orderNumber?: string;
     originEnrollmentId?: string;
@@ -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/db/OrdersCollection.js

@@ -2,7 +2,7 @@ import { mongodb, buildDbIndexes, isDocumentDBCompatModeEnabled, } from '@unchai
 export const OrderStatus = {
     PENDING: 'PENDING',
     CONFIRMED: 'CONFIRMED',
-    FULLFILLED: 'FULLFILLED',
+    FULFILLED: 'FULFILLED',
     REJECTED: 'REJECTED',
 };
 export const OrdersCollection = async (db) => {
@@ -33,6 +33,7 @@ export const OrdersCollection = async (db) => {
         ]);
     }
     await buildDbIndexes(Orders, [
+        { index: { deleted: 1 } },
         { index: { userId: 1 } },
         { index: { status: 1 } },
         { index: { orderNumber: 1 } },

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/configureOrderPaymentsModule.d.ts

@@ -2,7 +2,6 @@ import { mongodb } from '@unchainedshop/mongodb';
 import type { PricingCalculation } from '@unchainedshop/utils';
 import { type OrderPayment, OrderPaymentStatus } from '../db/OrderPaymentsCollection.ts';
 export declare const buildFindOrderPaymentByIdSelector: (orderPaymentId: string) => mongodb.Filter<OrderPayment>;
-export declare const buildFindByContextDataSelector: (context: any) => mongodb.Filter<OrderPayment> | null;
 export declare const configureOrderPaymentsModule: ({ OrderPayments, }: {
     OrderPayments: mongodb.Collection<OrderPayment>;
 }) => {
@@ -12,12 +11,7 @@ export declare const configureOrderPaymentsModule: ({ OrderPayments, }: {
     findOrderPaymentsByProviderIds: ({ paymentProviderIds, }: {
         paymentProviderIds: string[];
     }, options?: mongodb.FindOptions) => Promise<OrderPayment[]>;
-    findOrderPaymentByContextData: ({ context, }: {
-        context: any;
-    }, options?: mongodb.FindOptions) => Promise<OrderPayment | null>;
-    countOrderPaymentsByContextData: ({ context, }: {
-        context: any;
-    }, options?: mongodb.FindOptions) => Promise<number>;
+    findOrderPaymentByTransactionId: (transactionId: string) => Promise<mongodb.WithId<OrderPayment> | null>;
     normalizedStatus: (orderPayment: OrderPayment) => OrderPaymentStatus;
     create: (doc: Omit<OrderPayment, "_id" | "created"> & Pick<Partial<OrderPayment>, "_id" | "created">) => Promise<OrderPayment>;
     logEvent: (orderPaymentId: string, event: any) => Promise<boolean>;

package/lib/module/configureOrderPaymentsModule.js

@@ -3,18 +3,6 @@ import { generateDbFilterById, generateDbObjectId, mongodb } from '@unchainedsho
 import { OrderPaymentStatus } from "../db/OrderPaymentsCollection.js";
 const ORDER_PAYMENT_EVENTS = ['ORDER_UPDATE_PAYMENT', 'ORDER_SIGN_PAYMENT', 'ORDER_PAY'];
 export const buildFindOrderPaymentByIdSelector = (orderPaymentId) => generateDbFilterById(orderPaymentId);
-export const buildFindByContextDataSelector = (context) => {
-    const contextKeys = Object.keys(context);
-    if (contextKeys.length === 0)
-        return null;
-    const selector = contextKeys.reduce((currentSelector, key) => context[key] !== undefined
-        ? {
-            ...currentSelector,
-            [`context.${key}`]: context[key],
-        }
-        : currentSelector, {});
-    return selector;
-};
 export const configureOrderPaymentsModule = ({ OrderPayments, }) => {
     registerEvents(ORDER_PAYMENT_EVENTS);
     const normalizedStatus = (orderPayment) => {
@@ -52,17 +40,8 @@ export const configureOrderPaymentsModule = ({ OrderPayments, }) => {
                 return [];
             return OrderPayments.find({ paymentProviderId: { $in: paymentProviderIds } }, options).toArray();
         },
-        findOrderPaymentByContextData: async ({ context, }, options) => {
-            const selector = buildFindByContextDataSelector(context);
-            if (!selector)
-                return null;
-            return OrderPayments.findOne(selector, options);
-        },
-        countOrderPaymentsByContextData: async ({ context, }, options) => {
-            const selector = buildFindByContextDataSelector(context);
-            if (!selector)
-                return 0;
-            return OrderPayments.countDocuments(selector, options);
+        findOrderPaymentByTransactionId: async (transactionId) => {
+            return OrderPayments.findOne({ transactionId });
         },
         normalizedStatus,
         create: async (doc) => {

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' | 'fulfilled';
 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, }: {
@@ -84,12 +87,7 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
         findOrderPaymentsByProviderIds: ({ paymentProviderIds, }: {
             paymentProviderIds: string[];
         }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPaymentsCollection.ts").OrderPayment[]>;
-        findOrderPaymentByContextData: ({ context, }: {
-            context: any;
-        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPaymentsCollection.ts").OrderPayment | null>;
-        countOrderPaymentsByContextData: ({ context, }: {
-            context: any;
-        }, options?: mongodb.FindOptions) => Promise<number>;
+        findOrderPaymentByTransactionId: (transactionId: string) => Promise<mongodb.WithId<import("../db/OrderPaymentsCollection.ts").OrderPayment> | null>;
         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>;
@@ -107,7 +105,7 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
         status: OrderStatus | null;
         info?: string;
     }) => Promise<mongodb.WithId<Order> | null>;
-    acquireLock: (orderId: string, identifier: string, timeout?: number) => Promise<any>;
+    acquireLock: (orderId: string, identifier: string, timeout?: number) => Promise<import("@kontsedal/locco").Lock>;
     setDeliveryProvider: (orderId: string, deliveryProviderId: string) => Promise<mongodb.WithId<Order> | null>;
     setPaymentProvider: (orderId: string, paymentProviderId: string) => Promise<mongodb.WithId<Order> | null>;
     create: ({ userId, orderNumber, currencyCode, countryCode, billingAddress, contact, context, }: {
@@ -133,6 +131,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 +157,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/lib/module/configureOrdersModule.js

@@ -1,5 +1,5 @@
+import { Locker, MongoAdapter } from '@kontsedal/locco';
 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";
@@ -14,13 +14,11 @@ import { configureOrderModuleMutations } from "./configureOrdersModule-mutations
 import { configureOrdersModuleQueries } from "./configureOrdersModule-queries.js";
 import { emit, registerEvents } from '@unchainedshop/events';
 import renameCurrencyCode from "../migrations/20250502111800-currency-code.js";
-const require = createRequire(import.meta.url);
-const { Locker, MongoAdapter } = require('@kontsedal/locco');
 const ORDER_EVENTS = [
     'ORDER_CHECKOUT',
     'ORDER_CONFIRMED',
     'ORDER_REJECTED',
-    'ORDER_FULLFILLED',
+    'ORDER_FULFILLED',
 ];
 export const configureOrdersModule = async ({ db, migrationRepository, options: orderOptions = {}, }) => {
     renameCurrencyCode(migrationRepository);
@@ -84,8 +82,8 @@ export const configureOrdersModule = async ({ db, migrationRepository, options:
                 updated: new Date(),
             };
             switch (status) {
-                case OrderStatus.FULLFILLED:
-                    $set.fullfilled = order.fullfilled || date;
+                case OrderStatus.FULFILLED:
+                    $set.fulfilled = order.fulfilled || date;
                 case OrderStatus.REJECTED:
                 case OrderStatus.CONFIRMED:
                     if (status === OrderStatus.REJECTED) {
@@ -123,8 +121,8 @@ export const configureOrdersModule = async ({ db, migrationRepository, options:
                     await emit('ORDER_CHECKOUT', { order: modificationResult.value, oldStatus: order.status });
                 }
                 switch (status) {
-                    case OrderStatus.FULLFILLED:
-                        await emit('ORDER_FULLFILLED', { order: modificationResult.value, oldStatus: order.status });
+                    case OrderStatus.FULFILLED:
+                        await emit('ORDER_FULFILLED', { order: modificationResult.value, oldStatus: order.status });
                         break;
                     case OrderStatus.REJECTED:
                         await emit('ORDER_REJECTED', { order: modificationResult.value, oldStatus: order.status });

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@unchainedshop/core-orders",
-  "version": "4.4.0",
+  "description": "Order management module for the Unchained Engine",
+  "version": "4.6.0",
   "main": "lib/orders-index.js",
   "types": "lib/orders-index.d.ts",
   "type": "module",
+  "sideEffects": false,
   "scripts": {
     "clean": "tsc -b --clean",
     "build": "tsc -b",
@@ -33,10 +35,10 @@
   },
   "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"
+    "@kontsedal/locco": "1.0.0",
+    "@unchainedshop/events": "^4.6.0",
+    "@unchainedshop/logger": "^4.6.0",
+    "@unchainedshop/utils": "^4.6.0"
   },
   "devDependencies": {
     "@types/node": "^25.0.0",