@temporary-name/standard-server-node 1.9.3-alpha.03e17aa3340f4b261a549bf9e3fe948b084e2309

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Stainless
+
+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/README.md

@@ -0,0 +1,3 @@
+## `@temporary-name/standard-server-node`
+
+[Node.js](https://nodejs.org) server adapter for oRPC.

package/dist/index.d.mts

@@ -0,0 +1,52 @@
+import { StandardBody, StandardHeaders, StandardLazyRequest, StandardResponse } from '@temporary-name/standard-server';
+import Stream, { Readable } from 'node:stream';
+import { ToEventIteratorOptions as ToEventIteratorOptions$1, ToEventStreamOptions as ToEventStreamOptions$1 } from '@temporary-name/standard-server-fetch';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+
+interface ToEventIteratorOptions extends ToEventIteratorOptions$1 {
+}
+declare function toEventIterator(stream: Readable, options?: ToEventIteratorOptions): AsyncIteratorObject<unknown | void, unknown | void, void> & AsyncGenerator<unknown | void, unknown | void, void>;
+interface ToEventStreamOptions extends ToEventStreamOptions$1 {
+}
+declare function toEventStream(iterator: AsyncIterator<unknown | void, unknown | void, void>, options?: ToEventStreamOptions): Readable;
+
+type NodeHttpRequest = (IncomingMessage | Http2ServerRequest) & {
+    /**
+     * Replace `req.url` with `req.originalUrl` when `req.originalUrl` is available.
+     * This is useful for `express.js` middleware.
+     */
+    originalUrl?: string;
+    /**
+     * Prefer parsed body if it is available.
+     */
+    body?: unknown;
+};
+type NodeHttpResponse = ServerResponse | Http2ServerResponse;
+
+interface ToStandardBodyOptions extends ToEventIteratorOptions {
+}
+declare function toStandardBody(req: NodeHttpRequest, options?: ToStandardBodyOptions): Promise<StandardBody>;
+interface ToNodeHttpBodyOptions extends ToEventStreamOptions {
+}
+/**
+ * @param body
+ * @param headers - WARNING: The headers can be changed by the function and effects on the original headers.
+ * @param options
+ */
+declare function toNodeHttpBody(body: StandardBody, headers: StandardHeaders, options?: ToNodeHttpBodyOptions): Readable | undefined | string;
+
+declare function toStandardMethod(method: string | undefined): string;
+
+declare function toStandardLazyRequest(req: NodeHttpRequest, res: NodeHttpResponse): StandardLazyRequest;
+
+interface SendStandardResponseOptions extends ToNodeHttpBodyOptions {
+}
+declare function sendStandardResponse(res: NodeHttpResponse, standardResponse: StandardResponse, options?: SendStandardResponseOptions): Promise<void>;
+
+declare function toAbortSignal(stream: Stream.Writable): AbortSignal;
+
+declare function toStandardUrl(req: NodeHttpRequest): URL;
+
+export { sendStandardResponse, toAbortSignal, toEventIterator, toEventStream, toNodeHttpBody, toStandardBody, toStandardLazyRequest, toStandardMethod, toStandardUrl };
+export type { NodeHttpRequest, NodeHttpResponse, SendStandardResponseOptions, ToEventIteratorOptions, ToEventStreamOptions, ToNodeHttpBodyOptions, ToStandardBodyOptions };

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+import { StandardBody, StandardHeaders, StandardLazyRequest, StandardResponse } from '@temporary-name/standard-server';
+import Stream, { Readable } from 'node:stream';
+import { ToEventIteratorOptions as ToEventIteratorOptions$1, ToEventStreamOptions as ToEventStreamOptions$1 } from '@temporary-name/standard-server-fetch';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+
+interface ToEventIteratorOptions extends ToEventIteratorOptions$1 {
+}
+declare function toEventIterator(stream: Readable, options?: ToEventIteratorOptions): AsyncIteratorObject<unknown | void, unknown | void, void> & AsyncGenerator<unknown | void, unknown | void, void>;
+interface ToEventStreamOptions extends ToEventStreamOptions$1 {
+}
+declare function toEventStream(iterator: AsyncIterator<unknown | void, unknown | void, void>, options?: ToEventStreamOptions): Readable;
+
+type NodeHttpRequest = (IncomingMessage | Http2ServerRequest) & {
+    /**
+     * Replace `req.url` with `req.originalUrl` when `req.originalUrl` is available.
+     * This is useful for `express.js` middleware.
+     */
+    originalUrl?: string;
+    /**
+     * Prefer parsed body if it is available.
+     */
+    body?: unknown;
+};
+type NodeHttpResponse = ServerResponse | Http2ServerResponse;
+
+interface ToStandardBodyOptions extends ToEventIteratorOptions {
+}
+declare function toStandardBody(req: NodeHttpRequest, options?: ToStandardBodyOptions): Promise<StandardBody>;
+interface ToNodeHttpBodyOptions extends ToEventStreamOptions {
+}
+/**
+ * @param body
+ * @param headers - WARNING: The headers can be changed by the function and effects on the original headers.
+ * @param options
+ */
+declare function toNodeHttpBody(body: StandardBody, headers: StandardHeaders, options?: ToNodeHttpBodyOptions): Readable | undefined | string;
+
+declare function toStandardMethod(method: string | undefined): string;
+
+declare function toStandardLazyRequest(req: NodeHttpRequest, res: NodeHttpResponse): StandardLazyRequest;
+
+interface SendStandardResponseOptions extends ToNodeHttpBodyOptions {
+}
+declare function sendStandardResponse(res: NodeHttpResponse, standardResponse: StandardResponse, options?: SendStandardResponseOptions): Promise<void>;
+
+declare function toAbortSignal(stream: Stream.Writable): AbortSignal;
+
+declare function toStandardUrl(req: NodeHttpRequest): URL;
+
+export { sendStandardResponse, toAbortSignal, toEventIterator, toEventStream, toNodeHttpBody, toStandardBody, toStandardLazyRequest, toStandardMethod, toStandardUrl };
+export type { NodeHttpRequest, NodeHttpResponse, SendStandardResponseOptions, ToEventIteratorOptions, ToEventStreamOptions, ToNodeHttpBodyOptions, ToStandardBodyOptions };

package/dist/index.mjs

@@ -0,0 +1,152 @@
+import { runWithSpan, parseEmptyableJSON, isAsyncIteratorObject, stringifyJSON, AbortError, guard, once } from '@temporary-name/shared';
+import { getFilenameFromContentDisposition, flattenHeader, generateContentDisposition } from '@temporary-name/standard-server';
+import { Readable } from 'node:stream';
+import { toEventIterator as toEventIterator$1, toEventStream as toEventStream$1 } from '@temporary-name/standard-server-fetch';
+
+function toEventIterator(stream, options = {}) {
+  return toEventIterator$1(Readable.toWeb(stream), options);
+}
+function toEventStream(iterator, options = {}) {
+  return Readable.fromWeb(toEventStream$1(iterator, options));
+}
+
+function toStandardBody(req, options = {}) {
+  if (req.body !== void 0) {
+    return Promise.resolve(req.body);
+  }
+  return runWithSpan({ name: "parse_standard_body", signal: options.signal }, async () => {
+    const contentDisposition = req.headers["content-disposition"];
+    const contentType = req.headers["content-type"];
+    if (typeof contentDisposition === "string") {
+      const fileName = getFilenameFromContentDisposition(contentDisposition) ?? "blob";
+      return _streamToFile(req, fileName, contentType ?? "");
+    }
+    if (!contentType || contentType.startsWith("application/json")) {
+      const text = await _streamToString(req);
+      return parseEmptyableJSON(text);
+    }
+    if (contentType.startsWith("multipart/form-data")) {
+      return _streamToFormData(req, contentType);
+    }
+    if (contentType.startsWith("application/x-www-form-urlencoded")) {
+      const text = await _streamToString(req);
+      return new URLSearchParams(text);
+    }
+    if (contentType.startsWith("text/event-stream")) {
+      return toEventIterator(req, options);
+    }
+    if (contentType.startsWith("text/plain")) {
+      return _streamToString(req);
+    }
+    return _streamToFile(req, "blob", contentType);
+  });
+}
+function toNodeHttpBody(body, headers, options = {}) {
+  const currentContentDisposition = flattenHeader(headers["content-disposition"]);
+  delete headers["content-type"];
+  delete headers["content-disposition"];
+  if (body === void 0) {
+    return;
+  }
+  if (body instanceof Blob) {
+    headers["content-type"] = body.type;
+    headers["content-length"] = body.size.toString();
+    headers["content-disposition"] = currentContentDisposition ?? generateContentDisposition(body instanceof File ? body.name : "blob");
+    return Readable.fromWeb(body.stream());
+  }
+  if (body instanceof FormData) {
+    const response = new Response(body);
+    headers["content-type"] = response.headers.get("content-type");
+    return Readable.fromWeb(response.body);
+  }
+  if (body instanceof URLSearchParams) {
+    headers["content-type"] = "application/x-www-form-urlencoded";
+    return body.toString();
+  }
+  if (isAsyncIteratorObject(body)) {
+    headers["content-type"] = "text/event-stream";
+    return toEventStream(body, options);
+  }
+  headers["content-type"] = "application/json";
+  return stringifyJSON(body);
+}
+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 toStandardMethod(method) {
+  return method ?? "GET";
+}
+
+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 protocol = "encrypted" in req.socket && req.socket.encrypted ? "https:" : "http:";
+  const origin = guard(() => new URL(`${protocol}//${req.headers.host ?? "localhost"}`).origin) ?? `${protocol}//localhost`;
+  const path = req.originalUrl ?? req.url ?? "/";
+  return new URL(`${origin}${path.startsWith("/") ? "" : "/"}${path}`);
+}
+
+function toStandardLazyRequest(req, res) {
+  const signal = toAbortSignal(res);
+  return {
+    method: toStandardMethod(req.method),
+    url: toStandardUrl(req),
+    headers: req.headers,
+    body: once(() => toStandardBody(req, { signal })),
+    signal
+  };
+}
+
+function sendStandardResponse(res, standardResponse, options = {}) {
+  return new Promise((resolve, reject) => {
+    res.once("error", reject);
+    res.once("close", resolve);
+    const resHeaders = { ...standardResponse.headers };
+    const resBody = toNodeHttpBody(standardResponse.body, resHeaders, options);
+    res.writeHead(standardResponse.status, resHeaders);
+    if (resBody === void 0) {
+      res.end();
+    } else if (typeof resBody === "string") {
+      res.end(resBody);
+    } else {
+      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,40 @@
+{
+  "name": "@temporary-name/standard-server-node",
+  "type": "module",
+  "version": "1.9.3-alpha.03e17aa3340f4b261a549bf9e3fe948b084e2309",
+  "license": "MIT",
+  "homepage": "https://www.stainless.com/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stainless-api/krusty.git",
+    "directory": "packages/standard-server-node"
+  },
+  "keywords": [
+    "krusty"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@temporary-name/shared": "1.9.3-alpha.03e17aa3340f4b261a549bf9e3fe948b084e2309",
+    "@temporary-name/standard-server": "1.9.3-alpha.03e17aa3340f4b261a549bf9e3fe948b084e2309",
+    "@temporary-name/standard-server-fetch": "1.9.3-alpha.03e17aa3340f4b261a549bf9e3fe948b084e2309"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.30",
+    "@types/supertest": "^6.0.3",
+    "supertest": "^7.1.4"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "build:watch": "pnpm run build --watch",
+    "type:check": "tsc -b"
+  }
+}