@bytecodealliance/preview2-shim 0.0.21 → 0.14.1

package/lib/nodejs/http.js

@@ -1,46 +1,30 @@
-import { streams } from '../common/io.js';
-import { fileURLToPath } from 'node:url';
-import { createSyncFn } from '../synckit/index.js';
+import {
+  INPUT_STREAM_DISPOSE,
+  HTTP_CREATE_REQUEST,
+  HTTP_OUTPUT_STREAM_FINISH,
+  OUTPUT_STREAM_CREATE,
+  FUTURE_GET_VALUE_AND_DISPOSE,
+  FUTURE_DISPOSE,
+} from "../io/calls.js";
+import {
+  ioCall,
+  pollableCreate,
+  inputStreamCreate,
+  outputStreamCreate,
+  outputStreamId,
+} from "../io/worker-io.js";
+import { validateHeaderName, validateHeaderValue } from "node:http";
 
-const { InputStream, OutputStream } = streams;
+import { HTTP } from "../io/calls.js";
+
+const symbolDispose = Symbol.dispose || Symbol.for("dispose");
+export const _forbiddenHeaders = new Set(["connection", "keep-alive"]);
 
 /**
  * @typedef {import("../../types/interfaces/wasi-http-types").Method} Method
- * @typedef {import("../../types/interfaces/wasi-http-types").RequestOptions} RequestOptions
  * @typedef {import("../../types/interfaces/wasi-http-types").Scheme} Scheme
  * @typedef {import("../../types/interfaces/wasi-http-types").Error} HttpError
-*/
-
-const workerPath = fileURLToPath(new URL('../common/make-request.js', import.meta.url));
-
-function send(req) {
-  const syncFn = createSyncFn(workerPath);
-  let rawResponse = syncFn(req);
-  let response = JSON.parse(rawResponse);
-  if (response.status) {
-    return {
-      ...response,
-      body: response.body ? Buffer.from(response.body, 'base64') : undefined,
-    };
-  }
-  // HttpError
-  throw { tag: 'unexpected-error', val: response.message };
-}
-
-function combineChunks (chunks) {
-  if (chunks.length === 0)
-    return new Uint8Array();
-  if (chunks.length === 1)
-    return chunks[0];
-  const totalLen = chunks.reduce((total, chunk) => total + chunk.byteLength);
-  const out = new Uint8Array(totalLen);
-  let idx = 0;
-  for (const chunk of chunks) {
-    out.set(chunk, idx);
-    idx += chunk.byteLength;
-  }
-  return out;
-}
+ */
 
 export class WasiHttp {
   requestCnt = 1;
@@ -52,49 +36,84 @@ export class WasiHttp {
     const http = this;
 
     class IncomingBody {
-      #bodyFinished = false;
-      #chunks = [];
-      stream () {
-        const incomingBody = this;
-        return new InputStream({
-          blockingRead (_len) {
-            if (incomingBody.#bodyFinished)
-              throw { tag: 'closed' };
-            if (incomingBody.#chunks.length === 0)
-              return new Uint8Array([]);
-            // TODO: handle chunk splitting case where len is less than chunk length
-            return incomingBody.#chunks.shift();
-          },
-          subscribe () {
-            // TODO
-          }
-        });
+      #finished = false;
+      #streamId = undefined;
+      stream() {
+        if (!this.#streamId) throw undefined;
+        const streamId = this.#streamId;
+        this.#streamId = undefined;
+        return inputStreamCreate(HTTP, streamId);
       }
-      static finish (incomingBody) {
-        incomingBody.#bodyFinished = true;
+      static finish(incomingBody) {
+        if (incomingBody.#finished)
+          throw new Error("incoming body already finished");
+        incomingBody.#finished = true;
         return futureTrailersCreate(new Fields([]), false);
       }
-      static _addChunk (incomingBody, chunk) {
-        incomingBody.#chunks.push(chunk);
+      [symbolDispose]() {
+        if (!this.#finished) {
+          ioCall(INPUT_STREAM_DISPOSE | HTTP, this.#streamId);
+          this.#streamId = undefined;
+        }
+      }
+      static _create(streamId) {
+        const incomingBody = new IncomingBody();
+        incomingBody.#streamId = streamId;
+        return incomingBody;
       }
     }
-    const incomingBodyAddChunk = IncomingBody._addChunk;
-    delete IncomingBody._addChunk;
+    const incomingBodyCreate = IncomingBody._create;
+    delete IncomingBody._create;
 
-    // TODO
-    class IncomingRequest {}
+    class IncomingRequest {
+      #method;
+      #pathWithQuery;
+      #scheme;
+      #authority;
+      #headers;
+      #streamId;
+      method () {
+        return this.#method;
+      }
+      pathWithQuery () {
+        return this.#pathWithQuery;
+      }
+      scheme () {
+        return this.#scheme;
+      }
+      authority () {
+        return this.#authority;
+      }
+      headers () {
+        return this.#headers;
+      }
+      consume () {
+        return incomingBodyCreate(this.#streamId);
+      }
+      static _create(method, pathWithQuery, scheme, authority, streamId) {
+        const incomingRequest = new IncomingRequest();
+        incomingRequest.#method = method;
+        incomingRequest.#pathWithQuery = pathWithQuery;
+        incomingRequest.#scheme = scheme;
+        incomingRequest.#authority = authority;
+        incomingRequest.#streamId = streamId;
+        return incomingRequest;
+      }
+    }
+    const incomingRequestCreate = IncomingRequest._create;
+    delete IncomingRequest._create;
 
     class FutureTrailers {
-      id = this.futureCnt++;
+      _id = http.futureCnt++;
       #value;
       #isError;
-      subscribe () {
+      subscribe() {
         // TODO
       }
-      get () {
-        return { tag: this.#isError ? 'err' : 'ok', val: this.#value };
+      get() {
+        return { tag: this.#isError ? "err" : "ok", val: this.#value };
       }
-      static _create (value, isError) {
+      static _create(value, isError) {
         const res = new FutureTrailers();
         res.#value = value;
         res.#isError = isError;
@@ -105,72 +124,157 @@ export class WasiHttp {
     delete FutureTrailers._create;
 
     class OutgoingResponse {
-      id = http.responseCnt++;
-      /** @type {number} */ _statusCode;
-      /** @type {Fields} */ _headers;
+      _id = http.responseCnt++;
+      /** @type {number} */ #statusCode = 200;
+      /** @type {Fields} */ #headers;
 
       /**
-       * @param {number} statusCode 
-       * @param {Fields} headers 
+       * @param {number} statusCode
+       * @param {Fields} headers
        */
-      constructor (statusCode, headers) {
-        this._statusCode = statusCode;
-        this.headers = headers;
+      constructor(headers) {
+        fieldsLock(headers);
+        this.#headers = headers;
+      }
+
+      statusCode() {
+        return this.#statusCode;
+      }
+
+      setStatusCode(statusCode) {
+        this.#statusCode = statusCode;
+      }
+
+      headers() {
+        return this.#headers;
+      }
+
+      body() {
+        let contentLengthValues = this.#headers.get("content-length");
+        if (contentLengthValues.length === 0)
+          contentLengthValues = this.#headers.get("Content-Length");
+        let contentLength;
+        if (contentLengthValues.length > 0)
+          contentLength = Number(
+            new TextDecoder().decode(contentLengthValues[0])
+          );
+        return outgoingBodyCreate(contentLength);
       }
     }
 
     class ResponseOutparam {
-      static set (_param, _response) {
-        // TODO
+      #response;
+      static set(param, response) {
+        param.#response = response;
+      }
+    }
+
+    class RequestOptions {
+      #connectTimeoutMs;
+      #firstByteTimeoutMs;
+      #betweenBytesTimeoutMs;
+      connectTimeoutMs () {
+        return this.#connectTimeoutMs;
+      }
+      setConnectTimeoutMs (duration) {
+        this.#connectTimeoutMs = duration;
+      }
+      firstByteTimeoutMs () {
+        return this.#firstByteTimeoutMs;
+      }
+      setFirstByteTimeoutMs (duration) {
+        this.#firstByteTimeoutMs = duration;
+      }
+      betweenBytesTimeoutMs () {
+        return this.#betweenBytesTimeoutMs;
+      }
+      setBetweenBytesTimeoutMs (duration) {
+        this.#betweenBytesTimeoutMs = duration;
       }
     }
 
     class OutgoingRequest {
-      id = http.requestCnt++;
-      /** @type {Method} */ #method = { tag: 'get' };
-      /** @type {Scheme | undefined} */ #scheme = { tag: 'HTTP' };
+      _id = http.requestCnt++;
+      /** @type {Method} */ #method = { tag: "get" };
+      /** @type {Scheme | undefined} */ #scheme = undefined;
       /** @type {string | undefined} */ #pathWithQuery = undefined;
       /** @type {string | undefined} */ #authority = undefined;
-      /** @type {Fields} */ #headers = undefined;
-      /** @type {OutgoingBody} */ #body = new OutgoingBody();
-      constructor(method, pathWithQuery, scheme, authority, headers) {
+      /** @type {Fields} */ #headers;
+      /** @type {OutgoingBody} */ #body;
+      #bodyRequested = false;
+      constructor(headers) {
+        fieldsLock(headers);
+        this.#headers = headers;
+        let contentLengthValues = this.#headers.get("content-length");
+        if (contentLengthValues.length === 0)
+          contentLengthValues = this.#headers.get("Content-Length");
+        let contentLength;
+        if (contentLengthValues.length > 0)
+          contentLength = Number(
+            new TextDecoder().decode(contentLengthValues[0])
+          );
+        this.#body = outgoingBodyCreate(contentLength);
+      }
+      body() {
+        if (this.#bodyRequested) throw new Error("Body already requested");
+        this.#bodyRequested = true;
+        return this.#body;
+      }
+      method() {
+        return this.#method;
+      }
+      setMethod(method) {
+        if (method.tag === "other" && !method.val.match(/^[a-zA-Z-]+$/))
+          throw undefined;
         this.#method = method;
+      }
+      pathWithQuery() {
+        return this.#pathWithQuery;
+      }
+      setPathWithQuery(pathWithQuery) {
+        if (pathWithQuery && !pathWithQuery.match(/^[a-zA-Z0-9.-_~!$&'()*+,;=:@%/]+$/))
+          throw undefined;
         this.#pathWithQuery = pathWithQuery;
+      }
+      scheme() {
+        return this.#scheme;
+      }
+      setScheme(scheme) {
+        if (scheme?.tag === "other" && !scheme.val.match(/^[a-zA-Z]+$/))
+         throw undefined;
         this.#scheme = scheme;
+      }
+      authority() {
+        return this.#authority;
+      }
+      setAuthority(authority) {
+        if (authority) {
+          const [host, port, ...extra] = authority.split(':');
+          const portNum = Number(port);
+          if (extra.length || port !== undefined && (portNum.toString() !== port || portNum > 9999) || !host.match(/^[a-zA-Z0-9-.]+$/))
+            throw undefined;
+        }
         this.#authority = authority;
-        this.#headers = headers;
       }
-      write () {
-        return this.#body;
+      headers() {
+        return this.#headers;
       }
-
-      static _handle (request) {
-        const scheme = request.#scheme.tag === "HTTP" ? "http://" : "https://";
-        const url = scheme + request.#authority + request.#pathWithQuery;
-        const headers = {
-          "host": request.#authority,
-        };
+      [symbolDispose]() {}
+      static _handle(request, _options) {
+        // TODO: handle options timeouts
+        const scheme = schemeString(request.#scheme);
+        const url = scheme + request.#authority + (request.#pathWithQuery || '');
+        const headers = [["host", request.#authority]];
         const decoder = new TextDecoder();
         for (const [key, value] of request.#headers.entries()) {
-          headers[key] = decoder.decode(value);
-        }
-
-        let res;
-        try {
-          res = send({
-            method: request.#method.tag,
-            uri: url,
-            headers: headers,
-            params: [],
-            body: combineChunks(outgoingBodyGetChunks(request.#body)),
-          });
-        } catch (err) {
-          return newFutureIncomingResponse(err.toString(), true);
+          headers.push([key, decoder.decode(value)]);
         }
-
-        const encoder = new TextEncoder();
-        const response = newIncomingResponse(res.status, new Fields(res.headers.map(([key, value]) => [key, encoder.encode(value)])), [res.body]);
-        return newFutureIncomingResponse({ tag: 'ok', val: response }, false);
+        return futureIncomingResponseCreate(
+          request.#method.val || request.#method.tag,
+          url,
+          Object.entries(headers),
+          outgoingBodyOutputStreamId(request.#body)
+        );
       }
     }
 
@@ -178,121 +282,269 @@ export class WasiHttp {
     delete OutgoingRequest._handle;
 
     class OutgoingBody {
-      #chunks = [];
-      write () {
-        const body = this;
-        return new OutputStream({
-          write (bytes) {
-            body.#chunks.push(bytes);
-          },
-          blockingFlush () {}
-        });
+      #outputStream = undefined;
+      #contentLength = undefined;
+      write() {
+        if (this.#outputStream)
+          throw new Error("output stream already created for writing");
+        this.#outputStream = outputStreamCreate(
+          HTTP,
+          ioCall(OUTPUT_STREAM_CREATE | HTTP, null, this.#contentLength)
+        );
+        this.#outputStream[symbolDispose] = () => {};
+        return this.#outputStream;
+      }
+      [symbolDispose]() {
+        this.#outputStream?.[symbolDispose]();
       }
       /**
-       * @param {OutgoingBody} body 
+       * @param {OutgoingBody} body
        * @param {Fields | undefined} trailers
        */
-      static finish (_body, _trailers) {
-        // TODO
+      static finish(body, _trailers) {
+        // this will verify content length, and also verify not already finished
+        // throwing errors as appropriate
+        if (body.#outputStream)
+          ioCall(
+            HTTP_OUTPUT_STREAM_FINISH,
+            outputStreamId(body.#outputStream),
+            null
+          );
+        body.#outputStream?.[symbolDispose]();
       }
-
-      static _getChunks (body) {
-        return body.#chunks;
+      static _outputStreamId(outgoingBody) {
+        if (outgoingBody.#outputStream)
+          return outputStreamId(outgoingBody.#outputStream);
+      }
+      static _create(contentLength) {
+        const outgoingBody = new OutgoingBody();
+        outgoingBody.#contentLength = contentLength;
+        return outgoingBody;
       }
     }
-    const outgoingBodyGetChunks = OutgoingBody._getChunks;
-    delete OutgoingBody._getChunks;
+    const outgoingBodyOutputStreamId = OutgoingBody._outputStreamId;
+    delete OutgoingBody._outputStreamId;
+
+    const outgoingBodyCreate = OutgoingBody._create;
+    delete OutgoingBody._create;
 
     class IncomingResponse {
-      id = http.responseCnt++;
-      /** @type {InputStream} */ #body;
+      _id = http.responseCnt++;
       /** @type {Fields} */ #headers = undefined;
       #status = 0;
-      #bodyConsumed = false;
-      status () {
+      /** @type {number} */ #bodyStreamId;
+      status() {
         return this.#status;
       }
-      headers () {
+      headers() {
         return this.#headers;
       }
-      consume () {
-        if (this.#bodyConsumed)
-          throw { tag: 'unexpected-error', val: 'request body already consumed' };
-        this.#bodyConsumed = true;
-        return this.#body;
+      consume() {
+        if (this.#bodyStreamId === undefined) throw undefined;
+        const bodyStreamId = this.#bodyStreamId;
+        this.#bodyStreamId = undefined;
+        return incomingBodyCreate(bodyStreamId);
+      }
+      [symbolDispose]() {
+        if (this.#bodyStreamId) {
+          ioCall(INPUT_STREAM_DISPOSE | HTTP, this.#bodyStreamId);
+          this.#bodyStreamId = undefined;
+        }
       }
-      static _create (status, headers, chunks) {
+      static _create(status, headers, bodyStreamId) {
         const res = new IncomingResponse();
         res.#status = status;
         res.#headers = headers;
-        res.#body = new IncomingBody();
-        for (const chunk of chunks) {
-          incomingBodyAddChunk(res.#body, chunk);
-        }
+        res.#bodyStreamId = bodyStreamId;
         return res;
       }
     }
 
-    const newIncomingResponse = IncomingResponse._create;
+    const incomingResponseCreate = IncomingResponse._create;
     delete IncomingResponse._create;
 
     class FutureIncomingResponse {
-      id = this.futureCnt++;
-      #value;
-      #isError;
-      subscribe () {
-        // TODO
+      _id = http.futureCnt++;
+      #pollId;
+      subscribe() {
+        if (this.#pollId) return pollableCreate(this.#pollId);
+        // 0 poll is immediately resolving
+        return pollableCreate(0);
+      }
+      get() {
+        // already taken
+        if (!this.#pollId) return { tag: "err" };
+        const ret = ioCall(FUTURE_GET_VALUE_AND_DISPOSE | HTTP, this.#pollId);
+        if (!ret) return;
+        this.#pollId = undefined;
+        if (ret.error)
+          return { tag: "ok", val: { tag: "err", val: ret.value } };
+        const { status, headers, bodyStreamId } = ret.value;
+        const textEncoder = new TextEncoder();
+        return {
+          tag: "ok",
+          val: {
+            tag: "ok",
+            val: incomingResponseCreate(
+              status,
+              fieldsFromEntriesSafe(
+                headers.map(([key, val]) => [key, textEncoder.encode(val)])
+              ),
+              bodyStreamId
+            ),
+          },
+        };
       }
-      get () {
-        return { tag: this.#isError ? 'err' : 'ok', val: this.#value };
+      [symbolDispose]() {
+        if (this.#pollId) ioCall(FUTURE_DISPOSE | HTTP, this.#pollId);
       }
-      static _create (value, isError) {
+      static _create(method, url, headers, body) {
         const res = new FutureIncomingResponse();
-        res.#value = value;
-        res.#isError = isError;
+        res.#pollId = ioCall(HTTP_CREATE_REQUEST, null, {
+          method,
+          url,
+          headers,
+          body,
+        });
         return res;
       }
     }
 
-    const newFutureIncomingResponse = FutureIncomingResponse._create;
+    const futureIncomingResponseCreate = FutureIncomingResponse._create;
     delete FutureIncomingResponse._create;
 
     class Fields {
-      id = http.fieldsCnt++;
-      /** @type {Record<string, Uint8Array[]>} */ #fields;
+      _id = http.fieldsCnt++;
+      #immutable = false;
+      /** @type {[string, Uint8Array[]][]} */ #entries = [];
+      /** @type {Map<string, [string, Uint8Array[]][]>} */ #table = new Map();
 
       /**
-       * @param {[string, Uint8Array[]][]} fields
+       * @param {[string, Uint8Array[][]][]} entries
        */
-      constructor(fields) {
-        this.#fields = Object.fromEntries(fields);
+      static fromList(entries) {
+        const fields = new Fields();
+        for (const [key, value] of entries) {
+          fields.append(key, value);
+        }
+        return fields;
       }
-      get (name) {
-        return this.#fields[name];
+      get(name) {
+        const tableEntries = this.#table.get(name.toLowerCase());
+        if (!tableEntries) return [];
+        return tableEntries.map(([, v]) => v);
       }
-      set (name, value) {
-        this.#fields[name] = value;
+      set(name, values) {
+        if (this.#immutable) throw { tag: "immutable" };
+        try {
+          validateHeaderName(name);
+        } catch {
+          throw { tag: "invalid-syntax" };
+        }
+        for (const value of values) {
+          try {
+            validateHeaderValue(name, new TextDecoder().decode(value));
+          } catch {
+            throw { tag: "invalid-syntax" };
+          }
+          throw { tag: "invalid-syntax" };
+        }
+        const lowercased = name.toLowerCase();
+        if (_forbiddenHeaders.has(lowercased)) throw { tag: "forbidden" };
+        const tableEntries = this.#table.get(lowercased);
+        if (tableEntries)
+          this.#entries = this.#entries.filter(
+            (entry) => !tableEntries.includes(entry)
+          );
+        tableEntries.splice(0, tableEntries.length);
+        for (const value of values) {
+          const entry = [name, value];
+          this.#entries.push(entry);
+          tableEntries.push(entry);
+        }
       }
-      delete (name) {
-        delete this.#fields[name];
+      delete(name) {
+        if (this.#immutable) throw { tag: "immutable" };
+        const lowercased = name.toLowerCase();
+        const tableEntries = this.#table.get(lowercased);
+        if (tableEntries) {
+          this.#entries = this.#entries.filter(
+            (entry) => !tableEntries.includes(entry)
+          );
+          this.#table.delete(lowercased);
+        }
       }
-      entries () {
-        return Object.entries(this.#fields);
+      append(name, value) {
+        if (this.#immutable) throw { tag: "immutable" };
+        try {
+          validateHeaderName(name);
+        } catch {
+          throw { tag: "invalid-syntax" };
+        }
+        try {
+          validateHeaderValue(name, new TextDecoder().decode(value));
+        } catch (e) {
+          throw { tag: "invalid-syntax" };
+        }
+        const lowercased = name.toLowerCase();
+        if (_forbiddenHeaders.has(lowercased)) throw { tag: "forbidden" };
+        const entry = [name, value];
+        this.#entries.push(entry);
+        const tableEntries = this.#table.get(lowercased);
+        if (tableEntries) {
+          tableEntries.push(entry);
+        } else {
+          this.#table.set(lowercased, [entry]);
+        }
+      }
+      entries() {
+        return this.#entries;
+      }
+      clone() {
+        return fieldsFromEntriesSafe(this.#entries);
       }
-      clone () {
-        return new Fields(this.entries());
+      static _lock(fields) {
+        fields.#immutable = true;
+      }
+      // assumes entries are already validated
+      static _fromEntriesChecked(entries) {
+        const fields = new Fields();
+        fields.#entries = entries;
+        for (const entry of entries) {
+          const lowercase = entry[0].toLowerCase();
+          const existing = fields.#table.get(lowercase);
+          if (existing) {
+            existing.push(entry);
+          } else {
+            fields.#table.set(lowercase, [entry]);
+          }
+        }
+        return fields;
       }
     }
+    const fieldsLock = Fields._lock;
+    delete Fields._lock;
+    const fieldsFromEntriesSafe = Fields._fromEntriesChecked;
+    delete Fields._fromEntriesChecked;
 
     this.outgoingHandler = {
       /**
        * @param {OutgoingRequest} request
-       * @param {RequestOptions | undefined} _options
+       * @param {RequestOptions | undefined} options
        * @returns {FutureIncomingResponse}
        */
-      handle: outgoingRequestHandle
+      handle: outgoingRequestHandle,
     };
 
+    this._incomingRequestCreate = incomingRequestCreate;
+
+    function httpErrorCode(err) {
+      return {
+        tag: "internal-error",
+        val: err.message,
+      };
+    }
+
     this.types = {
       Fields,
       FutureIncomingResponse,
@@ -303,9 +555,24 @@ export class WasiHttp {
       OutgoingBody,
       OutgoingRequest,
       OutgoingResponse,
-      ResponseOutparam
+      ResponseOutparam,
+      RequestOptions,
+      httpErrorCode,
     };
   }
 }
 
+function schemeString(scheme) {
+  if (!scheme)
+    return 'https:';
+  switch (scheme.tag) {
+    case "HTTP":
+      return "http:";
+    case "HTTPS":
+      return "https:";
+    case "other":
+      return scheme.val.toLowerCase() + ":";
+  }
+}
+
 export const { outgoingHandler, types } = new WasiHttp();