awaiting some fs/promises API (readdir, readfile) breaks later try catch block

[its-frank-huang]

Version

v16.15.0, v20.10.0

Platform

Darwin Guang-Yu-Huang-Frank 23.2.0 Darwin Kernel Version 23.2.0: Wed Nov 15 21:59:33 PST 2023; root:xnu-10002.61.3~2/RELEASE_ARM64_T8112 arm64

Subsystem

No response

What steps will reproduce the bug?

Steps

Init a new project

$ npm init -y

Install fs

$ npm install fs

Modify package.json

add "type": "module", in package.json

{
  "name": "cli",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "type": "module",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "fs": "^0.0.1-security"
  }
}

Copy code in one of the following cases to created file

Execute

Case 1: The promise is created before the first try-catch

Code

import { readdir } from 'fs/promises';

const main = async () => {
  const p = Promise.reject('test error');

  try {
    await readdir('.');
  } catch (error) {
    console.error('first promise rejected');
  }

  try {
    await p;
  } catch (error) {
    console.error('second promise rejected');
  }
};

main();

Result

Case 2: The promise is created after the first try-catch

Code

import { readdir } from 'fs/promises';

const main = async () => {
  try {
    await readdir('.');
  } catch (error) {
    console.error('first promise rejected');
  }
  
  const p = Promise.reject('test error');

  try {
    await p;
  } catch (error) {
    console.error('second promise rejected');
  }
};

main();

Result

Case 3: The promise is created before the first try-catch & not using readdir

Code

const main = async () => {
  const p = Promise.reject('test error');

  try {
    await Promise.resolve('test success');
  } catch (error) {
    console.error('first promise rejected');
  }

  try {
    await p;
  } catch (error) {
    console.error('second promise rejected');
  }
};

main();

Result

Conclusion

Somehow, the order of creation of the promise affects the behavior of the second try-catch block

How often does it reproduce? Is there a required condition?

100% on my and my co-workers' computers (all macOS)

What is the expected behavior? Why is that the expected behavior?

The second try-catch block should always catch the error, regardless of the order of creation

What do you see instead?

The second try-catch block doesn't catch the error when the promise is created before the first try-catch block

Additional information

No response

[targos]

This is expected behavior. The error is emitted asynchronously while your function is suspended by the await readdir('.'); call.

Note: You never need to install fs. It's a builtin module.

[its-frank-huang]

@targos

Note: You never need to install fs. It's a builtin module.

Thx, that's a useful tip

The error is emitted asynchronously while your function is suspended by the await readdir('.'); call.

1. What do you mean by "emitted asynchronously"? Isn't the code "awaiting" the async function to execute?
2. Why can't the try-catch block catch the error?

[Jamesernator]

What do you mean by "emitted asynchronously"?

When a promise is rejected, it is added to a list of promises that haven't been handled. If when the microtask queue is empty it remains rejected and doesn't have a .catch handler or then Node kills the process.

Isn't the code "awaiting" the async function to execute?

"Awaiting" means delegate back to the event loop and run other microtasks. In the first example, when you await readdir(".") you give back control to the event loop, a task for reading the dir "." is added to the event loop. Because the microtask queue is empty but readdir hasn't finished Node notices the list of promises that isn't handled isn't empty so it terminates the process.

The only reason your case 3 works is because await Promise.resolve(...) resolves within a microtask rather than a full task. If you change case 3 to resolve on the task queue instead it'll have the same behaviour as case 1:

const main = async () => {
  const p = Promise.reject('test error');

  try {
    await new Promise((resolve, reject) => {
      // Main task queue
      setImmediate(resolve);
    });
  } catch (error) {
    console.error('first promise rejected');
  }

  try {
    await p;
  } catch (error) {
    console.error('second promise rejected');
  }
};

main();

Why can't the try-catch block catch the error?

Try-catch works reliably if you await promises immediately after you create them (like in case 2). If you await something else inbetween (or add the promise to say an array to handle later) you need to add an empty handler i.e.:

import { readdir } from 'fs/promises';

const main = async () => {
  const p = Promise.reject('test error');
  // Disable unhandledrejection handlers for this promise
  p.catch(() => {});

  try {
    await readdir('.');
  } catch (error) {
    console.error('first promise rejected');
  }

  try {
    await p;
  } catch (error) {
    console.error('second promise rejected');
  }
};

main();

[dario-piotrowicz]

Since the behavior is as expected I think that this issue can be closed? 🙂