@daiso-tech/core 0.24.0 → 0.26.0

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

@@ -1,11 +1,11 @@
 /**
  * @module Lock
  */
-import { TimeSpan, type OneOrMore } from "../../../../utilities/_module-exports.js";
+import { TimeSpan, type Invokable, type OneOrMore } from "../../../../utilities/_module-exports.js";
 import type { IDatabaseLockAdapter, LockEvents } from "../../../../lock/contracts/_module-exports.js";
 import { type ILock, type IGroupableLockProvider, type LockProviderCreateSettings, type ILockProvider, type ILockAdapter } from "../../../../lock/contracts/_module-exports.js";
 import type { BackoffPolicy, LazyPromise, RetryPolicy } from "../../../../async/_module-exports.js";
-import type { EventClass, EventInstance, IGroupableEventBus, Listener, Unsubscribe } from "../../../../event-bus/contracts/_module-exports.js";
+import type { EventClass, EventInstance, IGroupableEventBus, Unsubscribe } from "../../../../event-bus/contracts/_module-exports.js";
 import type { IFlexibleSerde } from "../../../../serde/contracts/_module-exports.js";
 /**
  *
@@ -20,17 +20,45 @@ export type LockProviderSettings = {
     adapter: ILockAdapter | IDatabaseLockAdapter;
     serde: OneOrMore<IFlexibleSerde>;
     /**
-     * In order to listen to events of <i>{@link LockProvider}</i> class you must pass in <i>{@link IGroupableEventBus}</i>.
+     * @default
+     * ```ts
+     * new EventBus({
+     *   adapter: new MemoryEventBusAdapter({
+     *     rootGroup: "@global"
+     *   })
+     * })
+     * ```
      */
     eventBus?: IGroupableEventBus<any>;
     /**
      * You can decide the default ttl value for <i>{@link ILock}</i> expiration. If null is passed then no ttl will be used by default.
-     * @default TimeSpan.fromMinutes(5);
+     * @default
+     * ```ts
+     * TimeSpan.fromMinutes(5);
+     * ```
      */
     defaultTtl?: TimeSpan | null;
+    /**
+     * The default refresh time used in the <i>{@link ILock}</i> <i>acquireBlocking</i> and <i>runBlocking</i> methods.
+     * @default
+     * ```ts
+     * TimeSpan.fromSeconds(1);
+     * ```
+     */
+    defaultBlockingInterval?: TimeSpan;
+    /**
+     * The default refresh time used in the <i>{@link ILock}</i> <i>acquireBlocking</i> and <i>runBlocking</i> methods.
+     * @default
+     * ```ts
+     * TimeSpan.fromMinutes(1);
+     * ```
+     */
+    defaultBlockingTime?: TimeSpan;
     /**
      * The default refresh time used in the <i>{@link ILock}</i> <i>extend</i> method.
-     * @default TimeSpan.fromMinutes(5);
+     * ```ts
+     * TimeSpan.fromMinutes(5);
+     * ```
      */
     defaultRefreshTime?: TimeSpan;
     /**
@@ -72,6 +100,8 @@ export declare class LockProvider implements IGroupableLockProvider {
     private readonly createOwnerId;
     private readonly adapter;
     private readonly defaultTtl;
+    private readonly defaultBlockingInterval;
+    private readonly defaultBlockingTime;
     private readonly defaultRefreshTime;
     private readonly retryAttempts;
     private readonly backoffPolicy;
@@ -107,16 +137,16 @@ export declare class LockProvider implements IGroupableLockProvider {
     constructor(settings: LockProviderSettings);
     private registerToSerde;
     /**
-     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     * You can listen to different events of all locks created by <i>LockProvider</i> class instance.
      *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
-     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
+     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
      * @example
      * ```ts
      * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
      * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
      * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
      * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
      * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
      * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
@@ -134,24 +164,26 @@ export declare class LockProvider implements IGroupableLockProvider {
      *   eventBus,
      * });
      *
-     * const listener: Listener<LockEvents> = event => {
+     * const listener: Invokable<LockEvents> = event => {
      *   console.log(event);
      * }
      * await lockProvider.addListener(KeyAcquiredLockEvent, listener);
+     * await lockProvider.removeListener(KeyAcquiredLockEvent, listener);
+     * await lockProvider.create("a").acquire();
      * ```
      */
