@orpc/standard-server-node 0.0.0-next.00fb0f4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 oRPC
+
+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,81 @@
+<div align="center">
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
+</div>
+
+<h1></h1>
+
+<div align="center">
+  <a href="https://codecov.io/gh/unnoq/orpc">
+    <img alt="codecov" src="https://codecov.io/gh/unnoq/orpc/branch/main/graph/badge.svg">
+  </a>
+  <a href="https://www.npmjs.com/package/@orpc/standard-server-node">
+    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Fstandard-server-node?logo=npm" />
+  </a>
+  <a href="https://github.com/unnoq/orpc/blob/main/LICENSE">
+    <img alt="MIT License" src="https://img.shields.io/github/license/unnoq/orpc?logo=open-source-initiative" />
+  </a>
+  <a href="https://discord.gg/TXEbwRBvQn">
+    <img alt="Discord" src="https://img.shields.io/discord/1308966753044398161?color=7389D8&label&logo=discord&logoColor=ffffff" />
+  </a>
+</div>
+
+<h3 align="center">Typesafe APIs Made Simple 🪄</h3>
+
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards, ensuring a smooth and enjoyable developer experience.
+
+---
+
+## Highlights
+
+- **End-to-End Type Safety 🔒**: Ensure complete type safety from inputs to outputs and errors, bridging server and client seamlessly.
+- **First-Class OpenAPI 📄**: Adheres to the OpenAPI standard out of the box, ensuring seamless integration and comprehensive API documentation.
+- **Contract-First Development 📜**: (Optional) Define your API contract upfront and implement it with confidence.
+- **Exceptional Developer Experience ✨**: Enjoy a streamlined workflow with robust typing and clear, in-code documentation.
+- **Multi-Runtime Support 🌍**: Run your code seamlessly on Cloudflare, Deno, Bun, Node.js, and more.
+- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue, Solid, Svelte), Pinia Colada, and more.
+- **Server Actions ⚡️**: Fully compatible with React Server Actions on Next.js, TanStack Start, and more.
+- **Standard Schema Support 🗂️**: Effortlessly work with Zod, Valibot, ArkType, and others right out of the box.
+- **Fast & Lightweight 💨**: Built on native APIs across all runtimes – optimized for speed and efficiency.
+- **Native Types 📦**: Enjoy built-in support for Date, File, Blob, BigInt, URL and more with no extra setup.
+- **Lazy Router ⏱️**: Improve cold start times with our lazy routing feature.
+- **SSE & Streaming 📡**: Provides SSE and streaming features – perfect for real-time notifications and AI-powered streaming responses.
+- **Reusability 🔄**: Write once and reuse your code across multiple purposes effortlessly.
+- **Extendability 🔌**: Easily enhance oRPC with plugins, middleware, and interceptors.
+- **Reliability 🛡️**: Well-tested, fully TypeScript, production-ready, and MIT licensed for peace of mind.
+- **Simplicity 💡**: Enjoy straightforward, clean code with no hidden magic.
+
+## Documentation
+
+You can find the full documentation [here](https://orpc.unnoq.com).
+
+## Packages
+
+- [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
+- [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
+- [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
+- [@orpc/react](https://www.npmjs.com/package/@orpc/react): Utilities for integrating oRPC with React and React Server Actions.
+- [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
+- [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).
+- [@orpc/solid-query](https://www.npmjs.com/package/@orpc/solid-query): Integration with [Solid Query](https://tanstack.com/query/latest/docs/framework/solid/overview).
+- [@orpc/svelte-query](https://www.npmjs.com/package/@orpc/svelte-query): Integration with [Svelte Query](https://tanstack.com/query/latest/docs/framework/svelte/overview).
+- [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
+- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
+- [@orpc/valibot](https://www.npmjs.com/package/@orpc/valibot): OpenAPI spec generation from [Valibot](https://valibot.dev/).
+- [@orpc/arktype](https://www.npmjs.com/package/@orpc/arktype): OpenAPI spec generation from [ArkType](https://arktype.io/).
+
+## `@orpc/standard-server-node`
+
+[Node.js](https://nodejs.org) server adapter for oRPC.
+
+## Sponsors
+
+<p align="center">
+  <a href="https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg">
+    <img src='https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg'/>
+  </a>
+</p>
+
+## License
+
+Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

package/dist/index.d.mts

@@ -0,0 +1,56 @@
+import { StandardBody, StandardHeaders, StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
+import { Readable } from 'node:stream';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+
+declare function toEventIterator(stream: Readable): AsyncGenerator<unknown | void, unknown | void, void>;
+interface ToEventStreamOptions {
+    /**
+     * If true, a ping comment is sent periodically to keep the connection alive.
+     *
+     * @default true
+     */
+    eventIteratorKeepAliveEnabled?: boolean;
+    /**
+     * Interval (in milliseconds) between ping comments sent after the last event.
+     *
+     * @default 5000
+     */
+    eventIteratorKeepAliveInterval?: number;
+    /**
+     * The content of the ping comment. Must not include newline characters.
+     *
+     * @default ''
+     */
+    eventIteratorKeepAliveComment?: string;
+}
+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;
+};
+type NodeHttpResponse = ServerResponse | Http2ServerResponse;
+
+declare function toStandardBody(req: NodeHttpRequest): 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 toStandardLazyRequest(req: NodeHttpRequest, res: NodeHttpResponse): StandardLazyRequest;
+
+interface SendStandardResponseOptions extends ToNodeHttpBodyOptions {
+}
+declare function sendStandardResponse(res: NodeHttpResponse, standardResponse: StandardResponse, options?: SendStandardResponseOptions): Promise<void>;
+
+declare function toAbortSignal(res: NodeHttpResponse): AbortSignal;
+
+export { type NodeHttpRequest, type NodeHttpResponse, type SendStandardResponseOptions, type ToEventStreamOptions, type ToNodeHttpBodyOptions, sendStandardResponse, toAbortSignal, toEventIterator, toEventStream, toNodeHttpBody, toStandardBody, toStandardLazyRequest };

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+import { StandardBody, StandardHeaders, StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
+import { Readable } from 'node:stream';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+
+declare function toEventIterator(stream: Readable): AsyncGenerator<unknown | void, unknown | void, void>;
+interface ToEventStreamOptions {
+    /**
+     * If true, a ping comment is sent periodically to keep the connection alive.
+     *
+     * @default true
+     */
+    eventIteratorKeepAliveEnabled?: boolean;
+    /**
+     * Interval (in milliseconds) between ping comments sent after the last event.
+     *
+     * @default 5000
+     */
+    eventIteratorKeepAliveInterval?: number;
+    /**
+     * The content of the ping comment. Must not include newline characters.
+     *
+     * @default ''
+     */
+    eventIteratorKeepAliveComment?: string;
+}
+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;
+};
+type NodeHttpResponse = ServerResponse | Http2ServerResponse;
+
+declare function toStandardBody(req: NodeHttpRequest): 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 toStandardLazyRequest(req: NodeHttpRequest, res: NodeHttpResponse): StandardLazyRequest;
+
+interface SendStandardResponseOptions extends ToNodeHttpBodyOptions {
+}
+declare function sendStandardResponse(res: NodeHttpResponse, standardResponse: StandardResponse, options?: SendStandardResponseOptions): Promise<void>;
+
+declare function toAbortSignal(res: NodeHttpResponse): AbortSignal;
+
+export { type NodeHttpRequest, type NodeHttpResponse, type SendStandardResponseOptions, type ToEventStreamOptions, type ToNodeHttpBodyOptions, sendStandardResponse, toAbortSignal, toEventIterator, toEventStream, toNodeHttpBody, toStandardBody, toStandardLazyRequest };

package/dist/index.mjs

@@ -0,0 +1,230 @@
+import { Readable } from 'node:stream';
+import { stringifyJSON, parseEmptyableJSON, isTypescriptObject, isAsyncIteratorObject, once } from '@orpc/shared';
+import { EventDecoderStream, encodeEventMessage, getEventMeta, ErrorEvent, withEventMeta, parseContentDisposition, contentDisposition } from '@orpc/standard-server';
+
+function toEventIterator(stream) {
+  const eventStream = Readable.toWeb(stream).pipeThrough(new TextDecoderStream()).pipeThrough(new EventDecoderStream());
+  const reader = eventStream.getReader();
+  async function* gen() {
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          return;
+        }
+        switch (value.event) {
+          case "message": {
+            let message = parseEmptyableJSON(value.data);
+            if (isTypescriptObject(message)) {
+              message = withEventMeta(message, value);
+            }
+            yield message;
+            break;
+          }
+          case "error": {
+            let error = new ErrorEvent({
+              data: parseEmptyableJSON(value.data)
+            });
+            error = withEventMeta(error, value);
+            throw error;
+          }
+          case "done": {
+            let done2 = parseEmptyableJSON(value.data);
+            if (isTypescriptObject(done2)) {
+              done2 = withEventMeta(done2, value);
+            }
+            return done2;
+          }
+        }
+      }
+    } finally {
+      await reader.cancel();
+    }
+  }
+  return gen();
+}
+function toEventStream(iterator, options = {}) {
+  const keepAliveEnabled = options.eventIteratorKeepAliveEnabled ?? true;
+  const keepAliveInterval = options.eventIteratorKeepAliveInterval ?? 5e3;
+  const keepAliveComment = options.eventIteratorKeepAliveComment ?? "";
+  let timeout;
+  const stream = new ReadableStream({
+    async pull(controller) {
+      try {
+        if (keepAliveEnabled) {
+          timeout = setInterval(() => {
+            controller.enqueue(encodeEventMessage({
+              comments: [keepAliveComment]
+            }));
+          }, keepAliveInterval);
+        }
+        const value = await iterator.next();
+        clearInterval(timeout);
+        controller.enqueue(encodeEventMessage({
+          ...getEventMeta(value.value),
+          event: value.done ? "done" : "message",
+          data: stringifyJSON(value.value)
+        }));
+        if (value.done) {
+          controller.close();
+        }
+      } catch (err) {
+        clearInterval(timeout);
+        controller.enqueue(encodeEventMessage({
+          ...getEventMeta(err),
+          event: "error",
+          data: err instanceof ErrorEvent ? stringifyJSON(err.data) : void 0
+        }));
+        controller.close();
+      }
+    },
+    async cancel(reason) {
+      if (reason) {
+        await iterator.throw?.(reason);
+      } else {
+        await iterator.return?.();
+      }
+    }
+  });
+  return Readable.fromWeb(stream);
+}
+
+async function toStandardBody(req) {
+  const method = req.method ?? "GET";
+  if (method === "GET" || method === "HEAD") {
+    return void 0;
+  }
+  const contentDisposition2 = req.headers["content-disposition"];
+  const contentType = req.headers["content-type"];
+  if (contentDisposition2) {
+    const fileName = parseContentDisposition(contentDisposition2).parameters.filename;
+    if (typeof fileName === "string") {
+      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);
+  }
+  if (contentType.startsWith("text/plain")) {
+    return _streamToString(req);
+  }
+  return _streamToFile(req, "blob", contentType);
+}
+function toNodeHttpBody(body, headers, options = {}) {
+  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"] = contentDisposition(
+      body instanceof File ? body.name : "blob",
+      { type: "inline" }
+    );
+    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";
+    headers["cache-control"] = "no-cache";
+    headers.connection = "keep-alive";
+    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 toAbortSignal(res) {
+  const controller = new AbortController();
+  res.on("close", () => {
+    if (res.errored) {
+      controller.abort(res.errored.toString());
+    } else if (!res.writableFinished) {
+      controller.abort("Client connection prematurely closed.");
+    } else {
+      controller.abort("Server closed the connection.");
+    }
+  });
+  return controller.signal;
+}
+
+function toStandardLazyRequest(req, res) {
+  const method = req.method ?? "GET";
+  const protocol = "encrypted" in req.socket && req.socket.encrypted ? "https:" : "http:";
+  const host = req.headers.host ?? "localhost";
+  const url = new URL(req.originalUrl ?? req.url ?? "/", `${protocol}//${host}`);
+  return {
+    method,
+    url,
+    headers: req.headers,
+    body: once(() => toStandardBody(req)),
+    signal: toAbortSignal(res)
+  };
+}
+
+function sendStandardResponse(res, standardResponse, options = {}) {
+  return new Promise((resolve, reject) => {
+    res.on("error", reject);
+    res.on("finish", resolve);
+    const resHeaders = standardResponse.headers;
+    const resBody = toNodeHttpBody(standardResponse.body, resHeaders, options);
+    res.writeHead(standardResponse.status, resHeaders);
+    if (resBody === void 0) {
+      res.end(resBody);
+    } else if (typeof resBody === "string") {
+      res.end(resBody);
+    } else {
+      res.on("close", () => {
+        if (!resBody.closed) {
+          resBody.destroy(res.errored ?? void 0);
+        }
+      });
+      resBody.pipe(res);
+    }
+  });
+}
+
+export { sendStandardResponse, toAbortSignal, toEventIterator, toEventStream, toNodeHttpBody, toStandardBody, toStandardLazyRequest };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@orpc/standard-server-node",
+  "type": "module",
+  "version": "0.0.0-next.00fb0f4",
+  "license": "MIT",
+  "homepage": "https://orpc.unnoq.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unnoq/orpc.git",
+    "directory": "packages/standard-server-node"
+  },
+  "keywords": [
+    "orpc"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@orpc/shared": "0.0.0-next.00fb0f4",
+    "@orpc/standard-server": "0.0.0-next.00fb0f4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.1",
+    "@types/supertest": "^6.0.2",
+    "supertest": "^7.0.0"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "build:watch": "pnpm run build --watch",
+    "type:check": "tsc -b"
+  }
+}