@orpc/server 0.0.0-next.1431467 → 0.0.0-next.14dd190

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (68) hide show
  1. package/README.md +29 -21
  2. package/dist/adapters/aws-lambda/index.d.mts +46 -0
  3. package/dist/adapters/aws-lambda/index.d.ts +46 -0
  4. package/dist/adapters/aws-lambda/index.mjs +41 -0
  5. package/dist/adapters/bun-ws/index.d.mts +36 -0
  6. package/dist/adapters/bun-ws/index.d.ts +36 -0
  7. package/dist/adapters/bun-ws/index.mjs +47 -0
  8. package/dist/adapters/crossws/index.d.mts +33 -0
  9. package/dist/adapters/crossws/index.d.ts +33 -0
  10. package/dist/adapters/crossws/index.mjs +47 -0
  11. package/dist/adapters/fetch/index.d.mts +63 -10
  12. package/dist/adapters/fetch/index.d.ts +63 -10
  13. package/dist/adapters/fetch/index.mjs +109 -8
  14. package/dist/adapters/message-port/index.d.mts +31 -0
  15. package/dist/adapters/message-port/index.d.ts +31 -0
  16. package/dist/adapters/message-port/index.mjs +41 -0
  17. package/dist/adapters/node/index.d.mts +65 -21
  18. package/dist/adapters/node/index.d.ts +65 -21
  19. package/dist/adapters/node/index.mjs +87 -23
  20. package/dist/adapters/standard/index.d.mts +11 -15
  21. package/dist/adapters/standard/index.d.ts +11 -15
  22. package/dist/adapters/standard/index.mjs +5 -3
  23. package/dist/adapters/standard-peer/index.d.mts +14 -0
  24. package/dist/adapters/standard-peer/index.d.ts +14 -0
  25. package/dist/adapters/standard-peer/index.mjs +7 -0
  26. package/dist/adapters/websocket/index.d.mts +54 -0
  27. package/dist/adapters/websocket/index.d.ts +54 -0
  28. package/dist/adapters/websocket/index.mjs +69 -0
  29. package/dist/adapters/ws/index.d.mts +31 -0
  30. package/dist/adapters/ws/index.d.ts +31 -0
  31. package/dist/adapters/ws/index.mjs +39 -0
  32. package/dist/hibernation/index.d.mts +44 -0
  33. package/dist/hibernation/index.d.ts +44 -0
  34. package/dist/hibernation/index.mjs +65 -0
  35. package/dist/index.d.mts +679 -131
  36. package/dist/index.d.ts +679 -131
  37. package/dist/index.mjs +208 -52
  38. package/dist/plugins/index.d.mts +144 -19
  39. package/dist/plugins/index.d.ts +144 -19
  40. package/dist/plugins/index.mjs +173 -17
  41. package/dist/shared/server.BW-nUGgA.mjs +36 -0
  42. package/dist/shared/server.C6Q5sqYw.mjs +20 -0
  43. package/dist/shared/server.CC8z0B3U.d.mts +32 -0
  44. package/dist/shared/{server.DKrKGnk2.mjs → server.CIL9uKTN.mjs} +74 -41
  45. package/dist/shared/server.CNZgPgce.d.ts +12 -0
  46. package/dist/shared/server.Cu-7se50.d.mts +12 -0
  47. package/dist/shared/server.Cwq7K86l.d.mts +42 -0
  48. package/dist/shared/server.DHgXKx3q.d.mts +74 -0
  49. package/dist/shared/server.DOwaI1le.d.ts +32 -0
  50. package/dist/shared/server.DVBSOxWU.d.ts +74 -0
  51. package/dist/shared/server.DZ5BIITo.mjs +9 -0
  52. package/dist/shared/{server.V6zT5iYQ.mjs → server.NeumLVdS.mjs} +172 -181
  53. package/dist/shared/server.a_VzWVCm.d.ts +42 -0
  54. package/dist/shared/server.wMv480px.d.mts +192 -0
  55. package/dist/shared/server.wMv480px.d.ts +192 -0
  56. package/package.json +64 -20
  57. package/dist/adapters/hono/index.d.mts +0 -19
  58. package/dist/adapters/hono/index.d.ts +0 -19
  59. package/dist/adapters/hono/index.mjs +0 -32
  60. package/dist/adapters/next/index.d.mts +0 -26
  61. package/dist/adapters/next/index.d.ts +0 -26
  62. package/dist/adapters/next/index.mjs +0 -29
  63. package/dist/shared/server.BHIDiY4a.mjs +0 -28
  64. package/dist/shared/server.CtBp-i4f.d.mts +0 -77
  65. package/dist/shared/server.Drm1Lma3.d.ts +0 -77
  66. package/dist/shared/server.Q6ZmnTgO.mjs +0 -12
  67. package/dist/shared/server.ptXwNGQr.d.mts +0 -158
  68. package/dist/shared/server.ptXwNGQr.d.ts +0 -158
