@unchainedshop/core-orders 4.8.26 → 4.8.28

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-queries.js

@@ -29,12 +29,13 @@ 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 }, ...options }).toArray();
+            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));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unchainedshop/core-orders",
   "description": "Order management module for the Unchained Engine",
-  "version": "4.8.26",
+  "version": "4.8.28",
   "main": "lib/orders-index.js",
   "types": "lib/orders-index.d.ts",
   "type": "module",
@@ -35,9 +35,9 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "dependencies": {
-    "@unchainedshop/events": "^4.8.12",
-    "@unchainedshop/mongodb": "^4.8.12",
-    "@unchainedshop/utils": "^4.8.12"
+    "@unchainedshop/events": "^4.8.27",
+    "@unchainedshop/mongodb": "^4.8.27",
+    "@unchainedshop/utils": "^4.8.27"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",