@daiso-tech/core 0.26.1 → 0.28.0

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

@@ -1,15 +1,18 @@
 /**
  * @module Lock
  */
-import { CORE, resolveOneOrMoreStr, TimeSpan, } from "../../../../utilities/_module-exports.js";
+import { resolveOneOrMore, TimeSpan, } from "../../../../utilities/_module-exports.js";
+import { KeyPrefixer, resolveFactoryable, } from "../../../../utilities/_module-exports.js";
 import {} from "../../../../lock/contracts/_module-exports.js";
-import { Lock } from "../../../../lock/implementations/derivables/lock-provider/lock.js";
+import { LazyPromise, } from "../../../../async/_module-exports.js";
+import { isDatabaseLockAdapter } from "../../../../lock/implementations/derivables/lock-provider/is-database-lock-adapter.js";
+import { DatabaseLockAdapter } from "../../../../lock/implementations/derivables/lock-provider/database-lock-adapter.js";
 import { EventBus } from "../../../../event-bus/implementations/derivables/_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 { Lock } from "../../../../lock/implementations/derivables/lock-provider/lock.js";
+import { LockState, } from "../../../../lock/implementations/derivables/lock-provider/lock-state.js";
 import { LockSerdeTransformer } from "../../../../lock/implementations/derivables/lock-provider/lock-serde-transformer.js";
