@bytecodealliance/preview3-shim 0.1.1 → 0.2.0

package/dist/nodejs/http/response.js

@@ -0,0 +1,202 @@
+import { FutureReader, future } from "../future.js";
+import { StreamReader, readableByteStreamFromReader } from "../stream.js";
+import { HttpError } from "./error.js";
+import { Fields, _fieldsLock } from "./fields.js";
+const symbolDispose = Symbol.dispose || Symbol.for("dispose");
+let RESPONSE_CREATE_TOKEN = null;
+function token() {
+    return (RESPONSE_CREATE_TOKEN ??= Symbol("ResponseCreateToken"));
+}
+export class Response {
+    #statusCode = 200;
+    #headers = null;
+    #contents = null;
+    #trailersFuture = null;
+    #responseFuture = null;
+    #contentsDispose = null;
+    #bodyOpen = false;
+    #bodyEnded = false;
+    /**
+     * @private
+     * Use Response.new(...) to create an instance
+     */
+    constructor(t) {
+        if (t !== token()) {
+            throw new Error("Use Response.new(...) to create a Response");
+        }
+    }
+    /**
+     * Construct a new Response with default status-code 200.
+     *
+     * WIT:
+     * ```
+     * new: static func(
+     *   headers: headers,
+     *   contents: option<stream<u8>>,
+     *   trailers: future<result<option<trailers>, error-code>>
+     * ) -> tuple<response, future<result<_, error-code>>>;
+     * ```
+     *
+     * @param {Fields} headers  immutable headers resource
+     * @param {?StreamReader|object} contents  optional body stream
+     * @param {FutureReader|Promise} trailers  future for trailers
+     * @returns {{ res: Response, future: FutureReader }}
+     * @throws {HttpError} with payload.tag 'invalid-argument' for invalid arguments
+     */
+    static new(headers, contents, trailers) {
+        if (!(headers instanceof Fields)) {
+            throw new HttpError("invalid-argument", "headers must be Fields");
+        }
+        if (!(trailers instanceof FutureReader) && (!trailers || typeof trailers.then !== "function")) {
+            throw new HttpError("invalid-argument", "trailers must be FutureReader or Promise");
+        }
+        let dispose = null;
+        if (contents != null && !(contents instanceof StreamReader)) {
+            try {
+                dispose = contents[symbolDispose]?.bind(contents);
+                const inner = readableByteStreamFromReader(contents, { name: "contents" });
+                contents = new StreamReader(inner);
+            }
+            catch (err) {
+                throw new HttpError("invalid-argument", err.message);
+            }
+        }
+        // Generated P3 futures are lazy thenables so we want to observe them now so early error paths don't hang.
+        if (!(trailers instanceof FutureReader)) {
+            const promise = Promise.resolve(trailers);
+            trailers = new FutureReader(promise);
+        }
+        const response = new Response(token());
+        response.#headers = _fieldsLock(headers);
+        response.#contents = contents;
+        response.#contentsDispose = dispose;
+        response.#trailersFuture = trailers;
+        const { tx, rx } = future();
+        response.#responseFuture = tx;
+        return [response, rx];
+    }
+    [symbolDispose]() {
+        if (this.#contents && !this.#bodyOpen && !this.#bodyEnded) {
+            this.#contentsDispose?.();
+            this.#closeBody();
+        }
+        this.#contents = null;
+        this.#contentsDispose = null;
+        this.#bodyOpen = false;
+        this.#bodyEnded = true;
+    }
+    /**
+     * Get the HTTP Status Code for the Response.
+     *
+     * WIT:
+     * ```
+     * status-code: func() -> status-code;
+     * ```
+     *
+     * @returns {number}
+     */
+    getStatusCode() {
+        return this.#statusCode;
+    }
+    /**
+     * Set the HTTP Status Code for the Response.
+     *
+     * WIT:
+     * ```
+     * set-status-code: func(status-code: status-code) -> result;
+     * ```
+     *
+     * @param {number} code
+     * @throws {HttpError} with payload.tag 'invalid-argument'
+     *   if code is not an integer in [100,599]
+     */
+    setStatusCode(code) {
+        if (typeof code !== "number" || !Number.isInteger(code) || code < 100 || code > 599) {
+            throw new HttpError("invalid-argument", `Invalid status code: ${code}`);
+        }
+        this.#statusCode = code;
+    }
+    /**
+     * Get the headers associated with the Response.
+     *
+     * WIT:
+     * ```
+     * headers: func() -> headers;
+     * ```
+     *
+     * @returns {Fields}
+     */
+    getHeaders() {
+        return this.#headers;
+    }
+    /**
+     * Get body stream and trailers future, consuming the resource.
+     *
+     * WIT:
+     * ```
+     * consume-body: static func(this: response, res: future<result<_, error-code>>)
+     *   -> tuple<stream<u8>, future<result<option<trailers>, error-code>>>;
+     * ```
+     *
+     * @param {Response} response - The response to consume.
+     * @param {FutureReader} res - A future for communicating errors.
+     * @returns {[StreamReader, FutureReader]} A tuple of [body stream, trailers future].
+     * @throws {HttpError} with payload.tag 'invalid-state' if body has already been opened or consumed.
+     */
+    static consumeBody(response, res) {
+        if (res && typeof res.then === "function") {
+            // TODO: Use res to abort/close the body transport on errors.
+            void Promise.resolve(res).catch(() => { });
+        }
+        if (response.#bodyOpen) {
+            throw new HttpError("invalid-state", "body already opened and not yet closed");
+        }
+        if (response.#bodyEnded) {
+            throw new HttpError("invalid-state", "body has already been consumed");
+        }
+        if (!response.#contents) {
+            response.#bodyEnded = true;
+            return [response.#contents, response.#trailersFuture];
+        }
+        const reader = response.#contents;
+        response.#bodyOpen = true;
+        const readFn = reader.read.bind(reader);
+        reader.read = async (...args) => {
+            const chunk = await readFn(...args);
+            if (chunk === null) {
+                response.#bodyEnded = true;
+                response.#bodyOpen = false;
+            }
+            return chunk;
+        };
+        const closedFn = reader.close.bind(reader);
+        reader.close = () => {
+            response.#closeBody(closedFn);
+        };
+        const cancelFn = reader.cancel.bind(reader);
+        reader.cancel = async (...args) => {
+            await response.#closeBody(() => cancelFn(...args));
+        };
+        return [response.#contents, response.#trailersFuture];
+    }
+    // Internal: call to complete the response transmission
+    _resolve(result) {
+        if (this.#responseFuture) {
+            this.#responseFuture.write(result);
+            this.#responseFuture = null;
+        }
+    }
+    #closeBody(close = this.#contents?.close.bind(this.#contents)) {
+        const closeTrailers = !this.#bodyEnded;
+        try {
+            return close?.();
+        }
+        finally {
+            if (closeTrailers) {
+                this.#trailersFuture.close();
+            }
+            this.#bodyEnded = true;
+            this.#bodyOpen = false;
+        }
+    }
+}

package/dist/nodejs/http/server.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from "node:events";
+/**
+ * HttpServer uses a background worker thread to handle raw HTTP connections,
+ * while the main thread invokes the user-provided handler and sends back the
+ * response.
+ */
+export declare class HttpServer extends EventEmitter {
+    #private;
+    constructor(handler: any);
+    listen(port: any, host: any): Promise<void>;
+    stop(): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/nodejs/http/server.js

@@ -0,0 +1,127 @@
+import { EventEmitter } from "node:events";
+import { MessageChannel } from "node:worker_threads";
+import { ResourceWorker } from "../workers/resource-worker.js";
+import { StreamReader, readableByteStreamFromReader } from "../stream.js";
+import { FutureReader, future } from "../future.js";
+import { Request } from "./request.js";
+import { Response } from "./response.js";
+import { HttpError } from "./error.js";
+import { _fieldsFromEntriesChecked, _readTrailersForTransport, _trailerResultFromEntries, } from "./fields.js";
+let WORKER = null;
+function worker() {
+    return (WORKER ??= new ResourceWorker(new URL("../workers/http-worker.js", import.meta.url)));
+}
+/**
+ * HttpServer uses a background worker thread to handle raw HTTP connections,
+ * while the main thread invokes the user-provided handler and sends back the
+ * response.
+ */
+export class HttpServer extends EventEmitter {
+    #serverId = null;
+    #handler = null;
+    #shutdown = null;
+    constructor(handler) {
+        super();
+        if (typeof handler?.handle !== "function") {
+            throw new HttpError("invalid-argument", "Not a valid HTTP server component to execute.");
+        }
+        this.#handler = handler;
+    }
+    async listen(port, host) {
+        this.#serverId = await worker().run({
+            op: "server-start",
+            port,
+            host,
+        });
+        this.#shutdown = this.#serveLoop();
+    }
+    async stop() {
+        if (!this.#serverId) {
+            return;
+        }
+        await worker().run({
+            op: "server-stop",
+            serverId: this.#serverId,
+        });
+        await this.#shutdown;
+    }
+    async close() {
+        if (!this.#serverId) {
+            return;
+        }
+        await this.stop();
+        await worker().run({
+            op: "server-close",
+            serverId: this.#serverId,
+        });
+        this.#serverId = null;
+    }
+    async #serveLoop() {
+        let next;
+        const nextRequest = async () => await worker().run({
+            op: "server-next",
+            serverId: this.#serverId,
+        });
+        while ((next = await nextRequest()) !== null) {
+            try {
+                const { requestId } = next;
+                const req = requestFromParts(next);
+                const outcome = await this.#handler.handle(req);
+                if (outcome.tag === "ok") {
+                    const res = outcome.val;
+                    const { rx: resRx } = future();
+                    const [body, trailers] = Response.consumeBody(res, resRx);
+                    const { port1: tx, port2: rx } = new MessageChannel();
+                    const stream = readableByteStreamFromReader(body, { name: "response body" });
+                    _readTrailersForTransport(trailers)
+                        .then((val) => tx.postMessage({ val }))
+                        .catch((err) => tx.postMessage({ err: HttpError.from(err).payload }))
+                        .finally(() => tx.close());
+                    await worker().run({
+                        op: "server-response",
+                        serverId: this.#serverId,
+                        requestId,
+                        statusCode: res.getStatusCode(),
+                        headers: res.getHeaders().copyAll(),
+                        trailers: rx,
+                        stream,
+                    }, [stream, rx]);
+                }
+                else {
+                    await worker().run({
+                        op: "server-response",
+                        serverId: this.#serverId,
+                        requestId,
+                        statusCode: 500,
+                        headers: [],
+                    });
+                }
+            }
+            catch (err) {
+                this.emit("error", err);
+            }
+        }
+    }
+}
+const requestFromParts = (parts) => {
+    const { headers, body, trailers, method, url } = parts;
+    // Create a promise that resolves when the worker sends a message with trailers
+    const promise = new Promise((resolve, reject) => {
+        trailers.once("message", ({ val, err }) => {
+            trailers.close();
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(val);
+            }
+        });
+    });
+    const future = new FutureReader(promise.then(_trailerResultFromEntries));
+    const contents = new StreamReader(body);
+    const fields = _fieldsFromEntriesChecked(headers);
+    const [req] = Request.new(fields, contents, future, null);
+    req.setMethod(method);
+    req.setPathWithQuery(url);
+    return req;
+};

