@bytecodealliance/preview3-shim 0.6.1 → 0.8.0

package/dist/browser/http/client.js

@@ -1,6 +1,141 @@
-import { Todo } from "../../common/errors.js";
-function send(request) {
-    throw new Todo();
+import * as preview2Http from "@bytecodealliance/preview2-shim/http";
+import { readableFromPreview2Input, writeToPreview2Output } from "../streams.js";
+import { Fields, Request, Response } from "./types.js";
+class HttpError extends Error {
+    payload;
+    constructor(payload, message) {
+        super(message ?? payload.tag);
+        this.name = "HttpError";
+        this.payload = payload;
+    }
+}
+function internalError(error) {
+    return {
+        tag: "internal-error",
+        val: error instanceof Error ? error.message : String(error),
+    };
+}
+function preview2Options(options) {
+    if (!options) {
+        return undefined;
+    }
+    const converted = new preview2Http.types.RequestOptions();
+    converted.setConnectTimeout(options.getConnectTimeout());
+    converted.setFirstByteTimeout(options.getFirstByteTimeout());
+    converted.setBetweenBytesTimeout(options.getBetweenBytesTimeout());
+    return converted;
+}
+async function responseTrailers(incomingBody, bodyResult) {
+    const completed = await bodyResult;
+    if (completed.tag === "err") {
+        return completed;
+    }
+    const future = preview2Http.types.IncomingBody.finish(incomingBody);
+    await future.subscribe().block();
+    const result = future.get();
+    if (!result || result.tag === "err") {
+        return { tag: "err", val: internalError("response trailers were already consumed") };
+    }
+    if (result.val.tag === "err") {
+        return { tag: "err", val: result.val.val };
+    }
+    const fields = result.val.val;
+    return {
+        tag: "ok",
+        val: fields ? new Fields(fields) : undefined,
+    };
+}
+function trailerEntries(trailers) {
+    if (trailers?.tag === "none") {
+        return [];
+    }
+    if (trailers?.tag === "some") {
+        return trailerEntries(trailers.val);
+    }
+    if (trailers instanceof Fields) {
+        return trailers.copyAll();
+    }
+    if (Array.isArray(trailers)) {
+        return trailers;
+    }
+    throw new TypeError("trailers must be Fields or a list of entries");
+}
+async function send(request) {
+    if (!(request instanceof Request)) {
+        throw new TypeError("request must be a Request resource");
+    }
+    const outgoing = new preview2Http.types.OutgoingRequest(request.getHeaders()._preview2.clone());
+    outgoing.setMethod(request.getMethod());
+    outgoing.setScheme(request.getScheme() ?? { tag: "HTTP" });
+    outgoing.setAuthority(request.getAuthority());
+    outgoing.setPathWithQuery(request.getPathWithQuery());
+    let transmit = Promise.resolve({ tag: "ok", val: undefined });
+    const contents = request._body();
+    if (contents) {
+        const outgoingBody = outgoing.body();
+        transmit = (async () => {
+            let result = { tag: "ok", val: undefined };
+            try {
+                await writeToPreview2Output(contents, outgoingBody.write());
+                const trailers = await request._trailers();
+                if (trailers.tag === "err") {
+                    result = trailers;
+                }
+                else if (trailers.val && trailerEntries(trailers.val).length > 0) {
+                    result = {
+                        tag: "err",
+                        val: {
+                            tag: "internal-error",
+                            val: "browser Fetch does not support request trailers",
+                        },
+                    };
+                }
+            }
+            catch (error) {
+                result = { tag: "err", val: internalError(error) };
+            }
+            finally {
+                try {
+                    preview2Http.types.OutgoingBody.finish(outgoingBody, undefined);
+                }
+                catch (error) {
+                    if (result.tag === "ok") {
+                        result = { tag: "err", val: internalError(error) };
+                    }
+                }
+            }
+            return result;
+        })();
+    }
+    else {
+        transmit = request
+            ._trailers()
+            .then((trailers) => (trailers.tag === "err" ? trailers : { tag: "ok", val: undefined }));
+    }
+    const future = preview2Http.outgoingHandler.handle(outgoing, preview2Options(request.getOptions()));
+    void transmit.then((result) => request._resolve(result));
+    try {
+        await future.subscribe().block();
+        const result = future.get();
+        if (!result || result.tag === "err") {
+            throw new HttpError(internalError("HTTP response future was already consumed"));
+        }
+        if (result.val.tag === "err") {
+            throw new HttpError(result.val.val);
+        }
+        const incoming = result.val.val;
+        const headers = new Fields(incoming.headers().clone());
+        const incomingBody = incoming.consume();
+        const [contents, bodyResult] = readableFromPreview2Input(incomingBody.stream(), internalError);
+        const [response] = Response.new(headers, contents, responseTrailers(incomingBody, bodyResult));
+        response.setStatusCode(incoming.status());
+        return response;
+    }
+    catch (error) {
+        const httpError = error instanceof HttpError ? error : new HttpError(internalError(error));
+        request._resolve({ tag: "err", val: httpError.payload });
+        throw httpError;
+    }
 }
 export default {
     send,

package/dist/browser/http/handler.d.ts

@@ -1,5 +1,9 @@
 import type { Request, Response } from "../../../types/interfaces/wasi-http-handler.d.ts";
+type Handler = {
+    handle(request: Request): Promise<Response> | Response;
+};
 declare function handle(request: Request): Promise<Response>;
+export declare function _setHandler(handler: Handler | undefined): Handler | undefined;
 declare const _default: {
     handle: typeof handle;
 };

package/dist/browser/http/handler.js

@@ -1,6 +1,14 @@
-import { Todo } from "../../common/errors.js";
-function handle(request) {
-    throw new Todo();
+let currentHandler;
+async function handle(request) {
+    if (!currentHandler) {
+        throw new Error("wasi:http/handler import is not configured");
+    }
+    return currentHandler.handle(request);
+}
+export function _setHandler(handler) {
+    const previous = currentHandler;
+    currentHandler = handler;
+    return previous;
 }
 export default {
     handle,

package/dist/browser/http/types.d.ts

@@ -1,6 +1,18 @@
-import type { Fields as FieldsT, Request as RequestT, RequestOptions as RequestOptionsT, Response as ResponseT, FieldName, FieldValue, Headers, Method, Scheme, Duration, StatusCode, Trailers, ErrorCode, Result } from "../../../types/interfaces/wasi-http-types.d.ts";
-declare class Fields implements FieldsT {
-    static fromList(entries: Array<[FieldName, FieldValue]>): FieldsT;
+import { types as preview2Types } from "@bytecodealliance/preview2-shim/http";
+import type { Fields as FieldsT, Request as RequestT, RequestOptions as RequestOptionsT, Response as ResponseT, FieldName, FieldValue, Headers, Method, Scheme, Duration, StatusCode, Trailers, HeaderError, ErrorCode, Result } from "../../../types/interfaces/wasi-http-types.d.ts";
+type Preview2Fields = InstanceType<typeof preview2Types.Fields>;
+export declare class HttpError extends Error {
+    readonly payload: HeaderError;
+    constructor(payload: HeaderError, message?: string);
+}
+export declare const _forbiddenHeaders: {
+    value: Set<string>;
+};
+export declare class Fields implements FieldsT {
+    #private;
+    readonly _preview2: Preview2Fields;
+    constructor(fields?: import("@bytecodealliance/preview2-shim/interfaces/wasi-http-types").Fields);
+    static fromList(entries: Array<[FieldName, FieldValue]>): Fields;
     get(name: FieldName): Array<FieldValue>;
     has(name: FieldName): boolean;
     set(name: FieldName, value: Array<FieldValue>): void;
@@ -8,10 +20,25 @@ declare class Fields implements FieldsT {
     getAndDelete(name: FieldName): Array<FieldValue>;
     append(name: FieldName, value: FieldValue): void;
     copyAll(): Array<[FieldName, FieldValue]>;
-    clone(): FieldsT;
+    clone(): Fields;
+    static _lock(fields: Fields): Fields;
+}
+export declare class RequestOptions implements RequestOptionsT {
+    #private;
+    getConnectTimeout(): Duration | undefined;
+    setConnectTimeout(duration: Duration | undefined): void;
+    getFirstByteTimeout(): Duration | undefined;
+    setFirstByteTimeout(duration: Duration | undefined): void;
+    getBetweenBytesTimeout(): Duration | undefined;
+    setBetweenBytesTimeout(duration: Duration | undefined): void;
+    clone(): RequestOptions;
+    static _lock(options: RequestOptions | undefined): RequestOptions | undefined;
 }
-declare class Request implements RequestT {
-    static new(headers: Headers, contents: ReadableStream<number> | undefined, trailers: Promise<Result<Trailers | undefined, ErrorCode>>, options: RequestOptions | undefined): [Request, Promise<Result<void, ErrorCode>>];
+type TransmissionResult = Result<void, ErrorCode>;
+type TrailersResult = Result<Trailers | undefined, ErrorCode>;
+export declare class Request implements RequestT {
+    #private;
+    static new(headers: Headers, contents: ReadableStream<number> | undefined, trailers: Promise<TrailersResult>, options: RequestOptions | undefined): [Request, Promise<TransmissionResult>];
     getMethod(): Method;
     setMethod(method: Method): void;
     getPathWithQuery(): string | undefined;
@@ -20,25 +47,20 @@ declare class Request implements RequestT {
     setScheme(scheme: Scheme | undefined): void;
     getAuthority(): string | undefined;
     setAuthority(authority: string | undefined): void;
-    getOptions(): RequestOptionsT | undefined;
-    getHeaders(): Headers;
-    static consumeBody(this_: Request, res: Promise<Result<void, ErrorCode>>): [ReadableStream<number>, Promise<Result<Trailers | undefined, ErrorCode>>];
-}
-declare class RequestOptions implements RequestOptionsT {
-    getConnectTimeout(): Duration | undefined;
-    setConnectTimeout(duration: Duration | undefined): void;
-    getFirstByteTimeout(): Duration | undefined;
-    setFirstByteTimeout(duration: Duration | undefined): void;
-    getBetweenBytesTimeout(): Duration | undefined;
-    setBetweenBytesTimeout(duration: Duration | undefined): void;
-    clone(): RequestOptionsT;
+    getOptions(): RequestOptions | undefined;
+    getHeaders(): Fields;
+    static consumeBody(this_: Request, res: Promise<TransmissionResult>): [ReadableStream<number>, Promise<TrailersResult>];
+    _body(): ReadableStream<number> | undefined;
+    _trailers(): Promise<TrailersResult>;
+    _resolve(result: TransmissionResult): void;
 }
-declare class Response implements ResponseT {
-    static new(headers: Headers, contents: ReadableStream<number> | undefined, trailers: Promise<Result<Trailers | undefined, ErrorCode>>): [Response, Promise<Result<void, ErrorCode>>];
+export declare class Response implements ResponseT {
+    #private;
+    static new(headers: Headers, contents: ReadableStream<number> | undefined, trailers: Promise<TrailersResult>): [Response, Promise<TransmissionResult>];
     getStatusCode(): StatusCode;
     setStatusCode(statusCode: StatusCode): void;
-    getHeaders(): Headers;
-    static consumeBody(this_: Response, res: Promise<Result<void, ErrorCode>>): [ReadableStream<number>, Promise<Result<Trailers | undefined, ErrorCode>>];
+    getHeaders(): Fields;
+    static consumeBody(this_: Response, res: Promise<TransmissionResult>): [ReadableStream<number>, Promise<TrailersResult>];
 }
 declare const _default: {
     Fields: typeof Fields;

package/dist/browser/http/types.js

@@ -1,109 +1,251 @@
-import { Todo } from "../../common/errors.js";
-class Fields {
+import { types as preview2Types } from "@bytecodealliance/preview2-shim/http";
+export class HttpError extends Error {
+    payload;
+    constructor(payload, message) {
+        super(message ?? payload.tag);
+        this.name = "HttpError";
+        this.payload = payload;
+    }
+}
+export const _forbiddenHeaders = {
+    value: new Set([
+        "connection",
+        "http2-settings",
+        "host",
+        "keep-alive",
+        "proxy-authenticate",
+        "proxy-authorization",
+        "proxy-connection",
+        "transfer-encoding",
+        "upgrade",
+    ]),
+};
+function rejectForbidden(name) {
+    if (_forbiddenHeaders.value.has(name.toLowerCase())) {
+        throw new HttpError({ tag: "forbidden" }, `Header ${name} is forbidden`);
+    }
+}
+export class Fields {
+    _preview2;
+    #immutable = false;
+    constructor(fields = new preview2Types.Fields()) {
+        this._preview2 = fields;
+    }
     static fromList(entries) {
-        throw new Todo();
+        for (const [name] of entries) {
+            rejectForbidden(name);
+        }
+        return new Fields(preview2Types.Fields.fromList(entries));
     }
     get(name) {
-        throw new Todo();
+        return this._preview2.get(name);
     }
     has(name) {
-        throw new Todo();
+        return this._preview2.has(name);
     }
     set(name, value) {
-        throw new Todo();
+        this.#ensureMutable();
+        rejectForbidden(name);
+        this._preview2.set(name, value);
     }
     delete(name) {
-        throw new Todo();
+        this.#ensureMutable();
+        rejectForbidden(name);
+        this._preview2.delete(name);
     }
     getAndDelete(name) {
-        throw new Todo();
+        const values = this.get(name);
+        this.delete(name);
+        return values;
     }
     append(name, value) {
-        throw new Todo();
+        this.#ensureMutable();
+        rejectForbidden(name);
+        this._preview2.append(name, value);
     }
     copyAll() {
-        throw new Todo();
+        return this._preview2.entries().map(([name, value]) => [name, value.slice()]);
+    }
+    clone() {
+        return new Fields(this._preview2.clone());
+    }
+    static _lock(fields) {
+        fields.#immutable = true;
+        return fields;
+    }
+    #ensureMutable() {
+        if (this.#immutable) {
+            throw new HttpError({ tag: "immutable" }, "Cannot modify immutable fields");
+        }
+    }
+}
+export class RequestOptions {
+    #connectTimeout;
+    #firstByteTimeout;
+    #betweenBytesTimeout;
+    #immutable = false;
+    getConnectTimeout() {
+        return this.#connectTimeout;
+    }
+    setConnectTimeout(duration) {
+        this.#ensureMutable();
+        this.#connectTimeout = duration;
+    }
+    getFirstByteTimeout() {
+        return this.#firstByteTimeout;
+    }
+    setFirstByteTimeout(duration) {
+        this.#ensureMutable();
+        this.#firstByteTimeout = duration;
+    }
+    getBetweenBytesTimeout() {
+        return this.#betweenBytesTimeout;
+    }
+    setBetweenBytesTimeout(duration) {
+        this.#ensureMutable();
+        this.#betweenBytesTimeout = duration;
     }
     clone() {
-        throw new Todo();
+        const options = new RequestOptions();
+        options.#connectTimeout = this.#connectTimeout;
+        options.#firstByteTimeout = this.#firstByteTimeout;
+        options.#betweenBytesTimeout = this.#betweenBytesTimeout;
+        return options;
+    }
+    static _lock(options) {
+        if (options) {
+            options.#immutable = true;
+        }
+        return options;
+    }
+    #ensureMutable() {
+        if (this.#immutable) {
+            throw new HttpError({ tag: "immutable" }, "Cannot modify immutable request options");
+        }
     }
 }
-class Request {
+function emptyByteStream() {
+    return new ReadableStream({
+        start(controller) {
+            controller.close();
+        },
+    });
+}
+export class Request {
+    #method = { tag: "get" };
+    #pathWithQuery;
+    #scheme;
+    #authority;
+    #headers;
+    #contents;
+    #trailers;
+    #options;
+    #resolveTransmission;
+    #consumed = false;
+    #transmissionResolved = false;
     static new(headers, contents, trailers, options) {
-        throw new Todo();
+        if (!(headers instanceof Fields)) {
+            throw new TypeError("headers must be a Fields resource");
+        }
+        if (options !== undefined && !(options instanceof RequestOptions)) {
+            throw new TypeError("options must be a RequestOptions resource");
+        }
+        const request = new Request();
+        request.#headers = headers;
+        request.#contents = contents;
+        request.#trailers = Promise.resolve(trailers);
+        request.#options = RequestOptions._lock(options);
+        Fields._lock(headers);
+        const transmission = new Promise((resolve) => (request.#resolveTransmission = resolve));
+        return [request, transmission];
     }
     getMethod() {
-        throw new Todo();
+        return this.#method;
     }
     setMethod(method) {
-        throw new Todo();
+        this.#method = method;
     }
     getPathWithQuery() {
-        throw new Todo();
+        return this.#pathWithQuery;
     }
     setPathWithQuery(pathWithQuery) {
-        throw new Todo();
+        this.#pathWithQuery = pathWithQuery;
     }
     getScheme() {
-        throw new Todo();
+        return this.#scheme;
     }
     setScheme(scheme) {
-        throw new Todo();
+        this.#scheme = scheme;
     }
     getAuthority() {
-        throw new Todo();
+        return this.#authority;
     }
     setAuthority(authority) {
-        throw new Todo();
+        this.#authority = authority;
     }
     getOptions() {
-        throw new Todo();
+        return this.#options;
     }
     getHeaders() {
-        throw new Todo();
+        return this.#headers;
     }
     static consumeBody(this_, res) {
-        throw new Todo();
-    }
-}
-class RequestOptions {
-    getConnectTimeout() {
-        throw new Todo();
+        if (this_.#consumed) {
+            throw new Error("request body has already been consumed");
+        }
+        this_.#consumed = true;
+        void Promise.resolve(res).catch(() => { });
+        return [this_.#contents ?? emptyByteStream(), this_.#trailers];
     }
-    setConnectTimeout(duration) {
-        throw new Todo();
+    _body() {
+        return this.#contents;
     }
-    getFirstByteTimeout() {
-        throw new Todo();
+    _trailers() {
+        return this.#trailers;
     }
-    setFirstByteTimeout(duration) {
-        throw new Todo();
-    }
-    getBetweenBytesTimeout() {
-        throw new Todo();
-    }
-    setBetweenBytesTimeout(duration) {
-        throw new Todo();
-    }
-    clone() {
-        throw new Todo();
+    _resolve(result) {
+        if (!this.#transmissionResolved) {
+            this.#transmissionResolved = true;
+            this.#resolveTransmission(result);
+        }
     }
 }
-class Response {
+export class Response {
+    #statusCode = 200;
+    #headers;
+    #contents;
+    #trailers;
+    #consumed = false;
     static new(headers, contents, trailers) {
-        throw new Todo();
+        if (!(headers instanceof Fields)) {
+            throw new TypeError("headers must be a Fields resource");
+        }
+        const response = new Response();
+        response.#headers = headers;
+        Fields._lock(headers);
+        response.#contents = contents;
+        response.#trailers = Promise.resolve(trailers);
+        return [response, Promise.resolve({ tag: "ok", val: undefined })];
     }
     getStatusCode() {
-        throw new Todo();
+        return this.#statusCode;
     }
     setStatusCode(statusCode) {
-        throw new Todo();
+        if (!Number.isInteger(statusCode) || statusCode < 100 || statusCode > 599) {
+            throw new RangeError(`invalid HTTP status code: ${statusCode}`);
+        }
+        this.#statusCode = statusCode;
     }
     getHeaders() {
-        throw new Todo();
+        return this.#headers;
     }
     static consumeBody(this_, res) {
-        throw new Todo();
+        if (this_.#consumed) {
+            throw new Error("response body has already been consumed");
+        }
+        this_.#consumed = true;
+        void Promise.resolve(res).catch(() => { });
+        return [this_.#contents ?? emptyByteStream(), this_.#trailers];
     }
 }
 export default {

package/dist/browser/http.d.ts

@@ -1,3 +1,6 @@
 export { default as client } from "./http/client.js";
 export { default as handler } from "./http/handler.js";
 export { default as types } from "./http/types.js";
+export { _forbiddenHeaders, HttpError } from "./http/types.js";
+export { _setRequestStreaming } from "@bytecodealliance/preview2-shim/http";
+export { _setHandler } from "./http/handler.js";

package/dist/browser/http.js

@@ -1,3 +1,6 @@
 export { default as client } from "./http/client.js";
 export { default as handler } from "./http/handler.js";
 export { default as types } from "./http/types.js";
+export { _forbiddenHeaders, HttpError } from "./http/types.js";
+export { _setRequestStreaming } from "@bytecodealliance/preview2-shim/http";
+export { _setHandler } from "./http/handler.js";

package/dist/browser/sockets/ip-name-lookup.js

@@ -1,6 +1,37 @@
-import { Todo } from "../../common/errors.js";
-function resolveAddresses(name) {
-    throw new Todo();
+import { ipNameLookup } from "@bytecodealliance/preview2-shim/sockets";
+class NameLookupError extends Error {
+    payload;
+    constructor(payload) {
+        super(payload.tag);
+        this.payload = payload;
+    }
+}
+async function resolveAddresses(name) {
+    try {
+        const stream = ipNameLookup.resolveAddresses({}, name);
+        const addresses = [];
+        while (true) {
+            const address = stream.resolveNextAddress();
+            if (!address) {
+                break;
+            }
+            addresses.push(address);
+        }
+        if (addresses.length === 0) {
+            throw new NameLookupError({ tag: "name-unresolvable" });
+        }
+        return addresses;
+    }
+    catch (error) {
+        if (error instanceof NameLookupError) {
+            throw error;
+        }
+        const tag = typeof error === "string" ? error : error?.tag;
+        if (tag === "not-supported") {
+            throw new NameLookupError({ tag: "other", val: "not-supported" });
+        }
+        throw new NameLookupError({ tag: "other", val: String(error) });
+    }
 }
 export default {
     resolveAddresses,

package/dist/browser/sockets/types.d.ts

@@ -1,6 +1,20 @@
+import * as preview2Sockets from "@bytecodealliance/preview2-shim/sockets";
 import type { Duration, ErrorCode, IpAddressFamily, IpSocketAddress, Result, TcpSocket as TcpSocketT, UdpSocket as UdpSocketT } from "../../../types/interfaces/wasi-sockets-types.d.ts";
+type TcpProvider = {
+    tcp: typeof preview2Sockets.tcp;
+    tcpCreateSocket: typeof preview2Sockets.tcpCreateSocket;
+};
+type UdpProvider = {
+    udp: typeof preview2Sockets.udp;
+    udpCreateSocket: typeof preview2Sockets.udpCreateSocket;
+};
+export declare function socketErrorCode(error: unknown): ErrorCode;
+export declare function _setTcpProvider(provider: TcpProvider): TcpProvider;
+export declare function _setUdpProvider(provider: UdpProvider): UdpProvider;
 export declare class TcpSocket implements TcpSocketT {
+    #private;
     static create(addressFamily: IpAddressFamily): TcpSocket;
+    static _wrap(socket: unknown, input?: unknown, output?: unknown): TcpSocket;
     bind(localAddress: IpSocketAddress): void;
     connect(remoteAddress: IpSocketAddress): Promise<void>;
     listen(): ReadableStream<TcpSocketT>;
@@ -27,6 +41,7 @@ export declare class TcpSocket implements TcpSocketT {
     setSendBufferSize(value: bigint): void;
 }
 export declare class UdpSocket implements UdpSocketT {
+    #private;
     static create(addressFamily: IpAddressFamily): UdpSocket;
     bind(localAddress: IpSocketAddress): void;
     connect(remoteAddress: IpSocketAddress): void;