From 24aba0167a14d1698565dd89593ed17636e9d7e3 Mon Sep 17 00:00:00 2001
From: Yagiz Nizipli <yagiz@nizipli.com>
Date: Sun, 23 Jul 2023 00:05:25 -0400
Subject: [PATCH] src: add built-in `.env` file support

---
 doc/api/cli.md                 |  26 ++++++++
 node.gyp                       |   2 +
 src/node.cc                    |   6 ++
 src/node_dotenv.cc             | 115 +++++++++++++++++++++++++++++++++
 src/node_dotenv.h              |  21 ++++++
 src/node_options.cc            |   5 ++
 src/node_options.h             |   2 +
 test/fixtures/dotenv/valid.env |  38 +++++++++++
 test/parallel/test-dotenv.js   |  72 +++++++++++++++++++++
 9 files changed, 287 insertions(+)
 create mode 100644 src/node_dotenv.cc
 create mode 100644 src/node_dotenv.h
 create mode 100644 test/fixtures/dotenv/valid.env
 create mode 100644 test/parallel/test-dotenv.js

diff --git a/doc/api/cli.md b/doc/api/cli.md
index cf509503dc838a..de66fccb32d858 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -975,6 +975,32 @@ surface on other platforms, but the performance impact may be severe.
 This flag is inherited from V8 and is subject to change upstream. It may
 disappear in a non-semver-major release.
 
+### `--env-file=config`
+
+> Stability: 1 - Experimental
+
+<!-- YAML
+added: REPLACEME
+-->
+
+Loads environment variables from a file relative to the current directory.
+
+`NODE_OPTIONS` environment variable is not supported at the moment.
+
+The format of the file should be one line per key-value pair of environment
+variable name and value separated by `=`:
+
+```text
+PORT=3000
+```
+
+Any text after a `#` is treated as a comment:
+
+```text
+# This is a comment
+PORT=3000 # This is also a comment
+```
+
 ### `--max-http-header-size=size`
 
 <!-- YAML
diff --git a/node.gyp b/node.gyp
index db6d7455bf1dbd..f145bcaf398005 100644
--- a/node.gyp
+++ b/node.gyp
@@ -100,6 +100,7 @@
       'src/node_contextify.cc',
       'src/node_credentials.cc',
       'src/node_dir.cc',
+      'src/node_dotenv.cc',
       'src/node_env_var.cc',
       'src/node_errors.cc',
       'src/node_external_reference.cc',
@@ -214,6 +215,7 @@
       'src/node_context_data.h',
       'src/node_contextify.h',
       'src/node_dir.h',
+      'src/node_dotenv.h',
       'src/node_errors.h',
       'src/node_exit_code.h',
       'src/node_external_reference.h',
diff --git a/src/node.cc b/src/node.cc
index 7ca3e14ee06c3a..3452394d4b080d 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -20,6 +20,7 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "node.h"
+#include "node_dotenv.h"
 
 // ========== local headers ==========
 
@@ -303,6 +304,11 @@ MaybeLocal<Value> StartExecution(Environment* env, StartExecutionCallback cb) {
   }
 #endif
 
+  if (env->options()->has_env_file_string) {
+    std::string path = env->GetCwd() + kPathSeparator + env->options()->env_file;
+    node::dotenv::LoadFromFile(env, path);
+  }
+
   // TODO(joyeecheung): move these conditions into JS land and let the
   // deserialize main function take precedence. For workers, we need to
   // move the pre-execution part into a different file that can be
