@daiso-tech/core 0.15.0 → 0.17.4

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

@@ -1,56 +1,70 @@
 /**
  * @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";
+import type { ICacheFactory, IGroupableCache } from "../../../cache/contracts/_module";
+import type { CacheFactorySettings } from "../../../cache/implementations/derivables/cache-factory-settings";
+import { CacheFactorySettingsBuilder } from "../../../cache/implementations/derivables/cache-factory-settings";
 /**
  * @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;
+export declare class CacheFactory<TAdapters extends string = string> implements ICacheFactory<TAdapters> {
     /**
-     * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link INamespacedEventBus}</i>.
+     * @example
+     * ```ts
+     * import { CacheFactory, SuperJsonSerde. MemoryCacheAdapter, RedisCacheAdapter, EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
+     * import Redis from "ioredis";
+     *
+     * const cacheFactory = new CacheFactory(
+     *   CacheFactory
+     *     .settings()
+     *     .setEventBus(new EventBus(new MemoryEventBusAdapter({ rootGroup: "@global" })))
+     *     .setAdapter("memory", new MemoryCacheAdapter({
+     *       rootGroup: "@global"
+     *     }))
+     *     .setAdapter("redis", new RedisCacheAdapter({
+     *       client: new Redis("YOUR_REDIS_CONNECTION"),
+     *       serde: new SuperJsonSerde(),
+     *       rootGroup: "@global"
+     *     }))
+     *     .setDefaultAdapter("memory")
+     *     .build()
+     * );
+     * ```
      */
-    eventBus?: INamespacedEventBus<any>;
+    static settings<TAdapters extends string, TSettings extends CacheFactorySettings<TAdapters>>(): CacheFactorySettingsBuilder<TSettings>;
+    private readonly adapters;
+    private readonly defaultAdapter?;
+    private readonly eventBus?;
+    private readonly defaultTtl;
+    private readonly retryAttempts?;
+    private readonly backoffPolicy?;
+    private readonly retryPolicy?;
+    private readonly timeout?;
     /**
-     * You can prefix all keys with a given <i>rootNamespace</i>.
+     * @example
+     * ```ts
+     * import { CacheFactory, MemoryCacheAdapter, RedisCacheAdapter, EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
+     * import Redis from "ioredis"
+     *
+     * const eventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cacheFactory = new CacheFactory({
+     *   adapters: {
+     *     memory: new MemoryCacheAdapter({
+     *       rootGroup: "@global"
+     *     }),
+     *     redis: new RedisCacheAdapter({
+     *       client: new Redis("YOUR_REDIS_CONNECTION"),
+     *       serde: new SuperJsonSerde(),
+     *       rootGroup: "@global"
+     *     }),
+     *   },
+     *   defaultAdapter: "memory",
+     *   eventBus,
+     * });
+     * ```
      */
-    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>;
+    constructor(settings: CacheFactorySettings<TAdapters>);
+    use<TType = unknown>(adapterName?: TAdapters | undefined): IGroupableCache<TType>;
 }

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

