responseType=text but json is parsed

[neg3ntropy]

Describe the bug

I want to get a response as string even if that comes as application/json. Parsing the response to an object is not required and not desired as the only thing I have to do with it is rewrite some urls and I am not sure of the content type the server will use.

To Reproduce

Server:

const http = require("http");
const server = http.createServer((req, res) => {
    res.writeHead(200, {"Content-Type": "application/json"});
    res.end("{\"doNotParse\": 1}");
});
server.listen(1234);

Client:

const axios = require("axios");   
axios.request({url: "http://localhost:1234/", responseType: "text"})
     .then(res => console.log("Type of data is %s", typeof res.data));

Outcome:

Type of data is object

Expected behavior
response data should be the string "{\"doNotParse\": 1}", the program would print:

Type of data is string

Environment:

• Axios 0.19.2
• Fedora 31
• Node 12

Additional context/Screenshots
Setting transformResponse: (data) => data appears to do the trick, regardless of responseType.

[determin1st]

What you think should be the default content type returned in the case of this option enabled:

• ArrayBuffer
• String

I'm asking, because in browser, for example, may be Response object which is the "raw" response, or any of these

[neg3ntropy]

I am not familiar with browsers, but it looks like responseType=text should result in strings. For ArrayBuffer there's responseType=arraybuffer.

[determin1st]

did you try using axios config with responseType option? (pre-created instance)

[neg3ntropy]

you can see that from the code posted "to reproduce".

[determin1st]

oke, tested..

    axios({
      url: "http://localhost:1234/",
      //responseType: "text",
      transformResponse: []
    }).then(function(res) {
      console.log("Type of data is %s", typeof res.data);
    });

that happens because of transformResponse has one function which transforms from JSON, so you may make it empty to opt-out of this behaviour. maybe it should clean-up the default JSON thing, im not sure how responseType option should operate...

[sagar-gavhane]

What do you think about this?

const instance = axios.create({
  baseURL: 'https://jsonplaceholder.typicode.com/',
  transformResponse: (data) => JSON.stringify(data)
});

const fetchUserInStringType = async () => {
  const response = await instance.get('/users/1')  
  console.log(response.data)
}

fetchUserInStringType()

[determin1st]

the main thought here, is why one option is choosen against another. should they depend on each other and stuff..

[liesauer]

+1

const response = await axios.get(url, {
    responseType: 'text',
    transformResponse: [data => data],
});
// get html string or others string
console.log(response.data);

works for me, but honestly, this is really bad...setting responseType to text suppose to return string but do nothing actually and keep trying to parse as json with no reason...

[jasonsaayman]

Fixed with #3688

[KaKi87]

Hello,

Fixed with #3688

@jasonsaayman Are you talking about OP's issue ?
Because I'm still experiencing it in v0.27.2 and forced to use @liesauer's workaround.

Thanks

[yozachar]

Hi, is this behaviour expected?

// standard
import fs from "fs";
import path from "path";

// external
import axios, { AxiosError } from "axios";

async function request() {
  const url = "https://api.github.com";
  const localFileName = path.join(__dirname, "response.txt");

  try {
    const response = await axios.get(url, {
      responseType: "text",
      transformResponse: [(data) => data],
    });
    fs.writeFile(localFileName, response.data, (fsError) => {
      if (fsError) {
        throw fsError;
      }
    });
  } catch (error) {
    if (error instanceof AxiosError) {
      console.error(error.response.status, error.response.statusText);
    } else {
      console.error(error);
    }
    return null;
  }
}

request();

JSON data gets written to a text file. I want to accept only files like at https://www.gnu.org/licenses/gpl-3.0.txt

@liesauer workaround doesn't seem to work.