@daiso-tech/core 0.22.2 → 0.24.0

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

@@ -0,0 +1,50 @@
+/**
+ * @module Lock
+ */
+import { UnexpectedCacheError } from "../../../../cache/contracts/_module-exports.js";
+/**
+ * @internal
+ */
+export class DatabaseLockAdapter {
+    adapter;
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    async acquire(key, owner, ttl) {
+        const expiration = ttl?.toEndDate() ?? null;
+        try {
+            await this.adapter.insert(key, owner, expiration);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof UnexpectedCacheError) {
+                throw error;
+            }
+            const result = await this.adapter.update(key, owner, expiration);
+            return result > 0;
+        }
+    }
+    async release(key, owner) {
+        const lock = await this.adapter.find(key);
+        if (lock === null) {
+            return true;
+        }
+        await this.adapter.remove(key, owner);
+        const isOwner = lock.owner === owner;
+        return isOwner;
+    }
+    async forceRelease(key) {
+        await this.adapter.remove(key, null);
+    }
+    async refresh(key, owner, ttl) {
+        const result = await this.adapter.refresh(key, owner, ttl.toEndDate());
+        return result > 0;
+    }
+    getGroup() {
+        return this.adapter.getGroup();
+    }
+    withGroup(group) {
+        return new DatabaseLockAdapter(this.adapter.withGroup(group));
+    }
+}
+//# sourceMappingURL=database-lock-adapter.js.map

package/dist/lock/implementations/derivables/lock-provider/database-lock-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-lock-adapter.js","sourceRoot":"","sources":["../../../../../src/lock/implementations/derivables/lock-provider/database-lock-adapter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAM5E;;GAEG;AACH,MAAM,OAAO,mBAAmB;IACC;IAA7B,YAA6B,OAA6B;QAA7B,YAAO,GAAP,OAAO,CAAsB;IAAG,CAAC;IAE9D,KAAK,CAAC,OAAO,CACT,GAAW,EACX,KAAa,EACb,GAAoB;QAEpB,MAAM,UAAU,GAAG,GAAG,EAAE,SAAS,EAAE,IAAI,IAAI,CAAC;QAE5C,IAAI,CAAC;YACD,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;YAClD,OAAO,IAAI,CAAC;QAChB,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACtB,IAAI,KAAK,YAAY,oBAAoB,EAAE,CAAC;gBACxC,MAAM,KAAK,CAAC;YAChB,CAAC;YACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;YACjE,OAAO,MAAM,GAAG,CAAC,CAAC;QACtB,CAAC;IACL,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,GAAW,EAAE,KAAa;QACpC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC1C,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAChB,OAAO,IAAI,CAAC;QAChB,CAAC;QACD,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACtC,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,KAAK,KAAK,CAAC;QACrC,OAAO,OAAO,CAAC;IACnB,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,GAAW;QAC1B,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IACzC,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,GAAW,EAAE,KAAa,EAAE,GAAa;QACnD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC;QACvE,OAAO,MAAM,GAAG,CAAC,CAAC;IACtB,CAAC;IAED,QAAQ;QACJ,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;IACnC,CAAC;IAED,SAAS,CAAC,KAAa;QACnB,OAAO,IAAI,mBAAmB,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;IAClE,CAAC;CACJ"}

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

