@orpc/server 0.43.0 → 0.44.0

package/README.md

@@ -1,5 +1,5 @@
 <div align="center">
-  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 />
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
 </div>
 
 <h1></h1>

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

@@ -0,0 +1,27 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { ToFetchResponseOptions } from '@orpc/standard-server-fetch';
+import { C as Context, R as Router } from '../../shared/server.CI7U5gRZ.mjs';
+import { S as StandardHandleOptions } from '../../shared/server.CHpDfeOK.mjs';
+import { R as RPCHandlerOptions } from '../../shared/server.MnOqRlBp.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+type FetchHandleResult = {
+    matched: true;
+    response: Response;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface FetchHandler<T extends Context> {
+    handle(request: Request, ...rest: MaybeOptionalOptions<StandardHandleOptions<T> & ToFetchResponseOptions>): Promise<FetchHandleResult>;
+}
+
+declare class RPCHandler<T extends Context> implements FetchHandler<T> {
+    private readonly standardHandler;
+    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
+    handle(request: Request, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T> & ToFetchResponseOptions>): Promise<FetchHandleResult>;
+}
+
+export { type FetchHandleResult, type FetchHandler, RPCHandler };

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

@@ -0,0 +1,27 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { ToFetchResponseOptions } from '@orpc/standard-server-fetch';
+import { C as Context, R as Router } from '../../shared/server.CI7U5gRZ.js';
+import { S as StandardHandleOptions } from '../../shared/server.DSZ2XY8G.js';
+import { R as RPCHandlerOptions } from '../../shared/server.BqEaivV1.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+type FetchHandleResult = {
+    matched: true;
+    response: Response;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface FetchHandler<T extends Context> {
+    handle(request: Request, ...rest: MaybeOptionalOptions<StandardHandleOptions<T> & ToFetchResponseOptions>): Promise<FetchHandleResult>;
+}
+
+declare class RPCHandler<T extends Context> implements FetchHandler<T> {
+    private readonly standardHandler;
+    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
+    handle(request: Request, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T> & ToFetchResponseOptions>): Promise<FetchHandleResult>;
+}
+
+export { type FetchHandleResult, type FetchHandler, RPCHandler };

package/dist/adapters/fetch/index.mjs

@@ -0,0 +1,9 @@
+export { R as RPCHandler } from '../../shared/server.CUE4Aija.mjs';
+import '@orpc/standard-server-fetch';
+import '../../shared/server.BBGuTxHE.mjs';
+import '@orpc/client';
+import '@orpc/shared';
+import '../../shared/server.Q6ZmnTgO.mjs';
+import '../../shared/server.V6zT5iYQ.mjs';
+import '@orpc/contract';
+import '@orpc/client/standard';

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

@@ -0,0 +1,20 @@
+import { FetchHandler } from '../fetch/index.mjs';
+export { FetchHandleResult, RPCHandler } from '../fetch/index.mjs';
+import { Value, MaybeOptionalOptions } from '@orpc/shared';
+import { Context as Context$1, MiddlewareHandler } from 'hono';
+import { C as Context } from '../../shared/server.CI7U5gRZ.mjs';
+import { S as StandardHandleOptions } from '../../shared/server.CHpDfeOK.mjs';
+import '@orpc/standard-server-fetch';
+import '../../shared/server.MnOqRlBp.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+type CreateMiddlewareOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: Value<T, [Context$1]>;
+} : {
+    context: Value<T, [Context$1]>;
+});
+declare function createMiddleware<T extends Context>(handler: FetchHandler<T>, ...[options]: MaybeOptionalOptions<CreateMiddlewareOptions<T>>): MiddlewareHandler;
+
+export { type CreateMiddlewareOptions, FetchHandler, createMiddleware };

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

@@ -0,0 +1,20 @@
+import { FetchHandler } from '../fetch/index.js';
+export { FetchHandleResult, RPCHandler } from '../fetch/index.js';
+import { Value, MaybeOptionalOptions } from '@orpc/shared';
+import { Context as Context$1, MiddlewareHandler } from 'hono';
+import { C as Context } from '../../shared/server.CI7U5gRZ.js';
+import { S as StandardHandleOptions } from '../../shared/server.DSZ2XY8G.js';
+import '@orpc/standard-server-fetch';
+import '../../shared/server.BqEaivV1.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+type CreateMiddlewareOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: Value<T, [Context$1]>;
+} : {
+    context: Value<T, [Context$1]>;
+});
+declare function createMiddleware<T extends Context>(handler: FetchHandler<T>, ...[options]: MaybeOptionalOptions<CreateMiddlewareOptions<T>>): MiddlewareHandler;
+
+export { type CreateMiddlewareOptions, FetchHandler, createMiddleware };

package/dist/{hono.js → adapters/hono/index.mjs}