@@ -1,51 +1,69 @@
1
+ import { toHttpPath, StandardRPCJsonSerializer, StandardRPCSerializer } from '@orpc/client/standard';
1
2
  import { ORPCError, toORPCError } from '@orpc/client';
2
- import { intercept, trim, parseEmptyableJSON } from '@orpc/shared';
3
- import { C as CompositePlugin } from './server.Q6ZmnTgO.mjs';
4
- import { c as createProcedureClient, e as eachContractProcedure, a as convertPathToHttpPath, i as isProcedure, u as unlazy, g as getRouterChild, b as createContractedProcedure } from './server.V6zT5iYQ.mjs';
3
+ import { toArray, intercept, parseEmptyableJSON, NullProtoObj, value } from '@orpc/shared';
4
+ import { flattenHeader } from '@orpc/standard-server';
5
+ import { c as createProcedureClient, t as traverseContractProcedures, i as isProcedure, u as unlazy, g as getRouter, a as createContractedProcedure } from './server.NeumLVdS.mjs';
6
+
7
+ class CompositeStandardHandlerPlugin {
8
+ plugins;
9
+ constructor(plugins = []) {
10
+ this.plugins = [...plugins].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
11
+ }
12
+ init(options, router) {
13
+ for (const plugin of this.plugins) {
14
+ plugin.init?.(options, router);
15
+ }
16
+ }
17
+ }
5
18
 
