@daiso-tech/core 0.16.0 → 0.17.4

package/dist/types/async/utilities/lazy-promise/lazy-promise.d.ts

@@ -5,16 +5,6 @@ import type { BackoffPolicy } from "../../../async/backof-policies/_module";
 import type { TimeSpan } from "../../../utilities/time-span/_module";
 import type { RetryPolicy } from "../../../async/utilities/retry/_module";
 import type { Func } from "../../../utilities/_module";
-/**
- * @group Utilities
- */
-export type LazyPromiseSettings = {
-    retryAttempts?: number | null;
-    backoffPolicy?: BackoffPolicy | null;
-    retryPolicy?: RetryPolicy | null;
-    abortSignal?: AbortSignal | null;
-    time?: TimeSpan | null;
-};
 /**
  * The <i>LazyPromise</i> class is used for creating lazy <i>{@link PromiseLike}<i> object that will only execute when awaited or when then method is called.
  * The class includes helpful methods
@@ -33,19 +23,6 @@ export type LazyPromiseSettings = {
  * This means that combining all methods ensures the <i>retryAttempts</i> method will continue retrying even if the timeout is triggered,
  * while the <i>abort</i> method takes priority to cancel all operations if activated.
  * @group Utilities
- * @example
- * ```ts
- * import { LazyPromise } from "@daiso-tech/core";
- * import {} from "node:fs/promises";
- *
- * (async () => {
- *   const promise = new LazyPromise(async () => {
- *     console.log("I am lazy");
- *   });
- *   // "I am lazy" will only logged when awaited or then method i called.
- *   await promise;
- * })();
- * ```
  */
 export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
     private asyncFn;
@@ -65,30 +42,43 @@ export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
      * })();
      * ```
      */
-    static wrapFn<TParameters extends unknown[], TReturn>(fn: Func<TParameters, PromiseLike<TReturn>>, settings?: LazyPromiseSettings): Func<TParameters, LazyPromise<TReturn>>;
+    static wrapFn<TParameters extends unknown[], TReturn>(fn: Func<TParameters, PromiseLike<TReturn>>): Func<TParameters, LazyPromise<TReturn>>;
     /**
      * The <i>all<i> method works similarly to <i>{@link Promise.all}</i> with the key distinction that it operates lazily.
      */
-    static all<TValue>(promises: LazyPromise<TValue>[], settings?: LazyPromiseSettings): LazyPromise<TValue[]>;
+    static all<TValue>(promises: LazyPromise<TValue>[]): LazyPromise<TValue[]>;
     /**
      * The <i>allSettled<i> method works similarly to <i>{@link Promise.allSettled}</i> with the key distinction that it operates lazily.
      */
-    static allSettled<TValue>(promises: LazyPromise<TValue>[], settings?: LazyPromiseSettings): LazyPromise<PromiseSettledResult<TValue>[]>;
+    static allSettled<TValue>(promises: LazyPromise<TValue>[]): LazyPromise<PromiseSettledResult<TValue>[]>;
     /**
      * The <i>race<i> method works similarly to <i>{@link Promise.race}</i> with the key distinction that it operates lazily.
      */
-    static race<TValue>(promises: LazyPromise<TValue>[], settings?: LazyPromiseSettings): LazyPromise<TValue>;
+    static race<TValue>(promises: LazyPromise<TValue>[]): LazyPromise<TValue>;
     /**
      * The <i>any<i> method works similarly to <i>{@link Promise.any}</i> with the key distinction that it operates lazily.
      */
-    static any<TValue>(promises: LazyPromise<TValue>[], settings?: LazyPromiseSettings): LazyPromise<TValue>;
+    static any<TValue>(promises: LazyPromise<TValue>[]): LazyPromise<TValue>;
     private promise;
     private attempts;
     private backoffPolicy_;
     private retryPolicy_;
     private abortSignal;
     private time;
-    constructor(asyncFn: () => PromiseLike<TValue>, settings?: LazyPromiseSettings);
+    /**
+     * @example
+     * ```ts
+     * import { LazyPromise } from "@daiso-tech/core";
+     *
+     * (async () => {
+     *   const promise = new LazyPromise(async () => {
+     *     console.log("I am lazy");
+     *   });
+     *   // "I am lazy" will only logged when awaited or then method i called.
+     *   await promise;
+     * })();
+     */
+    constructor(asyncFn: () => PromiseLike<TValue>);
     private applyTimeout;
     private applyRetry;
     private applyAbort;
