@bytecodealliance/preview3-shim 0.1.1 → 0.2.0

package/lib/nodejs/http/response.js

@@ -1,227 +0,0 @@
-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/lib/nodejs/http/server.js

@@ -1,157 +0,0 @@
-import { EventEmitter } from "node:events";
-
-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/lib/nodejs/sockets/address.js

@@ -1,146 +0,0 @@
-// Adapted from preview2-shim/lib/io/worker-sockets.js
-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]);
-    });
-};

package/lib/nodejs/sockets/error.js

@@ -1,123 +0,0 @@
-export const ERROR_MAP = {
-  EACCES: "access-denied",
-  EPERM: "access-denied",
-  EOPNOTSUPP: "not-supported",
-  ENOPROTOOPT: "not-supported",
-  EPFNOSUPPORT: "not-supported",
-  EPROTONOSUPPORT: "not-supported",
-  ESOCKTNOSUPPORT: "not-supported",
-  EINVAL: "invalid-argument",
-  EAFNOSUPPORT: "invalid-argument",
-  ENOMEM: "out-of-memory",
-  ENOBUFS: "out-of-memory",
-  ETIMEDOUT: "timeout",
-  EADDRINUSE: "address-in-use",
-  EADDRNOTAVAIL: "address-not-bindable",
-  EHOSTUNREACH: "remote-unreachable",
-  EHOSTDOWN: "remote-unreachable",
-  ENETUNREACH: "remote-unreachable",
-  ENETDOWN: "remote-unreachable",
-  ENONET: "remote-unreachable",
-  ECONNREFUSED: "connection-refused",
-  EPIPE: "connection-broken",
-  ECONNRESET: "connection-reset",
-  ECONNABORTED: "connection-aborted",
-  EMSGSIZE: "datagram-too-large",
-  ENOTCONN: "invalid-state",
-  EISCONN: "invalid-state",
-  EALREADY: "invalid-state",
-  EDESTADDRREQ: "invalid-argument",
-};
-
-export const CODE_MAP = {
-  4053: "invalid-state",
-  4083: "invalid-state",
-  ENOTCONN: "invalid-state",
-  EBADF: "invalid-state",
-  EACCES: "access-denied",
-  EPERM: "access-denied",
-  ENOTSUP: "not-supported",
-  EOPNOTSUPP: "not-supported",
-  ENOPROTOOPT: "not-supported",
-  EPFNOSUPPORT: "not-supported",
-  EPROTONOSUPPORT: "not-supported",
-  ESOCKTNOSUPPORT: "not-supported",
-  EINVAL: "invalid-argument",
-  EAFNOSUPPORT: "invalid-argument",
-  ENOMEM: "out-of-memory",
-  ENOBUFS: "out-of-memory",
-  4090: "address-not-bindable",
-  EADDRNOTAVAIL: "address-not-bindable",
-  4091: "address-in-use",
-  EADDRINUSE: "address-in-use",
-  EHOSTUNREACH: "remote-unreachable",
-  EHOSTDOWN: "remote-unreachable",
-  ENETUNREACH: "remote-unreachable",
-  ENETDOWN: "remote-unreachable",
-  ENONET: "remote-unreachable",
-  ECONNREFUSED: "connection-refused",
-  EPIPE: "connection-broken",
-  ECONNRESET: "connection-reset",
-  ECONNABORTED: "connection-aborted",
-  EMSGSIZE: "datagram-too-large",
-};
-
-/**
- * Custom error for Socket operations with JCO compatible payload.
- *
- * https://bytecodealliance.github.io/jco/wit-type-representations.html#result-considerations-idiomatic-js-errors-for-host-implementations
- */
-export class SocketError extends Error {
-  /**
-   * @param {string} tag        – machine‐readable error tag
-   * @param {string} [message]  – human‐readable message
-   * @param {any}    [val]      – optional extra data
-   */
-  constructor(tag, message, val, opts = {}) {
-    super(message ?? `Error: ${tag}`, { cause: opts.cause });
-    this.name = "SocketError";
-    this.payload = val !== undefined ? { tag, val } : { tag };
-  }
-
-  /**
-   * Create or rewrap an error into SocketError
-   * @param {any} err – number, string, Error, or SocketError
-   */
-  static from(err) {
-    if (err instanceof SocketError) {
-      return err;
-    }
-
-    let tag,
-      message = undefined,
-      val = undefined;
-
-    if (typeof err === "number") {
-      tag = CODE_MAP[err] ?? "other";
-      message = `Error code ${err}`;
-      if (tag === "other") {
-        val = message;
-      }
-    } else if (typeof err === "string") {
-      tag = ERROR_MAP[err] ?? "other";
-      if (tag === "other") {
-        val = err;
-      }
-    } else if (err && typeof err.code === "string") {
-      tag = ERROR_MAP[err.code] ?? "other";
-      message = err.message;
-      if (tag === "other") {
-        val = err.code;
-      }
-    } else if (err && typeof err.message === "string" && ERROR_MAP[err.message]) {
-      tag = ERROR_MAP[err.message];
-      message = err.message;
-    } else {
-      tag = "other";
-      message = err?.message;
-      val = message;
-    }
-
-    return new SocketError(tag, message, val);
-  }
-}