fix: use shared_ptr instead of unique_ptr for shared ressource, use o…

…perator[] instead of find_field.

src/node.cc

@@ -1022,11 +1022,11 @@ int InitializeNodeWithArgs(std::vector<std::string>* argv,
       InitializeNodeWithArgsInternal(argv, exec_argv, errors, flags));
 }
 
-static std::unique_ptr<InitializationResultImpl>
+static std::shared_ptr<InitializationResultImpl>
 InitializeOncePerProcessInternal(const std::vector<std::string>& args,
                                  ProcessInitializationFlags::Flags flags =
                                      ProcessInitializationFlags::kNoFlags) {
-  auto result = std::make_unique<InitializationResultImpl>();
+  auto result = std::make_shared<InitializationResultImpl>();
   result->args_ = args;
 
   if (!(flags & ProcessInitializationFlags::kNoParseGlobalDebugVariables)) {
@@ -1068,7 +1068,7 @@ InitializeOncePerProcessInternal(const std::vector<std::string>& args,
     auto positional_args = task_runner::GetPositionalArgs(args);
     result->early_return_ = true;
     task_runner::RunTask(
-        &result, per_process::cli_options->run, positional_args);
+        result, per_process::cli_options->run, positional_args);
     return result;
   }
 
@@ -1231,7 +1231,7 @@ InitializeOncePerProcessInternal(const std::vector<std::string>& args,
   return result;
 }
 
-std::unique_ptr<InitializationResult> InitializeOncePerProcess(
+std::shared_ptr<InitializationResult> InitializeOncePerProcess(
     const std::vector<std::string>& args,
     ProcessInitializationFlags::Flags flags) {
   return InitializeOncePerProcessInternal(args, flags);
@@ -1437,7 +1437,7 @@ static ExitCode StartInternal(int argc, char** argv) {
   // Hack around with the argv pointer. Used for process.title = "blah".
   argv = uv_setup_args(argc, argv);
 
-  std::unique_ptr<InitializationResultImpl> result =
+  std::shared_ptr<InitializationResultImpl> result =
       InitializeOncePerProcessInternal(
           std::vector<std::string>(argv, argv + argc));
   for (const std::string& error : result->errors()) {

src/node.h

@@ -349,7 +349,7 @@ NODE_DEPRECATED("Use InitializeOncePerProcess() instead",
 // including the arguments split into argv/exec_argv, a list of potential
 // errors encountered during initialization, and a potential suggested
 // exit code.
-NODE_EXTERN std::unique_ptr<InitializationResult> InitializeOncePerProcess(
+NODE_EXTERN std::shared_ptr<InitializationResult> InitializeOncePerProcess(
     const std::vector<std::string>& args,
     ProcessInitializationFlags::Flags flags =
         ProcessInitializationFlags::kNoFlags);
@@ -358,7 +358,7 @@ NODE_EXTERN std::unique_ptr<InitializationResult> InitializeOncePerProcess(
 NODE_EXTERN void TearDownOncePerProcess();
 // Convenience overload for specifying multiple flags without having
 // to worry about casts.
-inline std::unique_ptr<InitializationResult> InitializeOncePerProcess(
+inline std::shared_ptr<InitializationResult> InitializeOncePerProcess(
     const std::vector<std::string>& args,
     std::initializer_list<ProcessInitializationFlags::Flags> list) {
   uint64_t flags_accum = ProcessInitializationFlags::kNoFlags;

src/node_task_runner.cc

@@ -16,7 +16,7 @@ static const char task_file[] = "/bin/sh";
 #endif  // _WIN32
 
 ProcessRunner::ProcessRunner(
-    std::unique_ptr<InitializationResultImpl>* result,
+    std::shared_ptr<InitializationResultImpl>& result,
     std::string_view command,
     const std::optional<std::string>& positional_args) {
   memset(&options_, 0, sizeof(uv_process_options_t));
@@ -130,9 +130,9 @@ void ProcessRunner::ExitCallback(uv_process_t* handle,
 
 void ProcessRunner::OnExit(int64_t exit_status, int term_signal) {
   if (exit_status > 0) {
-    init_result->get()->exit_code_ = ExitCode::kGenericUserError;
+    init_result.get()->exit_code_ = ExitCode::kGenericUserError;
   } else {
-    init_result->get()->exit_code_ = ExitCode::kNoFailure;
+    init_result.get()->exit_code_ = ExitCode::kNoFailure;
   }
 }
 
@@ -144,7 +144,7 @@ void ProcessRunner::Run() {
   uv_run(loop_, UV_RUN_DEFAULT);
 }
 
-void RunTask(std::unique_ptr<InitializationResultImpl>* result,
+void RunTask(std::shared_ptr<InitializationResultImpl>& result,
              std::string_view command_id,
              const std::optional<std::string>& positional_args) {
   std::string_view path = "package.json";
@@ -153,7 +153,7 @@ void RunTask(std::unique_ptr<InitializationResultImpl>* result,
   // No need to exclude BOM since simdjson will skip it.
   if (ReadFileSync(&raw_json, path.data()) < 0) {
     fprintf(stderr, "Can't read package.json\n");
-    result->get()->exit_code_ = ExitCode::kGenericUserError;
+    result.get()->exit_code_ = ExitCode::kGenericUserError;
     return;
   }
 
@@ -165,22 +165,22 @@ void RunTask(std::unique_ptr<InitializationResultImpl>* result,
   // If document is not an object, throw an error.
   if (error || document.get_object().get(main_object)) {
     fprintf(stderr, "Can't parse package.json\n");
-    result->get()->exit_code_ = ExitCode::kGenericUserError;
+    result.get()->exit_code_ = ExitCode::kGenericUserError;
     return;
   }
 
   // If package_json object doesn't have "scripts" field, throw an error.
   simdjson::ondemand::object scripts_object;
-  if (main_object.find_field("scripts").get_object().get(scripts_object)) {
+  if (main_object["scripts"].get_object().get(scripts_object)) {
     fprintf(stderr, "Can't find \"scripts\" field in package.json\n");
-    result->get()->exit_code_ = ExitCode::kGenericUserError;
+    result.get()->exit_code_ = ExitCode::kGenericUserError;
     return;
   }
 
   // If the command_id is not found in the scripts object, throw an error.
   std::string_view command;
-  if (scripts_object.find_field(command_id).get_string().get(command)) {
-    fprintf(stderr, "Missing script: \"%s\"\n\n", command_id.data());
+  if (scripts_object[command_id].get_string().get(command)) {
+    fprintf(stderr, "Missing script: \"%.*s\"\n\n", static_cast<int>(command_id.size()), command_id.data());
     fprintf(stderr, "Available scripts are:\n");
 
     // Reset the object to iterate over it again
@@ -192,12 +192,12 @@ void RunTask(std::unique_ptr<InitializationResultImpl>* result,
       if (!field.unescaped_key().get(key_str) && !field.value().get(value) &&
           !value.get_string().get(value_str)) {
         fprintf(stderr,
-                "  %s: %s\n",
-                std::string(key_str).c_str(),
-                std::string(value_str).c_str());
+                "  %.*s: %.*s\n",
+                static_cast<int>(key_str.size()), key_str.data(),
+                static_cast<int>(value_str.size()), value_str.data());
       }
     }
-    result->get()->exit_code_ = ExitCode::kGenericUserError;
+    result.get()->exit_code_ = ExitCode::kGenericUserError;
     return;
   }
 

src/node_task_runner.h

@@ -16,7 +16,7 @@ namespace task_runner {
 
 class ProcessRunner {
  public:
-  ProcessRunner(std::unique_ptr<InitializationResultImpl>* result,
+  ProcessRunner(std::shared_ptr<InitializationResultImpl>& result,
                 std::string_view command_id,
                 const std::optional<std::string>& positional_args);
   void Run();
@@ -29,14 +29,14 @@ class ProcessRunner {
   uv_process_t process_{};
   uv_process_options_t options_{};
   uv_stdio_container_t child_stdio[3];
-  std::unique_ptr<InitializationResultImpl>* init_result;
+  std::shared_ptr<InitializationResultImpl> init_result;
   std::vector<std::string> command_args_{};
   std::vector<std::string> env_vars_{};
 
   void OnExit(int64_t exit_status, int term_signal);
 };
 
-void RunTask(std::unique_ptr<InitializationResultImpl>* result,
+void RunTask(std::shared_ptr<InitializationResultImpl>& result,
              std::string_view command_id,
              const std::optional<std::string>& positional_args);
 std::optional<std::string> GetPositionalArgs(

test/embedding/embedtest.cc

@@ -30,7 +30,7 @@ static int RunNodeInstance(MultiIsolatePlatform* platform,
 int main(int argc, char** argv) {
   argv = uv_setup_args(argc, argv);
   std::vector<std::string> args(argv, argv + argc);
-  std::unique_ptr<node::InitializationResult> result =
+  std::shared_ptr<node::InitializationResult> result =
       node::InitializeOncePerProcess(
           args,
           {node::ProcessInitializationFlags::kNoInitializeV8,

tools/snapshot/node_mksnapshot.cc

@@ -61,7 +61,7 @@ int BuildSnapshot(int argc, char* argv[]) {
     return 1;
   }
 
-  std::unique_ptr<node::InitializationResult> result =
+  std::shared_ptr<node::InitializationResult> result =
       node::InitializeOncePerProcess(
           std::vector<std::string>(argv, argv + argc),
           node::ProcessInitializationFlags::kGeneratePredictableSnapshot);