feat: add waitForLockRelease

Author: giladgd

.eslintrc.json

@@ -68,7 +68,10 @@
             "@typescript-eslint/parser": [".ts"]
         },
         "jsdoc": {
-            "exemptDestructuredRootsFromChecks": true
+            "exemptDestructuredRootsFromChecks": true,
+            "tagNamePreference": {
+                "hidden": "hidden"
+            }
         }
     },
     "rules": {

src/withLock.ts

@@ -5,7 +5,11 @@ const locks = new Map<any, Map<string, Promise<any>>>();
  */
 export async function withLock<ReturnType>(scope: any, key: string, callback: () => Promise<ReturnType>): Promise<ReturnType> {
     while (locks.get(scope)?.has(key)) {
-        await locks.get(scope)?.get(key);
+        try {
+            await locks.get(scope)?.get(key);
+        } catch (err) {
+            // we only need to wait here for the promise to resolve, we don't care about the result
+        }
     }
 
     const promise = callback();
@@ -60,6 +64,30 @@ export async function acquireLock<S = any, K extends string = string>(scope: S,
     };
 }
 
+/**
+ * Wait for a lock to be released for a given `scope` and `key`.
+ */
+export async function waitForLockRelease(scope: any, key: string): Promise<void> {
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        try {
+            await locks.get(scope)?.get(key);
+        } catch (err) {
+            // we only need to wait here for the promise to resolve, we don't care about the result
+        }
+
+        if (locks.get(scope)?.has(key))
+            continue;
+
+        await Promise.resolve(); // wait for a microtask to run, so other pending locks can be registered
+
+        if (locks.get(scope)?.has(key))
+            continue;
+
+        return;
+    }
+}
+
 export type Lock<S = any, K extends string = string> = {
     scope: S,
     key: K,

test/withLock.test.ts

@@ -1,5 +1,5 @@
 import {describe, expect, test} from "vitest";
-import {acquireLock, isLockActive, withLock} from "../src/index.js";
+import {acquireLock, isLockActive, waitForLockRelease, withLock} from "../src/index.js";
 
 describe("withLock", () => {
     test("lock works", async () => {
@@ -103,4 +103,56 @@ describe("withLock", () => {
 
         expect(res).toEqual([1, 2, 3]);
     });
+
+    test("waitForLockRelease", async () => {
+        const scope1 = {};
+        const key1 = "key";
+
+        const waitForEnoughMicrotasks = async () => {
+            for (let i = 0; i < 10; i++)
+                await Promise.resolve();
+        };
+
+        const lock1 = await acquireLock(scope1, key1);
+
+        const lockWithError2 = withLock(scope1, key1, async () => {
+            throw new Error("some error");
+        });
+
+        let lockReleased = false;
+        void (async () => {
+            await waitForLockRelease(scope1, key1);
+            lockReleased = true;
+        })();
+
+        const lock3Promise = acquireLock(scope1, key1);
+
+        expect(lockReleased).toBe(false);
+        await waitForEnoughMicrotasks();
+        expect(lockReleased).toBe(false);
+
+        lock1.dispose();
+        expect(lockReleased).toBe(false);
+        await waitForEnoughMicrotasks();
+        expect(lockReleased).toBe(false);
+
+        try {
+            await lockWithError2;
+            expect.unreachable("lockWithError2 should throw");
+        } catch (err) {
+            expect(lockReleased).toBe(false);
+            await waitForEnoughMicrotasks();
+            expect(lockReleased).toBe(false);
+        }
+
+        const lock2 = await lock3Promise;
+        expect(lockReleased).toBe(false);
+        await waitForEnoughMicrotasks();
+        expect(lockReleased).toBe(false);
+
+        lock2.dispose();
+
+        await waitForEnoughMicrotasks();
+        expect(lockReleased).toBe(true);
+    });
 });