@orpc/server 0.11.0 → 0.13.0

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.
package/dist/index.js CHANGED
@@ -1,11 +1,17 @@
1
1
  import {
2
+ LAZY_LOADER_SYMBOL,
2
3
  Procedure,
4
+ createFlattenLazy,
5
+ createLazy,
3
6
  createProcedureCaller,
7
+ decorateLazy,
4
8
  decorateMiddleware,
5
9
  decorateProcedure,
10
+ isLazy,
6
11
  isProcedure,
12
+ loadLazy,
7
13
  mergeContext
8
- } from "./chunk-CVLK2PBB.js";
14
+ } from "./chunk-FL4ZAGNE.js";
9
15
 
10
16
  // src/builder.ts
11
17
  import {
@@ -15,9 +21,138 @@ import {
15
21
 
16
22
  // src/procedure-builder.ts
17
23
  import {
18
- DecoratedContractProcedure
24
+ DecoratedContractProcedure as DecoratedContractProcedure2
19
25
  } from "@orpc/contract";
20
26
 
27
+ // src/router-builder.ts
28
+ import { DecoratedContractProcedure, prefixHTTPPath } from "@orpc/contract";
29
+ var LAZY_ROUTER_PREFIX_SYMBOL = Symbol("ORPC_LAZY_ROUTER_PREFIX");
30
+ var RouterBuilder = class _RouterBuilder {
31
+ constructor(zz$rb) {
32
+ this.zz$rb = zz$rb;
33
+ if (zz$rb.prefix && zz$rb.prefix.includes("{")) {
34
+ throw new Error('Prefix cannot contain "{" for dynamic routing');
35
+ }
36
+ }
37
+ prefix(prefix) {
38
+ return new _RouterBuilder({
39
+ ...this.zz$rb,
40
+ prefix: `${this.zz$rb.prefix ?? ""}${prefix}`
41
+ });
42
+ }
43
+ tags(...tags) {
44
+ if (!tags.length)
45
+ return this;
46
+ return new _RouterBuilder({
47
+ ...this.zz$rb,
48
+ tags: [...this.zz$rb.tags ?? [], ...tags]
49
+ });
50
+ }
51
+ use(middleware, mapInput) {
52
+ const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
53
+ return new _RouterBuilder({
54
+ ...this.zz$rb,
55
+ middlewares: [...this.zz$rb.middlewares || [], middleware_]
56
+ });
57
+ }
58
+ router(router) {
59
+ const handled = adaptRouter({
60
+ routerOrChild: router,
61
+ middlewares: this.zz$rb.middlewares,
62
+ tags: this.zz$rb.tags,
63
+ prefix: this.zz$rb.prefix
64
+ });
65
+ return handled;
66
+ }
67
+ lazy(loader) {
68
+ const lazy = adaptLazyRouter({
69
+ current: createLazy(loader),
70
+ middlewares: this.zz$rb.middlewares,
71
+ tags: this.zz$rb.tags,
72
+ prefix: this.zz$rb.prefix
73
+ });
74
+ return lazy;
75
+ }
76
+ };
77
+ function adaptRouter(options) {
78
+ if (isProcedure(options.routerOrChild)) {
79
+ return adaptProcedure({
80
+ ...options,
81
+ procedure: options.routerOrChild
82
+ });
83
+ }
84
+ if (isLazy(options.routerOrChild)) {
85
+ return adaptLazyRouter({
86
+ ...options,
87
+ current: options.routerOrChild
88
+ });
89
+ }
90
+ const handled = {};
91
+ for (const key in options.routerOrChild) {
92
+ handled[key] = adaptRouter({
93
+ ...options,
94
+ routerOrChild: options.routerOrChild[key]
95
+ });
96
+ }
97
+ return handled;
98
+ }
99
+ function adaptLazyRouter(options) {
100
+ const loader = async () => {
101
+ const current = (await loadLazy(options.current)).default;
102
+ return {
103
+ default: adaptRouter({
104
+ ...options,
105
+ routerOrChild: current
106
+ })
107
+ };
108
+ };
109
+ let lazyRouterPrefix = options.prefix;
110
+ if (LAZY_ROUTER_PREFIX_SYMBOL in options.current && typeof options.current[LAZY_ROUTER_PREFIX_SYMBOL] === "string") {
111
+ lazyRouterPrefix = lazyRouterPrefix ? prefixHTTPPath(options.current[LAZY_ROUTER_PREFIX_SYMBOL], lazyRouterPrefix) : options.current[LAZY_ROUTER_PREFIX_SYMBOL];
112
+ }
113
+ const decoratedLazy = Object.assign(decorateLazy(createLazy(loader)), {
114
+ [LAZY_ROUTER_PREFIX_SYMBOL]: lazyRouterPrefix
115
+ });
116
+ const recursive = new Proxy(decoratedLazy, {
117
+ get(target, key) {
118
+ if (typeof key !== "string") {
119
+ return Reflect.get(target, key);
120
+ }
121
+ return adaptLazyRouter({
122
+ ...options,
123
+ current: createLazy(async () => {
124
+ const current = (await loadLazy(options.current)).default;
125
+ return { default: current[key] };
126
+ })
127
+ });
128
+ }
129
+ });
130
+ return recursive;
131
+ }
132
+ function adaptProcedure(options) {
133
+ const builderMiddlewares = options.middlewares ?? [];
134
+ const procedureMiddlewares = options.procedure.zz$p.middlewares ?? [];
135
+ const middlewares = [
136
+ ...builderMiddlewares,
137
+ ...procedureMiddlewares.filter(
138
+ (item) => !builderMiddlewares.includes(item)
139
+ )
140
+ ];
141
+ let contract = DecoratedContractProcedure.decorate(
142
+ options.procedure.zz$p.contract
143
+ ).addTags(...options.tags ?? []);
144
+ if (options.prefix) {
145
+ contract = contract.prefix(options.prefix);
146
+ }
147
+ return decorateProcedure({
148
+ zz$p: {
149
+ ...options.procedure.zz$p,
150
+ contract,
151
+ middlewares
152
+ }
153
+ });
154
+ }
155
+
21
156
  // src/procedure-implementer.ts
22
157
  var ProcedureImplementer = class _ProcedureImplementer {
23
158
  constructor(zz$pi) {
@@ -39,6 +174,9 @@ var ProcedureImplementer = class _ProcedureImplementer {
39
174
  }
40
175
  });
41
176
  }
177
+ lazy(loader) {
178
+ return new RouterBuilder(this.zz$pi).lazy(loader);
179
+ }
42
180
  };