-    addListener<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    addListener<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
     /**
-     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     * You can listen to different events of all locks created by <i>LockProvider</i> class instance.
      *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
-     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
+     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
      * @example
      * ```ts
      * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
      * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
      * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
      * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
      * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
      * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
@@ -169,24 +201,26 @@ export declare class LockProvider implements IGroupableLockProvider {
      *   eventBus,
      * });
      *
-     * const listener: Listener<LockEvents> = event => {
+     * const listener: Invokable<LockEvents> = event => {
      *   console.log(event);
      * }
      * await lockProvider.addListenerMany([KeyAcquiredLockEvent], listener);
+     * await lockProvider.removeListenerMany([KeyAcquiredLockEvent], listener);
+     * await lockProvider.create("a").acquire();
      * ```
      */
-    addListenerMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    addListenerMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
     /**
-     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     * You can listen to different events of all locks created by <i>LockProvider</i> class instance.
      *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
-     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
+     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
      * @example
      * ```ts
      * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
      * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
      * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
      * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
      * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
      * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
@@ -204,24 +238,26 @@ export declare class LockProvider implements IGroupableLockProvider {
      *   eventBus,
      * });
      *
-     * const listener: Listener<LockEvents> = event => {
+     * const listener: Invokable<LockEvents> = event => {
      *   console.log(event);
      * }
+     * await lockProvider.addListener(KeyAcquiredLockEvent, listener);
      * await lockProvider.removeListener(KeyAcquiredLockEvent, listener);
+     * await lockProvider.create("a").acquire();
      * ```
      */
-    removeListener<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    removeListener<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
     /**
-     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     * You can listen to different events of all locks created by <i>LockProvider</i> class instance.
      *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
-     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
+     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
      * @example
      * ```ts
      * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
      * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
      * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
      * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
      * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
      * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
@@ -239,24 +275,26 @@ export declare class LockProvider implements IGroupableLockProvider {
      *   eventBus,
      * });
      *
-     * const listener: Listener<LockEvents> = event => {
+     * const listener: Invokable<LockEvents> = event => {
      *   console.log(event);
      * }
+     * await lockProvider.addListenerMany(KeyAcquiredLockEvent, listener);
      * await lockProvider.removeListenerMany([KeyAcquiredLockEvent], listener);
+     * await lockProvider.create("a").acquire();
      * ```
      */
-    removeListenerMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    removeListenerMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
     /**
-     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     * You can listen to different events of all locks created by <i>LockProvider</i> class instance.
      *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
-     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
+     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
      * @example
      * ```ts
      * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
      * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
      * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
      * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
      * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
      * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
@@ -274,24 +312,26 @@ export declare class LockProvider implements IGroupableLockProvider {
      *   eventBus,
      * });
      *
-     * const listener: Listener<LockEvents> = event => {
+     * const listener: Invokable<LockEvents> = event => {
      *   console.log(event);
      * }
      * await lockProvider.listenOnce(KeyAcquiredLockEvent, listener);
+     * await lockProvider.create("a").acquire();
      * ```
      */
-    listenOnce<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    listenOnce<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
+    asPromise<TEventClass extends EventClass<LockEvents>>(event: TEventClass): LazyPromise<EventInstance<TEventClass>>;
     /**
-     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     * You can listen to different events of all locks created by <i>LockProvider</i> class instance.
      *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
-     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
+     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
      * @example
      * ```ts
      * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
      * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
      * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
      * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
      * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
      * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
@@ -309,25 +349,26 @@ export declare class LockProvider implements IGroupableLockProvider {
      *   eventBus,
      * });
      *
-     * const listener: Listener<LockEvents> = event => {
+     * const listener: Invokable<LockEvents> = event => {
      *   console.log(event);
      * }
      * const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, listener);
+     * await lockProvider.create("a").acquire();
      * await unsubscribe();
      * ```
      */
