@unchainedshop/core-orders 5.0.0-alpha.1 → 5.0.0-alpha.3

package/lib/db/OrderDeliveriesCollection.js

@@ -8,7 +8,7 @@ export const OrderDeliveriesCollection = async (db) => {
     const OrderDeliveries = db.collection('order_deliveries');
     await buildDbIndexes(OrderDeliveries, [
         { index: { orderId: 1 } },
-        { index: { orderId: 1, deliveryProviderId: 1 } },
+        { index: { deliveryProviderId: 1 } },
     ]);
     return OrderDeliveries;
 };

package/lib/db/OrderDiscountsCollection.js

@@ -2,8 +2,8 @@ import { mongodb, buildDbIndexes } from '@unchainedshop/mongodb';
 export const OrderDiscountsCollection = async (db) => {
     const OrderDiscounts = db.collection('order_discounts');
     await buildDbIndexes(OrderDiscounts, [
-        { index: { orderId: 1 } },
-        { index: { trigger: 1 } },
+        { index: { orderId: 1, created: 1 } },
+        { index: { code: 1 }, options: { sparse: true } },
     ]);
     return OrderDiscounts;
 };

package/lib/db/OrderLocksCollection.d.ts

@@ -0,0 +1,10 @@
+import { mongodb } from '@unchainedshop/mongodb';
+export interface OrderLock {
+    key: string;
+    uniqueValue: string;
+    expireAt: Date;
+}
+export declare const OrderLocksCollection: (db: mongodb.Db) => Promise<mongodb.Collection<OrderLock>>;
+export declare const acquireLock: (OrderLocks: mongodb.Collection<OrderLock>, key: string, ttl: number) => Promise<{
+    release: () => Promise<void>;
+}>;

package/lib/db/OrderLocksCollection.js

@@ -0,0 +1,40 @@
+import { mongodb, buildDbIndexes } from '@unchainedshop/mongodb';
+import { setTimeout as sleep } from 'node:timers/promises';
+const DUPLICATE_KEY = 11000;
+const LOCK_RETRIES = 10;
+const LOCK_RETRY_DELAY_MS = 200;
+export const OrderLocksCollection = async (db) => {
+    const OrderLocks = db.collection('locco-locks');
+    const success = await buildDbIndexes(OrderLocks, [
+        { index: { key: 1 }, options: { unique: true } },
+        { index: { expireAt: 1 }, options: { expireAfterSeconds: 0 } },
+    ], { rebuild: false });
+    if (!success) {
+        throw new Error('Could not ensure the unique index backing order locks, refusing to start');
+    }
+    return OrderLocks;
+};
+export const acquireLock = async (OrderLocks, key, ttl) => {
+    const uniqueValue = crypto.randomUUID();
+    for (let attempt = 0; attempt < LOCK_RETRIES; attempt += 1) {
+        try {
+            await OrderLocks.updateOne({ key, expireAt: { $lt: new Date() } }, { $set: { key, uniqueValue, expireAt: new Date(Date.now() + ttl) } }, { upsert: true });
+            return {
+                release: async () => {
+                    try {
+                        await OrderLocks.deleteOne({ key, uniqueValue, expireAt: { $gt: new Date() } });
+                    }
+                    catch {
+                    }
+                },
+            };
+        }
+        catch (error) {
+            if (error?.code !== DUPLICATE_KEY)
+                throw error;
+            if (attempt < LOCK_RETRIES - 1)
+                await sleep(LOCK_RETRY_DELAY_MS);
+        }
+    }
+    throw new Error(`Could not acquire lock ${key}`);
+};

package/lib/db/OrderPaymentsCollection.js

@@ -8,9 +8,8 @@ export const OrderPaymentsCollection = async (db) => {
     const OrderPayments = db.collection('order_payments');
     await buildDbIndexes(OrderPayments, [
         { index: { orderId: 1 } },
-        {
-            index: { orderId: 1, paymentProviderId: 1 },
-        },
+        { index: { paymentProviderId: 1 } },
+        { index: { transactionId: 1 }, options: { sparse: true } },
     ]);
     return OrderPayments;
 };

