@orpc/server 0.29.0 → 0.31.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
@@ -9,15 +9,24 @@ import {
9
9
  isProcedure,
10
10
  lazy,
11
11
  mergeContext,
12
+ middlewareOutputFn,
12
13
  unlazy
13
- } from "./chunk-XDC42C3C.js";
14
+ } from "./chunk-GK2Z6B6W.js";
14
15
 
15
16
  // src/builder.ts
17
+ import { ContractProcedure as ContractProcedure4 } from "@orpc/contract";
18
+
19
+ // src/builder-with-errors.ts
20
+ import { ContractProcedure as ContractProcedure2 } from "@orpc/contract";
21
+
22
+ // src/builder-with-errors-middlewares.ts
16
23
  import { ContractProcedure } from "@orpc/contract";
17
24
 
18
- // src/implementer-chainable.ts
19
- import { isContractProcedure } from "@orpc/contract";
20
- import { createCallableObject as createCallableObject2 } from "@orpc/shared";
25
+ // src/procedure-builder.ts
26
+ import { ContractProcedureBuilder, DecoratedContractProcedure as DecoratedContractProcedure4 } from "@orpc/contract";
27
+
28
+ // src/procedure-builder-with-input.ts
29
+ import { ContractProcedureBuilderWithInput, DecoratedContractProcedure as DecoratedContractProcedure2 } from "@orpc/contract";
21
30
 
22
31
  // src/middleware-decorated.ts
23
32
  function decorateMiddleware(middleware) {
@@ -44,7 +53,6 @@ function decorateMiddleware(middleware) {
44
53
 
45
54
  // src/procedure-decorated.ts
46
55
  import { DecoratedContractProcedure } from "@orpc/contract";
47
- import { createCallableObject } from "@orpc/shared";
48
56
  var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
49
57
  static decorate(procedure) {
50
58
  if (procedure instanceof _DecoratedProcedure) {
@@ -64,11 +72,17 @@ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
64
72
  contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).route(route)
65
73
  });
66
74
  }
75
+ errors(errors) {
76
+ return new _DecoratedProcedure({
77
+ ...this["~orpc"],
78
+ contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).errors(errors)
79
+ });
80
+ }
67
81
  use(middleware, mapInput) {
68
82
  const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
69
83
  return new _DecoratedProcedure({
70
84
  ...this["~orpc"],
71
- middlewares: [...this["~orpc"].middlewares ?? [], middleware_]
85
+ middlewares: [...this["~orpc"].middlewares, middleware_]
72
86
  });
73
87
  }
74
88
  unshiftTag(...tags) {
@@ -79,7 +93,7 @@ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
79
93
  }
