srvx 0.1.3 → 0.2.0

package/dist/{shared/srvx.1e3bbf3a.mjs → adapters/node.mjs}

@@ -1,7 +1,80 @@
+import NodeHttp from 'node:http';
 import { splitSetCookieString } from 'cookie-es';
+import { r as resolvePort, f as fmtURL } from '../shared/srvx.PbkQy9Ck.mjs';
+import { w as wrapFetch } from '../shared/srvx.DhN4g5wJ.mjs';
+
+async function sendNodeResponse(nodeRes, webRes) {
+  if (!webRes) {
+    nodeRes.statusCode = 500;
+    return endNodeResponse(nodeRes);
+  }
+  if (webRes.nodeResponse) {
+    const res = webRes.nodeResponse();
+    nodeRes.writeHead(res.status, res.statusText, res.headers);
+    if (res.body instanceof ReadableStream) {
+      return streamBody(res.body, nodeRes);
+    }
+    nodeRes.write(res.body);
+    return endNodeResponse(nodeRes);
+  }
+  const headerEntries = [];
+  for (const [key, value] of webRes.headers) {
+    if (key === "set-cookie") {
+      for (const setCookie of splitSetCookieString(value)) {
+        headerEntries.push(["set-cookie", setCookie]);
+      }
+    } else {
+      headerEntries.push([key, value]);
+    }
+  }
+  nodeRes.writeHead(webRes.status || 200, webRes.statusText, headerEntries);
+  return webRes.body ? streamBody(webRes.body, nodeRes) : endNodeResponse(nodeRes);
+}
+function endNodeResponse(nodeRes) {
+  return new Promise((resolve) => nodeRes.end(resolve));
+}
+function streamBody(stream, nodeRes) {
+  if (nodeRes.destroyed) {
+    stream.cancel();
+    return;
+  }
+  const reader = stream.getReader();
+  function streamCancel(error) {
+    reader.cancel(error).catch(() => {
+    });
+    if (error) {
+      nodeRes.destroy(error);
+    }
+  }
+  function streamHandle({
+    done,
+    value
+  }) {
+    try {
+      if (done) {
+        nodeRes.end();
+      } else if (nodeRes.write(value)) {
+        reader.read().then(streamHandle, streamCancel);
+      } else {
+        nodeRes.once(
+          "drain",
+          () => reader.read().then(streamHandle, streamCancel)
+        );
+      }
+    } catch (error) {
+      streamCancel(error instanceof Error ? error : void 0);
+    }
+  }
+  nodeRes.on("close", streamCancel);
+  nodeRes.on("error", streamCancel);
+  reader.read().then(streamHandle, streamCancel);
+  return reader.closed.finally(() => {
+    nodeRes.off("close", streamCancel);
+    nodeRes.off("error", streamCancel);
+  });
+}
 
 const kNodeReq = /* @__PURE__ */ Symbol.for("srvx.node.request");
-const kNodeRes = /* @__PURE__ */ Symbol.for("srvx.node.response");
 const kNodeInspect = /* @__PURE__ */ Symbol.for(
   "nodejs.util.inspect.custom"
 );
@@ -11,6 +84,7 @@ const NodeReqHeadersProxy = /* @__PURE__ */ (() => class NodeReqHeadersProxy {
     this[kNodeReq] = req;
   }
   append(name, value) {
+    name = name.toLowerCase();
     const _headers = this[kNodeReq].headers;
     const _current = _headers[name];
     if (_current) {
@@ -24,9 +98,11 @@ const NodeReqHeadersProxy = /* @__PURE__ */ (() => class NodeReqHeadersProxy {
     }
   }
   delete(name) {
+    name = name.toLowerCase();
     this[kNodeReq].headers[name] = void 0;
   }
   get(name) {
+    name = name.toLowerCase();
     return _normalizeValue(this[kNodeReq].headers[name]);
   }
   getSetCookie() {
@@ -37,11 +113,19 @@ const NodeReqHeadersProxy = /* @__PURE__ */ (() => class NodeReqHeadersProxy {
     return splitSetCookieString(setCookie);
   }
   has(name) {
+    name = name.toLowerCase();
     return !!this[kNodeReq].headers[name];
   }
   set(name, value) {
+    name = name.toLowerCase();
     this[kNodeReq].headers[name] = value;
   }
+  get count() {
+    throw new Error("Method not implemented.");
+  }
+  getAll(_name) {
+    throw new Error("Method not implemented.");
+  }
   toJSON() {
     const _headers = this[kNodeReq].headers;
     const result = {};
@@ -93,73 +177,6 @@ const NodeReqHeadersProxy = /* @__PURE__ */ (() => class NodeReqHeadersProxy {
     return Object.fromEntries(this.entries());
   }
 })();
-const NodeResHeadersProxy = /* @__PURE__ */ (() => class NodeResHeadersProxy {
-  constructor(res) {
-    this[kNodeRes] = res;
-  }
-  append(name, value) {
-    this[kNodeRes].appendHeader(name, value);
-  }
-  delete(name) {
-    this[kNodeRes].removeHeader(name);
-  }
-  get(name) {
-    return _normalizeValue(this[kNodeRes].getHeader(name));
-  }
-  getSetCookie() {
-    const setCookie = _normalizeValue(this[kNodeRes].getHeader("set-cookie"));
-    if (!setCookie) {
-      return [];
-    }
-    return splitSetCookieString(setCookie);
-  }
-  has(name) {
-    return this[kNodeRes].hasHeader(name);
-  }
-  set(name, value) {
-    this[kNodeRes].setHeader(name, value);
-  }
-  forEach(cb, thisArg) {
-    const _headers = this[kNodeRes].getHeaders();
-    for (const key in _headers) {
-      if (_headers[key]) {
-        cb.call(
-          thisArg,
-          _normalizeValue(_headers[key]),
-          key,
-          this
-        );
-      }
-    }
-  }
-  *entries() {
-    const _headers = this[kNodeRes].getHeaders();
-    for (const key in _headers) {
-      yield [key, _normalizeValue(_headers[key])];
-    }
-  }
-  *keys() {
-    const keys = this[kNodeRes].getHeaderNames();
-    for (const key of keys) {
-      yield key;
-    }
-  }
-  *values() {
-    const values = Object.values(this[kNodeRes].getHeaders());
-    for (const value of values) {
-      yield _normalizeValue(value);
-    }
-  }
-  [(Symbol.iterator)]() {
-    return this.entries()[Symbol.iterator]();
-  }
-  get [Symbol.toStringTag]() {
-    return "Headers";
-  }
-  [kNodeInspect]() {
-    return Object.fromEntries(this.entries());
-  }
-})();
 function _normalizeValue(value) {
   if (Array.isArray(value)) {
     return value.join(", ");
@@ -348,7 +365,7 @@ const NodeRequestProxy = /* @__PURE__ */ (() => class NodeRequestProxy2 {
   #jsonBody;
   #textBody;
   #bodyStream;
-  get xRemoteAddress() {
+  get remoteAddress() {
     return this[kNodeReq].socket?.remoteAddress;
   }
   clone() {
@@ -479,51 +496,287 @@ async function _readStream(stream) {
   return Buffer.concat(chunks);
 }
 
-async function sendNodeResponse(nodeRes, webRes) {
-  if (!webRes) {
-    nodeRes.statusCode = 500;
-    return endNodeResponse(nodeRes);
-  }
-  if (webRes.xNodeResponse) {
-    const res = webRes.xNodeResponse();
-    nodeRes.writeHead(res.status, res.statusText, res.headers);
-    if (res.body instanceof ReadableStream) {
-      return streamBody(res.body, nodeRes).finally(
-        () => endNodeResponse(nodeRes)
-      );
+const NodeFastResponse = /* @__PURE__ */ (() => (
+  /**
+   * Fast Response for Node.js runtime
+   *
+   * It is faster because in most cases it doesn't create a full Response instance.
+   */
+  class NodeFastResponse {
+    #body;
+    #init;
+    constructor(body, init) {
+      this.#body = body;
+      this.#init = init;
+    }
+    /**
+     * Prepare Node.js response object
+     */
+    nodeResponse() {
+      const status = this.#init?.status ?? 200;
+      const statusText = this.#init?.statusText ?? "";
+      const headers = [];
+      let headersInit = this.#init?.headers;
+      if (headersInit) {
+        if (typeof headersInit === "object") {
+          headersInit = Object.entries(headersInit);
+        }
+        for (const [key, value] of headersInit) {
+          if (key === "set-cookie") {
+            for (const setCookie of splitSetCookieString(value)) {
+              headers.push(["set-cookie", setCookie]);
+            }
+          } else {
+            headers.push([key, value]);
+          }
+        }
+      }
+      const bodyInit = this.#body;
+      let body;
+      if (bodyInit) {
+        if (typeof bodyInit === "string") {
+          body = bodyInit;
+        } else if (bodyInit instanceof ReadableStream) {
+          body = bodyInit;
+        } else if (bodyInit instanceof ArrayBuffer) {
+          body = Buffer.from(bodyInit);
+        } else if (bodyInit instanceof Uint8Array) {
+          body = Buffer.from(bodyInit);
+        } else if (bodyInit instanceof DataView) {
+          body = Buffer.from(bodyInit.buffer);
+        } else if (bodyInit instanceof Blob) {
+          body = bodyInit.stream();
+          if (bodyInit.type) {
+            headers.push(["content-type", bodyInit.type]);
+          }
+        } else {
+          const res = new Response(bodyInit);
+          body = res.body;
+          for (const [key, value] of res.headers) {
+            headers.push([key, value]);
+          }
+        }
+      }
+      this.#body = void 0;
+      this.#init = void 0;
+      return {
+        status,
+        statusText,
+        headers,
+        body
+      };
+    }
+    // ... the rest is for interface compatibility only and usually not to be used ...
+    /** Lazy initialized response instance */
+    #responseObj;
+    /** Lazy initialized headers instance */
+    #headersObj;
+    clone() {
+      if (this.#responseObj) {
+        return this.#responseObj.clone();
+      }
+      return new Response(this.#body, this.#init);
+    }
+    get #response() {
+      if (!this.#responseObj) {
+        this.#responseObj = new Response(this.#body, this.#init);
+        this.#body = void 0;
+        this.#init = void 0;
+        this.#headersObj = void 0;
+      }
+      return this.#responseObj;
     }
-    nodeRes.write(res.body);
-    return endNodeResponse(nodeRes);
-  }
-  const headerEntries = [];
-  for (const [key, value] of webRes.headers) {
-    if (key === "set-cookie") {
-      for (const setCookie of splitSetCookieString(value)) {
-        headerEntries.push(["set-cookie", setCookie]);
+    get headers() {
+      if (this.#responseObj) {
+        return this.#responseObj.headers;
       }
-    } else {
-      headerEntries.push([key, value]);
+      if (!this.#headersObj) {
+        this.#headersObj = new Headers(this.#init?.headers);
+      }
+      return this.#headersObj;
+    }
+    get ok() {
+      if (this.#responseObj) {
+        return this.#responseObj.ok;
+      }
+      const status = this.#init?.status ?? 200;
+      return status >= 200 && status < 300;
+    }
+    get redirected() {
+      if (this.#responseObj) {
+        return this.#responseObj.redirected;
+      }
+      return false;
+    }
+    get status() {
+      if (this.#responseObj) {
+        return this.#responseObj.status;
+      }
+      return this.#init?.status ?? 200;
+    }
+    get statusText() {
+      if (this.#responseObj) {
+        return this.#responseObj.statusText;
+      }
+      return this.#init?.statusText ?? "";
+    }
+    get type() {
+      if (this.#responseObj) {
+        return this.#responseObj.type;
+      }
+      return "default";
+    }
+    get url() {
+      if (this.#responseObj) {
+        return this.#responseObj.url;
+      }
+      return "";
+    }
+    // --- body ---
+    #fastBody(as) {
+      const bodyInit = this.#body;
+      if (bodyInit === null || bodyInit === void 0) {
+        return null;
+      }
+      if (bodyInit instanceof as) {
+        return bodyInit;
+      }
+      return false;
+    }
+    get body() {
+      if (this.#responseObj) {
+        return this.#responseObj.body;
+      }
+      const fastBody = this.#fastBody(ReadableStream);
+      if (fastBody !== false) {
+        return fastBody;
+      }
+      return this.#response.body;
+    }
+    get bodyUsed() {
+      if (this.#responseObj) {
+        return this.#responseObj.bodyUsed;
+      }
+      return false;
+    }
+    arrayBuffer() {
+      if (this.#responseObj) {
+        return this.#responseObj.arrayBuffer();
+      }
+      const fastBody = this.#fastBody(ArrayBuffer);
+      if (fastBody !== false) {
+        return Promise.resolve(fastBody || new ArrayBuffer(0));
+      }
+      return this.#response.arrayBuffer();
+    }
+    blob() {
+      if (this.#responseObj) {
+        return this.#responseObj.blob();
+      }
+      const fastBody = this.#fastBody(Blob);
+      if (fastBody !== false) {
+        return Promise.resolve(fastBody || new Blob());
+      }
+      return this.#response.blob();
+    }
+    bytes() {
+      if (this.#responseObj) {
+        return this.#responseObj.bytes();
+      }
+      const fastBody = this.#fastBody(Uint8Array);
+      if (fastBody !== false) {
+        return Promise.resolve(fastBody || new Uint8Array());
+      }
+      return this.#response.bytes();
+    }
+    formData() {
+      if (this.#responseObj) {
+        return this.#responseObj.formData();
+      }
+      const fastBody = this.#fastBody(FormData);
+      if (fastBody !== false) {
+        return Promise.resolve(fastBody || new FormData());
+      }
+      return this.#response.formData();
+    }
+    text() {
+      if (this.#responseObj) {
+        return this.#responseObj.text();
+      }
+      const bodyInit = this.#body;
+      if (bodyInit === null || bodyInit === void 0) {
+        return Promise.resolve("");
+      }
+      if (typeof bodyInit === "string") {
+        return Promise.resolve(bodyInit);
+      }
+      return this.#response.text();
+    }
+    json() {
+      if (this.#responseObj) {
+        return this.#responseObj.json();
+      }
+      return this.text().then((text) => JSON.parse(text));
     }
   }
-  nodeRes.writeHead(webRes.status || 200, webRes.statusText, headerEntries);
-  return webRes.body ? streamBody(webRes.body, nodeRes).finally(() => endNodeResponse(nodeRes)) : endNodeResponse(nodeRes);
-}
-function endNodeResponse(nodeRes) {
-  return new Promise((resolve) => nodeRes.end(resolve));
+))();
+
+function serve(options) {
+  return new NodeServer(options);
 }
-async function streamBody(stream, nodeRes) {
-  const reader = stream.getReader();
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        break;
-      }
-      nodeRes.write(value);
+class NodeServer {
+  constructor(options) {
+    this.runtime = "node";
+    this.options = options;
+    const fetchHandler = wrapFetch(this, this.options.fetch);
+    this.fetch = fetchHandler;
+    const handler = (nodeReq, nodeRes) => {
+      const request = new NodeRequestProxy(nodeReq);
+      request.node = { req: nodeReq, res: nodeRes };
+      const res = fetchHandler(request);
+      return res instanceof Promise ? res.then((resolvedRes) => sendNodeResponse(nodeRes, resolvedRes)) : sendNodeResponse(nodeRes, res);
+    };
+    this.serveOptions = {
+      port: resolvePort(this.options.port, globalThis.process?.env.PORT),
+      host: this.options.hostname,
+      exclusive: !this.options.reusePort,
+      ...this.options.node
+    };
+    const server = NodeHttp.createServer(this.serveOptions, handler);
+    this.node = { server, handler };
+    if (!options.manual) {
+      this.serve();
+    }
+  }
+  #listeningPromise;
+  serve() {
+    if (this.#listeningPromise) {
+      return Promise.resolve(this.#listeningPromise).then(() => this);
+    }
+    this.#listeningPromise = new Promise((resolve) => {
+      this.node.server.listen(this.serveOptions, () => resolve());
+    });
+  }
+  get url() {
+    const addr = this.node?.server?.address();
+    if (!addr) {
+      return;
     }
-  } finally {
-    reader.releaseLock();
+    return typeof addr === "string" ? addr : fmtURL(addr.address, addr.port);
+  }
+  ready() {
+    return Promise.resolve(this.#listeningPromise).then(() => this);
+  }
+  close(closeAll) {
+    return new Promise((resolve, reject) => {
+      if (closeAll) {
+        this.node?.server?.closeAllConnections?.();
+      }
+      this.node?.server?.close(
+        (error) => error ? reject(error) : resolve()
+      );
+    });
   }
 }
 
-export { NodeRequestProxy as N, NodeReqHeadersProxy as a, NodeResHeadersProxy as b, sendNodeResponse as s };
+export { NodeFastResponse as Response, serve };

package/dist/shared/srvx.DhN4g5wJ.mjs

@@ -0,0 +1,76 @@
+function wrapFetch(server, fetchHandler) {
+  const plugins = server.options.plugins;
+  if (!plugins?.length) {
+    return fetchHandler;
+  }
+  const requestHooks = [];
+  const responseHooks = [];
+  for (const ctor of plugins) {
+    const plugin = typeof ctor === "function" ? ctor(server) : ctor;
+    if (plugin.request) {
+      requestHooks.push(plugin.request);
+    }
+    if (plugin.response) {
+      responseHooks.push(plugin.response);
+    }
+  }
+  const hasRequestHooks = requestHooks.length > 0;
+  const hasResponseHooks = responseHooks.length > 0;
+  if (!hasRequestHooks && !hasResponseHooks) {
+    return fetchHandler;
+  }
+  return (request) => {
+    let resValue;
+    let resPromise;
+    if (hasRequestHooks) {
+      for (const reqHook of requestHooks) {
+        if (resPromise) {
+          resPromise = resPromise.then((res) => res || reqHook(request));
+        } else {
+          const res = reqHook(request);
+          if (res) {
+            if (res instanceof Promise) {
+              resPromise = res;
+            } else {
+              return res;
+            }
+          }
+        }
+      }
+    }
+    if (resPromise) {
+      resPromise = resPromise.then((res) => res || fetchHandler(request));
+    } else {
+      const res = fetchHandler(request);
+      if (res instanceof Promise) {
+        resPromise = res;
+      } else {
+        resValue = res;
+      }
+    }
+    if (hasResponseHooks) {
+      for (const resHook of responseHooks) {
+        if (resPromise) {
+          resPromise = resPromise.then((res) => {
+            if (res) {
+              resValue = res;
+            }
+            return resHook(request, resValue);
+          });
+        } else {
+          const res = resHook(request, resValue);
+          if (res) {
+            if (res instanceof Promise) {
+              resPromise = res;
+            } else {
+              resValue = res;
+            }
+          }
+        }
+      }
+    }
+    return resPromise ? resPromise.then((res) => res || resValue) : resValue;
+  };
+}
+
+export { wrapFetch as w };

package/dist/shared/srvx.PbkQy9Ck.mjs

@@ -0,0 +1,18 @@
+function resolvePort(portOptions, portEnv) {
+  const portInput = portOptions ?? portEnv;
+  if (portInput === void 0) {
+    return 3e3;
+  }
+  return typeof portInput === "number" ? portInput : Number.parseInt(portInput, 10);
+}
+function fmtURL(host, port, ssl) {
+  if (!host || !port) {
+    return void 0;
+  }
+  if (host.includes(":")) {
+    host = `[${host}]`;
+  }
+  return `http${""}://${host}:${port}/`;
+}
+
+export { fmtURL as f, resolvePort as r };