@bytecodealliance/preview2-shim 0.0.19 → 0.0.21

package/lib/nodejs/http.js

@@ -1,5 +1,311 @@
-import { WasiHttp } from '../http/wasi-http.js';
 import { streams } from '../common/io.js';
+import { fileURLToPath } from 'node:url';
+import { createSyncFn } from '../synckit/index.js';
 
-const http = new WasiHttp(streams);
-export const { incomingHandler, outgoingHandler, types } = http;
+const { InputStream, OutputStream } = streams;
+
+/**
+ * @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;
+  responseCnt = 1;
+  fieldsCnt = 1;
+  futureCnt = 1;
+
+  constructor() {
+    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
+          }
+        });
+      }
+      static finish (incomingBody) {
+        incomingBody.#bodyFinished = true;
+        return futureTrailersCreate(new Fields([]), false);
+      }
+      static _addChunk (incomingBody, chunk) {
+        incomingBody.#chunks.push(chunk);
+      }
+    }
+    const incomingBodyAddChunk = IncomingBody._addChunk;
+    delete IncomingBody._addChunk;
+
+    // TODO
+    class IncomingRequest {}
+
+    class FutureTrailers {
+      id = this.futureCnt++;
+      #value;
+      #isError;
+      subscribe () {
+        // TODO
+      }
+      get () {
+        return { tag: this.#isError ? 'err' : 'ok', val: this.#value };
+      }
+      static _create (value, isError) {
+        const res = new FutureTrailers();
+        res.#value = value;
+        res.#isError = isError;
+        return res;
+      }
+    }
+    const futureTrailersCreate = FutureTrailers._create;
+    delete FutureTrailers._create;
+
+    class OutgoingResponse {
+      id = http.responseCnt++;
+      /** @type {number} */ _statusCode;
+      /** @type {Fields} */ _headers;
+
+      /**
+       * @param {number} statusCode 
+       * @param {Fields} headers 
+       */
+      constructor (statusCode, headers) {
+        this._statusCode = statusCode;
+        this.headers = headers;
+      }
+    }
+
+    class ResponseOutparam {
+      static set (_param, _response) {
+        // TODO
+      }
+    }
+
+    class OutgoingRequest {
+      id = http.requestCnt++;
+      /** @type {Method} */ #method = { tag: 'get' };
+      /** @type {Scheme | undefined} */ #scheme = { tag: 'HTTP' };
+      /** @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) {
+        this.#method = method;
+        this.#pathWithQuery = pathWithQuery;
+        this.#scheme = scheme;
+        this.#authority = authority;
+        this.#headers = headers;
+      }
+      write () {
+        return this.#body;
+      }
+
+      static _handle (request) {
+        const scheme = request.#scheme.tag === "HTTP" ? "http://" : "https://";
+        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);
+        }
+
+        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);
+      }
+    }
+
+    const outgoingRequestHandle = OutgoingRequest._handle;
+    delete OutgoingRequest._handle;
+
+    class OutgoingBody {
+      #chunks = [];
+      write () {
+        const body = this;
+        return new OutputStream({
+          write (bytes) {
+            body.#chunks.push(bytes);
+          },
+          blockingFlush () {}
+        });
+      }
+      /**
+       * @param {OutgoingBody} body 
+       * @param {Fields | undefined} trailers
+       */
+      static finish (_body, _trailers) {
+        // TODO
+      }
+
+      static _getChunks (body) {
+        return body.#chunks;
+      }
+    }
+    const outgoingBodyGetChunks = OutgoingBody._getChunks;
+    delete OutgoingBody._getChunks;
+
+    class IncomingResponse {
+      id = http.responseCnt++;
+      /** @type {InputStream} */ #body;
+      /** @type {Fields} */ #headers = undefined;
+      #status = 0;
+      #bodyConsumed = false;
+      status () {
+        return this.#status;
+      }
+      headers () {
+        return this.#headers;
+      }
+      consume () {
+        if (this.#bodyConsumed)
+          throw { tag: 'unexpected-error', val: 'request body already consumed' };
+        this.#bodyConsumed = true;
+        return this.#body;
+      }
+      static _create (status, headers, chunks) {
+        const res = new IncomingResponse();
+        res.#status = status;
+        res.#headers = headers;
+        res.#body = new IncomingBody();
+        for (const chunk of chunks) {
+          incomingBodyAddChunk(res.#body, chunk);
+        }
+        return res;
+      }
+    }
+
+    const newIncomingResponse = IncomingResponse._create;
+    delete IncomingResponse._create;
+
+    class FutureIncomingResponse {
+      id = this.futureCnt++;
+      #value;
+      #isError;
+      subscribe () {
+        // TODO
+      }
+      get () {
+        return { tag: this.#isError ? 'err' : 'ok', val: this.#value };
+      }
+      static _create (value, isError) {
+        const res = new FutureIncomingResponse();
+        res.#value = value;
+        res.#isError = isError;
+        return res;
+      }
+    }
+
+    const newFutureIncomingResponse = FutureIncomingResponse._create;
+    delete FutureIncomingResponse._create;
+
+    class Fields {
+      id = http.fieldsCnt++;
+      /** @type {Record<string, Uint8Array[]>} */ #fields;
+
+      /**
+       * @param {[string, Uint8Array[]][]} fields
+       */
+      constructor(fields) {
+        this.#fields = Object.fromEntries(fields);
+      }
+      get (name) {
+        return this.#fields[name];
+      }
+      set (name, value) {
+        this.#fields[name] = value;
+      }
+      delete (name) {
+        delete this.#fields[name];
+      }
+      entries () {
+        return Object.entries(this.#fields);
+      }
+      clone () {
+        return new Fields(this.entries());
+      }
+    }
+
+    this.outgoingHandler = {
+      /**
+       * @param {OutgoingRequest} request
+       * @param {RequestOptions | undefined} _options
+       * @returns {FutureIncomingResponse}
+       */
+      handle: outgoingRequestHandle
+    };
+
+    this.types = {
+      Fields,
+      FutureIncomingResponse,
+      FutureTrailers,
+      IncomingBody,
+      IncomingRequest,
+      IncomingResponse,
+      OutgoingBody,
+      OutgoingRequest,
+      OutgoingResponse,
+      ResponseOutparam
+    };
+  }
+}
+
+export const { outgoingHandler, types } = new WasiHttp();

package/lib/nodejs/index.js

@@ -2,7 +2,6 @@ import * as clocks from "./clocks.js";
 import * as filesystem from "./filesystem.js";
 import * as http from "./http.js";
 import * as io from "../common/io.js";
-import * as poll from "./poll.js";
 import * as random from "./random.js";
 import * as sockets from "./sockets.js";
 import * as cli from "./cli.js";
@@ -12,11 +11,7 @@ export {
   filesystem,
   http,
   io,
-  poll,
   random,
   sockets,
   cli
 }
-
-export { WasiHttp } from "../http/wasi-http.js";
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/preview2-shim",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "WASI Preview2 shim for JS environments",
   "author": "Guy Bedford, Eduardo Rodrigues<16357187+eduardomourar@users.noreply.github.com>",
   "type": "module",

package/types/interfaces/wasi-cli-stderr.d.ts

@@ -1,5 +1,5 @@
 export namespace WasiCliStderr {
   export function getStderr(): OutputStream;
 }
-import type { OutputStream } from '../interfaces/wasi-io-streams';
+import type { OutputStream } from '../interfaces/wasi-io-streams.js';
 export { OutputStream };

package/types/interfaces/wasi-cli-stdin.d.ts

@@ -1,5 +1,5 @@
 export namespace WasiCliStdin {
   export function getStdin(): InputStream;
 }
-import type { InputStream } from '../interfaces/wasi-io-streams';
+import type { InputStream } from '../interfaces/wasi-io-streams.js';
 export { InputStream };

package/types/interfaces/wasi-cli-stdout.d.ts

@@ -1,5 +1,5 @@
 export namespace WasiCliStdout {
   export function getStdout(): OutputStream;
 }
-import type { OutputStream } from '../interfaces/wasi-io-streams';
+import type { OutputStream } from '../interfaces/wasi-io-streams.js';
 export { OutputStream };

package/types/interfaces/wasi-cli-terminal-stderr.d.ts

@@ -5,5 +5,5 @@ export namespace WasiCliTerminalStderr {
    */
   export function getTerminalStderr(): TerminalOutput | undefined;
 }
-import type { TerminalOutput } from '../interfaces/wasi-cli-terminal-output';
+import type { TerminalOutput } from '../interfaces/wasi-cli-terminal-output.js';
 export { TerminalOutput };

package/types/interfaces/wasi-cli-terminal-stdin.d.ts

@@ -5,5 +5,5 @@ export namespace WasiCliTerminalStdin {
    */
   export function getTerminalStdin(): TerminalInput | undefined;
 }
-import type { TerminalInput } from '../interfaces/wasi-cli-terminal-input';
+import type { TerminalInput } from '../interfaces/wasi-cli-terminal-input.js';
 export { TerminalInput };

package/types/interfaces/wasi-cli-terminal-stdout.d.ts

@@ -5,5 +5,5 @@ export namespace WasiCliTerminalStdout {
    */
   export function getTerminalStdout(): TerminalOutput | undefined;
 }
-import type { TerminalOutput } from '../interfaces/wasi-cli-terminal-output';
+import type { TerminalOutput } from '../interfaces/wasi-cli-terminal-output.js';
 export { TerminalOutput };

package/types/interfaces/wasi-clocks-monotonic-clock.d.ts

@@ -16,7 +16,7 @@ export namespace WasiClocksMonotonicClock {
    */
   export function subscribe(when: Instant, absolute: boolean): Pollable;
 }
-import type { Pollable } from '../interfaces/wasi-io-poll';
+import type { Pollable } from '../interfaces/wasi-io-poll.js';
 export { Pollable };
 /**
  * A timestamp in nanoseconds.

package/types/interfaces/wasi-clocks-timezone.d.ts

@@ -14,7 +14,7 @@ export namespace WasiClocksTimezone {
    */
   export function utcOffset(when: Datetime): number;
 }
-import type { Datetime } from '../interfaces/wasi-clocks-wall-clock';
+import type { Datetime } from '../interfaces/wasi-clocks-wall-clock.js';
 export { Datetime };
 /**
  * Information useful for displaying the timezone of a specific `datetime`.

package/types/interfaces/wasi-filesystem-preopens.d.ts

@@ -4,5 +4,5 @@ export namespace WasiFilesystemPreopens {
    */
   export function getDirectories(): [Descriptor, string][];
 }
-import type { Descriptor } from '../interfaces/wasi-filesystem-types';
+import type { Descriptor } from '../interfaces/wasi-filesystem-types.js';
 export { Descriptor };

package/types/interfaces/wasi-filesystem-types.d.ts

@@ -391,13 +391,13 @@ export namespace WasiFilesystemTypes {
    */
   export function filesystemErrorCode(err: Error): ErrorCode | undefined;
 }
-import type { InputStream } from '../interfaces/wasi-io-streams';
+import type { InputStream } from '../interfaces/wasi-io-streams.js';
 export { InputStream };
-import type { OutputStream } from '../interfaces/wasi-io-streams';
+import type { OutputStream } from '../interfaces/wasi-io-streams.js';
 export { OutputStream };
-import type { Error } from '../interfaces/wasi-io-streams';
+import type { Error } from '../interfaces/wasi-io-streams.js';
 export { Error };
-import type { Datetime } from '../interfaces/wasi-clocks-wall-clock';
+import type { Datetime } from '../interfaces/wasi-clocks-wall-clock.js';
 export { Datetime };
 /**
  * File size or length of a region within a file.
@@ -808,10 +808,6 @@ export interface MetadataHashValue {
   upper: bigint,
 }
 
-export class DirectoryEntryStream {
-  readDirectoryEntry(): DirectoryEntry | undefined;
-}
-
 export class Descriptor {
   readViaStream(offset: Filesize): InputStream;
   writeViaStream(offset: Filesize): OutputStream;
@@ -849,3 +845,7 @@ export class Descriptor {
   metadataHash(): MetadataHashValue;
   metadataHashAt(pathFlags: PathFlags, path: string): MetadataHashValue;
 }
+
+export class DirectoryEntryStream {
+  readDirectoryEntry(): DirectoryEntry | undefined;
+}

package/types/interfaces/wasi-http-incoming-handler.d.ts

@@ -0,0 +1,19 @@
+export namespace WasiHttpIncomingHandler {
+  /**
+   * This function is invoked with an incoming HTTP Request, and a resource
+   * `response-outparam` which provides the capability to reply with an HTTP
+   * Response. The response is sent by calling the `response-outparam.set`
+   * method, which allows execution to continue after the response has been
+   * sent. This enables both streaming to the response body, and performing other
+   * work.
+   * 
+   * The implementor of this function must write a response to the
+   * `response-outparam` before returning, or else the caller will respond
+   * with an error on its behalf.
+   */
+  export function handle(request: IncomingRequest, responseOut: ResponseOutparam): void;
+}
+import type { IncomingRequest } from '../interfaces/wasi-http-types.js';
+export { IncomingRequest };
+import type { ResponseOutparam } from '../interfaces/wasi-http-types.js';
+export { ResponseOutparam };

package/types/interfaces/wasi-http-outgoing-handler.d.ts

@@ -0,0 +1,23 @@
+export namespace WasiHttpOutgoingHandler {
+  /**
+   * This function is invoked with an outgoing HTTP Request, and it returns
+   * a resource `future-incoming-response` which represents an HTTP Response
+   * which may arrive in the future.
+   * 
+   * The `options` argument accepts optional parameters for the HTTP
+   * protocol's transport layer.
+   * 
+   * This function may return an error if the `outgoing-request` is invalid
+   * or not allowed to be made. Otherwise, protocol errors are reported
+   * through the `future-incoming-response`.
+   */
+  export function handle(request: OutgoingRequest, options: RequestOptions | undefined): FutureIncomingResponse;
+}
+import type { OutgoingRequest } from '../interfaces/wasi-http-types.js';
+export { OutgoingRequest };
+import type { RequestOptions } from '../interfaces/wasi-http-types.js';
+export { RequestOptions };
+import type { FutureIncomingResponse } from '../interfaces/wasi-http-types.js';
+export { FutureIncomingResponse };
+import type { Error } from '../interfaces/wasi-http-types.js';
+export { Error };