@nocobase/lock-manager 2.1.40 → 2.1.41

package/lib/lock-manager.d.ts

@@ -19,6 +19,8 @@ export type Releaser = () => void | Promise<void>;
  */
 export interface ILock {
     acquire(ttl: number): Releaser | Promise<Releaser>;
+    /** Extend the currently held lease from now, when supported by the adapter. */
+    extend?(ttl: number): void | Promise<void>;
     runExclusive<T>(fn: () => Promise<T>, ttl: number): Promise<T>;
     release(): void | Promise<void>;
 }

package/lib/lock-manager.js

@@ -112,43 +112,63 @@ const _LocalLockAdapter = class _LocalLockAdapter {
         throw new LockAcquireError("lock acquire timed out", { cause: e });
       }
     }
-    let preAcquiredConsumed = false;
-    const getRelease = /* @__PURE__ */ __name(async () => {
-      const rawRelease = !preAcquiredConsumed ? (preAcquiredConsumed = true, preAcquiredRelease) : await mutex.acquire();
-      let released = false;
-      return () => {
-        if (!released) {
-          released = true;
-          return rawRelease();
-        }
-      };
-    }, "getRelease");
+    let reservation = preAcquiredRelease;
+    let activeLease;
+    const releaseLease = /* @__PURE__ */ __name(async (lease) => {
+      if (activeLease !== lease) {
+        return;
+      }
+      activeLease = void 0;
+      if (lease.timer) {
+        clearTimeout(lease.timer);
+      }
+      await lease.release();
+    }, "releaseLease");
+    const resetTimer = /* @__PURE__ */ __name((ttl) => {
+      if (!activeLease) {
+        throw new LockAcquireError("lock is not active");
+      }
+      const lease = activeLease;
+      if (lease.timer) {
+        clearTimeout(lease.timer);
+      }
+      lease.timer = setTimeout(() => {
+        releaseLease(lease).catch(() => void 0);
+      }, ttl);
+    }, "resetTimer");
     return {
       release: /* @__PURE__ */ __name(async () => {
-        const release = await getRelease();
-        await release();
+        if (reservation) {
+          const releaseReservation = reservation;
+          reservation = void 0;
+          await releaseReservation();
+          return;
+        }
+        if (activeLease) {
+          await releaseLease(activeLease);
+        }
       }, "release"),
       acquire: /* @__PURE__ */ __name(async (ttl) => {
-        const release = await getRelease();
-        const timer = setTimeout(() => {
-          if (mutex.isLocked()) {
-            release();
-          }
-        }, ttl);
-        return () => {
-          release();
-          clearTimeout(timer);
-        };
+        const rawRelease = reservation || await mutex.acquire();
+        reservation = void 0;
+        const lease = { release: rawRelease };
+        activeLease = lease;
+        resetTimer(ttl);
+        return () => releaseLease(lease);
       }, "acquire"),
+      extend: /* @__PURE__ */ __name(async (ttl) => {
+        resetTimer(ttl);
+      }, "extend"),
       runExclusive: /* @__PURE__ */ __name(async (fn, ttl) => {
-        const release = await getRelease();
-        let timer;
+        const release = await (async () => {
+          const rawRelease = reservation || await mutex.acquire();
+          reservation = void 0;
+          const lease = { release: rawRelease };
+          activeLease = lease;
+          resetTimer(ttl);
+          return () => releaseLease(lease);
+        })();
         try {
-          timer = setTimeout(() => {
-            if (mutex.isLocked()) {
-              release();
-            }
-          }, ttl);
           return await fn();
         } catch (e) {
           if (e === import_async_mutex.E_CANCELED) {
@@ -157,8 +177,7 @@ const _LocalLockAdapter = class _LocalLockAdapter {
             throw e;
           }
         } finally {
-          clearTimeout(timer);
-          release();
+          await release();
         }
       }, "runExclusive")
     };

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@nocobase/lock-manager",
-  "version": "2.1.40",
+  "version": "2.1.41",
   "main": "lib/index.js",
   "license": "Apache-2.0",
   "devDependencies": {
-    "@nocobase/utils": "2.1.40",
+    "@nocobase/utils": "2.1.41",
     "async-mutex": "^0.5.0"
   },
-  "gitHead": "4099ac7037f46789c6eff98be54f20ae9fdde0e2"
+  "gitHead": "91c01d0941d758d97d8000d0c8b8a2a48af6c1ae"
 }

package/src/__tests__/lock-manager.test.ts