@@ -1,12 +1,13 @@
-import {
-  RPCHandler
-} from "./chunk-WDY5PTME.js";
-import "./chunk-TV5DRAST.js";
-import "./chunk-MHVECKBC.js";
-import "./chunk-TXHKQO7N.js";
+export { R as RPCHandler } from '../../shared/server.CUE4Aija.mjs';
+import { value } from '@orpc/shared';
+import '@orpc/standard-server-fetch';
+import '../../shared/server.BBGuTxHE.mjs';
+import '@orpc/client';
+import '../../shared/server.Q6ZmnTgO.mjs';
+import '../../shared/server.V6zT5iYQ.mjs';
+import '@orpc/contract';
+import '@orpc/client/standard';
 
-// src/adapters/hono/middleware.ts
-import { value } from "@orpc/shared";
 function createMiddleware(handler, ...[options]) {
   return async (c, next) => {
     const bodyProps = /* @__PURE__ */ new Set(["arrayBuffer", "blob", "formData", "json", "text"]);
@@ -27,8 +28,5 @@ function createMiddleware(handler, ...[options]) {
     await next();
   };
 }
-export {
-  RPCHandler,
-  createMiddleware
-};
-//# sourceMappingURL=hono.js.map
+
+export { createMiddleware };

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

@@ -0,0 +1,27 @@
+import { FetchHandler } from '../fetch/index.mjs';
+export { FetchHandleResult, RPCHandler } from '../fetch/index.mjs';
+import { Value, MaybeOptionalOptions } from '@orpc/shared';
+import { NextRequest } from 'next/server';
+import { C as Context } from '../../shared/server.CI7U5gRZ.mjs';
+import { S as StandardHandleOptions } from '../../shared/server.CHpDfeOK.mjs';
+import '@orpc/standard-server-fetch';
+import '../../shared/server.MnOqRlBp.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+type ServeOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: Value<T, [NextRequest]>;
+} : {
+    context: Value<T, [NextRequest]>;
+});
+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>;
+}
+declare function serve<T extends Context>(handler: FetchHandler<T>, ...[options]: MaybeOptionalOptions<ServeOptions<T>>): ServeResult;
+
+export { FetchHandler, type ServeOptions, type ServeResult, serve };

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

@@ -0,0 +1,27 @@
+import { FetchHandler } from '../fetch/index.js';
+export { FetchHandleResult, RPCHandler } from '../fetch/index.js';
+import { Value, MaybeOptionalOptions } from '@orpc/shared';
+import { NextRequest } from 'next/server';
+import { C as Context } from '../../shared/server.CI7U5gRZ.js';
+import { S as StandardHandleOptions } from '../../shared/server.DSZ2XY8G.js';
+import '@orpc/standard-server-fetch';
+import '../../shared/server.BqEaivV1.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+type ServeOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: Value<T, [NextRequest]>;
+} : {
+    context: Value<T, [NextRequest]>;
+});
+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>;
+}
+declare function serve<T extends Context>(handler: FetchHandler<T>, ...[options]: MaybeOptionalOptions<ServeOptions<T>>): ServeResult;
+
+export { FetchHandler, type ServeOptions, type ServeResult, serve };

package/dist/{next.js → adapters/next/index.mjs}

@@ -1,12 +1,13 @@
-import {
-  RPCHandler
-} from "./chunk-WDY5PTME.js";
-import "./chunk-TV5DRAST.js";
-import "./chunk-MHVECKBC.js";
-import "./chunk-TXHKQO7N.js";
+export { R as RPCHandler } from '../../shared/server.CUE4Aija.mjs';
+import { value } from '@orpc/shared';
+import '@orpc/standard-server-fetch';
+import '../../shared/server.BBGuTxHE.mjs';
+import '@orpc/client';
+import '../../shared/server.Q6ZmnTgO.mjs';
+import '../../shared/server.V6zT5iYQ.mjs';
+import '@orpc/contract';
+import '@orpc/client/standard';
 
-// 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);
@@ -24,8 +25,5 @@ function serve(handler, ...[options]) {
     DELETE: main
   };
 }
-export {
-  RPCHandler,
-  serve
-};
-//# sourceMappingURL=next.js.map
+
+export { serve };

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

@@ -0,0 +1,35 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions } from '@orpc/standard-server-node';
+import { C as Context, R as Router } from '../../shared/server.CI7U5gRZ.mjs';
+import { S as StandardHandleOptions } from '../../shared/server.CHpDfeOK.mjs';
+import { R as RPCHandlerOptions } from '../../shared/server.MnOqRlBp.mjs';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+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;
+type NodeHttpHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface NodeHttpHandler<T extends Context> {
+    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: MaybeOptionalOptions<StandardHandleOptions<T> & SendStandardResponseOptions>): Promise<NodeHttpHandleResult>;
+}
+
+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, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T> & SendStandardResponseOptions>): Promise<NodeHttpHandleResult>;
+}
+
+export { type NodeHttpHandleResult, type NodeHttpHandler, type NodeHttpRequest, type NodeHttpResponse, RPCHandler };

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

