@azure-net/kit 1.4.0 → 1.4.2

package/dist/core/delivery/injectableDependencies/AsyncHelpers.d.ts

@@ -5,8 +5,8 @@ export interface AsyncActionResponse<T, D = unknown, CustomErrorField = never> {
     error?: AppError<D, CustomErrorField>;
 }
 type ActionOrThunk<Res> = Promise<Res> | (() => Promise<Res>);
-export declare const createAsyncHelpers: <Custom = unknown>(opts?: {
-    parseError?: ReturnType<typeof createErrorParser<unknown, Custom>>;
+export declare const createAsyncHelpers: <BaseError = unknown, Custom = unknown>(opts?: {
+    parseError?: ReturnType<typeof createErrorParser<BaseError, Custom>>;
 }) => {
     createAsyncAction: <Res = unknown, Req = unknown>(action: ActionOrThunk<Res>, args?: {
         beforeSend?: (next: () => void, abort: () => void) => void | Promise<void>;
@@ -18,6 +18,7 @@ export declare const createAsyncHelpers: <Custom = unknown>(opts?: {
             onAbort?: () => void;
         };
         fallbackResponse?: Res;
+        maxRetries?: number;
     }) => Promise<AsyncActionResponse<Res, Req, Custom>>;
     createAsyncResource: <Res, Req_1 = unknown>(action: ActionOrThunk<Res>, args?: {
         beforeSend?: (next: () => void, abort: () => void) => void | Promise<void>;
@@ -29,6 +30,7 @@ export declare const createAsyncHelpers: <Custom = unknown>(opts?: {
             onAbort?: () => void;
         };
         fallbackResponse?: Res;
+        maxRetries?: number;
     }) => Promise<Res>;
 };
 export {};

package/dist/core/delivery/injectableDependencies/AsyncHelpers.js

@@ -42,14 +42,32 @@ export const createAsyncHelpers = (opts) => {
                 };
             }
         }
-        try {
+        const maxRetries = args?.maxRetries ?? 3;
+        let retries = 0;
+        const req = async (isRetry = false) => {
+            if (isRetry) {
+                retries++;
+                if (retries > maxRetries) {
+                    return Promise.reject(Error('Max retries reached'));
+                }
+            }
             const response = await Promise.resolve(typeof action === 'function' ? action() : action);
             const result = { response, success: true };
             await args?.onSuccess?.(result);
             return result;
+        };
+        try {
+            return await req();
         }
         catch (err) {
-            const error = errorParser(err);
+            let retryResult;
+            const retry = async () => await req(true)
+                .then((res) => (retryResult = res))
+                .catch(() => undefined);
+            const error = await errorParser(err, async () => await retry());
+            if (retryResult) {
+                return retryResult;
+            }
             const { bus } = AppEvents();
             bus.publish('OnAsyncHelperError', error);
             const result = { error, response: args?.fallbackResponse, success: false };
@@ -84,13 +102,31 @@ export const createAsyncHelpers = (opts) => {
                 return args.fallbackResponse;
             }
         }
-        try {
+        const maxRetries = args?.maxRetries ?? 3;
+        let retries = 0;
+        const req = async (isRetry = false) => {
+            if (isRetry) {
+                retries++;
+                if (retries > maxRetries) {
+                    return Promise.reject(Error('Max retries reached'));
+                }
+            }
             const response = await Promise.resolve(typeof action === 'function' ? action() : action);
             await args?.onSuccess?.(response);
             return response;
+        };
+        try {
+            return await req();
         }
         catch (err) {
-            const error = errorParser(err);
+            let retryResult;
+            const retry = async () => await req(true)
+                .then((res) => (retryResult = res))
+                .catch(() => undefined);
+            const error = await errorParser(err, async () => await retry());
+            if (retryResult) {
+                return retryResult;
+            }
             const { bus } = AppEvents();
             bus.publish('OnAsyncHelperError', error);
             await args?.onError?.(error);

package/dist/core/delivery/injectableDependencies/ErrorHandler.d.ts

@@ -8,13 +8,14 @@ export interface AppError<T = unknown, CustomErrorField = never> {
     status?: number;
     original?: HttpServiceError<T> | SchemaFail<T> | Error;
     custom?: CustomErrorField;
+    retry?: () => unknown;
 }
 export type ErrorType<T = unknown> = Error | HttpServiceError<T> | SchemaFail<T>;
-export declare const baseParseHttpError: <T = unknown, D = never>(error: HttpServiceError<T>) => AppError<T, D>;
-export declare const baseParseSchemaError: <SchemaData = unknown, D = never>(error: SchemaFail<SchemaData>) => AppError<SchemaData, D>;
-export declare const baseParseBaseError: <D = never>(error: Error) => AppError<never, D>;
+export declare const baseParseHttpError: <T = unknown, D = never>(error: HttpServiceError<T>, retry?: () => unknown) => Promise<AppError<T, D>>;
+export declare const baseParseSchemaError: <SchemaData = unknown, D = never>(error: SchemaFail<SchemaData>, retry?: () => unknown) => Promise<AppError<SchemaData, D>>;
+export declare const baseParseBaseError: <D = never>(error: Error, retry?: () => unknown) => Promise<AppError<never, D>>;
 export declare const createErrorParser: <BaseError = unknown, Custom = unknown>(parsers?: {
     parseBaseError?: typeof baseParseBaseError<Custom>;
     parseHttpError?: typeof baseParseHttpError<BaseError, Custom>;
     parseSchemaError?: typeof baseParseSchemaError<BaseError, Custom>;
-}) => (<T = unknown>(error: ErrorType<BaseError>) => AppError<T, Custom>);
+}) => (<T = unknown>(error: ErrorType<BaseError>, retry?: () => unknown) => Promise<AppError<T, Custom>>);

package/dist/core/delivery/injectableDependencies/ErrorHandler.js

@@ -1,39 +1,45 @@
 import { HttpServiceError } from '../../infra/httpService/index.js';
 import { SchemaFail } from '../schema/index.js';
-export const baseParseHttpError = (error) => {
-    return {
+export const baseParseHttpError = async (error, retry) => {
+    const err = {
         type: 'http',
         message: error.message ?? 'unexpected error',
         status: error.status ?? 500,
-        original: error
+        original: error,
+        retry
     };
+    return { ...err, retry: undefined, original: undefined };
 };
-export const baseParseSchemaError = (error) => {
-    return {
+export const baseParseSchemaError = async (error, retry) => {
+    const err = {
         type: 'schema',
         message: 'schema validation error',
         status: 422,
         fields: error.getErrors(),
-        original: error
+        original: error,
+        retry
     };
+    return { ...err, retry: undefined, original: undefined };
 };
-export const baseParseBaseError = (error) => {
-    return {
+export const baseParseBaseError = async (error, retry) => {
+    const err = {
         type: 'app',
         message: error.message,
-        original: error
+        original: error,
+        retry
     };
+    return { ...err, retry: undefined, original: undefined };
 };
 export const createErrorParser = (parsers) => {
-    return (error) => {
+    return async (error, retry) => {
         const { parseBaseError = baseParseBaseError, parseHttpError = baseParseHttpError, parseSchemaError = baseParseSchemaError } = parsers ?? {};
         switch (true) {
             case error instanceof HttpServiceError:
-                return parseHttpError(error);
+                return (await parseHttpError(error, retry));
             case error instanceof SchemaFail:
-                return parseSchemaError(error);
+                return (await parseSchemaError(error, retry));
             default:
-                return parseBaseError(error);
+                return (await parseBaseError(error, retry));
         }
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/kit",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "files": [
     "dist",
     "!dist/**/*.test.*",