@unchainedshop/core-orders 4.9.0 → 4.9.1

package/lib/db/OrderLocksCollection.d.ts

@@ -7,4 +7,5 @@ export interface OrderLock {
 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>;
+    [Symbol.asyncDispose]: () => Promise<void>;
 }>;

package/lib/db/OrderLocksCollection.js

@@ -1,8 +1,8 @@
 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;
+const LOCK_WAIT_MS = 2000;
+const LOCK_RETRY_DELAY_MS = 50;
 export const OrderLocksCollection = async (db) => {
     const OrderLocks = db.collection('locco-locks');
     const success = await buildDbIndexes(OrderLocks, [
@@ -16,25 +16,38 @@ export const OrderLocksCollection = async (db) => {
 };
 export const acquireLock = async (OrderLocks, key, ttl) => {
     const uniqueValue = crypto.randomUUID();
-    for (let attempt = 0; attempt < LOCK_RETRIES; attempt += 1) {
+    const lease = () => ({ $set: { key, uniqueValue, expireAt: new Date(Date.now() + ttl) } });
+    const waitUntil = Date.now() + LOCK_WAIT_MS;
+    while (true) {
         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 {
-                    }
-                },
-            };
+            await OrderLocks.updateOne({ key, expireAt: { $lt: new Date() } }, lease(), { upsert: true });
+            break;
         }
         catch (error) {
             if (error?.code !== DUPLICATE_KEY)
                 throw error;
-            if (attempt < LOCK_RETRIES - 1)
-                await sleep(LOCK_RETRY_DELAY_MS);
         }
+        if (Date.now() > waitUntil)
+            throw new Error(`Could not acquire lock ${key}`, { cause: 'LOCKED' });
+        await sleep(LOCK_RETRY_DELAY_MS * (0.5 + Math.random()));
     }
-    throw new Error(`Could not acquire lock ${key}`);
+    const renewal = setInterval(async () => {
+        try {
+            const { matchedCount } = await OrderLocks.updateOne({ key, uniqueValue }, lease());
+            if (!matchedCount)
+                clearInterval(renewal);
+        }
+        catch {
+        }
+    }, ttl / 3);
+    renewal.unref?.();
+    const release = async () => {
+        clearInterval(renewal);
+        try {
+            await OrderLocks.deleteOne({ key, uniqueValue, expireAt: { $gt: new Date() } });
+        }
+        catch {
+        }
+    };
+    return { release, [Symbol.asyncDispose]: release };
 };

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

@@ -117,6 +117,7 @@ export declare const configureOrdersModule: ({ db, migrationRepository, options:
     }) => Promise<mongodb.WithId<Order> | null>;
     acquireLock: (orderId: string, identifier: string, timeout?: number) => Promise<{
         release: () => Promise<void>;
+        [Symbol.asyncDispose]: () => Promise<void>;
     }>;
     setDeliveryProvider: (orderId: string, deliveryProviderId: string) => Promise<mongodb.WithId<Order> | null>;
     setPaymentProvider: (orderId: string, paymentProviderId: string) => Promise<mongodb.WithId<Order> | null>;

package/lib/orders-settings.d.ts

@@ -12,7 +12,6 @@ export interface OrdersSettings {
     ensureUserHasCart: boolean;
     orderNumberHashFn: (order: Order, index: number) => string;
     validateOrderPosition: <UnchainedAPI = unknown>(validationParams: OrderSettingsOrderPositionValidation, unchainedAPI: UnchainedAPI) => Promise<void>;
-    lockOrderDuringCheckout: boolean;
     configureSettings: (options?: OrdersSettingsOptions) => void;
 }
 export type OrdersSettingsOptions = Omit<Partial<OrdersSettings>, 'configureSettings'>;

package/lib/orders-settings.js

@@ -8,11 +8,9 @@ export const ordersSettings = {
     ensureUserHasCart: false,
     orderNumberHashFn: generateRandomHash,
     validateOrderPosition: defaultValidateOrderPosition,
-    lockOrderDuringCheckout: false,
-    configureSettings({ ensureUserHasCart, orderNumberHashFn, validateOrderPosition, lockOrderDuringCheckout, } = {}) {
+    configureSettings({ ensureUserHasCart, orderNumberHashFn, validateOrderPosition } = {}) {
         this.ensureUserHasCart = ensureUserHasCart || false;
         this.orderNumberHashFn = orderNumberHashFn || generateRandomHash;
         this.validateOrderPosition = validateOrderPosition || defaultValidateOrderPosition;
-        this.lockOrderDuringCheckout = lockOrderDuringCheckout || false;
     },
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unchainedshop/core-orders",
   "description": "Order management module for the Unchained Engine",
-  "version": "4.9.0",
+  "version": "4.9.1",
   "main": "lib/orders-index.js",
   "types": "lib/orders-index.d.ts",
   "type": "module",
@@ -40,7 +40,7 @@
     "@unchainedshop/utils": "^4.9.0"
   },
   "devDependencies": {
-    "@types/node": "^26.6.5",
+    "@types/node": "^26.6.6",
     "typescript": "^6.0.3"
   }
 }