[Typescript-Anuglar] responseType not set on string response

[iljab]

Description

If response is a string, i get the following error when consuming the generated service:

Http failure during parsing for {API_URL}

Generated service:

return this.httpClient.get<string>(`${this.basePath}/accounts/${encodeURIComponent(String(accountName))}/account_name`,
            {
                withCredentials: this.configuration.withCredentials,
                headers: headers,
                observe: observe,
                reportProgress: reportProgress
            }
        );

If i add the line responseType: 'text' as 'json' to the options, everything works as expected.

Swagger-codegen version

2.3.1
2.4.0

Swagger declaration file content or url

"responses": {
"200": {
"description": "Returns account name for id",
"schema": {
"type": "string"
}
}
}

[andreypelykh]

Is there a workaround for specifying responseType without editing generated code by hands? Something like plugin that adds additional options for generated code? Thanks.

[andreypelykh]

How about an idea of using interceptor to add correct responseType? Does someone know better approach?

[chris-orchard]

@andreypelykh did you find another approach?

I've used a HttpInterceptor as a workaround as you'd considered doing. It works based on the accept header being correctly set (which seems to be the case in my apps generated code). I assume this could be adapted to other responseTypes as well if needed.

This then needs wiring in to your app.module.ts.

import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';

@Injectable()
export class HeaderAcceptsInterceptor implements HttpInterceptor {
  constructor() {}

  intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>> {
    // Workaround for this bug in swagger generated code: https://github.com/swagger-api/swagger-codegen/issues/8399
    if (request.headers.get('Accept') === 'text/csv' && request.responseType !== 'text') {
      // console.debug(`Changed responseType from '${request.responseType}' to 'text' for url ${request.url}`);
      request = request.clone({ responseType: 'text' });
    }

    return next.handle(request);
  }
}

[andreypelykh]

@chris-orchard We also could extend swagger generated service and override the method that needs the correct response type.

Then we can use extended service everywhere in the app.
This way you do not modify generated code but can fully customize some methods.

Thanks.

[ianzimmerman]

Currently running into this issue trying to return a .csv file from a FastApi endpoint.

The documentation shows the following for the response:

I believe the issue is that the response returns CSV for a 200, it returns a JSON for a 422 Validation error and the configuration.js will always prefer the JSON accept/content-type header for all responses:

    /**
     * Select the correct content-type to use for a request.
     * Uses {@link Configuration#isJsonMime} to determine the correct content-type.
     * If no content type is found return the first found type if the contentTypes is not empty
     * @param contentTypes - the array of content types that are available for selection
     * @returns the selected content-type or <code>undefined</code> if no selection could be made.
     */
    public selectHeaderContentType(contentTypes: string[]): string | undefined {
        if (contentTypes.length == 0) {
            return undefined;
        }

        let type = contentTypes.find(x => this.isJsonMime(x));
        if (type === undefined) {
            return contentTypes[0];
        }
        return type;
    }

  /**
   * Select the correct accept content-type to use for a request.
   * Uses {@link Configuration#isJsonMime} to determine the correct accept content-type.
   * If no content type is found return the first found type if the contentTypes is not empty
   * @param accepts - the array of content types that are available for selection.
   * @returns the selected content-type or <code>undefined</code> if no selection could be made.
   */
  public selectHeaderAccept(accepts: string[]): string | undefined {
      if (accepts.length == 0) {
          return undefined;
      }

      let type = accepts.find(x => this.isJsonMime(x));
      if (type === undefined) {
          return accepts[0];
      }
      return type;
  }

The generated service then will never use the accepted header for the 200 OK response and only use the JSON Type from the 422, incidentally, the "consumes" variable is not generated and not included in get-options:

        // to determine the Accept header
        let httpHeaderAccepts: string[] = [
            'text/csv',
            'application/json'
        ];
        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);
        if (httpHeaderAcceptSelected != undefined) {
            headers = headers.set('Accept', httpHeaderAcceptSelected);
        }

        // to determine the Content-Type header
        const consumes: string[] = [
        ];

        return this.httpClient.request<any>('get',`${this.basePath}/audits/${encodeURIComponent(String(auditId))}/export-csv`,
            {
                withCredentials: this.configuration.withCredentials,
                headers: headers,
                observe: observe,
                reportProgress: reportProgress
            }
        );

Currently the interceptor method is not working for me because the accept type is always returning as JSON.

I can solve the problem by changing

        let type = accepts.find(x => this.isJsonMime(x));
        if (type === undefined) {
            return accepts[0];
        }
        return type;

to

       return accepts[0];

Which needs to be done after every api generation.