@orpc/server 0.0.0-next.f99e554 → 0.0.0-next.fb0d07c

package/README.md

@@ -0,0 +1,128 @@
+<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/server">
+    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Fserver?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
+
+---
+
+## Highlights
+
+- **🔗 End-to-End Type Safety**: Ensure type-safe inputs, outputs, and errors from client to server.
+- **📘 First-Class OpenAPI**: Built-in support that fully adheres to the OpenAPI standard.
+- **📝 Contract-First Development**: Optionally define your API contract before implementation.
+- **⚙️ Framework Integrations**: Seamlessly integrate with TanStack Query (React, Vue, Solid, Svelte), Pinia Colada, and more.
+- **🚀 Server Actions**: Fully compatible with React Server Actions on Next.js, TanStack Start, and other platforms.
+- **🔠 Standard Schema Support**: Works out of the box with Zod, Valibot, ArkType, and other schema validators.
+- **🗃️ Native Types**: Supports native types like Date, File, Blob, BigInt, URL, and more.
+- **⏱️ Lazy Router**: Enhance cold start times with our lazy routing feature.
+- **📡 SSE & Streaming**: Enjoy full type-safe support for SSE and streaming.
+- **🌍 Multi-Runtime Support**: Fast and lightweight on Cloudflare, Deno, Bun, Node.js, and beyond.
+- **🔌 Extendability**: Easily extend functionality with plugins, middleware, and interceptors.
+- **🛡️ Reliability**: Well-tested, TypeScript-based, production-ready, and MIT licensed.
+
+## 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/nest](https://www.npmjs.com/package/@orpc/nest): Deeply integrate oRPC with NestJS.
+- [@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/server`
+
+Build your API or implement API contract. Read the [documentation](https://orpc.unnoq.com/docs/getting-started) for more information.
+
+```ts
+import type { IncomingHttpHeaders } from 'node:http'
+import { ORPCError, os } from '@orpc/server'
+import { z } from 'zod'
+
+const PlanetSchema = z.object({
+  id: z.number().int().min(1),
+  name: z.string(),
+  description: z.string().optional(),
+})
+
+export const listPlanet = os
+  .input(
+    z.object({
+      limit: z.number().int().min(1).max(100).optional(),
+      cursor: z.number().int().min(0).default(0),
+    }),
+  )
+  .handler(async ({ input }) => {
+    // your list code here
+    return [{ id: 1, name: 'name' }]
+  })
+
+export const findPlanet = os
+  .input(PlanetSchema.pick({ id: true }))
+  .handler(async ({ input }) => {
+    // your find code here
+    return { id: 1, name: 'name' }
+  })
+
+export const createPlanet = os
+  .$context<{ headers: IncomingHttpHeaders }>()
+  .use(({ context, next }) => {
+    const user = parseJWT(context.headers.authorization?.split(' ')[1])
+
+    if (user) {
+      return next({ context: { user } })
+    }
+
+    throw new ORPCError('UNAUTHORIZED')
+  })
+  .input(PlanetSchema.omit({ id: true }))
+  .handler(async ({ input, context }) => {
+    // your create code here
+    return { id: 1, name: 'name' }
+  })
+
+export const router = { planet: { list: listPlanet, find: findPlanet, create: createPlanet } }
+```
+
+## 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/adapters/bun-ws/index.d.mts

@@ -0,0 +1,35 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, R as Router } from '../../shared/server.DD2C4ujN.mjs';
+import { i as StandardHandler } from '../../shared/server.Dq8xr7PQ.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.BliFSTnG.mjs';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.Bd52nNaH.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+
+interface ServerWebSocket {
+    send(message: string | ArrayBufferLike): number;
+}
+declare class experimental_BunWsHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly peers;
+    constructor(standardHandler: StandardHandler<T>);
+    message(ws: ServerWebSocket, message: string | {
+        buffer: ArrayBufferLike;
+    }, ...rest: MaybeOptionalOptions<Omit<FriendlyStandardHandleOptions<T>, 'prefix'>>): Promise<void>;
+    close(ws: ServerWebSocket): void;
+}
+
+/**
+ * RPC Handler for Bun WS adapter
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class experimental_RPCHandler<T extends Context> extends experimental_BunWsHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { experimental_BunWsHandler, experimental_RPCHandler };
+export type { ServerWebSocket };

package/dist/adapters/bun-ws/index.d.ts

@@ -0,0 +1,35 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, R as Router } from '../../shared/server.DD2C4ujN.js';
+import { i as StandardHandler } from '../../shared/server.-ACo36I0.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.IG2MjhrD.js';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.BPAWobQg.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+
+interface ServerWebSocket {
+    send(message: string | ArrayBufferLike): number;
+}
+declare class experimental_BunWsHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly peers;
+    constructor(standardHandler: StandardHandler<T>);
+    message(ws: ServerWebSocket, message: string | {
+        buffer: ArrayBufferLike;
+    }, ...rest: MaybeOptionalOptions<Omit<FriendlyStandardHandleOptions<T>, 'prefix'>>): Promise<void>;
+    close(ws: ServerWebSocket): void;
+}
+
+/**
+ * RPC Handler for Bun WS adapter
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class experimental_RPCHandler<T extends Context> extends experimental_BunWsHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { experimental_BunWsHandler, experimental_RPCHandler };
+export type { ServerWebSocket };

package/dist/adapters/bun-ws/index.mjs

@@ -0,0 +1,51 @@
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
+import { ServerPeer } from '@orpc/standard-server-peer';
+import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.BVwwTHyO.mjs';
+import '@orpc/client';
+import '@orpc/standard-server';
+import '@orpc/contract';
+import { b as StandardRPCHandler } from '../../shared/server.4FnxLwwr.mjs';
+import '@orpc/client/standard';
+import '../../shared/server.DG7Tamti.mjs';
+
+class experimental_BunWsHandler {
+  constructor(standardHandler) {
+    this.standardHandler = standardHandler;
+  }
+  peers = /* @__PURE__ */ new WeakMap();
+  async message(ws, message, ...rest) {
+    let peer = this.peers.get(ws);
+    if (!peer) {
+      this.peers.set(ws, peer = new ServerPeer(async (raw) => {
+        if (raw instanceof Blob) {
+          const buffer = await raw.arrayBuffer();
+          ws.send(buffer);
+        } else {
+          ws.send(raw);
+        }
+      }));
+    }
+    const [id, request] = await peer.message(typeof message === "string" ? message : message.buffer);
+    if (!request) {
+      return;
+    }
+    const options = resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest));
+    const { response } = await this.standardHandler.handle({ ...request, body: () => Promise.resolve(request.body) }, options);
+    await peer.response(id, response ?? { status: 404, headers: {}, body: "No procedure matched" });
+  }
+  close(ws) {
+    const server = this.peers.get(ws);
+    if (server) {
+      server.close();
+      this.peers.delete(ws);
+    }
+  }
+}
+
+class experimental_RPCHandler extends experimental_BunWsHandler {
+  constructor(router, options = {}) {
+    super(new StandardRPCHandler(router, options));
+  }
+}
+
+export { experimental_BunWsHandler, experimental_RPCHandler };

package/dist/adapters/crossws/index.d.mts

@@ -0,0 +1,30 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { Peer, Message } from 'crossws';
+import { C as Context, R as Router } from '../../shared/server.DD2C4ujN.mjs';
+import { i as StandardHandler } from '../../shared/server.Dq8xr7PQ.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.BliFSTnG.mjs';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.Bd52nNaH.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+
+declare class experimental_CrosswsHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly peers;
+    constructor(standardHandler: StandardHandler<T>);
+    message(ws: Pick<Peer, 'send'>, message: Pick<Message, 'rawData' | 'uint8Array'>, ...rest: MaybeOptionalOptions<Omit<FriendlyStandardHandleOptions<T>, 'prefix'>>): Promise<void>;
+    close(ws: Pick<Peer, 'send'>): void;
+}
+
+/**
+ * RPC Handler for Crossws adapter
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class experimental_RPCHandler<T extends Context> extends experimental_CrosswsHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { experimental_CrosswsHandler, experimental_RPCHandler };

package/dist/adapters/crossws/index.d.ts

@@ -0,0 +1,30 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { Peer, Message } from 'crossws';
+import { C as Context, R as Router } from '../../shared/server.DD2C4ujN.js';
+import { i as StandardHandler } from '../../shared/server.-ACo36I0.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.IG2MjhrD.js';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.BPAWobQg.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+
+declare class experimental_CrosswsHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly peers;
+    constructor(standardHandler: StandardHandler<T>);
+    message(ws: Pick<Peer, 'send'>, message: Pick<Message, 'rawData' | 'uint8Array'>, ...rest: MaybeOptionalOptions<Omit<FriendlyStandardHandleOptions<T>, 'prefix'>>): Promise<void>;
+    close(ws: Pick<Peer, 'send'>): void;
+}
+
+/**
+ * RPC Handler for Crossws adapter
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class experimental_RPCHandler<T extends Context> extends experimental_CrosswsHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { experimental_CrosswsHandler, experimental_RPCHandler };

package/dist/adapters/crossws/index.mjs

@@ -0,0 +1,51 @@
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
+import { ServerPeer } from '@orpc/standard-server-peer';
+import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.BVwwTHyO.mjs';
+import '@orpc/client';
+import '@orpc/standard-server';
+import '@orpc/contract';
+import { b as StandardRPCHandler } from '../../shared/server.4FnxLwwr.mjs';
+import '@orpc/client/standard';
+import '../../shared/server.DG7Tamti.mjs';
+
+class experimental_CrosswsHandler {
+  constructor(standardHandler) {
+    this.standardHandler = standardHandler;
+  }
+  peers = /* @__PURE__ */ new WeakMap();
+  async message(ws, message, ...rest) {
+    let peer = this.peers.get(ws);
+    if (!peer) {
+      this.peers.set(ws, peer = new ServerPeer(async (raw) => {
+        if (raw instanceof Blob) {
+          const buffer = await raw.arrayBuffer();
+          ws.send(buffer);
+        } else {
+          ws.send(raw);
+        }
+      }));
+    }
+    const [id, request] = await peer.message(typeof message.rawData === "string" ? message.rawData : message.uint8Array());
+    if (!request) {
+      return;
+    }
+    const options = resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest));
+    const { response } = await this.standardHandler.handle({ ...request, body: () => Promise.resolve(request.body) }, options);
+    await peer.response(id, response ?? { status: 404, headers: {}, body: "No procedure matched" });
+  }
+  close(ws) {
+    const server = this.peers.get(ws);
+    if (server) {
+      server.close();
+      this.peers.delete(ws);
+    }
+  }
+}
+
+class experimental_RPCHandler extends experimental_CrosswsHandler {
+  constructor(router, options = {}) {
+    super(new StandardRPCHandler(router, options));
+  }
+}
+
+export { experimental_CrosswsHandler, experimental_RPCHandler };

package/dist/adapters/fetch/index.d.mts

@@ -0,0 +1,78 @@
+import { C as Context, R as Router } from '../../shared/server.DD2C4ujN.mjs';
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { ToFetchResponseOptions } from '@orpc/standard-server-fetch';
+import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, g as StandardHandleOptions, i as StandardHandler } from '../../shared/server.Dq8xr7PQ.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.BliFSTnG.mjs';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.Bd52nNaH.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+
+interface FetchHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
+    initRuntimeAdapter?(options: FetchHandlerOptions<T>): void;
+}
+declare class CompositeFetchHandlerPlugin<T extends Context, TPlugin extends FetchHandlerPlugin<T>> extends CompositeStandardHandlerPlugin<T, TPlugin> implements FetchHandlerPlugin<T> {
+    initRuntimeAdapter(options: FetchHandlerOptions<T>): void;
+}
+
+type FetchHandleResult = {
+    matched: true;
+    response: Response;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface FetchHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+    request: Request;
+    toFetchResponseOptions: ToFetchResponseOptions;
+}
+interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions {
+    adapterInterceptors?: Interceptor<FetchHandlerInterceptorOptions<T>, Promise<FetchHandleResult>>[];
+    plugins?: FetchHandlerPlugin<T>[];
+}
+declare class FetchHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly toFetchResponseOptions;
+    private readonly adapterInterceptors;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
+    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<FetchHandleResult>;
+}
+
+interface BodyLimitPluginOptions {
+    /**
+     * The maximum size of the body in bytes.
+     */
+    maxBodySize: number;
+}
+/**
+ * The Body Limit Plugin restricts the size of the request body for the Fetch Server.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/body-limit Body Limit Plugin Docs}
+ */
+declare class BodyLimitPlugin<T extends Context> implements FetchHandlerPlugin<T> {
+    private readonly maxBodySize;
+    constructor(options: BodyLimitPluginOptions);
+    initRuntimeAdapter(options: FetchHandlerOptions<T>): void;
+}
+
+type RPCHandlerOptions<T extends Context> = FetchHandlerOptions<T> & StandardRPCHandlerOptions<T> & {
+    /**
+     * Enables or disables the StrictGetMethodPlugin.
+     *
+     * @default true
+     */
+    strictGetMethodPluginEnabled?: boolean;
+};
+/**
+ * RPC Handler for Fetch Server
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends FetchHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}
+
+export { BodyLimitPlugin, CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
+export type { BodyLimitPluginOptions, FetchHandleResult, FetchHandlerInterceptorOptions, FetchHandlerOptions, FetchHandlerPlugin, RPCHandlerOptions };

package/dist/adapters/fetch/index.d.ts

@@ -0,0 +1,78 @@
+import { C as Context, R as Router } from '../../shared/server.DD2C4ujN.js';
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { ToFetchResponseOptions } from '@orpc/standard-server-fetch';
+import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, g as StandardHandleOptions, i as StandardHandler } from '../../shared/server.-ACo36I0.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.IG2MjhrD.js';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.BPAWobQg.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+
+interface FetchHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
+    initRuntimeAdapter?(options: FetchHandlerOptions<T>): void;
+}
+declare class CompositeFetchHandlerPlugin<T extends Context, TPlugin extends FetchHandlerPlugin<T>> extends CompositeStandardHandlerPlugin<T, TPlugin> implements FetchHandlerPlugin<T> {
+    initRuntimeAdapter(options: FetchHandlerOptions<T>): void;
+}
+
+type FetchHandleResult = {
+    matched: true;
+    response: Response;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface FetchHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+    request: Request;
+    toFetchResponseOptions: ToFetchResponseOptions;
+}
+interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions {
+    adapterInterceptors?: Interceptor<FetchHandlerInterceptorOptions<T>, Promise<FetchHandleResult>>[];
+    plugins?: FetchHandlerPlugin<T>[];
+}
+declare class FetchHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly toFetchResponseOptions;
+    private readonly adapterInterceptors;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
+    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<FetchHandleResult>;
+}
+
+interface BodyLimitPluginOptions {
+    /**
+     * The maximum size of the body in bytes.
+     */
+    maxBodySize: number;
+}
+/**
+ * The Body Limit Plugin restricts the size of the request body for the Fetch Server.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/body-limit Body Limit Plugin Docs}
+ */
+declare class BodyLimitPlugin<T extends Context> implements FetchHandlerPlugin<T> {
+    private readonly maxBodySize;
+    constructor(options: BodyLimitPluginOptions);
+    initRuntimeAdapter(options: FetchHandlerOptions<T>): void;
+}
+
+type RPCHandlerOptions<T extends Context> = FetchHandlerOptions<T> & StandardRPCHandlerOptions<T> & {
+    /**
+     * Enables or disables the StrictGetMethodPlugin.
+     *
+     * @default true
+     */
+    strictGetMethodPluginEnabled?: boolean;
+};
+/**
+ * RPC Handler for Fetch Server
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends FetchHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}
+
+export { BodyLimitPlugin, CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
+export type { BodyLimitPluginOptions, FetchHandleResult, FetchHandlerInterceptorOptions, FetchHandlerOptions, FetchHandlerPlugin, RPCHandlerOptions };

package/dist/adapters/fetch/index.mjs

@@ -0,0 +1,110 @@
+import { ORPCError } from '@orpc/client';
+import { toArray, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { toStandardLazyRequest, toFetchResponse } from '@orpc/standard-server-fetch';
+import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.BVwwTHyO.mjs';
+import '@orpc/standard-server';
+import '@orpc/contract';
+import { C as CompositeStandardHandlerPlugin, b as StandardRPCHandler } from '../../shared/server.4FnxLwwr.mjs';
+import '@orpc/client/standard';
+import '@orpc/standard-server/batch';
+import { S as StrictGetMethodPlugin } from '../../shared/server.BW-nUGgA.mjs';
+import '../../shared/server.DG7Tamti.mjs';
+
+class BodyLimitPlugin {
+  maxBodySize;
+  constructor(options) {
+    this.maxBodySize = options.maxBodySize;
+  }
+  initRuntimeAdapter(options) {
+    options.adapterInterceptors ??= [];
+    options.adapterInterceptors.push(async (options2) => {
+      if (!options2.request.body) {
+        return options2.next();
+      }
+      let currentBodySize = 0;
+      const rawReader = options2.request.body.getReader();
+      const reader = new ReadableStream({
+        start: async (controller) => {
+          try {
+            if (Number(options2.request.headers.get("content-length")) > this.maxBodySize) {
+              controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
+              return;
+            }
+            while (true) {
+              const { done, value } = await rawReader.read();
+              if (done) {
+                break;
+              }
+              currentBodySize += value.length;
+              if (currentBodySize > this.maxBodySize) {
+                controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
+                break;
+              }
+              controller.enqueue(value);
+            }
+          } finally {
+            controller.close();
+          }
+        }
+      });
+      const requestInit = { body: reader, duplex: "half" };
+      return options2.next({
+        ...options2,
+        request: new Request(options2.request, requestInit)
+      });
+    });
+  }
+}
+
+class CompositeFetchHandlerPlugin extends CompositeStandardHandlerPlugin {
+  initRuntimeAdapter(options) {
+    for (const plugin of this.plugins) {
+      plugin.initRuntimeAdapter?.(options);
+    }
+  }
+}
+
+class FetchHandler {
+  constructor(standardHandler, options = {}) {
+    this.standardHandler = standardHandler;
+    const plugin = new CompositeFetchHandlerPlugin(options.plugins);
+    plugin.initRuntimeAdapter(options);
+    this.adapterInterceptors = toArray(options.adapterInterceptors);
+    this.toFetchResponseOptions = options;
+  }
+  toFetchResponseOptions;
+  adapterInterceptors;
+  async handle(request, ...rest) {
+    return intercept(
+      this.adapterInterceptors,
+      {
+        ...resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest)),
+        request,
+        toFetchResponseOptions: this.toFetchResponseOptions
+      },
+      async ({ request: request2, toFetchResponseOptions, ...options }) => {
+        const standardRequest = toStandardLazyRequest(request2);
+        const result = await this.standardHandler.handle(standardRequest, options);
+        if (!result.matched) {
+          return result;
+        }
+        return {
+          matched: true,
+          response: toFetchResponse(result.response, toFetchResponseOptions)
+        };
+      }
+    );
+  }
+}
+
+class RPCHandler extends FetchHandler {
+  constructor(router, options = {}) {
+    if (options.strictGetMethodPluginEnabled ?? true) {
+      options.plugins ??= [];
+      options.plugins.push(new StrictGetMethodPlugin());
+    }
+    super(new StandardRPCHandler(router, options), options);
+  }
+}
+
+export { BodyLimitPlugin, CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };