From 272828d16d26f49383f64886472783b5a84de4fd Mon Sep 17 00:00:00 2001
From: Marco Ippolito <marcoippolito54@gmail.com>
Date: Tue, 27 Aug 2024 13:46:11 +0200
Subject: [PATCH] src: add config file support

---
 doc/api/cli.md                                |  40 +++++++
 doc/node.1                                    |   3 +
 doc/node_config_json_schema.json              |  10 ++
 lib/internal/process/pre_execution.js         |   8 ++
 node.gyp                                      |   2 +
 src/node.cc                                   |  21 ++++
 src/node_options.cc                           |   3 +
 src/node_options.h                            |   1 +
 src/node_rc.cc                                |  97 +++++++++++++++++
 src/node_rc.h                                 |  35 ++++++
 .../dotenv/node-options-no-tranform.env       |   1 +
 test/fixtures/rc/empty-object.json            |   4 +
 test/fixtures/rc/empty.json                   |   1 +
 test/fixtures/rc/override-property.json       |   4 +
 test/fixtures/rc/transform-types.json         |   3 +
 test/parallel/test-config_rc.js               | 101 ++++++++++++++++++
 16 files changed, 334 insertions(+)
 create mode 100644 doc/node_config_json_schema.json
 create mode 100644 src/node_rc.cc
 create mode 100644 src/node_rc.h
 create mode 100644 test/fixtures/dotenv/node-options-no-tranform.env
 create mode 100644 test/fixtures/rc/empty-object.json
 create mode 100644 test/fixtures/rc/empty.json
 create mode 100644 test/fixtures/rc/override-property.json
 create mode 100644 test/fixtures/rc/transform-types.json
 create mode 100644 test/parallel/test-config_rc.js

diff --git a/doc/api/cli.md b/doc/api/cli.md
index 9c5af91ae13f915..d3839e4b923b510 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -911,6 +911,46 @@ added: v23.6.0
 
 Enable experimental import support for `.node` addons.
 
+### `--experimental-config-file`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1.0 - Early development
+
+Use this flag to specify a configuration file that will be loaded and parsed
+before the application starts.
+Node.js will read the configuration file and apply the settings.
+The configuration file should be a JSON file
+with the following structure:
+
+```json
+{
+  "experimental_transform_types": true
+}
+```
+
+The priority in configuration is as follows:
+
+* NODE\_OPTIONS and command-line options
+* Config file
+* Dotenv NODE\_OPTIONS
+
+If multiple keys are present in the configuration file,
+the last one will override the previous ones.
+Unknown keys will be ignored.
+
+It possible to use the official json schema to validate the configuration file,
+which may vary depending on the Node.js version.
+
+```json
+{
+  "$schema": "https://nodejs.org/dist/REPLACEME/node_config_json_schema.json",
+  "experimental_transform_types": true
+}
+```
+
 ### `--experimental-eventsource`
 
 <!-- YAML
diff --git a/doc/node.1 b/doc/node.1
index d33bb82b7670e7b..ad8873b423105cf 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -166,6 +166,9 @@ Interpret the entry point as a URL.
 .It Fl -experimental-addon-modules
 Enable experimental addon module support.
 .
+.It Fl -experimental-config-file
+Enable support for experimental config file
+.
 .It Fl -experimental-import-meta-resolve
 Enable experimental ES modules support for import.meta.resolve().
 .