@@ -0,0 +1,68 @@
+/**
+ * @module Cache
+ */
+import type { ICacheAdapter } from "../../../cache/contracts/_module";
+import type { IBuildable } from "../../../utilities/_module";
+import type { TimeSpan } from "../../../utilities/_module";
+import type { BackoffPolicy, RetryPolicy } from "../../../async/_module";
+import type { IGroupableEventBus } from "../../../event-bus/contracts/_module";
+/**
+ * @group Derivables
+ */
+export type CacheSettings = {
+    adapter: ICacheAdapter<any>;
+    /**
+     * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link IGroupableEventBus}</i>.
+     */
+    eventBus?: IGroupableEventBus<any>;
+    /**
+     * You can decide the default ttl value. If null is passed then no ttl will be used by default.
+     */
+    defaultTtl?: TimeSpan | null;
+    /**
+     * The default retry attempt to use in the returned <i>LazyPromise</i>.
+     */
+    retryAttempts?: number | null;
+    /**
+     * The default backof policy to use in the returned <i>LazyPromise</i>.
+     */
+    backoffPolicy?: BackoffPolicy | null;
+    /**
+     * The default retry policy to use in the returned <i>LazyPromise</i>.
+     */
+    retryPolicy?: RetryPolicy | null;
+    /**
+     * The default timeout to use in the returned <i>LazyPromise</i>.
+     */
+    timeout?: TimeSpan | null;
+};
+/**
+ * The <i>CacheSettingsBuilder</i> is an immutable builder class, meaning that each method invocation creates a new instance.
+ * @group Derivables
+ */
+export declare class CacheSettingsBuilder<TSettings extends Partial<CacheSettings>> implements IBuildable<CacheSettings> {
+    private readonly settings;
+    constructor(settings?: TSettings);
+    setAdapter(adapter: ICacheAdapter<any>): CacheSettingsBuilder<TSettings & {
+        adapter: ICacheAdapter<any>;
+    }>;
+    setEventBus(eventBus: IGroupableEventBus<any>): CacheSettingsBuilder<TSettings & {
+        eventBus: IGroupableEventBus<any>;
+    }>;
+    setDefultTtl(time: TimeSpan): CacheSettingsBuilder<TSettings & {
+        defaultTtl: TimeSpan;
+    }>;
+    setRetryAttempts(attempts: number | null): CacheSettingsBuilder<TSettings & {
+        retryAttempts: number | null;
+    }>;
+    setBackoffPolicy(policy: BackoffPolicy | null): CacheSettingsBuilder<TSettings & {
+        backoffPolicy: BackoffPolicy | null;
+    }>;
+    setRetryPolicy(policy: RetryPolicy | null): CacheSettingsBuilder<TSettings & {
+        retryPolicy: RetryPolicy | null;
+    }>;
+    setTimeout(time: TimeSpan | null): CacheSettingsBuilder<TSettings & {
+        timeout: TimeSpan | null;
+    }>;
+    build(this: CacheSettingsBuilder<CacheSettings>): CacheSettings;
+}

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

@@ -1,75 +1,63 @@
 /**
  * @module Cache
  */
-import type { CacheEvents } from "../../../cache/contracts/_module";
-import { type ICache, type ICacheAdapter } from "../../../cache/contracts/_module";
-import { type INamespacedCache } from "../../../cache/contracts/_module";
-import type { OneOrMore } from "../../../utilities/_module";
+import type { CacheEvents, WithTtlValue } from "../../../cache/contracts/_module";
+import { type ICache } from "../../../cache/contracts/_module";
+import { type IGroupableCache } from "../../../cache/contracts/_module";
+import type { AsyncLazyable, GetOrAddValue, OneOrMore } from "../../../utilities/_module";
 import type { TimeSpan } from "../../../utilities/_module";
-import type { LazyPromiseSettings } from "../../../async/_module";
-import type { LazyPromise } from "../../../async/_module";
-import type { INamespacedEventBus } from "../../../event-bus/contracts/_module";
-import { BaseCache } from "../../../cache/implementations/derivables/base-cache";
+import { LazyPromise } from "../../../async/_module";
+import type { Listener, Unsubscribe, EventClass, EventInstance } from "../../../event-bus/contracts/_module";
+import type { CacheSettings } from "../../../cache/implementations/derivables/cache-settings";
+import { CacheSettingsBuilder } from "../../../cache/implementations/derivables/cache-settings";
 /**
+ * <i>Cache</i> class can be derived from any <i>{@link ICacheAdapter}</i>.
  * @group Derivables
  */
-export type CacheSettings<TType> = {
+export declare class Cache<TType = unknown> implements IGroupableCache<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"
-     * });
+     * import { Cache, MemoryCacheAdapter, TimeSpan } from "@daiso-tech/core";
      *
