@orpc/server 0.0.0-next.4220427 → 0.0.0-next.43889a7

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 (41) hide show
  1. package/dist/{chunk-V3I7RIRY.js → chunk-26GHKV43.js} +6 -7
  2. package/dist/{chunk-DNG2IB3R.js → chunk-LDIL7OEP.js} +40 -50
  3. package/dist/fetch.js +4 -4
  4. package/dist/hono.js +5 -5
  5. package/dist/index.js +687 -181
  6. package/dist/next.js +5 -5
  7. package/dist/node.js +10 -10
  8. package/dist/src/adapters/fetch/orpc-handler.d.ts +4 -4
  9. package/dist/src/adapters/fetch/types.d.ts +3 -3
  10. package/dist/src/adapters/hono/middleware.d.ts +3 -3
  11. package/dist/src/adapters/next/serve.d.ts +3 -3
  12. package/dist/src/adapters/node/orpc-handler.d.ts +5 -5
  13. package/dist/src/adapters/node/types.d.ts +3 -3
  14. package/dist/src/builder-with-errors-middlewares.d.ts +49 -0
  15. package/dist/src/builder-with-errors.d.ts +49 -0
  16. package/dist/src/builder-with-middlewares.d.ts +49 -0
  17. package/dist/src/builder.d.ts +33 -23
  18. package/dist/src/config.d.ts +6 -0
  19. package/dist/src/context.d.ts +10 -0
  20. package/dist/src/error.d.ts +1 -1
  21. package/dist/src/hidden.d.ts +2 -2
  22. package/dist/src/implementer-chainable.d.ts +11 -5
  23. package/dist/src/index.d.ts +5 -4
  24. package/dist/src/lazy-decorated.d.ts +4 -6
  25. package/dist/src/middleware-decorated.d.ts +5 -5
  26. package/dist/src/middleware.d.ts +19 -15
  27. package/dist/src/procedure-builder-with-input.d.ts +35 -0
  28. package/dist/src/procedure-builder-with-output.d.ts +34 -0
  29. package/dist/src/procedure-builder.d.ts +23 -19
  30. package/dist/src/procedure-client.d.ts +8 -21
  31. package/dist/src/procedure-decorated.d.ts +21 -11
  32. package/dist/src/procedure-implementer.d.ts +14 -10
  33. package/dist/src/procedure-utils.d.ts +17 -0
  34. package/dist/src/procedure.d.ts +16 -12
  35. package/dist/src/router-builder.d.ts +20 -16
  36. package/dist/src/router-client.d.ts +7 -6
  37. package/dist/src/router-implementer.d.ts +12 -10
  38. package/dist/src/router.d.ts +4 -4
  39. package/dist/src/types.d.ts +0 -3
  40. package/package.json +3 -3
  41. package/dist/src/utils.d.ts +0 -3
package/dist/index.js CHANGED
@@ -8,16 +8,24 @@ import {
8
8
  isLazy,
9
9
  isProcedure,
10
10
  lazy,
11
- mergeContext,
11
+ middlewareOutputFn,
12
12
  unlazy
13
- } from "./chunk-DNG2IB3R.js";
13
+ } from "./chunk-LDIL7OEP.js";
14
14
 
15
15
  // src/builder.ts
16
+ import { ContractProcedure as ContractProcedure4 } from "@orpc/contract";
17
+
18
+ // src/builder-with-errors.ts
19
+ import { ContractProcedure as ContractProcedure2 } from "@orpc/contract";
20
+
21
+ // src/builder-with-errors-middlewares.ts
16
22
  import { ContractProcedure } from "@orpc/contract";
17
23
 
18
- // src/implementer-chainable.ts
19
- import { isContractProcedure } from "@orpc/contract";
20
- import { createCallableObject } from "@orpc/shared";
24
+ // src/procedure-builder.ts
25
+ import { ContractProcedureBuilder, DecoratedContractProcedure as DecoratedContractProcedure4 } from "@orpc/contract";
26
+
27
+ // src/procedure-builder-with-input.ts
28
+ import { ContractProcedureBuilderWithInput, DecoratedContractProcedure as DecoratedContractProcedure2 } from "@orpc/contract";
21
29
 
22
30
  // src/middleware-decorated.ts