package/dist/nodejs/http.d.ts

@@ -0,0 +1,19 @@
+import { Fields } from "./http/fields.js";
+import { Request, RequestOptions } from "./http/request.js";
+import { Response } from "./http/response.js";
+export * from "./http/client.js";
+export * from "./http/error.js";
+export * from "./http/fields.js";
+export * from "./http/request.js";
+export * from "./http/response.js";
+export * from "./http/server.js";
+export declare const handler: {
+    handle(request: any): any;
+};
+export declare function _setHandler(nextHandler: any): any;
+export declare const types: {
+    Fields: typeof Fields;
+    Request: typeof Request;
+    RequestOptions: typeof RequestOptions;
+    Response: typeof Response;
+};

package/{lib → dist}/nodejs/http.js

@@ -1,34 +1,29 @@
 import { Fields } from "./http/fields.js";
 import { Request, RequestOptions } from "./http/request.js";
 import { Response } from "./http/response.js";
-
 export * from "./http/client.js";
 export * from "./http/error.js";
 export * from "./http/fields.js";
 export * from "./http/request.js";
 export * from "./http/response.js";
 export * from "./http/server.js";
-
 let currentHandler = null;
-
 export const handler = {
-  handle(request) {
-    if (!currentHandler) {
-      throw new Error("wasi:http/handler import is not configured");
-    }
-    return currentHandler.handle(request);
-  },
+    handle(request) {
+        if (!currentHandler) {
+            throw new Error("wasi:http/handler import is not configured");
+        }
+        return currentHandler.handle(request);
+    },
 };
