@daiso-tech/core 0.26.1 → 0.27.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,262 @@ 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;
-    createOwnerId;
-    adapter;
-    defaultTtl;
-    defaultBlockingInterval;
-    defaultBlockingTime;
-    defaultRefreshTime;
-    retryAttempts;
-    backoffPolicy;
-    retryPolicy;
-    timeout;
-    eventBus;
-    lockProviderEventBus;
-    stateRecord = {};
-    /**
-     * @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,
-     * });
-     * ```
-     */
-    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;
+    static resolveLockAdapter(adapter) {
         if (isDatabaseLockAdapter(adapter)) {
-            this.adapter = new DatabaseLockAdapter(adapter);
-        }
-        else {
-            this.adapter = adapter;
+            return new DatabaseLockAdapter(adapter);
         }
-        this.serde = serde;
-        this.defaultTtl = defaultTtl ?? LockProvider.DEFAULT_TTL;
-        this.defaultBlockingInterval = defaultBlockingInterval;
-        this.defaultBlockingTime = defaultBlockingTime;
-        this.defaultRefreshTime = defaultRefreshTime;
-        this.retryAttempts = retryAttempts;
-        this.backoffPolicy = backoffPolicy;
-        this.retryPolicy = retryPolicy;
-        this.timeout = timeout;
-        this.eventBus = eventBus;
-        this.lockProviderEventBus = eventBus.withGroup(adapter.getGroup());
-        this.registerToSerde();
+        return adapter;
     }
-    registerToSerde() {
+    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({
-            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,
+            keyPrefixer,
+            adapter: resolvedAdapter,
+            createLazyPromise,
+            lockStore,
+            defaultBlockingInterval,
+            defaultBlockingTime,
+            defaultRefreshTime,
+            groupableEventBus,
         });
-        let serde = this.serde;
-        if (!Array.isArray(serde)) {
-            serde = [serde];
-        }
-        for (const serde_ of serde) {
-            serde_.registerCustom(transformer, CORE);
+        for (const serde_ of resolveOneOrMore(serde)) {
+            serde_.registerCustom(transformer);
         }
+        return resolvedAdapter;
     }
+    lockStore = {};
+    groupableEventBus;
+    eventBus;
+    adapterFactoryable;
+    adapterPromise;
+    retryAttempts;
+    backoffPolicy;
+    retryPolicy;
+    timeout;
+    keyPrefixer;
+    createOwnerId;
+    defaultTtl;
+    defaultBlockingInterval;
+    defaultBlockingTime;
+    defaultRefreshTime;
+    serde;
     /**
-     * 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";
+     * import { SqliteLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { KeyPrefixer } 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,
+     * const database = new Sqlite("local.db");
+     * const lockAdapter = new SqliteLockAdapter({
+     *   database,
      * });
+     * // You need initialize the adapter once before using it.
+     * await lockAdapter.init();
      *
-     * const listener: Invokable<LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lockProvider.addListener(KeyAcquiredLockEvent, listener);
-     * await lockProvider.removeListener(KeyAcquiredLockEvent, listener);
-     * await lockProvider.create("a").acquire();
+     * const lockProvider = new LockProvider({
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   adapter: lockAdapter,
+     * });
      * ```
-     */
-    addListener(event, listener) {
-        return this.lockProviderEventBus.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.
+     * You can pass factory function that will create an adapter for every group.
      * @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 { SqliteLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { KeyPrefixer } 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,
+     * const database = new Sqlite("local.db");
+     * const lockAdapter = new SqliteLockAdapter({
+     *   database,
      * });
+     * // You need initialize the adapter once before using it.
+     * await lockAdapter.init();
      *
-     * const listener: Invokable<LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lockProvider.addListenerMany([KeyAcquiredLockEvent], listener);
-     * await lockProvider.removeListenerMany([KeyAcquiredLockEvent], listener);
-     * await lockProvider.create("a").acquire();
+     * const lockProvider = new LockProvider({
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   adapter: lockAdapter,
+     * });
      * ```
-     */
-    addListenerMany(events, listener) {
-        return this.lockProviderEventBus.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.
+     * You can also pass factory object that implements <i>{@link IFactoryObject}</i> contract. This useful for depedency injection libraries.
      * @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);
+     * 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 Promiseable } from "@daiso-tech/core/utilities";
+     *
+     * async function lockAdapterFactory(prefix: string): Promiseable<ILockAdapter> {
+     *   const database = new Sqlite("local.db");
+     *   const database = new Sqlite("local.db");
+     *   const lockAdapter = new SqliteLockAdapter({
+     *     database,
+     *     tableName: `lock_${prefix}`,
+     *   });
+     *   // You need initialize the adapter once before using it.
+     *   await lockAdapter.init();
+     *   return lockAdapter;
      * }
-     * await lockProvider.addListener(KeyAcquiredLockEvent, listener);
-     * await lockProvider.removeListener(KeyAcquiredLockEvent, listener);
-     * await lockProvider.create("a").acquire();
-     * ```
-     */
-    removeListener(event, listener) {
-        return this.lockProviderEventBus.removeListener(event, listener);
-    }
-    /**
-     * You 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 lockProvider = new LockProvider({
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   adapter: lockAdapterFactory,
      * });
-     *
-     * const listener: Invokable<LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lockProvider.addListenerMany(KeyAcquiredLockEvent, listener);
-     * await lockProvider.removeListenerMany([KeyAcquiredLockEvent], listener);
-     * await lockProvider.create("a").acquire();
      * ```
-     */
-    removeListenerMany(events, listener) {
-        return this.lockProviderEventBus.removeListenerMany(events, listener);
-    }
-    /**
-     * You 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.
+     * You can pass factory function that will create an adapter for every group.
      * @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 { 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 IFactoryObject, type Promiseable } from "@daiso-tech/core/utilities";
+     *
+     * class LockAdapterFactory implementations IFactoryObject<string, ILockAdapter> {
+     *   async use(prefix: string): Promiseable<ILockAdapter> {
+     *     const database = new Sqlite("local.db");
+     *     const database = new Sqlite("local.db");
+     *     const lockAdapter = new SqliteLockAdapter({
+     *       database,
+     *       tableName: `lock_${prefix}`,
+     *     });
+     *     // You need initialize the adapter once before using it.
+     *     await lockAdapter.init();
+     *     return lockAdapter;
+     *   }
+     * }
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * const lockProvider = new LockProvider({
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   adapter: new LockAdapterFactory(),
      * });
-     * 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();
      * ```
      */
+    constructor(settings) {
+        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, timeout = null, } = settings;
+        this.serde = serde;
+        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 = 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,
+        }));
+    }
+    addListener(event, listener) {
+        return this.eventBus.addListener(event, listener);
+    }
+    addListenerMany(events, listener) {
+        return this.eventBus.addListenerMany(events, listener);
+    }
+    removeListener(event, listener) {
+        return this.eventBus.removeListener(event, listener);
+    }
+    removeListenerMany(events, listener) {
+        return this.eventBus.removeListenerMany(events, listener);
+    }
     listenOnce(event, listener) {
-        return this.lockProviderEventBus.listenOnce(event, listener);
+        return this.eventBus.listenOnce(event, listener);
     }
     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();
-     * ```
-     */
     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();
-     * ```
-     */
     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,
+            timeout: this.timeout,
+        });
     }
-    /**
-     * ```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,
-     * });
-     *
-     * // 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"
-     * });
-     * ```
-     */
     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,
-     * });
-     *
-     * // Will print "@global"
-     * console.log(lockProvider.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" })
-     * });
-     * 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());
-     * ```
-     */
     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,
         });
     }
 }