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();

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");