-
 export function _setHandler(nextHandler) {
-  const previous = currentHandler;
-  currentHandler = nextHandler;
-  return previous;
+    const previous = currentHandler;
+    currentHandler = nextHandler;
+    return previous;
 }
-
 export const types = {
-  Fields,
-  Request,
-  RequestOptions,
-  Response,
+    Fields,
+    Request,
+    RequestOptions,
+    Response,
 };

package/dist/nodejs/index.js

@@ -0,0 +1,8 @@
+export * as cli from "./cli.js";
+export * as clocks from "./clocks.js";
+export * as filesystem from "./filesystem.js";
+export * as future from "./future.js";
+export * as http from "./http.js";
+export * as random from "./random.js";
+export * as sockets from "./sockets.js";
+export * as stream from "./stream.js";

package/dist/nodejs/random.d.ts

@@ -0,0 +1,5 @@
+import { insecure, random } from "@bytecodealliance/preview2-shim/random";
+export { insecure, random };
+export declare const insecureSeed: {
+    getInsecureSeed: typeof import("@bytecodealliance/preview2-shim/interfaces/wasi-random-insecure-seed").insecureSeed;
+};

package/{lib → dist}/nodejs/random.js

@@ -1,14 +1,8 @@
-import {
-  insecure,
-  insecureSeed as insecureSeedV2,
-  random,
-} from "@bytecodealliance/preview2-shim/random";
-
+import { insecure, insecureSeed as insecureSeedV2, random, } from "@bytecodealliance/preview2-shim/random";
 export { insecure, random };
