feat: add DatabaseStore + adapter system

Author: Julien-R44

packages/verrou/src/drivers/database.ts

@@ -0,0 +1,110 @@
+import { E_LOCK_NOT_OWNED } from '../errors.js'
+import type { DatabaseAdapter, DatabaseOptions } from '../types/drivers.js'
+
+/**
+ * A store that uses a database to store locks
+ *
+ * You should provide an adapter that will handle the database interactions
+ */
+export class DatabaseStore {
+  #adapter: DatabaseAdapter
+  #initialized: Promise<void>
+
+  constructor(adapter: DatabaseAdapter, config: DatabaseOptions) {
+    this.#adapter = adapter
+    this.#adapter.setTableName(config.tableName || 'verrou')
+
+    if (config.autoCreateTable !== false) {
+      this.#initialized = this.#adapter.createTableIfNotExists()
+    } else {
+      this.#initialized = Promise.resolve()
+    }
+  }
+
+  /**
+   * Compute the expiration date based on the provided TTL
+   */
+  #computeExpiresAt(ttl: number | null) {
+    if (ttl) return Date.now() + ttl
+    return null
+  }
+
+  /**
+   * Get the current owner of given lock key
+   */
+  async #getCurrentOwner(key: string) {
+    await this.#initialized
+    const lock = await this.#adapter.getLock(key)
+
+    return lock?.owner
+  }
+
+  /**
+   * Save the lock in the store if not already locked by another owner
+   *
+   * We basically rely on primary key constraint to ensure the lock is
+   * unique.
+   *
+   * If the lock already exists, we check if it's expired. If it is, we
+   * update it with the new owner and expiration date.
+   */
+  async save(key: string, owner: string, ttl: number | null) {
+    await this.#initialized
+    try {
+      await this.#adapter.insertLock({ key, owner, expiration: this.#computeExpiresAt(ttl) })
+      return true
+    } catch (error) {
+      const updatedRows = await this.#adapter.acquireLock({
+        key,
+        owner,
+        expiration: this.#computeExpiresAt(ttl),
+      })
+
+      return updatedRows > 0
+    }
+  }
+
+  /**
+   * Delete the lock from the store if it is owned by the owner
+   * Otherwise throws a E_LOCK_NOT_OWNED error
+   */
+  async delete(key: string, owner: string): Promise<void> {
+    const currentOwner = await this.#getCurrentOwner(key)
+    if (currentOwner !== owner) throw new E_LOCK_NOT_OWNED()
+
+    await this.#adapter.deleteLock(key, owner)
+  }
+
+  /**
+   * Force delete the lock from the store. No check is made on the owner
+   */
+  async forceDelete(key: string) {
+    await this.#adapter.deleteLock(key)
+  }
+
+  /**
+   * Extend the lock expiration. Throws an error if the lock is not owned by the owner
+   * Duration is in milliseconds
+   */
+  async extend(key: string, owner: string, duration: number) {
+    await this.#initialized
+    const updated = await this.#adapter.extendLock(key, owner, duration)
+
+    if (updated === 0) throw new E_LOCK_NOT_OWNED()
+  }
+
+  /**
+   * Check if the lock exists
+   */
+  async exists(key: string) {
+    await this.#initialized
+    const lock = await this.#adapter.getLock(key)
+
+    if (!lock) return false
+    if (lock.expiration === null) return true
+
+    return lock.expiration > Date.now()
+  }
+
+  async disconnect() {}
+}

packages/verrou/src/drivers/knex.ts

@@ -1,45 +1,37 @@
 import type { Knex } from 'knex'
 
-import { E_LOCK_NOT_OWNED } from '../errors.js'
-import type { KnexStoreOptions, LockStore } from '../types/main.js'
+import { DatabaseStore } from './database.js'
+import type { DatabaseAdapter, KnexStoreOptions } from '../types/main.js'
 
 /**
- * Create a new database store
+ * Create a new knex store
  */
 export function knexStore(config: KnexStoreOptions) {
-  return { config, factory: () => new KnexStore(config) }
+  return {
+    config,
+    factory: () => {
+      const adapter = new KnexAdapter(config.connection)
+      return new DatabaseStore(adapter, config)
+    },
+  }
 }
 
