@orpc/server 0.0.0-next.aa72097 → 0.0.0-next.ad0709a

package/dist/next.js

@@ -0,0 +1,38 @@
+import {
+  RPCHandler,
+  fetchReToStandardBody,
+  fetchRequestToStandardRequest,
+  standardBodyToFetchBody,
+  standardResponseToFetchResponse
+} from "./chunk-6RSW63UJ.js";
+import "./chunk-JHLUGXCM.js";
+import "./chunk-NOA3GBJQ.js";
+
+// src/adapters/next/serve.ts
+import { value } from "@orpc/shared";
+function serve(handler, ...[options]) {
+  const main = async (req) => {
+    const context = await value(options?.context ?? {}, req);
+    const { matched, response } = await handler.handle(req, { ...options, context });
+    if (matched) {
+      return response;
+    }
+    return new Response(`Cannot find a matching procedure for ${req.url}`, { status: 404 });
+  };
+  return {
+    GET: main,
+    POST: main,
+    PUT: main,
+    PATCH: main,
+    DELETE: main
+  };
+}
+export {
+  RPCHandler,
+  fetchReToStandardBody,
+  fetchRequestToStandardRequest,
+  serve,
+  standardBodyToFetchBody,
+  standardResponseToFetchResponse
+};
+//# sourceMappingURL=next.js.map

package/dist/node.js

@@ -1,87 +1,173 @@
 import {
-  ORPCHandler
-} from "./chunk-3BAPJGK6.js";
-import "./chunk-E7GUWVR4.js";
+  RPCCodec,
+  RPCMatcher,
+  StandardHandler
+} from "./chunk-JHLUGXCM.js";
+import "./chunk-NOA3GBJQ.js";
 
