@orpc/server 2.0.0-beta.49 → 2.0.0-beta.50

package/dist/adapters/node/handler.js

@@ -1,20 +1,20 @@
-import { resolveMaybeOptionalOptions } from '@orpc/shared';
-import { sendStandardResponse, toStandardLazyRequest } from '@standard-server/node';
-import { resolveFriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-export class NodeHttpHandler {
-    standardHandler;
-    sendStandardResponseOptions;
-    constructor(standardHandler, options = {}) {
-        this.standardHandler = standardHandler;
-        this.sendStandardResponseOptions = options.sendStandardResponse;
-    }
-    async handle(request, response, ...rest) {
-        const standardRequest = toStandardLazyRequest(request, response);
-        const result = await this.standardHandler.handle(standardRequest, resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)));
-        if (!result.matched) {
-            return result;
-        }
-        await sendStandardResponse(response, result.response, this.sendStandardResponseOptions);
-        return result;
-    }
-}
+import { resolveFriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+import { resolveMaybeOptionalOptions } from "@orpc/shared";
+import { sendStandardResponse, toStandardLazyRequest } from "@standard-server/node";
+// src/adapters/node/handler.ts
+var NodeHttpHandler = class {
+	standardHandler;
+	sendStandardResponseOptions;
+	constructor(standardHandler, options = {}) {
+		this.standardHandler = standardHandler;
+		this.sendStandardResponseOptions = options.sendStandardResponse;
+	}
+	async handle(request, response, ...rest) {
+		const standardRequest = toStandardLazyRequest(request, response);
+		const result = await this.standardHandler.handle(standardRequest, resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)));
+		if (!result.matched) return result;
+		await sendStandardResponse(response, result.response, this.sendStandardResponseOptions);
+		return result;
+	}
+};
+export { NodeHttpHandler };

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

@@ -1,7 +1,4 @@
-export { 
-/**
- * @deprecated Use `RequestLimitHandlerPlugin` from `@orpc/server/plugins` instead.
- */
-RequestLimitHandlerPlugin as BodyLimitPlugin, } from '../../plugins/request-limit.ts';
-export * from './handler.ts';
-export * from './rpc-handler.ts';
+import { RequestLimitHandlerPlugin } from "../../plugins/request-limit.js";
+import { NodeHttpHandler, NodeHttpHandlerHandleResult, NodeHttpHandlerOptions } from "./handler.js";
+import { RPCHandler, RPCHandlerOptions } from "./rpc-handler.js";
+export { RequestLimitHandlerPlugin as BodyLimitPlugin, NodeHttpHandler, NodeHttpHandlerHandleResult, NodeHttpHandlerOptions, RPCHandler, RPCHandlerOptions };

package/dist/adapters/node/index.js

@@ -1,7 +1,3 @@
-export { 
-/**
- * @deprecated Use `RequestLimitHandlerPlugin` from `@orpc/server/plugins` instead.
- */
-RequestLimitHandlerPlugin as BodyLimitPlugin, } from '../../plugins/request-limit.js';
-export * from './handler.js';
-export * from './rpc-handler.js';
+export { RequestLimitHandlerPlugin as BodyLimitPlugin } from "../../plugins/request-limit.js";
+export { NodeHttpHandler } from "./handler.js";
+export { RPCHandler } from "./rpc-handler.js";

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

@@ -1,10 +1,10 @@
-import type { Context } from '../../context.ts';
-import type { Router } from '../../router.ts';
-import type { RPCHandlerCodecOptions, StandardHandlerOptions } from '../standard/index.ts';
-import type { NodeHttpHandlerOptions } from './handler.ts';
-import { NodeHttpHandler } from './handler.ts';
-export interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
-}
+import { Context } from "../../context.js";
+import { StandardHandlerOptions } from "../standard/handler.js";
+import { Router } from "../../router.js";
+import { RPCHandlerCodecOptions } from "../standard/rpc-handler-codec.js";
+import "../standard/index.js";
+import { NodeHttpHandler, NodeHttpHandlerOptions } from "./handler.js";
+export interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {}
 /**
  * Serves an oRPC router over the RPC protocol using Node.js built-in
  * HTTP request/response objects.
@@ -12,5 +12,5 @@ export interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOpt
  * @see {@link https://orpc.dev/docs/adapters/node-http | Node HTTP Adapter}
  */
 export declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
