@daiso-tech/core 0.27.0 → 0.28.0

package/dist/lock/implementations/derivables/lock-provider-factory/lock-provider-factory.d.ts

@@ -3,17 +3,15 @@
  */
 import type { BackoffPolicy, RetryPolicy } from "../../../../async/_module-exports.js";
 import type { IGroupableEventBus } from "../../../../event-bus/contracts/_module-exports.js";
-import type { IDatabaseLockAdapter, ILockAdapter } from "../../../../lock/contracts/_module-exports.js";
-import type { ILockProviderFactory } from "../../../../lock/contracts/lock-provider-factory.contract.js";
-import type { IGroupableLockProvider } from "../../../../lock/contracts/lock-provider.contract.js";
+import type { ILockProviderFactory, IGroupableLockProvider } from "../../../../lock/contracts/_module-exports.js";
 import type { IKeyPrefixer, TimeSpan } from "../../../../utilities/_module-exports.js";
-import { type LockProviderSettingsBase } from "../../../../lock/implementations/derivables/lock-provider/_module.js";
+import { type LockAdapterFactoryable, type LockProviderSettingsBase } from "../../../../lock/implementations/derivables/lock-provider/_module.js";
 /**
  *
  * IMPORT_PATH: ```"@daiso-tech/core/lock"```
  * @group Derivables
  */