-     * (async () => {
-     *   await cacheA.add("a", 1);
-     *
-     *   // Will be "a"
-     *   console.log(await cacheA.get("a"));
-     *
-     *   // Will be "null"
-     *   console.log(await cacheB.get("a"));
-     * })();
+     * const cache = new Cache(
+     *   Cache
+     *     .settings()
+     *     .setAdapter(new MemoryCacheAdapter({ rootGroup: "@global" }))
+     *     .setEventBus(new EventBus(new MemoryEventBusAdapter({ rootGroup: "@global" })))
+     *     .setDefaultTtl(TimeSpan.fromMinutes(2))
+     *     .build()
+     * );
      * ```
      */
-    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<CacheEvents<TType>>;
-    /**
-     * You can decide the default ttl value. If null is passed then no ttl will be used by default.
-     */
-    defaultTtl?: TimeSpan | null;
-    lazyPromiseSettings?: LazyPromiseSettings;
-};
-/**
- * <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;
+    static settings<TSettings extends Partial<CacheSettings>>(): CacheSettingsBuilder<TSettings>;
+    private static defaultRetryPolicy;
+    private readonly groupdEventBus;
     private readonly eventBus;
-    private readonly cacheAdapter;
-    private readonly eventAttributes;
+    private readonly adapter;
     private readonly defaultTtl;
-    constructor(cacheAdapter: ICacheAdapter<any>, settings?: CacheSettings<TType>);
+    private readonly retryAttempts;
+    private readonly backoffPolicy;
+    private readonly retryPolicy;
+    private readonly timeout;
+    /**
+     *@example
+     * ```ts
+     * import { Cache, MemoryCacheAdapter, EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
+     *
+     * const eventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     * ```
+     */
+    constructor(settings: CacheSettings);
+    private createLayPromise;
     private createKeyFoundEvent;
     private createKeyNotFoundEvent;
     private createKeyAddedEvent;
@@ -78,14 +66,47 @@ export declare class Cache<TType = unknown> extends BaseCache<TType> implements
     private createKeysClearedEvent;
     private createKeyIncrementedEvent;
     private createKeyDecrementedEvent;
-    private keyWithNamespace;
-    withNamespace(namespace: OneOrMore<string>): ICache<TType>;
-    getNamespace(): string;
+    addListener<TEventClass extends EventClass<CacheEvents>>(eventName: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    addListenerMany<TEventClass extends EventClass<CacheEvents>>(eventNames: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    removeListener<TEventClass extends EventClass<CacheEvents>>(eventName: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    removeListenerMany<TEventClass extends EventClass<CacheEvents>>(eventNames: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    listenOnce<TEventClass extends EventClass<CacheEvents>>(eventName: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    subscribe<TEventClass extends EventClass<CacheEvents>>(eventName: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventClass extends EventClass<CacheEvents>>(eventNames: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    withGroup(group: OneOrMore<string>): ICache<TType>;
+    getGroup(): string;
     get(key: string): LazyPromise<TType | null>;
-    add(key: string, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
+    add(key: string, value: TType, 
+    /**
+     * @default null
+     */
+    ttl?: TimeSpan | null): LazyPromise<boolean>;
     update(key: string, value: TType): LazyPromise<boolean>;
-    put(key: string, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
+    put(key: string, value: TType, 
+    /**
+     * @default null
+     */
+    ttl?: TimeSpan | null): LazyPromise<boolean>;
     remove(key: string): LazyPromise<boolean>;
     increment(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
     clear(): LazyPromise<void>;
+    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>>;
+    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>;
+    addMany<TKeys extends string>(values: Record<TKeys, WithTtlValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): LazyPromise<Record<TKeys, boolean>>;
+    putMany<TKeys extends string>(values: Record<TKeys, WithTtlValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
+    getAndRemove(key: string): LazyPromise<TType | null>;
+    getOrAdd(key: string, valueToAdd: AsyncLazyable<GetOrAddValue<TType>>, 
+    /**
+     * @default {null}
+     */
+    ttl?: TimeSpan): LazyPromise<TType>;
+    decrement(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
 }