support error handling in middleware (#12716)

modules/openapi-generator/src/main/resources/typescript-fetch/runtime.mustache

@@ -166,7 +166,25 @@ export class BaseAPI {
                 }) || fetchParams;
             }
         }
-        let response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        let response = undefined;
+        try {
+            response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        } catch (e) {
+            for (const middleware of this.middleware) {
+                if (middleware.onError) {
+                    response = await middleware.onError({
+                        fetch: this.fetchApi,
+                        url: fetchParams.url,
+                        init: fetchParams.init,
+                        error: e,
+                        response: response ? response.clone() : undefined,
+                    }) || response;
+                }
+            }
+            if (response !== undefined) {
+                throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
+            }
+        }
         for (const middleware of this.middleware) {
             if (middleware.post) {
                 response = await middleware.post({
@@ -207,6 +225,13 @@ export class ResponseError extends Error {
     }
 }
 
+export class FetchError extends Error {
+    name: "FetchError" = "FetchError";
+    constructor(public cause: unknown, msg?: string) {
+        super(msg);
+    }
+}
+
 export class RequiredError extends Error {
     name: "RequiredError" = "RequiredError";
     constructor(public field: string, msg?: string) {
@@ -315,9 +340,18 @@ export interface ResponseContext {
     response: Response;
 }
 
+export interface ErrorContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    error: unknown;
+    response?: Response;
+}
+
 export interface Middleware {
     pre?(context: RequestContext): Promise<FetchParams | void>;
     post?(context: ResponseContext): Promise<Response | void>;
+    onError?(context: ErrorContext): Promise<Response | void>;
 }
 
 export interface ApiResponse<T> {

samples/client/petstore/typescript-fetch/builds/default-v3.0/runtime.ts

@@ -177,7 +177,25 @@ export class BaseAPI {
                 }) || fetchParams;
             }
         }
-        let response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        let response = undefined;
+        try {
+            response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        } catch (e) {
+            for (const middleware of this.middleware) {
+                if (middleware.onError) {
+                    response = await middleware.onError({
+                        fetch: this.fetchApi,
+                        url: fetchParams.url,
+                        init: fetchParams.init,
+                        error: e,
+                        response: response ? response.clone() : undefined,
+                    }) || response;
+                }
+            }
+            if (response !== undefined) {
+                throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
+            }
+        }
         for (const middleware of this.middleware) {
             if (middleware.post) {
                 response = await middleware.post({
@@ -218,6 +236,13 @@ export class ResponseError extends Error {
     }
 }
 
+export class FetchError extends Error {
+    name: "FetchError" = "FetchError";
+    constructor(public cause: unknown, msg?: string) {
+        super(msg);
+    }
+}
+
 export class RequiredError extends Error {
     name: "RequiredError" = "RequiredError";
     constructor(public field: string, msg?: string) {
@@ -322,9 +347,18 @@ export interface ResponseContext {
     response: Response;
 }
 
+export interface ErrorContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    error: unknown;
+    response?: Response;
+}
+
 export interface Middleware {
     pre?(context: RequestContext): Promise<FetchParams | void>;
     post?(context: ResponseContext): Promise<Response | void>;
+    onError?(context: ErrorContext): Promise<Response | void>;
 }
 
 export interface ApiResponse<T> {

samples/client/petstore/typescript-fetch/builds/default/runtime.ts

@@ -177,7 +177,25 @@ export class BaseAPI {
                 }) || fetchParams;
             }
         }
-        let response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        let response = undefined;
+        try {
+            response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        } catch (e) {
+            for (const middleware of this.middleware) {
+                if (middleware.onError) {
+                    response = await middleware.onError({
+                        fetch: this.fetchApi,
+                        url: fetchParams.url,
+                        init: fetchParams.init,
+                        error: e,
+                        response: response ? response.clone() : undefined,
+                    }) || response;
+                }
+            }
+            if (response !== undefined) {
+                throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
+            }
+        }
         for (const middleware of this.middleware) {
             if (middleware.post) {
                 response = await middleware.post({
@@ -218,6 +236,13 @@ export class ResponseError extends Error {
     }
 }
 
+export class FetchError extends Error {
+    name: "FetchError" = "FetchError";
+    constructor(public cause: unknown, msg?: string) {
+        super(msg);
+    }
+}
+
 export class RequiredError extends Error {
     name: "RequiredError" = "RequiredError";
     constructor(public field: string, msg?: string) {
@@ -322,9 +347,18 @@ export interface ResponseContext {
     response: Response;
 }
 
+export interface ErrorContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    error: unknown;
+    response?: Response;
+}
+
 export interface Middleware {
     pre?(context: RequestContext): Promise<FetchParams | void>;
     post?(context: ResponseContext): Promise<Response | void>;
+    onError?(context: ErrorContext): Promise<Response | void>;
 }
 
 export interface ApiResponse<T> {

samples/client/petstore/typescript-fetch/builds/enum/runtime.ts

@@ -177,7 +177,25 @@ export class BaseAPI {
                 }) || fetchParams;
             }
         }
-        let response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        let response = undefined;
+        try {
+            response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        } catch (e) {
+            for (const middleware of this.middleware) {
+                if (middleware.onError) {
+                    response = await middleware.onError({
+                        fetch: this.fetchApi,
+                        url: fetchParams.url,
+                        init: fetchParams.init,
+                        error: e,
+                        response: response ? response.clone() : undefined,
+                    }) || response;
+                }
+            }
+            if (response !== undefined) {
+                throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
+            }
+        }
         for (const middleware of this.middleware) {
             if (middleware.post) {
                 response = await middleware.post({
@@ -218,6 +236,13 @@ export class ResponseError extends Error {
     }
 }
 
+export class FetchError extends Error {
+    name: "FetchError" = "FetchError";
+    constructor(public cause: unknown, msg?: string) {
+        super(msg);
+    }
+}
+
 export class RequiredError extends Error {
     name: "RequiredError" = "RequiredError";
     constructor(public field: string, msg?: string) {
@@ -322,9 +347,18 @@ export interface ResponseContext {
     response: Response;
 }
 
+export interface ErrorContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    error: unknown;
+    response?: Response;
+}
+
 export interface Middleware {
     pre?(context: RequestContext): Promise<FetchParams | void>;
     post?(context: ResponseContext): Promise<Response | void>;
+    onError?(context: ErrorContext): Promise<Response | void>;
 }
 
 export interface ApiResponse<T> {

samples/client/petstore/typescript-fetch/builds/es6-target/src/runtime.ts

@@ -177,7 +177,25 @@ export class BaseAPI {
                 }) || fetchParams;
             }
         }
-        let response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        let response = undefined;
+        try {
+            response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        } catch (e) {
+            for (const middleware of this.middleware) {
+                if (middleware.onError) {
+                    response = await middleware.onError({
+                        fetch: this.fetchApi,
+                        url: fetchParams.url,
+                        init: fetchParams.init,
+                        error: e,
+                        response: response ? response.clone() : undefined,
+                    }) || response;
+                }
+            }
+            if (response !== undefined) {
+                throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
+            }
+        }
         for (const middleware of this.middleware) {
             if (middleware.post) {
                 response = await middleware.post({
@@ -218,6 +236,13 @@ export class ResponseError extends Error {
     }
 }
 
+export class FetchError extends Error {
+    name: "FetchError" = "FetchError";
+    constructor(public cause: unknown, msg?: string) {
+        super(msg);
+    }
+}
+
 export class RequiredError extends Error {
     name: "RequiredError" = "RequiredError";
     constructor(public field: string, msg?: string) {
@@ -322,9 +347,18 @@ export interface ResponseContext {
     response: Response;
 }
 
+export interface ErrorContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    error: unknown;
+    response?: Response;
+}
+
 export interface Middleware {
     pre?(context: RequestContext): Promise<FetchParams | void>;
     post?(context: ResponseContext): Promise<Response | void>;
+    onError?(context: ErrorContext): Promise<Response | void>;
 }
 
 export interface ApiResponse<T> {

samples/client/petstore/typescript-fetch/builds/multiple-parameters/runtime.ts

@@ -177,7 +177,25 @@ export class BaseAPI {
                 }) || fetchParams;
             }
         }
-        let response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        let response = undefined;
+        try {
+            response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        } catch (e) {
+            for (const middleware of this.middleware) {
+                if (middleware.onError) {
+                    response = await middleware.onError({
+                        fetch: this.fetchApi,
+                        url: fetchParams.url,
+                        init: fetchParams.init,
+                        error: e,
+                        response: response ? response.clone() : undefined,
+                    }) || response;
+                }
+            }
+            if (response !== undefined) {
+                throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
+            }
+        }
         for (const middleware of this.middleware) {
             if (middleware.post) {
                 response = await middleware.post({
@@ -218,6 +236,13 @@ export class ResponseError extends Error {
     }
 }
 
+export class FetchError extends Error {
+    name: "FetchError" = "FetchError";
+    constructor(public cause: unknown, msg?: string) {
+        super(msg);
+    }
+}
+
 export class RequiredError extends Error {
     name: "RequiredError" = "RequiredError";
     constructor(public field: string, msg?: string) {
@@ -322,9 +347,18 @@ export interface ResponseContext {
     response: Response;
 }
 
+export interface ErrorContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    error: unknown;
+    response?: Response;
+}
+
 export interface Middleware {
     pre?(context: RequestContext): Promise<FetchParams | void>;
     post?(context: ResponseContext): Promise<Response | void>;
+    onError?(context: ErrorContext): Promise<Response | void>;
 }
 
 export interface ApiResponse<T> {

samples/client/petstore/typescript-fetch/builds/prefix-parameter-interfaces/src/runtime.ts

@@ -177,7 +177,25 @@ export class BaseAPI {
                 }) || fetchParams;
             }
         }
-        let response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        let response = undefined;
+        try {
+            response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        } catch (e) {
+            for (const middleware of this.middleware) {
+                if (middleware.onError) {
+                    response = await middleware.onError({
+                        fetch: this.fetchApi,
+                        url: fetchParams.url,
+                        init: fetchParams.init,
+                        error: e,
+                        response: response ? response.clone() : undefined,
+                    }) || response;
+                }
+            }
+            if (response !== undefined) {
+                throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
+            }
+        }
         for (const middleware of this.middleware) {
             if (middleware.post) {
                 response = await middleware.post({
@@ -218,6 +236,13 @@ export class ResponseError extends Error {
     }
 }
 
+export class FetchError extends Error {
+    name: "FetchError" = "FetchError";
+    constructor(public cause: unknown, msg?: string) {
+        super(msg);
+    }
+}
+
 export class RequiredError extends Error {
     name: "RequiredError" = "RequiredError";
     constructor(public field: string, msg?: string) {
@@ -322,9 +347,18 @@ export interface ResponseContext {
     response: Response;
 }
 
+export interface ErrorContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    error: unknown;
+    response?: Response;
+}
+
 export interface Middleware {
     pre?(context: RequestContext): Promise<FetchParams | void>;
     post?(context: ResponseContext): Promise<Response | void>;
+    onError?(context: ErrorContext): Promise<Response | void>;
 }
 
 export interface ApiResponse<T> {

samples/client/petstore/typescript-fetch/builds/sagas-and-records/src/runtime.ts

@@ -177,7 +177,25 @@ export class BaseAPI {
                 }) || fetchParams;
             }
         }
-        let response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        let response = undefined;
+        try {
+            response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        } catch (e) {
+            for (const middleware of this.middleware) {
+                if (middleware.onError) {
+                    response = await middleware.onError({
+                        fetch: this.fetchApi,
+                        url: fetchParams.url,
+                        init: fetchParams.init,
+                        error: e,
+                        response: response ? response.clone() : undefined,
+                    }) || response;
+                }
+            }
+            if (response !== undefined) {
+                throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
+            }
+        }
         for (const middleware of this.middleware) {
             if (middleware.post) {
                 response = await middleware.post({
@@ -218,6 +236,13 @@ export class ResponseError extends Error {
     }
 }
 
+export class FetchError extends Error {
+    name: "FetchError" = "FetchError";
+    constructor(public cause: unknown, msg?: string) {
+        super(msg);
+    }
+}
+
 export class RequiredError extends Error {
     name: "RequiredError" = "RequiredError";
     constructor(public field: string, msg?: string) {
@@ -322,9 +347,18 @@ export interface ResponseContext {
     response: Response;
 }
 
+export interface ErrorContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    error: unknown;
+    response?: Response;
+}
+
 export interface Middleware {
     pre?(context: RequestContext): Promise<FetchParams | void>;
     post?(context: ResponseContext): Promise<Response | void>;
+    onError?(context: ErrorContext): Promise<Response | void>;
 }
 
 export interface ApiResponse<T> {

samples/client/petstore/typescript-fetch/builds/with-interfaces/runtime.ts

@@ -177,7 +177,25 @@ export class BaseAPI {
                 }) || fetchParams;
             }
         }
-        let response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        let response = undefined;
+        try {
+            response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        } catch (e) {
+            for (const middleware of this.middleware) {
+                if (middleware.onError) {
+                    response = await middleware.onError({
+                        fetch: this.fetchApi,
+                        url: fetchParams.url,
+                        init: fetchParams.init,
+                        error: e,
+                        response: response ? response.clone() : undefined,
+                    }) || response;
+                }
+            }
+            if (response !== undefined) {
+                throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
+            }
+        }
         for (const middleware of this.middleware) {
             if (middleware.post) {
                 response = await middleware.post({
@@ -218,6 +236,13 @@ export class ResponseError extends Error {
     }
 }
 
+export class FetchError extends Error {
+    name: "FetchError" = "FetchError";
+    constructor(public cause: unknown, msg?: string) {
+        super(msg);
+    }
+}
+
 export class RequiredError extends Error {
     name: "RequiredError" = "RequiredError";
     constructor(public field: string, msg?: string) {
@@ -322,9 +347,18 @@ export interface ResponseContext {
     response: Response;
 }
 
+export interface ErrorContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    error: unknown;
+    response?: Response;
+}
+
 export interface Middleware {
     pre?(context: RequestContext): Promise<FetchParams | void>;
     post?(context: ResponseContext): Promise<Response | void>;
+    onError?(context: ErrorContext): Promise<Response | void>;
 }
 
 export interface ApiResponse<T> {

samples/client/petstore/typescript-fetch/builds/with-npm-version/src/runtime.ts

@@ -177,7 +177,25 @@ export class BaseAPI {
                 }) || fetchParams;
             }
         }
-        let response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        let response = undefined;
+        try {
+            response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        } catch (e) {
+            for (const middleware of this.middleware) {
+                if (middleware.onError) {
+                    response = await middleware.onError({
+                        fetch: this.fetchApi,
+                        url: fetchParams.url,
+                        init: fetchParams.init,
+                        error: e,
+                        response: response ? response.clone() : undefined,
+                    }) || response;
+                }
+            }
+            if (response !== undefined) {
+                throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
+            }
+        }
         for (const middleware of this.middleware) {
             if (middleware.post) {
                 response = await middleware.post({
@@ -218,6 +236,13 @@ export class ResponseError extends Error {
     }
 }
 
+export class FetchError extends Error {
+    name: "FetchError" = "FetchError";
+    constructor(public cause: unknown, msg?: string) {
+        super(msg);
+    }
+}
+
 export class RequiredError extends Error {
     name: "RequiredError" = "RequiredError";
     constructor(public field: string, msg?: string) {
@@ -322,9 +347,18 @@ export interface ResponseContext {
     response: Response;
 }
 
+export interface ErrorContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    error: unknown;
+    response?: Response;
+}
+
 export interface Middleware {
     pre?(context: RequestContext): Promise<FetchParams | void>;
     post?(context: ResponseContext): Promise<Response | void>;
+    onError?(context: ErrorContext): Promise<Response | void>;
 }
 
 export interface ApiResponse<T> {

samples/client/petstore/typescript-fetch/builds/with-string-enums/runtime.ts

@@ -177,7 +177,25 @@ export class BaseAPI {
                 }) || fetchParams;
             }
         }
-        let response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        let response = undefined;
+        try {
+            response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        } catch (e) {
+            for (const middleware of this.middleware) {
+                if (middleware.onError) {
+                    response = await middleware.onError({
+                        fetch: this.fetchApi,
+                        url: fetchParams.url,
+                        init: fetchParams.init,
+                        error: e,
+                        response: response ? response.clone() : undefined,
+                    }) || response;
+                }
+            }
+            if (response !== undefined) {
+                throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
+            }
+        }
         for (const middleware of this.middleware) {
             if (middleware.post) {
                 response = await middleware.post({
@@ -218,6 +236,13 @@ export class ResponseError extends Error {
     }
 }
 
+export class FetchError extends Error {
+    name: "FetchError" = "FetchError";
+    constructor(public cause: unknown, msg?: string) {
+        super(msg);
+    }
+}
+
 export class RequiredError extends Error {
     name: "RequiredError" = "RequiredError";
     constructor(public field: string, msg?: string) {
@@ -322,9 +347,18 @@ export interface ResponseContext {
     response: Response;
 }
 
+export interface ErrorContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    error: unknown;
+    response?: Response;
+}
+
 export interface Middleware {
     pre?(context: RequestContext): Promise<FetchParams | void>;
     post?(context: ResponseContext): Promise<Response | void>;
+    onError?(context: ErrorContext): Promise<Response | void>;
 }
 
 export interface ApiResponse<T> {

samples/client/petstore/typescript-fetch/builds/without-runtime-checks/src/runtime.ts

@@ -177,7 +177,25 @@ export class BaseAPI {
                 }) || fetchParams;
             }
         }
-        let response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        let response = undefined;
+        try {
+            response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+        } catch (e) {
+            for (const middleware of this.middleware) {
+                if (middleware.onError) {
+                    response = await middleware.onError({
+                        fetch: this.fetchApi,
+                        url: fetchParams.url,
+                        init: fetchParams.init,
+                        error: e,
+                        response: response ? response.clone() : undefined,
+                    }) || response;
+                }
+            }
+            if (response !== undefined) {
+                throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
+            }
+        }
         for (const middleware of this.middleware) {
             if (middleware.post) {
                 response = await middleware.post({
@@ -218,6 +236,13 @@ export class ResponseError extends Error {
     }
 }
 
+export class FetchError extends Error {
+    name: "FetchError" = "FetchError";
+    constructor(public cause: unknown, msg?: string) {
+        super(msg);
+    }
+}
+
 export class RequiredError extends Error {
     name: "RequiredError" = "RequiredError";
     constructor(public field: string, msg?: string) {
@@ -312,9 +337,18 @@ export interface ResponseContext {
     response: Response;
 }
 
+export interface ErrorContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    error: unknown;
+    response?: Response;
+}
+
 export interface Middleware {
     pre?(context: RequestContext): Promise<FetchParams | void>;
     post?(context: ResponseContext): Promise<Response | void>;
+    onError?(context: ErrorContext): Promise<Response | void>;
 }
 
 export interface ApiResponse<T> {