Add tests for Web and Node builtins in WebNodeBuiltins.js

- Implement tests to verify the presence and functionality of web globals such as fetch, Headers, Request, Response, WebSocket, and ReadableStream.
- Include tests for internal web modules and ensure case-insensitivity in Headers.
- Add tests for Request and Response body helpers, fetch URL validation, and WebSocket URL scheme validation.
- Introduce tests for Node's fs and node:fs modules, covering file reading/writing, binary data handling, directory operations, and support for both callback and promise forms.
- Ensure dynamic import functionality for web and fs modules is tested.

Author: DjDeveloperr

NativeScript/CMakeLists.txt

@@ -151,10 +151,13 @@ if(ENABLE_JS_RUNTIME)
     runtime/modules/worker/WorkerImpl.mm
     runtime/modules/worker/WorkerImpl.mm
     runtime/modules/module/ModuleInternal.cpp
+    runtime/modules/node/Node.cpp
+    runtime/modules/node/FS.cpp
     runtime/modules/performance/Performance.cpp
     runtime/Bundle.mm
     runtime/modules/timers/Timers.mm
     runtime/modules/app/App.mm
+    runtime/modules/web/Web.mm
     runtime/NativeScript.mm
     runtime/RuntimeConfig.cpp
     runtime/modules/url/ada/ada.cpp

NativeScript/ffi/TypeConv.mm

@@ -1375,7 +1375,12 @@ void toNative(napi_env env, napi_value value, void* result, bool* shouldFree,
                 resolvedType->type->size > 0) {
               pointeeSize = resolvedType->type->size;
             }