-// src/adapters/node/request-listener.ts
-function createRequest(req, res) {
-  const controller = new AbortController();
-  res.on("close", () => {
-    controller.abort();
-  });
+// src/adapters/node/utils.ts
+import { Buffer, File } from "node:buffer";
+import { Readable } from "node:stream";
+import { once } from "@orpc/shared";
+import cd from "content-disposition";
+function nodeHttpToStandardRequest(req, res) {
   const method = req.method ?? "GET";
-  const headers = createHeaders(req);
   const protocol = "encrypted" in req.socket && req.socket.encrypted ? "https:" : "http:";
-  const host = headers.get("Host") ?? "localhost";
+  const host = req.headers.host ?? "localhost";
   const url = new URL(req.originalUrl ?? req.url ?? "/", `${protocol}//${host}`);
-  const init = { method, headers, signal: controller.signal };
-  if (method !== "GET" && method !== "HEAD") {
-    init.body = new ReadableStream({
-      start(controller2) {
-        req.on("data", (chunk) => {
-          controller2.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
-        });
-        req.on("end", () => {
-          controller2.close();
-        });
+  return {
+    raw: { request: req, response: res },
+    method,
+    url,
+    headers: req.headers,
+    body: once(() => {
+      return nodeHttpRequestToStandardBody(req);
+    }),
+    get signal() {
+      const signal = nodeHttpResponseToAbortSignal(res);
+      Object.defineProperty(this, "signal", { value: signal, writable: true });
+      return signal;
+    },
+    set signal(value) {
+      Object.defineProperty(this, "signal", { value, writable: true });
+    }
+  };
+}
+function nodeHttpResponseSendStandardResponse(res, standardResponse) {
+  return new Promise((resolve, reject) => {
+    res.on("error", reject);
+    res.on("finish", resolve);
+    if (standardResponse.body === void 0) {
+      res.writeHead(standardResponse.status, standardResponse.headers);
+      res.end();
+    }
+    if (standardResponse.body instanceof Blob) {
+      const resHeaders = {
+        ...standardResponse.headers,
+        "content-type": standardResponse.body.type,
+        "content-length": standardResponse.body.size.toString()
+      };
+      if (!standardResponse.headers["content-disposition"] && standardResponse.body instanceof Blob) {
+        resHeaders["content-disposition"] = cd(standardResponse.body instanceof File ? standardResponse.body.name : "blob");
       }
+      res.writeHead(standardResponse.status, resHeaders);
+      Readable.fromWeb(
+        standardResponse.body.stream()
+        // Conflict between types=node and lib=dom so we need to cast it
+      ).pipe(res);
+      return;
+    }
+    if (standardResponse.body instanceof FormData) {
+      const response = new Response(standardResponse.body);
+      res.writeHead(standardResponse.status, {
+        ...standardResponse.headers,
+        "content-type": response.headers.get("content-type")
+      });
+      Readable.fromWeb(
+        response.body
+        // Conflict between types=node and lib=dom so we need to cast it
+      ).pipe(res);
+      return;
+    }
+    if (standardResponse.body instanceof URLSearchParams) {
+      res.writeHead(standardResponse.status, {
+        ...standardResponse.headers,
+        "content-type": "application/x-www-form-urlencoded"
+      });
+      const string2 = standardResponse.body.toString();
+      res.end(string2);
+      return;
+    }
+    res.writeHead(standardResponse.status, {
+      ...standardResponse.headers,
+      "content-type": "application/json"
     });
-    init.duplex = "half";
-  }
-  return new Request(url, init);
+    const string = JSON.stringify(standardResponse.body);
+    res.end(string);
+  });
 }
-function createHeaders(req) {
-  const headers = new Headers();
-  const rawHeaders = req.rawHeaders;
-  for (let i = 0; i < rawHeaders.length; i += 2) {
-    headers.append(rawHeaders[i], rawHeaders[i + 1]);
+async function nodeHttpRequestToStandardBody(req) {
+  const method = req.method ?? "GET";
+  if (method === "GET" || method === "HEAD") {
+    return void 0;
   }
-  return headers;
-}
-async function sendResponse(res, response) {
-  const headers = {};
-  for (const [key, value] of response.headers) {
-    if (key in headers) {
-      if (Array.isArray(headers[key])) {
-        headers[key].push(value);
-      } else {
-        headers[key] = [headers[key], value];
-      }
-    } else {
-      headers[key] = value;
+  const contentDisposition = req.headers["content-disposition"];
+  const fileName = contentDisposition ? cd.parse(contentDisposition).parameters.filename : void 0;
+  const contentType = req.headers["content-type"];
+  if (fileName) {
+    return await streamToFile(req, fileName, contentType || "application/octet-stream");
+  }
+  if (!contentType || contentType.startsWith("application/json")) {
+    const text = await streamToString(req);
+    if (!text) {
+      return void 0;
     }
+    return JSON.parse(text);
+  }
+  if (contentType.startsWith("multipart/form-data")) {
+    return await streamToFormData(req, contentType);
+  }
+  if (contentType.startsWith("application/x-www-form-urlencoded")) {
+    const text = await streamToString(req);
+    return new URLSearchParams(text);
+  }
+  if (contentType.startsWith("text/")) {
+    return await streamToString(req);
   }
-  res.writeHead(response.status, headers);
-  if (response.body != null && res.req.method !== "HEAD") {
-    for await (const chunk of response.body) {
-      res.write(chunk);
+  return streamToFile(req, "blob", contentType);
+}
+function streamToFormData(stream, contentType) {
+  const response = new Response(stream, {
+    // Conflict between types=node and lib=dom so we need to cast it
+    headers: {
+      "content-type": contentType
     }
+  });
+  return response.formData();
+}
+async function streamToString(stream) {
+  let string = "";
+  for await (const chunk of stream) {
+    string += chunk.toString();
   }
-  res.end();
+  return string;
+}
+async function streamToFile(stream, fileName, contentType) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(chunk);
+  }
+  return new File([Buffer.concat(chunks)], fileName, { type: contentType });
+}
+function nodeHttpResponseToAbortSignal(res) {
+  const controller = new AbortController();
+  res.on("close", () => {
+    controller.abort();
+  });
+  return controller.signal;
 }
 
-// src/adapters/node/orpc-handler.ts
-var ORPCHandler2 = class {
-  orpcFetchHandler;
+// src/adapters/node/rpc-handler.ts
+var RPCHandler = class {
+  standardHandler;
   constructor(router, options) {
-    this.orpcFetchHandler = new ORPCHandler(router, options);
+    const codec = options?.codec ?? new RPCCodec();
+    const matcher = options?.matcher ?? new RPCMatcher();
+    this.standardHandler = new StandardHandler(router, matcher, codec, options);
   }
-  async handle(req, res, ...[options]) {
-    const request = createRequest(req, res);
-    const castedOptions = options ?? {};
-    const result = await this.orpcFetchHandler.handle(request, castedOptions);
-    if (result.matched === false) {
+  async handle(req, res, ...rest) {
+    const standardRequest = nodeHttpToStandardRequest(req, res);
+    const result = await this.standardHandler.handle(standardRequest, ...rest);
+    if (!result.matched) {
       return { matched: false };
     }
-    await options?.beforeSend?.(result.response, castedOptions.context);
-    await sendResponse(res, result.response);
+    await nodeHttpResponseSendStandardResponse(res, result.response);
     return { matched: true };
   }
 };
 export {
-  ORPCHandler2 as ORPCHandler,
-  createHeaders,
-  createRequest,
-  sendResponse
+  RPCHandler,
+  nodeHttpResponseSendStandardResponse,
+  nodeHttpToStandardRequest
 };
 //# sourceMappingURL=node.js.map

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

@@ -1,6 +1,4 @@
-export * from './orpc-handler';
-export * from './orpc-payload-codec';
-export * from './orpc-procedure-matcher';
-export * as SuperJSON from './super-json';
+export * from './rpc-handler';
 export * from './types';
+export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/fetch/rpc-handler.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from '../../context';
+import type { Router } from '../../router';
+import type { RPCHandlerOptions, StandardHandleRest } from '../standard';
+import type { FetchHandler, FetchHandleResult } from './types';
+export declare class RPCHandler<T extends Context> implements FetchHandler<T> {
+    private readonly standardHandler;
+    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
+    handle(request: Request, ...rest: StandardHandleRest<T>): Promise<FetchHandleResult>;
+}
+//# sourceMappingURL=rpc-handler.d.ts.map

package/dist/src/adapters/fetch/types.d.ts

@@ -1,13 +1,5 @@
-import type { HTTPPath } from '@orpc/contract';
-import type { Context } from '../../types';
-export type FetchHandleOptions<T extends Context> = {
-    prefix?: HTTPPath;
-} & (undefined extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
-export type FetchHandleRest<T extends Context> = [options: FetchHandleOptions<T>] | (undefined extends T ? [] : never);
+import type { Context } from '../../context';
+import type { StandardHandleRest } from '../standard';
 export type FetchHandleResult = {
     matched: true;
     response: Response;
@@ -16,6 +8,6 @@ export type FetchHandleResult = {
     response: undefined;
 };
 export interface FetchHandler<T extends Context> {
-    handle: (request: Request, ...rest: FetchHandleRest<T>) => Promise<FetchHandleResult>;
+    handle(request: Request, ...rest: StandardHandleRest<T>): Promise<FetchHandleResult>;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/src/adapters/fetch/utils.d.ts

@@ -0,0 +1,6 @@
+import type { StandardBody, StandardRequest, StandardResponse } from '../standard';
+export declare function fetchReToStandardBody(re: Request | Response): Promise<StandardBody>;
+export declare function fetchRequestToStandardRequest(request: Request): StandardRequest;
+export declare function standardBodyToFetchBody(body: StandardBody): Blob | FormData | URLSearchParams | string | undefined;
+export declare function standardResponseToFetchResponse(response: StandardResponse): Response;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/adapters/hono/middleware.d.ts

@@ -1,12 +1,13 @@
 import type { Context as HonoContext, MiddlewareHandler } from 'hono';
-import type { Context } from '../../types';
-import type { FetchHandleOptions, FetchHandler } from '../fetch';
+import type { Context } from '../../context';
+import type { FetchHandler } from '../fetch';
+import type { StandardHandleOptions } from '../standard';
 import { type Value } from '@orpc/shared';
-export type CreateMiddlewareOptions<T extends Context> = Omit<FetchHandleOptions<T>, 'context'> & (undefined extends T ? {
+export type CreateMiddlewareOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: Value<T, [HonoContext]>;
 } : {
     context: Value<T, [HonoContext]>;
 });
-export type CreateMiddlewareRest<T extends Context> = [options: CreateMiddlewareOptions<T>] | (undefined extends T ? [] : never);
+export type CreateMiddlewareRest<T extends Context> = [options: CreateMiddlewareOptions<T>] | (Record<never, never> extends T ? [] : never);
 export declare function createMiddleware<T extends Context>(handler: FetchHandler<T>, ...[options]: CreateMiddlewareRest<T>): MiddlewareHandler;
 //# sourceMappingURL=middleware.d.ts.map

package/dist/src/adapters/next/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../fetch';
+export * from './serve';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/next/serve.d.ts

@@ -0,0 +1,20 @@
+import type { NextRequest } from 'next/server';
+import type { Context } from '../../context';
+import type { FetchHandler } from '../fetch';
+import type { StandardHandleOptions } from '../standard';
+import { type Value } from '@orpc/shared';
+export type ServeOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: Value<T, [NextRequest]>;
+} : {
+    context: Value<T, [NextRequest]>;
+});
+export type ServeRest<T extends Context> = [options: ServeOptions<T>] | (Record<never, never> extends T ? [] : never);
+export interface ServeResult {
+    GET(req: NextRequest): Promise<Response>;
+    POST(req: NextRequest): Promise<Response>;
+    PUT(req: NextRequest): Promise<Response>;
+    PATCH(req: NextRequest): Promise<Response>;
+    DELETE(req: NextRequest): Promise<Response>;
+}
+export declare function serve<T extends Context>(handler: FetchHandler<T>, ...[options]: ServeRest<T>): ServeResult;
+//# sourceMappingURL=serve.d.ts.map

package/dist/src/adapters/node/index.d.ts

@@ -1,5 +1,4 @@
-export * from './orpc-handler';
-export * from './orpc-handler';
-export * from './request-listener';
+export * from './rpc-handler';
 export * from './types';
+export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/node/rpc-handler.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from '../../context';
+import type { Router } from '../../router';
+import type { RPCHandlerOptions, StandardHandleRest } from '../standard';
+import type { NodeHttpHandler, NodeHttpHandleResult, NodeHttpRequest, NodeHttpResponse } from './types';
+export declare class RPCHandler<T extends Context> implements NodeHttpHandler<T> {
+    private readonly standardHandler;
+    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
+    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: StandardHandleRest<T>): Promise<NodeHttpHandleResult>;
+}
+//# sourceMappingURL=rpc-handler.d.ts.map

package/dist/src/adapters/node/types.d.ts

@@ -1,22 +1,21 @@
-import type { HTTPPath } from '@orpc/contract';
-import type { Promisable } from '@orpc/shared';
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { Context } from '../../types';
-export type RequestHandleOptions<T extends Context> = {
-    prefix?: HTTPPath;
-    beforeSend?: (response: Response, context: T) => Promisable<void>;
-} & (undefined extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
-export type RequestHandleRest<T extends Context> = [options: RequestHandleOptions<T>] | (undefined extends T ? [] : never);
-export type RequestHandleResult = {
+import type { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+import type { Context } from '../../context';
+import type { StandardHandleRest } from '../standard';
+export type NodeHttpRequest = (IncomingMessage | Http2ServerRequest) & {
+    /**
+     * Replace `req.url` with `req.originalUrl` when `req.originalUrl` is available.
+     * This is useful for `express.js` middleware.
+     */
+    originalUrl?: string;
+};
+export type NodeHttpResponse = ServerResponse | Http2ServerResponse;
+export type NodeHttpHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-export interface RequestHandler<T extends Context> {
-    handle: (req: IncomingMessage, res: ServerResponse, ...rest: RequestHandleRest<T>) => Promise<RequestHandleResult>;
+export interface NodeHttpHandler<T extends Context> {
+    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: StandardHandleRest<T>): Promise<NodeHttpHandleResult>;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/src/adapters/node/utils.d.ts

@@ -0,0 +1,5 @@
+import type { StandardRequest, StandardResponse } from '../standard';
+import type { NodeHttpRequest, NodeHttpResponse } from './types';
+export declare function nodeHttpToStandardRequest(req: NodeHttpRequest, res: NodeHttpResponse): StandardRequest;
+export declare function nodeHttpResponseSendStandardResponse(res: NodeHttpResponse, standardResponse: StandardResponse): Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/adapters/standard/handler.d.ts

@@ -0,0 +1,33 @@
+import type { HTTPPath } from '@orpc/contract';
+import type { Interceptable } from '@orpc/shared';
+import type { Context } from '../../context';
+import type { Router } from '../../router';
+import type { StandardCodec, StandardMatcher, StandardRequest, StandardResponse } from './types';
+export type StandardHandleOptions<T extends Context> = {
+    prefix?: HTTPPath;
+} & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+export type StandardHandleRest<T extends Context> = [options: StandardHandleOptions<T>] | (Record<never, never> extends T ? [] : never);
+export type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+export interface StandardHandlerOptions<TContext extends Context> extends Interceptable<{
+    context: TContext;
+    request: StandardRequest;
+}, StandardHandleResult, unknown> {
+}
+export declare class StandardHandler<TContext extends Context> {
+    private readonly matcher;
+    private readonly codec;
+    private readonly options;
+    constructor(router: Router<TContext, any>, matcher: StandardMatcher, codec: StandardCodec, options?: NoInfer<StandardHandlerOptions<TContext>>);
+    handle(request: StandardRequest, ...[options]: StandardHandleRest<TContext>): Promise<StandardHandleResult>;
+}
+//# sourceMappingURL=handler.d.ts.map

package/dist/src/adapters/standard/index.d.ts

@@ -0,0 +1,7 @@
+export * from './handler';
+export * from './rpc-codec';
+export * from './rpc-handler';
+export * from './rpc-matcher';
+export * from './rpc-serializer';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/standard/rpc-codec.d.ts

@@ -0,0 +1,15 @@
+import type { ORPCError } from '@orpc/contract';
+import type { AnyProcedure } from '../../procedure';
+import type { StandardCodec, StandardParams, StandardRequest, StandardResponse } from './types';
+import { RPCSerializer } from './rpc-serializer';
+export interface StandardCodecOptions {
+    serializer?: RPCSerializer;
+}
+export declare class RPCCodec implements StandardCodec {
+    private readonly serializer;
+    constructor(options?: StandardCodecOptions);
+    decode(request: StandardRequest, _params: StandardParams | undefined, _procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, _procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+//# sourceMappingURL=rpc-codec.d.ts.map

package/dist/src/adapters/standard/rpc-handler.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from '../../context';
+import type { StandardHandlerOptions } from './handler';
+import type { StandardCodec, StandardMatcher } from './types';
+export interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T> {
+    matcher?: StandardMatcher;
+    codec?: StandardCodec;
+}
+//# sourceMappingURL=rpc-handler.d.ts.map

package/dist/src/adapters/standard/rpc-matcher.d.ts

@@ -0,0 +1,10 @@
+import type { HTTPPath } from '@orpc/contract';
+import type { StandardMatcher, StandardMatchResult } from './types';
+import { type AnyRouter } from '../../router';
+export declare class RPCMatcher implements StandardMatcher {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: string[]): void;
+    match(_method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+//# sourceMappingURL=rpc-matcher.d.ts.map

package/dist/src/adapters/standard/rpc-serializer.d.ts

@@ -0,0 +1,16 @@
+import type { Segment } from '@orpc/shared';
+export type RPCSerializedJsonMeta = ['bigint' | 'date' | 'nan' | 'undefined' | 'set' | 'map' | 'regexp' | 'url', Segment[]][];
+export type RPCSerialized = {
+    json: unknown;
+    meta: RPCSerializedJsonMeta;
+} | FormData | Blob;
+export type RPCSerializedFormDataMaps = Segment[][];
+export declare class RPCSerializer {
+    serialize(data: unknown): RPCSerialized;
+    deserialize(serialized: RPCSerialized): unknown;
+}
+export declare function serializeRPCJson(value: unknown, segments?: Segment[], meta?: RPCSerializedJsonMeta): {
+    json: unknown;
+    meta: RPCSerializedJsonMeta;
+};
+//# sourceMappingURL=rpc-serializer.d.ts.map

package/dist/src/adapters/standard/types.d.ts

@@ -0,0 +1,44 @@
+import type { AbortSignal, HTTPPath, ORPCError } from '@orpc/contract';
+import type { JsonValue } from '@orpc/shared';
+import type { AnyProcedure } from '../../procedure';
+import type { AnyRouter } from '../../router';
+export interface StandardHeaders {
+    [key: string]: string | string[] | undefined;
+}
+export type StandardBody = undefined | JsonValue | Blob | URLSearchParams | FormData;
+export interface StandardRequest {
+    /**
+     * Can be { request: Request } or { request: IncomingMessage, response: ServerResponse } based on the adapter.
+     */
+    raw: Record<string, unknown>;
+    method: string;
+    url: URL;
+    headers: StandardHeaders;
+    /**
+     * The body has been parsed base on the content-type header.
+     * This method can safely call multiple times (cached).
+     */
+    body(): Promise<StandardBody>;
+    signal?: AbortSignal;
+}
+export interface StandardResponse {
+    status: number;
+    headers: StandardHeaders;
+    body: StandardBody;
+}
+export type StandardParams = Record<string, string>;
+export type StandardMatchResult = {
+    path: string[];
+    procedure: AnyProcedure;
+    params?: StandardParams;
+} | undefined;
+export interface StandardMatcher {
+    init(router: AnyRouter): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+export interface StandardCodec {
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+    decode(request: StandardRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+}
+//# sourceMappingURL=types.d.ts.map