43
181
 
44
182
  // src/procedure-builder.ts
@@ -52,7 +190,7 @@ var ProcedureBuilder = class _ProcedureBuilder {
52
190
  route(opts) {
53
191
  return new _ProcedureBuilder({
54
192
  ...this.zz$pb,
55
- contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).route(
193
+ contract: DecoratedContractProcedure2.decorate(this.zz$pb.contract).route(
56
194
  opts
57
195
  )
58
196
  });
@@ -60,7 +198,7 @@ var ProcedureBuilder = class _ProcedureBuilder {
60
198
  input(schema, example) {
61
199
  return new _ProcedureBuilder({
62
200
  ...this.zz$pb,
63
- contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).input(
201
+ contract: DecoratedContractProcedure2.decorate(this.zz$pb.contract).input(
64
202
  schema,
65
203
  example
66
204
  )
@@ -69,7 +207,7 @@ var ProcedureBuilder = class _ProcedureBuilder {
69
207
  output(schema, example) {
70
208
  return new _ProcedureBuilder({
71
209
  ...this.zz$pb,
72
- contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).output(
210
+ contract: DecoratedContractProcedure2.decorate(this.zz$pb.contract).output(
73
211
  schema,
74
212
  example
75
213
  )
@@ -101,75 +239,24 @@ var ProcedureBuilder = class _ProcedureBuilder {
101
239
  }
102
240
  };
103
241
 
104
- // src/router-builder.ts
105
- import { DecoratedContractProcedure as DecoratedContractProcedure2 } from "@orpc/contract";
106
- var RouterBuilder = class _RouterBuilder {
107
- constructor(zz$rb) {
108
- this.zz$rb = zz$rb;
109
- }
110
- prefix(prefix) {
111
- return new _RouterBuilder({
112
- ...this.zz$rb,
113
- prefix: `${this.zz$rb.prefix ?? ""}${prefix}`
114
- });
115
- }
116
- tags(...tags) {
117
- if (!tags.length)
118
- return this;
119
- return new _RouterBuilder({
120
- ...this.zz$rb,
121
- tags: [...this.zz$rb.tags ?? [], ...tags]
122
- });
123
- }
124
- use(middleware, mapInput) {
125
- const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
126
- return new _RouterBuilder({
127
- ...this.zz$rb,
128
- middlewares: [...this.zz$rb.middlewares || [], middleware_]
129
- });
130
- }
131
- router(router) {
132
- const handled = {};
133
- for (const key in router) {
134
- const item = router[key];
135
- if (isProcedure(item)) {
136
- const builderMiddlewares = this.zz$rb.middlewares ?? [];
137
- const itemMiddlewares = item.zz$p.middlewares ?? [];
138
- const middlewares = [
139
- ...builderMiddlewares,
140
- ...itemMiddlewares.filter(
141
- (item2) => !builderMiddlewares.includes(item2)
142
- )
143
- ];
144
- const contract = DecoratedContractProcedure2.decorate(
145
- item.zz$p.contract
146
- ).addTags(...this.zz$rb.tags ?? []);
147
- handled[key] = decorateProcedure({
148
- zz$p: {
149
- ...item.zz$p,
150
- contract: this.zz$rb.prefix ? contract.prefix(this.zz$rb.prefix) : contract,
151
- middlewares
152
- }
153
- });
154
- } else {
155
- handled[key] = this.router(item);
156
- }
157
- }
158
- return handled;
159
- }
160
- };
161
-
162
242
  // src/router-implementer.ts
163
- import {
164
- isContractProcedure
165
- } from "@orpc/contract";
243
+ import { isContractProcedure } from "@orpc/contract";
244
+ var ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_ROUTER_CONTRACT");
166
245
  var RouterImplementer = class {
167
246
  constructor(zz$ri) {
168
247
  this.zz$ri = zz$ri;
169
248
  }
170
249
  router(router) {
171
- assertRouterImplementation(this.zz$ri.contract, router);
172
- return router;
250
+ return Object.assign(new RouterBuilder({}).router(router), {
251
+ [ROUTER_CONTRACT_SYMBOL]: this.zz$ri.contract
252
+ });
253
+ }
254
+ lazy(loader) {
255
+ const lazy = createLazy(loader);
256
+ const decorated = decorateLazy(lazy);
257
+ return Object.assign(decorated, {
258
+ [ROUTER_CONTRACT_SYMBOL]: this.zz$ri.contract
259
+ });
173
260
  }
174
261
  };
175
262
  function chainRouterImplementer(contract, middlewares) {
@@ -188,37 +275,6 @@ function chainRouterImplementer(contract, middlewares) {
188
275
  const implementer = new RouterImplementer({ contract });
189
276
  return Object.assign(implementer, result);
190
277
  }
191
- function assertRouterImplementation(contract, router, path = []) {
192
- for (const key in contract) {
193
- const currentPath = [...path, key];
194
- const contractItem = contract[key];
195
- const routerItem = router[key];
196
- if (!routerItem) {
197
- throw new Error(
198
- `Missing implementation for procedure at [${currentPath.join(".")}]`
199
- );
200
- }
201
- if (isContractProcedure(contractItem)) {
202
- if (isProcedure(routerItem)) {
203
- if (routerItem.zz$p.contract !== contractItem) {
204
- throw new Error(
205
- `Mismatch implementation for procedure at [${currentPath.join(".")}]`
206
- );
207
- }
208
- } else {
209
- throw new Error(
210
- `Mismatch implementation for procedure at [${currentPath.join(".")}]`
211
- );
212
- }
213
- } else {
214
- assertRouterImplementation(
215
- contractItem,
216
- routerItem,
217
- currentPath
218
- );
219
- }
220
- }
221
- }
222
278
 
223
279
  // src/builder.ts
224
280
  var Builder = class _Builder {
@@ -327,6 +383,9 @@ var Builder = class _Builder {
327
383
  router(router) {
328
384
  return new RouterBuilder(this.zz$b).router(router);
329
385
  }
386
+ lazy(loader) {
387
+ return new RouterBuilder(this.zz$b).lazy(loader);
388
+ }
330
389
  };
331
390
 
332
391
  // src/router.ts
@@ -350,25 +409,32 @@ function toContractRouter(router) {
350
409
 
351
410
  // src/router-caller.ts
352
411
  function createRouterCaller(options) {
353
- const caller = {};
354
- for (const key in options.router) {
355
- const path = [...options.basePath ?? [], key];
356
- const item = options.router[key];
357
- if (isProcedure(item)) {
358
- caller[key] = createProcedureCaller({
359
- procedure: item,
360
- context: options.context,
361
- path
362
- });
363
- } else {
364
- caller[key] = createRouterCaller({
365
- router: item,
412
+ return createRouterCallerInternal({
413
+ current: options.router,
414
+ context: options.context,
415
+ path: options.basePath ?? []
416
+ });
417
+ }
418
+ function createRouterCallerInternal(options) {
419
+ const procedureCaller = isLazy(options.current) || isProcedure(options.current) ? createProcedureCaller({
420
+ procedure: options.current,
421
+ context: options.context,
422
+ path: options.path
423
+ }) : {};
424
+ const recursive = new Proxy(procedureCaller, {
425
+ get(target, key) {
426
+ if (typeof key !== "string") {
427
+ return Reflect.get(target, key);
428
+ }
429
+ const next = options.current[key];
430
+ return createRouterCallerInternal({
431
+ current: next,
366
432
  context: options.context,
367
- basePath: path
433
+ path: [...options.path, key]
368
434
  });
369
435
  }
370
- }
371
- return caller;
436
+ });
437
+ return recursive;
372
438
  }
373
439
 
374
440
  // src/index.ts
@@ -376,18 +442,27 @@ export * from "@orpc/shared/error";
376
442
  var os = new Builder();
377
443
  export {
378
444
  Builder,
445
+ LAZY_LOADER_SYMBOL,
446
+ LAZY_ROUTER_PREFIX_SYMBOL,
379
447
  Procedure,
380
448
  ProcedureBuilder,
381
449
  ProcedureImplementer,
450
+ ROUTER_CONTRACT_SYMBOL,
451
+ RouterBuilder,
382
452
  RouterImplementer,
383
- assertRouterImplementation,
384
453
  chainRouterImplementer,
454
+ createFlattenLazy,
455
+ createLazy,
385
456
  createProcedureCaller,
386
457
  createRouterCaller,
458
+ decorateLazy,
387
459
  decorateMiddleware,
388
460
  decorateProcedure,
461
+ isLazy,
389
462
  isProcedure,
463
+ loadLazy,
390
464
  mergeContext,
391
465
  os,
392
466
  toContractRouter
393
467
  };
468
+ //# sourceMappingURL=index.js.map
@@ -1,9 +1,10 @@
1
1
  import type { IsEqual } from '@orpc/shared';
2
+ import type { DecoratedLazy } from './lazy';
3
+ import type { DecoratedProcedure, Procedure, ProcedureFunc } from './procedure';
2
4
  import type { HandledRouter, Router } from './router';
3
5
  import type { Context, MergeContext } from './types';
4
6
  import { ContractProcedure, type ContractRouter, type HTTPPath, type RouteOptions, type Schema, type SchemaInput, type SchemaOutput } from '@orpc/contract';
5
7
  import { type DecoratedMiddleware, type MapInputMiddleware, type Middleware } from './middleware';
6
- import { type DecoratedProcedure, type ProcedureFunc } from './procedure';
7
8
  import { ProcedureBuilder } from './procedure-builder';
8
9
  import { ProcedureImplementer } from './procedure-implementer';
9
10
  import { RouterBuilder } from './router-builder';
@@ -45,4 +46,8 @@ export declare class Builder<TContext extends Context, TExtraContext extends Con
45
46
  * Create DecoratedRouter
46
47
  */
47
48
  router<URouter extends Router<TContext>>(router: URouter): HandledRouter<URouter>;
49
+ lazy<U extends Router<TContext> | Procedure<TContext, any, any, any, any>>(loader: () => Promise<{
50
+ default: U;
51
+ }>): DecoratedLazy<U>;
48
52
  }
53
+ //# sourceMappingURL=builder.d.ts.map
@@ -0,0 +1,7 @@
1
+ import type { Router } from '../router';
2
+ import type { FetchHandler, FetchHandlerOptions } from './types';
3
+ export type HandleFetchRequestOptions<TRouter extends Router<any>> = FetchHandlerOptions<TRouter> & {
4
+ handlers: readonly [FetchHandler, ...FetchHandler[]];
5
+ };
6
+ export declare function handleFetchRequest<TRouter extends Router<any>>(options: HandleFetchRequestOptions<TRouter>): Promise<Response>;
7
+ //# sourceMappingURL=handle.d.ts.map
@@ -0,0 +1,3 @@
1
+ import type { FetchHandler } from './types';
2
+ export declare function createORPCHandler(): FetchHandler;
3
+ //# sourceMappingURL=handler.d.ts.map
@@ -0,0 +1,4 @@
1
+ export * from './handle';
2
+ export * from './handler';
3
+ export * from './types';
4
+ //# sourceMappingURL=index.d.ts.map
@@ -4,21 +4,12 @@ export interface FetchHandlerHooks {
4
4
  next: () => Promise<Response>;
5
5
  response: (response: Response) => Response;
6
6
  }
7
- export interface CreateFetchHandlerOptions<TRouter extends Router<any>> {
8
- router: TRouter;
9
- /**
10
- * Hooks for executing logics on lifecycle events.
11
- */
12
- hooks?: (context: TRouter extends Router<infer UContext> ? UContext : never, hooks: FetchHandlerHooks) => Promisable<Response>;
7
+ export type FetchHandlerOptions<TRouter extends Router<any>> = {
13
8
  /**
14
- * It will help improve the cold start time. But it will increase the performance.
9
+ * The `router` used for handling the request and routing,
15
10
  *
16
- * @default false
17
11
  */
18
- serverless?: boolean;
19
- }
20
- export declare function createFetchHandler<TRouter extends Router<any>>(options: CreateFetchHandlerOptions<TRouter>): FetchHandler<TRouter>;
21
- export type FetchHandlerOptions<TRouter extends Router<any>> = {
12
+ router: TRouter;
22
13
  /**
23
14
  * The request need to be handled.
24
15
  */
@@ -30,12 +21,15 @@ export type FetchHandlerOptions<TRouter extends Router<any>> = {
30
21
  * @example /api
31
22
  */
32
23
  prefix?: string;
24
+ /**
25
+ * Hooks for executing logics on lifecycle events.
26
+ */
27
+ hooks?: (context: TRouter extends Router<infer UContext> ? UContext : never, hooks: FetchHandlerHooks) => Promisable<Response>;
33
28
  } & PartialOnUndefinedDeep<{
34
29
  /**
35
30
  * The context used to handle the request.
36
31
  */
37
32
  context: Value<TRouter extends Router<infer UContext> ? UContext : never>;
38
33
  }>;
39
- export interface FetchHandler<TRouter extends Router<any>> {
40
- (options: FetchHandlerOptions<TRouter>): Promise<Response>;
41
- }
34
+ export type FetchHandler = <TRouter extends Router<any>>(options: FetchHandlerOptions<TRouter>) => Promise<Response | undefined>;
35
+ //# sourceMappingURL=types.d.ts.map
@@ -1,14 +1,17 @@
1
1
  import { Builder } from './builder';
2
2
  export * from './builder';
3
+ export * from './lazy';
3
4
  export * from './middleware';
4
5
  export * from './procedure';
5
6
  export * from './procedure-builder';
6
7
  export * from './procedure-caller';
7
8
  export * from './procedure-implementer';
8
9
  export * from './router';
10
+ export * from './router-builder';
9
11
  export * from './router-caller';
10
12
  export * from './router-implementer';
11
13
  export * from './types';
12
14
  export * from './utils';
13
15
  export * from '@orpc/shared/error';
14
16
  export declare const os: Builder<Record<string, unknown> | undefined, undefined>;
17
+ //# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,23 @@
1
+ import type { Procedure } from './procedure';
2
+ import type { ProcedureCaller } from './procedure-caller';
3
+ export declare const LAZY_LOADER_SYMBOL: unique symbol;
4
+ export interface Lazy<T> {
5
+ [LAZY_LOADER_SYMBOL]: () => Promise<{
6
+ default: T;
7
+ }>;
8
+ }
9
+ export type ANY_LAZY = Lazy<any>;
10
+ export declare function createLazy<T>(loader: () => Promise<{
11
+ default: T;
12
+ }>): Lazy<T>;
13
+ export declare function loadLazy<T>(lazy: Lazy<T>): Promise<{
14
+ default: T;
15
+ }>;
16
+ export declare function isLazy(item: unknown): item is ANY_LAZY;
17
+ export type FlattenLazy<T> = T extends Lazy<infer U> ? FlattenLazy<U> : Lazy<T>;
18
+ export declare function createFlattenLazy<T>(lazy: Lazy<T>): FlattenLazy<T>;
19
+ export type DecoratedLazy<T> = T extends Lazy<infer U> ? DecoratedLazy<U> : (T extends Procedure<infer UContext, any, any, any, any> ? Lazy<T> & (undefined extends UContext ? ProcedureCaller<T> : unknown) : T extends Record<any, any> ? {
20
+ [K in keyof T]: DecoratedLazy<T[K]>;
21
+ } /** Notice: this still a lazy, but type not work when I & Lazy<T>, maybe it's a bug, should improve */ : Lazy<T>);
22
+ export declare function decorateLazy<T>(lazy: Lazy<T>): DecoratedLazy<T>;
23
+ //# sourceMappingURL=lazy.d.ts.map
@@ -23,3 +23,4 @@ export interface DecoratedMiddleware<TContext extends Context, TExtraContext ext
23
23
  mapInput: <UInput = unknown>(map: MapInputMiddleware<UInput, TInput>) => DecoratedMiddleware<TContext, TExtraContext, UInput, TOutput>;
24
24
  }
25
25
  export declare function decorateMiddleware<TContext extends Context, TExtraContext extends Context, TInput, TOutput>(middleware: Middleware<TContext, TExtraContext, TInput, TOutput>): DecoratedMiddleware<TContext, TExtraContext, TInput, TOutput>;
26
+ //# sourceMappingURL=middleware.d.ts.map
@@ -28,3 +28,4 @@ export declare class ProcedureBuilder<TContext extends Context, TExtraContext ex
28
28
  */
29
29
  func<UFuncOutput extends SchemaOutput<TOutputSchema>>(func: ProcedureFunc<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput>): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput>;
30
30
  }
31
+ //# sourceMappingURL=procedure-builder.d.ts.map
@@ -1,12 +1,13 @@
1
1
  import type { SchemaInput, SchemaOutput } from '@orpc/contract';
2
- import type { Procedure } from './procedure';
2
+ import type { Lazy } from './lazy';
3
3
  import { type Value } from '@orpc/shared';
4
- export interface CreateProcedureCallerOptions<TProcedure extends Procedure<any, any, any, any, any>> {
4
+ import { type ANY_LAZY_PROCEDURE, type ANY_PROCEDURE, type Procedure } from './procedure';
5
+ export interface CreateProcedureCallerOptions<TProcedure extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE> {
5
6
  procedure: TProcedure;
6
7
  /**
7
8
  * The context used when calling the procedure.
8
9
  */
9
- context: Value<TProcedure extends Procedure<infer UContext, any, any, any, any> ? UContext : never>;
10
+ context: Value<TProcedure extends Procedure<infer UContext, any, any, any, any> | Lazy<Procedure<infer UContext, any, any, any, any>> ? UContext : never>;
10
11
  /**
11
12
  * This is helpful for logging and analytics.
12
13
  *
@@ -14,5 +15,6 @@ export interface CreateProcedureCallerOptions<TProcedure extends Procedure<any,
14
15
  */
15
16
  path?: string[];
16
17
  }
17
- export type ProcedureCaller<TProcedure extends Procedure<any, any, any, any, any>> = TProcedure extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> ? (...input: [input: SchemaInput<UInputSchema> | FormData] | (undefined extends SchemaInput<UInputSchema> ? [] : never)) => Promise<SchemaOutput<UOutputSchema, UFuncOutput>> : never;
18
- export declare function createProcedureCaller<TProcedure extends Procedure<any, any, any, any, any>>(options: CreateProcedureCallerOptions<TProcedure>): ProcedureCaller<TProcedure>;
18
+ export type ProcedureCaller<TProcedure extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE> = TProcedure extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput>> ? (...input: [input: SchemaInput<UInputSchema> | FormData] | (undefined extends SchemaInput<UInputSchema> ? [] : never)) => Promise<SchemaOutput<UOutputSchema, UFuncOutput>> : never;
19
+ export declare function createProcedureCaller<TProcedure extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE>(options: CreateProcedureCallerOptions<TProcedure>): ProcedureCaller<TProcedure>;
20
+ //# sourceMappingURL=procedure-caller.d.ts.map
@@ -1,7 +1,8 @@
1
1
  import type { ContractProcedure, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
2
+ import type { DecoratedLazy } from './lazy';
3
+ import type { DecoratedProcedure, Procedure, ProcedureFunc } from './procedure';
2
4
  import type { Context, MergeContext } from './types';
3
5
  import { type MapInputMiddleware, type Middleware } from './middleware';
4
- import { type DecoratedProcedure, type ProcedureFunc } from './procedure';
5
6
  export declare class ProcedureImplementer<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema> {
6
7
  zz$pi: {
7
8
  contract: ContractProcedure<TInputSchema, TOutputSchema>;
@@ -14,4 +15,8 @@ export declare class ProcedureImplementer<TContext extends Context, TExtraContex
14
15
  use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>>): ProcedureImplementer<TContext, MergeContext<TExtraContext, UExtraContext>, TInputSchema, TOutputSchema>;
15
16
  use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined, UMappedInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, UMappedInput, SchemaInput<TOutputSchema>>, mapInput: MapInputMiddleware<SchemaOutput<TInputSchema>, UMappedInput>): ProcedureImplementer<TContext, MergeContext<TExtraContext, UExtraContext>, TInputSchema, TOutputSchema>;
16
17
  func<UFuncOutput extends SchemaOutput<TOutputSchema>>(func: ProcedureFunc<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput>): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput>;
18
+ lazy<U extends Procedure<TContext, TExtraContext, TInputSchema, TOutputSchema, SchemaOutput<TOutputSchema>>>(loader: () => Promise<{
19
+ default: U;
20
+ }>): DecoratedLazy<U>;
17
21
  }
22
+ //# sourceMappingURL=procedure-implementer.d.ts.map
@@ -1,4 +1,5 @@
1
1
  import type { Promisable } from '@orpc/shared';
2
+ import type { Lazy } from './lazy';
2
3
  import type { ProcedureCaller } from './procedure-caller';
3
4
  import type { Context, MergeContext, Meta } from './types';
4
5
  import { type ContractProcedure, type HTTPPath, type RouteOptions, type Schema, type SchemaInput, type SchemaOutput } from '@orpc/contract';
@@ -15,6 +16,9 @@ export declare class Procedure<TContext extends Context, TExtraContext extends C
15
16
  func: ProcedureFunc<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput>;
16
17
  });
17
18
  }
19
+ export type ANY_PROCEDURE = Procedure<any, any, any, any, any>;
20
+ export type WELL_DEFINED_PROCEDURE = Procedure<Context, Context, Schema, Schema, unknown>;
21
+ export type ANY_LAZY_PROCEDURE = Lazy<ANY_PROCEDURE>;
18
22
  export type DecoratedProcedure<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TFuncOutput extends SchemaOutput<TOutputSchema>> = Procedure<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput> & {
19
23
  prefix: (prefix: HTTPPath) => DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput>;
20
24
  route: (opts: RouteOptions) => DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput>;
@@ -24,5 +28,5 @@ export interface ProcedureFunc<TContext extends Context, TExtraContext extends C
24
28
  (input: SchemaOutput<TInputSchema>, context: MergeContext<TContext, TExtraContext>, meta: Meta): Promisable<SchemaInput<TOutputSchema, TOutput>>;
25
29
  }
26
30
  export declare function decorateProcedure<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TFuncOutput extends SchemaOutput<TOutputSchema>>(procedure: Procedure<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput>): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput>;
27
- export type WELL_DEFINED_PROCEDURE = Procedure<Context, Context, Schema, Schema, unknown>;
28
- export declare function isProcedure(item: unknown): item is WELL_DEFINED_PROCEDURE;
31
+ export declare function isProcedure(item: unknown): item is ANY_PROCEDURE;
32
+ //# sourceMappingURL=procedure.d.ts.map
@@ -1,7 +1,9 @@
1
+ import type { DecoratedLazy } from './lazy';
1
2
  import type { HandledRouter, Router } from './router';
2
3
  import type { Context, MergeContext } from './types';
3
4
  import { type HTTPPath } from '@orpc/contract';
4
5
  import { type MapInputMiddleware, type Middleware } from './middleware';
6
+ export declare const LAZY_ROUTER_PREFIX_SYMBOL: unique symbol;
5
7
  export declare class RouterBuilder<TContext extends Context, TExtraContext extends Context> {
6
8
  zz$rb: {
7
9
  prefix?: HTTPPath;
@@ -18,4 +20,8 @@ export declare class RouterBuilder<TContext extends Context, TExtraContext exten
18
20
  use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, unknown, unknown>): RouterBuilder<TContext, MergeContext<TExtraContext, UExtraContext>>;
19
21
  use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined, UMappedInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, UMappedInput, unknown>, mapInput: MapInputMiddleware<unknown, UMappedInput>): RouterBuilder<TContext, MergeContext<TExtraContext, UExtraContext>>;
20
22
  router<URouter extends Router<TContext>>(router: URouter): HandledRouter<URouter>;
23
+ lazy<U extends Router<TContext>>(loader: () => Promise<{
24
+ default: U;
25
+ }>): DecoratedLazy<U>;
21
26
  }
27
+ //# sourceMappingURL=router-builder.d.ts.map
@@ -1,6 +1,6 @@
1
1
  import type { Value } from '@orpc/shared';
2
+ import type { ANY_LAZY_PROCEDURE, ANY_PROCEDURE } from './procedure';
2
3
  import type { Router } from './router';
3
- import { type Procedure } from './procedure';
4
4
  import { type ProcedureCaller } from './procedure-caller';
5
5
  export interface CreateRouterCallerOptions<TRouter extends Router<any>> {
6
6
  router: TRouter;
@@ -16,6 +16,7 @@ export interface CreateRouterCallerOptions<TRouter extends Router<any>> {
16
16
  basePath?: string[];
17
17
  }
18
18
  export type RouterCaller<TRouter extends Router<any>> = {
19
- [K in keyof TRouter]: TRouter[K] extends Procedure<any, any, any, any, any> ? ProcedureCaller<TRouter[K]> : TRouter[K] extends Router<any> ? RouterCaller<TRouter[K]> : never;
19
+ [K in keyof TRouter]: TRouter[K] extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE ? ProcedureCaller<TRouter[K]> : TRouter[K] extends Router<any> ? RouterCaller<TRouter[K]> : never;
20
20
  };
21
21
  export declare function createRouterCaller<TRouter extends Router<any>>(options: CreateRouterCallerOptions<TRouter>): RouterCaller<TRouter>;
22
+ //# sourceMappingURL=router-caller.d.ts.map