-    subscribe<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    subscribe<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
     /**
-     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     * You can listen to different events of all locks created by <i>LockProvider</i> class instance.
      *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
-     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
+     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
      * @example
      * ```ts
      * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
      * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
      * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
      * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
      * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
      * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
@@ -345,14 +386,15 @@ export declare class LockProvider implements IGroupableLockProvider {
      *   eventBus,
      * });
      *
-     * const listener: Listener<LockEvents> = event => {
+     * const listener: Invokable<LockEvents> = event => {
      *   console.log(event);
      * }
      * const unsubscribe = await lockProvider.subscribeMany([KeyAcquiredLockEvent], listener);
+     * await lockProvider.create("a").acquire();
      * await unsubscribe();
      * ```
      */
-    subscribeMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Invokable<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
     /**
      * ```ts
      * import type { IGroupableLockProvider } from "@daiso-tech/core/lock/contracts";
@@ -385,7 +427,7 @@ export declare class LockProvider implements IGroupableLockProvider {
      * });
      *
      * // You can provide a custom owner. By default the owner will be unique random value.
-     * const lockB = lockProvider.create("b", {
+     * const lockC = lockProvider.create("b", {
      *   owner: "user-1"
      * });
      * ```

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

@@ -1,11 +1,11 @@
 /**
  * @module Lock
  */
-import { CORE, simplifyOneOrMoreStr, TimeSpan, } from "../../../../utilities/_module-exports.js";
+import { CORE, resolveOneOrMoreStr, TimeSpan, } from "../../../../utilities/_module-exports.js";
 import {} from "../../../../lock/contracts/_module-exports.js";
 import { Lock } from "../../../../lock/implementations/derivables/lock-provider/lock.js";
 import { EventBus } from "../../../../event-bus/implementations/derivables/_module-exports.js";
-import { NoOpEventBusAdapter } from "../../../../event-bus/implementations/adapters/_module-exports.js";
+import { MemoryEventBusAdapter } from "../../../../event-bus/implementations/adapters/_module-exports.js";
 import { v4 } from "uuid";
 import { DatabaseLockAdapter } from "../../../../lock/implementations/derivables/lock-provider/database-lock-adapter.js";
 import { LockSerdeTransformer } from "../../../../lock/implementations/derivables/lock-provider/lock-serde-transformer.js";
