@daiso-tech/core 0.21.0 → 0.22.0

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

@@ -8,7 +8,7 @@ import type { CacheEvents } from "../../cache/contracts/_module";
 import type { TimeSpan } from "../../utilities/_module";
 import type { LazyPromise } from "../../async/_module";
 /**
- * The <i>ICacheListener</i> contract defines a way for listening <i>{@link ICache}</i> crud operations.
+ * The <i>ICacheListener</i> contract defines a way for listening <i>{@link ICache}</i> operations.
  * @group Contracts
  */
 export type ICacheListener<TType = unknown> = IEventListener<CacheEvents<TType>>;
@@ -124,6 +124,43 @@ export type ICache<TType = unknown> = ICacheListener & {
      *   // -1
      * }
      * ```
+     * You can pass a function as default value.
+     * @example
+     * ```ts
+     * import type { ICache } from "@daiso-tech/core";
+     *
+     * // Asume the inputed cache is empty
+     * async function main(cache: ICache): Promise<void> {
+     *   await cache.getOr("a", () => -1);
+     *   // -1
+     * }
+     * ```
+     * You can pass an async function as default value.
+     * @example
+     * ```ts
+     * import type { ICache } from "@daiso-tech/core";
+     *
+     * // Asume the inputed cache is empty
+     * async function main(cache: ICache): Promise<void> {
+     *   await cache.getOr("a", async () => -1);
+     *   // -1
+     * }
+     * ```
+     * You can pass an <i>{@link LazyPromise}</i> as default value.
+     * @example
+     * ```ts
+     * import type { ICache, IAsyncCollection } from "@daiso-tech/core";
+     *
+     * type IPerson = {
+     *   name: string;
+     *   age: number;
+     * };
+     *
+     * // Asume the inputed cache is empty
+     * async function main(cache: ICache, collection: IAsyncCollection<IPerson>): Promise<void> {
+     *   await cache.getOr("a", collection.first(person => person.name === "a"));
+     * }
+     * ```
      */
     getOr(key: string, defaultValue: AsyncLazyable<TType>): LazyPromise<TType>;
     /**
@@ -138,6 +175,43 @@ export type ICache<TType = unknown> = ICacheListener & {
      *   // { a: -1, b: -2, c: -3 }
      * }
      * ```
+     * You can pass a function as default value.
+     * @example
+     * ```ts
+     * import type { ICache } from "@daiso-tech/core";
+     *
+     * // Asume the inputed cache is empty
+     * async function main(cache: ICache): Promise<void> {
+     *   await cache.getOrMany({ a: () => -1 });
+     *   // -1
+     * }
+     * ```
+     * You can pass an async function as default value.
+     * @example
+     * ```ts
+     * import type { ICache } from "@daiso-tech/core";
+     *
+     * // Asume the inputed cache is empty
+     * async function main(cache: ICache): Promise<void> {
+     *   await cache.getOrMany({ a: async () => -1 });
+     *   // -1
+     * }
+     * ```
+     * You can pass an <i>{@link LazyPromise}</i> as default value.
+     * @example
+     * ```ts
+     * import type { ICache, IAsyncCollection } from "@daiso-tech/core";
+     *
+     * type IPerson = {
+     *   name: string;
+     *   age: number;
+     * };
+     *
+     * // Asume the inputed cache is empty
+     * async function main(cache: ICache, collection: IAsyncCollection<IPerson>): Promise<void> {
+     *   await cache.getOrMany({ a: collection.first(person => person.name === "a") });
+     * }
+     * ```
      */
     getOrMany<TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TType>>): LazyPromise<Record<TKeys, TType>>;
     /**
@@ -420,9 +494,43 @@ export type ICache<TType = unknown> = ICacheListener & {
      * async function main(cache: ICache): Promise<void> {
      *   await cache.getOrAdd("a", 1);
      *   // 1
+     * }
+     * ```
+     * You can pass a function as default value.
+     * @example
+     * ```ts
+     * import type { ICache } from "@daiso-tech/core";
      *
+     * // Asume the inputed cache is empty
+     * async function main(cache: ICache): Promise<void> {
+     *   await cache.getOrAdd("a", () => -1);
+     *   // -1
+     * }
+     * ```
+     * You can pass an async function as default value.
+     * @example
+     * ```ts
+     * import type { ICache } from "@daiso-tech/core";
+     *
+     * // Asume the inputed cache is empty
+     * async function main(cache: ICache): Promise<void> {
      *   await cache.getOrAdd("a", async () => -1);
-     *   // 1
+     *   // -1
+     * }
+     * ```
+     * You can pass an <i>{@link LazyPromise}</i> as default value.
+     * @example
+     * ```ts
+     * import type { ICache, IAsyncCollection } from "@daiso-tech/core";
+     *
+     * type IPerson = {
+     *   name: string;
+     *   age: number;
+     * };
+     *
+     * // Asume the inputed cache is empty
+     * async function main(cache: ICache, collection: IAsyncCollection<IPerson>): Promise<void> {
+     *   await cache.getOrAdd("a", collection.first(person => person.name === "a"));
      * }
      * ```
      */
