refactor: move to E_LOCK_NOT_OWNED

Author: Julien-R44

packages/verrou/bin/test.ts

@@ -7,31 +7,10 @@ import { processCLIArgs, configure, run } from '@japa/runner'
 
 import { BASE_URL } from '../test_helpers/index.js'
 
-/*
-|--------------------------------------------------------------------------
-| Configure tests
-|--------------------------------------------------------------------------
-|
-| The configure method accepts the configuration to configure the Japa
-| tests runner.
-|
-| The first method call "processCLIArgs" process the command line arguments
-| and turns them into a config object. Using this method is not mandatory.
-|
-| Please consult japa.dev/runner-config for the config docs.
-*/
 processCLIArgs(process.argv.slice(2))
 configure({
   files: ['tests/**/*.spec.ts'],
   plugins: [assert(), expectTypeOf(), fileSystem({ autoClean: true, basePath: BASE_URL })],
 })
 
-/*
-|--------------------------------------------------------------------------
-| Run tests
-|--------------------------------------------------------------------------
-|
-| The following "run" method is required to execute all the tests.
-|
-*/
 run()

packages/verrou/src/drivers/database.ts

@@ -1,6 +1,6 @@
 import knex, { type Knex } from 'knex'
 
-import { E_LOCK_NOT_OWNED, E_RELEASE_NOT_OWNED } from '../errors.js'
+import { E_LOCK_NOT_OWNED } from '../errors.js'
 import type { DatabaseStoreOptions, LockStore } from '../types/main.js'
 
 /**
@@ -121,7 +121,7 @@ export class DatabaseStore implements LockStore {
    */
   async delete(key: string, owner: string): Promise<void> {
     const currentOwner = await this.#getCurrentOwner(key)
-    if (currentOwner !== owner) throw new E_RELEASE_NOT_OWNED()
+    if (currentOwner !== owner) throw new E_LOCK_NOT_OWNED()
 
     await this.#connection.table(this.#tableName).where('key', key).where('owner', owner).delete()
   }

packages/verrou/src/drivers/dynamodb.ts

@@ -8,8 +8,8 @@ import {
   ResourceInUseException,
 } from '@aws-sdk/client-dynamodb'
 
+import { E_LOCK_NOT_OWNED } from '../errors.js'
 import type { LockStore, DynamoDbOptions } from '../types/main.js'
-import { E_LOCK_NOT_OWNED, E_RELEASE_NOT_OWNED } from '../errors.js'
 
 /**
  * Create a DynamoDB store.
@@ -110,7 +110,7 @@ export class DynamoDBStore implements LockStore {
     try {
       await this.#client.send(command)
     } catch (err) {
-      throw new E_RELEASE_NOT_OWNED()
+      throw new E_LOCK_NOT_OWNED()
     }
   }
 

packages/verrou/src/drivers/memory.ts

@@ -1,8 +1,8 @@
 import { Mutex, tryAcquire } from 'async-mutex'
 import type { MutexInterface } from 'async-mutex'
 
+import { E_LOCK_NOT_OWNED } from '../errors.js'
 import type { LockStore } from '../types/main.js'
-import { E_LOCK_NOT_OWNED, E_RELEASE_NOT_OWNED } from '../errors.js'
 
 type MemoryLockEntry = {
   mutex: MutexInterface
@@ -82,8 +82,8 @@ export class MemoryStore implements LockStore {
   async delete(key: string, owner: string) {
     const mutex = this.#locks.get(key)
 
-    if (!mutex || !mutex.releaser) throw new E_RELEASE_NOT_OWNED()
-    if (mutex.owner !== owner) throw new E_RELEASE_NOT_OWNED()
+    if (!mutex || !mutex.releaser) throw new E_LOCK_NOT_OWNED()
+    if (mutex.owner !== owner) throw new E_LOCK_NOT_OWNED()
 
     mutex.releaser()
   }

packages/verrou/src/drivers/redis.ts

@@ -1,6 +1,6 @@
 import { Redis as IoRedis } from 'ioredis'
 
-import { E_LOCK_NOT_OWNED, E_RELEASE_NOT_OWNED } from '../errors.js'
+import { E_LOCK_NOT_OWNED } from '../errors.js'
 import type { LockStore, RedisStoreOptions } from '../types/main.js'
 
 /**
@@ -37,7 +37,7 @@ export class RedisStore implements LockStore {
     `
 
     const result = await this.#connection.eval(lua, 1, key, owner)
-    if (result === 0) throw new E_RELEASE_NOT_OWNED()
+    if (result === 0) throw new E_LOCK_NOT_OWNED()
   }
 
   /**

packages/verrou/src/errors.ts

@@ -1,10 +1,5 @@
 import { createError } from '@poppinss/utils'
 
-export const E_RELEASE_NOT_OWNED = createError(
-  `It looks like you are trying to release a lock that is not acquired by you. Make sure to acquire the lock before trying to release it`,
-  'E_RELEASE_NOT_OWNED',
-)
-
 export const E_LOCK_TIMEOUT = createError(
   `Lock was not acquired in the allotted time`,
   'E_LOCK_TIMEOUT',

packages/verrou/src/types/main.ts

@@ -61,17 +61,27 @@ export interface LockFactoryConfig {
 
 export interface LockStore {
   /**
-   * Save the lock in the store if not already locked
+   * Save the lock in the store if not already locked by another owner
+   *
+   * @param key The key to lock
+   * @param owner The owner of the lock
+   * @param ttl The time to live of the lock in milliseconds. Null means no expiration
+   *
+   * @returns True if the lock was acquired, false otherwise
    */
-  save(key: string, owner: string, ttl: number | null | undefined): Promise<boolean>
+  save(key: string, owner: string, ttl: number | null): Promise<boolean>
 
   /**
-   * Delete the lock from the store
+   * Delete the lock from the store if it is owned by the owner
+   * Otherwise throws a E_LOCK_NOT_OWNED error
+   *
+   * @param key The key to delete
+   * @param owner The owner of the lock
    */
   delete(key: string, owner: string): Promise<void>
 
   /**
-   * Force delete the lock from the store
+   * Force delete the lock from the store. No check is made on the owner
    */
   forceRelease(key: string): Promise<void>
 
@@ -81,12 +91,13 @@ export interface LockStore {
   exists(key: string): Promise<boolean>
 
   /**
-   * Extend the lock expiration
+   * Extend the lock expiration. Throws an error if the lock is not owned by the owner
+   * Duration is in milliseconds
    */
   extend(key: string, owner: string, duration: number): Promise<void>
 
   /**
-   * Disconnect the store
+   * Disconnect the store from the underlying storage ( when applicable )
    */
   disconnect(): Promise<void>
 }