@daiso-tech/core 0.21.1 → 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

@@ -76,7 +76,18 @@ export declare class KeysClearedCacheEvent extends BaseEvent<{
 /**
  * @group Events
  */
-export type CacheEvents<TType = unknown> = KeyFoundCacheEvent<TType> | KeyNotFoundCacheEvent | KeyAddedCacheEvent<TType> | KeyUpdatedCacheEvent<TType> | KeyRemovedCacheEvent | KeyIncrementedCacheEvent | KeyDecrementedCacheEvent | KeysClearedCacheEvent;
+export declare class UnexpectedCacheErrorEvent extends BaseEvent<{
+    group: string;
+    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 | 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>.
@@ -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/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,10 +47,12 @@ 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>;
     get(key: string): Promise<TType | null>;

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,7 +40,7 @@ export declare class MemoryCacheAdapter<TType = unknown> implements ICacheAdapte
      * ```
      */
     constructor(settings: MemoryCacheAdapterSettings);
-    private getGroupName;
+    private getPrefix;
     private withPrefix;
     get(key: string): Promise<TType | null>;
     add(key: string, value: TType, ttl: TimeSpan | null): 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";

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

@@ -4,33 +4,23 @@
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
 import type { IDeinitizable } from "../../../../utilities/_module";
 import { type TimeSpan, type IInitizable } from "../../../../utilities/_module";
-import type { MongodbCacheAdapterSettings } from "../../../../cache/implementations/adapters/mongodb-cache-adapter/mongodb-cache-adapter-settings";
-import { MongodbCacheAdapterSettingsBuilder } from "../../../../cache/implementations/adapters/mongodb-cache-adapter/mongodb-cache-adapter-settings";
+import type { CollectionOptions, Db } from "mongodb";
+import type { ISerde } from "../../../../serde/contracts/_module";
+/**
+ * @group Adapters
+ */
+export type MongodbCacheAdapterSettings = {
+    database: Db;
+    serde: ISerde<string>;
+    rootGroup: string;
+    collectionName?: string;
+    collectionSettings?: CollectionOptions;
+};
 /**
  * To utilize the <i>MongodbCacheAdapter</i>, you must install the <i>"mongodb"</i> package and supply a <i>{@link ISerde | ISerde<string> }</i>, such as <i>{@link SuperJsonSerde}</i>.
  * @group Adapters
  */
 export declare class MongodbCacheAdapter<TType = unknown> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
-    /**
-     * @example
-     * ```ts
-     * import { MongodbCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
-     * import { MongoClient } from "mongodb";
-     *
-     * (async () => {
-     *   const client = await MongoClient.connect("YOUR_MONGODB_CONNECTION_STRING");
-     *   const cacheAdapter = new MongodbCacheAdapter(
-     *     MongodbCacheAdapter
-     *       .settings()
-     *       .setDatabase(client.db("database"))
-     *       .setSerde(new SuperJsonSerde())
-     *       .setRootGroup("@global")
-     *       .build()
-     *   );
-     * })();
-     * ```
-     */
-    static settings<TSettings extends Partial<MongodbCacheAdapterSettings>>(): MongodbCacheAdapterSettingsBuilder<TSettings>;
     private static isMongodbIncrementError;
     private readonly mongodbSerde;
     private readonly group;
@@ -38,6 +28,7 @@ export declare class MongodbCacheAdapter<TType = unknown> implements ICacheAdapt
     private readonly database;
     private readonly collection;
     private readonly collectionName;
+    private readonly collectionSettings?;
     /**
      * @example
      * ```ts
@@ -53,22 +44,21 @@ export declare class MongodbCacheAdapter<TType = unknown> implements ICacheAdapt
      *     serde,
      *     rootGroup: "@global"
      *   });
-     *
      *   await cacheAdapter.init();
-     *   await cacheAdapter.add("a", 1);
-     *   await cacheAdapter.deInit();
      * })();
      * ```
      */
-    constructor({ collectionName, collectionSettings, database, serde, rootGroup, }: MongodbCacheAdapterSettings);
+    constructor(settings: MongodbCacheAdapterSettings);
     getGroup(): string;
     withGroup(group: string): ICacheAdapter<TType>;
     /**
      * Creates all related indexes.
+     * Note the <i>init</i> method needs to be called before using the adapter.
      */
     init(): Promise<void>;
     /**
      * Removes the collection where the cache values are stored and all it's related indexes.
+     * Note all cache data will be removed.
      */
     deInit(): Promise<void>;
     get(key: string): Promise<TType | null>;

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

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

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

@@ -3,36 +3,26 @@
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
 import { type TimeSpan } from "../../../../utilities/_module";
-import { type Result } from "ioredis";
-import type { RedisCacheAdapterSettings } from "../../../../cache/implementations/adapters/redis-cache-adapter/redis-cache-adapter-settings";
-import { RedisCacheAdapterSettingsBuilder } from "../../../../cache/implementations/adapters/redis-cache-adapter/redis-cache-adapter-settings";
+import { type Redis, type Result } from "ioredis";
+import type { ISerde } from "../../../../serde/contracts/_module";
 declare module "ioredis" {
     interface RedisCommander<Context> {
         daiso_cache_increment(key: string, number: string): Result<number, Context>;
     }
 }
+/**
+ * @group Adapters
+ */
+export type RedisCacheAdapterSettings = {
+    database: Redis;
+    serde: ISerde<string>;
+    rootGroup: string;
+};
 /**
  * To utilize the <i>RedisCacheAdapter</i>, you must install the <i>"ioredis"</i> package and supply a <i>{@link ISerde | ISerde<string> }</i>, such as <i>{@link SuperJsonSerde}</i>.
  * @group Adapters
  */
 export declare class RedisCacheAdapter<TType = unknown> implements ICacheAdapter<TType> {
-    /**
-     * @example
-     * ```ts
-     * import { RedisCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
-     * import Redis from "ioredis";
-     *
-     * const cacheAdapter = new RedisCacheAdapter(
-     *   RedisCacheAdapter
-     *     .settings()
-     *     .setDatabase(new Redis("YOUR_REDIS_CONNECTION_STRING"))
-     *     .setSerde(new SuperJsonSerde())
-     *     .setRootGroup("@global")
-     *     .build()
-     * );
-     * ```
-     */
-    static settings<TSettings extends Partial<RedisCacheAdapterSettings>>(): RedisCacheAdapterSettingsBuilder<TSettings>;
     private static isRedisTypeError;
     private readonly baseSerde;
     private readonly redisSerde;
@@ -53,8 +43,8 @@ export declare class RedisCacheAdapter<TType = unknown> implements ICacheAdapter
      * });
      * ```
      */
-    constructor({ database, serde, rootGroup }: RedisCacheAdapterSettings);
-    private getGroupName;
+    constructor(settings: RedisCacheAdapterSettings);
+    private getPrefix;
     private withPrefix;
     get(key: string): Promise<TType | null>;
     add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;

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

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

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

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

package/dist/types/cache/implementations/derivables/cache/_module.d.ts

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