@daiso-tech/core 0.21.0 → 0.22.0

package/dist/types/lock/contracts/lock.contract.d.ts

@@ -0,0 +1,219 @@
+/**
+ * @module Lock
+ */
+import type { LazyPromiseable, Result, TimeSpan } from "../../utilities/_module";
+import type { LazyPromise } from "../../async/_module";
+import type { KeyAlreadyAcquiredLockError } from "../../lock/contracts/lock.errors";
+import type { IEventListener } from "../../event-bus/contracts/_module";
+import type { LockEvents } from "../../lock/contracts/lock.events";
+/**
+ * The <i>ILockListener</i> contract defines a way for listening <i>{@link ILock}</i> operations.
+ * @group Contracts
+ */
+export type ILockListener = IEventListener<LockEvents>;
+/**
+ * @group Contracts
+ */
+export type ILock = ILockListener & {
+    /**
+     * @throws {UnableToAquireLockError} {@link UnableToAquireLockError}
+     * @throws {UnableToReleaseLockError} {@link UnableToReleaseLockError}
+     * @example
+     * ```ts
+     * import { type ILock, TimeSpan } from "@daiso-tech/core";
+     *
+     * // The function will execute sequentially when called concurrently as long you use the same lock.
+     * async function main(lock: ILock): Promise<void> {
+     *   await lock.run(async () => {
+     *     console.log("1.");
+     *     await delay(TimeSpan.fromMilliseconds(1));
+     *     console.log("2.");
+     *   });
+     * }
+     * ```
+     * You can also pass in a <i>{@link LazyPromise}</i>.
+     * @example
+     * ```ts
+     * import { type ILock, TimeSpan } from "@daiso-tech/core";
+     *
+     * function fn(): LazyPromise<void> {
+     *   return new LazyPromise(async () => {
+     *     console.log("1.");
+     *     await delay(TimeSpan.fromMilliseconds(1));
+     *     console.log("2.");
+     *   });
+     * }
+     *
+     * // The function will execute sequentially when called concurrently as long you use the same lock.
+     * async function main(lock: ILock): Promise<void> {
+     *   await lock.run(fn());
+     * }
+     * ```
+     */
+    run<TValue = void>(asyncFn: LazyPromiseable<TValue>): LazyPromise<Result<TValue, KeyAlreadyAcquiredLockError>>;
+    /**
+     * @throws {UnableToAquireLockError} {@link UnableToAquireLockError}
+     * @throws {UnableToReleaseLockError} {@link UnableToReleaseLockError}
+     * @throws {KeyAlreadyAcquiredLockError} {@link KeyAlreadyAcquiredLockError}
+     * @example
+     * ```ts
+     * import { type ILock, TimeSpan } from "@daiso-tech/core";
+     *
+     * // The function will execute sequentially when called concurrently as long you use the same lock.
+     * async function main(lock: ILock): Promise<void> {
+     *   await lock.runOrFail(async () => {
+     *     console.log("1.");
+     *     await delay(TimeSpan.fromMilliseconds(1));
+     *     console.log("2.");
+     *   });
+     * }
+     * ```
+     * You can also pass in a <i>{@link LazyPromise}</i>.
+     * @example
+     * ```ts
+     * import { type ILock, TimeSpan } from "@daiso-tech/core";
+     *
+     * function fn(): LazyPromise<void> {
+     *   return new LazyPromise(async () => {
+     *     console.log("1.");
+     *     await delay(TimeSpan.fromMilliseconds(1));
+     *     console.log("2.");
+     *   });
+     * }
+     *
+     * // The function will execute sequentially when called concurrently as long you use the same lock.
+     * async function main(lock: ILock): Promise<void> {
+     *   await lock.runOrFail(fn());
+     * }
+     * ```
+     */
+    runOrFail<TValue = void>(asyncFn: LazyPromiseable<TValue>): LazyPromise<TValue>;
+    /**
+     * The <i>acquire</i> method acquires a lock only if the lock is not already acquired.
+     * Throws an error if a different owner attempts to release the lock.
+     * Returns true if the lock is acquired otherwise true is returned.
+     * @throws {UnableToAquireLockError} {@link UnableToAquireLockError}
+     * @example
+     * ```ts
+     * import { type ILock, TimeSpan } from "@daiso-tech/core";
+     *
+     * // The function will execute sequentially when called concurrently as long you use the same lock.
+     * async function main(lock: ILock): Promise<void> {
+     *   try {
+     *     await lock.acquire();
+     *     console.log("1.");
+     *     await delay(TimeSpan.fromMilliseconds(1));
+     *     console.log("2.");
+     *   }
+     *   finally {
+     *     await lock.release();
+     *   }
+     * }
+     * ```
+     */
+    acquire(): LazyPromise<boolean>;
+    /**
+     * The <i>acquireOrFail</i> method acquires a lock only if the lock is not already acquired.
+     * Throws an error if already acquired.
+     * @throws {UnableToAquireLockError} {@link UnableToAquireLockError}
+     * @throws {KeyAlreadyAcquiredLockError} {@link KeyAlreadyAcquiredLockError}
+     * @example
+     * ```ts
+     * import type { ILock, TimeSpan } from "@daiso-tech/core";
+     *
+     * // The function will execute sequentially when called concurrently as long you use the same lock.
+     * async function main(lock: ILock): Promise<void> {
+     *   try {
+     *     await lock.acquireOrFail();
+     *     console.log("1.");
+     *     await delay(TimeSpan.fromMilliseconds(1));
+     *     console.log("2.");
+     *   }
+     *   finally {
+     *     await lock.releaseOrFail();
+     *   }
+     * }
+     * ```
+     */
+    acquireOrFail(): LazyPromise<void>;
+    /**
+     * The <i>release</i> method releases a lock if owned by the same owner.
+     * Returns true if the lock is released otherwise false is returned.
+     * @throws {UnableToReleaseLockError} {@link UnableToReleaseLockError}
+     * @example
+     * ```ts
+     * import type { ILock, TimeSpan } from "@daiso-tech/core";
+     *
+     * // The function will execute sequentially when called concurrently as long you use the same lock.
+     * async function main(lock: ILock): Promise<void> {
+     *   try {
+     *     await lock.acquire();
+     *     console.log("1.");
+     *     await delay(TimeSpan.fromMilliseconds(1));
+     *     console.log("2.");
+     *   }
+     *   finally {
+     *     await lock.release();
+     *   }
+     * }
+     * ```
+     */
+    release(): LazyPromise<boolean>;
+    /**
+     * The <i>releaseOrFail</i> method releases a lock if owned by the same owner.
+     * Throws an error if a different owner attempts to release the lock.
+     * @throws {UnableToReleaseLockError} {@link UnableToReleaseLockError}
+     * @throws {UnownedReleaseLockError} {@link UnownedReleaseLockError}
+     * @example
+     * ```ts
+     * import type { ILock, TimeSpan } from "@daiso-tech/core";
+     *
+     * // The function will execute sequentially when called concurrently as long you use the same lock.
+     * async function main(lock: ILock): Promise<void> {
+     *   try {
+     *     await lock.acquireOrFail();
+     *     console.log("1.");
+     *     await delay(TimeSpan.fromMilliseconds(1));
+     *     console.log("2.");
+     *   }
+     *   finally {
+     *     await lock.releaseOrFail();
+     *   }
+     * }
+     * ```
+     */
+    releaseOrFail(): LazyPromise<void>;
+    /**
+     * The <i>forceRelease</i> method releases a lock regardless of the owner.
+     * @throws {UnableToReleaseLockError} {@link UnableToReleaseLockError}
+     */
+    forceRelease(): LazyPromise<void>;
+    /**
+     * The <i>isExpired</i> method returns true if the expired otherwise false is returned.
+     */
+    isExpired(): LazyPromise<boolean>;
+    /**
+     * The <i>isLocked</i> method returns true if the locked otherwise false is returned.
+     */
+    isLocked(): LazyPromise<boolean>;
+    /**
+     * The <i>refresh</i> method updates the TTL of the lock if owned by the same owner.
+     * Returns true if the lock is refreshed occurs otherwise false is returned.
+     */
+    refresh(ttl?: TimeSpan): LazyPromise<boolean>;
+    /**
+     * The <i>refreshOrFail</i> method updates the TTL of the lock if owned by the same owner.
+     * Throws an error if a different owner attempts to refresh the lock.
+     * @throws {UnownedExtendLockError} {@link UnownedExtendLockError}
+     */
+    refreshOrFail(ttl?: TimeSpan): LazyPromise<void>;
+    /**
+     * The <i>getRemainingTime</i> return the reaming time as <i>{@link TimeSpan}</i>.
+     * Returns null if the key doesnt exist, key has no expiration and key has expired.
+     */
+    getRemainingTime(): LazyPromise<TimeSpan | null>;
+    /**
+     * The <i>getOwner</i> method return the current owner.
+     */
+    getOwner(): LazyPromise<string>;
+};