-import { isDatabaseLockAdapter } from "../../../../lock/implementations/derivables/lock-provider/is-database-lock-adapter.js";
 /**
  * <i>LockProvider</i> class can be derived from any <i>{@link ILockAdapter}</i> or <i>{@link IDatabaseLockAdapter}</i>.
  *
@@ -17,503 +20,352 @@ import { isDatabaseLockAdapter } from "../../../../lock/implementations/derivabl
  * allowing them to be seamlessly transferred across different servers, processes, and databases.
  * This can be done directly using <i>{@link IFlexibleSerde}</i> or indirectly through components that rely on <i>{@link IFlexibleSerde}</i> internally.
  *
- * IMPORT_PATH: ```"@daiso-tech/core/lock/implementations/derivables"```
+ * IMPORT_PATH: ```"@daiso-tech/core/lock"```
  * @group Derivables
  */
 export class LockProvider {
-    static DEFAULT_TTL = TimeSpan.fromMinutes(5);
-    static DEFAULT_REFRESH_TIME = TimeSpan.fromMinutes(5);
-    serde;
+    static resolveLockAdapter(adapter) {
+        if (isDatabaseLockAdapter(adapter)) {
+            return new DatabaseLockAdapter(adapter);
+        }
+        return adapter;
+    }
+    static async resolveLockAdapterFactoryable(factoryable, settings) {
+        const { serde, lockStore, keyPrefixer, createLazyPromise, defaultBlockingInterval, defaultBlockingTime, defaultRefreshTime, groupableEventBus, } = settings;
+        const adapter = await resolveFactoryable(factoryable, keyPrefixer.keyPrefix);
+        const resolvedAdapter = LockProvider.resolveLockAdapter(adapter);
+        const transformer = new LockSerdeTransformer({
+            keyPrefixer,
+            adapter: resolvedAdapter,
+            createLazyPromise,
+            lockStore,
+            defaultBlockingInterval,
+            defaultBlockingTime,
+            defaultRefreshTime,
+            groupableEventBus,
+        });
+        for (const serde_ of resolveOneOrMore(serde)) {
+            serde_.registerCustom(transformer);
+        }
+        return resolvedAdapter;
+    }
+    lockStore = {};
+    groupableEventBus;
+    eventBus;
+    adapterFactoryable;
+    adapterPromise;
+    retryAttempts;
+    backoffPolicy;
+    retryPolicy;
+    retryTimeout;
+    totalTimeout;
+    keyPrefixer;
     createOwnerId;
-    adapter;
     defaultTtl;
     defaultBlockingInterval;
     defaultBlockingTime;
     defaultRefreshTime;
-    retryAttempts;
-    backoffPolicy;
-    retryPolicy;
-    timeout;
-    eventBus;
-    lockProviderEventBus;
-    stateRecord = {};
+    serde;
     /**
      * @example
      * ```ts
-     * import type { IGroupableLockProvider } 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 { 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 { SqliteLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
+     *
+     * const database = new Sqlite("local.db");
+     * const lockAdapter = new SqliteLockAdapter({
+     *   database,
+     * });
+     * // You need initialize the adapter once before using it.
+     * await lockAdapter.init();
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * const lockProvider = new LockProvider({
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   adapter: lockAdapter,
      * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
+     * ```
+     *
+     * You can pass factory function that will create an adapter for every group.
+     * @example
+     * ```ts
+     * import { SqliteLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import type { ILockAdapter } from "@daiso-tech/core/lock/contracts";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { KeyPrefixer, type ISqliteDatabase, type FactoryFn } from "@daiso-tech/core/utilities";
+     *
+     * async function lockAdapterFactory(database: ISqliteDatabase): FactoryFn<string, ILockAdapter> {
+     *   return async (prefix) => {
+     *     const lockAdapter = new SqliteLockAdapter({
+     *       database,
+     *       tableName: `lock_${prefix}`,
+     *     });
+     *     // You need initialize the adapter once before using it.
+     *     await lockAdapter.init();
+     *     return lockAdapter;
+     *   }
+     * }
+     *
+     * const database = new Sqlite("local.db");
+     * const lockProvider = new LockProvider({
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   adapter: lockAdapterFactory(database),
+     * });
+     * ```
+     *
+     * You can also pass factory object that implements <i>{@link IFactoryObject}</i> contract. This useful for depedency injection libraries.
+     * @example
+     * ```ts
+     * import { SqliteLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import type { ILockAdapter } from "@daiso-tech/core/lock/contracts";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { KeyPrefixer, type ISqliteDatabase, type IFactoryObject, type Promiseable } from "@daiso-tech/core/utilities";
+     *
+     * class LockAdapterFactory implements IFactoryObject<string, ILockAdapter> {
+     *   constructor(private readonly database: ISqliteDatabase) {}
+     *
+     *   async use(prefix: string): Promiseable<ILockAdapter> {
+     *     const lockAdapter = new SqliteLockAdapter({
+     *       database,
+     *       tableName: `lock_${prefix}`,
+     *     });
+     *     // You need initialize the adapter once before using it.
+     *     await lockAdapter.init();
+     *     return lockAdapter;
+     *   }
+     * }
+     *
+     * const database = new Sqlite("local.db");
+     * const lockProvider = new LockProvider({
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   adapter: new LockAdapterFactory(database),
      * });
      * ```
      */
     constructor(settings) {
-        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 (isDatabaseLockAdapter(adapter)) {
-            this.adapter = new DatabaseLockAdapter(adapter);
-        }
-        else {
-            this.adapter = adapter;
-        }
+        const { defaultTtl = TimeSpan.fromMinutes(5), defaultBlockingInterval = TimeSpan.fromSeconds(1), defaultBlockingTime = TimeSpan.fromMinutes(1), defaultRefreshTime = TimeSpan.fromMinutes(5), createOwnerId = () => v4(), serde, keyPrefixer, adapter, eventBus: groupableEventBus = new EventBus({
+            keyPrefixer: new KeyPrefixer("events"),
+            adapter: new MemoryEventBusAdapter(),
+        }), retryAttempts = null, backoffPolicy = null, retryPolicy = null, retryTimeout = null, totalTimeout = null, } = settings;
         this.serde = serde;
-        this.defaultTtl = defaultTtl ?? LockProvider.DEFAULT_TTL;
         this.defaultBlockingInterval = defaultBlockingInterval;
         this.defaultBlockingTime = defaultBlockingTime;
         this.defaultRefreshTime = defaultRefreshTime;
+        this.createOwnerId = createOwnerId;
+        this.keyPrefixer = keyPrefixer;
+        this.groupableEventBus = groupableEventBus;
+        this.adapterFactoryable = adapter;
+        this.defaultTtl = defaultTtl;
         this.retryAttempts = retryAttempts;
         this.backoffPolicy = backoffPolicy;
         this.retryPolicy = retryPolicy;
-        this.timeout = timeout;
-        this.eventBus = eventBus;
-        this.lockProviderEventBus = eventBus.withGroup(adapter.getGroup());
-        this.registerToSerde();
-    }
-    registerToSerde() {
-        const transformer = new LockSerdeTransformer({
-            defaultBlockingInterval: this.defaultBlockingInterval,
-            defaultBlockingTime: this.defaultBlockingTime,
-            adapter: this.adapter,
-            backoffPolicy: this.backoffPolicy,
-            defaultRefreshTime: this.defaultRefreshTime,
-            eventBus: this.eventBus,
-            retryAttempts: this.retryAttempts,
-            retryPolicy: this.retryPolicy,
-            timeout: this.timeout,
-        });
-        let serde = this.serde;
-        if (!Array.isArray(serde)) {
-            serde = [serde];
-        }
-        for (const serde_ of serde) {
-            serde_.registerCustom(transformer, CORE);
+        this.retryTimeout = retryTimeout;
+        this.totalTimeout = totalTimeout;
+        this.eventBus = this.eventBus = this.groupableEventBus.withGroup(this.keyPrefixer.resolvedRootPrefix);
+        if (this.keyPrefixer.resolvedGroup) {
+            this.eventBus = this.groupableEventBus.withGroup([
+                this.keyPrefixer.resolvedRootPrefix,
+                this.keyPrefixer.resolvedGroup,
+            ]);
         }
+        this.adapterPromise = new LazyPromise(async () => LockProvider.resolveLockAdapterFactoryable(this.adapterFactoryable, {
+            serde,
+            lockStore: this.lockStore,
+            keyPrefixer,
+            createLazyPromise: this.createLazyPromise.bind(this),
+            defaultBlockingInterval,
+            defaultBlockingTime,
+            defaultRefreshTime,
+            groupableEventBus,
+        }));
     }
     /**
-     * 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>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 listener: Invokable<LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lockProvider.addListener(KeyAcquiredLockEvent, listener);
-     * await lockProvider.removeListener(KeyAcquiredLockEvent, listener);
-     * await lockProvider.create("a").acquire();
-     * ```
+     * You can listen to the following <i>{@link LockEvents}</i> of all <i>{@link ILock}</i> instances created by the <i>{@link ILockProvider}</i>.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
      */
     addListener(event, listener) {
-        return this.lockProviderEventBus.addListener(event, listener);
+        return this.eventBus.addListener(event, listener);
     }
     /**
-     * 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>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 listener: Invokable<LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lockProvider.addListenerMany([KeyAcquiredLockEvent], listener);
-     * await lockProvider.removeListenerMany([KeyAcquiredLockEvent], listener);
-     * await lockProvider.create("a").acquire();
-     * ```
+     * You can listen to the following <i>{@link LockEvents}</i> of all <i>{@link ILock}</i> instances created by the <i>{@link ILockProvider}</i>.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
      */
     addListenerMany(events, listener) {
-        return this.lockProviderEventBus.addListenerMany(events, listener);
+        return this.eventBus.addListenerMany(events, listener);
     }
     /**
-     * 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>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 listener: Invokable<LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lockProvider.addListener(KeyAcquiredLockEvent, listener);
-     * await lockProvider.removeListener(KeyAcquiredLockEvent, listener);
-     * await lockProvider.create("a").acquire();
-     * ```
+     * You can listen to the following <i>{@link LockEvents}</i> of all <i>{@link ILock}</i> instances created by the <i>{@link ILockProvider}</i>.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
      */
     removeListener(event, listener) {
-        return this.lockProviderEventBus.removeListener(event, listener);
+        return this.eventBus.removeListener(event, listener);
     }
     /**
-     * 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>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 listener: Invokable<LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lockProvider.addListenerMany(KeyAcquiredLockEvent, listener);
-     * await lockProvider.removeListenerMany([KeyAcquiredLockEvent], listener);
-     * await lockProvider.create("a").acquire();
-     * ```
+     * You can listen to the following <i>{@link LockEvents}</i> of all <i>{@link ILock}</i> instances created by the <i>{@link ILockProvider}</i>.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
      */
     removeListenerMany(events, listener) {
-        return this.lockProviderEventBus.removeListenerMany(events, listener);
+        return this.eventBus.removeListenerMany(events, listener);
     }
     /**
-     * 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>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 listener: Invokable<LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lockProvider.listenOnce(KeyAcquiredLockEvent, listener);
-     * await lockProvider.create("a").acquire();
-     * ```
+     * You can listen to the following <i>{@link LockEvents}</i> of all <i>{@link ILock}</i> instances created by the <i>{@link ILockProvider}</i>.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
      */
     listenOnce(event, listener) {
-        return this.lockProviderEventBus.listenOnce(event, listener);
+        return this.eventBus.listenOnce(event, listener);
     }
+    /**
+     * You can listen to the following <i>{@link LockEvents}</i> of all <i>{@link ILock}</i> instances created by the <i>{@link ILockProvider}</i>.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     */
     asPromise(event) {
-        return this.lockProviderEventBus.asPromise(event);
+        return this.eventBus.asPromise(event);
     }
     /**
-     * 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>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 listener: Invokable<LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, listener);
-     * await lockProvider.create("a").acquire();
-     * await unsubscribe();
-     * ```
+     * You can listen to the following <i>{@link LockEvents}</i> of all <i>{@link ILock}</i> instances created by the <i>{@link ILockProvider}</i>.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
      */
     subscribe(event, listener) {
-        return this.lockProviderEventBus.subscribe(event, listener);
+        return this.eventBus.subscribe(event, listener);
     }
     /**
-     * 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>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 listener: Invokable<LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * const unsubscribe = await lockProvider.subscribeMany([KeyAcquiredLockEvent], listener);
-     * await lockProvider.create("a").acquire();
-     * await unsubscribe();
-     * ```
+     * You can listen to the following <i>{@link LockEvents}</i> of all <i>{@link ILock}</i> instances created by the <i>{@link ILockProvider}</i>.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
      */
     subscribeMany(events, listener) {
-        return this.lockProviderEventBus.subscribeMany(events, listener);
+        return this.eventBus.subscribeMany(events, listener);
+    }
+    createLazyPromise(asyncFn) {
+        return new LazyPromise(asyncFn, {
+            retryAttempts: this.retryAttempts,
+            backoffPolicy: this.backoffPolicy,
+            retryPolicy: this.retryPolicy,
+            retryTimeout: this.retryTimeout,
+            totalTimeout: this.totalTimeout,
+        });
     }
     /**
+     * @example
      * ```ts
-     * import type { IGroupableLockProvider } 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 { 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";
-     *
-     * 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 } 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())
      * });
      *
-     * // You can use the lock
-     * const lockA = lockProvider.create("a");
-     *
-     * // You can provide ttl
-     * const lockB = lockProvider.create("b", {
-     *   ttl: TimeSpan.fromMinutes(2),
-     * });
-     *
-     * // You can provide a custom owner. By default the owner will be unique random value.
-     * const lockC = lockProvider.create("b", {
-     *   owner: "user-1"
-     * });
+     * const lock = lockProvider.create("a");
      * ```
      */
     create(key, settings = {}) {
         const { ttl = this.defaultTtl, owner = this.createOwnerId() } = settings;
+        const keyObj = this.keyPrefixer.create(key);
+        let lockEventBus = this.groupableEventBus.withGroup([
+            this.keyPrefixer.resolvedRootPrefix,
+            keyObj.resolved,
+        ]);
+        if (this.keyPrefixer.resolvedGroup) {
+            lockEventBus = this.groupableEventBus.withGroup([
+                this.keyPrefixer.resolvedRootPrefix,
+                this.keyPrefixer.resolvedGroup,
+                keyObj.resolved,
+            ]);
+        }
         return new Lock({
+            adapterPromise: this.adapterPromise,
+            group: this.keyPrefixer.resolvedGroup,
+            createLazyPromise: this.createLazyPromise.bind(this),
+            lockState: new LockState(this.lockStore, keyObj.prefixed),
+            lockEventBus: lockEventBus,
+            lockProviderEventDispatcher: this.eventBus,
+            key: keyObj,
+            owner,
+            ttl,
+            expirationInMs: null,
             defaultBlockingInterval: this.defaultBlockingInterval,
             defaultBlockingTime: this.defaultBlockingTime,
-            lockProviderEventDispatcher: this.lockProviderEventBus,
-            lockEventBus: this.eventBus,
-            adapter: this.adapter,
             defaultRefreshTime: this.defaultRefreshTime,
-            key: resolveOneOrMoreStr(key),
-            owner: resolveOneOrMoreStr(owner),
-            ttl,
-            lazyPromiseSettings: {
-                backoffPolicy: this.backoffPolicy,
-                retryAttempts: this.retryAttempts,
-                retryPolicy: this.retryPolicy,
-                timeout: this.timeout,
-            },
-            stateRecord: this.stateRecord,
-            expirationInMs: null,
         });
     }
     /**
      * @example
      * ```ts
-     * import type { IGroupableLockProvider } 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 { 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,
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer } 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())
      * });
      *
-     * // Will print "@global"
+     * // Will log null because the lockProvider is not in a group
      * console.log(lockProvider.getGroup());
+     *
+     * const groupedLockProvider = lockProvider.withGroup("group-a");
+     *
+     * // Will log "group-a" because the groupedLockProvider is in a group
+     * console.log(groupedLockProvider.getGroup());
      * ```
      */
     getGroup() {
-        return this.adapter.getGroup();
+        return this.keyPrefixer.resolvedGroup;
     }
     /**
      * @example
      * ```ts
-     * import type { IGroupableLockProvider, ILockProvider } 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 { 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" })
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer } 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 serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * // Will print "@global"
-     * console.log(lockProvider.getGroup());
      *
-     * const groupedLockProvider: ILockProvider = lockProvider.withGroup("company-1");
-     *
-     * // Will print "@global/company-1"
-     * console.log(groupedLockProvider.getGroup());
+     * const groupedLockProvider = lockProvider.withGroup("group-a");
+     *
+     * // Will log true because they are in different groups.
+     * console.log(
+     *   await lockProvider
+     *     .create("a")
+     *     .acquire()
+     * );
+     *
+     * // Will log true because the lockProviders are in different groups.
+     * console.log(
+     *   await groupedLockProvider
+     *     .create("a")
+     *     .acquire()
+     * );
      * ```
      */
     withGroup(group) {
         return new LockProvider({
-            adapter: this.adapter.withGroup(resolveOneOrMoreStr(group)),
-            eventBus: this.eventBus,
+            adapter: this.adapterFactoryable,
+            keyPrefixer: this.keyPrefixer.withGroup(group),
+            serde: this.serde,
+            createOwnerId: this.createOwnerId,
+            eventBus: this.groupableEventBus,
             defaultTtl: this.defaultTtl,
+            defaultBlockingInterval: this.defaultBlockingInterval,
+            defaultBlockingTime: this.defaultBlockingTime,
             defaultRefreshTime: this.defaultRefreshTime,
             retryAttempts: this.retryAttempts,
             backoffPolicy: this.backoffPolicy,
             retryPolicy: this.retryPolicy,
-            timeout: this.timeout,
-            serde: this.serde,
+            retryTimeout: this.retryTimeout,
         });
     }
 }