-export class KnexStore implements LockStore {
-  /**
-   * Knex connection instance
-   */
+/**
+ * Knex adapter for the DatabaseStore
+ */
+export class KnexAdapter implements DatabaseAdapter {
   #connection: Knex
+  #tableName!: string
 
-  /**
-   * The name of the table used to store locks
-   */
-  #tableName = 'verrou'
-
-  /**
-   * A promise that resolves when the table is created
-   */
-  #initialized: Promise<void>
+  constructor(connection: Knex) {
+    this.#connection = connection
+  }
 
-  constructor(config: KnexStoreOptions) {
-    this.#connection = config.connection
-    this.#tableName = config.tableName || this.#tableName
-    if (config.autoCreateTable !== false) {
-      this.#initialized = this.#createTableIfNotExists()
-    } else {
-      this.#initialized = Promise.resolve()
-    }
+  setTableName(tableName: string) {
+    this.#tableName = tableName
   }
 
-  /**
-   * Create the locks table if it doesn't exist
-   */
-  async #createTableIfNotExists() {
+  async createTableIfNotExists() {
     const hasTable = await this.#connection.schema.hasTable(this.#tableName)
     if (hasTable) return
 
@@ -50,109 +42,47 @@ export class KnexStore implements LockStore {
     })
   }
 
-  /**
-   * Compute the expiration date based on the provided TTL
-   */
-  #computeExpiresAt(ttl: number | null) {
-    if (ttl) return Date.now() + ttl
-    return null
+  async insertLock(lock: { key: string; owner: string; expiration: number | null }) {
+    await this.#connection.table(this.#tableName).insert(lock)
   }
 
-  /**
-   * Get the current owner of given lock key
-   */
-  async #getCurrentOwner(key: string) {
-    await this.#initialized
-    const result = await this.#connection
+  async acquireLock(lock: { key: string; owner: string; expiration: number | null }) {
+    const updated = await this.#connection
       .table(this.#tableName)
-      .where('key', key)
-      .select('owner')
-      .first()
+      .where('key', lock.key)
+      .where('expiration', '<=', Date.now())
+      .update({ owner: lock.owner, expiration: lock.expiration })
 
-    return result?.owner
+    return updated
   }
 
-  /**
-   * Save the lock in the store if not already locked by another owner
-   *
-   * We basically rely on primary key constraint to ensure the lock is
-   * unique.
-   *
-   * If the lock already exists, we check if it's expired. If it is, we
-   * update it with the new owner and expiration date.
-   */
-  async save(key: string, owner: string, ttl: number | null) {
-    try {
-      await this.#initialized
-      await this.#connection
-        .table(this.#tableName)
-        .insert({ key, owner, expiration: this.#computeExpiresAt(ttl) })
-
-      return true
-    } catch (error) {
-      const updated = await this.#connection
-        .table(this.#tableName)
-        .where('key', key)
-        .where('expiration', '<=', Date.now())
-        .update({ owner, expiration: this.#computeExpiresAt(ttl) })
-
-      return updated >= 1
-    }
-  }
-
-  /**
-   * Delete the lock from the store if it is owned by the owner
-   * Otherwise throws a E_LOCK_NOT_OWNED error
-   */
-  async delete(key: string, owner: string): Promise<void> {
-    const currentOwner = await this.#getCurrentOwner(key)
-    if (currentOwner !== owner) throw new E_LOCK_NOT_OWNED()
-
-    await this.#connection.table(this.#tableName).where('key', key).where('owner', owner).delete()
-  }
-
-  /**
-   * Force delete the lock from the store. No check is made on the owner
-   */
-  async forceDelete(key: string) {
-    await this.#connection.table(this.#tableName).where('key', key).delete()
+  async deleteLock(key: string, owner?: string | undefined) {
+    await this.#connection
+      .table(this.#tableName)
+      .where('key', key)
+      .modify((query) => {
+        if (owner) query.where('owner', owner)
+      })
+      .delete()
   }
 
-  /**
-   * Extend the lock expiration. Throws an error if the lock is not owned by the owner
-   * Duration is in milliseconds
-   */
-  async extend(key: string, owner: string, duration: number) {
+  async extendLock(key: string, owner: string, duration: number) {
     const updated = await this.#connection
       .table(this.#tableName)
       .where('key', key)
       .where('owner', owner)
       .update({ expiration: Date.now() + duration })
 
-    if (updated === 0) throw new E_LOCK_NOT_OWNED()
+    return updated
   }
 
-  /**
-   * Check if the lock exists
-   */
-  async exists(key: string) {
-    await this.#initialized
+  async getLock(key: string) {
     const result = await this.#connection
       .table(this.#tableName)
       .where('key', key)
-      .select('expiration')
+      .select(['owner', 'expiration'])
       .first()
 
-    if (!result) return false
-    if (result.expiration === null) return true
-
-    return result.expiration > Date.now()
-  }
-
-  /**
-   * Disconnect knex connection
-   */
-  disconnect() {
-    return this.#connection.destroy()
+    return result
   }
 }