80
94
  unshiftMiddleware(...middlewares) {
81
95
  const castedMiddlewares = middlewares;
82
- if (this["~orpc"].middlewares?.length) {
96
+ if (this["~orpc"].middlewares.length) {
83
97
  let min = 0;
84
98
  for (let i = 0; i < this["~orpc"].middlewares.length; i++) {
85
99
  const index = castedMiddlewares.indexOf(this["~orpc"].middlewares[i], min);
@@ -90,21 +104,25 @@ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
90
104
  min = index + 1;
91
105
  }
92
106
  }
107
+ const numNewMiddlewares = castedMiddlewares.length - this["~orpc"].middlewares.length;
93
108
  return new _DecoratedProcedure({
94
109
  ...this["~orpc"],
110
+ inputValidationIndex: this["~orpc"].inputValidationIndex + numNewMiddlewares,
111
+ outputValidationIndex: this["~orpc"].outputValidationIndex + numNewMiddlewares,
95
112
  middlewares: castedMiddlewares
96
113
  });
97
114
  }
98
115
  /**
99
116
  * Make this procedure callable (works like a function while still being a procedure).
100
- * **Note**: this only takes effect when this method is called at the end of the chain.
101
117
  */
102
118
  callable(...rest) {
103
- return createCallableObject(this, createProcedureClient(this, ...rest));
119
+ return Object.assign(createProcedureClient(this, ...rest), {
120
+ "~type": "Procedure",
121
+ "~orpc": this["~orpc"]
122
+ });
104
123
  }
105
124
  /**
106
125
  * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
107
- * **Note**: this only takes effect when this method is called at the end of the chain.
108
126
  */
109
127
  actionable(...rest) {
110
128
  return this.callable(...rest);
@@ -122,13 +140,141 @@ var ProcedureImplementer = class _ProcedureImplementer {
122
140
  const mappedMiddleware = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
123
141
  return new _ProcedureImplementer({
124
142
  ...this["~orpc"],
125
- middlewares: [...this["~orpc"].middlewares ?? [], mappedMiddleware]
143
+ middlewares: [...this["~orpc"].middlewares, mappedMiddleware]
126
144
  });
127
145
  }
128
146
  handler(handler) {
129
147
  return new DecoratedProcedure({
130
- middlewares: this["~orpc"].middlewares,
131
- contract: this["~orpc"].contract,
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
+ return new _ProcedureBuilderWithOutput({
217
+ ...this["~orpc"],
218
+ inputValidationIndex: this["~orpc"].inputValidationIndex + 1,
219
+ middlewares: [...this["~orpc"].middlewares, middleware]
220
+ });
221
+ }
222
+ input(schema, example) {
223
+ return new ProcedureImplementer({
224
+ ...this["~orpc"],
225
+ contract: new ContractProcedureBuilderWithOutput(this["~orpc"].contract["~orpc"]).input(schema, example)
226
+ });
227
+ }
228
+ handler(handler) {
229
+ return new DecoratedProcedure({
230
+ ...this["~orpc"],
231
+ handler
232
+ });
233
+ }
234
+ };
235
+
236
+ // src/procedure-builder.ts
237
+ var ProcedureBuilder = class _ProcedureBuilder {
238
+ "~type" = "ProcedureBuilder";
239
+ "~orpc";
240
+ constructor(def) {
241
+ this["~orpc"] = def;
242
+ }
243
+ errors(errors) {
244
+ return new _ProcedureBuilder({
245
+ ...this["~orpc"],
246
+ contract: DecoratedContractProcedure4.decorate(this["~orpc"].contract).errors(errors)
247
+ });
248
+ }
249
+ route(route) {
250
+ return new _ProcedureBuilder({
251
+ ...this["~orpc"],
252
+ contract: DecoratedContractProcedure4.decorate(this["~orpc"].contract).route(route)
253
+ });
254
+ }
255
+ use(middleware) {
256
+ return new _ProcedureBuilder({
257
+ ...this["~orpc"],
258
+ inputValidationIndex: this["~orpc"].inputValidationIndex + 1,
259
+ outputValidationIndex: this["~orpc"].outputValidationIndex + 1,
260
+ middlewares: [...this["~orpc"].middlewares, middleware]
261
+ });
262
+ }
263
+ input(schema, example) {
264
+ return new ProcedureBuilderWithInput({
265
+ ...this["~orpc"],
266
+ contract: new ContractProcedureBuilder(this["~orpc"].contract["~orpc"]).input(schema, example)
267
+ });
268
+ }
269
+ output(schema, example) {
270
+ return new ProcedureBuilderWithOutput({
271
+ ...this["~orpc"],
272
+ contract: new ContractProcedureBuilder(this["~orpc"].contract["~orpc"]).output(schema, example)
273
+ });
274
+ }
275
+ handler(handler) {
276
+ return new DecoratedProcedure({
277
+ ...this["~orpc"],
132
278
  handler
133
279
  });
134
280
  }
@@ -208,10 +354,19 @@ var RouterBuilder = class _RouterBuilder {
208
354
  tags: [...this["~orpc"].tags ?? [], ...tags]
209
355
  });
210
356
  }
357
+ errors(errors) {
358
+ return new _RouterBuilder({
359
+ ...this["~orpc"],
360
+ errorMap: {
361
+ ...this["~orpc"].errorMap,
362
+ ...errors
363
+ }
364
+ });
365
+ }
211
366
  use(middleware) {
212
367
  return new _RouterBuilder({
213
368
  ...this["~orpc"],
214
- middlewares: [...this["~orpc"].middlewares ?? [], middleware]
369
+ middlewares: [...this["~orpc"].middlewares, middleware]
215
370
  });
216
371
  }
217
372
  router(router) {
@@ -248,6 +403,9 @@ function adapt(item, options) {
248
403
  if (options.middlewares?.length) {
249
404
  decorated = decorated.unshiftMiddleware(...options.middlewares);
250
405
  }
406
+ if (Object.keys(options.errorMap).length) {
407
+ decorated = decorated.errors(options.errorMap);
408
+ }
251
409
  return decorated;
252
410
  }
253
411
  const adapted = {};
@@ -257,6 +415,213 @@ function adapt(item, options) {
257
415
  return adapted;
258
416
  }
259
417
 
418
+ // src/builder-with-errors-middlewares.ts
419
+ var BuilderWithErrorsMiddlewares = class _BuilderWithErrorsMiddlewares {
420
+ "~type" = "BuilderWithErrorsMiddlewares";
421
+ "~orpc";
422
+ constructor(def) {
423
+ this["~orpc"] = def;
424
+ }
425
+ errors(errors) {
426
+ return new _BuilderWithErrorsMiddlewares({
427
+ ...this["~orpc"],
428
+ errorMap: {
429
+ ...this["~orpc"].errorMap,
430
+ ...errors
431
+ }
432
+ });
433
+ }
434
+ use(middleware) {
435
+ return new _BuilderWithErrorsMiddlewares({
436
+ ...this["~orpc"],
437
+ inputValidationIndex: this["~orpc"].inputValidationIndex + 1,
438
+ outputValidationIndex: this["~orpc"].outputValidationIndex + 1,
439
+ middlewares: [...this["~orpc"].middlewares, middleware]
440
+ // FIXME: I believe we can remove `as any` here
441
+ });
442
+ }
443
+ route(route) {
444
+ return new ProcedureBuilder({
445
+ ...this["~orpc"],
446
+ contract: new ContractProcedure({
447
+ route,
448
+ InputSchema: void 0,
449
+ OutputSchema: void 0,
450
+ errorMap: this["~orpc"].errorMap
451
+ })
452
+ });
453
+ }
454
+ input(schema, example) {
455
+ return new ProcedureBuilderWithInput({
456
+ ...this["~orpc"],
457
+ contract: new ContractProcedure({
458
+ OutputSchema: void 0,
459
+ InputSchema: schema,
460
+ inputExample: example,
461
+ errorMap: this["~orpc"].errorMap
462
+ })
463
+ });
464
+ }
465
+ output(schema, example) {
466
+ return new ProcedureBuilderWithOutput({
467
+ ...this["~orpc"],
468
+ contract: new ContractProcedure({
469
+ InputSchema: void 0,
470
+ OutputSchema: schema,
471
+ outputExample: example,
472
+ errorMap: this["~orpc"].errorMap
473
+ })
474
+ });
475
+ }
476
+ handler(handler) {
477
+ return new DecoratedProcedure({
478
+ ...this["~orpc"],
479
+ contract: new ContractProcedure({
480
+ InputSchema: void 0,
481
+ OutputSchema: void 0,
482
+ errorMap: this["~orpc"].errorMap
483
+ }),
484
+ handler
485
+ });
486
+ }
487
+ prefix(prefix) {
488
+ return new RouterBuilder({
489
+ ...this["~orpc"],
490
+ prefix
491
+ });
492
+ }
493
+ tag(...tags) {
494
+ return new RouterBuilder({
495
+ ...this["~orpc"],
496
+ tags
497
+ });
498
+ }
499
+ router(router) {
500
+ return new RouterBuilder(this["~orpc"]).router(router);
501
+ }
502
+ lazy(loader) {
503
+ return new RouterBuilder(this["~orpc"]).lazy(loader);
504
+ }
505
+ };
506
+
507
+ // src/builder-with-errors.ts
508
+ var BuilderWithErrors = class _BuilderWithErrors {
509
+ "~type" = "BuilderWithErrors";
510
+ "~orpc";
511
+ constructor(def) {
512
+ this["~orpc"] = def;
513
+ }
514
+ context() {
515
+ return this;
516
+ }
517
+ errors(errors) {
518
+ return new _BuilderWithErrors({
519
+ ...this["~orpc"],
520
+ errorMap: {
521
+ ...this["~orpc"].errorMap,
522
+ ...errors
523
+ }
524
+ });
525
+ }
526
+ middleware(middleware) {
527
+ return decorateMiddleware(middleware);
528
+ }
529
+ use(middleware) {
530
+ return new BuilderWithErrorsMiddlewares({
531
+ ...this["~orpc"],
532
+ inputValidationIndex: 1,
533
+ outputValidationIndex: 1,
534
+ middlewares: [middleware]
535
+ // FIXME: I believe we can remove `as any` here
536
+ });
537
+ }
538
+ route(route) {
539
+ return new ProcedureBuilder({
540
+ middlewares: [],
541
+ inputValidationIndex: 0,
542
+ outputValidationIndex: 0,
543
+ contract: new ContractProcedure2({
544
+ route,
545
+ InputSchema: void 0,
546
+ OutputSchema: void 0,
547
+ errorMap: this["~orpc"].errorMap
548
+ })
549
+ });
550
+ }
551
+ input(schema, example) {
552
+ return new ProcedureBuilderWithInput({
553
+ middlewares: [],
554
+ inputValidationIndex: 0,
555
+ outputValidationIndex: 0,
556
+ contract: new ContractProcedure2({
557
+ OutputSchema: void 0,
558
+ InputSchema: schema,
559
+ inputExample: example,
560
+ errorMap: this["~orpc"].errorMap
561
+ })
562
+ });
563
+ }
564
+ output(schema, example) {
565
+ return new ProcedureBuilderWithOutput({
566
+ middlewares: [],
567
+ inputValidationIndex: 0,
568
+ outputValidationIndex: 0,
569
+ contract: new ContractProcedure2({
570
+ InputSchema: void 0,
571
+ OutputSchema: schema,
572
+ outputExample: example,
573
+ errorMap: this["~orpc"].errorMap
574
+ })
575
+ });
576
+ }
577
+ handler(handler) {
578
+ return new DecoratedProcedure({
579
+ middlewares: [],
580
+ inputValidationIndex: 0,
581
+ outputValidationIndex: 0,
582
+ contract: new ContractProcedure2({
583
+ InputSchema: void 0,
584
+ OutputSchema: void 0,
585
+ errorMap: this["~orpc"].errorMap
586
+ }),
587
+ handler
588
+ });
589
+ }
590
+ prefix(prefix) {
591
+ return new RouterBuilder({
592
+ middlewares: [],
593
+ errorMap: this["~orpc"].errorMap,
594
+ prefix
595
+ });
596
+ }
597
+ tag(...tags) {
598
+ return new RouterBuilder({
599
+ middlewares: [],
600
+ errorMap: this["~orpc"].errorMap,
601
+ tags
602
+ });
603
+ }
604
+ router(router) {
605
+ return new RouterBuilder({
606
+ middlewares: [],
607
+ ...this["~orpc"]
608
+ }).router(router);
609
+ }
610
+ lazy(loader) {
611
+ return new RouterBuilder({
612
+ middlewares: [],
613
+ ...this["~orpc"]
614
+ }).lazy(loader);
615
+ }
616
+ };
617
+
618
+ // src/builder-with-middlewares.ts
619
+ import { ContractProcedure as ContractProcedure3 } from "@orpc/contract";
620
+
621
+ // src/implementer-chainable.ts
622
+ import { isContractProcedure } from "@orpc/contract";
623
+ import { createCallableObject } from "@orpc/shared";
624
+
260
625
  // src/router-implementer.ts
261
626
  var RouterImplementer = class _RouterImplementer {
262
627
  "~type" = "RouterImplementer";
@@ -271,31 +636,42 @@ var RouterImplementer = class _RouterImplementer {
271
636
  });
272
637
  }
273
638
  router(router) {
274
- const adapted = new RouterBuilder(this["~orpc"]).router(router);
639
+ const adapted = new RouterBuilder({
640
+ ...this["~orpc"],
641
+ errorMap: {}
642
+ }).router(router);
275
643
  const contracted = setRouterContract(adapted, this["~orpc"].contract);
276
644
  return contracted;
277
645
  }
278
646
  lazy(loader) {
279
- const adapted = new RouterBuilder(this["~orpc"]).lazy(loader);
647
+ const adapted = new RouterBuilder({
648
+ ...this["~orpc"],
649
+ errorMap: {}
650
+ }).lazy(loader);
280
651
  const contracted = setRouterContract(adapted, this["~orpc"].contract);
281
652
  return contracted;
282
653
  }
283
654
  };
284
655
 
285
656
  // src/implementer-chainable.ts
286
- function createChainableImplementer(contract, middlewares) {
657
+ function createChainableImplementer(contract, options) {
287
658
  if (isContractProcedure(contract)) {
288
659
  const implementer = new ProcedureImplementer({
289
660
  contract,
290
- middlewares
661
+ middlewares: options.middlewares,
662
+ inputValidationIndex: options.inputValidationIndex,
663
+ outputValidationIndex: options.outputValidationIndex
291
664
  });
292
665
  return implementer;
293
666
  }
294
667
  const chainable = {};
295
668
  for (const key in contract) {
296
- chainable[key] = createChainableImplementer(contract[key], middlewares);
669
+ chainable[key] = createChainableImplementer(contract[key], options);
297
670
  }
298
- const routerImplementer = new RouterImplementer({ contract, middlewares });
671
+ const routerImplementer = new RouterImplementer({
672
+ contract,
673
+ middlewares: options.middlewares
674
+ });
299
675
  const merged = new Proxy(chainable, {
300
676
  get(target, key) {
301
677
  const next = Reflect.get(target, key);
@@ -306,160 +682,219 @@ function createChainableImplementer(contract, middlewares) {
306
682
  if (!next) {
307
683
  return method.bind(routerImplementer);
308
684
  }
309
- return createCallableObject2(next, method.bind(routerImplementer));
685
+ return createCallableObject(next, method.bind(routerImplementer));
310
686
  }
311
687
  });
312
688
  return merged;
313
689
  }
314
690
 
315
- // src/procedure-builder.ts
316
- import {
317
- DecoratedContractProcedure as DecoratedContractProcedure2
318
- } from "@orpc/contract";
319
- var ProcedureBuilder = class _ProcedureBuilder {
320
- "~type" = "ProcedureBuilder";
691
+ // src/builder-with-middlewares.ts
692
+ var BuilderWithMiddlewares = class _BuilderWithMiddlewares {
693
+ "~type" = "BuilderHasMiddlewares";
321
694
  "~orpc";
322
695
  constructor(def) {
323
696
  this["~orpc"] = def;
324
697
  }
698
+ use(middleware) {
699
+ return new _BuilderWithMiddlewares({
700
+ ...this["~orpc"],
701
+ inputValidationIndex: this["~orpc"].inputValidationIndex + 1,
702
+ outputValidationIndex: this["~orpc"].outputValidationIndex + 1,
703
+ middlewares: [...this["~orpc"].middlewares, middleware]
704
+ });
705
+ }
706
+ errors(errors) {
707
+ return new BuilderWithErrorsMiddlewares({
708
+ ...this["~orpc"],
709
+ errorMap: errors
710
+ });
711
+ }
325
712
  route(route) {
326
- return new _ProcedureBuilder({
713
+ return new ProcedureBuilder({
327
714
  ...this["~orpc"],
328
- contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).route(route)
715
+ contract: new ContractProcedure3({
716
+ route,
717
+ InputSchema: void 0,
718
+ OutputSchema: void 0,
719
+ errorMap: {}
720
+ })
329
721
  });
330
722
  }
331
723
  input(schema, example) {
332
- return new _ProcedureBuilder({
724
+ return new ProcedureBuilderWithInput({
333
725
  ...this["~orpc"],
334
- contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).input(schema, example)
726
+ contract: new ContractProcedure3({
727
+ OutputSchema: void 0,
728
+ InputSchema: schema,
729
+ inputExample: example,
730
+ errorMap: {}
731
+ })
335
732
  });
336
733
  }
337
734
  output(schema, example) {
338
- return new _ProcedureBuilder({
735
+ return new ProcedureBuilderWithOutput({
339
736
  ...this["~orpc"],
340
- contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).output(schema, example)
737
+ contract: new ContractProcedure3({
738
+ InputSchema: void 0,
739
+ OutputSchema: schema,
740
+ outputExample: example,
741
+ errorMap: {}
742
+ })
341
743
  });
342
744
  }
343
- errors(errors) {
344
- return new _ProcedureBuilder({
745
+ handler(handler) {
746
+ return new DecoratedProcedure({
345
747
  ...this["~orpc"],
346
- contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).errors(errors)
748
+ contract: new ContractProcedure3({
749
+ InputSchema: void 0,
750
+ OutputSchema: void 0,
751
+ errorMap: {}
752
+ }),
753
+ handler
347
754
  });
348
755
  }
349
- use(middleware, mapInput) {
350
- if (!mapInput) {
351
- return new ProcedureImplementer({
352
- contract: this["~orpc"].contract,
353
- middlewares: this["~orpc"].middlewares
354
- }).use(middleware);
355
- }
356
- return new ProcedureImplementer({
357
- contract: this["~orpc"].contract,
358
- middlewares: this["~orpc"].middlewares
359
- }).use(middleware, mapInput);
756
+ prefix(prefix) {
757
+ return new RouterBuilder({
758
+ middlewares: this["~orpc"].middlewares,
759
+ errorMap: {},
760
+ prefix
761
+ });
360
762
  }
361
- handler(handler) {
362
- return new DecoratedProcedure({
763
+ tag(...tags) {
764
+ return new RouterBuilder({
363
765
  middlewares: this["~orpc"].middlewares,
364
- contract: this["~orpc"].contract,
365
- handler
766
+ errorMap: {},
767
+ tags
366
768
  });
367
769
  }
770
+ router(router) {
771
+ return new RouterBuilder({
772
+ errorMap: {},
773
+ ...this["~orpc"]
774
+ }).router(router);
775
+ }
776
+ lazy(loader) {
777
+ return new RouterBuilder({
778
+ errorMap: {},
779
+ ...this["~orpc"]
780
+ }).lazy(loader);
781
+ }
782
+ contract(contract) {
783
+ return createChainableImplementer(contract, this["~orpc"]);
784
+ }
368
785
  };
369
786
 
370
787
  // src/builder.ts
371
- var Builder = class _Builder {
788
+ var Builder = class {
372
789
  "~type" = "Builder";
373
790
  "~orpc";
374
791
  constructor(def) {
375
792
  this["~orpc"] = def;
376
793
  }
377
794
  context() {
378
- return new _Builder({});
795
+ return this;
796
+ }
797
+ middleware(middleware) {
798
+ return decorateMiddleware(middleware);
799
+ }
800
+ errors(errors) {
801
+ return new BuilderWithErrors({
802
+ errorMap: errors
803
+ });
379
804
  }
380
805
  use(middleware) {
381
- return new _Builder({
806
+ return new BuilderWithMiddlewares({
382
807
  ...this["~orpc"],
383
- middlewares: [...this["~orpc"].middlewares ?? [], middleware]
808
+ inputValidationIndex: 1,
809
+ outputValidationIndex: 1,
810
+ middlewares: [middleware]
811
+ // FIXME: I believe we can remove `as any` here
384
812
  });
385
813
  }
386
- middleware(middleware) {
387
- return decorateMiddleware(middleware);
388
- }
389
814
  route(route) {
390
815
  return new ProcedureBuilder({
391
- middlewares: this["~orpc"].middlewares,
392
- contract: new ContractProcedure({
816
+ middlewares: [],
817
+ inputValidationIndex: 0,
818
+ outputValidationIndex: 0,
819
+ contract: new ContractProcedure4({
393
820
  route,
394
821
  InputSchema: void 0,
395
822
  OutputSchema: void 0,
396
- errorMap: void 0
823
+ errorMap: {}
397
824
  })
398
825
  });
399
826
  }
400
827
  input(schema, example) {
401
- return new ProcedureBuilder({
402
- middlewares: this["~orpc"].middlewares,
403
- contract: new ContractProcedure({
828
+ return new ProcedureBuilderWithInput({
829
+ middlewares: [],
830
+ inputValidationIndex: 0,
831
+ outputValidationIndex: 0,
832
+ contract: new ContractProcedure4({
404
833
  OutputSchema: void 0,
405
834
  InputSchema: schema,
406
835
  inputExample: example,
407
- errorMap: void 0
836
+ errorMap: {}
408
837
  })
409
838
  });
410
839
  }
411
840
  output(schema, example) {
412
- return new ProcedureBuilder({
413
- middlewares: this["~orpc"].middlewares,
414
- contract: new ContractProcedure({
841
+ return new ProcedureBuilderWithOutput({
842
+ middlewares: [],
843
+ inputValidationIndex: 0,
844
+ outputValidationIndex: 0,
845
+ contract: new ContractProcedure4({
415
846
  InputSchema: void 0,
416
847
  OutputSchema: schema,
417
848
  outputExample: example,
418
- errorMap: void 0
419
- })
420
- });
421
- }
422
- errors(errors) {
423
- return new ProcedureBuilder({
424
- middlewares: this["~orpc"].middlewares,
425
- contract: new ContractProcedure({
426
- InputSchema: void 0,
427
- OutputSchema: void 0,
428
- errorMap: errors
849
+ errorMap: {}
429
850
  })
430
851
  });
431
852
  }
432
853
  handler(handler) {
433
854
  return new DecoratedProcedure({
434
- middlewares: this["~orpc"].middlewares,
435
- contract: new ContractProcedure({
855
+ middlewares: [],
856
+ inputValidationIndex: 0,
857
+ outputValidationIndex: 0,
858
+ contract: new ContractProcedure4({
436
859
  InputSchema: void 0,
437
860
  OutputSchema: void 0,
438
- errorMap: void 0
861
+ errorMap: {}
439
862
  }),
440
863
  handler
441
864
  });
442
865
  }
443
866
  prefix(prefix) {
444
867
  return new RouterBuilder({
445
- middlewares: this["~orpc"].middlewares,
868
+ middlewares: [],
869
+ errorMap: {},
446
870
  prefix
447
871
  });
448
872
  }
449
873
  tag(...tags) {
450
874
  return new RouterBuilder({
451
- middlewares: this["~orpc"].middlewares,
875
+ middlewares: [],
876
+ errorMap: {},
452
877
  tags
453
878
  });
454
879
  }
455
880
  router(router) {
456
- return new RouterBuilder(this["~orpc"]).router(router);
881
+ return new RouterBuilder({
882
+ middlewares: [],
883
+ errorMap: []
884
+ }).router(router);
457
885
  }
458
886
  lazy(loader) {
459
- return new RouterBuilder(this["~orpc"]).lazy(loader);
887
+ return new RouterBuilder({
888
+ middlewares: [],
889
+ errorMap: {}
890
+ }).lazy(loader);
460
891
  }
461
892
  contract(contract) {
462
- return createChainableImplementer(contract, this["~orpc"].middlewares);
893
+ return createChainableImplementer(contract, {
894
+ middlewares: [],
895
+ inputValidationIndex: 0,
896
+ outputValidationIndex: 0
897
+ });
463
898
  }
464
899
  };
465
900
 
@@ -511,7 +946,7 @@ function createRouterClient(router, ...rest) {
511
946
  }
512
947
 
513
948
  // src/index.ts
514
- import { configGlobal, fallbackToGlobalConfig, isDefinedError, ORPCError, safe } from "@orpc/contract";
949
+ import { configGlobal, fallbackToGlobalConfig, isDefinedError, ORPCError, safe, type } from "@orpc/contract";
515
950
  var os = new Builder({});
516
951
  export {
517
952
  Builder,
@@ -542,9 +977,11 @@ export {
542
977
  isProcedure,
543
978
  lazy,
544
979
  mergeContext,
980
+ middlewareOutputFn,
545
981
  os,
546
982
  safe,
547
983
  setRouterContract,
984
+ type,
548
985
  unlazy
549
986
  };
550
987
  //# sourceMappingURL=index.js.map