node.js axios descarga el flujo de archivos y escribe el archivo

quiero descargar un archivo pdf con axios y guardar en el disco (lado del servidor) con fs.writeFileYo he tratado:

axios.get('https://xxx/my.pdf', {responseType: 'blob'}).then(response => {
    fs.writeFile('/temp/my.pdf', response.data, (err) => {
        if (err) throw err;
        console.log('The file has been saved!');
    });
});

el archivo se guarda pero el contenido está roto…

¿Cómo guardo correctamente el archivo?

En realidad, creo que la respuesta previamente aceptada tiene algunas fallas, ya que no manejará el flujo de escritura correctamente, por lo que si llama “entonces ()” después de que Axios le haya dado la respuesta, terminará con un archivo parcialmente descargado.

Esta es una solución más apropiada cuando se descargan archivos un poco más grandes:

export async function downloadFile(fileUrl: string, outputLocationPath: string) {
  const writer = createWriteStream(outputLocationPath);

  return Axios({
    method: 'get',
    url: fileUrl,
    responseType: 'stream',
  }).then(response => {

    //ensure that the user can call `then()` only when the file has
    //been downloaded entirely.

    return new Promise((resolve, reject) => {
      response.data.pipe(writer);
      let error = null;
      writer.on('error', err => {
        error = err;
        writer.close();
        reject(err);
      });
      writer.on('close', () => {
        if (!error) {
          resolve(true);
        }
        //no need to call the reject here, as it will have been called in the
        //'error' stream;
      });
    });
  });
}

De esta manera, puede llamar downloadFile()llamar then() en la promesa devuelta, y asegurándose de que el archivo descargado haya completado el procesamiento.

O, si usa una versión más moderna de NodeJS, puede probar esto en su lugar:

import * as stream from 'stream';
import { promisify } from 'util';

const finished = promisify(stream.finished);

export async function downloadFile(fileUrl: string, outputLocationPath: string): Promise<any> {
  const writer = createWriteStream(outputLocationPath);
  return Axios({
    method: 'get',
    url: fileUrl,
    responseType: 'stream',
  }).then(response => {
    response.data.pipe(writer);
    return finished(writer); //this is a Promise
  });
}

Simplemente puede usar response.data.pipe y fs.createWriteStream canalizar la respuesta al archivo

axios({
    method: "get",
    url: "https://xxx/my.pdf",
    responseType: "stream"
}).then(function (response) {
    response.data.pipe(fs.createWriteStream("/temp/my.pdf"));
});

El problema con el archivo roto se debe a contrapresión en flujos de nodos. Puede encontrar este enlace útil para leer: https://nodejs.org/es/docs/guides/backpressuring-in-streams/

No soy realmente un fanático del uso de objetos declarativos básicos de Promise en códigos JS, ya que siento que contamina la lógica central real y hace que el código sea difícil de leer. Además, debe aprovisionar controladores y oyentes de eventos para asegurarse de que el código esté completo.

A continuación se proporciona un enfoque más limpio sobre la misma lógica que propone la respuesta aceptada. Utiliza los conceptos de tuberías de corriente.

const util = require('util');
const stream = require('stream');
const pipeline = util.promisify(stream.pipeline);

const downloadFile = async () => {
  try {
    const request = await axios.get('https://xxx/my.pdf', {
      responseType: 'stream',
    });
    await pipeline(request.data, fs.createWriteStream('/temp/my.pdf'));
    console.log('download pdf pipeline successful');   
  } catch (error) {
    console.error('download pdf pipeline failed', error);
  }
}

exports.downloadFile = downloadFile

Espero que encuentres esto útil.

// This works perfectly well! 
const axios = require('axios'); 

axios.get('http://www.sclance.com/pngs/png-file-download/png_file_download_1057991.png', {responseType: "stream"} )  
.then(response => {  
// Saving file to working directory  
    response.data.pipe(fs.createWriteStream("todays_picture.png"));  
})  
    .catch(error => {  
    console.log(error);  
});  

sistema de archivos de nodo writeFile codifica los datos de forma predeterminada en UTF8. que podría ser un problema en su caso.

Intente configurar su codificación en null y omita la codificación de los datos recibidos:

fs.writeFile('/temp/my.pdf', response.data, {encoding: null}, (err) => {...}

también puede decalre la codificación como una cadena (en lugar de un objeto de opciones) si solo declara la codificación y ninguna otra opción. la cadena se manejará como valor de codificación. como tal:

fs.writeFile('/temp/my.pdf', response.data, 'null', (err) => {...}

más leer en fileSystem API write_file

El siguiente código tomado de https://gist.github.com/senthilmpro/072f5e69bdef4baffc8442c7e696f4eb?permalink_comment_id=3620639#gistcomment-3620639 trabajó para mi

const res = await axios.get(url, { responseType: 'arraybuffer' });
fs.writeFileSync(downloadDestination, res.data);

Lo he intentado, y estoy seguro de que usando response.data.pipe y fs.createWriteStream puede trabajar.

Además, quiero agregar mi situación y solución.

Situación:

• usando koa para desarrollar un servidor node.js
• usando axios para obtener un pdf a través de url
• usando pdf-parse para analizar el pdf
• extraiga información de pdf y devuélvala como json al navegador

Solución:

const Koa = require('koa');
const app = new Koa();
const axios = require('axios')
const fs = require("fs")
const pdf = require('pdf-parse');
const utils = require('./utils')

app.listen(process.env.PORT || 3000)

app.use(async (ctx, next) => {
      let url="https://path/name.pdf"
      let resp = await axios({
          url: encodeURI(url),
          responseType: 'arraybuffer'
        })

        let data = await pdf(resp.data)

        ctx.body = {
            phone: utils.getPhone(data.text),
            email: utils.getEmail(data.text),
        }
})

En esta solución, no necesita escribir y leer archivos, es más eficiente.