fs.readFile calls not isolated

[kataik]

• Version: 18.12.0
• Platform: macOS Monterey v12.6.1

import fs from 'fs'

async function readFiles(): Promise<void> {
  const existingFilePromise = fs.promises.readFile('./exists')
  const notExistingFilePromise = fs.promises.readFile('./not-exists')

  const data = await existingFilePromise
  console.log(data.toString('utf-8'))

  try {
    await notExistingFilePromise
  } catch (err) {
    console.error(err)
  }
}

readFiles().finally(() => console.log('done'))

What is the expected output?

Content of the file referenced by the first promise (existingFilePromise) logged, ENOENT error logged for the second promise.

What do you see instead?

The following error is emitted when awaiting existingFilePromise:

[Error: ENOENT: no such file or directory, open './not-exists'] {
  errno: -2,
  code: 'ENOENT',
  syscall: 'open',
  path: './not-exists'
}

Apparently the two parallel reads share state, they fail together instead of being isolated and handled separately.

[climba03003]

From my understanding, it is not sharing the same state but you won't be able to catch when await promise like this.

import fs from 'fs'

async function readFiles() {
  // we assume the AsyncIO is fast enough to finish immediately
  // if the system resources is contrainted
  // the behavior maybe difference
  // since the Promise will be finish in next tick
  const existingFilePromise = fs.promises.readFile('./exists') // mircrotask - ['Promise.resolve']
  const notExistingFilePromise = fs.promises.readFile('./not-exists') // microtask ['Promise.resolve', 'Promise.reject']

  // The await here will start clearing the mircrotask 
  // microtask - ['Promise.reject']
  // and it still clearing the microtask
  // microtask - []
  // boom - unhandledRejection
  const data = await existingFilePromise 
  console.log(data.toString('utf-8'))

  try {
    await notExistingFilePromise
  } catch (err) {
    console.error(err)
  }
}

readFiles().finally(() => console.log('done'))

[kataik]

Thank you for your answer, so to put it simple, if I have two promises running in parallel, one rejects faster that the other one resolves then there is no way to await the resolving one?

The object passed to resolve() is returned at the time of await the corresponding promise. I find it counter-intuitive that reject() is different and throws at the first await if got dequeued earlier. Why is this the case not something like:

await(promise) {
  let result, error;

  promise
    .then((data) => result = data)
    .catch((err) => error = err)

  // wait for promise magic

  if (error != null) {
    throw error
  }

  return result
}

[bnoordhuis]

I'll convert this to a discussion because this seems to be misunderstanding rather than an actual bug. The notExistingFilePromise is an unhandled rejection, you should use something like Promise.all().

Reduced test case:

async function main() {
  const p0 = new Promise((k, _) => setTimeout(() => k("ok"), 2))
  const p1 = new Promise((_, k) => setTimeout(() => k("err"), 1))
  await p0 // ERR_UNHANDLED_REJECTION from p1
  try { await p1 } catch (e) { console.log(e) } // never reached
main()

Instead do something like this:

async function main() {
  const p0 = new Promise((k, _) => setTimeout(() => k("ok"), 2))
  const p1 = new Promise((_, k) => setTimeout(() => k("err"), 1))
  const p2 = Promise.all([p0, p1])
  try { await p2 } catch (e) { console.log(e) } // logs "err"
}
main()

[kataik]

Actually got the answer here: https://stackoverflow.com/questions/75164302 - it is a Node only behaviour which is configurable. On browser engines like Chromium it works as I expected and after reconfigured unhandledRejection Node also works as I expected.

[aduh95]

You can also add an empty catch handler to the second promise to avoid triggering unhandledRejection:

import fs from 'node:fs'

async function readFiles(): Promise<void> {
  const existingFilePromise = fs.promises.readFile('./exists')
  const notExistingFilePromise = fs.promises.readFile('./not-exists')

  notExistingFilePromise.catch(() => {}) // avoids unhandledRejection and doesn't affect the rest of the code.

  const data = await existingFilePromise
  console.log(data.toString('utf-8'))

  try {
    await notExistingFilePromise
  } catch (err) {
    console.error(err)
  }
}

readFiles().finally(() => console.log('done'))