@@ -47,6 +47,8 @@ export class LockProvider {
     createOwnerId;
     adapter;
     defaultTtl;
+    defaultBlockingInterval;
+    defaultBlockingTime;
     defaultRefreshTime;
     retryAttempts;
     backoffPolicy;
@@ -80,8 +82,10 @@ export class LockProvider {
      * ```
      */
     constructor(settings) {
-        const { createOwnerId = () => v4(), adapter, defaultTtl = LockProvider.DEFAULT_TTL, defaultRefreshTime = LockProvider.DEFAULT_REFRESH_TIME, retryAttempts = null, backoffPolicy = null, retryPolicy = null, timeout = null, eventBus = new EventBus({
-            adapter: new NoOpEventBusAdapter(),
+        const { createOwnerId = () => v4(), adapter, defaultTtl = LockProvider.DEFAULT_TTL, defaultBlockingInterval = TimeSpan.fromSeconds(1), defaultBlockingTime = TimeSpan.fromMinutes(1), defaultRefreshTime = LockProvider.DEFAULT_REFRESH_TIME, retryAttempts = null, backoffPolicy = null, retryPolicy = null, timeout = null, eventBus = new EventBus({
+            adapter: new MemoryEventBusAdapter({
+                rootGroup: "@global",
+            }),
         }), serde, } = settings;
         this.createOwnerId = createOwnerId;
         if (LockProvider.isDatabaseAdapter(adapter)) {
@@ -92,6 +96,8 @@ export class LockProvider {
         }
         this.serde = serde;
         this.defaultTtl = defaultTtl ?? LockProvider.DEFAULT_TTL;
+        this.defaultBlockingInterval = defaultBlockingInterval;
+        this.defaultBlockingTime = defaultBlockingTime;
         this.defaultRefreshTime = defaultRefreshTime;
         this.retryAttempts = retryAttempts;
         this.backoffPolicy = backoffPolicy;
@@ -103,6 +109,8 @@ export class LockProvider {
     }
     registerToSerde() {
         const transformer = new LockSerdeTransformer({
+            defaultBlockingInterval: this.defaultBlockingInterval,
+            defaultBlockingTime: this.defaultBlockingTime,
             adapter: this.adapter,
             backoffPolicy: this.backoffPolicy,
             defaultRefreshTime: this.defaultRefreshTime,
@@ -120,16 +128,16 @@ export class LockProvider {
         }
     }
     /**
-     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     * You can listen to different events of all locks created by <i>LockProvider</i> class instance.
      *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
-     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
+     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
      * @example
      * ```ts
      * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
      * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
      * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
      * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
      * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
      * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
@@ -147,26 +155,28 @@ export class LockProvider {
      *   eventBus,
      * });
      *
-     * const listener: Listener<LockEvents> = event => {
+     * const listener: Invokable<LockEvents> = event => {
      *   console.log(event);
      * }
      * await lockProvider.addListener(KeyAcquiredLockEvent, listener);
+     * await lockProvider.removeListener(KeyAcquiredLockEvent, listener);
+     * await lockProvider.create("a").acquire();
      * ```
      */
     addListener(event, listener) {
         return this.lockProviderEventBus.addListener(event, listener);
     }
     /**
-     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     * You can listen to different events of all locks created by <i>LockProvider</i> class instance.
      *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
-     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
+     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
      * @example
      * ```ts
      * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
      * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
      * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
      * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
      * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
      * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
@@ -184,26 +194,28 @@ export class LockProvider {
      *   eventBus,
      * });
      *
-     * const listener: Listener<LockEvents> = event => {
+     * const listener: Invokable<LockEvents> = event => {
      *   console.log(event);
      * }
      * await lockProvider.addListenerMany([KeyAcquiredLockEvent], listener);
+     * await lockProvider.removeListenerMany([KeyAcquiredLockEvent], listener);
+     * await lockProvider.create("a").acquire();
      * ```
      */
     addListenerMany(events, listener) {
         return this.lockProviderEventBus.addListenerMany(events, listener);
     }
     /**
-     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     * You can listen to different events of all locks created by <i>LockProvider</i> class instance.
      *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
-     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
+     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
      * @example
      * ```ts
      * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
      * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
      * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
      * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
      * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
      * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
@@ -221,26 +233,28 @@ export class LockProvider {
      *   eventBus,
      * });
      *
-     * const listener: Listener<LockEvents> = event => {
+     * const listener: Invokable<LockEvents> = event => {
      *   console.log(event);
      * }
+     * await lockProvider.addListener(KeyAcquiredLockEvent, listener);
      * await lockProvider.removeListener(KeyAcquiredLockEvent, listener);
+     * await lockProvider.create("a").acquire();
      * ```
      */
     removeListener(event, listener) {
         return this.lockProviderEventBus.removeListener(event, listener);
     }
     /**
-     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     * You can listen to different events of all locks created by <i>LockProvider</i> class instance.
      *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
-     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
+     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
      * @example
      * ```ts
      * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
      * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
      * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
      * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
      * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
      * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
@@ -258,26 +272,28 @@ export class LockProvider {
      *   eventBus,
      * });
      *
-     * const listener: Listener<LockEvents> = event => {
+     * const listener: Invokable<LockEvents> = event => {
      *   console.log(event);
      * }
+     * await lockProvider.addListenerMany(KeyAcquiredLockEvent, listener);
      * await lockProvider.removeListenerMany([KeyAcquiredLockEvent], listener);
+     * await lockProvider.create("a").acquire();
      * ```
      */
     removeListenerMany(events, listener) {
         return this.lockProviderEventBus.removeListenerMany(events, listener);
     }
     /**
-     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     * You can listen to different events of all locks created by <i>LockProvider</i> class instance.
      *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
-     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
+     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
      * @example
      * ```ts
      * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
      * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
      * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
      * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
      * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
      * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
@@ -295,26 +311,30 @@ export class LockProvider {
      *   eventBus,
      * });
      *
-     * const listener: Listener<LockEvents> = event => {
+     * const listener: Invokable<LockEvents> = event => {
      *   console.log(event);
      * }
      * await lockProvider.listenOnce(KeyAcquiredLockEvent, listener);
+     * await lockProvider.create("a").acquire();
      * ```
      */
     listenOnce(event, listener) {
         return this.lockProviderEventBus.listenOnce(event, listener);
     }
+    asPromise(event) {
+        return this.lockProviderEventBus.asPromise(event);
+    }
     /**
-     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     * You can listen to different events of all locks created by <i>LockProvider</i> class instance.
      *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
-     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
+     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
      * @example
      * ```ts
      * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
      * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
      * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
      * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
      * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
      * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
@@ -332,10 +352,11 @@ export class LockProvider {
      *   eventBus,
      * });
      *
-     * const listener: Listener<LockEvents> = event => {
+     * const listener: Invokable<LockEvents> = event => {
      *   console.log(event);
      * }
      * const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, listener);
+     * await lockProvider.create("a").acquire();
      * await unsubscribe();
      * ```
      */
@@ -343,16 +364,16 @@ export class LockProvider {
         return this.lockProviderEventBus.subscribe(event, listener);
     }
     /**
-     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     * You can listen to different events of all locks created by <i>LockProvider</i> class instance.
      *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
-     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
+     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
      * @example
      * ```ts
      * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
      * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
      * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import type { Invokable} from "@daiso-tech/core/event-bus/contracts";
      * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
      * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
      * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
@@ -370,10 +391,11 @@ export class LockProvider {
      *   eventBus,
      * });
      *
