@daiso-tech/core 0.33.0 → 0.35.0

package/dist/async/middlewares/hedging/sequential-hedging/sequential-hedging.middleware.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @module Async
+ */
+import { type AsyncMiddlewareFn, type HookContext } from "../../../../utilities/_module-exports.js";
+import type { HedgingSettings } from "../../../../async/middlewares/hedging/_shared.js";
+/**
+ * The `sequentialHedging` middleware executes the primary function and all fallback functions sequentially.
+ * It returns the result of the first successful function and automatically cancels all remaining functions.
+ * If all function fail than error is thrown.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ * @throws {HedgingAsyncError} {@link HedgingAsyncError}
+ *
+ * @example
+ * ```ts
+ * import { sequentialHedging } from "@daiso-tech/core/async";
+ * import { AsyncHooks } from "@daiso-tech/core/utilities";
+ *
+ * async function fn1(signal?: AbortSignal): Promise<unknown> {
+ *   const response = await fetch("ENDPOINT-1", { signal });
+ *   return await response.json();
+ * }
+ * async function fn2(signal?: AbortSignal): Promise<unknown> {
+ *   const response = await fetch("ENDPOINT-2", { signal });
+ *   return await response.json();
+ * }
+ * async function fn3(signal?: AbortSignal): Promise<unknown> {
+ *   const response = await fetch("ENDPOINT-3", { signal });
+ *   return await response.json();
+ * }
+ * const fetchData = new AsyncHooks(fn1, [
+ *   sequentialHedging({
+ *     fallbacks: [
+ *       fn2,
+ *       fn3
+ *     ]
+ *   })
+ * ], {
+ *   signalBinder: {
+ *     getSignal: (args) => args[0],
+ *     forwardSignal: (args, signal) => {
+ *       args[0] = signal;
+ *     }
+ *   }
+ * });
+ *
+ * console.log(await fetchData.invoke());
+ * ```
+ */
+export declare function sequentialHedging<TParameters extends unknown[], TReturn, TContext extends HookContext>(settings: NoInfer<HedgingSettings<TParameters, TReturn, TContext>>): AsyncMiddlewareFn<TParameters, TReturn, TContext>;

package/dist/async/middlewares/hedging/sequential-hedging/sequential-hedging.middleware.js

@@ -0,0 +1,104 @@
+/**
+ * @module Async
+ */
+import { callInvokable, isInvokable, resolveOneOrMore, TimeSpan, } from "../../../../utilities/_module-exports.js";
+import { HedgingAsyncError } from "../../../../async/async.errors.js";
+import { timeoutAndFail } from "../../../../async/utilities/_module.js";
+/**
+ * The `sequentialHedging` middleware executes the primary function and all fallback functions sequentially.
+ * It returns the result of the first successful function and automatically cancels all remaining functions.
+ * If all function fail than error is thrown.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ * @throws {HedgingAsyncError} {@link HedgingAsyncError}
+ *
+ * @example
+ * ```ts
+ * import { sequentialHedging } from "@daiso-tech/core/async";
+ * import { AsyncHooks } from "@daiso-tech/core/utilities";
+ *
+ * async function fn1(signal?: AbortSignal): Promise<unknown> {
+ *   const response = await fetch("ENDPOINT-1", { signal });
+ *   return await response.json();
+ * }
+ * async function fn2(signal?: AbortSignal): Promise<unknown> {
+ *   const response = await fetch("ENDPOINT-2", { signal });
+ *   return await response.json();
+ * }
+ * async function fn3(signal?: AbortSignal): Promise<unknown> {
+ *   const response = await fetch("ENDPOINT-3", { signal });
+ *   return await response.json();
+ * }
+ * const fetchData = new AsyncHooks(fn1, [
+ *   sequentialHedging({
+ *     fallbacks: [
+ *       fn2,
+ *       fn3
+ *     ]
+ *   })
+ * ], {
+ *   signalBinder: {
+ *     getSignal: (args) => args[0],
+ *     forwardSignal: (args, signal) => {
+ *       args[0] = signal;
+ *     }
+ *   }
+ * });
+ *
+ * console.log(await fetchData.invoke());
+ * ```
+ */
+export function sequentialHedging(settings) {
+    const { waitTime = TimeSpan.fromSeconds(2), fallbacks, onHedgeAttempt = () => { }, onHedgeError = () => { }, } = settings;
+    const resolvedFallbacks = resolveOneOrMore(fallbacks).map((fallback, index) => {
+        if (isInvokable(fallback)) {
+            return {
+                name: `fallback-${String(index + 1)}`,
+                func: fallback,
+            };
+        }
+        return fallback;
+    });
+    return async (args, next, { context, signal, abort }) => {
+        const errors = [];
+        const funcs = [
+            {
+                name: "__initial",
+                func: next,
+            },
+            ...resolvedFallbacks,
+        ];
+        for (const { name, func } of funcs) {
+            try {
+                callInvokable(onHedgeAttempt, {
+                    args,
+                    context,
+                    name,
+                });
+                return await timeoutAndFail((async () => callInvokable(func, ...args))(), waitTime, (error) => {
+                    abort(error);
+                }, signal);
+            }
+            catch (error) {
+                if (signal.aborted) {
+                    break;
+                }
+                callInvokable(onHedgeError, {
+                    args,
+                    context,
+                    error,
+                    name,
+                });
+                errors.push(error);
+            }
+        }
+        // If all promiseResults are rejected we will throw an error
+        const funcNames = funcs
+            .slice(1)
+            .map(({ name }) => `"${name}"`)
+            .join(", ");
+        throw new HedgingAsyncError(`The original function and fallback functions failed: ${funcNames}`, errors);
+    };
+}
+//# sourceMappingURL=sequential-hedging.middleware.js.map

