src: implement initial simdjson parser

araujogui · araujogui · commit 5bf3d88f859a · 2026-02-02T16:22:02.000-03:00
diff --git a/lib/internal/bootstrap/realm.js b/lib/internal/bootstrap/realm.js
@@ -129,6 +129,7 @@ const schemelessBlockList = new SafeSet([
   'quic',
   'test',
   'test/reporters',
+  'json',
 ]);
 // Modules that will only be enabled at run time.
 const experimentalModuleList = new SafeSet(['sqlite', 'quic']);
diff --git a/lib/json.js b/lib/json.js
@@ -0,0 +1,23 @@
+'use strict';
+
+const {
+  parse,
+} = internalBinding('json_parser');
+
+const {
+  validateString,
+} = require('internal/validators');
+
+/**
+ * Parse a JSON string using simdjson.
+ * @param {string} text - The JSON string to parse.
+ * @returns {unknown} - The parsed value.
+ */
+function parseJSON(text) {
+  validateString(text, 'text');
+  return parse(text);
+}
+
+module.exports = {
+  parse: parseJSON,
+};
diff --git a/node.gyp b/node.gyp
@@ -125,6 +125,7 @@
       'src/node_external_reference.cc',
       'src/node_file.cc',
       'src/node_http_parser.cc',
+      'src/node_json_parser.cc',
       'src/node_http2.cc',
       'src/node_i18n.cc',
       'src/node_locks.cc',
@@ -257,6 +258,7 @@
       'src/node_file-inl.h',
       'src/node_http_common.h',
       'src/node_http_common-inl.h',
+      'src/node_json_parser.h',
       'src/node_http2.h',
       'src/node_http2_state.h',
       'src/node_i18n.h',
diff --git a/src/node_binding.cc b/src/node_binding.cc
@@ -60,6 +60,7 @@
   V(internal_only_v8)                                                          \
   V(js_stream)                                                                 \
   V(js_udp_wrap)                                                               \
+  V(json_parser)                                                               \
   V(locks)                                                                     \
   V(messaging)                                                                 \
   V(modules)                                                                   \
