visaljs 0.0.0-stage → 0.0.2

package/node/prelude/http.js

@@ -0,0 +1,536 @@
+// node:http (ADR 0012, layer 3), the server side: createServer, Server, IncomingMessage and
+// ServerResponse over the host primitives of runtime/src/host_http.c (libuv TCP, llhttp
+// parsing). Responses are written as Node writes them: the status line, the headers in the
+// order set, then Date, Connection, Keep-Alive and Content-Length or chunked encoding.
+// A request is a Readable of the body's Buffers; a response writes strings and bytes.
+// Not yet: the client, timeouts, upgrades, trailers.
+import { errnoMessage, errnoName, httpAddress, httpCloseServer, httpDate, httpEnd, httpListen, httpWrite } from "visaljs:host";
+import { EventEmitter } from "./events.js";
+import { Readable, Stream } from "./stream.js";
+
+export const METHODS = ["ACL", "BIND", "CHECKOUT", "CONNECT", "COPY", "DELETE", "GET", "HEAD", "LINK", "LOCK", "M-SEARCH", "MERGE",
+  "MKACTIVITY", "MKCALENDAR", "MKCOL", "MOVE", "NOTIFY", "OPTIONS", "PATCH", "POST", "PROPFIND", "PROPPATCH", "PURGE", "PUT", "QUERY",
+  "REBIND", "REPORT", "SEARCH", "SOURCE", "SUBSCRIBE", "TRACE", "UNBIND", "UNLINK", "UNLOCK", "UNSUBSCRIBE"];
+
+export const STATUS_CODES = {
+  100: "Continue", 101: "Switching Protocols", 102: "Processing", 103: "Early Hints",
+  200: "OK", 201: "Created", 202: "Accepted", 203: "Non-Authoritative Information", 204: "No Content", 205: "Reset Content",
+  206: "Partial Content", 207: "Multi-Status", 208: "Already Reported", 226: "IM Used",
+  300: "Multiple Choices", 301: "Moved Permanently", 302: "Found", 303: "See Other", 304: "Not Modified", 305: "Use Proxy",
+  307: "Temporary Redirect", 308: "Permanent Redirect",
+  400: "Bad Request", 401: "Unauthorized", 402: "Payment Required", 403: "Forbidden", 404: "Not Found", 405: "Method Not Allowed",
+  406: "Not Acceptable", 407: "Proxy Authentication Required", 408: "Request Timeout", 409: "Conflict", 410: "Gone",
+  411: "Length Required", 412: "Precondition Failed", 413: "Payload Too Large", 414: "URI Too Long", 415: "Unsupported Media Type",
+  416: "Range Not Satisfiable", 417: "Expectation Failed", 418: "I'm a Teapot", 421: "Misdirected Request",
+  422: "Unprocessable Entity", 423: "Locked", 424: "Failed Dependency", 425: "Too Early", 426: "Upgrade Required",
+  428: "Precondition Required", 429: "Too Many Requests", 431: "Request Header Fields Too Large", 451: "Unavailable For Legal Reasons",
+  500: "Internal Server Error", 501: "Not Implemented", 502: "Bad Gateway", 503: "Service Unavailable", 504: "Gateway Timeout",
+  505: "HTTP Version Not Supported", 506: "Variant Also Negotiates", 507: "Insufficient Storage", 508: "Loop Detected",
+  509: "Bandwidth Limit Exceeded", 510: "Not Extended", 511: "Network Authentication Required",
+};
+
+/* the UTF-8 length of a string: Content-Length counts bytes */
+function byteLength(s) {
+  let n = s.length;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c >= 0x80) {
+      if (c < 0x800) n += 1;
+      else if (c >= 0xd800 && c <= 0xdbff && i + 1 < s.length && (s.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {
+        n += 2;
+        i++;
+      } else n += 2;
+    }
+  }
+  return n;
+}
+
+function chunkLength(chunk) {
+  return typeof chunk === "string" ? byteLength(chunk) : chunk.byteLength;
+}
+
+/* ---- IncomingMessage ------------------------------------------------------------------------ */
+
+/* A request: a Readable of the body's Buffers, pushed as llhttp parses them. */
+export class IncomingMessage extends Readable {
+  constructor(socket) {
+    super();
+    this.socket = socket;
+    this.httpVersionMajor = 1;
+    this.httpVersionMinor = 1;
+    this.httpVersion = "1.1";
+    this.complete = false;
+    this.rawHeaders = [];
+    this.headers = {};
+    this.rawTrailers = [];
+    this.trailers = {};
+    this.method = null;
+    this.url = "";
+    this.aborted = false;
+    this.statusCode = null;
+    this.statusMessage = null;
+  }
+
+  get connection() {
+    return this.socket;
+  }
+
+  _read() {}
+
+  _push(chunk) {
+    this.push(Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+  }
+
+  _finish() {
+    this.complete = true;
+    this.push(null);
+  }
+
+  /* the connection closed before the body was complete */
+  _abort() {
+    if (this.complete || this.destroyed) return;
+    this.aborted = true;
+    this.emit("aborted");
+    const e = new Error("aborted");
+    e.code = "ECONNRESET";
+    this.destroy(e);
+  }
+
+  setTimeout(msecs, callback) {
+    if (typeof callback === "function") this.once("timeout", callback);
+    return this;
+  }
+}
+
+/* Node's req.headers: lowercase names; repeats joined with ", " ("; " for cookie), kept as an
+ * array for set-cookie, and the first one kept for the headers that can't repeat */
+const SINGLE = new Set(["age", "authorization", "content-length", "content-type", "etag", "expires", "from", "host",
+  "if-modified-since", "if-unmodified-since", "last-modified", "location", "max-forwards", "proxy-authorization", "referer",
+  "retry-after", "server", "user-agent"]);
+
+function addHeader(headers, name, value) {
+  const key = name.toLowerCase();
+  const existing = headers[key];
+  if (existing === undefined) headers[key] = key === "set-cookie" ? [value] : value;
+  else if (key === "set-cookie") existing.push(value);
+  else if (SINGLE.has(key)) return;
+  else headers[key] = existing + (key === "cookie" ? "; " : ", ") + value;
+}
+
+/* ---- ServerResponse ------------------------------------------------------------------------- */
+
+export class ServerResponse extends Stream {
+  constructor(req, conn, keepAlive) {
+    super();
+    this.writable = true;
+    this.destroyed = false;
+    this.writableCorked = 0;
+    this.writableNeedDrain = false;
+    this.writableHighWaterMark = 16384;
+    /* Node's OutgoingMessage internals, which frameworks set (@hono/node-server sets
+     * _contentLength to have the length sent after the other headers, as Node sends it) */
+    this.useChunkedEncodingByDefault = true;
+    this._hasBody = req.method !== "HEAD";
+    this._contentLength = null;
+    this._removedContLen = false;
+    this.req = req;
+    this.socket = req.socket;
+    this.statusCode = 200;
+    this.statusMessage = undefined;
+    this.headersSent = false;
+    this.finished = false;
+    this.writableEnded = false;
+    this.writableFinished = false;
+    this.sendDate = true;
+    this.chunkedEncoding = false;
+    this._conn = conn;
+    this._keepAlive = keepAlive;
+    this._headers = new Map();  /* lowercase name → [name as set, value] */
+    this._head = req.method === "HEAD";
+  }
+
+  setHeader(name, value) {
+    if (this.headersSent) {
+      const e = new Error("Cannot set headers after they are sent to the client");
+      e.code = "ERR_HTTP_HEADERS_SENT";
+      throw e;
+    }
+    this._headers.set(String(name).toLowerCase(), [String(name), value]);
+    return this;
+  }
+
+  appendHeader(name, value) {
+    const key = String(name).toLowerCase();
+    const existing = this._headers.get(key);
+    if (existing === undefined) return this.setHeader(name, value);
+    existing[1] = [].concat(existing[1], value);
+    return this;
+  }
+
+  get connection() {
+    return this.socket;
+  }
+
+  get writableLength() {
+    return 0;
+  }
+
+  cork() {
+    this.writableCorked++;
+  }
+
+  uncork() {
+    if (this.writableCorked) this.writableCorked--;
+  }
+
+  setTimeout(msecs, callback) {
+    if (typeof callback === "function") this.once("timeout", callback);
+    return this;
+  }
+
+  /* sends the head now: the body that follows is chunked */
+  flushHeaders() {
+    if (!this.headersSent) httpWrite(this._conn, this._renderHead(undefined));
+  }
+
+  destroy(error) {
+    if (this.destroyed) return this;
+    this.destroyed = true;
+    this.writable = false;
+    httpEnd(this._conn, true);
+    queueMicrotask(() => {
+      if (error) this.emit("error", error);
+      this.emit("close");
+    });
+    return this;
+  }
+
+  /* the connection closed: 'close', without 'finish' when the response wasn't ended */
+  _connectionClosed() {
+    if (this._closeEmitted) return;
+    this._closeEmitted = true;
+    this.destroyed = true;
+    this.writable = false;
+    queueMicrotask(() => this.emit("close"));
+  }
+
+  getHeader(name) {
+    const h = this._headers.get(String(name).toLowerCase());
+    return h === undefined ? undefined : h[1];
+  }
+
+  hasHeader(name) {
+    return this._headers.has(String(name).toLowerCase());
+  }
+
+  removeHeader(name) {
+    this._headers.delete(String(name).toLowerCase());
+  }
+
+  getHeaderNames() {
+    return [...this._headers.keys()];
+  }
+
+  getHeaders() {
+    const out = Object.create(null);
+    for (const [key, [, value]] of this._headers) out[key] = value;
+    return out;
+  }
+
+  writeHead(statusCode, statusMessage, headers) {
+    if (typeof statusMessage !== "string") {
+      headers = statusMessage;
+      statusMessage = undefined;
+    }
+    this.statusCode = statusCode;
+    if (statusMessage !== undefined) this.statusMessage = statusMessage;
+    if (Array.isArray(headers)) {
+      for (let i = 0; i < headers.length; i += 2) this.appendHeader(headers[i], headers[i + 1]);
+    } else if (headers) {
+      for (const name of Object.keys(headers)) this.setHeader(name, headers[name]);
+    }
+    /* Node renders the head now (sent with the first write): without a known length, the body
+     * is chunked even when end() brings all of it */
+    if (!this.headersSent) this._pendingHead = this._renderHead(undefined);
+    return this;
+  }
+
+  /* what goes out before a body chunk: the head, if it hasn't gone yet */
+  _takeHead(length) {
+    if (!this.headersSent) return this._renderHead(length);
+    const head = this._pendingHead;
+    this._pendingHead = null;
+    return head ?? "";
+  }
+
+  /* the status line and headers; `length` is the whole body's when end() knows it */
+  _renderHead(length) {
+    const status = this.statusCode;
+    const noBody = status === 204 || status === 304 || (status >= 100 && status < 200);
+    let head = "HTTP/1.1 " + status + " " + (this.statusMessage ?? STATUS_CODES[status] ?? "unknown") + "\r\n";
+    for (const [, [name, value]] of this._headers) {
+      if (Array.isArray(value)) for (const v of value) head += name + ": " + v + "\r\n";
+      else head += name + ": " + value + "\r\n";
+    }
+    if (this.sendDate && !this._headers.has("date")) head += "Date: " + httpDate() + "\r\n";
+    const connection = this._headers.get("connection");
+    if (connection !== undefined && String(connection[1]).toLowerCase().includes("close")) this._keepAlive = false;
+    if (connection === undefined) head += this._keepAlive ? "Connection: keep-alive\r\nKeep-Alive: timeout=5\r\n" : "Connection: close\r\n";
+    /* Node: no length for HEAD; an HTTP/1.0 client gets a body that ends with the connection */
+    const http10 = this.req.httpVersionMajor < 1 || this.req.httpVersionMinor < 1;
+    /* a Transfer-Encoding: chunked the program set: the body is chunk-encoded, as Node does */
+    const te = this._headers.get("transfer-encoding");
+    if (te !== undefined && /\bchunked\b/i.test(String(te[1])) && !noBody) this.chunkedEncoding = true;
+    if (!noBody && !this._head && !http10 && !this._headers.has("content-length") && te === undefined) {
+      if (this._contentLength !== null && this._contentLength !== undefined) length = this._contentLength;
+      if (length !== undefined) {
+        head += "Content-Length: " + length + "\r\n";
+      } else {
+        head += "Transfer-Encoding: chunked\r\n";
+        this.chunkedEncoding = true;
+      }
+    }
+    this.headersSent = true;
+    return head + "\r\n";
+  }
+
+  write(chunk, encoding, callback) {
+    if (typeof encoding === "function") callback = encoding;
+    if (this.writableEnded || this.destroyed) {
+      const e = new Error(this.destroyed ? "Cannot call write after a stream was destroyed" : "write after end");
+      e.code = this.destroyed ? "ERR_STREAM_DESTROYED" : "ERR_STREAM_WRITE_AFTER_END";
+      queueMicrotask(() => this.emit("error", e));
+      if (typeof callback === "function") queueMicrotask(() => callback(e));
+      return false;
+    }
+    if (typeof chunk === "string" && typeof encoding === "string" && encoding !== "utf8" && encoding !== "utf-8") chunk = Buffer.from(chunk, encoding);
+    const head = this._takeHead(undefined);
+    if (head) httpWrite(this._conn, head);
+    if (chunk !== undefined && chunk !== null && chunkLength(chunk) > 0 && !this._head) {
+      if (this.chunkedEncoding) {
+        httpWrite(this._conn, chunkLength(chunk).toString(16) + "\r\n");
+        httpWrite(this._conn, chunk);
+        httpWrite(this._conn, "\r\n");
+      } else {
+        httpWrite(this._conn, chunk);
+      }
+    }
+    if (typeof callback === "function") queueMicrotask(callback);
+    return true;
+  }
+
+  end(chunk, encoding, callback) {
+    if (typeof chunk === "function") {
+      callback = chunk;
+      chunk = undefined;
+    } else if (typeof encoding === "function") {
+      callback = encoding;
+    }
+    if (this.writableEnded) return this;
+    if (typeof chunk === "string" && typeof encoding === "string" && encoding !== "utf8" && encoding !== "utf-8") chunk = Buffer.from(chunk, encoding);
+    if (!this.headersSent) {
+      const hasChunk = chunk !== undefined && chunk !== null;
+      const length = hasChunk ? chunkLength(chunk) : 0;
+      if (hasChunk && typeof chunk === "string" && !this._head) httpWrite(this._conn, this._renderHead(length) + chunk);
+      else {
+        httpWrite(this._conn, this._renderHead(length));
+        if (hasChunk && length && !this._head) httpWrite(this._conn, chunk);
+      }
+    } else {
+      if (chunk !== undefined && chunk !== null) this.write(chunk);
+      const head = this._takeHead(undefined);
+      if (head) httpWrite(this._conn, head);
+      if (this.chunkedEncoding && !this._head) httpWrite(this._conn, "0\r\n\r\n");
+    }
+    this.writableEnded = this.finished = true;
+    this.writable = false;
+    httpEnd(this._conn, !this._keepAlive);
+    queueMicrotask(() => {
+      this.writableFinished = true;
+      this.emit("finish");
+      if (!this._closeEmitted) {
+        this._closeEmitted = true;
+        this.emit("close");
+      }
+      if (typeof callback === "function") callback();
+    });
+    return this;
+  }
+}
+
+/* ---- Socket: what a request's and a response's `socket` is ---------------------------------- */
+
+class Socket extends EventEmitter {
+  constructor(conn) {
+    super();
+    this._conn = conn;
+    this.remoteAddress = undefined;
+    this.remotePort = undefined;
+    this.encrypted = false;
+    this.destroyed = false;
+    this.readable = true;
+    this.writable = true;
+  }
+
+  destroy() {
+    if (!this.destroyed) {
+      this.destroyed = true;
+      httpEnd(this._conn, true);
+    }
+    return this;
+  }
+
+  destroySoon() {
+    return this.destroy();
+  }
+
+  end() {
+    return this.destroy();
+  }
+
+  setTimeout() {
+    return this;
+  }
+
+  setNoDelay() {
+    return this;
+  }
+
+  setKeepAlive() {
+    return this;
+  }
+
+  ref() {
+    return this;
+  }
+
+  unref() {
+    return this;
+  }
+}
+
+/* ---- Server --------------------------------------------------------------------------------- */
+
+export class Server extends EventEmitter {
+  constructor(options, requestListener) {
+    super();
+    if (typeof options === "function") requestListener = options;
+    if (typeof requestListener === "function") this.on("request", requestListener);
+    this.listening = false;
+    this._id = -1;
+    this._requests = new Map();  /* connection → the request being received */
+    this._sockets = new Map();   /* connection → its socket object */
+    this._responses = new Map(); /* connection → the response being written */
+  }
+
+  listen(...args) {
+    let port, host, backlog = 511, callback;
+    if (typeof args[args.length - 1] === "function") callback = args.pop();
+    if (args[0] !== null && typeof args[0] === "object") {
+      port = args[0].port ?? 0;
+      host = args[0].host;
+      backlog = args[0].backlog ?? backlog;
+    } else {
+      port = args[0] ?? 0;
+      if (typeof args[1] === "string") host = args[1];
+      if (typeof args[args.length - 1] === "number" && args.length > 1) backlog = args[args.length - 1];
+    }
+    if (callback) this.once("listening", callback);
+    const callbacks = [
+      (conn, method, url, raw, major, minor, keepAlive) => this._onRequest(conn, method, url, raw, major, minor, keepAlive),
+      (conn, chunk) => {
+        const req = this._requests.get(conn);
+        if (req) req._push(chunk);
+      },
+      (conn) => {
+        const req = this._requests.get(conn);
+        if (req) {
+          this._requests.delete(conn);
+          req._finish();
+        }
+      },
+      (conn) => {
+        const req = this._requests.get(conn);
+        this._requests.delete(conn);
+        if (req) req._abort();
+        const res = this._responses.get(conn);
+        this._responses.delete(conn);
+        if (res) res._connectionClosed();
+        const socket = this._sockets.get(conn);
+        this._sockets.delete(conn);
+        if (socket) {
+          socket.destroyed = true;
+          socket.emit("close", false);
+        }
+      },
+    ];
+    let address = host ?? "::";
+    let id = httpListen(address, Number(port), backlog, ...callbacks);
+    if (id < 0 && host === undefined && errnoName(id) === "EAFNOSUPPORT") {  /* no IPv6: Node falls back to IPv4 */
+      address = "0.0.0.0";
+      id = httpListen(address, Number(port), backlog, ...callbacks);
+    }
+    if (id < 0) {
+      const code = errnoName(id);
+      const err = new Error("listen " + code + ": " + errnoMessage(id) + " " + address + ":" + port);
+      err.code = code;
+      err.errno = id;
+      err.syscall = "listen";
+      err.address = address;
+      err.port = Number(port);
+      queueMicrotask(() => this.emit("error", err));
+      return this;
+    }
+    this._id = id;
+    this.listening = true;
+    queueMicrotask(() => this.emit("listening"));
+    return this;
+  }
+
+  _onRequest(conn, method, url, raw, major, minor, keepAlive) {
+    let socket = this._sockets.get(conn);
+    if (!socket) {
+      socket = new Socket(conn);
+      this._sockets.set(conn, socket);
+      this.emit("connection", socket);
+    }
+    const req = new IncomingMessage(socket);
+    req.method = method;
+    req.url = url;
+    req.httpVersionMajor = major;
+    req.httpVersionMinor = minor;
+    req.httpVersion = major + "." + minor;
+    req.rawHeaders = raw;
+    for (let i = 0; i < raw.length; i += 2) addHeader(req.headers, raw[i], raw[i + 1]);
+    this._requests.set(conn, req);
+    const res = new ServerResponse(req, conn, keepAlive);
+    this._responses.set(conn, res);
+    res.once("finish", () => {
+      if (this._responses.get(conn) === res) this._responses.delete(conn);
+    });
+    this.emit("request", req, res);
+  }
+
+  address() {
+    const a = httpAddress(this._id);
+    return a === null ? null : { address: a[0], family: a[1], port: a[2] };
+  }
+
+  close(callback) {
+    if (this.listening) {
+      httpCloseServer(this._id);
+      this.listening = false;
+    }
+    queueMicrotask(() => {
+      this.emit("close");
+      if (typeof callback === "function") callback();
+    });
+    return this;
+  }
+}
+
+export function createServer(options, requestListener) {
+  return new Server(options, requestListener);
+}
+
+export default { METHODS, STATUS_CODES, IncomingMessage, ServerResponse, Server, createServer };

package/node/prelude/http2.js

@@ -0,0 +1,30 @@
+// node:http2 (ADR 0012, layer 3): only what code that supports both HTTP versions touches when it
+// runs on HTTP/1 — the request and response classes (for instanceof checks, which never match
+// here) and the constants. Servers and sessions aren't provided: creating one throws.
+import { notSupported } from "./internal/errors.js";
+
+export class Http2ServerRequest {}
+export class Http2ServerResponse {}
+
+export const constants = {
+  NGHTTP2_NO_ERROR: 0, NGHTTP2_PROTOCOL_ERROR: 1, NGHTTP2_INTERNAL_ERROR: 2, NGHTTP2_FLOW_CONTROL_ERROR: 3,
+  NGHTTP2_SETTINGS_TIMEOUT: 4, NGHTTP2_STREAM_CLOSED: 5, NGHTTP2_FRAME_SIZE_ERROR: 6, NGHTTP2_REFUSED_STREAM: 7,
+  NGHTTP2_CANCEL: 8, NGHTTP2_COMPRESSION_ERROR: 9, NGHTTP2_CONNECT_ERROR: 10, NGHTTP2_ENHANCE_YOUR_CALM: 11,
+  NGHTTP2_INADEQUATE_SECURITY: 12, NGHTTP2_HTTP_1_1_REQUIRED: 13,
+  HTTP2_HEADER_STATUS: ":status", HTTP2_HEADER_METHOD: ":method", HTTP2_HEADER_AUTHORITY: ":authority",
+  HTTP2_HEADER_SCHEME: ":scheme", HTTP2_HEADER_PATH: ":path", HTTP2_HEADER_CONTENT_TYPE: "content-type",
+  HTTP2_HEADER_CONTENT_LENGTH: "content-length",
+  HTTP_STATUS_OK: 200, HTTP_STATUS_NOT_FOUND: 404, HTTP_STATUS_INTERNAL_SERVER_ERROR: 500,
+};
+
+export function createServer() {
+  throw notSupported("http2.createServer");
+}
+export function createSecureServer() {
+  throw notSupported("http2.createSecureServer");
+}
+export function connect() {
+  throw notSupported("http2.connect");
+}
+
+export default { Http2ServerRequest, Http2ServerResponse, constants, createServer, createSecureServer, connect };