@unchainedshop/core-orders 4.8.20 → 4.8.22

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

@@ -115,7 +115,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, }: {

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";
@@ -31,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,
@@ -139,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": "4.8.20",
+  "version": "4.8.22",
   "main": "lib/orders-index.js",
   "types": "lib/orders-index.d.ts",
   "type": "module",
@@ -35,9 +35,8 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "dependencies": {
-    "@kontsedal/locco": "^1.1.0",
     "@unchainedshop/events": "^4.8.12",
-    "@unchainedshop/logger": "^4.8.12",
+    "@unchainedshop/mongodb": "^4.8.12",
     "@unchainedshop/utils": "^4.8.12"
   },
   "devDependencies": {