@@ -149,6 +149,7 @@ describe('lock manager', () => {
       await release();
       const lock = await lockManager.tryAcquire('test');
       expect(lock.acquire).toBeTypeOf('function');
+      expect(lock.extend).toBeTypeOf('function');
       expect(lock.runExclusive).toBeTypeOf('function');
 
       const order = [];
@@ -221,6 +222,19 @@ describe('lock manager', () => {
       await release2();
     });
 
+    it('tryAcquire: extends an active lease', async () => {
+      const lock = await lockManager.tryAcquire('extend-test');
+      const release = await lock.acquire(500);
+      await sleep(100);
+      await lock.extend(500);
+      await sleep(200);
+      await expect(lockManager.tryAcquire('extend-test')).rejects.toThrowError(LockAcquireError);
+      await release();
+
+      const nextLock = await lockManager.tryAcquire('extend-test');
+      await nextLock.release();
+    });
+
     it('tryAcquire: release() abandons the pre-acquired lock without executing work', async () => {
       // Acquire the lock via tryAcquire, then immediately release it.
       const lock = await lockManager.tryAcquire('cancel-test');

package/src/lock-manager.ts

@@ -24,6 +24,8 @@ export type Releaser = () => void | Promise<void>;
  */
 export interface ILock {
   acquire(ttl: number): Releaser | Promise<Releaser>;
+  /** Extend the currently held lease from now, when supported by the adapter. */
+  extend?(ttl: number): void | Promise<void>;
   runExclusive<T>(fn: () => Promise<T>, ttl: number): Promise<T>;
   release(): void | Promise<void>;
 }
@@ -123,49 +125,71 @@ class LocalLockAdapter implements ILockAdapter {
       }
     }
 
-    let preAcquiredConsumed = false;
-
-    const getRelease = async (): Promise<Releaser> => {
-      const rawRelease: Releaser = !preAcquiredConsumed
-        ? ((preAcquiredConsumed = true), preAcquiredRelease)
-        : ((await mutex.acquire()) as Releaser);
-      // Idempotency guard: prevents double-release when both the TTL auto-
-      // release timer and the caller-facing releaser (or finally block) fire.
-      let released = false;
-      return () => {
-        if (!released) {
-          released = true;
-          return (rawRelease as () => void | Promise<void>)();
+    let reservation: Releaser | undefined = preAcquiredRelease;
+    let activeLease:
+      | {
+          release: Releaser;
+          timer?: ReturnType<typeof setTimeout>;
         }
-      };
+      | undefined;
+
+    const releaseLease = async (lease: NonNullable<typeof activeLease>): Promise<void> => {
+      if (activeLease !== lease) {
+        return;
+      }
+      activeLease = undefined;
+      if (lease.timer) {
+        clearTimeout(lease.timer);
+      }
+      await lease.release();
+    };
+
+    const resetTimer = (ttl: number) => {
+      if (!activeLease) {
+        throw new LockAcquireError('lock is not active');
+      }
+      const lease = activeLease;
+      if (lease.timer) {
+        clearTimeout(lease.timer);
+      }
+      lease.timer = setTimeout(() => {
+        releaseLease(lease).catch(() => undefined);
+      }, ttl);
     };
 
     return {
       release: async (): Promise<void> => {
-        const release = await getRelease();
-        await release();
+        if (reservation) {
+          const releaseReservation = reservation;
+          reservation = undefined;
+          await releaseReservation();
+          return;
+        }
+        if (activeLease) {
+          await releaseLease(activeLease);
+        }
       },
       acquire: async (ttl: number): Promise<Releaser> => {
-        const release = await getRelease();
-        const timer: ReturnType<typeof setTimeout> = setTimeout(() => {
-          if (mutex.isLocked()) {
-            release();
-          }
-        }, ttl);
-        return () => {
-          release();
-          clearTimeout(timer);
-        };
+        const rawRelease = reservation || ((await mutex.acquire()) as Releaser);
+        reservation = undefined;
+        const lease = { release: rawRelease };
+        activeLease = lease;
+        resetTimer(ttl);
+        return () => releaseLease(lease);
+      },
+      extend: async (ttl: number): Promise<void> => {
+        resetTimer(ttl);
       },
       runExclusive: async <T>(fn: () => Promise<T>, ttl: number): Promise<T> => {
-        const release = await getRelease();
-        let timer: ReturnType<typeof setTimeout>;
+        const release = await (async () => {
+          const rawRelease = reservation || ((await mutex.acquire()) as Releaser);
+          reservation = undefined;
+          const lease = { release: rawRelease };
+          activeLease = lease;
+          resetTimer(ttl);
+          return () => releaseLease(lease);
+        })();
         try {
-          timer = setTimeout(() => {
-            if (mutex.isLocked()) {
-              release();
-            }
-          }, ttl);
           return await fn();
         } catch (e) {
           if (e === E_CANCELED) {
@@ -174,8 +198,7 @@ class LocalLockAdapter implements ILockAdapter {
             throw e;
           }
         } finally {
-          clearTimeout(timer);
-          release();
+          await release();
         }
       },
     };