@@ -0,0 +1,455 @@
+/**
+ * @module Lock
+ */
+import { TimeSpan, type OneOrMore } from "../../../../utilities/_module-exports.js";
+import type { IDatabaseLockAdapter, LockEvents } from "../../../../lock/contracts/_module-exports.js";
+import { type ILock, type IGroupableLockProvider, type LockProviderCreateSettings, type ILockProvider, type ILockAdapter } from "../../../../lock/contracts/_module-exports.js";
+import type { BackoffPolicy, LazyPromise, RetryPolicy } from "../../../../async/_module-exports.js";
+import type { EventClass, EventInstance, IGroupableEventBus, Listener, Unsubscribe } from "../../../../event-bus/contracts/_module-exports.js";
+import type { IFlexibleSerde } from "../../../../serde/contracts/_module-exports.js";
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/lock/implementations/derivables"```
+ * @group Derivables
+ */
+export type LockProviderSettings = {
+    /**
+     * You can pass your owner id generator function.
+     */
+    createOwnerId?: () => string;
+    adapter: ILockAdapter | IDatabaseLockAdapter;
+    serde: OneOrMore<IFlexibleSerde>;
+    /**
+     * In order to listen to events of <i>{@link LockProvider}</i> class you must pass in <i>{@link IGroupableEventBus}</i>.
+     */
+    eventBus?: IGroupableEventBus<any>;
+    /**
+     * You can decide the default ttl value for <i>{@link ILock}</i> expiration. If null is passed then no ttl will be used by default.
+     * @default TimeSpan.fromMinutes(5);
+     */
+    defaultTtl?: TimeSpan | null;
+    /**
+     * The default refresh time used in the <i>{@link ILock}</i> <i>extend</i> method.
+     * @default TimeSpan.fromMinutes(5);
+     */
+    defaultRefreshTime?: TimeSpan;
+    /**
+     * The default retry attempt to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    retryAttempts?: number | null;
+    /**
+     * The default backof policy to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    backoffPolicy?: BackoffPolicy | null;
+    /**
+     * The default retry policy to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    retryPolicy?: RetryPolicy | null;
+    /**
+     * The default timeout to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    timeout?: TimeSpan | null;
+};
+/**
+ * <i>LockProvider</i> class can be derived from any <i>{@link ILockAdapter}</i> or <i>{@link IDatabaseLockAdapter}</i>.
+ *
+ * Note the <i>{@link ILock}</i> instances created by the <i>LockProvider</i> class are serializable and deserializable,
+ * 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"```
+ * @group Derivables
+ */
+export declare class LockProvider implements IGroupableLockProvider {
+    private static DEFAULT_TTL;
+    private static DEFAULT_REFRESH_TIME;
+    private static isDatabaseAdapter;
+    private readonly serde;
+    private readonly createOwnerId;
+    private readonly adapter;
+    private readonly defaultTtl;
+    private readonly defaultRefreshTime;
+    private readonly retryAttempts;
+    private readonly backoffPolicy;
+    private readonly retryPolicy;
+    private readonly timeout;
+    private readonly eventBus;
+    private readonly lockProviderEventBus;
+    private 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: LockProviderSettings);
+    private registerToSerde;
+    /**
+     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     *
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
+     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * @example
+     * ```ts
+     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
+     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
+     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import { 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: Listener<LockEvents> = event => {
+     *   console.log(event);
+     * }
+     * await lockProvider.addListener(KeyAcquiredLockEvent, listener);
+     * ```
+     */
+    addListener<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    /**
+     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     *
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
+     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * @example
+     * ```ts
+     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
+     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
+     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import { 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: Listener<LockEvents> = event => {
+     *   console.log(event);
+     * }
+     * await lockProvider.addListenerMany([KeyAcquiredLockEvent], listener);
+     * ```
+     */
+    addListenerMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    /**
+     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     *
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
+     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * @example
+     * ```ts
+     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
+     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
+     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import { 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: Listener<LockEvents> = event => {
+     *   console.log(event);
+     * }
+     * await lockProvider.removeListener(KeyAcquiredLockEvent, listener);
+     * ```
+     */
+    removeListener<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    /**
+     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     *
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
+     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * @example
+     * ```ts
+     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
+     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
+     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import { 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: Listener<LockEvents> = event => {
+     *   console.log(event);
+     * }
+     * await lockProvider.removeListenerMany([KeyAcquiredLockEvent], listener);
+     * ```
+     */
+    removeListenerMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    /**
+     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     *
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
+     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * @example
+     * ```ts
+     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
+     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
+     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import { 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: Listener<LockEvents> = event => {
+     *   console.log(event);
+     * }
+     * await lockProvider.listenOnce(KeyAcquiredLockEvent, listener);
+     * ```
+     */
+    listenOnce<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    /**
+     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     *
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
+     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * @example
+     * ```ts
+     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
+     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
+     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import { 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: Listener<LockEvents> = event => {
+     *   console.log(event);
+     * }
+     * const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, listener);
+     * await unsubscribe();
+     * ```
+     */
+    subscribe<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    /**
+     * You listen to different events of all locks created by <i>LockProvider</i> class.
+     *
+     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>Cache</i> class.
+     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * @example
+     * ```ts
+     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
+     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
+     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import { 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: Listener<LockEvents> = event => {
+     *   console.log(event);
+     * }
+     * const unsubscribe = await lockProvider.subscribeMany([KeyAcquiredLockEvent], listener);
+     * await unsubscribe();
+     * ```
+     */
+    subscribeMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    /**
+     * ```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 lockB = lockProvider.create("b", {
+     *   owner: "user-1"
+     * });
+     * ```
+     */
+    create(key: OneOrMore<string>, settings?: LockProviderCreateSettings): ILock;
+    /**
+     * @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(): string;
+    /**
+     * @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: OneOrMore<string>): ILockProvider;
+}