@@ -485,10 +593,10 @@ export type ICache<TType = unknown> = ICacheListener & {
      * The <i>getGroup</i> method returns the group name.
      * @example
      * ```ts
-     * import type { ICache } from "@daiso-tech/core";
+     * import type { IGroupableCache } from "@daiso-tech/core";
      *
      * // Asume the inputed cache is empty and the default rootGroup is "@global"
-     * async function main(cache: ICache): Promise<void> {
+     * async function main(cache: IGroupableCache): Promise<void> {
      *   console.log(cache.getGroup())
      *
      *   const cacheA = cache.withGroup("a");
@@ -502,20 +610,20 @@ export type ICache<TType = unknown> = ICacheListener & {
 };
 /**
  * The <i>IGroupableCache</i> contract defines a way for storing data as key-value pairs independent of data storage.
- * It commes with one extra method which is useful for multitennat applications compared to <i>ICache</i>.
+ * It commes with one extra method which is useful for multitennat applications compared to <i>{@link ICache}</i>.
  * @group Contracts
  */
 export type IGroupableCache<TType = unknown> = ICache<TType> & {
     /**
      * The <i>withGroup</i> method returns a new <i>{@link ICache}</i> instance that groups keys together.
-     * Only keys in the group can be updated, removed, or retrieved, leaving keys outside the group unaffected.
+     * Only keys in the same group will be updated, removed, or retrieved, leaving keys outside the group unaffected.
      * This useful for multitennat applications.
      * @example
      * ```ts
-     * import type { ICache } from "@daiso-tech/core";
+     * import type { IGroupableCache } from "@daiso-tech/core";
      *
      * // Asume the inputed cache is empty and the default rootGroup is "@global"
-     * async function main(cache: ICache): Promise<void> {
+     * async function main(cache: IGroupableCache): Promise<void> {
      *   const cacheA = cache.withGroup("a");
      *   await cacheA.add("a", 1);
      *

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

@@ -7,153 +7,87 @@ import type { OneOrMore, TimeSpan } from "../../utilities/_module";
 /**
  * @group Events
  */
-export type KeyFoundCacheEventFields<TType> = {
+export declare class KeyFoundCacheEvent<TType = unknown> extends BaseEvent<{
     group: string;
     key: string;
     value: TType;
-};
-/**
- * @group Events
- */
-export declare class KeyFoundCacheEvent<TType = unknown> extends BaseEvent<KeyFoundCacheEventFields<TType>> {
-    group: string;
-    key: string;
-    value: TType;
-    static deserialize<TType>(serializedEvent: KeyFoundCacheEventFields<TType>): KeyFoundCacheEvent<TType>;
-    constructor(fields: KeyFoundCacheEventFields<TType>);
-    serialize(): KeyFoundCacheEventFields<TType>;
+}> {
 }
 /**
  * @group Events
  */
-export type KeyNotFoundCacheEventFields = {
-    group: string;
-    key: string;
-};
-/**
- * @group Events
- */
-export declare class KeyNotFoundCacheEvent extends BaseEvent<KeyNotFoundCacheEventFields> {
+export declare class KeyNotFoundCacheEvent extends BaseEvent<{
     group: string;
     key: string;
-    static deserialize(serializedEvent: KeyNotFoundCacheEventFields): KeyNotFoundCacheEvent;
-    constructor(fields: KeyNotFoundCacheEventFields);
-    serialize(): KeyNotFoundCacheEventFields;
+}> {
 }
 /**
  * @group Events
  */
-export type KeyAddedCacheEventFields<TType = unknown> = {
+export declare class KeyAddedCacheEvent<TType = unknown> extends BaseEvent<{
     group: string;
     key: string;
     value: TType;
     ttl: TimeSpan | null;
-};
-/**
- * @group Events
- */
-export declare class KeyAddedCacheEvent<TType = unknown> extends BaseEvent<KeyAddedCacheEventFields<TType>> {
-    group: string;
-    key: string;
-    value: TType;
-    ttl: TimeSpan | null;
-    static deserialize<TType>(serializedEvent: KeyAddedCacheEventFields<TType>): KeyAddedCacheEvent<TType>;
-    constructor(fields: KeyAddedCacheEventFields<TType>);
-    serialize(): KeyAddedCacheEventFields<TType>;
+}> {
 }
 /**
  * @group Events
  */
-export type KeyUpdatedCacheEventFields<TType = unknown> = {
-    group: string;
-    key: string;
-    value: TType;
-};
-/**
- * @group Events
- */
-export declare class KeyUpdatedCacheEvent<TType = unknown> extends BaseEvent<KeyUpdatedCacheEventFields<TType>> {
+export declare class KeyUpdatedCacheEvent<TType = unknown> extends BaseEvent<{
     group: string;
     key: string;
     value: TType;
-    static deserialize<TType>(serializedEvent: KeyUpdatedCacheEventFields<TType>): KeyUpdatedCacheEvent<TType>;
-    constructor(fields: KeyUpdatedCacheEventFields<TType>);
-    serialize(): KeyUpdatedCacheEventFields<TType>;
+}> {
 }
 /**
  * @group Events
  */
-export type KeyRemovedCacheEventFields = {
+export declare class KeyRemovedCacheEvent extends BaseEvent<{
     group: string;
     key: string;
-};
-/**
- * @group Events
- */
-export declare class KeyRemovedCacheEvent extends BaseEvent<KeyRemovedCacheEventFields> {
-    group: string;
-    key: string;
-    static deserialize(serializedEvent: KeyRemovedCacheEventFields): KeyRemovedCacheEvent;
-    constructor(fields: KeyRemovedCacheEventFields);
-    serialize(): KeyRemovedCacheEventFields;
+}> {
 }
 /**
  * @group Events
  */
-export type KeyIncrementedCacheEventFields = {
+export declare class KeyIncrementedCacheEvent extends BaseEvent<{
     group: string;
     key: string;
     value: number;
-};
-/**
- * @group Events
- */
-export declare class KeyIncrementedCacheEvent extends BaseEvent<KeyIncrementedCacheEventFields> {
-    group: string;
-    key: string;
-    value: number;
-    static deserialize(serializedEvent: KeyIncrementedCacheEventFields): KeyIncrementedCacheEvent;
-    constructor(fields: KeyIncrementedCacheEventFields);
-    serialize(): KeyIncrementedCacheEventFields;
+}> {
 }
 /**
  * @group Events
  */
-export type KeyDecrementedCacheEventFields = {
-    group: string;
-    key: string;
-    value: number;
-};
-/**
- * @group Events
- */
-export declare class KeyDecrementedCacheEvent extends BaseEvent<KeyDecrementedCacheEventFields> {
+export declare class KeyDecrementedCacheEvent extends BaseEvent<{
     group: string;
     key: string;
     value: number;
-    static deserialize(serializedEvent: KeyDecrementedCacheEventFields): KeyDecrementedCacheEvent;
-    constructor(fields: KeyDecrementedCacheEventFields);
-    serialize(): KeyDecrementedCacheEventFields;
+}> {
 }
 /**
  * @group Events
  */
-export type KeysClearedCacheEventFields = {
+export declare class KeysClearedCacheEvent extends BaseEvent<{
     group: string;
-};
+}> {
+}
 /**
  * @group Events
  */
-export declare class KeysClearedCacheEvent extends BaseEvent<KeysClearedCacheEventFields> {
+export declare class UnexpectedCacheErrorEvent extends BaseEvent<{
     group: string;
-    static deserialize(serializedEvent: KeysClearedCacheEventFields): KeysClearedCacheEvent;
-    constructor(fields: KeysClearedCacheEventFields);
-    serialize(): KeysClearedCacheEventFields;
+    key?: string;
+    value?: unknown;
+    method: string;
+    error: unknown;
+}> {
 }
 /**
  * @group Events
  */
-export type CacheEvents<TType = unknown> = KeyFoundCacheEvent<TType> | KeyNotFoundCacheEvent | KeyAddedCacheEvent<TType> | KeyUpdatedCacheEvent<TType> | KeyRemovedCacheEvent | KeyIncrementedCacheEvent | KeyDecrementedCacheEvent | KeysClearedCacheEvent;
+export type CacheEvents<TType = unknown> = KeyFoundCacheEvent<TType> | KeyNotFoundCacheEvent | KeyAddedCacheEvent<TType> | KeyUpdatedCacheEvent<TType> | KeyRemovedCacheEvent | KeyIncrementedCacheEvent | KeyDecrementedCacheEvent | KeysClearedCacheEvent | UnexpectedCacheErrorEvent;
 /**
  * The <i>registerCacheEvents</i> function registers all <i>{@link IGroupableCache}</i> related events with <i>IFlexibleSerde</i>, ensuring they will properly be serialized and deserialized.
  * @group Events

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

@@ -12,8 +12,7 @@ export type CacheAdapterTestSuiteSettings = {
     test: TestAPI;
     describe: SuiteAPI;
     beforeEach: typeof beforeEach;
-    createAdapterA: () => Promisable<ICacheAdapter>;
-    createAdapterB: () => Promisable<ICacheAdapter>;
+    createAdapter: () => Promisable<ICacheAdapter>;
 };
 /**
  * The <i>cacheAdapterTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link ICacheAdapter}</i> with <i>vitest</i>.
@@ -39,18 +38,12 @@ export type CacheAdapterTestSuiteSettings = {
  *     await startedContainer.stop();
  *   }, TIMEOUT.toMilliseconds());
  *   cacheAdapterTestSuite({
- *     createAdapterA: () =>
+ *     createAdapter: () =>
  *       new RedisCacheAdapter({
  *         database,
  *         serde,
  *         rootGroup: "@a"
  *       }),
- *     createAdapterB: () =>
- *       new RedisCacheAdapter({
- *         database,
- *         serde,
- *         rootGroup: "@b"
- *       }),
  *     test,
  *     beforeEach,
  *     expect,

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

@@ -2,7 +2,7 @@
  * @module Cache
  */
 import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
-import { type ICache } from "../../../cache/contracts/_module";
+import { type IGroupableCache } from "../../../cache/contracts/_module";
 import { type Promisable } from "../../../utilities/_module";
 /**
  * @group Utilities
@@ -12,8 +12,7 @@ export type CacheTestSuiteSettings = {
     test: TestAPI;
     describe: SuiteAPI;
     beforeEach: typeof beforeEach;
-    createCacheA: () => Promisable<ICache>;
-    createCacheB: () => Promisable<ICache>;
+    createCache: () => Promisable<IGroupableCache>;
 };
 /**
  * The <i>cacheTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link ICache}</i> with <i>vitest</i>.
@@ -23,14 +22,14 @@ export type CacheTestSuiteSettings = {
  * import Redis from "ioredis";
  * import { afterEach, beforeEach, describe, expect, test } from "vitest";
  * import { RedisContainer, type StartedRedisContainer } from "@testcontainers/redis";
- * import { SuperJsonSerde, TimeSpan, RedisCacheAdapter, cacheTestSuite, MemoryEventBusAdapter } from "@daiso-tech/core";
+ * import { SuperJsonSerde, TimeSpan, RedisCacheAdapter, cacheTestSuite, MemorycacheAdapter } from "@daiso-tech/core";
  *
  * const TIMEOUT = TimeSpan.fromMinutes(2);
  * describe("class: Cache", () => {
  *   let database: Redis;
  *   let startedContainer: StartedRedisContainer;
  *   const eventBus = new EventBus({
- *     adapter: new MemoryEventBusAdapter({
+ *     adapter: new MemorycacheAdapter({
  *       rootGroup: "@global"
  *     })
  *   }):
@@ -44,7 +43,7 @@ export type CacheTestSuiteSettings = {
  *     await startedContainer.stop();
  *   }, TIMEOUT.toMilliseconds());
  *   cacheTestSuite({
- *     createCacheA: () =>
+ *     createCache: () =>
  *       new Cache(
  *         new RedisCacheAdapter({
  *           database,
@@ -53,15 +52,6 @@ export type CacheTestSuiteSettings = {
  *         }),
  *         { eventBus }
  *       ),
- *     createCacheB: () =>
- *       new Cache(
- *         new RedisCacheAdapter({
- *           database,
- *           serde,
- *           rootGroup: "@b",
- *         }),
- *         { eventBus }
- *       ),
  *     test,
  *     beforeEach,
  *     expect,

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

@@ -50,7 +50,6 @@ export declare class KyselySqliteCacheAdapter<TType = unknown> implements ICache
     removeExpiredKeys(): Promise<void>;
     init(): Promise<void>;
     deInit(): Promise<void>;
-    exists(key: string): Promise<boolean>;
     get(key: string): Promise<TType | null>;
     add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
     update(key: string, value: TType): Promise<boolean>;

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

@@ -1,2 +1 @@
-export * from "../../../../cache/implementations/adapters/libsql-cache-adapter/libsql-cache-adapter-settings";
 export * from "../../../../cache/implementations/adapters/libsql-cache-adapter/libsql-cache-adapter";

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

@@ -3,30 +3,25 @@
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
 import type { TimeSpan, IDeinitizable, IInitizable } from "../../../../utilities/_module";
-import type { LibsqlCacheAdapterSettings } from "../../../../cache/implementations/adapters/libsql-cache-adapter/libsql-cache-adapter-settings";
-import { LibsqlCacheAdapterSettingsBuilder } from "../../../../cache/implementations/adapters/libsql-cache-adapter/libsql-cache-adapter-settings";
+import type { ISerde } from "../../../../serde/contracts/_module";
+import type { Client } from "@libsql/client";
+/**
+ * @group Adapters
+ */
+export type LibsqlCacheAdapterSettings = {
+    database: Client;
+    tableName?: string;
+    serde: ISerde<string>;
+    enableTransactions?: boolean;
+    expiredKeysRemovalInterval?: TimeSpan;
+    shouldRemoveExpiredKeys?: boolean;
+    rootGroup: string;
+};
 /**
  * To utilize the <i>LibsqlCacheAdapter</i>, you must install the <i>"@libsql/client"</i> package and supply a <i>{@link ISerde | ISerde<string> }</i>, such as <i>{@link SuperJsonSerde}</i>.
  * @group Adapters
  */
 export declare class LibsqlCacheAdapter<TType = unknown> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
-    /**
-     * @example
-     * ```ts
-     * import { LibsqlCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
-     * import { createClient } from "@libsql/client";
-     *
-     * const cacheAdapter = new LibsqlCacheAdapter(
-     *   LibsqlCacheAdapter
-     *     .settings()
-     *     .setDatabase(createClient({ url: "file:local.db" }))
-     *     .setSerde(new SuperJsonSerde())
-     *     .setRootGroup("@global")
-     *     .build()
-     * );
-     * ```
-     */
-    static settings<TSettings extends Partial<LibsqlCacheAdapterSettings>>(): LibsqlCacheAdapterSettingsBuilder<TSettings>;
     private readonly cacheAdapter;
     /***
      * @example
@@ -34,18 +29,15 @@ export declare class LibsqlCacheAdapter<TType = unknown> implements ICacheAdapte
      * import { LibsqlCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
      * import { createClient } from "@libsql/client";
      *
-     * const database = createClient({ url: "file:local.db" });
-     * const serde = new SuperJsonSerde();
-     * const cacheAdapter = new LibsqlCacheAdapter({
-     *   database,
-     *   serde,
-     *   rootGroup: "@global"
-     * });
-     *
      * (async () => {
+     *   const database = createClient({ url: "file:local.db" });
+     *   const serde = new SuperJsonSerde();
+     *   const cacheAdapter = new LibsqlCacheAdapter({
+     *     database,
+     *     serde,
+     *     rootGroup: "@global"
+     *   });
      *   await cacheAdapter.init();
-     *   await cacheAdapter.add("a", 1);
-     *   await cacheAdapter.deInit();
      * })();
      * ```
      */
@@ -55,13 +47,14 @@ export declare class LibsqlCacheAdapter<TType = unknown> implements ICacheAdapte
     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>;
-    exists(key: string): Promise<boolean>;
     get(key: string): Promise<TType | null>;
     add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
     update(key: string, value: TType): Promise<boolean>;

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

@@ -1,2 +1 @@
-export * from "../../../../cache/implementations/adapters/memory-cache-adapter/memory-cache-adapter-settings";
 export * from "../../../../cache/implementations/adapters/memory-cache-adapter/memory-cache-adapter";

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

@@ -3,28 +3,18 @@
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
 import { type TimeSpan } from "../../../../utilities/_module";
-import type { MemoryCacheAdapterSettings } from "../../../../cache/implementations/adapters/memory-cache-adapter/memory-cache-adapter-settings";
-import { MemoryCacheAdapterSettingsBuilder } from "../../../../cache/implementations/adapters/memory-cache-adapter/memory-cache-adapter-settings";
+/**
+ * @group Adapters
+ */
+export type MemoryCacheAdapterSettings = {
+    rootGroup: string;
+    map?: Map<string, unknown>;
+};
 /**
  * To utilize the <i>MemoryCacheAdapter</i>, you must create instance of it.
  * @group Adapters
  */
 export declare class MemoryCacheAdapter<TType = unknown> implements ICacheAdapter<TType> {
-    /**
-     * @example
-     * ```ts
-     * import { MemoryCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
-     *
-     * const cacheAdapter = new MemoryCacheAdapter(
-     *   MemoryCacheAdapter
-     *     .settings()
-     *     .setMap(new Map())
-     *     .setRootGroup("@global")
-     *     .build()
-     * );
-     * ```
-     */
-    static settings<TSettings extends Partial<MemoryCacheAdapterSettings>>(): MemoryCacheAdapterSettingsBuilder<TSettings>;
     private readonly group;
     private readonly timeoutMap;
     private readonly map;
@@ -50,9 +40,8 @@ export declare class MemoryCacheAdapter<TType = unknown> implements ICacheAdapte
      * ```
      */
     constructor(settings: MemoryCacheAdapterSettings);
-    private getGroupName;
+    private getPrefix;
     private withPrefix;
-    exists(key: string): Promise<boolean>;
     get(key: string): Promise<TType | null>;
     add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
     update(key: string, value: TType): Promise<boolean>;

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

@@ -1,2 +1 @@
-export * from "../../../../cache/implementations/adapters/mongodb-cache-adapter/mongodb-cache-adapter-settings";
 export * from "../../../../cache/implementations/adapters/mongodb-cache-adapter/mongodb-cache-adapter";