diff --git a/src/node_dotenv.cc b/src/node_dotenv.cc
new file mode 100644
index 00000000000000..6de36b84784cb2
--- /dev/null
+++ b/src/node_dotenv.cc
@@ -0,0 +1,115 @@
+#include "env-inl.h"
+#include "node_dotenv.h"
+#include "node_file.h"
+#include "uv.h"
+
+namespace node {
+
+using v8::Isolate;
+using v8::NewStringType;
+
+namespace dotenv {
+
+void ParseLine(const std::string_view line, Isolate* isolate, std::shared_ptr<KVStore> store) {
+  auto equal_index = line.find('=');
+
+  if (equal_index == std::string_view::npos) {
+    return;
+  }
+
+  auto key = line.substr(0, equal_index);
+
+  // Remove leading and trailing space characters from key.
+  while (!key.empty() && std::isspace(key.front())) key.remove_prefix(1);
+  while (!key.empty() && std::isspace(key.back())) key.remove_suffix(1);
+
+  // Omit lines with comments
+  if (key.front() == '#' || key.empty()) {
+    return;
+  }
+
+  auto value = std::string(line.substr(equal_index + 1));
+
+  // Might start and end with `"' characters.
+  auto quotation_index = value.find_first_of("`\"'");
+
+  if (quotation_index == 0) {
+    auto quote_character = value[quotation_index];
+    value.erase(0, 1);
+
+    auto end_quotation_index = value.find_last_of(quote_character);
+
+    // We couldn't find the closing quotation character. Terminate.
+    if (end_quotation_index == std::string::npos) {
+      return;
+    }
+
+    value.erase(end_quotation_index);
+  } else {
+    auto hash_index = value.find('#');
+
+    // Remove any inline comments
+    if (hash_index != std::string::npos) {
+      value.erase(hash_index);
+    }
+
+    // Remove any leading/trailing spaces from unquoted values.
+    while (!value.empty() && std::isspace(value.front())) value.erase(0, 1);
+    while (!value.empty() && std::isspace(value.back())) value.erase(value.size() - 1);
+  }
+
+  store->Set(isolate,
+             v8::String::NewFromUtf8(
+                 isolate, key.data(), NewStringType::kNormal, key.size())
+                 .ToLocalChecked(),
+             v8::String::NewFromUtf8(
+                 isolate, value.data(), NewStringType::kNormal, value.size())
+                 .ToLocalChecked());
+}
+
+void LoadFromFile(Environment* env, const std::string_view path) {
+  Isolate* isolate = env->isolate();
+  auto store = env->env_vars();
+  uv_fs_t req;
+  auto defer_req_cleanup = OnScopeLeave([&req]() { uv_fs_req_cleanup(&req); });
+
+  uv_file file = uv_fs_open(nullptr, &req, path.data(), 0, 438, nullptr);
+  if (req.result < 0) {
+    // req will be cleaned up by scope leave.
+    return;
+  }
+  uv_fs_req_cleanup(&req);
+
+  auto defer_close = OnScopeLeave([file]() {
+    uv_fs_t close_req;
+    CHECK_EQ(0, uv_fs_close(nullptr, &close_req, file, nullptr));
+    uv_fs_req_cleanup(&close_req);
+  });
+
+  std::string result{};
+  char buffer[8192];
+  uv_buf_t buf = uv_buf_init(buffer, sizeof(buffer));
+
+  while (true) {
+    auto r = uv_fs_read(nullptr, &req, file, &buf, 1, -1, nullptr);
+    if (req.result < 0) {
+      // req will be cleaned up by scope leave.
+      return;
+    }
+    uv_fs_req_cleanup(&req);
+    if (r <= 0) {
+      break;
+    }
+    result.append(buf.base, r);
+  }
+
+  using std::string_view_literals::operator""sv;
+
+  for (const auto& line : SplitString(result, "\n"sv)) {
+    ParseLine(line, isolate, store);
+  }
+}
+
+}  // namespace dotenv
+
+}  // namespace node
diff --git a/src/node_dotenv.h b/src/node_dotenv.h
new file mode 100644
index 00000000000000..134f986f2d3e0e
--- /dev/null
+++ b/src/node_dotenv.h
@@ -0,0 +1,21 @@
+#ifndef SRC_NODE_DOTENV_H_
+#define SRC_NODE_DOTENV_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "util-inl.h"
+
+namespace node {
+
+namespace dotenv {
+
+void LoadFromFile(Environment* env,
+                  const std::string_view path);
+
+}  // namespace dotenv
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_DOTENV_H_
diff --git a/src/node_options.cc b/src/node_options.cc
index c02752464c4ab5..2fe3af4928be5e 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -575,6 +575,11 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "write warnings to file instead of stderr",
             &EnvironmentOptions::redirect_warnings,
             kAllowedInEnvvar);
+  AddOption("[has_env_file_string]", "", &EnvironmentOptions::has_env_file_string);
+  AddOption("--env-file",
+            "set environment variables from supplied file",
+            &EnvironmentOptions::env_file);
+  Implies("--env-file", "[has_env_file_string]");
   AddOption("--test",
             "launch test runner on startup",
             &EnvironmentOptions::test_runner);