package/dist/async/middlewares/hedging/sequential-hedging/sequential-hedging.middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequential-hedging.middleware.js","sourceRoot":"","sources":["../../../../../src/async/middlewares/hedging/sequential-hedging/sequential-hedging.middleware.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACH,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,QAAQ,GAGX,MAAM,gCAAgC,CAAC;AAKxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,UAAU,iBAAiB,CAK7B,QAAkE;IAElE,MAAM,EACF,QAAQ,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,EAClC,SAAS,EACT,cAAc,GAAG,GAAG,EAAE,GAAE,CAAC,EACzB,YAAY,GAAG,GAAG,EAAE,GAAE,CAAC,GAC1B,GAAG,QAAQ,CAAC;IAEb,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,SAAS,CAAC,CAAC,GAAG,CAEvD,CAAC,QAAQ,EAAE,KAAK,EAAE,EAAE;QAClB,IAAI,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;YACxB,OAAO;gBACH,IAAI,EAAE,YAAY,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE;gBACrC,IAAI,EAAE,QAAQ;aACjB,CAAC;QACN,CAAC;QACD,OAAO,QAAQ,CAAC;IACpB,CAAC,CAAC,CAAC;IAEH,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,EAAE;QACpD,MAAM,MAAM,GAAc,EAAE,CAAC;QAC7B,MAAM,KAAK,GAAG;YACV;gBACI,IAAI,EAAE,WAAW;gBACjB,IAAI,EAAE,IAAI;aACb;YACD,GAAG,iBAAiB;SACvB,CAAC;QACF,KAAK,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,KAAK,EAAE,CAAC;YACjC,IAAI,CAAC;gBACD,aAAa,CAAC,cAAc,EAAE;oBAC1B,IAAI;oBACJ,OAAO;oBACP,IAAI;iBACP,CAAC,CAAC;gBACH,OAAO,MAAM,cAAc,CACvB,CAAC,KAAK,IAAI,EAAE,CAAC,aAAa,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,EAC5C,QAAQ,EACR,CAAC,KAAc,EAAE,EAAE;oBACf,KAAK,CAAC,KAAK,CAAC,CAAC;gBACjB,CAAC,EACD,MAAM,CACT,CAAC;YACN,CAAC;YAAC,OAAO,KAAc,EAAE,CAAC;gBACtB,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM;gBACV,CAAC;gBACD,aAAa,CAAC,YAAY,EAAE;oBACxB,IAAI;oBACJ,OAAO;oBACP,KAAK;oBACL,IAAI;iBACP,CAAC,CAAC;gBACH,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACvB,CAAC;QACL,CAAC;QAED,4DAA4D;QAC5D,MAAM,SAAS,GAAG,KAAK;aAClB,KAAK,CAAC,CAAC,CAAC;aACR,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,IAAI,GAAG,CAAC;aAC9B,IAAI,CAAC,IAAI,CAAC,CAAC;QAChB,MAAM,IAAI,iBAAiB,CACvB,wDAAwD,SAAS,EAAE,EACnE,MAAM,CACT,CAAC;IACN,CAAC,CAAC;AACN,CAAC"}