@@ -0,0 +1,35 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions } from '@orpc/standard-server-node';
+import { C as Context, R as Router } from '../../shared/server.CI7U5gRZ.js';
+import { S as StandardHandleOptions } from '../../shared/server.DSZ2XY8G.js';
+import { R as RPCHandlerOptions } from '../../shared/server.BqEaivV1.js';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+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;
+type NodeHttpHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface NodeHttpHandler<T extends Context> {
+    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: MaybeOptionalOptions<StandardHandleOptions<T> & SendStandardResponseOptions>): Promise<NodeHttpHandleResult>;
+}
+
+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, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T> & SendStandardResponseOptions>): Promise<NodeHttpHandleResult>;
+}
+
+export { type NodeHttpHandleResult, type NodeHttpHandler, type NodeHttpRequest, type NodeHttpResponse, RPCHandler };

package/dist/adapters/node/index.mjs

@@ -0,0 +1,28 @@
+import { toStandardRequest, sendStandardResponse } from '@orpc/standard-server-node';
+import { R as RPCCodec, a as RPCMatcher, S as StandardHandler } from '../../shared/server.BBGuTxHE.mjs';
+import '@orpc/client';
+import '@orpc/shared';
+import '../../shared/server.Q6ZmnTgO.mjs';
+import '../../shared/server.V6zT5iYQ.mjs';
+import '@orpc/contract';
+import '@orpc/client/standard';
+
+class RPCHandler {
+  standardHandler;
+  constructor(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 standardRequest = toStandardRequest(req, res);
+    const result = await this.standardHandler.handle(standardRequest, options);
+    if (!result.matched) {
+      return { matched: false };
+    }
+    await sendStandardResponse(res, result.response, options);
+    return { matched: true };
+  }
+}
+
+export { RPCHandler };

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

@@ -0,0 +1,29 @@
+import { c as StandardCodec, e as StandardParams, b as StandardMatcher, f as StandardMatchResult } from '../../shared/server.CHpDfeOK.mjs';
+export { S as StandardHandleOptions, g as StandardHandleResult, h as StandardHandler, d as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, W as WellStandardHandleOptions } from '../../shared/server.CHpDfeOK.mjs';
+import { ORPCError } from '@orpc/client';
+import { StandardRequest, StandardResponse } from '@orpc/standard-server';
+import { A as AnyProcedure, a as AnyRouter } from '../../shared/server.CI7U5gRZ.mjs';
+import { RPCSerializer } from '@orpc/client/standard';
+export { R as RPCHandlerOptions } from '../../shared/server.MnOqRlBp.mjs';
+import { HTTPPath } from '@orpc/contract';
+import '@orpc/shared';
+
+interface StandardCodecOptions {
+    serializer?: RPCSerializer;
+}
+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;
+}
+
+declare class RPCMatcher implements StandardMatcher {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: string[]): void;
+    match(_method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+export { RPCCodec, RPCMatcher, StandardCodec, type StandardCodecOptions, StandardMatchResult, StandardMatcher, StandardParams };

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

@@ -0,0 +1,29 @@
+import { c as StandardCodec, e as StandardParams, b as StandardMatcher, f as StandardMatchResult } from '../../shared/server.DSZ2XY8G.js';
+export { S as StandardHandleOptions, g as StandardHandleResult, h as StandardHandler, d as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, W as WellStandardHandleOptions } from '../../shared/server.DSZ2XY8G.js';
+import { ORPCError } from '@orpc/client';
+import { StandardRequest, StandardResponse } from '@orpc/standard-server';
+import { A as AnyProcedure, a as AnyRouter } from '../../shared/server.CI7U5gRZ.js';
+import { RPCSerializer } from '@orpc/client/standard';
+export { R as RPCHandlerOptions } from '../../shared/server.BqEaivV1.js';
+import { HTTPPath } from '@orpc/contract';
+import '@orpc/shared';
+
+interface StandardCodecOptions {
+    serializer?: RPCSerializer;
+}
+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;
+}
+
+declare class RPCMatcher implements StandardMatcher {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: string[]): void;
+    match(_method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+export { RPCCodec, RPCMatcher, StandardCodec, type StandardCodecOptions, StandardMatchResult, StandardMatcher, StandardParams };

package/dist/adapters/standard/index.mjs

@@ -0,0 +1,7 @@
+export { R as RPCCodec, a as RPCMatcher, S as StandardHandler } from '../../shared/server.BBGuTxHE.mjs';
+import '@orpc/client';
+import '@orpc/shared';
+import '../../shared/server.Q6ZmnTgO.mjs';
+import '../../shared/server.V6zT5iYQ.mjs';
+import '@orpc/contract';
+import '@orpc/client/standard';