Download File using axios : Node.js program

download-file-axios-nodejs.js

'use strict'

const Fs = require('fs')  
const Path = require('path')  
const Axios = require('axios')

async function downloadImage () {

  const url = 'https://unsplash.com/photos/AaEQmoufHLk/download?force=true'
  const path = Path.resolve(__dirname, 'images', 'code1.jpg')

  // axios image download with response type "stream"
  const response = await Axios({
    method: 'GET',
    url: url,
    responseType: 'stream'
  })

  // pipe the result stream into a file on disc
  response.data.pipe(Fs.createWriteStream(path))

  // return a promise and resolve when download finishes
  return new Promise((resolve, reject) => {
    response.data.on('end', () => {
      resolve()
    })

    response.data.on('error', () => {
      reject()
    })
  })

}

async function Main(){
    const data = await downloadImage();
    console.log("DATA ", data);
}

Main();

if you use await, don't use then

Sure. Updated the code.

Isn't it better to call resolve() at the end of writing to disk?

const writer = Fs.createWriteStream(path)
...
response.data.pipe(writer)
...
return new Promise((resolve, reject) => {
    writer.on('finish', resolve)
    writer.on('error', reject)
  })

Isn't it better to call resolve() at the end of writing to disk?

const writer = Fs.createWriteStream(path)
...
response.data.pipe(writer)
...
return new Promise((resolve, reject) => {
    writer.on('finish', resolve)
    writer.on('error', reject)
  })

I agree with you. In the shown example the promise is resolved when the file finishes download.
But in your example the promise is resolved when BOTH

• the file finished download AND

• the file is successfully written to the new path on disk

If u don't want to use streams you can set responseType: "arraybuffer" like this

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

Thx friend. This snippet rly helped me :)

Is it possible to do this all in memory instead of writing a file?

Is it possible to do this all in memory instead of writing a file?

instead of doing a response.pipe into a file..
use a library like https://github.com/paulja/memory-streams-js and write your streams into memory.

Isn't it better to call resolve() at the end of writing to disk?

const writer = Fs.createWriteStream(path)
...
response.data.pipe(writer)
...
return new Promise((resolve, reject) => {
    writer.on('finish', resolve)
    writer.on('error', reject)
  })

This was great! I've modified this a little. Here is my module:

const fs = require('fs')
const axios = require('axios')
const _ = require('underscore')

module.exports = {
    downloadFile: async function (src, dest) {
        // axios download with response type "stream"
        return await axios({
            method: 'GET',
            url: src,
            responseType: 'stream'
        })
        .then(function (response) {
            if (response && response.status === 200 && !_(response.data).isUndefined() && !_(response.data).isNull()) {
                let writer = fs.createWriteStream(dest)

                // pipe the result stream into a file on disc
                response.data.pipe(writer)

                // return a promise and resolve when download finishes
                return new Promise((resolve, reject) => {
                    writer.on('finish', () => {
                        resolve(true)
                    })

                    writer.on('error', (error) => {
                        reject(error)
                    })
                })
            }
        })
        .catch(function (e) {
            throw new Error(e)
        });
    }
}

Usage:

const downloader = require('../utils/download')
...

downloader.downloadFile(src, dest)
        .then(function (result) {
            if (result === true) {
                ...
            }
        })
        .catch(function (e) {
            console.log(e)
        });

Dzięki wielkie mam nadziej ze za działa

This got me going - and annoyed - by nodejs.
I wanted to try the fs promises version of fs to handle a download. Turns out that it's quite different and even feels c-like.

Here's a download function that uses fs promises and axios as http handler:

const axios = require('axios');
const fs = require('fs/promises');

const downloadFile = async (url, destination) => {
    let file = null;
    try {
        console.log(`Starting file download with url ${url}`)
        const response = await axios({
            method: 'GET',
            url: url,
            responseType: 'stream'
          })

        file = await fs.open(destination, 'w')
        const writer = file.createWriteStream()
        response.data.pipe(writer)

        await new Promise((resolve, reject) => {
            writer.on('finish', async () => {
                console.log(`Completed download with url ${url}`)
                resolve()
            })
            writer.on('error', reject)
          })
    } catch (error) {
        throw new Error(error);
    } finally {
        file?.close()
    }
}

Frankly, it's ugly. I thought promises were to make things easier and prettier (and they often are!), but the case of downloading a file (specially the writer object that you need to promisify still) just makes it look messy.

Note the use of finally to close the file handle. The ? part in file?.close() handles the error case neatly.
Also note that this means you must not return within the try block else the finally won't be called.

Call with something like:
await downloadFile("https://whatever/url/to/file", "/destination/file");