@orpc/server 0.51.0 → 0.53.0

package/dist/shared/{server.DnR6v9pj.mjs → server.DFuJLDuo.mjs}

@@ -1,14 +1,28 @@
-import { ORPCError, toORPCError } from '@orpc/client';
+import { toHttpPath, StandardRPCJsonSerializer, StandardRPCSerializer } from '@orpc/client/standard';
 import { toArray, intercept, parseEmptyableJSON } from '@orpc/shared';
-import { c as createProcedureClient, t as traverseContractProcedures, a as toHttpPath, i as isProcedure, u as unlazy, g as getRouter, b as createContractedProcedure } from './server.BtxZnWJ9.mjs';
+import '@orpc/standard-server/batch';
+import { ORPCError, toORPCError } from '@orpc/client';
+import { S as StrictGetMethodPlugin } from './server.BW-nUGgA.mjs';
+import { c as createProcedureClient, t as traverseContractProcedures, i as isProcedure, u as unlazy, g as getRouter, a as createContractedProcedure } from './server.C37gDhSZ.mjs';
+
+class CompositeStandardHandlerPlugin {
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = [...plugins].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      plugin.init?.(options);
+    }
+  }
+}
 
 class StandardHandler {
   constructor(router, matcher, codec, options) {
     this.matcher = matcher;
     this.codec = codec;
-    for (const plugin of toArray(options.plugins)) {
-      plugin.init?.(options);
-    }
+    const plugins = new CompositeStandardHandlerPlugin(options.plugins);
+    plugins.init(options);
     this.interceptors = toArray(options.interceptors);
     this.clientInterceptors = toArray(options.clientInterceptors);
     this.rootInterceptors = toArray(options.rootInterceptors);
@@ -17,23 +31,24 @@ class StandardHandler {
   interceptors;
   clientInterceptors;
   rootInterceptors;
-  handle(request, options) {
+  async handle(request, options) {
+    const prefix = options.prefix?.replace(/\/$/, "") || void 0;
+    if (prefix && !request.url.pathname.startsWith(`${prefix}/`) && request.url.pathname !== prefix) {
+      return { matched: false, response: void 0 };
+    }
     return intercept(
       this.rootInterceptors,
-      { ...options, request },
+      { ...options, request, prefix },
       async (interceptorOptions) => {
         let isDecoding = false;
         try {
           return await intercept(
             this.interceptors,
             interceptorOptions,
-            async ({ request: request2, context, prefix }) => {
+            async ({ request: request2, context, prefix: prefix2 }) => {
               const method = request2.method;
               const url = request2.url;
-              if (prefix && !url.pathname.startsWith(prefix)) {
-                return { matched: false, response: void 0 };
-              }
-              const pathname = prefix ? url.pathname.replace(prefix, "") : url.pathname;
+              const pathname = prefix2 ? url.pathname.replace(prefix2, "") : url.pathname;
               const match = await this.matcher.match(method, `/${pathname.replace(/^\/|\/$/g, "")}`);
               if (!match) {
                 return { matched: false, response: void 0 };
@@ -157,4 +172,19 @@ class StandardRPCMatcher {
   }
 }
 
-export { StandardHandler as S, StandardRPCCodec as a, StandardRPCMatcher as b };
+class StandardRPCHandler extends StandardHandler {
+  constructor(router, options) {
+    options.plugins ??= [];
+    const strictGetMethodPluginEnabled = options.strictGetMethodPluginEnabled ?? true;
+    if (strictGetMethodPluginEnabled) {
+      options.plugins.push(new StrictGetMethodPlugin());
+    }
+    const jsonSerializer = new StandardRPCJsonSerializer(options);
+    const serializer = new StandardRPCSerializer(jsonSerializer);
+    const matcher = new StandardRPCMatcher();
+    const codec = new StandardRPCCodec(serializer);
+    super(router, matcher, codec, options);
+  }
+}
+
+export { CompositeStandardHandlerPlugin as C, StandardHandler as S, StandardRPCCodec as a, StandardRPCHandler as b, StandardRPCMatcher as c };

package/dist/shared/{server.MZvbGc3n.d.mts → server.DLt5njUb.d.mts}

@@ -1,8 +1,8 @@
-import { ORPCErrorCode, ORPCErrorOptions, ORPCError, ClientContext, Client } from '@orpc/client';
+import { ORPCErrorCode, ORPCErrorOptions, ORPCError, HTTPPath, ClientContext, Client } from '@orpc/client';
 import { MaybeOptionalOptions, Promisable, Interceptor, Value } from '@orpc/shared';
-import { ErrorMap, ErrorMapItem, InferSchemaInput, HTTPPath, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@orpc/contract';
+import { ErrorMap, ErrorMapItem, InferSchemaInput, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@orpc/contract';
 
-type Context = Record<string, any>;
+type Context = Record<PropertyKey, any>;
 type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
 type MergedCurrentContext<T extends Context, U extends Context> = Omit<T, keyof U> & U;
 declare function mergeCurrentContext<T extends Context, U extends Context>(context: T, other: U): MergedCurrentContext<T, U>;
@@ -97,9 +97,9 @@ interface MapInputMiddleware<TInput, TMappedInput> {
 declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
 
 type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
-interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TInputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> {
     context: TInitialContext;
-    input: InferSchemaInput<TInputSchema>;
+    input: unknown;
     errors: ORPCErrorConstructorMap<TErrorMap>;
     path: readonly string[];
     procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
@@ -109,18 +109,18 @@ interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TIn
 /**
  * Options for creating a procedure caller with comprehensive type safety
  */
-type CreateProcedureClientOptions<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
+type CreateProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
     /**
      * This is helpful for logging and analytics.
      */
     path?: readonly string[];
-    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TInputSchema, TErrorMap, TMeta>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>[];
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap, TMeta>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>[];
 } & (Record<never, never> extends TInitialContext ? {
     context?: Value<TInitialContext, [clientContext: TClientContext]>;
 } : {
     context: Value<TInitialContext, [clientContext: TClientContext]>;
 });
-declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
 
 type Router<T extends AnyContractRouter, TInitialContext extends Context> = T extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, UErrorMap, UMeta> : {
     [K in keyof T]: T[K] extends AnyContractRouter ? Lazyable<Router<T[K], TInitialContext>> : never;

package/dist/shared/{server.MZvbGc3n.d.ts → server.DLt5njUb.d.ts}

@@ -1,8 +1,8 @@
-import { ORPCErrorCode, ORPCErrorOptions, ORPCError, ClientContext, Client } from '@orpc/client';
+import { ORPCErrorCode, ORPCErrorOptions, ORPCError, HTTPPath, ClientContext, Client } from '@orpc/client';
 import { MaybeOptionalOptions, Promisable, Interceptor, Value } from '@orpc/shared';
-import { ErrorMap, ErrorMapItem, InferSchemaInput, HTTPPath, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@orpc/contract';
+import { ErrorMap, ErrorMapItem, InferSchemaInput, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@orpc/contract';
 
-type Context = Record<string, any>;
+type Context = Record<PropertyKey, any>;
 type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
 type MergedCurrentContext<T extends Context, U extends Context> = Omit<T, keyof U> & U;
 declare function mergeCurrentContext<T extends Context, U extends Context>(context: T, other: U): MergedCurrentContext<T, U>;
@@ -97,9 +97,9 @@ interface MapInputMiddleware<TInput, TMappedInput> {
 declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
 
 type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
-interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TInputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> {
     context: TInitialContext;
-    input: InferSchemaInput<TInputSchema>;
+    input: unknown;
     errors: ORPCErrorConstructorMap<TErrorMap>;
     path: readonly string[];
     procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
@@ -109,18 +109,18 @@ interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TIn
 /**
  * Options for creating a procedure caller with comprehensive type safety
  */
-type CreateProcedureClientOptions<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
+type CreateProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
     /**
      * This is helpful for logging and analytics.
      */
     path?: readonly string[];
-    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TInputSchema, TErrorMap, TMeta>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>[];
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap, TMeta>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>[];
 } & (Record<never, never> extends TInitialContext ? {
     context?: Value<TInitialContext, [clientContext: TClientContext]>;
 } : {
     context: Value<TInitialContext, [clientContext: TClientContext]>;
 });
-declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
 
 type Router<T extends AnyContractRouter, TInitialContext extends Context> = T extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, UErrorMap, UMeta> : {
     [K in keyof T]: T[K] extends AnyContractRouter ? Lazyable<Router<T[K], TInitialContext>> : never;

package/dist/shared/{server.DJqfB27m.d.mts → server.DOYDVeMX.d.mts}

@@ -1,8 +1,8 @@
-import { HTTPPath, AnySchema, Meta, InferSchemaOutput, ErrorFromErrorMap } from '@orpc/contract';
-import { Interceptor } from '@orpc/shared';
+import { HTTPPath, ORPCError } from '@orpc/client';
+import { Meta, InferSchemaOutput, AnySchema, ErrorFromErrorMap } from '@orpc/contract';
+import { Interceptor, ThrowableError } from '@orpc/shared';
 import { StandardResponse, StandardLazyRequest } from '@orpc/standard-server';
-import { a as AnyRouter, A as AnyProcedure, C as Context, P as ProcedureClientInterceptorOptions, R as Router } from './server.MZvbGc3n.mjs';
-import { ORPCError } from '@orpc/client';
+import { a as AnyRouter, A as AnyProcedure, C as Context, P as ProcedureClientInterceptorOptions, R as Router } from './server.DLt5njUb.mjs';
 
 type StandardParams = Record<string, string>;
 type StandardMatchResult = {
@@ -20,6 +20,16 @@ interface StandardCodec {
     decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
 }
 
+interface StandardHandlerPlugin<TContext extends Context> {
+    order?: number;
+    init?(options: StandardHandlerOptions<TContext>): void;
+}
+declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends StandardHandlerPlugin<T>> implements StandardHandlerPlugin<T> {
+    protected readonly plugins: TPlugin[];
+    constructor(plugins?: readonly TPlugin[]);
+    init(options: StandardHandlerOptions<T>): void;
+}
+
 interface StandardHandleOptions<T extends Context> {
     prefix?: HTTPPath;
     context: T;
@@ -31,9 +41,6 @@ type StandardHandleResult = {
     matched: false;
     response: undefined;
 };
-interface StandardHandlerPlugin<TContext extends Context> {
-    init?(options: StandardHandlerOptions<TContext>): void;
-}
 interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
     request: StandardLazyRequest;
 }
@@ -42,16 +49,16 @@ interface StandardHandlerOptions<TContext extends Context> {
     /**
      * Interceptors at the request level, helpful when you want catch errors
      */
-    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, ThrowableError>[];
     /**
      * Interceptors at the root level, helpful when you want override the request/response
      */
-    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, ThrowableError>[];
     /**
      *
      * Interceptors for procedure client.
      */
-    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, AnySchema, Record<never, never>, Meta>, InferSchemaOutput<AnySchema>, ErrorFromErrorMap<Record<never, never>>>[];
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, InferSchemaOutput<AnySchema>, ErrorFromErrorMap<Record<never, never>>>[];
 }
 declare class StandardHandler<T extends Context> {
     private readonly matcher;
@@ -63,4 +70,4 @@ declare class StandardHandler<T extends Context> {
     handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
 }
 
-export { type StandardHandleOptions as S, type StandardHandlerOptions as a, type StandardHandlerInterceptorOptions as b, type StandardHandlerPlugin as c, type StandardCodec as d, type StandardParams as e, type StandardMatcher as f, type StandardMatchResult as g, type StandardHandleResult as h, StandardHandler as i };
+export { CompositeStandardHandlerPlugin as C, type StandardHandleOptions as S, type StandardHandlerOptions as a, StandardHandler as b, type StandardCodec as c, type StandardParams as d, type StandardMatcher as e, type StandardMatchResult as f, type StandardHandleResult as g, type StandardHandlerInterceptorOptions as h, type StandardHandlerPlugin as i };

package/dist/shared/{server.BG5ftPWa.d.ts → server._2UufoXA.d.ts}

@@ -1,5 +1,5 @@
-import { C as Context } from './server.MZvbGc3n.js';
-import { S as StandardHandleOptions } from './server.23VRZIfj.js';
+import { C as Context } from './server.DLt5njUb.js';
+import { S as StandardHandleOptions } from './server.DFFT_EZo.js';
 
 type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: T;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.51.0",
+  "version": "0.53.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -58,12 +58,12 @@
     "next": ">=14.0.0"
   },
   "dependencies": {
-    "@orpc/contract": "0.51.0",
-    "@orpc/client": "0.51.0",
-    "@orpc/standard-server": "0.51.0",
-    "@orpc/standard-server-fetch": "0.51.0",
-    "@orpc/standard-server-node": "0.51.0",
-    "@orpc/shared": "0.51.0"
+    "@orpc/client": "0.53.0",
+    "@orpc/shared": "0.53.0",
+    "@orpc/contract": "0.53.0",
+    "@orpc/standard-server-fetch": "0.53.0",
+    "@orpc/standard-server": "0.53.0",
+    "@orpc/standard-server-node": "0.53.0"
   },
   "devDependencies": {
     "supertest": "^7.0.0"

package/dist/shared/server.CIbpOMZX.d.mts

@@ -1,8 +0,0 @@
-import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
-import { C as Context } from './server.MZvbGc3n.mjs';
-import { a as StandardHandlerOptions } from './server.DJqfB27m.mjs';
-
-interface StandardRPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, StandardRPCJsonSerializerOptions {
-}
-
-export type { StandardRPCHandlerOptions as S };

package/dist/shared/server.DCcCuA52.d.ts

@@ -1,8 +0,0 @@
-import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
-import { C as Context } from './server.MZvbGc3n.js';
-import { a as StandardHandlerOptions } from './server.23VRZIfj.js';
-
-interface StandardRPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, StandardRPCJsonSerializerOptions {
-}
-
-export type { StandardRPCHandlerOptions as S };