-     * const listener: Listener<LockEvents> = event => {
+     * const listener: Invokable<LockEvents> = event => {
      *   console.log(event);
      * }
      * const unsubscribe = await lockProvider.subscribeMany([KeyAcquiredLockEvent], listener);
+     * await lockProvider.create("a").acquire();
      * await unsubscribe();
      * ```
      */
@@ -412,7 +434,7 @@ export class LockProvider {
      * });
      *
      * // You can provide a custom owner. By default the owner will be unique random value.
-     * const lockB = lockProvider.create("b", {
+     * const lockC = lockProvider.create("b", {
      *   owner: "user-1"
      * });
      * ```
@@ -420,12 +442,14 @@ export class LockProvider {
     create(key, settings = {}) {
         const { ttl = this.defaultTtl, owner = this.createOwnerId() } = settings;
         return new Lock({
+            defaultBlockingInterval: this.defaultBlockingInterval,
+            defaultBlockingTime: this.defaultBlockingTime,
             lockProviderEventDispatcher: this.lockProviderEventBus,
             lockEventBus: this.eventBus,
             adapter: this.adapter,
             defaultRefreshTime: this.defaultRefreshTime,
-            key: simplifyOneOrMoreStr(key),
-            owner: simplifyOneOrMoreStr(owner),
+            key: resolveOneOrMoreStr(key),
+            owner: resolveOneOrMoreStr(owner),
             ttl,
             lazyPromiseSettings: {
                 backoffPolicy: this.backoffPolicy,
@@ -501,7 +525,7 @@ export class LockProvider {
      */
     withGroup(group) {
         return new LockProvider({
-            adapter: this.adapter.withGroup(simplifyOneOrMoreStr(group)),
+            adapter: this.adapter.withGroup(resolveOneOrMoreStr(group)),
             eventBus: this.eventBus,
             defaultTtl: this.defaultTtl,
             defaultRefreshTime: this.defaultRefreshTime,