@daiso-tech/core 0.26.1 → 0.28.0

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

@@ -1,9 +1,11 @@
 /**
  * @module Lock
  */
-import { delay, LazyPromise } from "../../../../async/_module-exports.js";
-import { UnexpectedErrorLockEvent, KeyAcquiredLockEvent, KeyAlreadyAcquiredLockError, KeyAlreadyAcquiredLockEvent, KeyForceReleasedLockEvent, KeyReleasedLockEvent, KeyRefreshedLockEvent, UnableToAquireLockError, UnownedRefreshLockError, UnownedRefreshLockEvent, UnownedReleaseLockError, UnownedReleaseLockEvent, } from "../../../../lock/contracts/_module-exports.js";
-import { LockState, } from "../../../../lock/implementations/derivables/lock-provider/lock-state.js";
+import {} from "../../../../utilities/_module-exports.js";
+import { resolveOneOrMoreStr } from "../../../../utilities/_module-exports.js";
+import { KeyAcquiredLockEvent, KeyAlreadyAcquiredLockError, KeyAlreadyAcquiredLockEvent, KeyForceReleasedLockEvent, KeyRefreshedLockEvent, KeyReleasedLockEvent, UnableToAquireLockError, UnexpectedErrorLockEvent, UnownedRefreshLockError, UnownedRefreshLockEvent, UnownedReleaseLockError, UnownedReleaseLockEvent, } from "../../../../lock/contracts/_module-exports.js";
+import {} from "../../../../lock/contracts/_module-exports.js";
+import { LazyPromise } from "../../../../async/_module-exports.js";
 /**
  * IMPORTANT: This class is not intended to be instantiated directly, instead it should be created by the <i>LockProvider</i> class instance.
  * @group Derivables
@@ -14,149 +16,153 @@ export class Lock {
      */
     static serialize(deserializedValue) {
         return {
-            group: deserializedValue.adapter.getGroup(),
-            key: deserializedValue.key,
+            group: deserializedValue.group,
+            key: deserializedValue.key.resolved,
             owner: deserializedValue.owner,
             ttlInMs: deserializedValue.ttl?.toMilliseconds() ?? null,
-            expirationInMs: deserializedValue.state.get()?.getTime() ?? null,
+            expirationInMs: deserializedValue.lockState.get()?.getTime() ?? null,
         };
     }
-    lockProviderEventDispatcher;
+    createLazyPromise;
+    adapterPromise;
+    lockState;
     lockEventBus;
-    adapter;
+    lockProviderEventDispatcher;
     key;
     owner;
     ttl;
     defaultBlockingInterval;
     defaultBlockingTime;
     defaultRefreshTime;
-    lazyPromiseSettings;
-    state;
+    group;
     /**
      * @internal
      */
     constructor(settings) {
-        const { lockProviderEventDispatcher, lockEventBus, defaultBlockingInterval, defaultBlockingTime, defaultRefreshTime, adapter, key, owner, ttl, lazyPromiseSettings, stateRecord, expirationInMs, } = settings;
+        const { group, createLazyPromise, adapterPromise, lockState, lockEventBus, lockProviderEventDispatcher, key, owner, ttl, expirationInMs, defaultBlockingInterval, defaultBlockingTime, defaultRefreshTime, } = settings;
+        this.group = group;
+        this.createLazyPromise = createLazyPromise;
+        this.adapterPromise = adapterPromise;
+        this.lockState = lockState;
+        this.lockState.set(expirationInMs);
+        this.lockEventBus = lockEventBus;
         this.lockProviderEventDispatcher = lockProviderEventDispatcher;
-        this.lockEventBus = lockEventBus.withGroup([adapter.getGroup(), key]);
+        this.key = key;
+        this.owner = resolveOneOrMoreStr(owner);
+        this.ttl = ttl;
         this.defaultBlockingInterval = defaultBlockingInterval;
         this.defaultBlockingTime = defaultBlockingTime;
         this.defaultRefreshTime = defaultRefreshTime;
-        this.adapter = adapter;
-        this.key = key;
-        this.owner = owner;
-        this.ttl = ttl;
-        this.lazyPromiseSettings = lazyPromiseSettings;
-        this.state = new LockState(stateRecord, key);
-        this.state.set(expirationInMs);
     }
