refactor: refactorLock new api

Author: Julien-R44

docs/content/docs/api.md

@@ -132,10 +132,11 @@ First argument is the lock key. Second argument is optional and is the lock expi
 
 ### `restoreLock`
 
-Restore a lock with a given owner. Useful when sharing a lock between multiple processes. See [Sharing a lock between multiple processes](./usage.md#sharing-a-lock-between-multiple-processes) for more details.
+Restore a lock. Useful when sharing a lock between multiple processes. See [Sharing a lock between multiple processes](./usage.md#sharing-a-lock-between-multiple-processes) for more details.
 
 ```ts
-const lock = verrou.restoreLock('key', 'owner')
+const lock1 = verrou.createLock('key', 'owner')
+const lock2 = verrou.restoreLock(lock1.serialize())
 ```
 
 ### `disconnect`

docs/content/docs/usage.md

@@ -165,8 +165,8 @@ router.get('/process-payment', async (req, res) => {
   await lock.acquire()
 
   myQueue.dispatch('process-payment', { 
-    paymentId: 123, 
-    lockOwner: lock.getOwner() 
+    paymentId: 123,
+    lock: lock.serialize()
   })
 })
 ```
@@ -177,9 +177,9 @@ So we dispatch a message to our queue with the lock owner. Now let's see how we
 // title: worker.ts
 import { verrou } from './verrou.js'
 
-myQueue.on('process-payment', async ({ paymentId, lockOwner }) => {
+myQueue.on('process-payment', async ({ paymentId, lock }) => {
   // First we **restore** the lock with the lock owner
-  const lock = verrou.restoreLock('my-resource', lockOwner) 
+  const lock = verrou.restoreLock(lock)
 
   processPayment(paymentId)
 
@@ -188,7 +188,7 @@ myQueue.on('process-payment', async ({ paymentId, lockOwner }) => {
 })
 ```
 
-As you can see, we can restore a lock by calling the `restoreLock` method and passing the lock owner. This will create a new `Lock` instance with the same resource and owner. Then we can release it.
+As you can see, we can restore a lock by calling the `restoreLock` method and passing the serialized lock. This will create a new `Lock` instance with the same resource and owner. Then we can release it.
 
 Note that you can also use `lock.forceRelease()` to release a lock, no matter the owner.
 

packages/verrou/src/lock.ts

@@ -3,7 +3,13 @@ import { InvalidArgumentsException } from '@poppinss/utils'
 
 import { E_LOCK_TIMEOUT } from './errors.js'
 import { resolveDuration } from './helpers.js'
-import type { Duration, LockAcquireOptions, LockFactoryConfig, LockStore } from './types/main.js'
+import type {
+  Duration,
+  LockAcquireOptions,
+  LockFactoryConfig,
+  LockStore,
+  SerializedLock,
+} from './types/main.js'
 
 export class Lock {
   #key: string
@@ -19,11 +25,12 @@ export class Lock {
     config: LockFactoryConfig,
     owner?: string,
     ttl?: number | null,
+    expirationTime?: number | null,
   ) {
     this.#key = key
     this.#config = config
     this.#lockStore = lockStore
-    this.#expirationTime = null
+    this.#expirationTime = expirationTime ?? null
     this.#owner = owner ?? this.#generateOwner()
     this.#ttl = ttl ?? null
   }
@@ -42,6 +49,18 @@ export class Lock {
     return this.#owner
   }
 
+  /**
+   * Serialize the lock
+   */
+  serialize(): SerializedLock {
+    return {
+      key: this.#key,
+      owner: this.#owner,
+      ttl: this.#ttl,
+      expirationTime: this.#expirationTime,
+    }
+  }
+
   /**
    * Acquire the lock
    */

packages/verrou/src/lock_factory.ts

@@ -2,7 +2,13 @@ import { noopLogger } from 'typescript-log'
 
 import { Lock } from './lock.js'
 import { resolveDuration } from './helpers.js'
-import type { Duration, LockFactoryConfig, LockFactoryOptions, LockStore } from './types/main.js'
+import type {
+  Duration,
+  LockFactoryConfig,
+  LockFactoryOptions,
+  LockStore,
+  SerializedLock,
+} from './types/main.js'
 
 export class LockFactory {
   /**
@@ -37,8 +43,8 @@ export class LockFactory {
    * if you want to release a lock from a different process than the one
    * that acquired it.
    */
-  restoreLock(name: string, owner: string, ttl: Duration = LockFactory.#kDefaultTtl) {
-    return new Lock(name, this.store, this.#config, owner, resolveDuration(ttl))
+  restoreLock(lock: SerializedLock) {
+    return new Lock(lock.key, this.store, this.#config, lock.owner, lock.ttl, lock.expirationTime)
   }
 
   /**

packages/verrou/src/types/main.ts

@@ -16,6 +16,13 @@ export type StoreFactory = {
   driver: { factory: () => LockStore }
 }
 
+export interface SerializedLock {
+  key: string
+  owner: string
+  ttl: number | null
+  expirationTime: number | null
+}
+
 export interface RetryConfig {
   /**
    * The number of times to retry the operation before giving up.

packages/verrou/src/verrou.ts

@@ -1,7 +1,7 @@
 import { noopLogger, type Logger } from 'typescript-log'
 
 import { LockFactory } from './lock_factory.js'
-import type { Duration, StoreFactory } from './types/main.js'
+import type { Duration, SerializedLock, StoreFactory } from './types/main.js'
 
 /**
  * Verrou is the main class of the library. It is used to create locks
@@ -67,8 +67,8 @@ export class Verrou<KnownStores extends Record<string, StoreFactory>> {
    * if you want to release a lock from a different process than the one
    * that acquired it.
    */
-  restoreLock(name: string, owner: string, ttl?: Duration) {
-    return this.use(this.#defaultStoreName).restoreLock(name, owner, ttl)
+  restoreLock(lock: SerializedLock) {
+    return this.use(this.#defaultStoreName).restoreLock(lock)
   }
 
   /**

packages/verrou/test_helpers/driver_test_suite.ts

@@ -193,7 +193,7 @@ export function registerStoreTestSuite<T extends { new (options: any): LockStore
     await lock.acquire()
 
     const provider2 = new LockFactory(storeInstance)
-    const lock2 = provider2.restoreLock('foo', lock.getOwner())
+    const lock2 = provider2.restoreLock(lock.serialize())
 
     assert.isTrue(await lock2.isLocked())
     await lock2.release()

packages/verrou/tests/lock_factory.spec.ts

@@ -0,0 +1,24 @@
+import { test } from '@japa/runner'
+import { setTimeout } from 'node:timers/promises'
+
+import { LockFactory } from '../src/lock_factory.js'
+import { MemoryStore } from '../src/drivers/memory.js'
+
+test.group('Lock Factory', () => {
+  test('restoreLock should preserve expiration time', async ({ assert }) => {
+    const store = new MemoryStore()
+    const lockFactory = new LockFactory(store)
+
+    const lock = lockFactory.createLock('foo', '1s')
+
+    await lock.acquire()
+
+    await setTimeout(100)
+
+    const serializedLock = lock.serialize()
+    const restoredLock = lockFactory.restoreLock(serializedLock)
+
+    assert.closeTo(restoredLock.getRemainingTime()!, 900, 100)
+    assert.deepEqual(restoredLock.getRemainingTime(), lock.getRemainingTime())
+  })
+})