-export type LockAdapters<TAdapters extends string> = Partial<Record<TAdapters, ILockAdapter | IDatabaseLockAdapter>>;
+export type LockAdapters<TAdapters extends string> = Partial<Record<TAdapters, LockAdapterFactoryable>>;
 /**
  *
  * IMPORT_PATH: ```"@daiso-tech/core/lock"```
@@ -30,6 +28,48 @@ export type LockProviderFactorySettings<TAdapters extends string> = LockProvider
  */
 export declare class LockProviderFactory<TAdapters extends string> implements ILockProviderFactory<TAdapters> {
     private readonly settings;
+    /**
+     * @example
+     * ```ts
+     * import { LockProviderFactory } from "@daiso-tech/core/lock";
+     * import type { ILockAdapter } from "@daiso-tech/core/lock/contracts";
+     * import { MemoryLockAdapter, RedisLockAdapter, SqliteLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { Serde } from "@daiso-tech/core/serde";
+     * import type { ISerde } from "@daiso-tech/core/serde/contracts";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters";
+     * import { KeyPrefixer, TimeSpan, type ISqliteDatabase, type FactoryFn } from "@daiso-tech/core/utilities";
+     * import Redis from "ioredis"
+     * import Sqlite from "better-sqlite3";
+     *
+     * function lockAdapterFactory(database: ISqliteDatabase, serde: ISerde<string>): FactoryFn<string, ILockAdapter> {
+     *   return async (prefix) => {
+     *     const lockAdapter = new SqliteLockAdapter({
+     *       database,
+     *       serde,
+     *       tableName: `lock_${prefix}`
+     *     });
+     *     await lockAdapter.init();
+     *     return lockAdapter;
+     *   }
+     * }
+     *
+     * const database = new Sqlite("local.db");
+     * const serde = new Serde(new SuperJsonSerdeAdapter());
+     * const lockProviderFactory = new LockProviderFactory({
+     *   serde,
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   adapters: {
+     *     sqlite: lockAdapterFactory(database, serde),
+     *     memory: new MemoryLockAdapter(),
+     *     redis: new RedisLockAdapter({
+     *       client: new Redis("YOUR_REDIS_CONNECTION"),
+     *       serde,
+     *     }),
+     *   },
+     *   defaultAdapter: "memory",
+     * });
+     * ```
+     */
     constructor(settings: LockProviderFactorySettings<TAdapters>);
     setKeyPrefixer(keyPrefixer: IKeyPrefixer): LockProviderFactory<TAdapters>;
     setCreateOwnerId(createId: () => string): LockProviderFactory<TAdapters>;
@@ -41,19 +81,45 @@ export declare class LockProviderFactory<TAdapters extends string> implements IL
     setRetryAttempts(attempts: number): LockProviderFactory<TAdapters>;
     setBackoffPolicy(policy: BackoffPolicy): LockProviderFactory<TAdapters>;
     setRetryPolicy(policy: RetryPolicy): LockProviderFactory<TAdapters>;
-    setTimeout(timeout: TimeSpan): LockProviderFactory<TAdapters>;
+    setRetryTimeout(timeout: TimeSpan): LockProviderFactory<TAdapters>;
+    setTotalTimeout(timeout: TimeSpan): LockProviderFactory<TAdapters>;
     /**
      * @example
      * ```ts
      * import { LockProviderFactory } from "@daiso-tech/core/lock";
-     * import { MemoryLockAdapter, RedisLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import type { ILockAdapter } from "@daiso-tech/core/lock/contracts";
+     * import { MemoryLockAdapter, RedisLockAdapter, SqliteLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { Serde } from "@daiso-tech/core/serde";
+     * import type { ISerde } from "@daiso-tech/core/serde/contracts";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters";
+     * import { KeyPrefixer, TimeSpan, type ISqliteDatabase, type FactoryFn } from "@daiso-tech/core/utilities";
      * import Redis from "ioredis"
+     * import Sqlite from "better-sqlite3";
+     *
+     * function lockAdapterFactory(database: ISqliteDatabase, serde: ISerde<string>): FactoryFn<string, ILockAdapter> {
+     *   return async (prefix) => {
+     *     const lockAdapter = new SqliteLockAdapter({
+     *       database,
+     *       serde,
+     *       tableName: `lock_${prefix}`
+     *     });
+     *     await lockAdapter.init();
+     *     return lockAdapter;
+     *   }
+     * }
      *
+     * const database = new Sqlite("local.db");
+     * const serde = new Serde(new SuperJsonSerdeAdapter());
      * const lockProviderFactory = new LockProviderFactory({
+     *   serde,
      *   keyPrefixer: new KeyPrefixer("lock"),
      *   adapters: {
+     *     sqlite: lockAdapterFactory(database, serde),
      *     memory: new MemoryLockAdapter(),
-     *     redis: new RedisLockAdapter(client),
+     *     redis: new RedisLockAdapter({
+     *       client: new Redis("YOUR_REDIS_CONNECTION"),
+     *       serde,
+     *     }),
      *   },
      *   defaultAdapter: "memory",
      * });
@@ -88,7 +154,7 @@ export declare class LockProviderFactory<TAdapters extends string> implements IL
      *
      * // You can extend the settings
      * const extendedLockProviderFactory = longLivedLockProviderFactory
-     *   .setTimeout(TimeSpan.fromSeconds(1));
+     *   .setRetryTimeout(TimeSpan.fromSeconds(1));
      *
      * await extendedLockProviderFactory
      *   .use()

package/dist/lock/implementations/derivables/lock-provider-factory/lock-provider-factory.js

@@ -1,7 +1,7 @@
 /**
  * @module Lock
  */
-import { DefaultAdapterNotDefinedError, UnregisteredAdapterError, } from "../../../../utilities/_module-exports.js";
+import { DefaultAdapterNotDefinedError, KeyPrefixer, resolveOneOrMore, UnregisteredAdapterError, } from "../../../../utilities/_module-exports.js";
 import { LockProvider, } from "../../../../lock/implementations/derivables/lock-provider/_module.js";
 /**
  *
@@ -10,6 +10,48 @@ import { LockProvider, } from "../../../../lock/implementations/derivables/lock-
  */
 export class LockProviderFactory {
     settings;
+    /**
+     * @example
+     * ```ts
+     * import { LockProviderFactory } from "@daiso-tech/core/lock";
+     * import type { ILockAdapter } from "@daiso-tech/core/lock/contracts";
+     * import { MemoryLockAdapter, RedisLockAdapter, SqliteLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { Serde } from "@daiso-tech/core/serde";
+     * import type { ISerde } from "@daiso-tech/core/serde/contracts";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters";
+     * import { KeyPrefixer, TimeSpan, type ISqliteDatabase, type FactoryFn } from "@daiso-tech/core/utilities";
+     * import Redis from "ioredis"
+     * import Sqlite from "better-sqlite3";
+     *
+     * function lockAdapterFactory(database: ISqliteDatabase, serde: ISerde<string>): FactoryFn<string, ILockAdapter> {
+     *   return async (prefix) => {
+     *     const lockAdapter = new SqliteLockAdapter({
+     *       database,
+     *       serde,
+     *       tableName: `lock_${prefix}`
+     *     });
+     *     await lockAdapter.init();
+     *     return lockAdapter;
+     *   }
+     * }
+     *
+     * const database = new Sqlite("local.db");
+     * const serde = new Serde(new SuperJsonSerdeAdapter());
+     * const lockProviderFactory = new LockProviderFactory({
+     *   serde,
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   adapters: {
+     *     sqlite: lockAdapterFactory(database, serde),
+     *     memory: new MemoryLockAdapter(),
+     *     redis: new RedisLockAdapter({
+     *       client: new Redis("YOUR_REDIS_CONNECTION"),
+     *       serde,
+     *     }),
+     *   },
+     *   defaultAdapter: "memory",
+     * });
+     * ```
+     */
     constructor(settings) {
         this.settings = settings;
     }
@@ -73,24 +115,55 @@ export class LockProviderFactory {
             retryPolicy: policy,
         });
     }