package/dist/types/lock/contracts/lock.errors.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @module Lock
+ */
+import type { ISerializedError, OneOrMore } from "../../utilities/_module";
+import type { IFlexibleSerde, ISerializable } from "../../serde/contracts/_module";
+/**
+ * @group Errors
+ */
+export declare class LockError extends Error implements ISerializable<ISerializedError> {
+    static deserialize(serializedError: ISerializedError): LockError;
+    constructor(message: string, cause?: unknown);
+    serialize(): ISerializedError;
+}
+/**
+ * @group Errors
+ */
+export declare class UnexpectedLockError extends LockError implements ISerializable<ISerializedError> {
+    static deserialize(serializedError: ISerializedError): UnexpectedLockError;
+    constructor(message: string, cause?: unknown);
+    serialize(): ISerializedError;
+}
+/**
+ * @group Errors
+ */
+export declare class UnableToAquireLockError extends UnexpectedLockError implements ISerializable<ISerializedError> {
+    static deserialize(serializedError: ISerializedError): UnableToAquireLockError;
+    constructor(message: string, cause?: unknown);
+    serialize(): ISerializedError;
+}
+/**
+ * @group Errors
+ */
+export declare class UnableToReleaseLockError extends UnexpectedLockError implements ISerializable<ISerializedError> {
+    static deserialize(serializedError: ISerializedError): UnableToReleaseLockError;
+    constructor(message: string, cause?: unknown);
+    serialize(): ISerializedError;
+}
+/**
+ * @group Errors
+ */
+export declare class KeyAlreadyAcquiredLockError extends LockError implements ISerializable<ISerializedError> {
+    static deserialize(serializedError: ISerializedError): KeyAlreadyAcquiredLockError;
+    constructor(message: string, cause?: unknown);
+    serialize(): ISerializedError;
+}
+/**
+ * @group Errors
+ */
+export declare class UnownedReleaseLockError extends LockError implements ISerializable<ISerializedError> {
+    static deserialize(serializedError: ISerializedError): UnownedReleaseLockError;
+    constructor(message: string, cause?: unknown);
+    serialize(): ISerializedError;
+}
+/**
+ * @group Errors
+ */
+export declare class UnownedExtendLockError extends LockError implements ISerializable<ISerializedError> {
+    static deserialize(serializedError: ISerializedError): UnownedExtendLockError;
+    constructor(message: string, cause?: unknown);
+    serialize(): ISerializedError;
+}
+/**
+ * The <i>registerLockErrorsToSerde</i> function registers all <i>{@link ILock}</i> related errors with <i>IFlexibleSerde</i>, ensuring they will properly be serialized and deserialized.
+ * @group Errors
+ */
+export declare function registerLockErrorsToSerde(serde: OneOrMore<IFlexibleSerde>): void;