-            ref->data = malloc(pointeeSize);
+            ref->data = calloc(1, pointeeSize);
+            if (ref->data == nullptr) {
+              napi_throw_error(env, nullptr, "Out of memory while allocating out parameter");
+              *res = nullptr;
+              return;
+            }
             ref->ownsData = true;
             if (ref->initValue) {
               napi_value initValue = get_ref_value(env, ref->initValue);
@@ -2572,6 +2577,15 @@ void toNative(napi_env env, napi_value value, void* result, bool* shouldFree,
     return info;
   }
 
+  inline size_t getStructSize(napi_env env) {
+    if (this->type != nullptr && this->type->size > 0) {
+      return this->type->size;
+    }
+
+    auto info = getInfo(env);
+    return info != nullptr ? info->size : 0;
+  }
+
   napi_value toJS(napi_env env, void* value, uint32_t flags) override {
     auto info = getInfo(env);
 
@@ -2590,6 +2604,12 @@ void toNative(napi_env env, napi_value value, void* result, bool* shouldFree,
                 bool* shouldFreeAny) override {
     NAPI_PREAMBLE
 
+    const size_t structSize = getStructSize(env);
+    if (structSize == 0) {
+      napi_throw_type_error(env, "TypeError", "Invalid struct size");
+      return;
+    }
+
     bool isTypedArray = false;
     napi_is_typedarray(env, value, &isTypedArray);
 
@@ -2601,8 +2621,10 @@ void toNative(napi_env env, napi_value value, void* result, bool* shouldFree,
         NAPI_THROW_LAST_ERROR
         return;
       }
-
-      memcpy(result, data, length * getTypedArrayUnitLength(type));
+      const size_t unitLength = getTypedArrayUnitLength(type);
+      const size_t byteLength = length * unitLength;
+      memset(result, 0, structSize);
+      memcpy(result, data, std::min(byteLength, structSize));
 
       return;
     }
@@ -2631,7 +2653,9 @@ void toNative(napi_env env, napi_value value, void* result, bool* shouldFree,
 
     auto structObject = StructObject::unwrap(env, value);
     if (structObject != nullptr) {
-      memcpy(result, structObject->data, structObject->info->size);
+      const size_t copySize = std::min(static_cast<size_t>(structObject->info->size), structSize);
+      memset(result, 0, structSize);
+      memcpy(result, structObject->data, copySize);
       return;
     }
 
@@ -2643,7 +2667,14 @@ void toNative(napi_env env, napi_value value, void* result, bool* shouldFree,
       return;
     }
 
-    // Serialize directly to previously allocated memory
+    if (structSize < info->size) {
+      std::vector<uint8_t> storage(info->size, 0);
+      StructObject(env, info, value, storage.data());
+      memcpy(result, storage.data(), structSize);
+      return;
+    }
+
+    // Serialize directly to previously allocated memory.
     StructObject(env, info, value, result);
   }
 };
@@ -2868,8 +2899,7 @@ void copyToInlineArrayStorage(napi_env env, napi_value value, void* result, bool
   std::shared_ptr<TypeConv> elementType;
   MDTypeKind vectorKind;
 
-  VectorTypeConv(MDTypeKind vectorKind, uint16_t vectorSize,
-                 std::shared_ptr<TypeConv> elementType)
+  VectorTypeConv(MDTypeKind vectorKind, uint16_t vectorSize, std::shared_ptr<TypeConv> elementType)
       : vectorSize(vectorSize), elementType(elementType), vectorKind(vectorKind) {
     auto vectorType = new ffi_type();
 #if defined(FFI_TYPE_EXT_VECTOR)
@@ -2882,10 +2912,12 @@ void copyToInlineArrayStorage(napi_env env, napi_value value, void* result, bool
     size_t abiLanes = lanes == 3 ? 4 : lanes;
     vectorType->elements = (ffi_type**)malloc(sizeof(ffi_type*) * (abiLanes + 1));
 
-    ffi_type* elementFfiType =
-        elementType != nullptr && elementType->type != nullptr ? elementType->type : &ffi_type_float;
+    ffi_type* elementFfiType = elementType != nullptr && elementType->type != nullptr
+                                   ? elementType->type
+                                   : &ffi_type_float;
     const size_t elementSize = std::max<size_t>(elementFfiType->size, sizeof(float));
-    const size_t elementAlignment = std::max<size_t>(elementFfiType->alignment, static_cast<size_t>(1));
+    const size_t elementAlignment =
+        std::max<size_t>(elementFfiType->alignment, static_cast<size_t>(1));
 
     for (size_t i = 0; i < abiLanes; i++) {
       vectorType->elements[i] = elementFfiType;

NativeScript/napi/v8/v8-module-loader.cpp

@@ -7,6 +7,7 @@
 #include <filesystem>
 #include <fstream>
 #include <sstream>
+#include <unordered_set>
 
 #include "runtime/RuntimeConfig.h"
 
@@ -57,7 +58,11 @@ std::string ModulePathToURL(const std::string& modulePath) {
 }
 
 bool IsNodeBuiltinSpecifier(const std::string& specifier) {
-  return specifier == "node:url" || specifier == "url";
+  static const std::unordered_set<std::string> kBuiltins = {
+      "url",         "node:url",         "fs",  "node:fs",
+      "fs/promises", "node:fs/promises", "web", "node:web",
+      "stream/web",  "node:stream/web"};
+  return kBuiltins.contains(specifier);
 }
 
 std::string NormalizeNodeBuiltinSpecifier(const std::string& specifier) {
@@ -89,6 +94,109 @@ export default { URL, URLSearchParams, pathToFileURL, fileURLToPath };
 )";
   }
 
+  if (builtinName == "fs") {
+    return R"(
+const __load = (name) => {
+  if (typeof globalThis.require === "function") {
+    return globalThis.require(name);
+  }
+  if (typeof globalThis.__nativeRequire === "function") {
+    const dir = typeof globalThis.__approot === "string" ? `${globalThis.__approot}/app` : "";
+    return globalThis.__nativeRequire(name, dir);
+  }
+  throw new Error(`Cannot load builtin module '${name}'`);
+};
+const __fs = __load("node:fs");
+export const readFileSync = __fs.readFileSync;
+export const writeFileSync = __fs.writeFileSync;
+export const existsSync = __fs.existsSync;
+export const mkdirSync = __fs.mkdirSync;
+export const readdirSync = __fs.readdirSync;
+export const statSync = __fs.statSync;
+export const lstatSync = __fs.lstatSync;
+export const unlinkSync = __fs.unlinkSync;
+export const rmSync = __fs.rmSync;
+export const readFile = __fs.readFile;
+export const writeFile = __fs.writeFile;
+export const constants = __fs.constants;
+export const promises = __fs.promises;
+export default __fs;
+)";
+  }
+
+  if (builtinName == "fs/promises") {
+    return R"(
+const __load = (name) => {
+  if (typeof globalThis.require === "function") {
+    return globalThis.require(name);
+  }
+  if (typeof globalThis.__nativeRequire === "function") {
+    const dir = typeof globalThis.__approot === "string" ? `${globalThis.__approot}/app` : "";
+    return globalThis.__nativeRequire(name, dir);
+  }
+  throw new Error(`Cannot load builtin module '${name}'`);
+};
+const __fsp = __load("node:fs").promises;
+export const readFile = __fsp.readFile;
+export const writeFile = __fsp.writeFile;
+export const mkdir = __fsp.mkdir;
+export const readdir = __fsp.readdir;
+export const stat = __fsp.stat;
+export const lstat = __fsp.lstat;
+export const unlink = __fsp.unlink;
+export const rm = __fsp.rm;
+export default __fsp;
+)";
+  }
+
+  if (builtinName == "web") {
+    return R"(
+const __load = (name) => {
+  if (typeof globalThis.require === "function") {
+    return globalThis.require(name);
+  }
+  if (typeof globalThis.__nativeRequire === "function") {
+    const dir = typeof globalThis.__approot === "string" ? `${globalThis.__approot}/app` : "";
+    return globalThis.__nativeRequire(name, dir);
+  }
+  throw new Error(`Cannot load builtin module '${name}'`);
+};
+const __web = __load("web");
+export const fetch = __web.fetch;
+export const Headers = __web.Headers;
+export const Request = __web.Request;
+export const Response = __web.Response;
+export const WebSocket = __web.WebSocket;
+export const ReadableStream = __web.ReadableStream;
+export const WritableStream = __web.WritableStream;
+export const TransformStream = __web.TransformStream;
+export default __web;
+)";
+  }
+
+  if (builtinName == "stream/web") {
+    return R"(
+const __load = (name) => {
+  if (typeof globalThis.require === "function") {
+    return globalThis.require(name);
+  }
+  if (typeof globalThis.__nativeRequire === "function") {
+    const dir = typeof globalThis.__approot === "string" ? `${globalThis.__approot}/app` : "";
+    return globalThis.__nativeRequire(name, dir);
+  }
+  throw new Error(`Cannot load builtin module '${name}'`);
+};
+const __streamWeb = __load("stream/web");
+export const ReadableStream = __streamWeb.ReadableStream;
+export const ReadableStreamDefaultReader = __streamWeb.ReadableStreamDefaultReader;
+export const WritableStream = __streamWeb.WritableStream;
+export const TransformStream = __streamWeb.TransformStream;
+export const ByteLengthQueuingStrategy = __streamWeb.ByteLengthQueuingStrategy;
+export const CountQueuingStrategy = __streamWeb.CountQueuingStrategy;
+export default __streamWeb;
+)";
+  }
+
   return "";
 }
 