+  constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}

package/dist/adapters/node/rpc-handler.js

@@ -1,15 +1,18 @@
-import { RPCHandlerCodec, StandardHandler } from '../standard/index.js';
-import { NodeHttpHandler } from './handler.js';
+import { RPCHandlerCodec } from "../standard/rpc-handler-codec.js";
+import { StandardHandler } from "../standard/handler.js";
+import { NodeHttpHandler } from "./handler.js";
+// src/adapters/node/rpc-handler.ts
 /**
- * Serves an oRPC router over the RPC protocol using Node.js built-in
- * HTTP request/response objects.
- *
- * @see {@link https://orpc.dev/docs/adapters/node-http | Node HTTP Adapter}
- */
-export class RPCHandler extends NodeHttpHandler {
-    constructor(router, options = {}) {
-        const codec = new RPCHandlerCodec(router, options);
-        const handler = new StandardHandler(codec, options);
-        super(handler, options);
-    }
-}
+* Serves an oRPC router over the RPC protocol using Node.js built-in
+* HTTP request/response objects.
+*
+* @see {@link https://orpc.dev/docs/adapters/node-http | Node HTTP Adapter}
+*/
+var RPCHandler = class extends NodeHttpHandler {
+	constructor(router, options = {}) {
+		const codec = new RPCHandlerCodec(router, options);
+		const handler = new StandardHandler(codec, options);
+		super(handler, options);
+	}
+};
+export { RPCHandler };

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

@@ -1,16 +1,16 @@
-import type { AnyORPCError } from '@orpc/client';
-import type { Promisable } from '@orpc/shared';
-import type { StandardLazyRequest, StandardResponse } from '@standard-server/core';
-import type { Context } from '../../context.ts';
-import type { AnyProcedure } from '../../procedure.ts';
-import type { ResolvedStandardHandlerHandleOptions } from './handler.ts';
+import { Context } from "../../context.js";
+import { AnyProcedure } from "../../procedure.js";
+import { ResolvedStandardHandlerHandleOptions } from "./handler.js";
+import { Promisable } from "@orpc/shared";
+import { AnyORPCError } from "@orpc/client";
+import { StandardLazyRequest, StandardResponse } from "@standard-server/core";
 export interface StandardHandlerCodecResolvedProcedure {
-    path: string[];
-    procedure: AnyProcedure;
-    decodeInput: () => Promise<unknown>;
+  path: string[];
+  procedure: AnyProcedure;
+  decodeInput: () => Promise<unknown>;
 }
 export interface StandardHandlerCodec<T extends Context> {
-    resolveProcedure(request: StandardLazyRequest, options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardHandlerCodecResolvedProcedure | undefined>;
-    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-    encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-}
+  resolveProcedure(request: StandardLazyRequest, options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardHandlerCodecResolvedProcedure | undefined>;
+  encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+  encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+}

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

@@ -1,68 +1,68 @@
-import type { ErrorMap, Schema } from '@orpc/contract';
-import type { Interceptor, Promisable, Value } from '@orpc/shared';
-import type { StandardLazyRequest, StandardResponse } from '@standard-server/core';
-import type { Context } from '../../context.ts';
-import type { ProcedureClientInterceptor } from '../../procedure-client.ts';
-import type { StandardHandlerCodec, StandardHandlerCodecResolvedProcedure } from './codec.ts';
-import type { StandardHandlerPlugin } from './plugin.ts';
+import { Context } from "../../context.js";
+import { ProcedureClientInterceptor } from "../../procedure-client.js";
+import { StandardHandlerCodec, StandardHandlerCodecResolvedProcedure } from "./codec.js";
+import { StandardHandlerPlugin } from "./plugin.js";
+import { ErrorMap, Schema } from "@orpc/contract";
+import { Interceptor, Promisable, Value } from "@orpc/shared";
+import { StandardLazyRequest, StandardResponse } from "@standard-server/core";
 export interface StandardHandlerHandleOptions<T extends Context> {
-    prefix?: `/${string}` | undefined;
-    /**
-     * The initial context, or a function (sync or async) that receives the request and returns it.
-     * The function only runs once the request passes the prefix check.
-     */
-    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+  prefix?: `/${string}` | undefined;
+  /**
+   * The initial context, or a function (sync or async) that receives the request and returns it.
+   * The function only runs once the request passes the prefix check.
+   */
+  context: Value<Promisable<T>, [request: StandardLazyRequest]>;
 }
 /**
  * `StandardHandlerHandleOptions` after the context has been resolved,
  * this is what interceptors and codecs receive.
  */
-export interface ResolvedStandardHandlerHandleOptions<T extends Context> extends Omit<StandardHandlerHandleOptions<T>, 'context'> {
-    context: T;
+export interface ResolvedStandardHandlerHandleOptions<T extends Context> extends Omit<StandardHandlerHandleOptions<T>, "context"> {
+  context: T;
 }
 export type StandardHandlerHandleResult = {
-    matched: true;
-    response: StandardResponse;
+  matched: true;
+  response: StandardResponse;
 } | {
-    matched: false;
-    response?: undefined;
+  matched: false;
+  response?: undefined;
 };
 export interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, ResolvedStandardHandlerHandleOptions<T> {
-    request: StandardLazyRequest;
+  request: StandardLazyRequest;
 }
 export type StandardHandlerInterceptor<T extends Context> = Interceptor<StandardHandlerInterceptorOptions<T>, Promise<StandardResponse>>;
 export interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends ResolvedStandardHandlerHandleOptions<T> {
-    request: StandardLazyRequest;
+  request: StandardLazyRequest;
 }
 export type StandardHandlerRoutingInterceptor<T extends Context> = Interceptor<StandardHandlerRoutingInterceptorOptions<T>, Promise<StandardHandlerHandleResult>>;
 export interface StandardHandlerOptions<TContext extends Context> {
-    /**
-     * Fired on every request before routing, useful when you want
-     * to intercept all requests regardless of whether they match a procedure or not.
-     *
-     * @examples
-     * - batch plugins - separate one request into multiple and call multiple next
-     * - openapi spec plugin - to intercept a request and early response
-     */
-    routingInterceptors?: StandardHandlerRoutingInterceptor<TContext>[] | undefined;
-    /**
-     * interceptor run after routing and before error handler,
-     * useful for error handling, logging, metrics, etc.
-     */
-    interceptors?: StandardHandlerInterceptor<TContext>[] | undefined;
-    /**
-     *
-     * ClientInterceptor equivalent with createRouterClient.interceptors / createProcedure.interceptors
-     * useful for error handling, logging, metrics, etc. (not counting encoding/decoding)
-     */
-    clientInterceptors?: ProcedureClientInterceptor<TContext, Schema<unknown>, ErrorMap>[] | undefined;
-    plugins?: StandardHandlerPlugin<TContext>[] | undefined;
+  /**
+   * Fired on every request before routing, useful when you want
+   * to intercept all requests regardless of whether they match a procedure or not.
+   *
+   * @examples
+   * - batch plugins - separate one request into multiple and call multiple next
+   * - openapi spec plugin - to intercept a request and early response
+   */
+  routingInterceptors?: StandardHandlerRoutingInterceptor<TContext>[] | undefined;
+  /**
+   * interceptor run after routing and before error handler,
+   * useful for error handling, logging, metrics, etc.
+   */
+  interceptors?: StandardHandlerInterceptor<TContext>[] | undefined;
+  /**
+   *
+   * ClientInterceptor equivalent with createRouterClient.interceptors / createProcedure.interceptors
+   * useful for error handling, logging, metrics, etc. (not counting encoding/decoding)
+   */
+  clientInterceptors?: ProcedureClientInterceptor<TContext, Schema<unknown>, ErrorMap>[] | undefined;
+  plugins?: StandardHandlerPlugin<TContext>[] | undefined;
 }
 export declare class StandardHandler<T extends Context> {
-    private readonly codec;
-    private readonly routingInterceptors;
-    private readonly interceptors;
-    private readonly clientInterceptors;
-    constructor(codec: StandardHandlerCodec<T>, options: StandardHandlerOptions<T>);
-    handle(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
-}
+  private readonly codec;
+  private readonly routingInterceptors;
+  private readonly interceptors;
+  private readonly clientInterceptors;
+  constructor(codec: StandardHandlerCodec<T>, options: StandardHandlerOptions<T>);
+  handle(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
+}