package/dist/types/lock/contracts/lock.events.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @module Lock
+ */
+import { BaseEvent } from "../../event-bus/contracts/_module";
+import type { IFlexibleSerde } from "../../serde/contracts/_module";
+import type { OneOrMore } from "../../utilities/types";
+import type { TimeSpan } from "../../utilities/_module";
+/**
+ * @group Events
+ */
+export declare class KeyAcquiredLockEvent extends BaseEvent<{
+    key: string;
+    owner: string;
+    ttl: TimeSpan | null;
+}> {
+}
+/**
+ * @group Events
+ */
+export declare class KeyReleasedLockEvent extends BaseEvent<{
+    key: string;
+    owner: string;
+}> {
+}
+/**
+ * @group Events
+ */
+export declare class KeyForceReleasedLockEvent extends BaseEvent<{
+    key: string;
+}> {
+}
+/**
+ * @group Events
+ */
+export declare class UnownedReleaseLockEvent extends BaseEvent<{
+    key: string;
+    owner: string;
+}> {
+}
+/**
+ * @group Events
+ */
+export declare class UnownedRefreshLockEvent extends BaseEvent<{
+    key: string;
+    owner: string;
+}> {
+}
+/**
+ * @group Events
+ */
+export declare class KeyAlreadyAcquiredLockEvent extends BaseEvent<{
+    key: string;
+    owner: string;
+}> {
+}
+/**
+ * @group Events
+ */
+export declare class KeyRefreshedLockEvent extends BaseEvent<{
+    key: string;
+    owner: string;
+    ttl: TimeSpan;
+}> {
+}
+/**
+ * @group Events
+ */
+export declare class UnexpectedErrorLockEvent extends BaseEvent<{
+    key: string;
+    owner: string;
+    ttl: TimeSpan | null;
+    error: unknown;
+}> {
+}
+/**
+ * @group Events
+ */
+export type LockEvents = KeyAcquiredLockEvent | KeyReleasedLockEvent | UnownedReleaseLockEvent | UnownedRefreshLockEvent | KeyAlreadyAcquiredLockEvent | KeyForceReleasedLockEvent | KeyRefreshedLockEvent | UnexpectedErrorLockEvent;
+/**
+ * The <i>registerLockEventsToSerde</i> function registers all <i>{@link ILock}</i> related events with <i>IFlexibleSerde</i>, ensuring they will properly be serialized and deserialized.
+ * @group Events
+ */
+export declare function registerLockEventsToSerde(serde: OneOrMore<IFlexibleSerde>): void;

