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

package/README.md

@@ -13,126 +13,18 @@ npm install @unchainedshop/core-orders
 
 ## Usage
 
-```typescript
-import { configureOrdersModule, OrderStatus } from '@unchainedshop/core-orders';
-
-const ordersModule = await configureOrdersModule({ db });
-
-// Create an order
-const orderId = await ordersModule.create({
-  userId: 'user-123',
-  currency: 'CHF',
-  countryCode: 'CH',
-});
+The platform initializes this module as `platform.unchainedAPI.modules.orders`.
 
-// Add position to order
-await ordersModule.positions.create({
-  orderId,
-  productId: 'product-456',
-  quantity: 2,
-});
+```typescript
+const { orders } = platform.unchainedAPI.modules;
 
-// Checkout order
-await ordersModule.checkout(orderId, { paymentContext: {} });
+const order = await orders.findOrder({ orderId: 'order-123' });
+const userOrders = await orders.findOrders({ userId: 'user-123', limit: 20 });
 ```
 
-## API Overview
-
-### Module Configuration
-
-| Export | Description |
-|--------|-------------|
-| `configureOrdersModule` | Configure and return the orders module |
-
-### Queries
-
-| Method | Description |
-|--------|-------------|
-| `findOrder` | Find order by ID or number |
-| `findOrders` | Find orders with filtering and pagination |
-| `count` | Count orders matching query |
-| `orderExists` | Check if order exists |
-
-### Mutations
-
-| Method | Description |
-|--------|-------------|
-| `create` | Create a new order |
-| `update` | Update order data |
-| `delete` | Delete an order |
-| `checkout` | Process order checkout |
-| `confirm` | Confirm an order |
-| `reject` | Reject an order |
-| `setPaymentProvider` | Set payment provider |
-| `setDeliveryProvider` | Set delivery provider |
-
-### Submodules
-
-#### Positions (`orders.positions`)
-| Method | Description |
-|--------|-------------|
-| `findPositions` | Find order positions |
-| `create` | Add position to order |
-| `update` | Update position |
-| `delete` | Remove position |
-
-#### Payments (`orders.payments`)
-| Method | Description |
-|--------|-------------|
-| `findPayment` | Find order payment |
-| `create` | Create payment for order |
-| `markPaid` | Mark payment as paid |
-| `charge` | Charge the payment |
-
-#### Deliveries (`orders.deliveries`)
-| Method | Description |
-|--------|-------------|
-| `findDelivery` | Find order delivery |
-| `create` | Create delivery for order |
-| `markDelivered` | Mark as delivered |
-| `send` | Trigger delivery |
-
-#### Discounts (`orders.discounts`)
-| Method | Description |
-|--------|-------------|
-| `findDiscounts` | Find order discounts |
-| `create` | Add discount to order |
-| `delete` | Remove discount |
-
-### Constants
-
-| Export | Description |
-|--------|-------------|
-| `OrderStatus` | Order status values (OPEN, PENDING, CONFIRMED, FULFILLED, REJECTED) |
-
-### Settings
-
-| Export | Description |
-|--------|-------------|
-| `ordersSettings` | Access order module settings |
-
-### Types
-
-| Export | Description |
-|--------|-------------|
-| `Order` | Order document type |
-| `OrderPosition` | Position document type |
-| `OrderPayment` | Payment document type |
-| `OrderDelivery` | Delivery document type |
-| `OrderDiscount` | Discount document type |
-| `OrdersModule` | Module interface type |
-
-## Events
+Order positions, payments, deliveries, discounts, and statistics are exposed through the corresponding submodules. Use `unchainedAPI.services.orders` or the GraphQL API for cart operations and checkout so pricing, validation, payment, and delivery are coordinated.
 
-| Event | Description |
-|-------|-------------|
-| `ORDER_CREATE` | Order created |
-| `ORDER_UPDATE` | Order updated |
-| `ORDER_REMOVE` | Order deleted |
-| `ORDER_CHECKOUT` | Order checked out |
-| `ORDER_CONFIRMED` | Order confirmed |
-| `ORDER_REJECTED` | Order rejected |
-| `ORDER_FULFILLED` | Order fulfilled |
+See the [module guide](https://docs.unchained.shop/platform-configuration/modules/orders), [checkout guide](https://docs.unchained.shop/guides/checkout-implementation), [public exports](src/orders-index.ts), and [module implementation](src/module/configureOrdersModule.ts).
 
 ## License
 

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/migrations/20260907120000-order-calculation-net.d.ts

@@ -0,0 +1,4 @@
+import type { MigrationRepository } from '@unchainedshop/mongodb';
+import type { PricingCalculation } from '@unchainedshop/utils';
+export declare const convertOrderCalculationToNet: (calculation: PricingCalculation[]) => PricingCalculation[];
+export default function migrateOrderCalculationToNet(repository: MigrationRepository): void;

package/lib/migrations/20260907120000-order-calculation-net.js

@@ -0,0 +1,125 @@
+import { OrdersCollection } from "../db/OrdersCollection.js";
+const legacyCalculationSelector = {
+    'calculation.0': { $exists: true },
+    calculation: {
+        $not: { $elemMatch: { category: { $ne: 'TAXES' }, isNetPrice: true } },
+    },
+};
+export const convertOrderCalculationToNet = (calculation) => {
+    let previousBaseRow;
+    const attributed = calculation.map((row) => {
+        if (!row || !Number.isFinite(row.amount)) {
+            throw new Error('Calculation contains an invalid amount');
+        }
+        if (row.category !== 'TAXES') {
+            previousBaseRow = row;
+            return row;
+        }
+        const baseCategory = row.baseCategory || previousBaseRow?.category;
+        if (!baseCategory || baseCategory === 'TAXES') {
+            throw new Error('Cannot determine the base category of a tax row');
+        }
+        const discountId = row.discountId ??
+            (previousBaseRow?.category === baseCategory ? previousBaseRow.discountId : undefined);
+        return { ...row, baseCategory, discountId, isNetPrice: false };
+    });
+    const converted = attributed.flatMap((row) => {
+        if (row.category !== 'TAXES')
+            return [row];
+        return [
+            {
+                category: row.baseCategory,
+                amount: -row.amount,
+                discountId: row.discountId,
+                isNetPrice: true,
+                meta: row.meta,
+            },
+            row,
+        ];
+    });
+    const sum = (rows, category, discountId) => rows.reduce((total, row) => (category === undefined || row.category === category) &&
+        (discountId === undefined || row.discountId === discountId)
+        ? total + row.amount
+        : total, 0);
+    const taxes = attributed.filter((row) => row.category === 'TAXES');
+    const taxSum = (category, discountId) => sum(category === undefined ? taxes : taxes.filter((row) => row.baseCategory === category), undefined, discountId);
+    const categories = [
+        ...new Set(attributed.map((row) => (row.category === 'TAXES' ? row.baseCategory : row.category))),
+    ];
+    const discountIds = [...new Set(attributed.map((row) => row.discountId))].filter((discountId) => discountId !== undefined);
+    let roundingCategory = 'ROUNDING';
+    while (categories.includes(roundingCategory))
+        roundingCategory = `_${roundingCategory}`;
+    const scopes = [
+        ...categories.flatMap((category) => [
+            ...discountIds.map((discountId) => ({ category, discountId })),
+            { category, discountId: undefined },
+        ]),
+        ...discountIds.map((discountId) => ({ category: undefined, discountId })),
+        { category: undefined, discountId: undefined },
+    ];
+    const balances = scopes.map(({ category, discountId }) => ({
+        category,
+        discountId,
+        amount: sum(attributed, category, discountId) - taxSum(category, discountId),
+    }));
+    for (const { category, discountId, amount } of balances) {
+        const difference = amount - sum(converted, category, discountId);
+        if (!Number.isFinite(amount) || !Number.isFinite(difference)) {
+            throw new Error('Calculation contains an invalid balance');
+        }
+        if (difference) {
+            converted.push({
+                category: category ?? roundingCategory,
+                discountId,
+                amount: difference,
+                isNetPrice: true,
+                meta: { migration: 20260907120000, reason: 'Preserve historical floating-point balance' },
+            });
+        }
+    }
+    for (const { category, discountId, amount } of balances) {
+        if (sum(converted, category, discountId) !== amount) {
+            throw new Error(`Cannot preserve historical balance for ${category ?? 'order'} ${discountId ?? ''}`);
+        }
+    }
+    for (const discountId of discountIds) {
+        const before = sum(attributed, 'DISCOUNTS', discountId);
+        const after = sum(converted, 'DISCOUNTS', discountId) + taxSum('DISCOUNTS', discountId);
+        if (Math.round(before) !== Math.round(after) || Boolean(before) !== Boolean(after)) {
+            throw new Error(`Cannot preserve historical discount ${discountId}`);
+        }
+    }
+    return converted;
+};
+export default function migrateOrderCalculationToNet(repository) {
+    repository?.register({
+        id: 20260907120000,
+        name: 'Convert persisted order calculations from gross to net category balances',
+        up: async ({ logger }) => {
+            const Orders = await OrdersCollection(repository.db);
+            const projection = { _id: 1, calculation: 1 };
+            let migrated = 0;
+            for await (const order of Orders.find(legacyCalculationSelector, { projection })) {
+                let calculation;
+                try {
+                    calculation = convertOrderCalculationToNet(order.calculation);
+                }
+                catch (error) {
+                    throw new Error(`Cannot migrate order ${order._id}: ${error.message}`, { cause: error });
+                }
+                if (!calculation.some((row) => row.isNetPrice === true)) {
+                    calculation = calculation.map((row) => ({ ...row, isNetPrice: true }));
+                }
+                const result = await Orders.updateOne({ _id: order._id, calculation: order.calculation }, { $set: { calculation } });
+                if (result.matchedCount) {
+                    migrated += 1;
+                }
+                else if (await Orders.findOne({ _id: order._id, ...legacyCalculationSelector }, { projection })) {
+                    throw new Error(`Order ${order._id} changed during migration; retry after stopping old writers`);
+                }
+            }
+            logger?.info(`Converted ${migrated} order calculation(s) to net category balances`);
+        },
+    });
+}

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

@@ -8,6 +8,9 @@ export declare const configureOrderDeliveriesModule: ({ OrderDeliveries, }: {
     findDelivery: ({ orderDeliveryId }: {
         orderDeliveryId: string;
     }, options?: mongodb.FindOptions) => Promise<OrderDelivery | null>;
+    findDeliveries: ({ orderDeliveryIds }: {
+        orderDeliveryIds: string[];
+    }, options?: mongodb.FindOptions) => Promise<OrderDelivery[]>;
     findDeliveryByProvidersId: ({ deliveryProviderIds }: {
         deliveryProviderIds: string[];
     }, options?: mongodb.FindOptions) => Promise<OrderDelivery[]>;

package/lib/module/configureOrderDeliveriesModule.js

@@ -32,6 +32,11 @@ export const configureOrderDeliveriesModule = ({ OrderDeliveries, }) => {
         findDelivery: async ({ orderDeliveryId }, options) => {
             return OrderDeliveries.findOne(buildFindByIdSelector(orderDeliveryId), options);
         },
+        findDeliveries: async ({ orderDeliveryIds }, options) => {
+            if (!orderDeliveryIds?.length)
+                return [];
+            return OrderDeliveries.find({ _id: { $in: orderDeliveryIds } }, options).toArray();
+        },
         findDeliveryByProvidersId: async ({ deliveryProviderIds }, options) => {
             if (!deliveryProviderIds?.length)
                 return [];

package/lib/module/configureOrderDiscountsModule.d.ts

@@ -7,8 +7,10 @@ export declare const configureOrderDiscountsModule: ({ OrderDiscounts, }: {
     findOrderDiscount: ({ discountId }: {
         discountId: string;
     }, options?: mongodb.FindOptions) => Promise<OrderDiscount | null>;
-    findOrderDiscounts: ({ orderId }: {
+    findOrderDiscounts: (query: {
         orderId: string;
+    } | {
+        orderIds: string[];
     }) => Promise<OrderDiscount[]>;
     create: (doc: Omit<OrderDiscount, "_id" | "created" | "trigger"> & Pick<Partial<OrderDiscount>, "_id" | "created" | "trigger">) => Promise<OrderDiscount>;
     delete: (orderDiscountId: string) => Promise<mongodb.WithId<OrderDiscount> | null>;

package/lib/module/configureOrderDiscountsModule.js

@@ -13,8 +13,11 @@ export const configureOrderDiscountsModule = ({ OrderDiscounts, }) => {
         findOrderDiscount: async ({ discountId }, options) => {
             return OrderDiscounts.findOne(buildFindOrderDiscountByIdSelector(discountId), options);
         },
-        findOrderDiscounts: async ({ orderId }) => {
-            const discounts = OrderDiscounts.find({ orderId });
+        findOrderDiscounts: async (query) => {
+            if ('orderIds' in query && !query.orderIds.length)
+                return [];
+            const orderId = 'orderIds' in query ? { $in: query.orderIds } : query.orderId;
+            const discounts = OrderDiscounts.find({ orderId }, { sort: { created: 1, _id: 1 } });
             return discounts.toArray();
         },
         create: async (doc) => {

package/lib/module/configureOrderPaymentsModule.d.ts

@@ -8,6 +8,9 @@ export declare const configureOrderPaymentsModule: ({ OrderPayments, }: {
     findOrderPayment: ({ orderPaymentId, }: {
         orderPaymentId: string;
     }, options?: mongodb.FindOptions) => Promise<OrderPayment | null>;
+    findOrderPayments: ({ orderPaymentIds }: {
+        orderPaymentIds: string[];
+    }, options?: mongodb.FindOptions) => Promise<OrderPayment[]>;
     findOrderPaymentsByProviderIds: ({ paymentProviderIds, }: {
         paymentProviderIds: string[];
     }, options?: mongodb.FindOptions) => Promise<OrderPayment[]>;

package/lib/module/configureOrderPaymentsModule.js

@@ -1,7 +1,7 @@
 import { emit, registerEvents } from '@unchainedshop/events';
 import { generateDbFilterById, generateDbObjectId, mongodb } from '@unchainedshop/mongodb';
 import { OrderPaymentStatus } from "../db/OrderPaymentsCollection.js";
-const ORDER_PAYMENT_EVENTS = ['ORDER_UPDATE_PAYMENT', 'ORDER_SIGN_PAYMENT', 'ORDER_PAY'];
+const ORDER_PAYMENT_EVENTS = ['ORDER_UPDATE_PAYMENT', 'ORDER_PAY'];
 export const buildFindOrderPaymentByIdSelector = (orderPaymentId) => generateDbFilterById(orderPaymentId);
 export const configureOrderPaymentsModule = ({ OrderPayments, }) => {
     registerEvents(ORDER_PAYMENT_EVENTS);
@@ -35,6 +35,11 @@ export const configureOrderPaymentsModule = ({ OrderPayments, }) => {
         findOrderPayment: async ({ orderPaymentId, }, options) => {
             return OrderPayments.findOne(buildFindOrderPaymentByIdSelector(orderPaymentId), options);
         },
+        findOrderPayments: async ({ orderPaymentIds }, options) => {
+            if (!orderPaymentIds?.length)
+                return [];
+            return OrderPayments.find({ _id: { $in: orderPaymentIds } }, options).toArray();
+        },
         findOrderPaymentsByProviderIds: async ({ paymentProviderIds, }, options) => {
             if (!paymentProviderIds?.length)
                 return [];

package/lib/module/configureOrderPositionsModule.d.ts

@@ -23,8 +23,10 @@ export declare const configureOrderPositionsModule: ({ OrderPositions, }: {
     findOrderPosition: ({ itemId }: {
         itemId: string;
     }, options?: mongodb.FindOptions) => Promise<OrderPosition | null>;
-    findOrderPositions: ({ orderId }: {
+    findOrderPositions: (query: {
         orderId: string;
+    } | {
+        orderIds: string[];
     }) => Promise<OrderPosition[]>;
     delete: (orderPositionId: string) => Promise<mongodb.WithId<OrderPosition> | null>;
     removePositions: ({ orderId }: {

package/lib/module/configureOrderPositionsModule.js

@@ -13,8 +13,11 @@ export const configureOrderPositionsModule = ({ OrderPositions, }) => {
         findOrderPosition: async ({ itemId }, options) => {
             return OrderPositions.findOne(buildFindOrderPositionByIdSelector(itemId), options);
         },
-        findOrderPositions: async ({ orderId }) => {
-            const positions = OrderPositions.find({ orderId, quantity: { $gt: 0 } });
+        findOrderPositions: async (query) => {
+            if ('orderIds' in query && !query.orderIds.length)
+                return [];
+            const orderId = 'orderIds' in query ? { $in: query.orderIds } : query.orderId;
+            const positions = OrderPositions.find({ orderId, quantity: { $gt: 0 } }, { sort: { created: 1, _id: 1 } });
             return positions.toArray();
         },
         delete: async (orderPositionId) => {

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

@@ -5,7 +5,7 @@ export declare const configureOrderModuleMutations: ({ Orders, OrderPositions, }
     Orders: mongodb.Collection<Order>;
     OrderPositions: mongodb.Collection<OrderPosition>;
 }) => {
-    create: ({ userId, orderNumber, currencyCode, countryCode, billingAddress, contact, context, }: {
+    create: ({ userId, orderNumber, currencyCode, countryCode, billingAddress, contact, originEnrollmentId, context, }: {
         userId: string;
         billingAddress?: Address;
         contact?: Contact;

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,20 +11,29 @@ 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, }) => {
+        create: async ({ userId, orderNumber, currencyCode, countryCode, billingAddress, contact, originEnrollmentId, context, }) => {
             const { insertedId: orderId } = await Orders.insertOne({
                 _id: generateDbObjectId(),
                 created: new Date(),
                 status: null,
                 billingAddress,
-                contact,
+                contact: normalizeContactPhone(contact, billingAddress?.countryCode || countryCode),
                 userId,
                 currencyCode,
                 countryCode,
                 calculation: [],
                 log: [],
                 orderNumber,
+                originEnrollmentId,
                 context: context || {},
             });
             const order = (await Orders.findOne(generateDbFilterById(orderId), {}));
@@ -66,9 +76,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 +127,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

@@ -29,10 +29,14 @@ export const configureOrdersModuleQueries = ({ Orders }) => {
             const options = {
                 sort: {
                     updated: -1,
+                    _id: -1,
                 },
             };
             return Orders.findOne(selector, options);
         },
+        findCarts: async ({ userIds }, options) => {
+            return Orders.find({ status: { $eq: null }, userId: { $in: userIds } }, { sort: { updated: -1, _id: -1 }, ...options }).toArray();
+        },
         count: async (query) => {
             const orderCount = await Orders.countDocuments(buildFindSelector(query));
             return orderCount;
@@ -41,14 +45,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 }];
@@ -60,6 +66,7 @@ export const configureOrdersModuleQueries = ({ Orders }) => {
             const selector = buildFindSelector({ queryString, ...query });
             if (queryString) {
                 return Orders.find(selector, {
+                    ...findOptions,
                     ...options,
                     projection: { score: { $meta: 'textScore' } },
                     sort: { score: { $meta: 'textScore' } },
@@ -154,19 +161,26 @@ export const configureOrdersModuleQueries = ({ Orders }) => {
                             created: 1,
                             currencyCode: 1,
                             itemAmount: {
-                                $let: {
-                                    vars: {
-                                        item: {
-                                            $first: {
-                                                $filter: {
-                                                    input: '$calculation',
-                                                    as: 'c',
-                                                    cond: { $eq: ['$$c.category', 'ITEMS'] },
-                                                },
+                                $reduce: {
+                                    input: {
+                                        $filter: {
+                                            input: { $ifNull: ['$calculation', []] },
+                                            as: 'c',
+                                            cond: {
+                                                $or: [
+                                                    { $eq: ['$$c.category', 'ITEMS'] },
+                                                    {
+                                                        $and: [
+                                                            { $eq: ['$$c.category', 'TAXES'] },
+                                                            { $eq: ['$$c.baseCategory', 'ITEMS'] },
+                                                        ],
+                                                    },
+                                                ],
                                             },
                                         },
                                     },
-                                    in: '$$item.amount',
+                                    initialValue: 0,
+                                    in: { $add: ['$$value', { $ifNull: ['$$this.amount', 0] }] },
                                 },
                             },
                         },

package/lib/module/configureOrdersModule.d.ts

@@ -6,6 +6,9 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
         findDelivery: ({ orderDeliveryId }: {
             orderDeliveryId: string;
         }, options?: mongodb.FindOptions) => Promise<import("../db/OrderDeliveriesCollection.ts").OrderDelivery | null>;
+        findDeliveries: ({ orderDeliveryIds }: {
+            orderDeliveryIds: string[];
+        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderDeliveriesCollection.ts").OrderDelivery[]>;
         findDeliveryByProvidersId: ({ deliveryProviderIds }: {
             deliveryProviderIds: string[];
         }, options?: mongodb.FindOptions) => Promise<import("../db/OrderDeliveriesCollection.ts").OrderDelivery[]>;
@@ -25,8 +28,10 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
         findOrderDiscount: ({ discountId }: {
             discountId: string;
         }, options?: mongodb.FindOptions) => Promise<import("../db/OrderDiscountsCollection.ts").OrderDiscount | null>;
-        findOrderDiscounts: ({ orderId }: {
+        findOrderDiscounts: (query: {
             orderId: string;
+        } | {
+            orderIds: string[];
         }) => 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>;
@@ -44,8 +49,10 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
         findOrderPosition: ({ itemId }: {
             itemId: string;
         }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPositionsCollection.ts").OrderPosition | null>;
-        findOrderPositions: ({ orderId }: {
+        findOrderPositions: (query: {
             orderId: string;
+        } | {
+            orderIds: string[];
         }) => Promise<import("../db/OrderPositionsCollection.ts").OrderPosition[]>;
         delete: (orderPositionId: string) => Promise<mongodb.WithId<import("../db/OrderPositionsCollection.ts").OrderPosition> | null>;
         removePositions: ({ orderId }: {
@@ -84,6 +91,9 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
         findOrderPayment: ({ orderPaymentId, }: {
             orderPaymentId: string;
         }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPaymentsCollection.ts").OrderPayment | null>;
+        findOrderPayments: ({ orderPaymentIds }: {
+            orderPaymentIds: string[];
+        }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPaymentsCollection.ts").OrderPayment[]>;
         findOrderPaymentsByProviderIds: ({ paymentProviderIds, }: {
             paymentProviderIds: string[];
         }, options?: mongodb.FindOptions) => Promise<import("../db/OrderPaymentsCollection.ts").OrderPayment[]>;
@@ -105,10 +115,12 @@ 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, }: {
+    create: ({ userId, orderNumber, currencyCode, countryCode, billingAddress, contact, originEnrollmentId, context, }: {
         userId: string;
         billingAddress?: import("@unchainedshop/mongodb").Address;
         contact?: import("@unchainedshop/mongodb").Contact;
@@ -142,12 +154,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,8 @@ 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";
+import migrateOrderCalculationToNet from "../migrations/20260907120000-order-calculation-net.js";
 const ORDER_EVENTS = [
     'ORDER_CHECKOUT',
     'ORDER_CONFIRMED',
@@ -22,6 +24,8 @@ const ORDER_EVENTS = [
 ];
 export const configureOrdersModule = async ({ db, migrationRepository, options: orderOptions = {}, }) => {
     renameCurrencyCode(migrationRepository);
+    normalizeOrderContactPhone(migrationRepository);
+    migrateOrderCalculationToNet(migrationRepository);
     registerEvents(ORDER_EVENTS);
     ordersSettings.configureSettings(orderOptions);
     const Orders = await OrdersCollection(db);
@@ -29,15 +33,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 +133,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,10 @@
 {
   "name": "@unchainedshop/core-orders",
   "description": "Order management module for the Unchained Engine",
-  "version": "5.0.0-alpha.1",
+  "version": "5.0.0-alpha.10",
+  "files": [
+    "lib"
+  ],
   "main": "lib/orders-index.js",
   "types": "lib/orders-index.d.ts",
   "type": "module",
@@ -35,13 +38,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/utils": "^5.0.0-alpha.1"
+    "@unchainedshop/events": "^5.0.0-alpha.10",
+    "@unchainedshop/mongodb": "^5.0.0-alpha.10",
+    "@unchainedshop/utils": "^5.0.0-alpha.10"
   },
   "devDependencies": {
-    "@types/node": "^25.0.0",
-    "typescript": "^5.8.3"
+    "@types/node": "^26.2.0",
+    "typescript": "^6.0.3"
   }
 }