feat(broker): await using BrokerLockItem.hold() for better resource…

… management

```
const broker = new BrokerLock(...);

{
   await using hold = await broker.item('my-lock', { ttl: 500 }).hold();

   //lock automatically released here.
}
```

jest-setup-runtime.js

@@ -0,0 +1,2 @@
+Symbol.dispose ??= Symbol("Symbol.dispose");
+Symbol.asyncDispose ??= Symbol("Symbol.asyncDispose");

packages/broker/package.json

@@ -58,6 +58,9 @@
     },
     "testMatch": [
       "**/tests/**/*.spec.ts"
+    ],
+    "setupFiles": [
+      "<rootDir>/../../jest-setup-runtime.js"
     ]
   },
   "gitHead": "56081823b559bb68b77a8781957af5d9c2e019a7"

packages/broker/src/broker.ts

@@ -272,10 +272,34 @@ export class BrokerLockItem {
     ) {
     }
 
+    async [Symbol.asyncDispose] () {
+        await this.release();
+    }
+
+    /**
+     * Disposable way of acquiring a lock. Automatically releases the lock when the returned object is disposed.
+     *
+     * @example
+     * ```typescript
+     * async function doSomething() {
+     *   async using hold = lock.hold();
+     *
+     *   // do stuff
+     *
+     *   // when out of scope, lock is automatically released.
+     * }
+     * ```
+     */
+    async hold() {
+        await this.acquire();
+        return this;
+    }
+
     /**
      * Returns true if the current lock object is the holder of the lock.
      *
      * This does not check whether the lock is acquired by someone else.
+     * Use isReserved() if you want to check that.
      */
     get acquired(): boolean {
         return this.releaser !== undefined;

packages/broker/tests/broker.spec.ts

@@ -106,6 +106,19 @@ test('lock', async () => {
     expect(lock1.acquired).toBe(false);
 });
 
+test('lock dispose', async () => {
+    const lock = new BrokerLock(await adapterFactory());
+
+    const lock1 = lock.item('my-lock', { ttl: 500 });
+
+    {
+        await using hold = await lock1.hold();
+        expect(lock1.acquired).toBe(true);
+    }
+
+    expect(lock1.acquired).toBe(false);
+});
+
 test('lock2', async () => {
     const lock = new BrokerLock(await adapterFactory());
 
@@ -171,7 +184,7 @@ test('queue message process exactly once options for broker channel', async () =
 
     await channel.produce({ id: 3, username: 'peter' });
 
-    expect(consumed).toBe(1)
+    expect(consumed).toBe(1);
 });
 
 test('queue message process exactly once with deduplication interval options for broker channel', async () => {