@@ -456,6 +564,7 @@ v8::MaybeLocal<v8::Promise> ImportModuleDynamicallyCallback(
                                             isolate, "Failed to resolve module")
                                             .ToLocalChecked()))
           .Check();
+      isolate->PerformMicrotaskCheckpoint();
       return scope.Escape(resolver->GetPromise());
     }
 
@@ -469,6 +578,7 @@ v8::MaybeLocal<v8::Promise> ImportModuleDynamicallyCallback(
                                       isolate, "Failed to instantiate module")
                                       .ToLocalChecked()))
             .Check();
+        isolate->PerformMicrotaskCheckpoint();
         return scope.Escape(resolver->GetPromise());
       }
     }
@@ -481,11 +591,13 @@ v8::MaybeLocal<v8::Promise> ImportModuleDynamicallyCallback(
                                       isolate, "Failed to evaluate module")
                                       .ToLocalChecked()))
             .Check();
+        isolate->PerformMicrotaskCheckpoint();
         return scope.Escape(resolver->GetPromise());
       }
     }
 
     resolver->Resolve(context, module->GetModuleNamespace()).Check();
+    isolate->PerformMicrotaskCheckpoint();
 
   } catch (const std::exception& e) {
     resolver
@@ -494,6 +606,7 @@ v8::MaybeLocal<v8::Promise> ImportModuleDynamicallyCallback(
             v8::Exception::Error(
                 v8::String::NewFromUtf8(isolate, e.what()).ToLocalChecked()))
         .Check();
+    isolate->PerformMicrotaskCheckpoint();
   }
 
   return scope.Escape(resolver->GetPromise());

NativeScript/runtime/modules/RuntimeModules.h

@@ -3,12 +3,14 @@
 
 #include "console/Console.h"
 #include "js_native_api_types.h"
+#include "node/Node.h"
 #include "performance/Performance.h"
 #include "runtime/RuntimeConfig.h"
 #include "runtime/modules/module/ModuleInternal.h"
 #include "runtime/modules/worker/Worker.h"
 #include "url/URL.h"
 #include "url/URLSearchParams.h"
+#include "web/Web.h"
 #ifdef __APPLE__
 #include "app/App.h"
 #include "timers/Timers.h"
@@ -28,10 +30,12 @@ class RuntimeModules {
 
     Console::Init(env, global);
     Performance::Init(env, global);
+    Node::Init(env, global);
 
 #ifdef __APPLE__
     App::Init(env);
     Timers::Init(env, global);
+    Web::Init(env, global);
 #endif  // __APPLE__
 
     Worker::Init(env, global);