@aresdefencelabs/wasm-http-runtime 0.1.7 → 0.1.9

package/hostingEngine/wasm-http-runtime.js

@@ -104,10 +104,6 @@ export function createWasmHttpRuntime(config) {
         view.setUint32(start + 4, 0, true);
     }
 
-    function headersToObject(headers) {
-        return Object.fromEntries(headers.entries());
-    }
-
     function utf8ByteLength(value) {
         return encoder.encode(value).length;
     }
@@ -120,6 +116,35 @@ export function createWasmHttpRuntime(config) {
         return out;
     }
 
+    function searchParamsToObject(searchParams) {
+        const out = {};
+        for (const [key, value] of searchParams.entries()) {
+            out[key] = value;
+        }
+        return out;
+    }
+
+    async function readRequestBodyAsText(request) {
+        if (request.method === "GET" || request.method === "HEAD") {
+            return "";
+        }
+        return await request.text();
+    }
+
+    async function buildInboundEnvelope(request) {
+        const url = new URL(request.url);
+        const bodyText = await readRequestBodyAsText(request);
+
+        return {
+            method: request.method,
+            url: request.url,
+            path: url.pathname,
+            body: bodyText,
+            headers: normalizeHeaders(request.headers),
+            query: searchParamsToObject(url.searchParams),
+        };
+    }
+
     function estimateResponseBytes(resp) {
         let total = utf8ByteLength(resp.bodyText);
         for (const [k, v] of Object.entries(resp.headers)) {
@@ -207,7 +232,6 @@ export function createWasmHttpRuntime(config) {
         }
 
         const heap = getHeapU8(mod);
-
         if (ptr + encoded.length + 1 > heap.length) {
             throw new Error("Allocated CString buffer exceeds wasm memory bounds");
         }
@@ -274,6 +298,27 @@ export function createWasmHttpRuntime(config) {
         });
     }
 
+    function normalizeResponseEnvelope(responseEnvelope) {
+        const status = Number.isInteger(responseEnvelope?.status)
+            ? responseEnvelope.status
+            : 200;
+
+        const headers =
+            responseEnvelope?.headers &&
+            typeof responseEnvelope.headers === "object" &&
+            !Array.isArray(responseEnvelope.headers)
+                ? responseEnvelope.headers
+                : { "content-type": "application/json; charset=utf-8" };
+
+        let body = responseEnvelope?.body ?? "";
+
+        if (typeof body !== "string") {
+            body = JSON.stringify(body);
+        }
+
+        return { status, headers, body };
+    }
+
     function makeBaseImports() {
         return {
             env: {
@@ -318,7 +363,6 @@ export function createWasmHttpRuntime(config) {
 
         instancePromise = (async () => {
             const baseImports = makeBaseImports();
-
             let mod = null;
 
             mod = await createModule({
@@ -366,34 +410,25 @@ export function createWasmHttpRuntime(config) {
 
                     try {
                         const requestJson = readCStringFromModule(mod, requestJsonCstrPtr);
-                        log("[AresHost] requestJson =", requestJson);
-
                         const outbound = JSON.parse(requestJson);
-                        log("[AresHost] parsed outbound =", outbound);
 
                         if (typeof state.options.beforeOutboundFetch === "function") {
                             state.options.beforeOutboundFetch(outbound);
                         }
 
-                        log("[AresHost] before fetch:", outbound.url);
-
                         const response = await fetch(outbound.url, {
                             method: outbound.method ?? "GET",
-                            headers: outbound.headers,
+                            headers: outbound.headers ?? {},
                             body: outbound.body ?? undefined,
                         });
 
-                        log("[AresHost] fetch returned, status =", response.status);
-
                         const bodyText = await response.text();
-                        log("[AresHost] response.text resolved, length =", bodyText.length);
 
                         if (typeof state.options.afterOutboundFetch === "function") {
                             state.options.afterOutboundFetch(response, bodyText, outbound);
                         }
 
                         const bodyBytes = utf8ByteLength(bodyText);
-
                         if (bodyBytes > state.options.maxResponseBodyBytes) {
                             throw new Error(
                                 `HTTP response body too large: ${bodyBytes} bytes exceeds maxResponseBodyBytes=${state.options.maxResponseBodyBytes}`
@@ -417,8 +452,6 @@ export function createWasmHttpRuntime(config) {
                             estimatedBytes,
                         });
 
-                        log("[AresHost] stored responseId =", responseId);
-
                         return responseId >>> 0;
                     } catch (error) {
                         console.error("[AresHost] __aresAbiHttpFetchBlockingAsync failed:", error);
@@ -495,19 +528,11 @@ export function createWasmHttpRuntime(config) {
                 throw new Error("WASM runtime method ccall() is not available");
             }
 
-            const bodyText = await request.text();
-            const url = new URL(request.url);
+            const inboundEnvelope = await buildInboundEnvelope(request);
+            const requestJson = JSON.stringify(inboundEnvelope);
 
-            const inboundEnvelope = {
-                url: request.url,
-                path: url.pathname,
-                query: url.search,
-                method: request.method,
-                headers: headersToObject(request.headers),
-                body: bodyText,
-            };
+            log("[AresHost] inbound envelope =", inboundEnvelope);
 
-            const requestJson = JSON.stringify(inboundEnvelope);
             const written = writeCString(mod, requestJson);
             requestPtr = written.ptr;
             requestSize = written.size;
@@ -520,26 +545,22 @@ export function createWasmHttpRuntime(config) {
                 { async: true }
             );
 
-            log("[AresHost] ccall(handle_http) returned:", responsePtr);
-
             if (!responsePtr) {
                 throw new Error("WASM returned null response pointer");
             }
 
             const responseJson = readCStringFromModule(mod, responsePtr);
             const responseEnvelope = JSON.parse(responseJson);
+            const normalized = normalizeResponseEnvelope(responseEnvelope);
 
-            return new Response(
-                typeof responseEnvelope.body === "string"
-                    ? responseEnvelope.body
-                    : JSON.stringify(responseEnvelope.body ?? ""),
-                {
-                    status: responseEnvelope.status ?? 200,
-                    headers: responseEnvelope.headers ?? {
-                        "content-type": "application/json; charset=utf-8",
-                    },
-                }
-            );
+            log("[AresHost] response envelope =", normalized);
+
+            return new Response(normalized.body, {
+                responseCode: normalized.responseCode,
+                errorMessage: normalized.errorMessage,
+                isSuccess: normalized.isSuccess,
+                headers: normalized.headers,
+            });
         } catch (err) {
             if (typeof state.options.onError === "function") {
                 try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aresdefencelabs/wasm-http-runtime",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Runtime adapter that connects C++ WebAssembly workers to the Cloudflare Workers runtime via an ABI bridge.",
   "type": "module",
   "private": false,