@daiso-tech/core 0.34.0 → 0.35.0

package/dist/async/middlewares/hedging/concurrent-hedging/concurrent-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 `concurrentHedging` middleware executes the primary function and all fallback functions concurrently.
+ * It returns the result of the first successful function and automatically aborts 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 { concurrentHedging } 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, [
+ *   concurrentHedging({
+ *     fallbacks: [
+ *       fn2,
+ *       fn3
+ *     ]
+ *   })
+ * ], {
+ *   signalBinder: {
+ *     getSignal: (args) => args[0],
+ *     forwardSignal: (args, signal) => {
+ *       args[0] = signal;
+ *     }
+ *   }
+ * });
+ *
+ * console.log(await fetchData.invoke());
+ * ```
+ */
+export declare function concurrentHedging<TParameters extends unknown[], TReturn, TContext extends HookContext>(settings: NoInfer<HedgingSettings<TParameters, TReturn, TContext>>): AsyncMiddlewareFn<TParameters, TReturn, TContext>;

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

@@ -0,0 +1,138 @@
+/**
+ * @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";
+/**
+ * @internal
+ */
+class ResolvedError extends Error {
+    constructor(message, cause) {
+        super(message, { cause });
+        this.name = ResolvedError.name;
+    }
+}
+/**
+ * The `concurrentHedging` middleware executes the primary function and all fallback functions concurrently.
+ * It returns the result of the first successful function and automatically aborts 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 { concurrentHedging } 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, [
+ *   concurrentHedging({
+ *     fallbacks: [
+ *       fn2,
+ *       fn3
+ *     ]
+ *   })
+ * ], {
+ *   signalBinder: {
+ *     getSignal: (args) => args[0],
+ *     forwardSignal: (args, signal) => {
+ *       args[0] = signal;
+ *     }
+ *   }
+ * });
+ *
+ * console.log(await fetchData.invoke());
+ * ```
+ */
+export function concurrentHedging(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, abort, signal }) => {
+        function step1({ name, func }) {
+            return {
+                name,
+                promise: timeoutAndFail((async () => callInvokable(func, ...args))(), waitTime, (error) => {
+                    abort(error);
+                }, signal),
+            };
+        }
+        async function step2({ name, promise }) {
+            try {
+                const value = await promise;
+                // We abort all other promises when on promise succeds.
+                abort(new ResolvedError("Already resolved"));
+                return {
+                    type: "success",
+                    value,
+                    name,
+                };
+            }
+            catch (error) {
+                return {
+                    type: "failure",
+                    error,
+                    name,
+                };
+            }
+        }
+        const funcs = [
+            {
+                name: "__initial",
+                func: next,
+            },
+            ...resolvedFallbacks,
+        ];
+        const promises = funcs.map(step1).map(step2);
+        const errors = [];
+        const promiseResults = await Promise.all(promises);
+        for (const promiseResult of promiseResults) {
+            callInvokable(onHedgeAttempt, {
+                args,
+                context,
+                name: promiseResult.name,
+            });
+            // We return the first fulfilled value
+            if (promiseResult.type === "success") {
+                return promiseResult.value;
+            }
+            else if (!(promiseResult.error instanceof ResolvedError)) {
+                callInvokable(onHedgeError, {
+                    args,
+                    context,
+                    error: promiseResult.error,
+                    name: promiseResult.name,
+                });
+                errors.push(promiseResult.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=concurrent-hedging.middleware.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"concurrent-hedging.middleware.js","sourceRoot":"","sources":["../../../../../src/async/middlewares/hedging/concurrent-hedging/concurrent-hedging.middleware.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACH,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,QAAQ,GAGX,MAAM,gCAAgC,CAAC;AAMxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAE9D;;GAEG;AACH,MAAM,aAAc,SAAQ,KAAK;IAC7B,YAAY,OAAe,EAAE,KAAe;QACxC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QAC1B,IAAI,CAAC,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC;IACnC,CAAC;CACJ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE;QAoBpD,SAAS,KAAK,CAAC,EAAE,IAAI,EAAE,IAAI,EAAS;YAChC,OAAO;gBACH,IAAI;gBACJ,OAAO,EAAE,cAAc,CACnB,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;aACJ,CAAC;QACN,CAAC;QACD,KAAK,UAAU,KAAK,CAAC,EAAE,IAAI,EAAE,OAAO,EAAS;YACzC,IAAI,CAAC;gBACD,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC;gBAC5B,uDAAuD;gBACvD,KAAK,CAAC,IAAI,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAC;gBAC7C,OAAO;oBACH,IAAI,EAAE,SAAS;oBACf,KAAK;oBACL,IAAI;iBACP,CAAC;YACN,CAAC;YAAC,OAAO,KAAc,EAAE,CAAC;gBACtB,OAAO;oBACH,IAAI,EAAE,SAAS;oBACf,KAAK;oBACL,IAAI;iBACP,CAAC;YACN,CAAC;QACL,CAAC;QACD,MAAM,KAAK,GAAG;YACV;gBACI,IAAI,EAAE,WAAW;gBACjB,IAAI,EAAE,IAAI;aACb;YACD,GAAG,iBAAiB;SACvB,CAAC;QACF,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAE7C,MAAM,MAAM,GAAc,EAAE,CAAC;QAC7B,MAAM,cAAc,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACnD,KAAK,MAAM,aAAa,IAAI,cAAc,EAAE,CAAC;YACzC,aAAa,CAAC,cAAc,EAAE;gBAC1B,IAAI;gBACJ,OAAO;gBACP,IAAI,EAAE,aAAa,CAAC,IAAI;aAC3B,CAAC,CAAC;YAEH,sCAAsC;YACtC,IAAI,aAAa,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;gBACnC,OAAO,aAAa,CAAC,KAAK,CAAC;YAC/B,CAAC;iBAAM,IAAI,CAAC,CAAC,aAAa,CAAC,KAAK,YAAY,aAAa,CAAC,EAAE,CAAC;gBACzD,aAAa,CAAC,YAAY,EAAE;oBACxB,IAAI;oBACJ,OAAO;oBACP,KAAK,EAAE,aAAa,CAAC,KAAK;oBAC1B,IAAI,EAAE,aAAa,CAAC,IAAI;iBAC3B,CAAC,CAAC;gBACH,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;YACrC,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/hedging/sequential-hedging/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../async/middlewares/hedging/sequential-hedging/_module.js";

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

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

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

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

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/observe.middleware.d.ts

@@ -8,7 +8,7 @@ import { type AsyncMiddlewareFn, type Invokable } from "../../../utilities/_modu
  * IMPORT_PATH: `"@daiso-tech/core/async"`
  * @group Middleware
  */
-export type OnStartData<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
+export type OnObserveStartData<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
     args: TParameters;
     context: TContext;
 };
@@ -17,13 +17,13 @@ export type OnStartData<TParameters extends unknown[] = unknown[], TContext exte
  * IMPORT_PATH: `"@daiso-tech/core/async"`
  * @group Middleware
  */
-export type OnStart<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = Invokable<[data: OnStartData<TParameters, TContext>]>;
+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 OnSuccessData<TParameters extends unknown[] = unknown[], TReturn = unknown, TContext extends HookContext = HookContext> = {
+export type OnObserveSuccessData<TParameters extends unknown[] = unknown[], TReturn = unknown, TContext extends HookContext = HookContext> = {
     returnValue: TReturn;
     args: TParameters;
     context: TContext;
@@ -33,13 +33,13 @@ export type OnSuccessData<TParameters extends unknown[] = unknown[], TReturn = u
  * IMPORT_PATH: `"@daiso-tech/core/async"`
  * @group Middleware
  */
-export type OnSuccess<TParameters extends unknown[] = unknown[], TReturn = unknown, TContext extends HookContext = HookContext> = Invokable<[data: OnSuccessData<TParameters, TReturn, TContext>]>;
+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 OnErrorData<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
+export type OnObserveErrorData<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
     error: unknown;
     args: TParameters;
     context: TContext;
@@ -49,7 +49,7 @@ export type OnErrorData<TParameters extends unknown[] = unknown[], TContext exte
  * IMPORT_PATH: `"@daiso-tech/core/async"`
  * @group Middleware
  */
-export type OnFinallyData<TContext extends HookContext = HookContext> = {
+export type OnObserveFinallyData<TContext extends HookContext = HookContext> = {
     executionTime: TimeSpan;
     context: TContext;
 };
@@ -58,37 +58,35 @@ export type OnFinallyData<TContext extends HookContext = HookContext> = {
  * IMPORT_PATH: `"@daiso-tech/core/async"`
  * @group Middleware
  */
-export type OnError<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = Invokable<[data: OnErrorData<TParameters, TContext>]>;
+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 OnFinally<TContext extends HookContext = HookContext> = Invokable<[
-    data: OnFinallyData<TContext>
-]>;
+export type OnObserveFinally<TContext extends HookContext = HookContext> = Invokable<[data: OnObserveFinallyData<TContext>]>;
 /**
  *
  * IMPORT_PATH: `"@daiso-tech/core/async"`
  * @group Middleware
  */
-export type ObserveSettings<TParameters extends unknown[] = unknown[], TReturn = unknown, TContext extends HookContext = HookContext> = {
+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?: OnStart<TParameters, TContext>;
+    onStart?: OnObserveStart<TParameters, TContext>;
     /**
      * Callback function that will be called when the underlying {@link Invokable | `Invokable`} is successfully called.
      */
-    onSuccess?: OnSuccess<TParameters, TReturn, TContext>;
+    onSuccess?: OnObserveSuccess<TParameters, TReturn, TContext>;
     /**
      * Callback function that will be called when the underlying {@link Invokable | `Invokable`} throws an error.
      */
-    onError?: OnError<TParameters, TContext>;
+    onError?: OnObserveError<TParameters, TContext>;
     /**
      * Callback function that will be called when the underlying {@link Invokable | `Invokable`} throws an error or is successfully called.
      */
-    onFinally?: OnFinally<TContext>;
+    onFinally?: OnObserveFinally<TContext>;
 };
 /**
  * The `observe` middleware tracks an async function's state and runs callbacks when it fails with an error or succeeds.
@@ -129,4 +127,4 @@ export type ObserveSettings<TParameters extends unknown[] = unknown[], TReturn =
  * // Will log the execution time and arguments
  * ```
  */
-export declare function observe<TParameters extends unknown[], TReturn, TContext extends HookContext>(settings: NoInfer<ObserveSettings<TParameters, TReturn, TContext>>): AsyncMiddlewareFn<TParameters, TReturn, TContext>;
+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

@@ -44,7 +44,7 @@ import { callInvokable, } from "../../../utilities/_module-exports.js";
  */
 export function observe(settings) {
     const { onStart = () => { }, onSuccess = () => { }, onError = () => { }, onFinally = () => { }, } = settings;
-    return async (args, next, context) => {
+    return async (args, next, { context }) => {
         const start = performance.now();
         try {
             callInvokable(onStart, {

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

@@ -1 +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;AA6HxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,UAAU,OAAO,CAKnB,QAAkE;IAElE,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,OAAO,EAAE,EAAE;QACjC,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"}
+{"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/retry.middleware.d.ts

@@ -3,12 +3,13 @@
  */
 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 Utilities
+ * @group Middlewares
  */
-export type OnExecutionAttemptData<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
+export type OnRetryAttemptData<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
     attempt: number;
     args: TParameters;
     context: TContext;
@@ -16,15 +17,15 @@ export type OnExecutionAttemptData<TParameters extends unknown[] = unknown[], TC
 /**
  *
  * IMPORT_PATH: `"@daiso-tech/core/async"`
- * @group Utilities
+ * @group Middlewares
  */
-export type OnExecutionAttempt<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = Invokable<[data: OnExecutionAttemptData<TParameters, TContext>]>;
+export type OnRetryAttempt<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = Invokable<[data: OnRetryAttemptData<TParameters, TContext>]>;
 /**
  *
  * IMPORT_PATH: `"@daiso-tech/core/async"`
- * @group Utilities
+ * @group Middlewares
  */
-export type OnRetryData<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
+export type OnRetryDelayData<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
     error: unknown;
     attempt: number;
     waitTime: TimeSpan;
@@ -34,21 +35,30 @@ export type OnRetryData<TParameters extends unknown[] = unknown[], TContext exte
 /**
  *
  * IMPORT_PATH: `"@daiso-tech/core/async"`
- * @group Utilities
+ * @group Middlewares
  */
-export type OnRetry<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = Invokable<[data: OnRetryData<TParameters, TContext>]>;
+export type OnRetryDelay<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = Invokable<[data: OnRetryDelayData<TParameters, TContext>]>;
 /**
  *
  * IMPORT_PATH: `"@daiso-tech/core/async"`
- * @group Utilities
+ * @group Middlewares
  */
-export type RetryPolicy = Invokable<[error: unknown, attempt: number], boolean>;
+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 Utilities
+ * @group Middlewares
  */
-export type RetrySettings<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = {
+export type RetrySettings<TParameters extends unknown[] = unknown[], TContext extends HookContext = HookContext> = RetryCallbacks<TParameters, TContext> & {
     /**
      * You can decide maximal times you can retry.
      * @default {4}
@@ -68,22 +78,10 @@ export type RetrySettings<TParameters extends unknown[] = unknown[], TContext ex
      *
      * @default
      * ```ts
-     * () => true
+     * (_error: unknown) => true
      * ```
      */
-    retryPolicy?: RetryPolicy;
-    /**
-     * Callback function that will be called before execution attempt.
-     */
-    onExecutionAttempt?: OnExecutionAttempt<TParameters, TContext>;
-    /**
-     * Callback function that will be called when the retry delay starts.
-     */
-    onRetryStart?: OnRetry<TParameters, TContext>;
-    /**
-     * Callback function that will be called when the retry delay ends and before the next execution attempt.
-     */
-    onRetryEnd?: OnRetry<TParameters, TContext>;
+    retryPolicy?: ErrorPolicy;
 };
 /**
  * The `retry` middleware enables automatic retries for all errors or specific errors, with configurable backoff policies.
@@ -91,22 +89,29 @@ export type RetrySettings<TParameters extends unknown[] = unknown[], TContext ex
  *
  * IMPORT_PATH: `"@daiso-tech/core/async"`
  * @group Middleware
- *
- * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @throws {RetryAsyncError} {@link RetryAsyncError}
  *
  * @example
  * ```ts
  * import { retry } from "@daiso-tech/core/async";
- * import { AsyncHooks } from "@daiso-tech/core/utilities";
+ * import { AsyncHooks, TimeSpan } from "@daiso-tech/core/utilities";
  *
- * await new AsyncHooks(async (url: string) => {
- *   const response = await fetch(url);
- *   const json = await response.json();
- *   if (!response.ok) {
- *     throw json
+ * 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;
+ *       }
+ *     }
  *   }
- *   return json;
- * }, retry({ maxAttempts: 8 })).invoke("URL_ENDPOINT");
+ * )
+ * .invoke("URL");
  * ```
  */
 export declare function retry<TParameters extends unknown[], TReturn, TContext extends HookContext>(settings?: NoInfer<RetrySettings<TParameters, TContext>>): AsyncMiddlewareFn<TParameters, TReturn, TContext>;