-
 // `wasi:random/insecure-seed` was renamed between p2 (`insecure-seed`)
 // and p3 (`get-insecure-seed`). Rename the member to match the p3 WIT
 // while keeping the original implementation.
 export const insecureSeed = {
-  getInsecureSeed: insecureSeedV2.insecureSeed,
+    getInsecureSeed: insecureSeedV2.insecureSeed,
 };

package/dist/nodejs/sockets/address.d.ts

@@ -0,0 +1,78 @@
+export declare const IP_ADDRESS_FAMILY: {
+    IPV4: string;
+    IPV6: string;
+};
+export declare const tupleToIpv6: (segments: any) => any;
+export declare const tupleToIpv4: (segments: any) => any;
+export declare const ipv6ToTuple: (ipv6: any) => number[];
+export declare const ipv4ToTuple: (ipv4: any) => any;
+export declare const isMulticastIpAddress: ({ tag, val: { address } }: {
+    tag: any;
+    val: {
+        address: any;
+    };
+}) => boolean;
+export declare const isIpv4MappedAddress: ({ tag, val: { address } }: {
+    tag: any;
+    val: {
+        address: any;
+    };
+}) => boolean;
+export declare const isWildcardIpAddress: ({ val: { address } }: {
+    val: {
+        address: any;
+    };
+}) => any;
+export declare const isBroadcastIpAddress: ({ tag, val: { address } }: {
+    tag: any;
+    val: {
+        address: any;
+    };
+}) => any;
+export declare const isUnicastIpAddress: (a: any) => boolean;
+export declare const isLoopbackIpAddress: ({ tag, val: { address } }: {
+    tag: any;
+    val: {
+        address: any;
+    };
+}) => boolean;
+export declare const ipAddressConflict: (a: any, b: any) => any;
+/**
+ * Serialize a socket‐address to text.
+ * @param {{tag:string,val:{address:number[]}}} ipAddr
+ * @returns {string|null}
+ */
+export declare const serializeIpAddress: ({ tag, val: { address } }: {
+    tag: any;
+    val: {
+        address: any;
+    };
+}) => any;
+/**
+ * Create a socket‐address object.
+ * @param {'ipv4'|'ipv6'} family
+ * @param {string} host IP text
+ * @param {number|bigint} port
+ * @returns {{tag:string,val:Object}}
+ */
+export declare const makeIpAddress: (family: any, host: any, port: any) => {
+    tag: string;
+    val: {
+        address: any;
+        port: any;
+    };
+} | {
+    tag: string;
+    val: {
+        flowInfo: number;
+        scopeId: number;
+        address: any;
+        port: any;
+    };
+};
+/**
+ * Determine whether an IP address can be used as a local bind address.
+ * @param {{tag:'ipv4'|'ipv6',val:{address:number[]}}} ipAddress
+ * @returns {boolean}
+ */
+export declare const isBindableIpAddress: (ipAddress: any) => boolean;

package/dist/nodejs/sockets/address.js

@@ -0,0 +1,120 @@
+// Adapted from preview2-shim/src/io/worker-sockets.ts
+import { networkInterfaces } from "node:os";
+// TODO(tandr): switch to generated types
+export const IP_ADDRESS_FAMILY = {
+    IPV4: "ipv4",
+    IPV6: "ipv6",
+};
+export const tupleToIpv6 = (segments) => {
+    if (segments.length !== 8) {
+        return null;
+    }
+    return segments.map((segment) => segment.toString(16)).join(":");
+};
+export const tupleToIpv4 = (segments) => {
+    if (segments.length !== 4) {
+        return null;
+    }
+    return segments.map((segment) => segment.toString(10)).join(".");
+};
+export const ipv6ToTuple = (ipv6) => {
+    const [lhs, rhs = ""] = ipv6.includes("::") ? ipv6.split("::") : [ipv6];
+    const lhsParts = lhs === "" ? [] : lhs.split(":");
+    const rhsParts = rhs === "" ? [] : rhs.split(":");
+    return [...lhsParts, ...Array(8 - lhsParts.length - rhsParts.length).fill(0), ...rhsParts].map((segment) => {
+        const val = parseInt(segment, 16);
+        if (val < 0 || val > 0xffff || Number.isNaN(val)) {
+            throw new Error(`Invalid IPv6 segment: ${segment}`);
+        }
+        return val;
+    });
+};
+export const ipv4ToTuple = (ipv4) => {
+    return ipv4.split(".").map((segment) => {
+        const val = parseInt(segment, 10);
+        if (val < 0 || val > 255 || Number.isNaN(val)) {
+            throw new Error(`Invalid IPv4 segment: ${segment}`);
+        }
+        return val;
+    });
+};
+export const isMulticastIpAddress = ({ tag, val: { address } }) => (tag === "ipv4" && address[0] >= 0xe0 && address[0] <= 0xef) ||
+    (tag === "ipv6" && (address[0] & 0xff00) === 0xff00);
+export const isIpv4MappedAddress = ({ tag, val: { address } }) => tag === "ipv6" &&
+    address[0] === 0 &&
+    address[1] === 0 &&
+    address[2] === 0 &&
+    address[3] === 0 &&
+    address[4] === 0 &&
+    address[5] === 0xffff;
+export const isWildcardIpAddress = ({ val: { address } }) => address.every((b) => b === 0);
+export const isBroadcastIpAddress = ({ tag, val: { address } }) => tag === "ipv4" && address.every((b) => b === 0xff);
+export const isUnicastIpAddress = (a) => !isMulticastIpAddress(a) && !isBroadcastIpAddress(a) && !isWildcardIpAddress(a);
+export const isLoopbackIpAddress = ({ tag, val: { address } }) => (tag === "ipv4" && address[0] === 127) ||
+    (tag === "ipv6" && address.slice(0, 7).every((segment) => segment === 0) && address[7] === 1);
+export const ipAddressConflict = (a, b) => a.tag === b.tag &&
+    Number(a.val.port) === Number(b.val.port) &&
+    Number(a.val.port) !== 0 &&
+    (isWildcardIpAddress(a) ||
+        isWildcardIpAddress(b) ||
+        a.val.address.every((segment, idx) => segment === b.val.address[idx]));
+/**
+ * Serialize a socket‐address to text.
+ * @param {{tag:string,val:{address:number[]}}} ipAddr
+ * @returns {string|null}
+ */
+export const serializeIpAddress = ({ tag, val: { address } }) => {
+    switch (tag) {
+        case "ipv4":
+            return tupleToIpv4(address);
+        case "ipv6":
+            return tupleToIpv6(address);
+        default:
+            throw new Error(`Unknown IP tag: ${tag}`);
+    }
+};
+/**
+ * Create a socket‐address object.
+ * @param {'ipv4'|'ipv6'} family
+ * @param {string} host IP text
+ * @param {number|bigint} port
+ * @returns {{tag:string,val:Object}}
+ */
+export const makeIpAddress = (family, host, port) => {
+    let address;
+    switch (family) {
+        case "ipv4":
+            address = ipv4ToTuple(host);
+            break;
+        case "ipv6":
+            address = ipv6ToTuple(host);
+            break;
+        default:
+            throw new Error(`Unknown IP family: ${family}`);
+    }
+    const base = { address, port };
+    return family === "ipv4"
+        ? { tag: "ipv4", val: base }
+        : { tag: "ipv6", val: { ...base, flowInfo: 0, scopeId: 0 } };
+};
+/**
+ * Determine whether an IP address can be used as a local bind address.
+ * @param {{tag:'ipv4'|'ipv6',val:{address:number[]}}} ipAddress
+ * @returns {boolean}
+ */
+export const isBindableIpAddress = (ipAddress) => {
+    if (isWildcardIpAddress(ipAddress)) {
+        return true;
+    }
+    const expectedFamily = ipAddress.tag === "ipv4" ? "IPv4" : "IPv6";
+    const expectedAddress = ipAddress.val.address;
+    return Object.values(networkInterfaces())
+        .flat()
+        .some((iface) => {
+        if (iface?.family !== expectedFamily) {
+            return false;
+        }
+        const ifaceAddress = ipAddress.tag === "ipv4" ? ipv4ToTuple(iface.address) : ipv6ToTuple(iface.address);
+        return expectedAddress.every((segment, idx) => segment === ifaceAddress[idx]);
+    });
+};