23
31
  function decorateMiddleware(middleware) {
@@ -31,8 +39,8 @@ function decorateMiddleware(middleware) {
31
39
  decorated.concat = (concatMiddleware, mapInput) => {
32
40
  const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
33
41
  const concatted = decorateMiddleware((options, input, output, ...rest) => {
34
- const next = async (nextOptions) => {
35
- return mapped({ ...options, context: mergeContext(nextOptions.context, options.context) }, input, output, ...rest);
42
+ const next = async (...[nextOptions]) => {
43
+ return mapped({ ...options, context: { ...nextOptions?.context, ...options.context } }, input, output, ...rest);
36
44
  };
37
45
  const merged = middleware({ ...options, next }, input, output, ...rest);
38
46
  return merged;
@@ -44,58 +52,82 @@ function decorateMiddleware(middleware) {
44
52
 
45
53
  // src/procedure-decorated.ts
46
54
  import { DecoratedContractProcedure } from "@orpc/contract";
47
- function decorateProcedure(procedure) {
48
- const caller = createProcedureClient({
49
- procedure,
50
- context: void 0
51
- });
52
- const decorated = caller;
53
- decorated["~type"] = procedure["~type"];
54
- decorated["~orpc"] = procedure["~orpc"];
55
- decorated.prefix = (prefix) => {
56
- return decorateProcedure(new Procedure({
57
- ...procedure["~orpc"],
58
- contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).prefix(prefix)
59
- }));
60
- };
61
- decorated.route = (route) => {
62
- return decorateProcedure(new Procedure({
63
- ...procedure["~orpc"],
64
- contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).route(route)
65
- }));
66
- };
67
- decorated.use = (middleware, mapInput) => {
55
+ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
56
+ static decorate(procedure) {
57
+ if (procedure instanceof _DecoratedProcedure) {
58
+ return procedure;
59
+ }
60
+ return new _DecoratedProcedure(procedure["~orpc"]);
61
+ }
62
+ prefix(prefix) {
63
+ return new _DecoratedProcedure({
64
+ ...this["~orpc"],
65
+ contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).prefix(prefix)
66
+ });
67
+ }
68
+ route(route) {
69
+ return new _DecoratedProcedure({
70
+ ...this["~orpc"],
71
+ contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).route(route)
72
+ });
73
+ }
74
+ errors(errors) {
75
+ return new _DecoratedProcedure({
76
+ ...this["~orpc"],
77
+ contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).errors(errors)
78
+ });
79
+ }
80
+ use(middleware, mapInput) {
68
81
  const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
69
- return decorateProcedure(new Procedure({
70
- ...procedure["~orpc"],
71
- middlewares: [...procedure["~orpc"].middlewares ?? [], middleware_]
72
- }));
73
- };
74
- decorated.unshiftTag = (...tags) => {
75
- return decorateProcedure(new Procedure({
76
- ...procedure["~orpc"],
77
- contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).unshiftTag(...tags)
78
- }));
79
- };
80
- decorated.unshiftMiddleware = (...middlewares) => {
81
- if (procedure["~orpc"].middlewares?.length) {
82
+ return new _DecoratedProcedure({
83
+ ...this["~orpc"],
84
+ middlewares: [...this["~orpc"].middlewares, middleware_]
85
+ });
86
+ }
87
+ unshiftTag(...tags) {
88
+ return new _DecoratedProcedure({
89
+ ...this["~orpc"],
90
+ contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).unshiftTag(...tags)
91
+ });
92
+ }
93
+ unshiftMiddleware(...middlewares) {
94
+ const castedMiddlewares = middlewares;
95
+ if (this["~orpc"].middlewares.length) {
82
96
  let min = 0;
83
- for (let i = 0; i < procedure["~orpc"].middlewares.length; i++) {
84
- const index = middlewares.indexOf(procedure["~orpc"].middlewares[i], min);
97
+ for (let i = 0; i < this["~orpc"].middlewares.length; i++) {
98
+ const index = castedMiddlewares.indexOf(this["~orpc"].middlewares[i], min);
85
99
  if (index === -1) {
86
- middlewares.push(...procedure["~orpc"].middlewares.slice(i));
100
+ castedMiddlewares.push(...this["~orpc"].middlewares.slice(i));
87
101
  break;
88
102
  }
89
103
  min = index + 1;
90
104
  }
91
105
  }
92
- return decorateProcedure(new Procedure({
93
- ...procedure["~orpc"],
94
- middlewares
95
- }));
96
- };
97
- return decorated;
98
- }
106
+ const numNewMiddlewares = castedMiddlewares.length - this["~orpc"].middlewares.length;
107
+ const decorated = new _DecoratedProcedure({
108
+ ...this["~orpc"],
109
+ inputValidationIndex: this["~orpc"].inputValidationIndex + numNewMiddlewares,
110
+ outputValidationIndex: this["~orpc"].outputValidationIndex + numNewMiddlewares,
111
+ middlewares: castedMiddlewares
112
+ });
113
+ return decorated;
114
+ }
115
+ /**
116
+ * Make this procedure callable (works like a function while still being a procedure).
117
+ */
118
+ callable(...rest) {
119
+ return Object.assign(createProcedureClient(this, ...rest), {
120
+ "~type": "Procedure",
121
+ "~orpc": this["~orpc"]
122
+ });
123
+ }
124
+ /**
125
+ * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
126
+ */
127
+ actionable(...rest) {
128
+ return this.callable(...rest);
129
+ }
130
+ };
99
131
 
100
132
  // src/procedure-implementer.ts
101
133
  var ProcedureImplementer = class _ProcedureImplementer {
@@ -108,15 +140,146 @@ var ProcedureImplementer = class _ProcedureImplementer {
108
140
  const mappedMiddleware = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
109
141
  return new _ProcedureImplementer({
110
142
  ...this["~orpc"],
111
- middlewares: [...this["~orpc"].middlewares ?? [], mappedMiddleware]
143
+ middlewares: [...this["~orpc"].middlewares, mappedMiddleware]
112
144
  });
113
145
  }
114
146
  handler(handler) {
115
- return decorateProcedure(new Procedure({
116
- middlewares: this["~orpc"].middlewares,
147
+ return new DecoratedProcedure({
148
+ ...this["~orpc"],
149
+ handler
150
+ });
151
+ }
152
+ };
153
+
154
+ // src/procedure-builder-with-input.ts
155
+ var ProcedureBuilderWithInput = class _ProcedureBuilderWithInput {
156
+ "~type" = "ProcedureBuilderWithInput";
157
+ "~orpc";
158
+ constructor(def) {
159
+ this["~orpc"] = def;
160
+ }
161
+ errors(errors) {
162
+ return new _ProcedureBuilderWithInput({
163
+ ...this["~orpc"],
164
+ contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).errors(errors)
165
+ });
166
+ }
167
+ route(route) {
168
+ return new _ProcedureBuilderWithInput({
169
+ ...this["~orpc"],
170
+ contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).route(route)
171
+ });
172
+ }
173
+ use(middleware, mapInput) {
174
+ const maybeWithMapInput = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
175
+ return new _ProcedureBuilderWithInput({
176
+ ...this["~orpc"],
177
+ outputValidationIndex: this["~orpc"].outputValidationIndex + 1,
178
+ middlewares: [...this["~orpc"].middlewares, maybeWithMapInput]
179
+ });
180
+ }
181
+ output(schema, example) {
182
+ return new ProcedureImplementer({
183
+ ...this["~orpc"],
184
+ contract: new ContractProcedureBuilderWithInput(this["~orpc"].contract["~orpc"]).output(schema, example)
185
+ });
186
+ }
187
+ handler(handler) {
188
+ return new DecoratedProcedure({
189
+ ...this["~orpc"],
190
+ handler
191
+ });
192
+ }
193
+ };
194
+
195
+ // src/procedure-builder-with-output.ts
196
+ import { ContractProcedureBuilderWithOutput, DecoratedContractProcedure as DecoratedContractProcedure3 } from "@orpc/contract";
197
+ var ProcedureBuilderWithOutput = class _ProcedureBuilderWithOutput {
198
+ "~type" = "ProcedureBuilderWithOutput";
199
+ "~orpc";
200
+ constructor(def) {
201
+ this["~orpc"] = def;
202
+ }
203
+ errors(errors) {
204
+ return new _ProcedureBuilderWithOutput({
205
+ ...this["~orpc"],
206
+ contract: DecoratedContractProcedure3.decorate(this["~orpc"].contract).errors(errors)
207
+ });
208
+ }
209
+ route(route) {
210
+ return new _ProcedureBuilderWithOutput({
211
+ ...this["~orpc"],
212
+ contract: DecoratedContractProcedure3.decorate(this["~orpc"].contract).route(route)
213
+ });
214
+ }
215
+ use(middleware) {
216
+ const builder = new _ProcedureBuilderWithOutput({
117
217
  contract: this["~orpc"].contract,
218
+ outputValidationIndex: this["~orpc"].outputValidationIndex,
219
+ inputValidationIndex: this["~orpc"].inputValidationIndex + 1,
220
+ middlewares: [...this["~orpc"].middlewares, middleware]
221
+ });
222
+ return builder;
223
+ }
224
+ input(schema, example) {
225
+ return new ProcedureImplementer({
226
+ ...this["~orpc"],
227
+ contract: new ContractProcedureBuilderWithOutput(this["~orpc"].contract["~orpc"]).input(schema, example)
228
+ });
229
+ }
230
+ handler(handler) {
231
+ return new DecoratedProcedure({
232
+ ...this["~orpc"],
118
233
  handler
119
- }));
234
+ });
235
+ }
236
+ };
237
+
238
+ // src/procedure-builder.ts
239
+ var ProcedureBuilder = class _ProcedureBuilder {
240
+ "~type" = "ProcedureBuilder";
241
+ "~orpc";
242
+ constructor(def) {
243
+ this["~orpc"] = def;
244
+ }
245
+ errors(errors) {
246
+ return new _ProcedureBuilder({
247
+ ...this["~orpc"],
248
+ contract: DecoratedContractProcedure4.decorate(this["~orpc"].contract).errors(errors)
249
+ });
250
+ }
251
+ route(route) {
252
+ return new _ProcedureBuilder({
253
+ ...this["~orpc"],
254
+ contract: DecoratedContractProcedure4.decorate(this["~orpc"].contract).route(route)
255
+ });
256
+ }
257
+ use(middleware) {
258
+ const builder = new _ProcedureBuilder({
259
+ contract: this["~orpc"].contract,
260
+ inputValidationIndex: this["~orpc"].inputValidationIndex + 1,
261
+ outputValidationIndex: this["~orpc"].outputValidationIndex + 1,
262
+ middlewares: [...this["~orpc"].middlewares, middleware]
263
+ });
264
+ return builder;
265
+ }
266
+ input(schema, example) {
267
+ return new ProcedureBuilderWithInput({
268
+ ...this["~orpc"],
269
+ contract: new ContractProcedureBuilder(this["~orpc"].contract["~orpc"]).input(schema, example)
270
+ });
271
+ }
272
+ output(schema, example) {
273
+ return new ProcedureBuilderWithOutput({
274
+ ...this["~orpc"],
275
+ contract: new ContractProcedureBuilder(this["~orpc"].contract["~orpc"]).output(schema, example)
276
+ });
277
+ }
278
+ handler(handler) {
279
+ return new DecoratedProcedure({
280
+ ...this["~orpc"],
281
+ handler
282
+ });
120
283
  }
121
284
  };