-    createLayPromise(asyncFn) {
-        return new LazyPromise(asyncFn)
-            .setRetryAttempts(this.lazyPromiseSettings.retryAttempts)
-            .setBackoffPolicy(this.lazyPromiseSettings.backoffPolicy)
-            .setRetryPolicy(this.lazyPromiseSettings.retryPolicy)
-            .setTimeout(this.lazyPromiseSettings.timeout);
+    /**
+     * You can listen to the following <i>{@link LockEvents}</i> of the <i>{@link Lock}</i> instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     */
+    addListener(event, listener) {
+        return this.lockEventBus.addListener(event, listener);
+    }
+    /**
+     * You can listen to the following <i>{@link LockEvents}</i> of the <i>{@link Lock}</i> instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     */
+    addListenerMany(events, listener) {
+        return this.lockEventBus.addListenerMany(events, listener);
+    }
+    /**
+     * You can listen to the following <i>{@link LockEvents}</i> of the <i>{@link Lock}</i> instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     */
+    removeListener(event, listener) {
+        return this.lockEventBus.removeListener(event, listener);
+    }
+    /**
+     * You can listen to the following <i>{@link LockEvents}</i> of the <i>{@link Lock}</i> instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     */
+    removeListenerMany(events, listener) {
+        return this.lockEventBus.removeListenerMany(events, listener);
+    }
+    /**
+     * You can listen to the following <i>{@link LockEvents}</i> of lock instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     */
+    listenOnce(event, listener) {
+        return this.lockEventBus.listenOnce(event, listener);
+    }
+    /**
+     * You can listen to the following <i>{@link LockEvents}</i> of lock instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     */
+    asPromise(event) {
+        return this.lockEventBus.asPromise(event);
     }
     /**
+     * You can listen to the following <i>{@link LockEvents}</i> of lock instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     */
+    subscribe(event, listener) {
+        return this.lockEventBus.subscribe(event, listener);
+    }
+    /**
+     * You can listen to the following <i>{@link LockEvents}</i> of lock instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     */
+    subscribeMany(events, listener) {
+        return this.lockEventBus.subscribeMany(events, listener);
+    }
+    /**
+     * You can pass in a sync function or async function.
      * @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 { 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";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer, TimeSpan, LazyPromise } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
      *
      * const lock = lockProvider.create("a");
      *
-     * async function fn(): Promise<void> {
-     *   await lock.run(async () => {
-     *     console.log("START: ", 1);
-     *     // Let’s pretend we’re doing async database work.
-     *     await delay(TimeSpan.fromSeconds(2));
-     *     console.log("END: ", 2);
-     *   });
-     * }
-     *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
+     * await lock.run(async () => {
+     *   console.log("START");
+     *   await LazyPromise.delay(TimeSpan.fromSeconds(10));
+     *   console.log("END");
+     * });
      * ```
      *
-     * You can also pass an <i>{@link LazyPromise}</i> instead of async function.
+     * You can also pass in a <i>{@link LazyPromise}</i>. This is useful because all other components in this library returns <i>{@link LazyPromise}</i>.
      * @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 { 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";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer, TimeSpan, LazyPromise } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
      *
-     * const cache: IGroupableCache = new Cache({
-     *   // Let's pretend when the cache adapter increments a key it will occur in 2 async, get the value, increment the value in memory and update the key.
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
-     * await cache.put("a", 0);
      *
      * const lock = lockProvider.create("a");
      *
-     * async function fn(): Promise<void> {
-     *   // The lock will ensure the key will be incremented correctly
-     *   await lock.run(cache.increment("a", 1));
-     * }
-     *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
+     * await lock.run(
+     *   new LazyPromise(async () => {
+     *     console.log("START");
+     *     await LazyPromise.delay(TimeSpan.fromSeconds(10));
+     *     console.log("END");
+     *   })
+     * );
      * ```
      */
     run(asyncFn) {
-        return this.createLayPromise(async () => {
+        return this.createLazyPromise(async () => {
             if (typeof asyncFn === "function") {
                 asyncFn = new LazyPromise(asyncFn);
             }
@@ -165,7 +171,7 @@ export class Lock {
                 if (!hasAquired) {
                     return [
                         null,
-                        new KeyAlreadyAcquiredLockError(`Key "${this.key}" already acquired`),
+                        new KeyAlreadyAcquiredLockError(`Key "${this.key.resolved}" already acquired`),
                     ];
                 }
                 return [await asyncFn, null];
@@ -176,110 +182,58 @@ export class Lock {
         }).setRetryPolicy((error) => error instanceof UnableToAquireLockError);
     }
     /**
+     * You can pass in a sync function or async function.
      * @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 { 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";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer, TimeSpan, LazyPromise } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
      *
      * const lock = lockProvider.create("a");
      *
-     * async function fn(): Promise<void> {
-     *   await lock.runOrFail(async () => {
-     *     console.log("START: ", 1);
-     *     // Let’s pretend we’re doing async database work.
-     *     await delay(TimeSpan.fromSeconds(2));
-     *     console.log("END: ", 2);
-     *   })
-     *   // Retries 4 times to acquire the lock, then throws an error.
-     *   .setRetryAttempts(4);
-     * }
-     *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
+     * await lock.runOrFail(async () => {
+     *   console.log("START");
+     *   await LazyPromise.delay(TimeSpan.fromSeconds(10));
+     *   console.log("END");
+     * });
      * ```
      *
-     * You can also pass an <i>{@link LazyPromise}</i> instead of async function.
+     * You can also pass in a <i>{@link LazyPromise}</i>. This is useful because all other components in this library returns <i>{@link LazyPromise}</i>.
      * @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 { 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";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer, TimeSpan, LazyPromise } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
      *
-     * const cache: IGroupableCache = new Cache({
-     *   // Let's pretend when the cache adapter increments a key it will occur in 2 async, get the value, increment the value in memory and update the key.
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     * await cache.put("a", 0);
-     *
      * const lock = lockProvider.create("a");
      *
-     * async function fn(): Promise<void> {
-     *   await lock
-     *     // The lock will ensure the key will be incremented correctly
-     *     .runOrFail(cache.increment("a", 1));
-     *     // Retries 4 times to acquire the lock, then throws an error.
-     *     .setRetryAttempts(4);
-     * }
-     *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
+     * await lock.runOrFail(
+     *   new LazyPromise(async () => {
+     *     console.log("START");
+     *     await LazyPromise.delay(TimeSpan.fromSeconds(10));
+     *     console.log("END");
+     *   })
+     * );
      * ```
      */
     runOrFail(asyncFn) {
-        return this.createLayPromise(async () => {
+        return this.createLazyPromise(async () => {
             try {
                 if (typeof asyncFn === "function") {
                     asyncFn = new LazyPromise(asyncFn);
@@ -294,105 +248,58 @@ export class Lock {
             error instanceof KeyAlreadyAcquiredLockError);
     }
     /**
+     * You can pass in a sync function or async function.
      * @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 { 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";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer, TimeSpan, LazyPromise } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
      *
      * const lock = lockProvider.create("a");
      *
-     * async function fn(): Promise<void> {
-     *   await lock.runBlocking(async () => {
-     *     console.log("START: ", 1);
-     *     // Let’s pretend we’re doing async database work.
-     *     await delay(TimeSpan.fromSeconds(2));
-     *     console.log("END: ", 2);
-     *   });
-     * }
-     *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
+     * await lock.runBlocking(async () => {
+     *   console.log("START");
+     *   await LazyPromise.delay(TimeSpan.fromSeconds(10));
+     *   console.log("END");
+     * });
      * ```
      *
-     * You can also pass an <i>{@link LazyPromise}</i> instead of async function.
+     * You can also pass in a <i>{@link LazyPromise}</i>. This is useful because all other components in this library returns <i>{@link LazyPromise}</i>.
      * @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 { 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";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer, TimeSpan, LazyPromise } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
      *
-     * const cache: IGroupableCache = new Cache({
-     *   // Let's pretend when the cache adapter increments a key it will occur in 2 async, get the value, increment the value in memory and update the key.
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     * await cache.put("a", 0);
-     *
      * const lock = lockProvider.create("a");
      *
-     * async function fn(): Promise<void> {
-     *   // The lock will ensure the key will be incremented correctly
-     *   await lock.runBlocking(cache.increment("a", 1));
-     * }
-     *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
+     * await lock.runBlocking(
+     *   new LazyPromise(async () => {
+     *     console.log("START");
+     *     await LazyPromise.delay(TimeSpan.fromSeconds(10));
+     *     console.log("END");
+     *   })
+     * );
      * ```
      */
     runBlocking(asyncFn, settings) {
-        return this.createLayPromise(async () => {
+        return this.createLazyPromise(async () => {
             if (typeof asyncFn === "function") {
                 asyncFn = new LazyPromise(asyncFn);
             }
@@ -401,7 +308,7 @@ export class Lock {
                 if (!hasAquired) {
                     return [
                         null,
-                        new KeyAlreadyAcquiredLockError(`Key "${this.key}" already acquired`),
+                        new KeyAlreadyAcquiredLockError(`Key "${this.key.resolved}" already acquired`),
                     ];
                 }
                 return [await asyncFn, null];
@@ -412,67 +319,80 @@ export class Lock {
         }).setRetryPolicy((error) => error instanceof UnableToAquireLockError);
     }
     /**
+     * You can pass in a sync function or async function.
      * @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 { 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";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer, TimeSpan, LazyPromise } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
      *
      * const lock = lockProvider.create("a");
      *
-     * async function fn(): Promise<void> {
-     *   // Use try-finally when acquiring a lock to ensure it’s released if an error happens.
-     *   try {
-     *     const hasAquired = await lock.acquire();
-     *     if (!hasAquired) {
-     *       return;
-     *     }
-     *     console.log("START: ", 1);
-     *     // Let’s pretend we’re doing async database work.
-     *     await delay(TimeSpan.fromSeconds(2));
-     *     console.log("END: ", 2);
-     *   }
-     *   finally {
-     *     await lock.release();
-     *   }
-     * }
+     * await lock.runBlockingOrFail(async () => {
+     *   console.log("START");
+     *   await LazyPromise.delay(TimeSpan.fromSeconds(10));
+     *   console.log("END");
+     * });
+     * ```
      *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
+     * You can also pass in a <i>{@link LazyPromise}</i>. This is useful because all other components in this library returns <i>{@link LazyPromise}</i>.
+     * @example
+     * ```ts
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer, TimeSpan, LazyPromise } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
+     *
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
+     * });
+     *
+     * const lock = lockProvider.create("a");
+     *
+     * await lock.runBlockingOrFail(
+     *   new LazyPromise(async () => {
+     *     console.log("START");
+     *     await LazyPromise.delay(TimeSpan.fromSeconds(10));
+     *     console.log("END");
+     *   })
+     * );
      * ```
      */
+    runBlockingOrFail(asyncFn, settings) {
+        return new LazyPromise(async () => {
+            if (typeof asyncFn === "function") {
+                asyncFn = new LazyPromise(asyncFn);
+            }
+            try {
+                await this.acquireBlockingOrFail(settings);
+                return await asyncFn;
+            }
+            finally {
+                await this.release();
+            }
+        }).setRetryPolicy((error) => error instanceof UnableToAquireLockError);
+    }
     acquire() {
-        return this.createLayPromise(async () => {
+        return this.createLazyPromise(async () => {
             try {
-                this.state.remove();
-                const hasAquired = await this.adapter.acquire(this.key, this.owner, this.ttl);
+                const adapter = await this.adapterPromise;
+                this.lockState.remove();
+                const hasAquired = await adapter.acquire(this.key.prefixed, this.owner, this.ttl);
                 if (hasAquired) {
-                    this.state.set(this.ttl);
+                    this.lockState.set(this.ttl);
                     const event = new KeyAcquiredLockEvent({
-                        key: this.key,
+                        key: this.key.resolved,
                         owner: this.owner,
                         ttl: this.ttl,
                     });
@@ -481,7 +401,7 @@ export class Lock {
                 }
                 else {
                     const event = new KeyAlreadyAcquiredLockEvent({
-                        key: this.key,
+                        key: this.key.resolved,
                         owner: this.owner,
                     });
                     this.lockEventBus.dispatch(event).defer();
@@ -491,7 +411,7 @@ export class Lock {
             }
             catch (error) {
                 const event = new UnexpectedErrorLockEvent({
-                    key: this.key,
+                    key: this.key.resolved,
                     owner: this.owner,
                     ttl: this.ttl,
                     error,
@@ -502,140 +422,45 @@ export class Lock {
             }
         });
     }
-    /**
-     * @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 { 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";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const lock = lockProvider.create("a");
-     *
-     * async function fn(): Promise<void> {
-     *   // Use try-finally when acquiring a lock to ensure it’s released if an error happens.
-     *   try {
-     *     // Retries 4 times to acquire the lock, then throws an error.
-     *     await lock.acquireOrFail().setRetryAttempts(4);
-     *     console.log("START: ", 1);
-     *     // Let’s pretend we’re doing async database work.
-     *     await delay(TimeSpan.fromSeconds(2));
-     *     console.log("END: ", 2);
-     *   }
-     *   finally {
-     *     await lock.release();
-     *   }
-     * }
-     *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
-     * ```
-     */
     acquireOrFail() {
-        return this.createLayPromise(async () => {
+        return this.createLazyPromise(async () => {
             const hasAquired = await this.acquire();
             if (!hasAquired) {
-                throw new KeyAlreadyAcquiredLockError(`Key "${this.key}" already acquired`);
+                throw new KeyAlreadyAcquiredLockError(`Key "${this.key.resolved}" already acquired`);
             }
         });
     }
-    /**
-     * @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 { 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";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const lock = lockProvider.create("a");
-     *
-     * async function fn(): Promise<void> {
-     *   // Use try-finally when acquiring a lock to ensure it’s released if an error happens.
-     *   try {
-     *     const hasAquired = await lock.acquireBlocking();
-     *     if (!hasAquired) {
-     *       return;
-     *     }
-     *     console.log("START: ", 1);
-     *     // Let’s pretend we’re doing async database work.
-     *     await delay(TimeSpan.fromSeconds(2));
-     *     console.log("END: ", 2);
-     *   }
-     *   finally {
-     *     await lock.release();
-     *   }
-     * }
-     *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
-     * ```
-     */
     acquireBlocking(settings = {}) {
         return new LazyPromise(async () => {
-            const { time = this.defaultBlockingInterval, interval = this.defaultBlockingInterval, } = settings;
+            const { time = this.defaultBlockingTime, interval = this.defaultBlockingInterval, } = settings;
             const endDate = time.toEndDate();
             while (endDate.getTime() > new Date().getTime()) {
                 const hasAquired = await this.acquire();
                 if (hasAquired) {
                     return true;
                 }
-                await delay(interval);
+                await LazyPromise.delay(interval);
             }
             return false;
         });
     }
+    acquireBlockingOrFail(settings) {
+        return new LazyPromise(async () => {
+            const hasAquired = await this.acquireBlocking(settings);
+            if (!hasAquired) {
+                throw new KeyAlreadyAcquiredLockError(`Key "${this.key.resolved}" already acquired`);
+            }
+        });
+    }
     release() {
-        return this.createLayPromise(async () => {
+        return this.createLazyPromise(async () => {
             try {
-                const hasReleased = await this.adapter.release(this.key, this.owner);
+                const adapter = await this.adapterPromise;
+                const hasReleased = await adapter.release(this.key.prefixed, this.owner);
                 if (hasReleased) {
-                    this.state.remove();
+                    this.lockState.remove();
                     const event = new KeyReleasedLockEvent({
-                        key: this.key,
+                        key: this.key.resolved,
                         owner: this.owner,
                     });
                     this.lockEventBus.dispatch(event).defer();
@@ -643,7 +468,7 @@ export class Lock {
                 }
                 else {
                     const event = new UnownedReleaseLockEvent({
-                        key: this.key,
+                        key: this.key.resolved,
                         owner: this.owner,
                     });
                     this.lockEventBus.dispatch(event).defer();
@@ -653,7 +478,7 @@ export class Lock {
             }
             catch (error) {
                 const event = new UnexpectedErrorLockEvent({
-                    key: this.key,
+                    key: this.key.resolved,
                     owner: this.owner,
                     ttl: this.ttl,
                     error,
@@ -665,27 +490,28 @@ export class Lock {
         });
     }
     releaseOrFail() {
-        return this.createLayPromise(async () => {
+        return this.createLazyPromise(async () => {
             const hasRelased = await this.release();
             if (!hasRelased) {
-                throw new UnownedReleaseLockError(`Unonwed release on key "${this.key}" by owner "${this.owner}"`);
+                throw new UnownedReleaseLockError(`Unonwed release on key "${this.key.resolved}" by owner "${this.owner}"`);
             }
         });
     }
     forceRelease() {
-        return this.createLayPromise(async () => {
+        return this.createLazyPromise(async () => {
             try {
-                await this.adapter.forceRelease(this.key);
-                this.state.remove();
+                const adapter = await this.adapterPromise;
+                await adapter.forceRelease(this.key.prefixed);
+                this.lockState.remove();
                 const event = new KeyForceReleasedLockEvent({
-                    key: this.key,
+                    key: this.key.resolved,
                 });
                 this.lockEventBus.dispatch(event).defer();
                 this.lockProviderEventDispatcher.dispatch(event).defer();
             }
             catch (error) {
                 const event = new UnexpectedErrorLockEvent({
-                    key: this.key,
+                    key: this.key.resolved,
                     owner: this.owner,
                     ttl: this.ttl,
                     error,
@@ -698,13 +524,13 @@ export class Lock {
     }
     isExpired() {
         // eslint-disable-next-line @typescript-eslint/require-await
-        return this.createLayPromise(async () => {
+        return this.createLazyPromise(async () => {
             try {
-                return this.state.isExpired();
+                return this.lockState.isExpired();
             }
             catch (error) {
                 const event = new UnexpectedErrorLockEvent({
-                    key: this.key,
+                    key: this.key.resolved,
                     owner: this.owner,
                     ttl: this.ttl,
                     error,
@@ -716,28 +542,29 @@ export class Lock {
         });
     }
     isLocked() {
-        return this.createLayPromise(async () => {
+        return this.createLazyPromise(async () => {
             const isExpired = await this.isExpired();
             return !isExpired;
         });
     }
     refresh(ttl = this.defaultRefreshTime) {
-        return this.createLayPromise(async () => {
+        return this.createLazyPromise(async () => {
             try {
-                const hasRefreshed = await this.adapter.refresh(this.key, this.owner, ttl);
+                const adapter = await this.adapterPromise;
+                const hasRefreshed = await adapter.refresh(this.key.prefixed, this.owner, ttl);
                 if (hasRefreshed) {
                     const event = new KeyRefreshedLockEvent({
-                        key: this.key,
+                        key: this.key.resolved,
                         owner: this.owner,
                         ttl,
                     });
-                    this.state.set(ttl);
+                    this.lockState.set(ttl);
                     this.lockEventBus.dispatch(event).defer();
                     this.lockProviderEventDispatcher.dispatch(event).defer();
                 }
                 else {
                     const event = new UnownedRefreshLockEvent({
-                        key: this.key,
+                        key: this.key.resolved,
                         owner: this.owner,
                     });
                     this.lockEventBus.dispatch(event).defer();
@@ -747,7 +574,7 @@ export class Lock {
             }
             catch (error) {
                 const event = new UnexpectedErrorLockEvent({
-                    key: this.key,
+                    key: this.key.resolved,
                     owner: this.owner,
                     ttl: this.ttl,
                     error,
@@ -759,311 +586,24 @@ export class Lock {
         });
     }
     refreshOrFail(ttl) {
-        return this.createLayPromise(async () => {
+        return this.createLazyPromise(async () => {
             const hasRefreshed = await this.refresh(ttl);
             if (!hasRefreshed) {
-                throw new UnownedRefreshLockError(`Unonwed refresh on key "${this.key}" by owner "${this.owner}"`);
+                throw new UnownedRefreshLockError(`Unonwed refresh on key "${this.key.resolved}" by owner "${this.owner}"`);
             }
         });
     }
     getRemainingTime() {
         // eslint-disable-next-line @typescript-eslint/require-await
-        return this.createLayPromise(async () => {
-            return this.state.getRemainingTime();
+        return this.createLazyPromise(async () => {
+            return this.lockState.getRemainingTime();
         });
     }
     getOwner() {
         // eslint-disable-next-line @typescript-eslint/require-await
-        return this.createLayPromise(async () => {
+        return this.createLazyPromise(async () => {
             return this.owner;
         });
     }
-    /**
-     * You can listen to different events of the current <i>Lock</i> class instance.
-     *
-     * 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 { 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";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const lock = lockProvider.create("a");
-     *
-     * const listener: Invokable <LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lock.addListener(KeyAcquiredLockEvent, listener);
-     * await lock.acquire();
-     * ```
-     */
-    addListener(event, listener) {
-        return this.lockEventBus.addListener(event, listener);
-    }
-    /**
-     * You can listen to different events of the current <i>Lock</i> class instance.
-     *
-     * 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 { 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";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const lock = lockProvider.create("a");
-     *
-     * const listener: Invokable <LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lock.addListenerMany([KeyAcquiredLockEvent], listener);
-     * await lock.acquire();
-     * ```
-     */
-    addListenerMany(events, listener) {
-        return this.lockEventBus.addListenerMany(events, listener);
-    }
-    /**
-     * You can listen to different events of the current <i>Lock</i> class instance.
-     *
-     * 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 { 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";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const lock = lockProvider.create("a");
-     *
-     * const listener: Invokable <LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lock.addListener(KeyAcquiredLockEvent, listener);
-     * await lock.removeListener(KeyAcquiredLockEvent, listener);
-     * await lock.acquire();
-     * ```
-     */
-    removeListener(event, listener) {
-        return this.lockEventBus.removeListener(event, listener);
-    }
-    /**
-     * You can listen to different events of the current <i>Lock</i> class instance.
-     *
-     * 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 { 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";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const lock = lockProvider.create("a");
-     *
-     * const listener: Invokable <LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lock.addListenerMany([KeyAcquiredLockEvent], listener);
-     * await lock.removeListenerMany([KeyAcquiredLockEvent], listener);
-     * await lock.acquire();
-     * ```
-     */
-    removeListenerMany(events, listener) {
-        return this.lockEventBus.removeListenerMany(events, listener);
-    }
-    /**
-     * You can listen to different events of the current <i>Lock</i> class instance.
-     *
-     * 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 { 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";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const lock = lockProvider.create("a");
-     *
-     * const listener: Invokable <LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lock.listenOnce(KeyAcquiredLockEvent, listener);
-     * await lock.acquire();
-     * ```
-     */
-    listenOnce(event, listener) {
-        return this.lockEventBus.listenOnce(event, listener);
-    }
-    asPromise(event) {
-        return this.lockEventBus.asPromise(event);
-    }
-    /**
-     * You can listen to different events of the current <i>Lock</i> class instance.
-     *
-     * 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 { 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";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const lock = lockProvider.create("a");
-     *
-     * const listener: Invokable <LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * const unsubscribe = await lock.subscribe(KeyAcquiredLockEvent, listener);
-     * await lock.acquire();
-     * await unsubscribe();
-     * ```
-     */
-    subscribe(event, listener) {
-        return this.lockEventBus.subscribe(event, listener);
-    }
-    /**
-     * You can listen to different events of the current <i>Lock</i> class instance.
-     *
-     * 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 { 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";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const lock = lockProvider.create("a");
-     *
-     * const listener: Invokable <LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * const unsubscribe = await lock.subscribeMany([KeyAcquiredLockEvent], listener);
-     * await lock.acquire();
-     * await unsubscribe();
-     * ```
-     */
-    subscribeMany(events, listener) {
-        return this.lockEventBus.subscribeMany(events, listener);
-    }
 }
 //# sourceMappingURL=lock.js.map