@standardserver/node 0.0.0

package/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Standard Server
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,63 @@
+import { StandardBodyHint, StandardBody, StandardHeaders, StandardMethod, StandardLazyRequest, StandardResponse, StandardUrl } from '@standardserver/core';
+import { ToEventStreamOptions as ToEventStreamOptions$1 } from '@standardserver/fetch';
+import { AsyncIteratorClass } from '@standardserver/shared';
+import Stream, { Readable } from 'node:stream';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+
+declare function toEventIterator(stream: Readable): AsyncIteratorClass<unknown>;
+interface ToEventStreamOptions extends ToEventStreamOptions$1 {
+}
+declare function toEventStream(iterator: AsyncIterator<unknown | void, unknown | void, void>, options?: ToEventStreamOptions): Readable;
+
+type NodeHttpRequest = (IncomingMessage | Http2ServerRequest) & {
+    /**
+     * Prefer `originalUrl` over `url` if it is available.
+     */
+    originalUrl?: string;
+    /**
+     * Body might already parsed by upstream framework like express.js, ...
+     */
+    body?: unknown;
+};
+type NodeHttpResponse = ServerResponse | Http2ServerResponse;
+
+interface ToStandardBodyOptions {
+    /**
+     * Hints on how the body should be parsed.
+     */
+    hint?: StandardBodyHint | undefined;
+}
+/**
+ * Parses the body of a node http request.
+ */
+declare function toStandardBody(req: NodeHttpRequest, options?: ToStandardBodyOptions): Promise<StandardBody>;
+interface ToNodeHttpBodyOptions {
+    /**
+     * Options for the event iterator, like keep-alive settings, initial comment, etc.
+     */
+    eventIterator?: ToEventStreamOptions;
+}
+declare function toNodeHttpBody(body: StandardBody, headers: StandardHeaders, options?: ToNodeHttpBodyOptions): Promise<[
+    body: Readable | undefined | string,
+    headers: StandardHeaders
+]>;
+
+declare function toStandardMethod(method: string | undefined): StandardMethod;
+
+declare function toStandardLazyRequest(req: NodeHttpRequest, res: NodeHttpResponse): StandardLazyRequest;
+
+interface SendStandardResponseOptions {
+    /**
+     * Options for converting the response body to a Node.js HTTP body.
+     */
+    body?: ToNodeHttpBodyOptions;
+}
+declare function sendStandardResponse(res: NodeHttpResponse, standardResponse: StandardResponse, options?: SendStandardResponseOptions): Promise<void>;
+
+declare function toAbortSignal(stream: Stream.Writable): AbortSignal;
+
+declare function toStandardUrl(req: NodeHttpRequest): StandardUrl;
+
+export { sendStandardResponse, toAbortSignal, toEventIterator, toEventStream, toNodeHttpBody, toStandardBody, toStandardLazyRequest, toStandardMethod, toStandardUrl };
+export type { NodeHttpRequest, NodeHttpResponse, SendStandardResponseOptions, ToEventStreamOptions, ToNodeHttpBodyOptions, ToStandardBodyOptions };

package/dist/index.d.ts

@@ -0,0 +1,63 @@
+import { StandardBodyHint, StandardBody, StandardHeaders, StandardMethod, StandardLazyRequest, StandardResponse, StandardUrl } from '@standardserver/core';
+import { ToEventStreamOptions as ToEventStreamOptions$1 } from '@standardserver/fetch';
+import { AsyncIteratorClass } from '@standardserver/shared';
+import Stream, { Readable } from 'node:stream';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+
+declare function toEventIterator(stream: Readable): AsyncIteratorClass<unknown>;
+interface ToEventStreamOptions extends ToEventStreamOptions$1 {
+}
+declare function toEventStream(iterator: AsyncIterator<unknown | void, unknown | void, void>, options?: ToEventStreamOptions): Readable;
+
+type NodeHttpRequest = (IncomingMessage | Http2ServerRequest) & {
+    /**
+     * Prefer `originalUrl` over `url` if it is available.
+     */
+    originalUrl?: string;
+    /**
+     * Body might already parsed by upstream framework like express.js, ...
+     */
+    body?: unknown;
+};
+type NodeHttpResponse = ServerResponse | Http2ServerResponse;
+
+interface ToStandardBodyOptions {
+    /**
+     * Hints on how the body should be parsed.
+     */
+    hint?: StandardBodyHint | undefined;
+}
+/**
+ * Parses the body of a node http request.
+ */
+declare function toStandardBody(req: NodeHttpRequest, options?: ToStandardBodyOptions): Promise<StandardBody>;
+interface ToNodeHttpBodyOptions {
+    /**
+     * Options for the event iterator, like keep-alive settings, initial comment, etc.
+     */
+    eventIterator?: ToEventStreamOptions;
+}
+declare function toNodeHttpBody(body: StandardBody, headers: StandardHeaders, options?: ToNodeHttpBodyOptions): Promise<[
+    body: Readable | undefined | string,
+    headers: StandardHeaders
+]>;
+
+declare function toStandardMethod(method: string | undefined): StandardMethod;
+
+declare function toStandardLazyRequest(req: NodeHttpRequest, res: NodeHttpResponse): StandardLazyRequest;
+
+interface SendStandardResponseOptions {
+    /**
+     * Options for converting the response body to a Node.js HTTP body.
+     */
+    body?: ToNodeHttpBodyOptions;
+}
+declare function sendStandardResponse(res: NodeHttpResponse, standardResponse: StandardResponse, options?: SendStandardResponseOptions): Promise<void>;
+
+declare function toAbortSignal(stream: Stream.Writable): AbortSignal;
+
+declare function toStandardUrl(req: NodeHttpRequest): StandardUrl;
+
+export { sendStandardResponse, toAbortSignal, toEventIterator, toEventStream, toNodeHttpBody, toStandardBody, toStandardLazyRequest, toStandardMethod, toStandardUrl };
+export type { NodeHttpRequest, NodeHttpResponse, SendStandardResponseOptions, ToEventStreamOptions, ToNodeHttpBodyOptions, ToStandardBodyOptions };

package/dist/index.mjs

@@ -0,0 +1,177 @@
+import { Readable } from 'node:stream';
+import { flattenStandardHeader, getFilenameFromContentDisposition, generateContentDisposition } from '@standardserver/core';
+import { parseEmptyableJSON, isAsyncIteratorObject, stringifyJSON, AbortError } from '@standardserver/shared';
+import { toEventIterator as toEventIterator$1, toEventStream as toEventStream$1 } from '@standardserver/fetch';
+
+function toEventIterator(stream) {
+  return toEventIterator$1(Readable.toWeb(stream));
+}
+function toEventStream(iterator, options = {}) {
+  return Readable.fromWeb(toEventStream$1(iterator, options));
+}
+
+function toStandardMethod(method) {
+  return method ?? "GET";
+}
+
+const EMPTY_BODY_METHOD_SET = /* @__PURE__ */ new Set(["GET", "HEAD"]);
+async function toStandardBody(req, options = {}) {
+  const hint = flattenStandardHeader(req.headers["standard-server"]) ?? options?.hint;
+  const contentType = req.headers["content-type"];
+  const mimeType = contentType?.split(";")[0]?.trim();
+  const contentDisposition = req.headers["content-disposition"];
+  const contentLength = req.headers["content-length"];
+  if (hint === "none") {
+    return void 0;
+  }
+  if (hint === void 0 && EMPTY_BODY_METHOD_SET.has(toStandardMethod(req.method))) {
+    return void 0;
+  }
+  if (req.body !== void 0) {
+    return req.body;
+  }
+  if (!req.readable) {
+    throw new TypeError("Failed to read body: body stream already read or destroyed");
+  }
+  if (hint === "json" || hint === void 0 && contentDisposition === void 0 && mimeType === "application/json") {
+    const text = await _streamToString(req);
+    return parseEmptyableJSON(text);
+  }
+  if (hint === "form-data" || hint === void 0 && contentDisposition === void 0 && mimeType === "multipart/form-data") {
+    return _streamToFormData(req, contentType);
+  }
+  if (hint === "url-search-params" || hint === void 0 && contentDisposition === void 0 && mimeType === "application/x-www-form-urlencoded") {
+    const text = await _streamToString(req);
+    return new URLSearchParams(text);
+  }
+  if (hint === "event-stream" || hint === void 0 && contentDisposition === void 0 && mimeType === "text/event-stream") {
+    return toEventIterator(req);
+  }
+  if (hint === "file" || hint === void 0 && (contentDisposition !== void 0 || contentLength !== void 0)) {
+    const fileName = contentDisposition !== void 0 ? getFilenameFromContentDisposition(contentDisposition) : void 0;
+    return _streamToFile(req, fileName ?? "blob", contentType ?? "");
+  }
+  return Readable.toWeb(req);
+}
+async function toNodeHttpBody(body, headers, options = {}) {
+  headers = { ...headers };
+  if (body === void 0) {
+    headers["standard-server"] = "none";
+    return [void 0, headers];
+  }
+  if (body instanceof ReadableStream) {
+    headers["standard-server"] = "octet-stream";
+    headers["content-type"] ??= "application/octet-stream";
+    return [Readable.fromWeb(body), headers];
+  }
+  if (body instanceof Blob) {
+    headers["standard-server"] = "file";
+    headers["content-type"] ??= body.type;
+    headers["content-disposition"] ??= generateContentDisposition(body instanceof File ? body.name : "blob");
+    if (!Number.isNaN(body.size)) {
+      headers["content-length"] ??= body.size.toString();
+    }
+    return [Readable.fromWeb(body.stream()), headers];
+  }
+  if (body instanceof FormData) {
+    const response = new Response(body);
+    const blob = await response.blob();
+    headers["standard-server"] = "form-data";
+    headers["content-type"] ??= blob.type;
+    headers["content-length"] ??= blob.size.toString();
+    return [Readable.fromWeb(blob.stream()), headers];
+  }
+  if (body instanceof URLSearchParams) {
+    headers["standard-server"] = "url-search-params";
+    headers["content-type"] ??= "application/x-www-form-urlencoded";
+    return [body.toString(), headers];
+  }
+  if (isAsyncIteratorObject(body)) {
+    headers["standard-server"] = "event-stream";
+    headers["content-type"] ??= "text/event-stream";
+    return [toEventStream(body, options.eventIterator), headers];
+  }
+  headers["standard-server"] = "json";
+  headers["content-type"] ??= "application/json";
+  return [stringifyJSON(body), headers];
+}
+function _streamToFormData(stream, contentType) {
+  const response = new Response(stream, {
+    headers: {
+      "content-type": contentType
+    }
+  });
+  return response.formData();
+}
+async function _streamToString(stream) {
+  let string = "";
+  for await (const chunk of stream) {
+    string += chunk.toString();
+  }
+  return string;
+}
+async function _streamToFile(stream, fileName, contentType) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(chunk);
+  }
+  return new File(chunks, fileName, { type: contentType });
+}
+
+function toAbortSignal(stream) {
+  const controller = new AbortController();
+  stream.once("error", (error) => controller.abort(error));
+  stream.once("close", () => {
+    if (!stream.writableFinished) {
+      controller.abort(new AbortError("Writable stream closed before it finished writing"));
+    }
+  });
+  return controller.signal;
+}
+
+function toStandardUrl(req) {
+  const url = req.originalUrl ?? req.url ?? "/";
+  return `${url.startsWith("/") ? "" : "/"}${url}`;
+}
+
+function toStandardLazyRequest(req, res) {
+  const signal = toAbortSignal(res);
+  return {
+    url: toStandardUrl(req),
+    method: toStandardMethod(req.method),
+    headers: req.headers,
+    resolveBody: (hint) => toStandardBody(req, { hint }),
+    signal
+  };
+}
+
+async function sendStandardResponse(res, standardResponse, options = {}) {
+  const [resBody, resHeaders] = await toNodeHttpBody(standardResponse.body, standardResponse.headers, options.body);
+  return new Promise((resolve, reject) => {
+    res.once("error", reject);
+    res.once("close", resolve);
+    res.statusCode = standardResponse.status;
+    for (const key in resHeaders) {
+      const value = resHeaders[key];
+      if (value !== void 0) {
+        res.setHeader(key, value);
+      }
+    }
+    if (resBody === void 0) {
+      res.end();
+    } else if (typeof resBody === "string") {
+      res.end(resBody);
+    } else {
+      res.writeHead(standardResponse.status);
+      res.once("close", () => {
+        if (!resBody.closed) {
+          resBody.destroy(res.errored ?? void 0);
+        }
+      });
+      resBody.once("error", (error) => res.destroy(error));
+      resBody.pipe(res);
+    }
+  });
+}
+
+export { sendStandardResponse, toAbortSignal, toEventIterator, toEventStream, toNodeHttpBody, toStandardBody, toStandardLazyRequest, toStandardMethod, toStandardUrl };

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@standardserver/node",
+  "type": "module",
+  "version": "0.0.0",
+  "license": "MIT",
+  "homepage": "https://standardserver.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/standardserver/standardserver.git",
+    "directory": "packages/node"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@standardserver/core": "0.0.0",
+    "@standardserver/shared": "0.0.0",
+    "@standardserver/fetch": "0.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "@types/supertest": "^6.0.3",
+    "supertest": "^7.1.4"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "type:check": "tsc -b"
+  }
+}