package/dist/async/middlewares/observe/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../async/middlewares/observe/observe.middleware.js";

package/dist/async/middlewares/observe/_module.js

@@ -0,0 +1,2 @@
+export * from "../../../async/middlewares/observe/observe.middleware.js";
+//# sourceMappingURL=_module.js.map

package/dist/async/middlewares/observe/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../src/async/middlewares/observe/_module.ts"],"names":[],"mappings":"AAAA,cAAc,mDAAmD,CAAC"}

package/dist/async/middlewares/observe/observe.middleware.d.ts

@@ -0,0 +1,130 @@
+/**
+ * @module Async
+ */
+import { TimeSpan, type HookContext } from "../../../utilities/_module-exports.js";
+import { type AsyncMiddlewareFn, type Invokable } from "../../../utilities/_module-exports.js";
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ */
+export type OnObserveStartData<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
+    args: TParameters;
+    context: TContext;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ */
+export type OnObserveStart<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = Invokable<[data: OnObserveStartData<TParameters, TContext>]>;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ */
+export type OnObserveSuccessData<TParameters extends unknown[] = unknown[], TReturn = unknown, TContext extends HookContext = HookContext> = {
+    returnValue: TReturn;
+    args: TParameters;
+    context: TContext;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ */
+export type OnObserveSuccess<TParameters extends unknown[] = unknown[], TReturn = unknown, TContext extends HookContext = HookContext> = Invokable<[data: OnObserveSuccessData<TParameters, TReturn, TContext>]>;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ */
+export type OnObserveErrorData<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
+    error: unknown;
+    args: TParameters;
+    context: TContext;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ */
+export type OnObserveFinallyData<TContext extends HookContext = HookContext> = {
+    executionTime: TimeSpan;
+    context: TContext;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ */
+export type OnObserveError<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = Invokable<[data: OnObserveErrorData<TParameters, TContext>]>;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ */
+export type OnObserveFinally<TContext extends HookContext = HookContext> = Invokable<[data: OnObserveFinallyData<TContext>]>;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ */
+export type ObserveCallbacks<TParameters extends unknown[] = unknown[], TReturn = unknown, TContext extends HookContext = HookContext> = {
+    /**
+     * Callback function that will be called when before the underlying {@link Invokable | `Invokable`} is called.
+     */
+    onStart?: OnObserveStart<TParameters, TContext>;
+    /**
+     * Callback function that will be called when the underlying {@link Invokable | `Invokable`} is successfully called.
+     */
+    onSuccess?: OnObserveSuccess<TParameters, TReturn, TContext>;
+    /**
+     * Callback function that will be called when the underlying {@link Invokable | `Invokable`} throws an error.
+     */
+    onError?: OnObserveError<TParameters, TContext>;
+    /**
+     * Callback function that will be called when the underlying {@link Invokable | `Invokable`} throws an error or is successfully called.
+     */
+    onFinally?: OnObserveFinally<TContext>;
+};
+/**
+ * The `observe` middleware tracks an async function's state and runs callbacks when it fails with an error or succeeds.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ *
+ * @example
+ * ```ts
+ * import { observe, LazyPromise } from "@daiso-tech/core/async";
+ * import { AsyncHooks, TimeSpan } from "@daiso-tech/core/utilities";
+ *
+ * await new AsyncHooks(
+ *   // Lets pretend this function can throw and takes time to execute.
+ *   async (a: number, b: number): Promise<number> => {
+ *      const shouldThrow1 = Math.round(Math.random() * 100);
+ *      if (shouldThrow1 > 50) {
+ *        throw new Error("Unexpected error occured");
+ *      }
+ *      await LazyPromise.delay(TimeSpan.fromMilliseconds(Math.random() * 1000));
+ *      const shouldThrow2 = Math.round(Math.random() * 100);
+ *      if (shouldThrow2 > 50) {
+ *        throw new Error("Unexpected error occured");
+ *      }
+ *      return a / b;
+ *   },
+ *   observe({
+ *     onStart: (data) => console.log("START:", data),
+ *     onSuccess: (data) => console.log("SUCCESS:", data),
+ *     onError: (data) => console.error("ERROR:", data),
+ *     onFinally: (data) => console.log("FINALLY:", data),
+ *   })
+ * )
+ * .invoke(20, 10);
+ * // Will log when the function execution has started and the arguments.
+ * // Will log if the function succeded, the arguments and the return value.
+ * // Will log if the function errored, arguments and the error.
+ * // Will log the execution time and arguments
+ * ```
+ */
+export declare function observe<TParameters extends unknown[], TReturn, TContext extends HookContext>(settings: NoInfer<ObserveCallbacks<TParameters, TReturn, TContext>>): AsyncMiddlewareFn<TParameters, TReturn, TContext>;

package/dist/async/middlewares/observe/observe.middleware.js

@@ -0,0 +1,80 @@
+/**
+ * @module Async
+ */
+import { TimeSpan } from "../../../utilities/_module-exports.js";
+import { callInvokable, } from "../../../utilities/_module-exports.js";
+/**
+ * The `observe` middleware tracks an async function's state and runs callbacks when it fails with an error or succeeds.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ *
+ * @example
+ * ```ts
+ * import { observe, LazyPromise } from "@daiso-tech/core/async";
+ * import { AsyncHooks, TimeSpan } from "@daiso-tech/core/utilities";
+ *
+ * await new AsyncHooks(
+ *   // Lets pretend this function can throw and takes time to execute.
+ *   async (a: number, b: number): Promise<number> => {
+ *      const shouldThrow1 = Math.round(Math.random() * 100);
+ *      if (shouldThrow1 > 50) {
+ *        throw new Error("Unexpected error occured");
+ *      }
+ *      await LazyPromise.delay(TimeSpan.fromMilliseconds(Math.random() * 1000));
+ *      const shouldThrow2 = Math.round(Math.random() * 100);
+ *      if (shouldThrow2 > 50) {
+ *        throw new Error("Unexpected error occured");
+ *      }
+ *      return a / b;
+ *   },
+ *   observe({
+ *     onStart: (data) => console.log("START:", data),
+ *     onSuccess: (data) => console.log("SUCCESS:", data),
+ *     onError: (data) => console.error("ERROR:", data),
+ *     onFinally: (data) => console.log("FINALLY:", data),
+ *   })
+ * )
+ * .invoke(20, 10);
+ * // Will log when the function execution has started and the arguments.
+ * // Will log if the function succeded, the arguments and the return value.
+ * // Will log if the function errored, arguments and the error.
+ * // Will log the execution time and arguments
+ * ```
+ */
+export function observe(settings) {
+    const { onStart = () => { }, onSuccess = () => { }, onError = () => { }, onFinally = () => { }, } = settings;
+    return async (args, next, { context }) => {
+        const start = performance.now();
+        try {
+            callInvokable(onStart, {
+                args,
+                context,
+            });
+            const returnValue = await next(...args);
+            callInvokable(onSuccess, {
+                args,
+                context,
+                returnValue,
+            });
+            return returnValue;
+        }
+        catch (error) {
+            callInvokable(onError, {
+                args,
+                context,
+                error,
+            });
+            throw error;
+        }
+        finally {
+            const end = performance.now();
+            const time = end - start;
+            callInvokable(onFinally, {
+                context,
+                executionTime: TimeSpan.fromMilliseconds(time),
+            });
+        }
+    };
+}
+//# sourceMappingURL=observe.middleware.js.map

package/dist/async/middlewares/observe/observe.middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observe.middleware.js","sourceRoot":"","sources":["../../../../src/async/middlewares/observe/observe.middleware.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,QAAQ,EAAoB,MAAM,gCAAgC,CAAC;AAC5E,OAAO,EACH,aAAa,GAGhB,MAAM,gCAAgC,CAAC;AA4HxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,UAAU,OAAO,CAKnB,QAAmE;IAEnE,MAAM,EACF,OAAO,GAAG,GAAG,EAAE,GAAE,CAAC,EAClB,SAAS,GAAG,GAAG,EAAE,GAAE,CAAC,EACpB,OAAO,GAAG,GAAG,EAAE,GAAE,CAAC,EAClB,SAAS,GAAG,GAAG,EAAE,GAAE,CAAC,GACvB,GAAG,QAAQ,CAAC;IACb,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE;QACrC,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QAChC,IAAI,CAAC;YACD,aAAa,CAAC,OAAO,EAAE;gBACnB,IAAI;gBACJ,OAAO;aACV,CAAC,CAAC;YACH,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;YACxC,aAAa,CAAC,SAAS,EAAE;gBACrB,IAAI;gBACJ,OAAO;gBACP,WAAW;aACd,CAAC,CAAC;YACH,OAAO,WAAW,CAAC;QACvB,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACtB,aAAa,CAAC,OAAO,EAAE;gBACnB,IAAI;gBACJ,OAAO;gBACP,KAAK;aACR,CAAC,CAAC;YACH,MAAM,KAAK,CAAC;QAChB,CAAC;gBAAS,CAAC;YACP,MAAM,GAAG,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;YAC9B,MAAM,IAAI,GAAG,GAAG,GAAG,KAAK,CAAC;YACzB,aAAa,CAAC,SAAS,EAAE;gBACrB,OAAO;gBACP,aAAa,EAAE,QAAQ,CAAC,gBAAgB,CAAC,IAAI,CAAC;aACjD,CAAC,CAAC;QACP,CAAC;IACL,CAAC,CAAC;AACN,CAAC"}

package/dist/async/middlewares/retry/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../async/middlewares/retry/retry.middleware.js";

package/dist/async/middlewares/retry/_module.js

@@ -0,0 +1,2 @@
+export * from "../../../async/middlewares/retry/retry.middleware.js";
+//# sourceMappingURL=_module.js.map

package/dist/async/middlewares/retry/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../src/async/middlewares/retry/_module.ts"],"names":[],"mappings":"AAAA,cAAc,+CAA+C,CAAC"}

package/dist/async/middlewares/retry/retry.middleware.d.ts

@@ -0,0 +1,117 @@
+/**
+ * @module Async
+ */
+import { TimeSpan, type Invokable, type HookContext, type AsyncMiddlewareFn } from "../../../utilities/_module-exports.js";
+import { type BackoffPolicy } from "../../../async/backof-policies/_module.js";
+import { type ErrorPolicy } from "../../../async/middlewares/_shared.js";
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middlewares
+ */
+export type OnRetryAttemptData<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
+    attempt: number;
+    args: TParameters;
+    context: TContext;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middlewares
+ */
+export type OnRetryAttempt<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = Invokable<[data: OnRetryAttemptData<TParameters, TContext>]>;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middlewares
+ */
+export type OnRetryDelayData<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
+    error: unknown;
+    attempt: number;
+    waitTime: TimeSpan;
+    args: TParameters;
+    context: TContext;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middlewares
+ */
+export type OnRetryDelay<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = Invokable<[data: OnRetryDelayData<TParameters, TContext>]>;
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middlewares
+ */
+export type RetryCallbacks<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
+    /**
+     * Callback function that will be called before execution attempt.
+     */
+    onExecutionAttempt?: OnRetryAttempt<TParameters, TContext>;
+    /**
+     * Callback function that will be called when the retry delay starts.
+     */
+    onRetryDelay?: OnRetryDelay<TParameters, TContext>;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middlewares
+ */
+export type RetrySettings<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = RetryCallbacks<TParameters, TContext> & {
+    /**
+     * You can decide maximal times you can retry.
+     * @default {4}
+     */
+    maxAttempts?: number;
+    /**
+     * @default
+     * ```ts
+     * import { exponentialBackoffPolicy } from "@daiso-tech/core/async";
+     *
+     * exponentialBackoffPolicy();
+     * ```
+     */
+    backoffPolicy?: BackoffPolicy;
+    /**
+     * You can choose what errors you want to retry. By default all erros will be retried.
+     *
+     * @default
+     * ```ts
+     * (_error: unknown) => true
+     * ```
+     */
+    retryPolicy?: ErrorPolicy;
+};
+/**
+ * The `retry` middleware enables automatic retries for all errors or specific errors, with configurable backoff policies.
+ * An error will be thrown when all retry attempts fail.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ * @throws {RetryAsyncError} {@link RetryAsyncError}
+ *
+ * @example
+ * ```ts
+ * import { retry } from "@daiso-tech/core/async";
+ * import { AsyncHooks, TimeSpan } from "@daiso-tech/core/utilities";
+ *
+ * const data = await new AsyncHooks(
+ *   async (url: string, signal?: AbortSignal): Promise<unknown> => {
+ *     const response = await fetch(url, { signal });
+ *     return await response.json();
+ *   },
+ *   [retry()],
+ *   {
+ *     signalBinder: {
+ *       getSignal: (args) => args[1],
+ *       forwardSignal: (args, signal) => {
+ *         args[1] = signal;
+ *       }
+ *     }
+ *   }
+ * )
+ * .invoke("URL");
+ * ```
+ */
+export declare function retry<TParameters extends unknown[], TReturn, TContext extends HookContext>(settings?: NoInfer<RetrySettings<TParameters, TContext>>): AsyncMiddlewareFn<TParameters, TReturn, TContext>;

package/dist/async/middlewares/retry/retry.middleware.js

@@ -0,0 +1,82 @@
+/**
+ * @module Async
+ */
+import { callInvokable, TimeSpan, } from "../../../utilities/_module-exports.js";
+import { exponentialBackoffPolicy, } from "../../../async/backof-policies/_module.js";
+import { RetryAsyncError } from "../../../async/async.errors.js";
+import { LazyPromise } from "../../../async/utilities/_module.js";
+import {} from "../../../async/middlewares/_shared.js";
+/**
+ * The `retry` middleware enables automatic retries for all errors or specific errors, with configurable backoff policies.
+ * An error will be thrown when all retry attempts fail.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/async"`
+ * @group Middleware
+ * @throws {RetryAsyncError} {@link RetryAsyncError}
+ *
+ * @example
+ * ```ts
+ * import { retry } from "@daiso-tech/core/async";
+ * import { AsyncHooks, TimeSpan } from "@daiso-tech/core/utilities";
+ *
+ * const data = await new AsyncHooks(
+ *   async (url: string, signal?: AbortSignal): Promise<unknown> => {
+ *     const response = await fetch(url, { signal });
+ *     return await response.json();
+ *   },
+ *   [retry()],
+ *   {
+ *     signalBinder: {
+ *       getSignal: (args) => args[1],
+ *       forwardSignal: (args, signal) => {
+ *         args[1] = signal;
+ *       }
+ *     }
+ *   }
+ * )
+ * .invoke("URL");
+ * ```
+ */
+export function retry(settings = {}) {
+    const { maxAttempts = 4, backoffPolicy = exponentialBackoffPolicy(), retryPolicy = () => true, onRetryDelay = () => { }, onExecutionAttempt = () => { }, } = settings;
+    return async (args, next, { context, signal }) => {
+        const errors = [];
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                callInvokable(onExecutionAttempt, { attempt, args, context });
+                return await next(...args);
+            }
+            catch (error) {
+                if (signal.aborted) {
+                    break;
+                }
+                const waitTime = TimeSpan.fromMilliseconds(callInvokable(backoffPolicy, attempt, error));
+                callInvokable(onRetryDelay, {
+                    error,
+                    waitTime,
+                    attempt,
+                    args,
+                    context,
+                });
+                if (callInvokable(retryPolicy, error)) {
+                    errors.push(error);
+                }
+                else {
+                    throw error;
+                }
+                await LazyPromise.delay(waitTime, signal);
+            }
+        }
+        let errorMessage = `Promise was failed after retried ${String(maxAttempts)} times`;
+        const lastError = errors[errors.length - 1];
+        if (lastError) {
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string
+            errorMessage = `${errorMessage} and last thrown error was "${String(lastError)}"`;
+        }
+        throw new RetryAsyncError(errorMessage, {
+            errors,
+            maxAttempts,
+        });
+    };
+}
+//# sourceMappingURL=retry.middleware.js.map