diff --git a/src/node_external_reference.h b/src/node_external_reference.h
@@ -80,6 +80,7 @@ class ExternalReferenceRegistry {
   V(heap_utils)                                                                \
   V(http_parser)                                                               \
   V(internal_only_v8)                                                          \
+  V(json_parser)                                                               \
   V(locks)                                                                     \
   V(messaging)                                                                 \
   V(mksnapshot)                                                                \
diff --git a/src/node_json_parser.cc b/src/node_json_parser.cc
@@ -0,0 +1,316 @@
+#include "node_json_parser.h"
+#include "env-inl.h"
+#include "node_errors.h"
+#include "node_external_reference.h"
+#include "simdjson.h"
+#include "util-inl.h"
+
+#include <string>
+
+namespace node {
+namespace json_parser {
+
+using v8::Array;
+using v8::Context;
+using v8::EscapableHandleScope;
+using v8::Exception;
+using v8::FunctionCallbackInfo;
+using v8::Isolate;
+using v8::Local;
+using v8::MaybeLocal;
+using v8::Number;
+using v8::Object;
+using v8::String;
+using v8::Value;
+
+namespace {
+
+MaybeLocal<Value> ConvertSimdjsonValue(Isolate* isolate,
+                                       simdjson::ondemand::value element);
+
+MaybeLocal<Object> ConvertSimdjsonObject(Isolate* isolate,
+                                         simdjson::ondemand::object obj) {
+  EscapableHandleScope handle_scope(isolate);
+  Local<Context> context = isolate->GetCurrentContext();
+  Local<Object> result = Object::New(isolate);
+
+  for (auto field : obj) {
+    std::string_view key;
+    if (field.unescaped_key().get(key)) continue;
+
+    simdjson::ondemand::value val;
+    if (field.value().get(val)) continue;
+
+    Local<String> v8_key;
+    if (!String::NewFromUtf8(isolate,
+                             key.data(),
+                             v8::NewStringType::kNormal,
+                             key.length())
+             .ToLocal(&v8_key)) {
+      return MaybeLocal<Object>();
+    }
+
+    Local<Value> v8_value;
+    if (!ConvertSimdjsonValue(isolate, val).ToLocal(&v8_value)) {
+      return MaybeLocal<Object>();
+    }
+
+    if (result->Set(context, v8_key, v8_value).IsNothing()) {
+      return MaybeLocal<Object>();
+    }
+  }
+
+  return handle_scope.Escape(result);
+}
+
+MaybeLocal<Array> ConvertSimdjsonArray(Isolate* isolate,
+                                       simdjson::ondemand::array arr) {
+  EscapableHandleScope handle_scope(isolate);
+  Local<Context> context = isolate->GetCurrentContext();
+
+  size_t count = 0;
+  for (auto element : arr) {
+    (void)element;
+    count++;
+  }
+
+  arr.reset();
+
+  Local<Array> result = Array::New(isolate, count);
+
+  size_t index = 0;
+  for (auto element : arr) {
+    simdjson::ondemand::value val;
+    if (element.get(val)) continue;
+
+    Local<Value> v8_value;
+    if (!ConvertSimdjsonValue(isolate, val).ToLocal(&v8_value)) {
+      return MaybeLocal<Array>();
+    }
+
+    if (result->Set(context, index++, v8_value).IsNothing()) {
+      return MaybeLocal<Array>();
+    }
+  }
+
+  return handle_scope.Escape(result);
+}
+
+MaybeLocal<Value> ConvertSimdjsonValue(Isolate* isolate,
+                                       simdjson::ondemand::value element) {
+  EscapableHandleScope handle_scope(isolate);
+
+  simdjson::ondemand::json_type type;
+  if (element.type().get(type)) {
+    return handle_scope.Escape(v8::Undefined(isolate));
+  }
+
+  Local<Value> result;
+
+  switch (type) {
+    case simdjson::ondemand::json_type::object: {
+      simdjson::ondemand::object obj;
+      if (element.get_object().get(obj)) {
+        return handle_scope.Escape(v8::Undefined(isolate));
+      }
+      Local<Object> obj_result;
+      if (!ConvertSimdjsonObject(isolate, obj).ToLocal(&obj_result)) {
+        return MaybeLocal<Value>();
+      }
+      result = obj_result;
+      break;
+    }
+    case simdjson::ondemand::json_type::array: {
+      simdjson::ondemand::array arr;
+      if (element.get_array().get(arr)) {
+        return handle_scope.Escape(v8::Undefined(isolate));
+      }
+      Local<Array> arr_result;
+      if (!ConvertSimdjsonArray(isolate, arr).ToLocal(&arr_result)) {
+        return MaybeLocal<Value>();
+      }
+      result = arr_result;
+      break;
+    }
+    case simdjson::ondemand::json_type::string: {
+      std::string_view str;
+      if (element.get_string().get(str)) {
+        return handle_scope.Escape(v8::Undefined(isolate));
+      }
+      Local<String> str_result;
+      if (!String::NewFromUtf8(
+               isolate, str.data(), v8::NewStringType::kNormal, str.length())
+               .ToLocal(&str_result)) {
+        return MaybeLocal<Value>();
+      }
+      result = str_result;
+      break;
+    }
+    case simdjson::ondemand::json_type::number: {
+      simdjson::ondemand::number num;
+      if (element.get_number().get(num)) {
+        return handle_scope.Escape(v8::Undefined(isolate));
+      }
+      if (num.is_int64()) {
+        result = Number::New(isolate, static_cast<double>(num.get_int64()));
+      } else if (num.is_uint64()) {
+        result = Number::New(isolate, static_cast<double>(num.get_uint64()));
+      } else {
+        result = Number::New(isolate, num.get_double());
+      }
+      break;
+    }
+    case simdjson::ondemand::json_type::boolean: {
+      bool val;
+      if (element.get_bool().get(val)) {
+        return handle_scope.Escape(v8::Undefined(isolate));
+      }
+      result = v8::Boolean::New(isolate, val);
+      break;
+    }
+    case simdjson::ondemand::json_type::null: {
+      result = v8::Null(isolate);
+      break;
+    }
+    case simdjson::ondemand::json_type::unknown:
+      result = v8::Undefined(isolate);
+      break;
+  }
+
+  return handle_scope.Escape(result);
+}
+
+MaybeLocal<Value> ConvertSimdjsonDocument(Isolate* isolate,
+                                          simdjson::ondemand::document& doc,
+                                          simdjson::ondemand::json_type type) {
+  EscapableHandleScope handle_scope(isolate);
+  Local<Value> result;
+
+  switch (type) {
+    case simdjson::ondemand::json_type::object: {
+      simdjson::ondemand::object obj;
+      if (doc.get_object().get(obj)) {
+        return handle_scope.Escape(v8::Undefined(isolate));
+      }
+      Local<Object> obj_result;
+      if (!ConvertSimdjsonObject(isolate, obj).ToLocal(&obj_result)) {
+        return MaybeLocal<Value>();
+      }
+      result = obj_result;
+      break;
+    }
+    case simdjson::ondemand::json_type::array: {
+      simdjson::ondemand::array arr;
+      if (doc.get_array().get(arr)) {
+        return handle_scope.Escape(v8::Undefined(isolate));
+      }
+      Local<Array> arr_result;
+      if (!ConvertSimdjsonArray(isolate, arr).ToLocal(&arr_result)) {
+        return MaybeLocal<Value>();
+      }
+      result = arr_result;
+      break;
+    }
+    case simdjson::ondemand::json_type::string: {
+      std::string_view str;
+      if (doc.get_string().get(str)) {
+        return handle_scope.Escape(v8::Undefined(isolate));
+      }
+      Local<String> str_result;
+      if (!String::NewFromUtf8(
+               isolate, str.data(), v8::NewStringType::kNormal, str.length())
+               .ToLocal(&str_result)) {
+        return MaybeLocal<Value>();
+      }
+      result = str_result;
+      break;
+    }
+    case simdjson::ondemand::json_type::number: {
+      double val;
+      if (doc.get_double().get(val)) {
+        return handle_scope.Escape(v8::Undefined(isolate));
+      }
+      result = Number::New(isolate, val);
+      break;
+    }
+    case simdjson::ondemand::json_type::boolean: {
+      bool val;
+      if (doc.get_bool().get(val)) {
+        return handle_scope.Escape(v8::Undefined(isolate));
+      }
+      result = v8::Boolean::New(isolate, val);
+      break;
+    }
+    case simdjson::ondemand::json_type::null: {
+      result = v8::Null(isolate);
+      break;
+    }
+    case simdjson::ondemand::json_type::unknown:
+      result = v8::Undefined(isolate);
+      break;
+  }
+
+  return handle_scope.Escape(result);
+}
+
+}
+
+void Parse(const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+
+  if (args.Length() < 1 || !args[0]->IsString()) {
+    isolate->ThrowException(Exception::TypeError(
+        FIXED_ONE_BYTE_STRING(isolate, "JSON argument must be a string")));
+    return;
+  }
+
+  Local<String> v8_str = args[0].As<String>();
+  String::Utf8Value utf8_str(isolate, v8_str);
+  std::string json_str(*utf8_str, utf8_str.length());
+
+  simdjson::padded_string padded(json_str);
+  simdjson::ondemand::parser parser;
+  simdjson::ondemand::document doc;
+
+  auto error = parser.iterate(padded).get(doc);
+  if (error) {
+    isolate->ThrowException(Exception::SyntaxError(
+        FIXED_ONE_BYTE_STRING(isolate, "Invalid JSON")));
+    return;
+  }
+
+  simdjson::ondemand::json_type type;
+  error = doc.type().get(type);
+  if (error) {
+    isolate->ThrowException(Exception::SyntaxError(
+        FIXED_ONE_BYTE_STRING(isolate, "Invalid JSON")));
+    return;
+  }
+
+  Local<Value> result;
+
+  if (!ConvertSimdjsonDocument(isolate, doc, type).ToLocal(&result)) {
+    return;
+  }
+
+  args.GetReturnValue().Set(result);
+}
+
+void Initialize(Local<Object> target,
+                Local<Value> unused,
+                Local<Context> context,
+                void* priv) {
+  SetMethodNoSideEffect(context, target, "parse", Parse);
+}
+
+void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
+  registry->Register(Parse);
+}
+
+}
+}
+
+NODE_BINDING_CONTEXT_AWARE_INTERNAL(json_parser,
+                                    node::json_parser::Initialize)
+NODE_BINDING_EXTERNAL_REFERENCE(json_parser,
+                                node::json_parser::RegisterExternalReferences)
diff --git a/src/node_json_parser.h b/src/node_json_parser.h
diff --git a/test/parallel/test-json-parser.js b/test/parallel/test-json-parser.js