package/dist/types/lock/implementations/_module.d.ts

@@ -0,0 +1,3 @@
+export * from "../../lock/implementations/_shared/_module";
+export * from "../../lock/implementations/adapters/_module";
+export * from "../../lock/implementations/derivables/_module";

package/dist/types/lock/implementations/_shared/_module.d.ts

@@ -0,0 +1,3 @@
+export * from "../../../lock/implementations/_shared/database-lock-adapter.test-suite";
+export * from "../../../lock/implementations/_shared/lock-adapter.test-suite";
+export * from "../../../lock/implementations/_shared/lock-provider.test-suite";

package/dist/types/lock/implementations/_shared/database-lock-adapter.test-suite.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module Lock
+ */
+import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
+import { type IDatabaseLockAdapter } from "../../../lock/contracts/_module";
+import { type Promisable } from "../../../utilities/_module";
+/**
+ * @group Utilities
+ */
+export type DatabaseLockAdapterTestSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    describe: SuiteAPI;
+    beforeEach: typeof beforeEach;
+    createAdapter: () => Promisable<IDatabaseLockAdapter>;
+};
+/**
+ * The <i>databaseLockAdapterTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link IDatabaseLockAdapter}</i> with <i>vitest</i>.
+ * @group Utilities
+ */
+export declare function databaseLockAdapterTestSuite(settings: DatabaseLockAdapterTestSuiteSettings): void;

package/dist/types/lock/implementations/_shared/lock-adapter.test-suite.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module Lock
+ */
+import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
+import { type ILockAdapter } from "../../../lock/contracts/_module";
+import { type Promisable } from "../../../utilities/_module";
+/**
+ * @group Utilities
+ */
+export type LockAdapterTestSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    describe: SuiteAPI;
+    beforeEach: typeof beforeEach;
+    createAdapter: () => Promisable<ILockAdapter>;
+};
+/**
+ * The <i>lockAdapterTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link ILockAdapter}</i> with <i>vitest</i>.
+ * @group Utilities
+ */
+export declare function lockAdapterTestSuite(settings: LockAdapterTestSuiteSettings): void;