package/dist/async/middlewares/retry/retry.middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.middleware.js","sourceRoot":"","sources":["../../../../src/async/middlewares/retry/retry.middleware.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACH,aAAa,EACb,QAAQ,GAIX,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACH,wBAAwB,GAE3B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAoB,MAAM,gCAAgC,CAAC;AA4GlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,KAAK,CAKjB,WAA0D,EAAE;IAE5D,MAAM,EACF,WAAW,GAAG,CAAC,EACf,aAAa,GAAG,wBAAwB,EAAE,EAC1C,WAAW,GAAG,GAAG,EAAE,CAAC,IAAI,EACxB,YAAY,GAAG,GAAG,EAAE,GAAE,CAAC,EACvB,kBAAkB,GAAG,GAAG,EAAE,GAAE,CAAC,GAChC,GAAG,QAAQ,CAAC;IACb,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE;QAC7C,MAAM,MAAM,GAAc,EAAE,CAAC;QAC7B,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,WAAW,EAAE,OAAO,EAAE,EAAE,CAAC;YACtD,IAAI,CAAC;gBACD,aAAa,CAAC,kBAAkB,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;gBAC9D,OAAO,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;YAC/B,CAAC;YAAC,OAAO,KAAc,EAAE,CAAC;gBACtB,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM;gBACV,CAAC;gBACD,MAAM,QAAQ,GAAG,QAAQ,CAAC,gBAAgB,CACtC,aAAa,CAAC,aAAa,EAAE,OAAO,EAAE,KAAK,CAAC,CAC/C,CAAC;gBACF,aAAa,CAAC,YAAY,EAAE;oBACxB,KAAK;oBACL,QAAQ;oBACR,OAAO;oBACP,IAAI;oBACJ,OAAO;iBACV,CAAC,CAAC;gBAEH,IAAI,aAAa,CAAC,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC;oBACpC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACvB,CAAC;qBAAM,CAAC;oBACJ,MAAM,KAAK,CAAC;gBAChB,CAAC;gBACD,MAAM,WAAW,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YAC9C,CAAC;QACL,CAAC;QAED,IAAI,YAAY,GAAG,oCAAoC,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC;QACnF,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC5C,IAAI,SAAS,EAAE,CAAC;YACZ,gEAAgE;YAChE,YAAY,GAAG,GAAG,YAAY,+BAA+B,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC;QACtF,CAAC;QACD,MAAM,IAAI,eAAe,CAAC,YAAY,EAAE;YACpC,MAAM;YACN,WAAW;SACd,CAAC,CAAC;IACP,CAAC,CAAC;AACN,CAAC"}

package/dist/async/middlewares/timeout/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../async/middlewares/timeout/timeout.middleware.js";

package/dist/async/middlewares/timeout/_module.js

@@ -0,0 +1,2 @@
+export * from "../../../async/middlewares/timeout/timeout.middleware.js";
+//# sourceMappingURL=_module.js.map

package/dist/async/middlewares/timeout/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../src/async/middlewares/timeout/_module.ts"],"names":[],"mappings":"AAAA,cAAc,mDAAmD,CAAC"}