diff --git a/src/node_options.h b/src/node_options.h
index bb8b68894b4430..1cc575bb9c7e3c 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -158,6 +158,8 @@ class EnvironmentOptions : public Options {
 #endif  // HAVE_INSPECTOR
   std::string redirect_warnings;
   std::string diagnostic_dir;
+  std::string env_file;
+  bool has_env_file_string = false;
   bool test_runner = false;
   bool test_runner_coverage = false;
   std::vector<std::string> test_name_pattern;
diff --git a/test/fixtures/dotenv/valid.env b/test/fixtures/dotenv/valid.env
new file mode 100644
index 00000000000000..40d66e073d39b1
--- /dev/null
+++ b/test/fixtures/dotenv/valid.env
@@ -0,0 +1,38 @@
+BASIC=basic
+
+# previous line intentionally left blank
+AFTER_LINE=after_line
+EMPTY=
+EMPTY_SINGLE_QUOTES=''
+EMPTY_DOUBLE_QUOTES=""
+EMPTY_BACKTICKS=``
+SINGLE_QUOTES='single_quotes'
+SINGLE_QUOTES_SPACED='    single quotes    '
+DOUBLE_QUOTES="double_quotes"
+DOUBLE_QUOTES_SPACED="    double quotes    "
+DOUBLE_QUOTES_INSIDE_SINGLE='double "quotes" work inside single quotes'
+DOUBLE_QUOTES_WITH_NO_SPACE_BRACKET="{ port: $MONGOLAB_PORT}"
+SINGLE_QUOTES_INSIDE_DOUBLE="single 'quotes' work inside double quotes"
+BACKTICKS_INSIDE_SINGLE='`backticks` work inside single quotes'
+BACKTICKS_INSIDE_DOUBLE="`backticks` work inside double quotes"
+BACKTICKS=`backticks`
+BACKTICKS_SPACED=`    backticks    `
+DOUBLE_QUOTES_INSIDE_BACKTICKS=`double "quotes" work inside backticks`
+SINGLE_QUOTES_INSIDE_BACKTICKS=`single 'quotes' work inside backticks`
+DOUBLE_AND_SINGLE_QUOTES_INSIDE_BACKTICKS=`double "quotes" and single 'quotes' work inside backticks`
+EXPAND_NEWLINES="expand\nnew\nlines"
+DONT_EXPAND_UNQUOTED=dontexpand\nnewlines
+DONT_EXPAND_SQUOTED='dontexpand\nnewlines'
+# COMMENTS=work
+INLINE_COMMENTS=inline comments # work #very #well
+INLINE_COMMENTS_SINGLE_QUOTES='inline comments outside of #singlequotes' # work
+INLINE_COMMENTS_DOUBLE_QUOTES="inline comments outside of #doublequotes" # work
+INLINE_COMMENTS_BACKTICKS=`inline comments outside of #backticks` # work
+INLINE_COMMENTS_SPACE=inline comments start with a#number sign. no space required.
+EQUAL_SIGNS=equals==
+RETAIN_INNER_QUOTES={"foo": "bar"}
+RETAIN_INNER_QUOTES_AS_STRING='{"foo": "bar"}'
+RETAIN_INNER_QUOTES_AS_BACKTICKS=`{"foo": "bar's"}`
+TRIM_SPACE_FROM_UNQUOTED=    some spaced out string
+USERNAME=therealnerdybeast@example.tld
+    SPACED_KEY = parsed
diff --git a/test/parallel/test-dotenv.js b/test/parallel/test-dotenv.js
new file mode 100644
index 00000000000000..d31b9b8ab42249
--- /dev/null
+++ b/test/parallel/test-dotenv.js
@@ -0,0 +1,72 @@
+// Flags: --env-file test/fixtures/dotenv/valid.env
+'use strict';
+
+const common = require('../common');
+const assert = require('node:assert');
+const fs = require('node:fs');
+const path = require('node:path');
+
+// Sets basic environment variable
+assert.strictEqual(process.env.BASIC, 'basic');
+// Reads after a skipped line
+assert.strictEqual(process.env.AFTER_LINE, 'after_line');
+// Defaults empty values to empty string
+assert.strictEqual(process.env.EMPTY, '');
+assert.strictEqual(process.env.EMPTY_SINGLE_QUOTES, '');
+assert.strictEqual(process.env.EMPTY_DOUBLE_QUOTES, '');
+assert.strictEqual(process.env.EMPTY_BACKTICKS, '');
+// Escapes single quoted values
+assert.strictEqual(process.env.SINGLE_QUOTES, 'single_quotes');
+// Respects surrounding spaces in single quotes
+assert.strictEqual(process.env.SINGLE_QUOTES_SPACED, '    single quotes    ');
+// Escapes double quoted values
+assert.strictEqual(process.env.DOUBLE_QUOTES, 'double_quotes');
+// Respects surrounding spaces in double quotes
+assert.strictEqual(process.env.DOUBLE_QUOTES_SPACED, '    double quotes    ');
+// Respects double quotes inside single quotes
+assert.strictEqual(process.env.DOUBLE_QUOTES_INSIDE_SINGLE, 'double "quotes" work inside single quotes');
+// Respects spacing for badly formed brackets
+assert.strictEqual(process.env.DOUBLE_QUOTES_WITH_NO_SPACE_BRACKET, '{ port: $MONGOLAB_PORT}');
+// Respects single quotes inside double quotes
+assert.strictEqual(process.env.SINGLE_QUOTES_INSIDE_DOUBLE, "single 'quotes' work inside double quotes");
+// Respects backticks inside single quotes
+assert.strictEqual(process.env.BACKTICKS_INSIDE_SINGLE, '`backticks` work inside single quotes');
+// Respects backticks inside double quotes
+assert.strictEqual(process.env.BACKTICKS_INSIDE_DOUBLE, '`backticks` work inside double quotes');
+assert.strictEqual(process.env.BACKTICKS, 'backticks');
+assert.strictEqual(process.env.BACKTICKS_SPACED, '    backticks    ');
+// Respects double quotes inside backticks
+assert.strictEqual(process.env.DOUBLE_QUOTES_INSIDE_BACKTICKS, 'double "quotes" work inside backticks');
+// Respects single quotes inside backticks
+assert.strictEqual(process.env.SINGLE_QUOTES_INSIDE_BACKTICKS, "single 'quotes' work inside backticks");
+// Respects single quotes inside backticks
+assert.strictEqual(
+  process.env.DOUBLE_AND_SINGLE_QUOTES_INSIDE_BACKTICKS,
+  "double \"quotes\" and single 'quotes' work inside backticks",
+);
+// Ignores inline comments
+assert.strictEqual(process.env.INLINE_COMMENTS, 'inline comments');
+// Ignores inline comments and respects # character inside of single quotes
+assert.strictEqual(process.env.INLINE_COMMENTS_SINGLE_QUOTES, 'inline comments outside of #singlequotes');
+// Ignores inline comments and respects # character inside of double quotes
+assert.strictEqual(process.env.INLINE_COMMENTS_DOUBLE_QUOTES, 'inline comments outside of #doublequotes');
+// Ignores inline comments and respects # character inside of backticks
+assert.strictEqual(process.env.INLINE_COMMENTS_BACKTICKS, 'inline comments outside of #backticks');
+// Treats # character as start of comment
+assert.strictEqual(process.env.INLINE_COMMENTS_SPACE, 'inline comments start with a');
+// Respects equals signs in values
+assert.strictEqual(process.env.EQUAL_SIGNS, 'equals==');
+// Retains inner quotes
+assert.strictEqual(process.env.RETAIN_INNER_QUOTES, '{"foo": "bar"}');
+// Respects equals signs in values
+assert.strictEqual(process.env.EQUAL_SIGNS, 'equals==');
+// Retains inner quotes
+assert.strictEqual(process.env.RETAIN_INNER_QUOTES, '{"foo": "bar"}');
+assert.strictEqual(process.env.RETAIN_INNER_QUOTES_AS_STRING, '{"foo": "bar"}');
+assert.strictEqual(process.env.RETAIN_INNER_QUOTES_AS_BACKTICKS, '{"foo": "bar\'s"}');
+// Retains spaces in string
+assert.strictEqual(process.env.TRIM_SPACE_FROM_UNQUOTED, 'some spaced out string');
+// Parses email addresses completely
+assert.strictEqual(process.env.USERNAME, 'therealnerdybeast@example.tld');
+// Parses keys and values surrounded by spaces
+assert.strictEqual(process.env.SPACED_KEY, 'parsed');