@@ -100,7 +90,7 @@ export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
      */
     then<TResult1 = TValue, TResult2 = never>(onfulfilled?: ((value: TValue) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
     /**
-     * The <i>retryAttempts</i> method is used for setting max retry attempts.
+     * The <i>setRetryAttempts</i> method is used for setting max retry attempts.
      * @example
      * ```ts
      * import { LazyPromise } from "@daiso-tech/core";
@@ -110,16 +100,16 @@ export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
      *     console.log("A");
      *     throw new Error("Error occured!");
      *   })
-     *   .retryAttempts(3)
+     *   .setRetryAttempts(3)
      * (async () => {
      *   // Will log "A" 3 times and then retry error will be thrown.
      *   await promise;
      * })();
      * ```
      */
-    retryAttempts(attempts: number): this;
+    setRetryAttempts(attempts: number | null): this;
     /**
-     * The <i>backoffPolicy</i> method is used for setting a custom <i>{@link BackoffPolicy}</i>.
+     * The <i>setBackoffPolicy</i> method is used for setting a custom <i>{@link BackoffPolicy}</i>.
      * @example
      * ```ts
      * import { LazyPromise, linearBackoffPolicy } from "@daiso-tech/core";
@@ -129,17 +119,17 @@ export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
      *     console.log("A");
      *     throw new Error("Error occured!");
      *   })
-     *   .retryAttempts(3)
-     *   .backoffPolicy(linearBackoffPolicy())
+     *   .setRetryAttempts(3)
+     *   .setBackoffPolicy(linearBackoffPolicy())
      * (async () => {
      *   // Will log "A" 3 times and then retry error will be thrown.
      *   await promise;
      * })();
      * ```
      */
-    backoffPolicy(policy: BackoffPolicy): this;
+    setBackoffPolicy(policy: BackoffPolicy | null): this;
     /**
-     * The <i>backoffPolicy</i> method is used for setting a custom <i>{@link BackoffPolicy}</i>.
+     * The <i>setRetryPolicy</i> method is used for setting a custom <i>{@link BackoffPolicy}</i>.
      * @example
      * ```ts
      * import { LazyPromise } from "@daiso-tech/core";
@@ -151,18 +141,18 @@ export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
      *     console.log("A");
      *     throw new Error("Error occured!");
      *   })
-     *   .retryAttempts(3)
+     *   .setRetryAttempts(3)
      *   // Will only retry an error that is instance ErrorA
-     *   .retryPolicy(error => error instanceof ErrorA)
+     *   .setRetryPolicy(error => error instanceof ErrorA)
      * (async () => {
      *   // Will log "A" 1 time and then error will be thrown.
      *   await promise;
      * })();
      * ```
      */
-    retryPolicy(policy: RetryPolicy): this;
+    setRetryPolicy(policy: RetryPolicy | null): this;
     /**
-     * The <i>timeout</i> method aborts the <i>LazyPromise</i> if it exceeds the given <i>time</i> by throwning an error.
+     * The <i>setTimeout</i> method aborts the <i>LazyPromise</i> if it exceeds the given <i>time</i> by throwning an error.
      * @example
      * ```ts
      * import { LazyPromise, delay, TimeSpan } from "@daiso-tech/core";
@@ -171,16 +161,16 @@ export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
      *   new LazyPromise(async () => {
      *     await delay(TimeSpan.fromMinutes(1));
      *   })
-     *   .timeout(TimeSpan.fromSeconds(1));
+     *   .setTimeout(TimeSpan.fromSeconds(1));
      * (async () => {
      *   // An timeout error will be thrown.
      *   await promise;
      * })();
      * ```
      */
-    timeout(time: TimeSpan): this;
+    setTimeout(time: TimeSpan | null): this;
     /**
-     * The <i>abort</i> method aborts the <i>LazyPromise</i> by the passed in <i>abortSignal</i>.
+     * The <i>setAbortSignal</i> method aborts the <i>LazyPromise</i> by the passed in <i>abortSignal</i>.
      * @example
      * ```ts
      * import { LazyPromise, delay, TimeSpan } from "@daiso-tech/core";
@@ -190,7 +180,7 @@ export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
      *   new LazyPromise(async () => {
      *     await delay(TimeSpan.fromMinutes(1));
      *   })
-     *   .abort(abortController.signal);
+     *   .setAbortSignal(abortController.signal);
      * (async () => {
      *   setTimeout(() => {
      *     abortController.abort();
@@ -200,7 +190,7 @@ export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
      * })();
      * ```
      */
-    abort(abortSignal: AbortSignal): this;
+    setAbortSignal(abortSignal: AbortSignal | null): this;
     /**
      * The <i>defer</i> method executes the <i>LazyPromise</i> without awaiting it.
      * @example

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

@@ -6,18 +6,21 @@ import type { IGroupableCache } from "../../cache/contracts/cache.contract";
  * The <i>ICacheFactory</i> contract makes it easy to configure and switch between different <i>{@link IGroupableCache}</i> dynamically.
  * @group Contracts
  */
-export type ICacheFactory<TDrivers extends string = string, TType = unknown> = {
+export type ICacheFactory<TAdapters extends string = string> = {
     /**
-     * The <i>use</i> method will throw an error if you provide it unregisted driver.
-     * If no default driver is defined an error will be thrown by <i>use</i> method.
-     * @throws {UnregisteredDriverError} {@link UnregisteredDriverError}
-     * @throws {DefaultDriverNotDefinedError} {@link DefaultDriverNotDefinedError}
+     * The <i>use</i> method will throw an error if you provide it unregisted adapter.
+     * If no default adapter is defined an error will be thrown by <i>use</i> method.
+     * @throws {UnregisteredAdapterError} {@link UnregisteredAdapterError}
+     * @throws {DefaultAdapterNotDefinedError} {@link DefaultAdapterNotDefinedError}
      * @example
      * ```ts
      * import { type ICacheFactory } from "@daiso-tech/core";
+     * import Redis from "ioredis"
      *
+     * // Asume the inputed cacheFactory has registered both a memory and Redis ICacheAdapter.
+     * // The memory ICacheAdapter adapter is the default.
      * async function main(cacheFactory: ICacheFactory): Promise<void> {
-     *   // Will add key using the default driver
+     *   // Will add key using the default adapter
      *   await cacheFactory
      *     .use()
      *     .add("a", 1);
@@ -28,21 +31,5 @@ export type ICacheFactory<TDrivers extends string = string, TType = unknown> = {
      * }
      * ```
      */
-    use(driverName?: TDrivers): IGroupableCache<TType>;
-    /**
-     * The <i>withTypes</i> method is used to set the value types of the cache.
-     * @example
-     * ```ts
-     * import { type ICacheFactory } from "@daiso-tech/core";
-     *
-     * async function main(cacheFactory: ICacheFactory): Promise<void> {
-     *   await cacheFactory
-     *     .withTypes<string>()
-     *     .use()
-     *     // You will se an typescript error
-     *     .add("a", 1)
-     * }
-     * ```
-     */
-    withType<TOutput extends TType = TType>(): ICacheFactory<TDrivers, TOutput>;
+    use<TType = unknown>(adapterName?: TAdapters): IGroupableCache<TType>;
 };