package/lib/db/OrderPositionsCollection.js

@@ -2,8 +2,8 @@ import { mongodb, buildDbIndexes } from '@unchainedshop/mongodb';
 export const OrderPositionsCollection = async (db) => {
     const OrderPositions = db.collection('order_positions');
     await buildDbIndexes(OrderPositions, [
+        { index: { orderId: 1, created: 1 } },
         { index: { productId: 1 } },
-        { index: { orderId: 1 } },
     ]);
     return OrderPositions;
 };

package/lib/db/OrdersCollection.js

@@ -1,4 +1,4 @@
-import { mongodb, buildDbIndexes, isDocumentDBCompatModeEnabled, } from '@unchainedshop/mongodb';
+import { mongodb, buildDbIndexes, } from '@unchainedshop/mongodb';
 export const OrderStatus = {
     PENDING: 'PENDING',
     CONFIRMED: 'CONFIRMED',
@@ -7,36 +7,33 @@ export const OrderStatus = {
 };
 export const OrdersCollection = async (db) => {
     const Orders = db.collection('orders');
-    if (!isDocumentDBCompatModeEnabled()) {
-        await buildDbIndexes(Orders, [
-            {
-                index: {
-                    _id: 'text',
-                    userId: 'text',
-                    orderNumber: 'text',
-                    status: 'text',
-                    'contact.emailAddress': 'text',
-                    'contact.telNumber': 'text',
-                },
-                options: {
-                    weights: {
-                        _id: 8,
-                        userId: 3,
-                        orderNumber: 6,
-                        'contact.telNumber': 5,
-                        'contact.emailAddress': 4,
-                        status: 1,
-                    },
-                    name: 'order_fulltext_search',
+    await buildDbIndexes(Orders, [
+        {
+            index: {
+                _id: 'text',
+                userId: 'text',
+                orderNumber: 'text',
+                status: 'text',
+                'contact.emailAddress': 'text',
+                'contact.telNumber': 'text',
+            },
+            options: {
+                weights: {
+                    _id: 8,
+                    userId: 3,
+                    orderNumber: 6,
+                    'contact.telNumber': 5,
+                    'contact.emailAddress': 4,
+                    status: 1,
                 },
+                name: 'order_fulltext_search',
             },
-        ]);
-    }
+        },
+    ]);
     await buildDbIndexes(Orders, [
-        { index: { deleted: 1 } },
-        { index: { userId: 1 } },
-        { index: { status: 1 } },
-        { index: { orderNumber: 1 } },
+        { index: { userId: 1, status: 1 } },
+        { index: { status: 1, updated: 1 } },
+        { index: { orderNumber: 1 }, options: { sparse: true } },
     ]);
     return Orders;
 };

package/lib/migrations/20260625120000-normalize-contact-phone.d.ts

@@ -0,0 +1,2 @@
+import type { MigrationRepository } from '@unchainedshop/mongodb';
+export default function normalizeContactPhone(repository: MigrationRepository): void;

package/lib/migrations/20260625120000-normalize-contact-phone.js

@@ -0,0 +1,27 @@
+import { normalizePhoneNumber } from '@unchainedshop/utils';
+import { OrdersCollection } from "../orders-index.js";
+export default function normalizeContactPhone(repository) {
+    repository?.register({
+        id: 20260625120000,
+        name: 'Normalize order.contact.telNumber to E.164 format',
+        up: async ({ logger }) => {
+            const Orders = await OrdersCollection(repository.db);
+            const orders = await Orders.find({ 'contact.telNumber': { $exists: true, $nin: [null, ''] } }, { projection: { _id: true, contact: true, billingAddress: true, countryCode: true } }).toArray();
+            let changed = 0;
+            let skipped = 0;
+            for (const order of orders) {
+                const current = order.contact?.telNumber;
+                const defaultCountry = order.billingAddress?.countryCode || order.countryCode;
+                const normalized = normalizePhoneNumber(current, defaultCountry);
+                if (!normalized || normalized === current) {
+                    if (!normalized)
+                        skipped += 1;
+                    continue;
+                }
+                await Orders.updateOne({ _id: order._id }, { $set: { 'contact.telNumber': normalized } });
+                changed += 1;
+            }
+            logger?.info(`Normalize order.contact.telNumber: ${changed} updated, ${skipped} left unchanged (unparseable)`);
+        },
+    });
+}

package/lib/module/buildFindSelector.js

@@ -1,4 +1,4 @@
-import { assertDocumentDBCompatMode, mongodb } from '@unchainedshop/mongodb';
+import { mongodb } from '@unchainedshop/mongodb';
 export const buildFindSelector = ({ includeCarts, status, userId, queryString, paymentIds, deliveryIds, dateRange, orderIds, }) => {
     const selector = {};
     if (userId) {
@@ -30,7 +30,6 @@ export const buildFindSelector = ({ includeCarts, status, userId, queryString, p
         selector.status = { $ne: null };
     }
     if (queryString) {
-        assertDocumentDBCompatMode();
         selector.$text = { $search: queryString };
     }
     return selector;

package/lib/module/configureOrderDiscountsModule.js

@@ -14,7 +14,7 @@ export const configureOrderDiscountsModule = ({ OrderDiscounts, }) => {
             return OrderDiscounts.findOne(buildFindOrderDiscountByIdSelector(discountId), options);
         },
         findOrderDiscounts: async ({ orderId }) => {
-            const discounts = OrderDiscounts.find({ orderId });
+            const discounts = OrderDiscounts.find({ orderId }, { sort: { created: 1 } });
             return discounts.toArray();
         },
         create: async (doc) => {

package/lib/module/configureOrderPositionsModule.js

@@ -14,7 +14,7 @@ export const configureOrderPositionsModule = ({ OrderPositions, }) => {
             return OrderPositions.findOne(buildFindOrderPositionByIdSelector(itemId), options);
         },
         findOrderPositions: async ({ orderId }) => {
-            const positions = OrderPositions.find({ orderId, quantity: { $gt: 0 } });
+            const positions = OrderPositions.find({ orderId, quantity: { $gt: 0 } }, { sort: { created: 1 } });
             return positions.toArray();
         },
         delete: async (orderPositionId) => {

package/lib/module/configureOrdersModule-mutations.js

@@ -1,4 +1,5 @@
 import { emit, registerEvents } from '@unchainedshop/events';
+import { normalizePhoneNumber } from '@unchainedshop/utils';
 import { generateDbFilterById, generateDbObjectId, mongodb, } from '@unchainedshop/mongodb';
 import { OrderStatus } from "../db/OrdersCollection.js";
 const ORDER_EVENTS = [
@@ -10,6 +11,14 @@ const ORDER_EVENTS = [
 ];
 export const configureOrderModuleMutations = ({ Orders, OrderPositions, }) => {
     registerEvents(ORDER_EVENTS);
+    const normalizeContactPhone = (contact, defaultCountry) => {
+        if (!contact?.telNumber)
+            return contact;
+        return {
+            ...contact,
+            telNumber: normalizePhoneNumber(contact.telNumber, defaultCountry) || contact.telNumber,
+        };
+    };
     return {
         create: async ({ userId, orderNumber, currencyCode, countryCode, billingAddress, contact, context, }) => {
             const { insertedId: orderId } = await Orders.insertOne({
@@ -17,7 +26,7 @@ export const configureOrderModuleMutations = ({ Orders, OrderPositions, }) => {
                 created: new Date(),
                 status: null,
                 billingAddress,
-                contact,
+                contact: normalizeContactPhone(contact, billingAddress?.countryCode || countryCode),
                 userId,
                 currencyCode,
                 countryCode,
@@ -66,9 +75,13 @@ export const configureOrderModuleMutations = ({ Orders, OrderPositions, }) => {
         },
         updateContact: async (orderId, contact) => {
             const selector = generateDbFilterById(orderId);
+            const existing = await Orders.findOne(selector, {
+                projection: { billingAddress: true, countryCode: true },
+            });
+            const defaultCountry = existing?.billingAddress?.countryCode || existing?.countryCode;
             const order = await Orders.findOneAndUpdate(selector, {
                 $set: {
-                    contact,
+                    contact: normalizeContactPhone(contact, defaultCountry),
                     updated: new Date(),
                 },
             }, { returnDocument: 'after' });
@@ -113,7 +126,14 @@ export const configureOrderModuleMutations = ({ Orders, OrderPositions, }) => {
                 $set.billingAddress = updates.billingAddress;
             }
             if (updates.contact) {
-                $set.contact = updates.contact;
+                let defaultCountry = updates.billingAddress?.countryCode;
+                if (!defaultCountry && updates.contact.telNumber) {
+                    const existing = await Orders.findOne(generateDbFilterById(orderId), {
+                        projection: { billingAddress: true, countryCode: true },
+                    });
+                    defaultCountry = existing?.billingAddress?.countryCode || existing?.countryCode;
+                }
+                $set.contact = normalizeContactPhone(updates.contact, defaultCountry);
             }
             if (updates.meta && Object.keys(updates.meta).length > 0) {
                 const contextSetters = Object.fromEntries(Object.entries(updates.meta).map(([key, value]) => [`context.${key}`, value]));

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

@@ -48,12 +48,16 @@ export declare const configureOrdersModuleQueries: ({ Orders }: {
         orderNumber?: string;
         userId: string;
     }) => Promise<mongodb.WithId<Order> | null>;
+    findCarts: ({ userIds }: {
+        userIds: string[];
+    }, options?: mongodb.FindOptions) => Promise<Order[]>;
     count: (query: OrderQuery) => Promise<number>;
     findOrder: ({ orderId, orderNumber, }: {
         orderId?: string;
         orderNumber?: string;
     }, options?: mongodb.FindOptions) => Promise<Order | null>;
-    findCartsToInvalidate: (maxAgeDays?: number) => Promise<mongodb.WithId<Order>[]>;
+    findCartUserIds: () => Promise<string[]>;
+    findCartIdsToInvalidate: (maxAgeDays?: number) => Promise<string[]>;
     findOrders: ({ limit, offset, queryString, sort, ...query }: OrderQuery & {
         limit?: number;
         offset?: number;

package/lib/module/configureOrdersModule-queries.js

@@ -33,6 +33,9 @@ export const configureOrdersModuleQueries = ({ Orders }) => {
             };
             return Orders.findOne(selector, options);
         },
+        findCarts: async ({ userIds }, options) => {
+            return Orders.find({ status: { $eq: null }, userId: { $in: userIds } }, { sort: { updated: -1 }, ...options }).toArray();
+        },
         count: async (query) => {
             const orderCount = await Orders.countDocuments(buildFindSelector(query));
             return orderCount;
@@ -41,14 +44,16 @@ export const configureOrdersModuleQueries = ({ Orders }) => {
             const selector = orderId ? generateDbFilterById(orderId) : { orderNumber };
             return Orders.findOne(selector, options);
         },
-        findCartsToInvalidate: async (maxAgeDays = 30) => {
+        findCartUserIds: async () => {
+            return Orders.distinct('userId', { status: { $eq: null } });
+        },
+        findCartIdsToInvalidate: async (maxAgeDays = 30) => {
             const ONE_DAY_IN_MILLISECONDS = 86400000;
             const minValidDate = new Date(new Date().getTime() - maxAgeDays * ONE_DAY_IN_MILLISECONDS);
-            const orders = await Orders.find({
+            return Orders.distinct('_id', {
                 status: { $eq: null },
                 updated: { $gte: minValidDate },
-            }).toArray();
-            return orders;
+            });
         },
         findOrders: async ({ limit, offset, queryString, sort, ...query }, options) => {
             const defaultSortOption = [{ key: 'created', value: SortDirection.DESC }];

package/lib/module/configureOrdersModule.d.ts

@@ -105,7 +105,9 @@ 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<import("@kontsedal/locco").Lock>;
+    acquireLock: (orderId: string, identifier: string, timeout?: number) => Promise<{
+        release: () => Promise<void>;
+    }>;
     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, }: {
@@ -142,12 +144,16 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
         orderNumber?: string;
         userId: string;
     }) => Promise<mongodb.WithId<Order> | null>;
+    findCarts: ({ userIds }: {
+        userIds: string[];
+    }, options?: mongodb.FindOptions) => Promise<Order[]>;
     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>[]>;
+    findCartUserIds: () => Promise<string[]>;
+    findCartIdsToInvalidate: (maxAgeDays?: number) => Promise<string[]>;
     findOrders: ({ limit, offset, queryString, sort, ...query }: import("../db/OrdersCollection.ts").OrderQuery & {
         limit?: number;
         offset?: number;

package/lib/module/configureOrdersModule.js

@@ -1,6 +1,6 @@
-import { Locker, MongoAdapter } from '@kontsedal/locco';
 import { generateDbFilterById, mongodb } from '@unchainedshop/mongodb';
 import { OrderDeliveriesCollection } from "../db/OrderDeliveriesCollection.js";
+import { OrderLocksCollection, acquireLock } from "../db/OrderLocksCollection.js";
 import { OrderDiscountsCollection } from "../db/OrderDiscountsCollection.js";
 import { OrderPaymentsCollection } from "../db/OrderPaymentsCollection.js";
 import { OrderPositionsCollection } from "../db/OrderPositionsCollection.js";
@@ -14,6 +14,7 @@ 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";
+import normalizeOrderContactPhone from "../migrations/20260625120000-normalize-contact-phone.js";
 const ORDER_EVENTS = [
     'ORDER_CHECKOUT',
     'ORDER_CONFIRMED',
@@ -22,6 +23,7 @@ const ORDER_EVENTS = [
 ];
 export const configureOrdersModule = async ({ db, migrationRepository, options: orderOptions = {}, }) => {
     renameCurrencyCode(migrationRepository);
+    normalizeOrderContactPhone(migrationRepository);
     registerEvents(ORDER_EVENTS);
     ordersSettings.configureSettings(orderOptions);
     const Orders = await OrdersCollection(db);
@@ -29,15 +31,7 @@ export const configureOrdersModule = async ({ db, migrationRepository, options:
     const OrderDiscounts = await OrderDiscountsCollection(db);
     const OrderPayments = await OrderPaymentsCollection(db);
     const OrderPositions = await OrderPositionsCollection(db);
-    const mongoAdapter = new MongoAdapter({
-        client: {
-            db: () => db,
-        },
-    });
-    const locker = new Locker({
-        adapter: mongoAdapter,
-        retrySettings: { retryDelay: 200, retryTimes: 10 },
-    });
+    const OrderLocks = await OrderLocksCollection(db);
     const orderQueries = configureOrdersModuleQueries({ Orders });
     const orderMutations = configureOrderModuleMutations({
         Orders,
@@ -137,7 +131,7 @@ export const configureOrdersModule = async ({ db, migrationRepository, options:
             return modificationResult.value || Orders.findOne(selector, {});
         },
         acquireLock: async (orderId, identifier, timeout = 5000) => {
-            return await locker.lock(`order:${identifier}:${orderId}`, timeout).acquire();
+            return acquireLock(OrderLocks, `order:${identifier}:${orderId}`, timeout);
         },
         setDeliveryProvider: async (orderId, deliveryProviderId) => {
             const delivery = await OrderDeliveries.findOne({

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unchainedshop/core-orders",
   "description": "Order management module for the Unchained Engine",
-  "version": "5.0.0-alpha.1",
+  "version": "5.0.0-alpha.3",
   "main": "lib/orders-index.js",
   "types": "lib/orders-index.d.ts",
   "type": "module",
@@ -35,13 +35,12 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "dependencies": {
-    "@kontsedal/locco": "^1.1.0",
     "@unchainedshop/events": "^5.0.0-alpha.1",
-    "@unchainedshop/logger": "^5.0.0-alpha.1",
+    "@unchainedshop/mongodb": "^5.0.0-alpha.1",
     "@unchainedshop/utils": "^5.0.0-alpha.1"
   },
   "devDependencies": {
-    "@types/node": "^25.0.0",
+    "@types/node": "^26.2.0",
     "typescript": "^5.8.3"
   }
 }