package/dist/types/lock/implementations/_shared/lock-provider.test-suite.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @module Lock
+ */
+import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
+import type { IGroupableLockProvider } from "../../../lock/contracts/_module";
+import { type Promisable } from "../../../utilities/_module";
+import type { ISerde } from "../../../serde/contracts/_module";
+/**
+ * @group Utilities
+ */
+export type LockProviderTestSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    describe: SuiteAPI;
+    beforeEach: typeof beforeEach;
+    createLockProvider: () => Promisable<IGroupableLockProvider>;
+    serde?: ISerde;
+};
+/**
+ * The <i>lockProviderTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link ILock}</i> with <i>vitest</i>.
+ * @group Utilities
+ */
+export declare function lockProviderTestSuite(settings: LockProviderTestSuiteSettings): void;

package/dist/types/lock/implementations/adapters/_module.d.ts

@@ -0,0 +1,5 @@
+export * from "../../../lock/implementations/adapters/libsql-lock-adapter/_module";
+export * from "../../../lock/implementations/adapters/memory-lock-adapter/_module";
+export * from "../../../lock/implementations/adapters/mongodb-lock-adapter/_module";
+export * from "../../../lock/implementations/adapters/redis-lock-adapter/_module";
+export * from "../../../lock/implementations/adapters/sqlite-lock-adapter/_module";

package/dist/types/lock/implementations/adapters/kysely-lock-adapter/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../lock/implementations/adapters/kysely-lock-adapter/kysely-lock-adapter";

package/dist/types/lock/implementations/adapters/kysely-lock-adapter/kysely-lock-adapter.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @module Lock
+ */
+import type { IDatabaseLockAdapter, ILockData } from "../../../../lock/contracts/_module";
+import type { Kysely } from "kysely";
+import { TimeSpan } from "../../../../utilities/_module";
+/**
+ * @internal
+ */
+type KyselyLockTable = {
+    group: string;
+    key: string;
+    owner: string;
+    expiresAt: number | null;
+};
+/**
+ * @internal
+ */
+type KyselyTables = {
+    lock: KyselyLockTable;
+};
+/**
+ * @internal
+ */
+type KyselySettings = {
+    database: Kysely<KyselyTables>;
+    rootGroup: string;
+    expiredKeysRemovalInterval?: TimeSpan;
+    shouldRemoveExpiredKeys?: boolean;
+};
+/**
+ * @internal
+ */
+export declare class KyselyLockAdapter implements IDatabaseLockAdapter {
+    private readonly group;
+    private readonly database;
+    private readonly expiredKeysRemovalInterval;
+    private readonly shouldRemoveExpiredKeys;
+    private timeoutId;
+    constructor(settings: KyselySettings);
+    deInit(): Promise<void>;
+    init(): Promise<void>;
+    removeExpiredKeys(): Promise<void>;
+    insert(key: string, owner: string, expiration: Date | null): Promise<void>;
+    update(key: string, owner: string, expiration: Date | null): Promise<number>;
+    remove(key: string, owner: string | null): Promise<void>;
+    refresh(key: string, owner: string, expiration: Date): Promise<number>;
+    find(key: string): Promise<ILockData | null>;
+    getGroup(): string;
+    withGroup(group: string): IDatabaseLockAdapter;
+}
+export {};

package/dist/types/lock/implementations/adapters/libsql-lock-adapter/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../lock/implementations/adapters/libsql-lock-adapter/libsql-lock-adapter";