-    setTimeout(timeout) {
+    setRetryTimeout(timeout) {
         return new LockProviderFactory({
             ...this.settings,
-            timeout,
+            retryTimeout: timeout,
+        });
+    }
+    setTotalTimeout(timeout) {
+        return new LockProviderFactory({
+            ...this.settings,
+            totalTimeout: timeout,
         });
     }
     /**
      * @example
      * ```ts
      * import { LockProviderFactory } from "@daiso-tech/core/lock";
-     * import { MemoryLockAdapter, RedisLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import type { ILockAdapter } from "@daiso-tech/core/lock/contracts";
+     * import { MemoryLockAdapter, RedisLockAdapter, SqliteLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { Serde } from "@daiso-tech/core/serde";
+     * import type { ISerde } from "@daiso-tech/core/serde/contracts";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/adapters";
+     * import { KeyPrefixer, TimeSpan, type ISqliteDatabase, type FactoryFn } from "@daiso-tech/core/utilities";
      * import Redis from "ioredis"
+     * import Sqlite from "better-sqlite3";
+     *
+     * function lockAdapterFactory(database: ISqliteDatabase, serde: ISerde<string>): FactoryFn<string, ILockAdapter> {
+     *   return async (prefix) => {
+     *     const lockAdapter = new SqliteLockAdapter({
+     *       database,
+     *       serde,
+     *       tableName: `lock_${prefix}`
+     *     });
+     *     await lockAdapter.init();
+     *     return lockAdapter;
+     *   }
+     * }
      *
+     * const database = new Sqlite("local.db");
+     * const serde = new Serde(new SuperJsonSerdeAdapter());
      * const lockProviderFactory = new LockProviderFactory({
+     *   serde,
      *   keyPrefixer: new KeyPrefixer("lock"),
      *   adapters: {
+     *     sqlite: lockAdapterFactory(database, serde),
      *     memory: new MemoryLockAdapter(),
-     *     redis: new RedisLockAdapter(client),
+     *     redis: new RedisLockAdapter({
+     *       client: new Redis("YOUR_REDIS_CONNECTION"),
+     *       serde,
+     *     }),
      *   },
      *   defaultAdapter: "memory",
      * });
@@ -125,7 +198,7 @@ export class LockProviderFactory {
      *
      * // You can extend the settings
      * const extendedLockProviderFactory = longLivedLockProviderFactory
-     *   .setTimeout(TimeSpan.fromSeconds(1));
+     *   .setRetryTimeout(TimeSpan.fromSeconds(1));
      *
      * await extendedLockProviderFactory
      *   .use()
@@ -141,9 +214,14 @@ export class LockProviderFactory {
         if (adapter === undefined) {
             throw new UnregisteredAdapterError(adapterName);
         }
+        const { keyPrefixer } = this.settings;
         return new LockProvider({
-            adapter,
             ...this.settings,
+            adapter,
+            keyPrefixer: new KeyPrefixer([
+                ...resolveOneOrMore(keyPrefixer.originalRootPrefix),
+                adapterName,
+            ]),
         });
     }
 }

package/dist/lock/implementations/derivables/lock-provider-factory/lock-provider-factory.js.map

@@ -1 +1 @@
-{"version":3,"file":"lock-provider-factory.js","sourceRoot":"","sources":["../../../../../src/lock/implementations/derivables/lock-provider-factory/lock-provider-factory.ts"],"names":[],"mappings":"AAAA;;GAEG;AAUH,OAAO,EACH,6BAA6B,EAC7B,wBAAwB,GAC3B,MAAM,gCAAgC,CAAC;AAExC,OAAO,EACH,YAAY,GAEf,MAAM,4DAA4D,CAAC;AAuBpE;;;;GAIG;AACH,MAAM,OAAO,mBAAmB;IAIP;IADrB,YACqB,QAAgD;QAAhD,aAAQ,GAAR,QAAQ,CAAwC;IAClE,CAAC;IAEJ,cAAc,CAAC,WAAyB;QACpC,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,WAAW;SACd,CAAC,CAAC;IACP,CAAC;IAED,gBAAgB,CAAC,QAAsB;QACnC,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,aAAa,EAAE,QAAQ;SAC1B,CAAC,CAAC;IACP,CAAC;IAED,WAAW,CACP,QAAiC;QAEjC,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,QAAQ;SACX,CAAC,CAAC;IACP,CAAC;IAED,aAAa,CAAC,GAAa;QACvB,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,UAAU,EAAE,GAAG;SAClB,CAAC,CAAC;IACP,CAAC;IAED,0BAA0B,CACtB,QAAkB;QAElB,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,uBAAuB,EAAE,QAAQ;SACpC,CAAC,CAAC;IACP,CAAC;IAED,sBAAsB,CAAC,IAAc;QACjC,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,mBAAmB,EAAE,IAAI;SAC5B,CAAC,CAAC;IACP,CAAC;IAED,qBAAqB,CAAC,IAAc;QAChC,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,kBAAkB,EAAE,IAAI;SAC3B,CAAC,CAAC;IACP,CAAC;IAED,gBAAgB,CAAC,QAAgB;QAC7B,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,aAAa,EAAE,QAAQ;SAC1B,CAAC,CAAC;IACP,CAAC;IAED,gBAAgB,CAAC,MAAqB;QAClC,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,aAAa,EAAE,MAAM;SACxB,CAAC,CAAC;IACP,CAAC;IAED,cAAc,CAAC,MAAmB;QAC9B,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,WAAW,EAAE,MAAM;SACtB,CAAC,CAAC;IACP,CAAC;IAED,UAAU,CAAC,OAAiB;QACxB,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,OAAO;SACV,CAAC,CAAC;IACP,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqDG;IACH,GAAG,CACC,cAAqC,IAAI,CAAC,QAAQ,CAAC,cAAc;QAEjE,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC5B,MAAM,IAAI,6BAA6B,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;QACtE,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;QACpD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,IAAI,wBAAwB,CAAC,WAAW,CAAC,CAAC;QACpD,CAAC;QACD,OAAO,IAAI,YAAY,CAAC;YACpB,OAAO;YACP,GAAG,IAAI,CAAC,QAAQ;SACnB,CAAC,CAAC;IACP,CAAC;CACJ"}
+{"version":3,"file":"lock-provider-factory.js","sourceRoot":"","sources":["../../../../../src/lock/implementations/derivables/lock-provider-factory/lock-provider-factory.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,OAAO,EACH,6BAA6B,EAC7B,WAAW,EACX,gBAAgB,EAChB,wBAAwB,GAC3B,MAAM,gCAAgC,CAAC;AAExC,OAAO,EACH,YAAY,GAGf,MAAM,4DAA4D,CAAC;AAuBpE;;;;GAIG;AACH,MAAM,OAAO,mBAAmB;IA8CP;IA3CrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,YACqB,QAAgD;QAAhD,aAAQ,GAAR,QAAQ,CAAwC;IAClE,CAAC;IAEJ,cAAc,CAAC,WAAyB;QACpC,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,WAAW;SACd,CAAC,CAAC;IACP,CAAC;IAED,gBAAgB,CAAC,QAAsB;QACnC,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,aAAa,EAAE,QAAQ;SAC1B,CAAC,CAAC;IACP,CAAC;IAED,WAAW,CACP,QAAiC;QAEjC,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,QAAQ;SACX,CAAC,CAAC;IACP,CAAC;IAED,aAAa,CAAC,GAAa;QACvB,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,UAAU,EAAE,GAAG;SAClB,CAAC,CAAC;IACP,CAAC;IAED,0BAA0B,CACtB,QAAkB;QAElB,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,uBAAuB,EAAE,QAAQ;SACpC,CAAC,CAAC;IACP,CAAC;IAED,sBAAsB,CAAC,IAAc;QACjC,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,mBAAmB,EAAE,IAAI;SAC5B,CAAC,CAAC;IACP,CAAC;IAED,qBAAqB,CAAC,IAAc;QAChC,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,kBAAkB,EAAE,IAAI;SAC3B,CAAC,CAAC;IACP,CAAC;IAED,gBAAgB,CAAC,QAAgB;QAC7B,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,aAAa,EAAE,QAAQ;SAC1B,CAAC,CAAC;IACP,CAAC;IAED,gBAAgB,CAAC,MAAqB;QAClC,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,aAAa,EAAE,MAAM;SACxB,CAAC,CAAC;IACP,CAAC;IAED,cAAc,CAAC,MAAmB;QAC9B,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,WAAW,EAAE,MAAM;SACtB,CAAC,CAAC;IACP,CAAC;IAED,eAAe,CAAC,OAAiB;QAC7B,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,YAAY,EAAE,OAAO;SACxB,CAAC,CAAC;IACP,CAAC;IAED,eAAe,CAAC,OAAiB;QAC7B,OAAO,IAAI,mBAAmB,CAAC;YAC3B,GAAG,IAAI,CAAC,QAAQ;YAChB,YAAY,EAAE,OAAO;SACxB,CAAC,CAAC;IACP,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8EG;IACH,GAAG,CACC,cAAqC,IAAI,CAAC,QAAQ,CAAC,cAAc;QAEjE,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC5B,MAAM,IAAI,6BAA6B,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;QACtE,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;QACpD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,IAAI,wBAAwB,CAAC,WAAW,CAAC,CAAC;QACpD,CAAC;QACD,MAAM,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC;QACtC,OAAO,IAAI,YAAY,CAAC;YACpB,GAAG,IAAI,CAAC,QAAQ;YAChB,OAAO;YACP,WAAW,EAAE,IAAI,WAAW,CAAC;gBACzB,GAAG,gBAAgB,CAAC,WAAW,CAAC,kBAAkB,CAAC;gBACnD,WAAW;aACd,CAAC;SACL,CAAC,CAAC;IACP,CAAC;CACJ"}

package/dist/lock/implementations/test-utilities/lock-provider.test-suite.js

@@ -215,6 +215,78 @@ export function lockProviderTestSuite(settings) {
                 expect(index).toBeGreaterThan(1);
             });
         });
+        describe("method: runBlockingOrFail", () => {
+            test("Should return string when lock is available", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                });
+                const result = await lock.runBlockingOrFail(async () => {
+                    await LazyPromise.delay(DELAY_TIME);
+                    return "a";
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(result).toBe("a");
+            });
+            test("Should throw KeyAlreadyAcquiredLockError when lock is already acquired", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                });
+                await lock.acquire();
+                const promise = lock.runBlockingOrFail(async () => {
+                    await LazyPromise.delay(DELAY_TIME);
+                    return "a";
+                }, {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await expect(promise).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should work with LazyPromise", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                });
+                const result = await lock.runBlockingOrFail(new LazyPromise(async () => {
+                    await LazyPromise.delay(DELAY_TIME);
+                    return "a";
+                }), {
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                expect(result).toBe("a");
+            });
+            test("Should retry acquire the lock", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                });
+                await lock.acquire();
+                let index = 0;
+                await lock.addListener(KeyAlreadyAcquiredLockEvent, (_event) => {
+                    index++;
+                });
+                try {
+                    await lock.runBlockingOrFail(async () => {
+                        await LazyPromise.delay(DELAY_TIME);
+                    }, {
+                        time: TimeSpan.fromMilliseconds(55),
+                        interval: TimeSpan.fromMilliseconds(5),
+                    });
+                }
+                catch {
+                    /* Empty */
+                }
+                expect(index).toBeGreaterThan(1);
+            });
+        });
         describe("method: acquire", () => {
             test("Should return true when lock is available", async () => {
                 const key = "a";
@@ -301,12 +373,12 @@ export function lockProviderTestSuite(settings) {
                     ttl,
                 });
                 await lock.acquireBlocking({
-                    time: TimeSpan.fromMilliseconds(0),
-                    interval: TimeSpan.fromMilliseconds(0),
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
                 const result = await lock.acquireBlocking({
-                    time: TimeSpan.fromMilliseconds(0),
-                    interval: TimeSpan.fromMilliseconds(0),
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
                 expect(result).toBe(false);
             });
@@ -319,8 +391,8 @@ export function lockProviderTestSuite(settings) {
                     owner,
                 });
                 await lock.acquireBlocking({
-                    time: TimeSpan.fromMilliseconds(0),
-                    interval: TimeSpan.fromMilliseconds(0),
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
                 const result = await lock.isExpired();
                 expect(result).toBe(false);
@@ -334,8 +406,8 @@ export function lockProviderTestSuite(settings) {
                     owner,
                 });
                 await lock.acquireBlocking({
-                    time: TimeSpan.fromMilliseconds(0),
-                    interval: TimeSpan.fromMilliseconds(0),
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
                 });
                 const result = await lock.isLocked();
                 expect(result).toBe(true);
@@ -358,6 +430,88 @@ export function lockProviderTestSuite(settings) {
                 expect(index).toBeGreaterThan(1);
             });
         });
+        describe("method: acquireBlockingOrFail", () => {
+            test("Should not throw KeyAlreadyAcquiredLockError when lock is available", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                });
+                const promise = lock.acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await expect(promise).resolves.toBeUndefined();
+            });
+            test("Should throw KeyAlreadyAcquiredLockError when lock is already acquired", async () => {
+                const key = "a";
+                const ttl = null;
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                });
+                await lock.acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                const promise = lock.acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                await expect(promise).rejects.toBeInstanceOf(KeyAlreadyAcquiredLockError);
+            });
+            test("Should not be expired when released by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const owner = "b";
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                const result = await lock.isExpired();
+                expect(result).toBe(false);
+            });
+            test("Should be loked when released by same owner", async () => {
+                const key = "a";
+                const ttl = null;
+                const owner = "b";
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                    owner,
+                });
+                await lock.acquireBlockingOrFail({
+                    time: TimeSpan.fromMilliseconds(5),
+                    interval: TimeSpan.fromMilliseconds(5),
+                });
+                const result = await lock.isLocked();
+                expect(result).toBe(true);
+            });
+            test("Should retry acquire the lock", async () => {
+                const key = "a";
+                const ttl = TimeSpan.fromMilliseconds(50);
+                const lock = lockProviderA.create(key, {
+                    ttl,
+                });
+                await lock.acquire();
+                let index = 0;
+                await lock.addListener(KeyAlreadyAcquiredLockEvent, (_event) => {
+                    index++;
+                });
+                try {
+                    await lock.acquireBlockingOrFail({
+                        time: TimeSpan.fromMilliseconds(55),
+                        interval: TimeSpan.fromMilliseconds(5),
+                    });
+                }
+                catch {
+                    /* Empty */
+                }
+                expect(index).toBeGreaterThan(1);
+            });
+        });
         describe("method: release", () => {
             test("Should return true when released by same owner", async () => {
                 const key = "a";