diff --git a/doc/node_config_json_schema.json b/doc/node_config_json_schema.json
new file mode 100644
index 000000000000000..3ac44ba7f74857f
--- /dev/null
+++ b/doc/node_config_json_schema.json
@@ -0,0 +1,10 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+        "experimental_transform_types": {
+            "type": "boolean"
+        }
+    },
+    "additionalProperties": false
+}
diff --git a/lib/internal/process/pre_execution.js b/lib/internal/process/pre_execution.js
index 109890e5986ee48..537d0a7b39b6821 100644
--- a/lib/internal/process/pre_execution.js
+++ b/lib/internal/process/pre_execution.js
@@ -116,6 +116,8 @@ function prepareExecution(options) {
   initializeSourceMapsHandlers();
   initializeDeprecations();
 
+  setupConfigFile();
+
   require('internal/dns/utils').initializeDns();
 
   if (isMainThread) {
@@ -312,6 +314,12 @@ function setupSQLite() {
   BuiltinModule.allowRequireByUsers('sqlite');
 }
 
+function setupConfigFile() {
+  if (getOptionValue('--experimental-config-file')) {
+    emitExperimentalWarning('--experimental-config-file');
+  }
+}
+
 function setupQuic() {
   if (!getOptionValue('--experimental-quic')) {
     return;
diff --git a/node.gyp b/node.gyp
index ba1f50d7541cca4..1e246a0d0a6ae77 100644
--- a/node.gyp
+++ b/node.gyp
@@ -130,6 +130,7 @@
       'src/node_process_events.cc',
       'src/node_process_methods.cc',
       'src/node_process_object.cc',
+      'src/node_rc.cc',
       'src/node_realm.cc',
       'src/node_report.cc',
       'src/node_report_module.cc',
@@ -262,6 +263,7 @@
       'src/node_platform.h',
       'src/node_process.h',
       'src/node_process-inl.h',
+      'src/node_rc.h',
       'src/node_realm.h',
       'src/node_realm-inl.h',
       'src/node_report.h',
diff --git a/src/node.cc b/src/node.cc
index 6b5ae7f7e455f83..ca73c69d3b64c4d 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -21,6 +21,7 @@
 
 #include "node.h"
 #include "node_dotenv.h"
+#include "node_rc.h"
 #include "node_task_runner.h"
 
 // ========== local headers ==========
@@ -150,6 +151,9 @@ namespace per_process {
 // Instance is used to store environment variables including NODE_OPTIONS.
 node::Dotenv dotenv_file = Dotenv();
 
+// node_rc.h
+node::ConfigReader config_reader = ConfigReader();
+
 // node_revert.h
 // Bit flag used to track security reverts.
 unsigned int reverted_cve = 0;
@@ -884,6 +888,23 @@ static ExitCode InitializeNodeWithArgsInternal(
     per_process::dotenv_file.AssignNodeOptionsIfAvailable(&node_options);
   }
 
+  auto result = per_process::config_reader.GetDataFromArgs(*argv);
+  if (result.has_value()) {
+    switch (per_process::config_reader.ParseConfig(result.value())) {
+      case ConfigReader::ParseResult::Valid:
+        break;
+      case ConfigReader::ParseResult::InvalidContent:
+        errors->push_back(result.value() + ": invalid format");
+        break;
+      case ConfigReader::ParseResult::FileError:
+        errors->push_back(result.value() + ": not found");
+        break;
+      default:
+        UNREACHABLE();
+    }
+    per_process::config_reader.AssignNodeOptions(&node_options);
+  }
+
 #if !defined(NODE_WITHOUT_NODE_OPTIONS)
   if (!(flags & ProcessInitializationFlags::kDisableNodeOptionsEnv)) {
     // NODE_OPTIONS environment variable is preferred over the file one.
diff --git a/src/node_options.cc b/src/node_options.cc
index a6dc00d7d7213fb..e013a8978544dbb 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -671,6 +671,9 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "set environment variables from supplied file",
             &EnvironmentOptions::optional_env_file);
   Implies("--env-file-if-exists", "[has_env_file_string]");
+  AddOption("--experimental-config-file",
+            "set config file from supplied file",
+            &EnvironmentOptions::experimental_config_file);
   AddOption("--test",
             "launch test runner on startup",
             &EnvironmentOptions::test_runner);
diff --git a/src/node_options.h b/src/node_options.h
index 3c4d2f853f2b354..02ef5708c85fce5 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -256,6 +256,7 @@ class EnvironmentOptions : public Options {
 
   bool report_exclude_env = false;
   bool report_exclude_network = false;
+  std::string experimental_config_file;
 
   inline DebugOptions* get_debug_options() { return &debug_options_; }
   inline const DebugOptions& debug_options() const { return debug_options_; }
diff --git a/src/node_rc.cc b/src/node_rc.cc
new file mode 100644
index 000000000000000..601e4f7a2ef4a83
--- /dev/null
+++ b/src/node_rc.cc
@@ -0,0 +1,97 @@
+#include "node_rc.h"
+#include "debug_utils-inl.h"
+#include "env-inl.h"
+#include "node_errors.h"
+#include "node_file.h"
+#include "node_internals.h"
+#include "simdjson.h"
+
+#include <functional>
+#include <map>
+#include <string>
+
+namespace node {
+
+std::optional<std::string> ConfigReader::GetDataFromArgs(
+    const std::vector<std::string>& args) {
+  constexpr std::string_view flag = "--experimental-config-file";
+
+  for (auto it = args.begin(); it != args.end(); ++it) {
+    if (*it == flag) {
+      // Case: "--experimental-config-file foo"
+      if (auto next = std::next(it); next != args.end()) {
+        return *next;
+      }
+    } else if (it->starts_with(flag)) {
+      // Case: "--experimental-config-file=foo"
+      if (it->size() > flag.size() && (*it)[flag.size()] == '=') {
+        return it->substr(flag.size() + 1);
+      }
+    }
+  }
+
+  return std::nullopt;
+}
+
+ConfigReader::ParseResult ConfigReader::ParseConfig(
+    const std::string& config_path) {
+  std::string file_content;
+  // Read the configuration file
+  int r = ReadFileSync(&file_content, config_path.c_str());
+  if (r != 0) {
+    const char* err = uv_strerror(r);
+    FPrintF(
+        stderr, "Cannot read configuration from %s: %s\n", config_path, err);
+    return ParseResult::FileError;
+  }
+
+  // Parse the configuration file
+  simdjson::ondemand::parser json_parser;
+  simdjson::ondemand::document document;
+  if (json_parser.iterate(file_content).get(document)) {
+    FPrintF(stderr, "Can't parse %s\n", config_path.c_str());
+    return ParseResult::InvalidContent;
+  }
+
+  simdjson::ondemand::object main_object;
+  // If document is not an object, throw an error.
+  if (auto root_error = document.get_object().get(main_object)) {
+    if (root_error == simdjson::error_code::INCORRECT_TYPE) {
+      FPrintF(stderr,
+              "Root value unexpected not an object for %s\n\n",
+              config_path.c_str());
+    } else {
+      FPrintF(stderr, "Can't parse %s\n", config_path.c_str());
+    }
+    return ParseResult::InvalidContent;
+  }
+
+  ConfigReader::Config config;
+  simdjson::ondemand::value ondemand_value;
+  simdjson::ondemand::raw_json_string key;
+
+  for (auto field : main_object) {
+    if (field.key().get(key) || field.value().get(ondemand_value)) {
+      return ParseResult::InvalidContent;
+    }
+    if (key == "experimental_transform_types") {
+      if (ondemand_value.get_bool().get(config.experimental_transform_types)) {
+        FPrintF(stderr, "Invalid value for experimental_transform_types\n");
+        return ParseResult::InvalidContent;
+      }
+    }
+  }
+
+  config_ = config;
+  return ParseResult::Valid;
+}
+
+void ConfigReader::AssignNodeOptions(std::string* node_options) {
+  std::string result = "";
+  if (config_.experimental_transform_types) {
+    result += "--experimental-transform-types";
+  }
+  *node_options = result;
+  return;
+}
+}  // namespace node
diff --git a/src/node_rc.h b/src/node_rc.h
new file mode 100644
index 000000000000000..afacc8f520e66e8
--- /dev/null
+++ b/src/node_rc.h
@@ -0,0 +1,35 @@
+#ifndef SRC_NODE_RC_H_
+#define SRC_NODE_RC_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <map>
+#include <string>
+#include <variant>
+#include "simdjson.h"
+#include "util-inl.h"
+
+namespace node {
+
+class ConfigReader {
+ public:
+  enum ParseResult { Valid, FileError, InvalidContent };
+  struct Config {
+    bool experimental_transform_types;
+  };
+  ConfigReader::ParseResult ParseConfig(const std::string& config_path);
+
+  std::optional<std::string> GetDataFromArgs(
+      const std::vector<std::string>& args);
+
+  void AssignNodeOptions(std::string* node_options);
+
+ private:
+  ConfigReader::Config config_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_RC_H_
diff --git a/test/fixtures/dotenv/node-options-no-tranform.env b/test/fixtures/dotenv/node-options-no-tranform.env
new file mode 100644
index 000000000000000..88ecfa83522e9fb
--- /dev/null
+++ b/test/fixtures/dotenv/node-options-no-tranform.env
@@ -0,0 +1 @@
+NODE_OPTIONS="--no-experimental-strip-types"
diff --git a/test/fixtures/rc/empty-object.json b/test/fixtures/rc/empty-object.json
new file mode 100644
index 000000000000000..f5ed717bad58ade
--- /dev/null
+++ b/test/fixtures/rc/empty-object.json
@@ -0,0 +1,4 @@
+{
+
+}
+
diff --git a/test/fixtures/rc/empty.json b/test/fixtures/rc/empty.json
new file mode 100644
index 000000000000000..8b137891791fe96
--- /dev/null
+++ b/test/fixtures/rc/empty.json
@@ -0,0 +1 @@
+
diff --git a/test/fixtures/rc/override-property.json b/test/fixtures/rc/override-property.json
new file mode 100644
index 000000000000000..c381476036771d1
--- /dev/null
+++ b/test/fixtures/rc/override-property.json
@@ -0,0 +1,4 @@
+{
+    "experimental_transform_types": true,
+    "experimental_transform_types": false
+}
diff --git a/test/fixtures/rc/transform-types.json b/test/fixtures/rc/transform-types.json
new file mode 100644
index 000000000000000..e59b2d84ab51f12
--- /dev/null
+++ b/test/fixtures/rc/transform-types.json
@@ -0,0 +1,3 @@
+{
+    "experimental_transform_types": true
+}
diff --git a/test/parallel/test-config_rc.js b/test/parallel/test-config_rc.js
new file mode 100644
index 000000000000000..1ced87823d60cdf
--- /dev/null
+++ b/test/parallel/test-config_rc.js
@@ -0,0 +1,101 @@
+'use strict';
+
+const { spawnPromisified } = require('../common');
+const fixtures = require('../common/fixtures');
+const { notStrictEqual, match, strictEqual } = require('node:assert');
+const { test } = require('node:test');
+
+test('should handle empty json', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--experimental-config-file',
+    fixtures.path('rc/empty.json'),
+    '-p', '"Hello, World!"',
+  ]);
+  match(result.stderr, /Can't parse/);
+  match(result.stderr, /empty\.json: invalid format/);
+  strictEqual(result.stdout, '');
+  notStrictEqual(result.code, 0);
+});
+
+test('should handle empty object json', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--no-warnings',
+    '--experimental-config-file',
+    fixtures.path('rc/empty-object.json'),
+    '-p', '"Hello, World!"',
+  ]);
+  strictEqual(result.stderr, '');
+  match(result.stdout, /Hello, World!/);
+  strictEqual(result.code, 0);
+});
+
+test('should parse version with experimental_transform_types true', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--experimental-config-file',
+    fixtures.path('rc/transform-types.json'),
+    fixtures.path('typescript/ts/transformation/test-enum.ts'),
+  ]);
+  match(result.stderr, /--experimental-config-file is an experimental feature and might change at any time/);
+  match(result.stdout, /Hello, TypeScript!/);
+  strictEqual(result.code, 0);
+});
+
+test('should override a flag declared twice', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--no-warnings',
+    '--experimental-config-file',
+    fixtures.path('rc/override-property.json'),
+    fixtures.path('typescript/ts/transformation/test-enum.ts'),
+  ]);
+  match(result.stderr, /ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX/);
+  strictEqual(result.stdout, '');
+  strictEqual(result.code, 1);
+});
+
+test('should override env-file', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--no-warnings',
+    '--experimental-config-file',
+    fixtures.path('rc/transform-types.json'),
+    '--env-file', fixtures.path('dotenv/node-options-no-tranform.env'),
+    fixtures.path('typescript/ts/transformation/test-enum.ts'),
+  ]);
+  strictEqual(result.stderr, '');
+  match(result.stdout, /Hello, TypeScript!/);
+  strictEqual(result.code, 0);
+});
+
+test('should not work when when NODE_OPTIONS are passed', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--no-warnings',
+    '--experimental-config-file',
+    fixtures.path('rc/transform-types.json'),
+    fixtures.path('typescript/ts/transformation/test-enum.ts'),
+  ], {
+    env: {
+      ...process.env,
+      NODE_OPTIONS: '--no-experimental-transform-types',
+    },
+  });
+  match(result.stderr, /ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX/);
+  strictEqual(result.stdout, '');
+  notStrictEqual(result.code, 0);
+});
+
+test('should not work when when NODE_OPTIONS are passed', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--no-warnings',
+    '--no-experimental-transform-types',
+    '--experimental-config-file',
+    fixtures.path('rc/transform-types.json'),
+    fixtures.path('typescript/ts/transformation/test-enum.ts'),
+  ], {
+    env: {
+      ...process.env,
+      NODE_OPTIONS: '--no-experimental-transform-types',
+    },
+  });
+  match(result.stderr, /ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX/);
+  strictEqual(result.stdout, '');
+  notStrictEqual(result.code, 0);
+});