6
19
  class StandardHandler {
7
20
  constructor(router, matcher, codec, options) {
8
21
  this.matcher = matcher;
9
22
  this.codec = codec;
10
- this.options = options;
11
- this.plugin = new CompositePlugin(options.plugins);
12
- this.plugin.init(this.options);
23
+ const plugins = new CompositeStandardHandlerPlugin(options.plugins);
24
+ plugins.init(options, router);
25
+ this.interceptors = toArray(options.interceptors);
26
+ this.clientInterceptors = toArray(options.clientInterceptors);
27
+ this.rootInterceptors = toArray(options.rootInterceptors);
13
28
  this.matcher.init(router);
14
29
  }
15
- plugin;
16
- handle(request, ...[options]) {
30
+ interceptors;
31
+ clientInterceptors;
32
+ rootInterceptors;
33
+ async handle(request, options) {
34
+ const prefix = options.prefix?.replace(/\/$/, "") || void 0;
35
+ if (prefix && !request.url.pathname.startsWith(`${prefix}/`) && request.url.pathname !== prefix) {
36
+ return { matched: false, response: void 0 };
37
+ }
17
38
  return intercept(
18
- this.options.rootInterceptors ?? [],
19
- {
20
- request,
21
- ...options,
22
- context: options?.context ?? {}
23
- // context is optional only when all fields are optional so we can safely force it to have a context
24
- },
39
+ this.rootInterceptors,
40
+ { ...options, request, prefix },
25
41
  async (interceptorOptions) => {
26
42
  let isDecoding = false;
27
43
  try {
28
44
  return await intercept(
29
- this.options.interceptors ?? [],
45
+ this.interceptors,
30
46
  interceptorOptions,
31
- async (interceptorOptions2) => {
32
- const method = interceptorOptions2.request.method;
33
- const url = interceptorOptions2.request.url;
34
- const pathname = `/${trim(url.pathname.replace(interceptorOptions2.prefix ?? "", ""), "/")}`;
35
- const match = await this.matcher.match(method, pathname);
47
+ async ({ request: request2, context, prefix: prefix2 }) => {
48
+ const method = request2.method;
49
+ const url = request2.url;
50
+ const pathname = prefix2 ? url.pathname.replace(prefix2, "") : url.pathname;
51
+ const match = await this.matcher.match(method, `/${pathname.replace(/^\/|\/$/g, "")}`);
36
52
  if (!match) {
37
53
  return { matched: false, response: void 0 };
38
54
  }
39
55
  const client = createProcedureClient(match.procedure, {
40
- context: interceptorOptions2.context,
56
+ context,
41
57
  path: match.path,
42
- interceptors: this.options.clientInterceptors
58
+ interceptors: this.clientInterceptors
43
59
  });
44
60
  isDecoding = true;
45
- const input = await this.codec.decode(request, match.params, match.procedure);
61
+ const input = await this.codec.decode(request2, match.params, match.procedure);
46
62
  isDecoding = false;
47
- const lastEventId = Array.isArray(request.headers["last-event-id"]) ? request.headers["last-event-id"].at(-1) : request.headers["last-event-id"];
48
- const output = await client(input, { signal: request.signal, lastEventId });
63
+ const output = await client(input, {
64
+ signal: request2.signal,
65
+ lastEventId: flattenHeader(request2.headers["last-event-id"])
66
+ });
49
67
  const response = this.codec.encode(output, match.procedure);
50
68
  return {
51
69
  matched: true,
@@ -54,7 +72,7 @@ class StandardHandler {
54
72
  }
55
73
  );
56
74
  } catch (e) {
57
- const error = isDecoding ? new ORPCError("BAD_REQUEST", {
75
+ const error = isDecoding && !(e instanceof ORPCError) ? new ORPCError("BAD_REQUEST", {
58
76
  message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
59
77
  cause: e
60
78
  }) : toORPCError(e);
@@ -69,7 +87,7 @@ class StandardHandler {
69
87
  }
70
88
  }
71
89
 
72
- class RPCCodec {
90
+ class StandardRPCCodec {
73
91
  constructor(serializer) {
74
92
  this.serializer = serializer;
75
93
  }
@@ -93,15 +111,20 @@ class RPCCodec {
93
111
  }
94
112
  }
95
113
 
96
- class RPCMatcher {
97
- tree = {};
114
+ class StandardRPCMatcher {
115
+ filter;
116
+ tree = new NullProtoObj();
98
117
  pendingRouters = [];
118
+ constructor(options = {}) {
119
+ this.filter = options.filter ?? true;
120
+ }
99
121
  init(router, path = []) {
100
- const laziedOptions = eachContractProcedure({
101
- router,
102
- path
103
- }, ({ path: path2, contract }) => {
104
- const httpPath = convertPathToHttpPath(path2);
122
+ const laziedOptions = traverseContractProcedures({ router, path }, (traverseOptions) => {
123
+ if (!value(this.filter, traverseOptions)) {
124
+ return;
125
+ }
126
+ const { path: path2, contract } = traverseOptions;
127
+ const httpPath = toHttpPath(path2);
105
128
  if (isProcedure(contract)) {
106
129
  this.tree[httpPath] = {
107
130
  path: path2,
@@ -121,7 +144,7 @@ class RPCMatcher {
121
144
  });
122
145
  this.pendingRouters.push(...laziedOptions.map((option) => ({
123
146
  ...option,
124
- httpPathPrefix: convertPathToHttpPath(option.path)
147
+ httpPathPrefix: toHttpPath(option.path)
125
148
  })));
126
149
  }
127
150
  async match(_method, pathname) {
@@ -129,7 +152,7 @@ class RPCMatcher {
129
152
  const newPendingRouters = [];
130
153
  for (const pendingRouter of this.pendingRouters) {
131
154
  if (pathname.startsWith(pendingRouter.httpPathPrefix)) {
132
- const { default: router } = await unlazy(pendingRouter.lazied);
155
+ const { default: router } = await unlazy(pendingRouter.router);
133
156
  this.init(router, pendingRouter.path);
134
157
  } else {
135
158
  newPendingRouters.push(pendingRouter);
@@ -142,14 +165,14 @@ class RPCMatcher {
142
165
  return void 0;
143
166
  }
144
167
  if (!match.procedure) {
145
- const { default: maybeProcedure } = await unlazy(getRouterChild(match.router, ...match.path));
168
+ const { default: maybeProcedure } = await unlazy(getRouter(match.router, match.path));
146
169
  if (!isProcedure(maybeProcedure)) {
147
170
  throw new Error(`
148
- [Contract-First] Missing or invalid implementation for procedure at path: ${convertPathToHttpPath(match.path)}.
171
+ [Contract-First] Missing or invalid implementation for procedure at path: ${toHttpPath(match.path)}.
149
172
  Ensure that the procedure is correctly defined and matches the expected contract.
150
173
  `);
151
174
  }
152
- match.procedure = createContractedProcedure(match.contract, maybeProcedure);
175
+ match.procedure = createContractedProcedure(maybeProcedure, match.contract);
153
176
  }
154
177
  return {
155
178
  path: match.path,
@@ -158,4 +181,14 @@ class RPCMatcher {
158
181
  }
159
182
  }
160
183
 
161
- export { RPCCodec as R, StandardHandler as S, RPCMatcher as a };
184
+ class StandardRPCHandler extends StandardHandler {
185
+ constructor(router, options = {}) {
186
+ const jsonSerializer = new StandardRPCJsonSerializer(options);
187
+ const serializer = new StandardRPCSerializer(jsonSerializer);
188
+ const matcher = new StandardRPCMatcher(options);
189
+ const codec = new StandardRPCCodec(serializer);
190
+ super(router, matcher, codec, options);
191
+ }
192
+ }
193
+
194
+ export { CompositeStandardHandlerPlugin as C, StandardHandler as S, StandardRPCCodec as a, StandardRPCHandler as b, StandardRPCMatcher as c };
@@ -0,0 +1,12 @@
1
+ import { C as Context } from './server.wMv480px.js';
2
+ import { b as StandardHandleOptions } from './server.DVBSOxWU.js';
3
+
4
+ type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
5
+ context?: T;
6
+ } : {
7
+ context: T;
8
+ });
9
+ declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
10
+
11
+ export { resolveFriendlyStandardHandleOptions as r };
12
+ export type { FriendlyStandardHandleOptions as F };
@@ -0,0 +1,12 @@
1
+ import { C as Context } from './server.wMv480px.mjs';
2
+ import { b as StandardHandleOptions } from './server.DHgXKx3q.mjs';
3
+
4
+ type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
5
+ context?: T;
6
+ } : {
7
+ context: T;
8
+ });
9
+ declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
10
+
11
+ export { resolveFriendlyStandardHandleOptions as r };
12
+ export type { FriendlyStandardHandleOptions as F };
@@ -0,0 +1,42 @@
1
+ import { ErrorMap, EnhanceRouteOptions, MergedErrorMap, AnyContractRouter, AnyContractProcedure } from '@orpc/contract';
2
+ import { a as AnyMiddleware, L as Lazyable, b as AnyRouter, C as Context, c as Lazy, A as AnyProcedure, P as Procedure, M as MergedInitialContext } from './server.wMv480px.mjs';
3
+
4
+ declare function getRouter<T extends Lazyable<AnyRouter | undefined>>(router: T, path: readonly string[]): T extends Lazy<any> ? Lazy<AnyRouter | undefined> : Lazyable<AnyRouter | undefined>;
5
+ type AccessibleLazyRouter<T extends Lazyable<AnyRouter | undefined>> = T extends Lazy<infer U extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> ? AccessibleLazyRouter<U> : T extends AnyProcedure | undefined ? Lazy<T> : Lazy<T> & {
6
+ [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? AccessibleLazyRouter<T[K]> : never;
7
+ };
8
+ declare function createAccessibleLazyRouter<T extends Lazy<AnyRouter | undefined>>(lazied: T): AccessibleLazyRouter<T>;
9
+ type EnhancedRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap> = T extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<EnhancedRouter<U, TInitialContext, TCurrentContext, TErrorMap>> : T extends Procedure<infer UInitialContext, infer UCurrentContext, infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<MergedInitialContext<TInitialContext, UInitialContext, TCurrentContext>, UCurrentContext, UInputSchema, UOutputSchema, MergedErrorMap<TErrorMap, UErrorMap>, UMeta> : {
10
+ [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? EnhancedRouter<T[K], TInitialContext, TCurrentContext, TErrorMap> : never;
11
+ };
12
+ interface EnhanceRouterOptions<TErrorMap extends ErrorMap> extends EnhanceRouteOptions {
13
+ middlewares: readonly AnyMiddleware[];
14
+ errorMap: TErrorMap;
15
+ dedupeLeadingMiddlewares: boolean;
16
+ }
17
+ declare function enhanceRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap>(router: T, options: EnhanceRouterOptions<TErrorMap>): EnhancedRouter<T, TInitialContext, TCurrentContext, TErrorMap>;
18
+ interface TraverseContractProceduresOptions {
19
+ router: AnyContractRouter | AnyRouter;
20
+ path: readonly string[];
21
+ }
22
+ interface TraverseContractProcedureCallbackOptions {
23
+ contract: AnyContractProcedure | AnyProcedure;
24
+ path: readonly string[];
25
+ }
26
+ /**
27
+ * @deprecated Use `TraverseContractProcedureCallbackOptions` instead.
28
+ */
29
+ type ContractProcedureCallbackOptions = TraverseContractProcedureCallbackOptions;
30
+ interface LazyTraverseContractProceduresOptions {
31
+ router: Lazy<AnyRouter>;
32
+ path: readonly string[];
33
+ }
34
+ declare function traverseContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void, lazyOptions?: LazyTraverseContractProceduresOptions[]): LazyTraverseContractProceduresOptions[];
35
+ declare function resolveContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void): Promise<void>;
36
+ type UnlaziedRouter<T extends AnyRouter> = T extends AnyProcedure ? T : {
37
+ [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? UnlaziedRouter<U> : never;
38
+ };
39
+ declare function unlazyRouter<T extends AnyRouter>(router: T): Promise<UnlaziedRouter<T>>;
40
+
41
+ export { createAccessibleLazyRouter as c, enhanceRouter as e, getRouter as g, resolveContractProcedures as r, traverseContractProcedures as t, unlazyRouter as u };
42
+ export type { AccessibleLazyRouter as A, ContractProcedureCallbackOptions as C, EnhanceRouterOptions as E, LazyTraverseContractProceduresOptions as L, TraverseContractProcedureCallbackOptions as T, UnlaziedRouter as U, EnhancedRouter as a, TraverseContractProceduresOptions as b };
@@ -0,0 +1,74 @@
1
+ import { HTTPPath, ORPCError } from '@orpc/client';
2
+ import { Meta } from '@orpc/contract';
3
+ import { Interceptor } from '@orpc/shared';
4
+ import { StandardResponse, StandardLazyRequest } from '@orpc/standard-server';
5
+ import { C as Context, R as Router, b as AnyRouter, A as AnyProcedure, d as ProcedureClientInterceptorOptions } from './server.wMv480px.mjs';
6
+
7
+ interface StandardHandlerPlugin<T extends Context> {
8
+ order?: number;
9
+ init?(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
10
+ }
11
+ declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends StandardHandlerPlugin<T>> implements StandardHandlerPlugin<T> {
12
+ protected readonly plugins: TPlugin[];
13
+ constructor(plugins?: readonly TPlugin[]);
14
+ init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
15
+ }
16
+
17
+ type StandardParams = Record<string, string>;
18
+ type StandardMatchResult = {
19
+ path: readonly string[];
20
+ procedure: AnyProcedure;
21
+ params?: StandardParams;
22
+ } | undefined;
23
+ interface StandardMatcher {
24
+ init(router: AnyRouter): void;
25
+ match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
26
+ }
27
+ interface StandardCodec {
28
+ encode(output: unknown, procedure: AnyProcedure): StandardResponse;
29
+ encodeError(error: ORPCError<any, any>): StandardResponse;
30
+ decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
31
+ }
32
+
33
+ interface StandardHandleOptions<T extends Context> {
34
+ prefix?: HTTPPath;
35
+ context: T;
36
+ }
37
+ type StandardHandleResult = {
38
+ matched: true;
39
+ response: StandardResponse;
40
+ } | {
41
+ matched: false;
42
+ response: undefined;
43
+ };
44
+ interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
45
+ request: StandardLazyRequest;
46
+ }
47
+ interface StandardHandlerOptions<TContext extends Context> {
48
+ plugins?: StandardHandlerPlugin<TContext>[];
49
+ /**
50
+ * Interceptors at the request level, helpful when you want catch errors
51
+ */
52
+ interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
53
+ /**
54
+ * Interceptors at the root level, helpful when you want override the request/response
55
+ */
56
+ rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
57
+ /**
58
+ *
59
+ * Interceptors for procedure client.
60
+ */
61
+ clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, Promise<unknown>>[];
62
+ }
63
+ declare class StandardHandler<T extends Context> {
64
+ private readonly matcher;
65
+ private readonly codec;
66
+ private readonly interceptors;
67
+ private readonly clientInterceptors;
68
+ private readonly rootInterceptors;
69
+ constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
70
+ handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
71
+ }
72
+
73
+ export { CompositeStandardHandlerPlugin as C, StandardHandler as f };
74
+ export type { StandardCodec as S, StandardParams as a, StandardHandleOptions as b, StandardHandleResult as c, StandardHandlerInterceptorOptions as d, StandardHandlerOptions as e, StandardHandlerPlugin as g, StandardMatchResult as h, StandardMatcher as i };
@@ -0,0 +1,32 @@
1
+ import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
2
+ import { b as AnyRouter, C as Context, R as Router } from './server.wMv480px.js';
3
+ import { i as StandardMatcher, h as StandardMatchResult, e as StandardHandlerOptions, f as StandardHandler } from './server.DVBSOxWU.js';
4
+ import { HTTPPath } from '@orpc/client';
5
+ import { Value } from '@orpc/shared';
6
+ import { T as TraverseContractProcedureCallbackOptions } from './server.a_VzWVCm.js';
7
+
8
+ interface StandardRPCMatcherOptions {
9
+ /**
10
+ * Filter procedures. Return `false` to exclude a procedure from matching.
11
+ *
12
+ * @default true
13
+ */
14
+ filter?: Value<boolean, [options: TraverseContractProcedureCallbackOptions]>;
15
+ }
16
+ declare class StandardRPCMatcher implements StandardMatcher {
17
+ private readonly filter;
18
+ private readonly tree;
19
+ private pendingRouters;
20
+ constructor(options?: StandardRPCMatcherOptions);
21
+ init(router: AnyRouter, path?: readonly string[]): void;
22
+ match(_method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
23
+ }
24
+
25
+ interface StandardRPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, StandardRPCJsonSerializerOptions, StandardRPCMatcherOptions {
26
+ }
27
+ declare class StandardRPCHandler<T extends Context> extends StandardHandler<T> {
28
+ constructor(router: Router<any, T>, options?: StandardRPCHandlerOptions<T>);
29
+ }
30
+
31
+ export { StandardRPCHandler as a, StandardRPCMatcher as c };
32
+ export type { StandardRPCHandlerOptions as S, StandardRPCMatcherOptions as b };
@@ -0,0 +1,74 @@
1
+ import { HTTPPath, ORPCError } from '@orpc/client';
2
+ import { Meta } from '@orpc/contract';
3
+ import { Interceptor } from '@orpc/shared';
4
+ import { StandardResponse, StandardLazyRequest } from '@orpc/standard-server';
5
+ import { C as Context, R as Router, b as AnyRouter, A as AnyProcedure, d as ProcedureClientInterceptorOptions } from './server.wMv480px.js';
6
+
7
+ interface StandardHandlerPlugin<T extends Context> {
8
+ order?: number;
9
+ init?(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
10
+ }
11
+ declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends StandardHandlerPlugin<T>> implements StandardHandlerPlugin<T> {
12
+ protected readonly plugins: TPlugin[];
13
+ constructor(plugins?: readonly TPlugin[]);
14
+ init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
15
+ }
16
+
17
+ type StandardParams = Record<string, string>;
18
+ type StandardMatchResult = {
19
+ path: readonly string[];
20
+ procedure: AnyProcedure;
21
+ params?: StandardParams;
22
+ } | undefined;
23
+ interface StandardMatcher {
24
+ init(router: AnyRouter): void;
25
+ match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
26
+ }
27
+ interface StandardCodec {
28
+ encode(output: unknown, procedure: AnyProcedure): StandardResponse;
29
+ encodeError(error: ORPCError<any, any>): StandardResponse;
30
+ decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
31
+ }
32
+
33
+ interface StandardHandleOptions<T extends Context> {
34
+ prefix?: HTTPPath;
35
+ context: T;
36
+ }
37
+ type StandardHandleResult = {
38
+ matched: true;
39
+ response: StandardResponse;
40
+ } | {
41
+ matched: false;
42
+ response: undefined;
43
+ };
44
+ interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
45
+ request: StandardLazyRequest;
46
+ }
47
+ interface StandardHandlerOptions<TContext extends Context> {
48
+ plugins?: StandardHandlerPlugin<TContext>[];
49
+ /**
50
+ * Interceptors at the request level, helpful when you want catch errors
51
+ */
52
+ interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
53
+ /**
54
+ * Interceptors at the root level, helpful when you want override the request/response
55
+ */
56
+ rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
57
+ /**
58
+ *
59
+ * Interceptors for procedure client.
60
+ */
61
+ clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, Promise<unknown>>[];
62
+ }
63
+ declare class StandardHandler<T extends Context> {
64
+ private readonly matcher;
65
+ private readonly codec;
66
+ private readonly interceptors;
67
+ private readonly clientInterceptors;
68
+ private readonly rootInterceptors;
69
+ constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
70
+ handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
71
+ }
72
+
73
+ export { CompositeStandardHandlerPlugin as C, StandardHandler as f };
74
+ export type { StandardCodec as S, StandardParams as a, StandardHandleOptions as b, StandardHandleResult as c, StandardHandlerInterceptorOptions as d, StandardHandlerOptions as e, StandardHandlerPlugin as g, StandardMatchResult as h, StandardMatcher as i };
@@ -0,0 +1,9 @@
1
+ function resolveFriendlyStandardHandleOptions(options) {
2
+ return {
3
+ ...options,
4
+ context: options.context ?? {}
5
+ // Context only optional if all fields are optional
6
+ };
7
+ }
8
+
9
+ export { resolveFriendlyStandardHandleOptions as r };