From cf6d05950d991b0cbeb06aa10d5bcf79c485c81f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Juan=20Jos=C3=A9=20Arboleda?= <soyjuanarbol@gmail.com>
Date: Sat, 27 Jul 2024 22:50:55 -0500
Subject: [PATCH] src,lib: introduce `util.getSystemErrorMessage(err)`
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This patch adds a new utility function which provides human-readable
string description of the given system error code.

Signed-off-by: Juan José Arboleda <soyjuanarbol@gmail.com>
---
 doc/api/util.md                | 21 +++++++++++++++++++++
 lib/internal/util.js           |  5 +++++
 lib/util.js                    | 14 ++++++++++++++
 src/uv.cc                      | 12 ++++++++++++
 test/parallel/test-uv-errno.js |  5 +++++
 5 files changed, 57 insertions(+)

diff --git a/doc/api/util.md b/doc/api/util.md
index bc7c7da964776d0..26858acd4accc7e 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -406,6 +406,27 @@ fs.access('file/that/does/not/exist', (err) => {
 });
 ```
 
+## `util.getSystemErrorMessage(err)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `err` {number}
+* Returns: {string}
+
+Returns the string message for a numeric error code that comes from a Node.js
+API.
+The mapping between error codes and error names is platform-dependent.
+See [Common System Errors][] for the names of common errors.
+
+```js
+fs.access('file/that/does/not/exist', (err) => {
+  const name = util.getSystemErrorMessage(err.errno);
+  console.error(name);  // no such file or directory
+});
+```
+
 ## `util.inherits(constructor, superConstructor)`
 
 <!-- YAML
diff --git a/lib/internal/util.js b/lib/internal/util.js
index f9de6cd77c71f44..f4a132643d340a8 100644
--- a/lib/internal/util.js
+++ b/lib/internal/util.js
@@ -381,6 +381,10 @@ function getCWDURL() {
   return cachedURL;
 }
 
+function getSystemErrorMessage(err) {
+  return lazyUv().getErrorMessage(err);
+}
+
 function getSystemErrorName(err) {
   const entry = uvErrmapGet(err);
   return entry ? entry[0] : `Unknown system error ${err}`;
@@ -916,6 +920,7 @@ module.exports = {
   getStructuredStack,
   getSystemErrorMap,
   getSystemErrorName,
+  getSystemErrorMessage,
   guessHandleType,
   isArrayBufferDetached,
   isError,
diff --git a/lib/util.js b/lib/util.js
index e3f3b11bda8333f..e2881a2b0ca3220 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -68,6 +68,7 @@ const {
   deprecate,
   getSystemErrorMap,
   getSystemErrorName: internalErrorName,
+  getSystemErrorMessage: internalErrorMessage,
   promisify,
   defineLazyProperties,
 } = require('internal/util');
@@ -229,6 +230,18 @@ function callbackify(original) {
   return callbackified;
 }
 
+/**
+ * @param {number} err
+ * @returns {string}
+ */
+function getSystemErrorMessage(err) {
+  validateNumber(err, 'err');
+  if (err >= 0 || !NumberIsSafeInteger(err)) {
+    throw new ERR_OUT_OF_RANGE('err', 'a negative integer', err);
+  }
+  return internalErrorMessage(err);
+}
+
 /**
  * @param {number} err
  * @returns {string}
@@ -291,6 +304,7 @@ module.exports = {
   formatWithOptions,
   getSystemErrorMap,
   getSystemErrorName,
+  getSystemErrorMessage,
   inherits,
   inspect,
   isArray: deprecate(ArrayIsArray,
diff --git a/src/uv.cc b/src/uv.cc
index a8f0c07240e1079..abec6098fb75f20 100644
--- a/src/uv.cc
+++ b/src/uv.cc
@@ -59,6 +59,16 @@ using v8::ReadOnly;
 using v8::String;
 using v8::Value;
 
+void GetErrMessage(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  int err;
+  if (!args[0]->Int32Value(env->context()).To(&err)) return;
+  CHECK_LT(err, 0);
+  char message[50];
+  uv_strerror_r(err, message, sizeof(message));
+  args.GetReturnValue().Set(OneByteString(env->isolate(), message));
+}
+
 void ErrName(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   if (env->options()->pending_deprecation && env->EmitErrNameWarning()) {
@@ -128,11 +138,13 @@ void Initialize(Local<Object> target,
   }
 
   SetMethod(context, target, "getErrorMap", GetErrMap);
+  SetMethod(context, target, "getErrorMessage", GetErrMessage);
 }
 
 void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(ErrName);
   registry->Register(GetErrMap);
+  registry->Register(GetErrMessage);
 }
 }  // namespace uv
 }  // namespace node
diff --git a/test/parallel/test-uv-errno.js b/test/parallel/test-uv-errno.js
index f30518fb474657c..1ca0ee6c759dd01 100644
--- a/test/parallel/test-uv-errno.js
+++ b/test/parallel/test-uv-errno.js
@@ -5,6 +5,7 @@ const common = require('../common');
 const assert = require('assert');
 const {
   getSystemErrorName,
+  getSystemErrorMessage,
   _errnoException
 } = require('util');
 
@@ -13,6 +14,7 @@ const uv = internalBinding('uv');
 const keys = Object.keys(uv);
 
 assert.strictEqual(uv.errname(-111111), 'Unknown system error -111111');
+assert.strictEqual(uv.getErrorMessage(-111111), 'Unknown system error -111111');
 
 keys.forEach((key) => {
   if (!key.startsWith('UV_'))
@@ -21,6 +23,8 @@ keys.forEach((key) => {
   const err = _errnoException(uv[key], 'test');
   const name = uv.errname(uv[key]);
   assert.strictEqual(getSystemErrorName(uv[key]), name);
+  assert.notStrictEqual(getSystemErrorMessage(uv[key]),
+                        `Unknown system error ${key}`);
   assert.strictEqual(err.code, name);
   assert.strictEqual(err.code, getSystemErrorName(err.errno));
   assert.strictEqual(err.message, `test ${name}`);
@@ -53,3 +57,4 @@ function runTest(fn) {
 
 runTest(_errnoException);
 runTest(getSystemErrorName);
+runTest(getSystemErrorMessage);