@jsenv/fetch 1.2.9 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/fetch",
-  "version": "1.2.9",
+  "version": "1.3.0",
   "description": "Unified url fetcher (http, http, file, data)",
   "license": "MIT",
   "author": {
@@ -33,11 +33,11 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@jsenv/urls": "2.7.1",
-    "@jsenv/server": "16.0.7",
+    "@jsenv/urls": "2.7.3",
+    "@jsenv/server": "16.1.1",
     "node-fetch": "3.3.2"
   },
   "devDependencies": {
-    "@jsenv/server": "16.0.7"
+    "@jsenv/server": "16.1.1"
   }
 }

package/src/node/fetch_url_node.js

@@ -1,6 +1,6 @@
 // https://github.com/node-fetch/node-fetch/blob/8c197f8982a238b3c345c64b17bfa92e16b4f7c4/src/response.js#L1
 
-import { createFileSystemFetch } from "@jsenv/server";
+import { createFileSystemFetch } from "@jsenv/server/src/filesystem/fetch_filesystem.js";
 import {
   fileHandleToReadableStream,
   isFileHandle,

package/src/node/fetch_using_node_request.js

@@ -0,0 +1,92 @@
+import { observableFromNodeStream } from "@jsenv/server/src/interfacing_with_node/observable_from_node_stream.js";
+
+export const fetchUsingNodeRequest = async (
+  url,
+  { signal, method = "GET", headers = {}, body, path, ignoreHttpsError } = {},
+) => {
+  let createNodeRequest;
+  if (url.startsWith("http:")) {
+    const { request } = await import("node:http");
+    createNodeRequest = request;
+  } else {
+    const { request } = await import("node:https");
+    createNodeRequest = request;
+  }
+
+  const urlObject = new URL(url);
+  const { port, hostname } = urlObject;
+  const options = {
+    signal,
+    hostname,
+    port,
+    method,
+    headers: {
+      ...(body ? { "content-length": Buffer.byteLength(body) } : {}),
+      ...headers,
+    },
+    path: path || urlObject.pathname,
+  };
+  if (ignoreHttpsError && url.startsWith("https")) {
+    const { Agent } = await import("node:https");
+    options.agent = new Agent({
+      rejectUnauthorized: false,
+    });
+  }
+
+  const nodeRequest = createNodeRequest(options);
+  if (body) {
+    nodeRequest.write(body);
+  }
+  nodeRequest.end();
+
+  const nodeResponse = await new Promise((resolve, reject) => {
+    nodeRequest.on("error", (error) => {
+      console.error(`error event triggered on request to ${url}`);
+      reject(error);
+    });
+    nodeRequest.on("response", (nodeResponse) => {
+      resolve(nodeResponse);
+    });
+  });
+  const responseBody = observableFromNodeStream(nodeResponse);
+  // ideally we would not wait for the response to return a response object
+  // for now I can't make node.fetch + Response + all things work together here
+  // and this util is not used in production so it's good enough for now
+  const responseBodyBuffer = await new Promise((resolve, reject) => {
+    const bufferArray = [];
+    responseBody.subscribe(
+      {
+        next: (data) => {
+          bufferArray.push(data);
+        },
+        error: (value) => {
+          reject(value);
+        },
+        complete: () => {
+          resolve(Buffer.concat(bufferArray));
+        },
+      },
+      { signal },
+    );
+  });
+
+  return {
+    url,
+    status: nodeResponse.statusCode,
+    statusText: nodeResponse.statusMessage,
+    headers: new Map(Object.entries(nodeResponse.headers)),
+    body: responseBodyBuffer,
+    arrayBuffer: async () => {
+      return responseBodyBuffer;
+    },
+    text: async () => {
+      const responseBodyString = responseBodyBuffer.toString();
+      return responseBodyString;
+    },
+    json: async () => {
+      const responseBodyString = responseBodyBuffer.toString();
+      const responseBodyJSON = JSON.parse(responseBodyString);
+      return responseBodyJSON;
+    },
+  };
+};