feat: add forceRelease method

Author: Julien-R44

packages/verrou/src/drivers/database.ts

@@ -130,6 +130,13 @@ export class DatabaseStore implements LockStore {
     await this.#connection.table(this.#tableName).where('key', key).where('owner', owner).delete()
   }
 
+  /**
+   * Force delete a lock
+   */
+  async forceRelease(key: string) {
+    await this.#connection.table(this.#tableName).where('key', key).delete()
+  }
+
   /**
    * Check if a lock exists
    */

packages/verrou/src/drivers/dynamodb.ts

@@ -114,9 +114,25 @@ export class DynamoDBStore implements LockStore {
    * Delete a lock
    */
   async delete(key: string, owner: string) {
-    const currentOwner = await this.#getCurrentOwner(key)
-    if (currentOwner !== owner) throw new E_RELEASE_NOT_OWNED()
+    const command = new DeleteItemCommand({
+      TableName: this.#tableName,
+      Key: { key: { S: key } },
+      ConditionExpression: '#owner = :owner',
+      ExpressionAttributeNames: { '#owner': 'owner' },
+      ExpressionAttributeValues: { ':owner': { S: owner } },
+    })
+
+    try {
+      await this.#client.send(command)
+    } catch (err) {
+      throw new E_RELEASE_NOT_OWNED()
+    }
+  }
 
+  /**
+   * Force delete a lock
+   */
+  async forceRelease(key: string) {
     const command = new DeleteItemCommand({
       TableName: this.#tableName,
       Key: { key: { S: key } },

packages/verrou/src/drivers/memory.ts

@@ -80,6 +80,16 @@ export class MemoryStore implements LockStore {
     mutex.releaser()
   }
 
+  /**
+   * Force delete a lock
+   */
+  async forceRelease(key: string) {
+    const lock = this.#locks.get(key)
+    if (!lock) return
+
+    lock.releaser?.()
+  }
+
   /**
    * Check if a lock exists
    */

packages/verrou/src/drivers/redis.ts

@@ -44,6 +44,13 @@ export class RedisStore implements LockStore {
     if (result === 0) throw new E_RELEASE_NOT_OWNED()
   }
 
+  /**
+   * Force delete a lock
+   */
+  async forceRelease(key: string) {
+    await this.#connection.del(key)
+  }
+
   /**
    * Check if a lock exists
    */

packages/verrou/src/lock.ts

@@ -75,13 +75,27 @@ export class Lock {
     }
   }
 
+  /**
+   * Force release the lock
+   */
+  async forceRelease() {
+    await this.lockStore.forceRelease(this.key)
+  }
+
   /**
    * Release the lock
    */
   async release() {
     await this.lockStore.delete(this.key, this.#owner)
   }
 
+  /**
+   * Returns true if the lock is expired
+   */
+  async isExpired() {
+    return false
+  }
+
   /**
    * Returns true if the lock is currently locked
    */

packages/verrou/src/types/main.ts

@@ -59,6 +59,11 @@ export interface LockStore {
    */
   delete(key: string, owner: string): Promise<void>
 
+  /**
+   * Force delete the lock from the store
+   */
+  forceRelease(key: string): Promise<void>
+
   /**
    * Check if the lock exists
    */

packages/verrou/test_helpers/driver_test_suite.ts

@@ -292,4 +292,16 @@ export function registerStoreTestSuite<T extends { new (options: any): LockStore
 
     assert.isTrue(await lock.isLocked())
   })
+
+  test('forceRelease allows to release a lock that is not acquired by you', async ({ assert }) => {
+    const provider = new LockFactory(new store(config))
+    const lock = provider.createLock('foo')
+    const lock2 = provider.createLock('foo')
+
+    await lock.acquire()
+
+    await lock2.forceRelease()
+
+    assert.isFalse(await lock.isLocked())
+  })
 }

packages/verrou/test_helpers/null_store.ts

@@ -13,6 +13,10 @@ export class NullStore implements LockStore {
     return true
   }
 
+  async forceRelease(_key: string): Promise<void> {
+    return
+  }
+
   async extend(_key: string, _duration: Duration): Promise<void> {
     return
   }