package/dist/types/lock/implementations/adapters/libsql-lock-adapter/libsql-lock-adapter.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @module Lock
+ */
+import type { IDatabaseLockAdapter, ILockData } from "../../../../lock/contracts/_module";
+import { TimeSpan } from "../../../../utilities/_module";
+import type { Client } from "@libsql/client/.";
+/**
+ * @group Adapters
+ */
+export type LibsqlLockAdapterSettings = {
+    database: Client;
+    tableName?: string;
+    expiredKeysRemovalInterval?: TimeSpan;
+    shouldRemoveExpiredKeys?: boolean;
+    rootGroup: string;
+};
+/**
+ * To utilize the <i>LibsqlLockAdapter</i>, you must install the <i>"@libsql/client"</i> package.
+ * @group Adapters
+ */
+export declare class LibsqlLockAdapter implements IDatabaseLockAdapter {
+    private databaseLockAdapter;
+    /***
+     * @example
+     * ```ts
+     * import { LibsqlCacheAdapter } from "@daiso-tech/core";
+     * import { createClient } from "@libsql/client";
+     *
+     * (async () => {
+     *   const database = createClient({ url: "file:local.db" });
+     *   const lockAdapter = new LibsqlCacheAdapter({
+     *     database,
+     *     rootGroup: "@global"
+     *   });
+     *   await lockAdapter.init();
+     * })();
+     * ```
+     */
+    constructor(settings: LibsqlLockAdapterSettings);
+    removeExpiredKeys(): Promise<void>;
+    /**
+     * Removes the table where the cache values are stored and removes the table indexes.
+     * Note all cache data will be removed.
+     */
+    deInit(): Promise<void>;
+    /**
+     * Creates the table where the cache values are stored and it's related indexes.
+     * Note the <i>init</i> method needs to be called before using the adapter.
+     */
+    init(): Promise<void>;
+    insert(key: string, owner: string, expiration: Date | null): Promise<void>;
+    update(key: string, owner: string, expiration: Date | null): Promise<number>;
+    remove(key: string, owner: string | null): Promise<void>;
+    refresh(key: string, owner: string, expiration: Date): Promise<number>;
+    find(key: string): Promise<ILockData | null>;
+    getGroup(): string;
+    withGroup(group: string): IDatabaseLockAdapter;
+}

package/dist/types/lock/implementations/adapters/memory-lock-adapter/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../lock/implementations/adapters/memory-lock-adapter/memory-lock-adapter";

package/dist/types/lock/implementations/adapters/memory-lock-adapter/memory-lock-adapter.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @module Lock
+ */
+import { TimeSpan } from "../../../../utilities/_module";
+import type { ILockAdapter, ILockData } from "../../../../lock/contracts/_module";
+/**
+ * @group Adapters
+ */
+export type MemoryLockAdapterSettings = {
+    rootGroup: string;
+    map?: Map<string, ILockData>;
+};
+/**
+ * @group Adapters
+ */
+export declare class MemoryLockAdapter implements ILockAdapter {
+    private readonly group;
+    private readonly timeoutMap;
+    private readonly map;
+    /**
+     *  @example
+     * ```ts
+     * import { MemoryLockAdapter } from "@daiso-tech/core";
+     *
+     * const lockAdapter = new MemoryLockAdapter({
+     *   rootGroup: "@cache"
+     * });
+     * ```
+     * You can also provide an <i>Map</i>.
+     * @example
+     * ```ts
+     * import { MemoryLockAdapter } from "@daiso-tech/core";
+     *
+     * const map = new Map<any, any>();
+     * const lockAdapter = new MemoryLockAdapter({
+     *   rootGroup: "@cache",
+     *   map
+     * });
+     * ```
+     */
+    constructor(settings: MemoryLockAdapterSettings);
+    private getPrefix;
+    private withPrefix;
+    acquire(key: string, owner: string, ttl: TimeSpan | null): Promise<boolean>;
+    release(key: string, owner: string): Promise<boolean>;
+    forceRelease(key: string): Promise<void>;
+    isLocked(key: string): Promise<boolean>;
+    getRemainingTime(key: string): Promise<TimeSpan | null>;
+    refresh(key: string, owner: string, time: TimeSpan): Promise<boolean>;
+    getGroup(): string;
+    withGroup(group: string): ILockAdapter;
+}

package/dist/types/lock/implementations/adapters/mongodb-lock-adapter/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../lock/implementations/adapters/mongodb-lock-adapter/mongodb-lock-adapter";