@daiso-tech/core 0.11.0 → 0.13.0

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

@@ -0,0 +1,55 @@
+/**
+ * @module Cache
+ */
+import { type ICacheAdapter } from "../../../../cache/contracts/_module";
+import { type Kysely } from "kysely";
+import { type ISerializer } from "../../../../serializer/contracts/_module";
+import type { IDeinitizable, IInitizable } from "../../../../_shared/types";
+import { TimeSpan } from "../../../../utilities/_module";
+/**
+ * @internal
+ */
+type KyselySqliteCacheTable = {
+    key: string;
+    value: string;
+    expiresAt: number | null;
+};
+/**
+ * @internal
+ */
+type KyselySqliteTables = {
+    cache: KyselySqliteCacheTable;
+};
+/**
+ * @internal
+ */
+type KyselySqliteSettings = {
+    serializer: ISerializer<string>;
+    enableTransactions: boolean;
+    expiredKeysRemovalInterval?: TimeSpan;
+    shouldRemoveExpiredKeys?: boolean;
+};
+/**
+ * @internal
+ */
+export declare class KyselySqliteCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
+    private readonly db;
+    private readonly serializer;
+    private readonly enableTransactions;
+    private readonly expiredKeysRemovalInterval;
+    private readonly shouldRemoveExpiredKeys;
+    private timeoutId;
+    constructor(db: Kysely<KyselySqliteTables>, settings: KyselySqliteSettings);
+    private withTransaction;
+    removeExpiredKeys(): Promise<void>;
+    init(): Promise<void>;
+    deInit(): Promise<void>;
+    get(key: string): Promise<TType | null>;
+    add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
+    update(key: string, value: TType): Promise<boolean>;
+    put(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
+    remove(key: string): Promise<boolean>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}
+export {};

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

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

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

@@ -0,0 +1,35 @@
+/**
+ * @module Cache
+ */
+import type { IDeinitizable, IInitizable } from "../../../../_shared/types";
+import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
+import type { ISerializer } from "../../../../serializer/contracts/_module";
+import type { TimeSpan } from "../../../../utilities/_module";
+import type { Client } from "@libsql/client";
+/**
+ * @group Adapters
+ */
+export type LibsqlCacheAdapterSettings = {
+    tableName?: string;
+    serializer?: ISerializer<string>;
+    enableTransactions?: boolean;
+    expiredKeysRemovalInterval?: TimeSpan;
+    shouldRemoveExpiredKeys?: boolean;
+};
+/**
+ * @group Adapters
+ */
+export declare class LibsqlCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
+    private readonly cacheAdapter;
+    constructor(client: Client, settings?: LibsqlCacheAdapterSettings);
+    removeExpiredKeys(): Promise<void>;
+    deInit(): Promise<void>;
+    init(): Promise<void>;
+    get(key: string): Promise<TType | null>;
+    add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
+    update(key: string, value: TType): Promise<boolean>;
+    put(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
+    remove(key: string): Promise<boolean>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}

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

@@ -0,0 +1 @@
+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

@@ -0,0 +1,20 @@
+/**
+ * @module Cache
+ */
+import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
+import type { TimeSpan } from "../../../../utilities/_module";
+/**
+ * @group Adapters
+ */
+export declare class MemoryCacheAdapter<TType> implements ICacheAdapter<TType> {
+    private readonly map;
+    constructor(map?: Map<string, TType>);
+    private readonly timeoutIdMap;
+    get(key: string): Promise<TType | null>;
+    add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
+    update(key: string, value: TType): Promise<boolean>;
+    put(key: string, value: TType, _ttl: TimeSpan | null): Promise<boolean>;
+    remove(key: string): Promise<boolean>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}

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

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

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