122
285
 
@@ -154,31 +317,10 @@ function getLazyRouterPrefix(obj) {
154
317
  return obj[LAZY_ROUTER_PREFIX_SYMBOL];
155
318
  }
156
319
 
157
- // src/lazy-utils.ts
158
- function createLazyProcedureFormAnyLazy(lazied) {
159
- const lazyProcedure = lazy(async () => {
160
- const { default: maybeProcedure } = await unlazy(flatLazy(lazied));
161
- if (!isProcedure(maybeProcedure)) {
162
- throw new Error(`
163
- Expected a lazy<procedure> but got lazy<unknown>.
164
- This should be caught by TypeScript compilation.
165
- Please report this issue if this makes you feel uncomfortable.
166
- `);
167
- }
168
- return { default: maybeProcedure };
169
- });
170
- return lazyProcedure;
171
- }
172
-
173
320
  // src/lazy-decorated.ts
174
321
  function decorateLazy(lazied) {
175
322
  const flattenLazy = flatLazy(lazied);
176
- const procedureProcedureClient = createProcedureClient({
177
- procedure: createLazyProcedureFormAnyLazy(flattenLazy),
178
- context: void 0
179
- });
180
- Object.assign(procedureProcedureClient, flattenLazy);
181
- const recursive = new Proxy(procedureProcedureClient, {
323
+ const recursive = new Proxy(flattenLazy, {
182
324
  get(target, key) {
183
325
  if (typeof key !== "string") {
184
326
  return Reflect.get(target, key);
@@ -215,12 +357,24 @@ var RouterBuilder = class _RouterBuilder {
215
357
  tags: [...this["~orpc"].tags ?? [], ...tags]
216
358
  });
217
359
  }
218
- use(middleware) {
360
+ errors(errors) {
219
361
  return new _RouterBuilder({
220
362
  ...this["~orpc"],
221
- middlewares: [...this["~orpc"].middlewares ?? [], middleware]
363
+ errorMap: {
364
+ ...this["~orpc"].errorMap,
365
+ ...errors
366
+ }
222
367
  });
223
368
  }
369
+ use(middleware) {
370
+ const builder = new _RouterBuilder({
371
+ tags: this["~orpc"].tags,
372
+ prefix: this["~orpc"].prefix,
373
+ errorMap: this["~orpc"].errorMap,
374
+ middlewares: [...this["~orpc"].middlewares, middleware]
375
+ });
376
+ return builder;
377
+ }
224
378
  router(router) {
225
379
  const adapted = adapt(router, this["~orpc"]);
226
380
  return adapted;
@@ -245,7 +399,7 @@ function adapt(item, options) {
245
399
  return adaptedLazy;
246
400
  }
247
401
  if (isProcedure(item)) {
248
- let decorated = decorateProcedure(item);
402
+ let decorated = DecoratedProcedure.decorate(item);
249
403
  if (options.tags?.length) {
250
404
  decorated = decorated.unshiftTag(...options.tags);
251
405
  }
@@ -255,6 +409,9 @@ function adapt(item, options) {
255
409
  if (options.middlewares?.length) {
256
410
  decorated = decorated.unshiftMiddleware(...options.middlewares);
257
411
  }
412
+ if (Object.keys(options.errorMap).length) {
413
+ decorated = decorated.errors(options.errorMap);
414
+ }
258
415
  return decorated;
259
416
  }
260
417
  const adapted = {};
@@ -264,6 +421,246 @@ function adapt(item, options) {
264
421
  return adapted;
265
422
  }
266
423
 
424
+ // src/builder-with-errors-middlewares.ts
425
+ var BuilderWithErrorsMiddlewares = class _BuilderWithErrorsMiddlewares {
426
+ "~type" = "BuilderWithErrorsMiddlewares";
427
+ "~orpc";
428
+ constructor(def) {
429
+ this["~orpc"] = def;
430
+ }
431
+ errors(errors) {
432
+ return new _BuilderWithErrorsMiddlewares({
433
+ ...this["~orpc"],
434
+ errorMap: {
435
+ ...this["~orpc"].errorMap,
436
+ ...errors
437
+ }
438
+ });
439
+ }
440
+ use(middleware) {
441
+ const builder = new _BuilderWithErrorsMiddlewares({
442
+ config: this["~orpc"].config,
443
+ errorMap: this["~orpc"].errorMap,
444
+ inputValidationIndex: this["~orpc"].inputValidationIndex + 1,
445
+ outputValidationIndex: this["~orpc"].outputValidationIndex + 1,
446
+ middlewares: [...this["~orpc"].middlewares, middleware]
447
+ });
448
+ return builder;
449
+ }
450
+ route(route) {
451
+ return new ProcedureBuilder({
452
+ ...this["~orpc"],
453
+ contract: new ContractProcedure({
454
+ route: {
455
+ ...this["~orpc"].config.initialRoute,
456
+ ...route
457
+ },
458
+ InputSchema: void 0,
459
+ OutputSchema: void 0,
460
+ errorMap: this["~orpc"].errorMap
461
+ })
462
+ });
463
+ }
464
+ input(schema, example) {
465
+ return new ProcedureBuilderWithInput({
466
+ ...this["~orpc"],
467
+ contract: new ContractProcedure({
468
+ route: this["~orpc"].config.initialRoute,
469
+ OutputSchema: void 0,
470
+ InputSchema: schema,
471
+ inputExample: example,
472
+ errorMap: this["~orpc"].errorMap
473
+ })
474
+ });
475
+ }
476
+ output(schema, example) {
477
+ return new ProcedureBuilderWithOutput({
478
+ ...this["~orpc"],
479
+ contract: new ContractProcedure({
480
+ route: this["~orpc"].config.initialRoute,
481
+ InputSchema: void 0,
482
+ OutputSchema: schema,
483
+ outputExample: example,
484
+ errorMap: this["~orpc"].errorMap
485
+ })
486
+ });
487
+ }
488
+ handler(handler) {
489
+ return new DecoratedProcedure({
490
+ ...this["~orpc"],
491
+ contract: new ContractProcedure({
492
+ route: this["~orpc"].config.initialRoute,
493
+ InputSchema: void 0,
494
+ OutputSchema: void 0,
495
+ errorMap: this["~orpc"].errorMap
496
+ }),
497
+ handler
498
+ });
499
+ }
500
+ prefix(prefix) {
501
+ return new RouterBuilder({
502
+ ...this["~orpc"],
503
+ prefix
504
+ });
505
+ }
506
+ tag(...tags) {
507
+ return new RouterBuilder({
508
+ ...this["~orpc"],
509
+ tags
510
+ });
511
+ }
512
+ router(router) {
513
+ return new RouterBuilder(this["~orpc"]).router(router);
514
+ }
515
+ lazy(loader) {
516
+ return new RouterBuilder(this["~orpc"]).lazy(loader);
517
+ }
518
+ };
519
+
520
+ // src/config.ts
521
+ var DEFAULT_CONFIG = {
522
+ initialInputValidationIndex: 0,
523
+ initialOutputValidationIndex: 0
524
+ };
525
+ function fallbackConfig(key, value) {
526
+ if (value === void 0) {
527
+ return DEFAULT_CONFIG[key];
528
+ }
529
+ return value;
530
+ }
531
+
532
+ // src/builder-with-errors.ts
533
+ var BuilderWithErrors = class _BuilderWithErrors {
534
+ "~type" = "BuilderWithErrors";
535
+ "~orpc";
536
+ constructor(def) {
537
+ this["~orpc"] = def;
538
+ }
539
+ config(config) {
540
+ return new _BuilderWithErrors({
541
+ ...this["~orpc"],
542
+ config: {
543
+ ...this["~orpc"].config,
544
+ ...config
545
+ }
546
+ });
547
+ }
548
+ context() {
549
+ return this;
550
+ }
551
+ errors(errors) {
552
+ return new _BuilderWithErrors({
553
+ ...this["~orpc"],
554
+ errorMap: {
555
+ ...this["~orpc"].errorMap,
556
+ ...errors
557
+ }
558
+ });
559
+ }
560
+ middleware(middleware) {
561
+ return decorateMiddleware(middleware);
562
+ }
563
+ use(middleware) {
564
+ return new BuilderWithErrorsMiddlewares({
565
+ ...this["~orpc"],
566
+ inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex) + 1,
567
+ outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex) + 1,
568
+ middlewares: [middleware]
569
+ });
570
+ }
571
+ route(route) {
572
+ return new ProcedureBuilder({
573
+ middlewares: [],
574
+ inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
575
+ outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex),
576
+ contract: new ContractProcedure2({
577
+ route: {
578
+ ...this["~orpc"].config.initialRoute,
579
+ ...route
580
+ },
581
+ InputSchema: void 0,
582
+ OutputSchema: void 0,
583
+ errorMap: this["~orpc"].errorMap
584
+ })
585
+ });
586
+ }
587
+ input(schema, example) {
588
+ return new ProcedureBuilderWithInput({
589
+ middlewares: [],
590
+ inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
591
+ outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex),
592
+ contract: new ContractProcedure2({
593
+ route: this["~orpc"].config.initialRoute,
594
+ OutputSchema: void 0,
595
+ InputSchema: schema,
596
+ inputExample: example,
597
+ errorMap: this["~orpc"].errorMap
598
+ })
599
+ });
600
+ }
601
+ output(schema, example) {
602
+ return new ProcedureBuilderWithOutput({
603
+ middlewares: [],
604
+ inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
605
+ outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex),
606
+ contract: new ContractProcedure2({
607
+ route: this["~orpc"].config.initialRoute,
608
+ InputSchema: void 0,
609
+ OutputSchema: schema,
610
+ outputExample: example,
611
+ errorMap: this["~orpc"].errorMap
612
+ })
613
+ });
614
+ }
615
+ handler(handler) {
616
+ return new DecoratedProcedure({
617
+ middlewares: [],
618
+ inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
619
+ outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex),
620
+ contract: new ContractProcedure2({
621
+ route: this["~orpc"].config.initialRoute,
622
+ InputSchema: void 0,
623
+ OutputSchema: void 0,
624
+ errorMap: this["~orpc"].errorMap
625
+ }),
626
+ handler
627
+ });
628
+ }
629
+ prefix(prefix) {
630
+ return new RouterBuilder({
631
+ middlewares: [],
632
+ errorMap: this["~orpc"].errorMap,
633
+ prefix
634
+ });
635
+ }
636
+ tag(...tags) {
637
+ return new RouterBuilder({
638
+ middlewares: [],
639
+ errorMap: this["~orpc"].errorMap,
640
+ tags
641
+ });
642
+ }
643
+ router(router) {
644
+ return new RouterBuilder({
645
+ middlewares: [],
646
+ ...this["~orpc"]
647
+ }).router(router);
648
+ }
649
+ lazy(loader) {
650
+ return new RouterBuilder({
651
+ middlewares: [],
652
+ ...this["~orpc"]
653
+ }).lazy(loader);
654
+ }
655
+ };
656
+
657
+ // src/builder-with-middlewares.ts
658
+ import { ContractProcedure as ContractProcedure3 } from "@orpc/contract";
659
+
660
+ // src/implementer-chainable.ts
661
+ import { isContractProcedure } from "@orpc/contract";
662
+ import { createCallableObject } from "@orpc/shared";
663
+
267
664
  // src/router-implementer.ts
268
665
  var RouterImplementer = class _RouterImplementer {
269
666
  "~type" = "RouterImplementer";
@@ -272,37 +669,49 @@ var RouterImplementer = class _RouterImplementer {
272
669
  this["~orpc"] = def;
273
670
  }
274
671
  use(middleware) {
275
- return new _RouterImplementer({
276
- ...this["~orpc"],
277
- middlewares: [...this["~orpc"].middlewares ?? [], middleware]
672
+ const builder = new _RouterImplementer({
673
+ contract: this["~orpc"].contract,
674
+ middlewares: [...this["~orpc"].middlewares, middleware]
278
675
  });
676
+ return builder;
279
677
  }
280
678
  router(router) {
281
- const adapted = new RouterBuilder(this["~orpc"]).router(router);
679
+ const adapted = new RouterBuilder({
680
+ ...this["~orpc"],
681
+ errorMap: {}
682
+ }).router(router);
282
683
  const contracted = setRouterContract(adapted, this["~orpc"].contract);
283
684
  return contracted;
284
685
  }
285
686
  lazy(loader) {
286
- const adapted = new RouterBuilder(this["~orpc"]).lazy(loader);
687
+ const adapted = new RouterBuilder({
688
+ ...this["~orpc"],
689
+ errorMap: {}
690
+ }).lazy(loader);
287
691
  const contracted = setRouterContract(adapted, this["~orpc"].contract);
288
692
  return contracted;
289
693
  }
290
694
  };
291
695
 
292
696
  // src/implementer-chainable.ts
293
- function createChainableImplementer(contract, middlewares) {
697
+ function createChainableImplementer(contract, options) {
294
698
  if (isContractProcedure(contract)) {
295
699
  const implementer = new ProcedureImplementer({
296
700
  contract,
297
- middlewares
701
+ middlewares: options.middlewares,
702
+ inputValidationIndex: options.inputValidationIndex,
703
+ outputValidationIndex: options.outputValidationIndex
298
704
  });
299
705
  return implementer;
300
706
  }
301
707
  const chainable = {};
302
708
  for (const key in contract) {
303
- chainable[key] = createChainableImplementer(contract[key], middlewares);
709
+ chainable[key] = createChainableImplementer(contract[key], options);
304
710
  }
305
- const routerImplementer = new RouterImplementer({ contract, middlewares });
711
+ const routerImplementer = new RouterImplementer({
712
+ contract,
713
+ middlewares: options.middlewares
714
+ });
306
715
  const merged = new Proxy(chainable, {
307
716
  get(target, key) {
308
717
  const next = Reflect.get(target, key);
@@ -319,58 +728,106 @@ function createChainableImplementer(contract, middlewares) {
319
728
  return merged;
320
729
  }
321
730
 
322
- // src/procedure-builder.ts
323
- import {
324
- DecoratedContractProcedure as DecoratedContractProcedure2
325
- } from "@orpc/contract";
326
- var ProcedureBuilder = class _ProcedureBuilder {
327
- "~type" = "ProcedureBuilder";
731
+ // src/builder-with-middlewares.ts
732
+ var BuilderWithMiddlewares = class _BuilderWithMiddlewares {
733
+ "~type" = "BuilderHasMiddlewares";
328
734
  "~orpc";
329
735
  constructor(def) {
330
736
  this["~orpc"] = def;
331
737
  }
738
+ use(middleware) {
739
+ const builder = new _BuilderWithMiddlewares({
740
+ config: this["~orpc"].config,
741
+ inputValidationIndex: this["~orpc"].inputValidationIndex + 1,
742
+ outputValidationIndex: this["~orpc"].outputValidationIndex + 1,
743
+ middlewares: [...this["~orpc"].middlewares, middleware]
744
+ });
745
+ return builder;
746
+ }
747
+ errors(errors) {
748
+ return new BuilderWithErrorsMiddlewares({
749
+ ...this["~orpc"],
750
+ errorMap: errors
751
+ });
752
+ }
332
753
  route(route) {
333
- return new _ProcedureBuilder({
754
+ return new ProcedureBuilder({
334
755
  ...this["~orpc"],
335
- contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).route(route)
756
+ contract: new ContractProcedure3({
757
+ route: {
758
+ ...this["~orpc"].config.initialRoute,
759
+ ...route
760
+ },
761
+ InputSchema: void 0,
762
+ OutputSchema: void 0,
763
+ errorMap: {}
764
+ })
336
765
  });
337
766
  }
338
767
  input(schema, example) {
339
- return new _ProcedureBuilder({
768
+ return new ProcedureBuilderWithInput({
340
769
  ...this["~orpc"],
341
- contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).input(schema, example)
770
+ contract: new ContractProcedure3({
771
+ route: this["~orpc"].config.initialRoute,
772
+ OutputSchema: void 0,
773
+ InputSchema: schema,
774
+ inputExample: example,
775
+ errorMap: {}
776
+ })
342
777
  });
343
778
  }
344
779
  output(schema, example) {
345
- return new _ProcedureBuilder({
780
+ return new ProcedureBuilderWithOutput({
346
781
  ...this["~orpc"],
347
- contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).output(schema, example)
782
+ contract: new ContractProcedure3({
783
+ route: this["~orpc"].config.initialRoute,
784
+ InputSchema: void 0,
785
+ OutputSchema: schema,
786
+ outputExample: example,
787
+ errorMap: {}
788
+ })
348
789
  });
349
790
  }
350
- errors(errors) {
351
- return new _ProcedureBuilder({
791
+ handler(handler) {
792
+ return new DecoratedProcedure({
352
793
  ...this["~orpc"],
353
- contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).errors(errors)
794
+ contract: new ContractProcedure3({
795
+ route: this["~orpc"].config.initialRoute,
796
+ InputSchema: void 0,
797
+ OutputSchema: void 0,
798
+ errorMap: {}
799
+ }),
800
+ handler
354
801
  });
355
802
  }
356
- use(middleware, mapInput) {
357
- if (!mapInput) {
358
- return new ProcedureImplementer({
359
- contract: this["~orpc"].contract,
360
- middlewares: this["~orpc"].middlewares
361
- }).use(middleware);
362
- }
363
- return new ProcedureImplementer({
364
- contract: this["~orpc"].contract,
365
- middlewares: this["~orpc"].middlewares
366
- }).use(middleware, mapInput);
803
+ prefix(prefix) {
804
+ return new RouterBuilder({
805
+ middlewares: this["~orpc"].middlewares,
806
+ errorMap: {},
807
+ prefix
808
+ });
367
809
  }
368
- handler(handler) {
369
- return decorateProcedure(new Procedure({
810
+ tag(...tags) {
811
+ return new RouterBuilder({
370
812
  middlewares: this["~orpc"].middlewares,
371
- contract: this["~orpc"].contract,
372
- handler
373
- }));
813
+ errorMap: {},
814
+ tags
815
+ });
816
+ }
817
+ router(router) {
818
+ return new RouterBuilder({
819
+ errorMap: {},
820
+ ...this["~orpc"]
821
+ }).router(router);
822
+ }
823
+ lazy(loader) {
824
+ return new RouterBuilder({
825
+ errorMap: {},
826
+ ...this["~orpc"]
827
+ }).lazy(loader);
828
+ }
829
+ contract(contract) {
830
+ return createChainableImplementer(contract, this["~orpc"]);
374
831
  }
375
832
  };
376
833
 
@@ -381,125 +838,171 @@ var Builder = class _Builder {
381
838
  constructor(def) {
382
839
  this["~orpc"] = def;
383
840
  }
384
- context() {
385
- return new _Builder({});
386
- }
387
- use(middleware) {
841
+ config(config) {
388
842
  return new _Builder({
389
843
  ...this["~orpc"],
390
- middlewares: [...this["~orpc"].middlewares ?? [], middleware]
844
+ config: {
845
+ ...this["~orpc"].config,
846
+ ...config
847
+ }
391
848
  });
392
849
  }
850
+ context() {
851
+ return this;
852
+ }
393
853
  middleware(middleware) {
394
854
  return decorateMiddleware(middleware);
395
855
  }
856
+ errors(errors) {
857
+ return new BuilderWithErrors({
858
+ ...this["~orpc"],
859
+ errorMap: errors
860
+ });
861
+ }
862
+ use(middleware) {
863
+ const builder = new BuilderWithMiddlewares({
864
+ ...this["~orpc"],
865
+ inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex) + 1,
866
+ outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex) + 1,
867
+ middlewares: [middleware]
868
+ // FIXME: I believe we can remove `as any` here
869
+ });
870
+ return builder;
871
+ }
396
872
  route(route) {
397
873
  return new ProcedureBuilder({
398
- middlewares: this["~orpc"].middlewares,
399
- contract: new ContractProcedure({
400
- route,
874
+ middlewares: [],
875
+ inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
876
+ outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex),
877
+ contract: new ContractProcedure4({
878
+ route: {
879
+ ...this["~orpc"].config.initialRoute,
880
+ ...route
881
+ },
401
882
  InputSchema: void 0,
402
883
  OutputSchema: void 0,
403
- errorMap: void 0
884
+ errorMap: {}
404
885
  })
405
886
  });
406
887
  }
407
888
  input(schema, example) {
408
- return new ProcedureBuilder({
409
- middlewares: this["~orpc"].middlewares,
410
- contract: new ContractProcedure({
889
+ return new ProcedureBuilderWithInput({
890
+ middlewares: [],
891
+ inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
892
+ outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex),
893
+ contract: new ContractProcedure4({
894
+ route: this["~orpc"].config.initialRoute,
411
895
  OutputSchema: void 0,
412
896
  InputSchema: schema,
413
897
  inputExample: example,
414
- errorMap: void 0
898
+ errorMap: {}
415
899
  })
416
900
  });
417
901
  }
418
902
  output(schema, example) {
419
- return new ProcedureBuilder({
420
- middlewares: this["~orpc"].middlewares,
421
- contract: new ContractProcedure({
903
+ return new ProcedureBuilderWithOutput({
904
+ middlewares: [],
905
+ inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
906
+ outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex),
907
+ contract: new ContractProcedure4({
908
+ route: this["~orpc"].config.initialRoute,
422
909
  InputSchema: void 0,
423
910
  OutputSchema: schema,
424
911
  outputExample: example,
425
- errorMap: void 0
426
- })
427
- });
428
- }
429
- errors(errors) {
430
- return new ProcedureBuilder({
431
- middlewares: this["~orpc"].middlewares,
432
- contract: new ContractProcedure({
433
- InputSchema: void 0,
434
- OutputSchema: void 0,
435
- errorMap: errors
912
+ errorMap: {}
436
913
  })
437
914
  });
438
915
  }
439
916
  handler(handler) {
440
- return decorateProcedure(new Procedure({
441
- middlewares: this["~orpc"].middlewares,
442
- contract: new ContractProcedure({
917
+ return new DecoratedProcedure({
918
+ middlewares: [],
919
+ inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
920
+ outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex),
921
+ contract: new ContractProcedure4({
922
+ route: this["~orpc"].config.initialRoute,
443
923
  InputSchema: void 0,
444
924
  OutputSchema: void 0,
445
- errorMap: void 0
925
+ errorMap: {}
446
926
  }),
447
927
  handler
448
- }));
928
+ });
449
929
  }
450
930
  prefix(prefix) {
451
931
  return new RouterBuilder({
452
- middlewares: this["~orpc"].middlewares,
932
+ middlewares: [],
933
+ errorMap: {},
453
934
  prefix
454
935
  });
455
936
  }
456
937
  tag(...tags) {
457
938
  return new RouterBuilder({
458
- middlewares: this["~orpc"].middlewares,
939
+ middlewares: [],
940
+ errorMap: {},
459
941
  tags
460
942
  });
461
943
  }
462
944
  router(router) {
463
- return new RouterBuilder(this["~orpc"]).router(router);
945
+ return new RouterBuilder({
946
+ middlewares: [],
947
+ errorMap: []
948
+ }).router(router);
464
949
  }
465
950
  lazy(loader) {
466
- return new RouterBuilder(this["~orpc"]).lazy(loader);
951
+ return new RouterBuilder({
952
+ middlewares: [],
953
+ errorMap: {}
954
+ }).lazy(loader);
467
955
  }
468
956
  contract(contract) {
469
- return createChainableImplementer(contract, this["~orpc"].middlewares);
957
+ return createChainableImplementer(contract, {
958
+ middlewares: [],
959
+ inputValidationIndex: 0,
960
+ outputValidationIndex: 0
961
+ });
470
962
  }
471
963
  };
472
964
 
965
+ // src/procedure-utils.ts
966
+ function call(procedure, input, ...rest) {
967
+ return createProcedureClient(procedure, ...rest)(input);
968
+ }
969
+
970
+ // src/lazy-utils.ts
971
+ function createLazyProcedureFormAnyLazy(lazied) {
972
+ const lazyProcedure = lazy(async () => {
973
+ const { default: maybeProcedure } = await unlazy(flatLazy(lazied));
974
+ if (!isProcedure(maybeProcedure)) {
975
+ throw new Error(`
976
+ Expected a lazy<procedure> but got lazy<unknown>.
977
+ This should be caught by TypeScript compilation.
978
+ Please report this issue if this makes you feel uncomfortable.
979
+ `);
980
+ }
981
+ return { default: maybeProcedure };
982
+ });
983
+ return lazyProcedure;
984
+ }
985
+
473
986
  // src/router-client.ts
474
- function createRouterClient(options) {
475
- if (isProcedure(options.router)) {
476
- const caller = createProcedureClient({
477
- ...options,
478
- procedure: options.router,
479
- context: options.context,
480
- path: options.path
481
- });
987
+ function createRouterClient(router, ...rest) {
988
+ if (isProcedure(router)) {
989
+ const caller = createProcedureClient(router, ...rest);
482
990
  return caller;
483
991
  }
484
- const procedureCaller = isLazy(options.router) ? createProcedureClient({
485
- ...options,
486
- procedure: createLazyProcedureFormAnyLazy(options.router),
487
- context: options.context,
488
- path: options.path
489
- }) : {};
992
+ const procedureCaller = isLazy(router) ? createProcedureClient(createLazyProcedureFormAnyLazy(router), ...rest) : {};
490
993
  const recursive = new Proxy(procedureCaller, {
491
994
  get(target, key) {
492
995
  if (typeof key !== "string") {
493
996
  return Reflect.get(target, key);
494
997
  }
495
- const next = getRouterChild(options.router, key);
998
+ const next = getRouterChild(router, key);
496
999
  if (!next) {
497
1000
  return Reflect.get(target, key);
498
1001
  }
499
- return createRouterClient({
1002
+ const [options] = rest;
1003
+ return createRouterClient(next, {
500
1004
  ...options,
501
- router: next,
502
- path: [...options.path ?? [], key]
1005
+ path: [...options?.path ?? [], key]
503
1006
  });
504
1007
  }
505
1008
  });
@@ -507,10 +1010,13 @@ function createRouterClient(options) {
507
1010
  }
508
1011
 
509
1012
  // src/index.ts
510
- import { configGlobal, fallbackToGlobalConfig, isDefinedError, ORPCError, safe } from "@orpc/contract";
511
- var os = new Builder({});
1013
+ import { isDefinedError, ORPCError, safe, type } from "@orpc/contract";
1014
+ var os = new Builder({
1015
+ config: {}
1016
+ });
512
1017
  export {
513
1018
  Builder,
1019
+ DecoratedProcedure,
514
1020
  LAZY_LOADER_SYMBOL,
515
1021
  ORPCError,
516
1022
  Procedure,
@@ -518,16 +1024,15 @@ export {
518
1024
  ProcedureImplementer,
519
1025
  RouterBuilder,
520
1026
  RouterImplementer,
521
- configGlobal,
1027
+ call,
522
1028
  createChainableImplementer,
523
1029
  createORPCErrorConstructorMap,
524
1030
  createProcedureClient,
525
1031
  createRouterClient,
526
1032
  decorateLazy,
527
1033
  decorateMiddleware,
528
- decorateProcedure,
529
1034
  deepSetLazyRouterPrefix,
530
- fallbackToGlobalConfig,
1035
+ fallbackConfig,
531
1036
  flatLazy,
532
1037
  getLazyRouterPrefix,
533
1038
  getRouterChild,
@@ -536,10 +1041,11 @@ export {
536
1041
  isLazy,
537
1042
  isProcedure,
538
1043
  lazy,
539
- mergeContext,
1044
+ middlewareOutputFn,
540
1045
  os,
541
1046
  safe,
542
1047
  setRouterContract,
1048
+ type,
543
1049
  unlazy
544
1050
  };
545
1051
  //# sourceMappingURL=index.js.map