@@ -0,0 +1,41 @@
+/**
+ * @module Cache
+ */
+import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
+import type { TimeSpan } from "../../../../utilities/_module";
+import type { IInitizable } from "../../../../_shared/types";
+import type { ObjectId } from "mongodb";
+import { type Collection } from "mongodb";
+import type { ISerializer } from "../../../../serializer/contracts/_module";
+/**
+ * @group Adapters
+ */
+export type MongodbCacheDocument = {
+    _id: ObjectId;
+    key: string;
+    value: number | string;
+    expiresAt: Date | null;
+};
+/**
+ * @group Adapters
+ */
+export type MongodbCacheAdapterSettings = {
+    serializer?: ISerializer<string>;
+};
+/**
+ * @group Adapters
+ */
+export declare class MongodbCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable {
+    private readonly collection;
+    private static isMongodbIncrementError;
+    private serializer;
+    constructor(collection: Collection<MongodbCacheDocument>, { serializer, }?: MongodbCacheAdapterSettings);
+    init(): Promise<void>;
+    get(key: string): Promise<TType | null>;
+    add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
+    update(key: string, value: TType): Promise<boolean>;
+    put(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
+    remove(key: string): Promise<boolean>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}

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

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

package/dist/types/{storage/implementations/adapters/redis-storage-adapter/redis-storage-adapter.d.ts → cache/implementations/adapters/redis-cache-adapter/redis-cache-adapter.d.ts}

@@ -1,10 +1,10 @@
 /**
- * @module Storage
+ * @module Cache
  */
-import { type ISerializer } from "../../../../serializer/contracts/_module";
-import { type IStorageAdapter } from "../../../../storage/contracts/_module";
-import type Redis from "ioredis";
-import { type Result } from "ioredis";
+import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
+import type { TimeSpan } from "../../../../utilities/_module";
+import { type Redis, type Result } from "ioredis";
+import type { ISerializer } from "../../../../serializer/contracts/_module";
 declare module "ioredis" {
     interface RedisCommander<Context> {
         daiso_storage_increment(key: string, number: string): Result<number, Context>;
@@ -15,21 +15,21 @@ declare module "ioredis" {
 /**
  * @group Adapters
  */
-export type RedisStorageAdapterSettings = {
+export type RedisCacheAdapterSettings = {
     serializer?: ISerializer<string>;
 };
 /**
  * @group Adapters
  */
-export declare class RedisStorageAdapter<TType> implements IStorageAdapter<TType> {
+export declare class RedisCacheAdapter<TType> implements ICacheAdapter<TType> {
     private readonly client;
+    private static isRedisTypeError;
     private serializer;
-    constructor(client: Redis, { serializer, }?: RedisStorageAdapterSettings);
+    constructor(client: Redis, { serializer, }?: RedisCacheAdapterSettings);
     get(key: string): Promise<TType | null>;
-    add(key: string, value: TType): Promise<boolean>;
+    add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
     update(key: string, value: TType): Promise<boolean>;
-    private initPutCommand;
-    put(key: string, value: TType): Promise<boolean>;
+    put(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
     remove(key: string): Promise<boolean>;
     private initIncrementCommand;
     increment(key: string, value: number): Promise<boolean>;

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

@@ -0,0 +1 @@
+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

@@ -0,0 +1,35 @@
+/**
+ * @module Cache
+ */
+import type { IDeinitizable, IInitizable } from "../../../../_shared/types";
+import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
+import type { ISerializer } from "../../../../serializer/contracts/_module";
+import type { TimeSpan } from "../../../../utilities/_module";
+import { type Database } from "better-sqlite3";
+/**
+ * @group Adapters
+ */
+export type SqliteStorageAdapterSettings = {
+    tableName?: string;
+    serializer?: ISerializer<string>;
+    enableTransactions?: boolean;
+    expiredKeysRemovalInterval?: TimeSpan;
+    shouldRemoveExpiredKeys?: boolean;
+};
+/**
+ * @group Adapters
+ */
+export declare class SqliteCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
+    private readonly cacheAdapter;
+    constructor(database: Database, settings: SqliteStorageAdapterSettings);
+    removeExpiredKeys(): Promise<void>;
+    deInit(): Promise<void>;
+    init(): Promise<void>;
+    get(key: string): Promise<TType | null>;
+    add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
+    update(key: string, value: TType): Promise<boolean>;
+    put(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
+    remove(key: string): Promise<boolean>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}

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

@@ -0,0 +1,3 @@
+export * from "../../../cache/implementations/derivables/base-cache";
+export * from "../../../cache/implementations/derivables/cache";
+export * from "../../../cache/implementations/derivables/cache-factory";

package/dist/types/cache/implementations/derivables/base-cache.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @module Cache
+ */
+import type { CacheEventNames, WithTtlValue } from "../../../cache/contracts/_module";
+import { type ICache } from "../../../cache/contracts/_module";
+import { type INamespacedCache, type AllCacheEvents } from "../../../cache/contracts/_module";
+import type { OneOrMore } from "../../../_shared/types";
+import { type AsyncLazyable, type GetOrAddValue } from "../../../_shared/types";
+import type { TimeSpan } from "../../../utilities/_module";
+import { LazyPromise } from "../../../utilities/_module";
+import type { Listener, SelectEvent, Unsubscribe, INamespacedEventBus } from "../../../event-bus/contracts/_module";
+/**
+ * @group Derivables
+ */
+export type BaseCacheSettings<TType> = {
+    namespace: string;
+    eventBus: INamespacedEventBus<AllCacheEvents<TType>>;
+};
+/**
+ * The BaseCache class serves as an abstract base class that provides implementations for redundant methods.
+ * It simplifies implementing the {@link INamespacedCache} interface without using an {@link ICacheAdapter}.
+ * @group Derivables
+ */
+export declare abstract class BaseCache<TType = unknown> implements INamespacedCache<TType> {
+    private readonly listenable;
+    constructor(settings: BaseCacheSettings<TType>);
+    addListener<TEventType extends CacheEventNames>(event: TEventType, listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<void>;
+    addListenerMany<TEventType extends CacheEventNames>(events: TEventType[], listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<void>;
+    removeListener<TEventType extends CacheEventNames>(event: TEventType, listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<void>;
+    removeListenerMany<TEventType extends CacheEventNames>(events: TEventType[], listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<void>;
+    subscribe<TEventType extends CacheEventNames>(event: TEventType, listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventType extends CacheEventNames>(events: TEventType[], listener: Listener<SelectEvent<AllCacheEvents<TType>, TEventType>>): LazyPromise<Unsubscribe>;
+    abstract withNamespace(namespace: OneOrMore<string>): ICache<TType>;
+    abstract getNamespace(): string;
+    exists(key: string): LazyPromise<boolean>;
+    existsMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
+    missing(key: string): LazyPromise<boolean>;
+    missingMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
+    abstract get(key: string): LazyPromise<TType | null>;
+    getMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, TType | null>>;
+    getOr(key: string, defaultValue: AsyncLazyable<TType>): LazyPromise<TType>;
+    getOrMany<TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TType>>): LazyPromise<Record<TKeys, TType>>;
+    getOrFail(key: string): LazyPromise<TType>;
+    abstract add(key: string, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
+    addMany<TKeys extends string>(values: Record<TKeys, WithTtlValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
+    abstract update(key: string, value: TType): LazyPromise<boolean>;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): LazyPromise<Record<TKeys, boolean>>;
+    abstract put(key: string, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
+    putMany<TKeys extends string>(values: Record<TKeys, WithTtlValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
+    abstract remove(key: string): LazyPromise<boolean>;
+    removeMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
+    getAndRemove(key: string): LazyPromise<TType | null>;
+    getOrAdd(key: string, valueToAdd: AsyncLazyable<GetOrAddValue<TType>>, ttl?: TimeSpan): LazyPromise<TType>;
+    abstract increment(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
+    decrement(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
+    abstract clear(): LazyPromise<void>;
+}

package/dist/types/cache/implementations/derivables/cache-factory.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @module Cache
+ */
+import type { INamespacedEventBus } from "../../../event-bus/contracts/_module";
+import type { ICacheFactory, INamespacedCache, ICacheAdapter } from "../../../cache/contracts/_module";
+import type { TimeSpan } from "../../../utilities/_module";
+/**
+ * @group Derivables
+ */
+export type CacheDrivers<TDrivers extends string> = Partial<Record<TDrivers, ICacheAdapter<any>>>;
+/**
+ * @group Derivables
+ */
+export type CacheFactorySettings<TDrivers extends string = string> = {
+    drivers: CacheDrivers<TDrivers>;
+    defaultDriver?: NoInfer<TDrivers>;
+    /**
+     * You can decide the default ttl value. If null is passed then no ttl will be used by default.
+     */
+    defaultTtl?: TimeSpan;
+    /**
+     * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link INamespacedEventBus}</i>.
+     */
+    eventBus?: INamespacedEventBus<any>;
+    /**
+     * You can prefix all keys with a given <i>rootNamespace</i>.
+     */
+    rootNamespace?: string;
+};
+/**
+ * @group Derivables
+ * @example
+ * ```ts
+ * import { CacheFactory } from "@daiso-tech/core";
+ * import Redis from "ioredis"
+ *
+ * const cacheFactory = new CacheFactory({
+ *   drivers: {
+ *     memory: new MemoryCacheAdapter(),
+ *     redis: new RedisCacheAdapter(new Redis()),
+ *   },
+ *   defaultDriver: "memory",
+ *   rootNamespace: "@events"
+ * });
+ * ```
+ */
+export declare class CacheFactory<TDrivers extends string = string, TType = unknown> implements ICacheFactory<TDrivers, TType> {
+    private readonly rootNamespace?;
+    private readonly drivers;
+    private readonly defaultDriver?;
+    private readonly eventBus?;
+    private defaultTtl;
+    constructor(settings: CacheFactorySettings<TDrivers>);
+    use(driverName?: TDrivers | undefined): INamespacedCache<TType>;
+    withType<TOutput extends TType = TType>(): ICacheFactory<TDrivers, TOutput>;
+}

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

@@ -0,0 +1,88 @@
+/**
+ * @module Cache
+ */
+import { type ICache, type ICacheAdapter } from "../../../cache/contracts/_module";
+import { type INamespacedCache, type AllCacheEvents } from "../../../cache/contracts/_module";
+import type { OneOrMore } from "../../../_shared/types";
+import type { TimeSpan } from "../../../utilities/_module";
+import { LazyPromise } from "../../../utilities/_module";
+import type { INamespacedEventBus } from "../../../event-bus/contracts/_module";
+import { BaseCache } from "../../../cache/implementations/derivables/base-cache";
+/**
+ * @group Derivables
+ */
+export type CacheSettings<TType> = {
+    /**
+     * You can prefix all keys with a given <i>rootNamespace</i>.
+     * This useful if you want to add multitenancy but still use the same database.
+     * @default {""}
+     * @example
+     * ```ts
+     * import { Cache, MemoryCacheAdapter } from "@daiso-tech/core";
+     *
+     * const memoryCacheAdapter = new MemoryCacheAdapter();
+     * const cacheA = new Cache(memoryCacheAdapter, {
+     *   rootNamespace: "@a"
+     * });
+     * const cacheB = new Cache(memoryCacheAdapter, {
+     *   rootNamespace: "@b"
+     * });
+     *
+     * (async () => {
+     *   await cacheA.add("a", 1);
+     *
+     *   // Will be "a"
+     *   console.log(await cacheA.get("a"));
+     *
+     *   // Will be "null"
+     *   console.log(await cacheB.get("a"));
+     * })();
+     * ```
+     */
+    rootNamespace?: OneOrMore<string>;
+    /**
+     * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link INamespacedEventBus}</i>.
+     */
+    eventBus?: INamespacedEventBus<AllCacheEvents<TType>>;
+    /**
+     * You can decide the default ttl value. If null is passed then no ttl will be used by default.
+     */
+    defaultTtl?: TimeSpan | null;
+};
+/**
+ * <i>Cache</i> class can be derived from any <i>{@link ICacheAdapter}</i>.
+ * @group Derivables
+ * @example
+ * ```ts
+ * import { Cache, MemoryCacheAdapter } from "@daiso-tech/core";
+ *
+ * const cache = new Cache(new MemoryCacheAdapter());
+ * ```
+ */
+export declare class Cache<TType = unknown> extends BaseCache<TType> implements INamespacedCache<TType> {
+    private readonly namespace;
+    private readonly namespacedEventBus;
+    private readonly eventBus;
+    private readonly cacheAdapter;
+    private readonly eventAttributes;
+    private readonly defaultTtl;
+    constructor(cacheAdapter: ICacheAdapter<any>, settings?: CacheSettings<TType>);
+    private createKeyFoundEvent;
+    private createKeyNotFoundEvent;
+    private createKeyAddedEvent;
+    private createKeyUpdatedEvent;
+    private createKeyRemovedEvent;
+    private createKeysClearedEvent;
+    private createKeyIncrementedEvent;
+    private createKeyDecrementedEvent;
+    private keyWithNamespace;
+    withNamespace(namespace: OneOrMore<string>): ICache<TType>;
+    getNamespace(): string;
+    get(key: string): LazyPromise<TType | null>;
+    add(key: string, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
+    update(key: string, value: TType): LazyPromise<boolean>;
+    put(key: string, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
+    remove(key: string): LazyPromise<boolean>;
+    increment(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
+    clear(): LazyPromise<void>;
+}

package/dist/types/collection/contracts/_module.d.ts

@@ -1,3 +1,4 @@
 export * from "../../collection/contracts/_shared";
 export * from "../../collection/contracts/collection.contract";
+export * from "../../collection/contracts/collection.errors";
 export * from "../../collection/contracts/async-collection.contract";

package/dist/types/collection/contracts/_shared.d.ts

@@ -1,42 +1,6 @@
 /**
  * @module Collection
  */
-/**
- * @group Errors
- */
-export declare class CollectionError extends Error {
-    constructor(message: string, cause?: unknown);
-}
-/**
- * @group Errors
- */
-export declare class UnexpectedCollectionError extends CollectionError {
-    constructor(message: string, cause?: unknown);
-}
-/**
- * @group Errors
- */
-export declare class ItemNotFoundCollectionError extends CollectionError {
-    constructor(message: string, cause?: unknown);
-}
-/**
- * @group Errors
- */
-export declare class MultipleItemsFoundCollectionError extends CollectionError {
-    constructor(message: string, cause?: unknown);
-}
-/**
- * @group Errors
- */
-export declare class TypeCollectionError extends CollectionError {
-    constructor(message: string, cause?: unknown);
-}
-/**
- * @group Errors
- */
-export declare class EmptyCollectionError extends CollectionError {
-    constructor(message: string, cause?: unknown);
-}
 export type Comparator<TItem> = (itemA: TItem, itemB: TItem) => number;
 export type Predicate_<TInput, TCollection> = (item: TInput, index: number, collection: TCollection) => boolean;
 export type PredicateGuard<TInput, TCollection, TOutput extends TInput = TInput> = (item: TInput, index: number, collection: TCollection) => item is TOutput;
@@ -65,3 +29,5 @@ export type CrossJoinResult<TInput, TExtended> = TInput extends [
     infer R,
     ...infer L
 ] ? [R, ...L, TExtended] : [TInput, TExtended];
+export type EnsureRecord<TInput> = TInput extends [infer TKey, infer TValue] | readonly [infer TKey, infer TValue] ? TKey extends string | number | symbol ? Record<TKey, TValue> : never : never;
+export type EnsureMap<TInput> = TInput extends [infer TKey, infer TValue] | readonly [infer TKey, infer TValue] ? globalThis.Map<TKey, TValue> : never;