@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/{chunk-XDC42C3C.js → chunk-GK2Z6B6W.js} +34 -31
- package/dist/{chunk-VY6NXNQT.js → chunk-SXUFCJBY.js} +2 -2
- package/dist/fetch.js +2 -2
- package/dist/hono.js +2 -2
- package/dist/index.js +525 -88
- package/dist/next.js +2 -2
- package/dist/node.js +2 -2
- package/dist/src/builder-with-errors-middlewares.d.ts +50 -0
- package/dist/src/builder-with-errors.d.ts +49 -0
- package/dist/src/builder-with-middlewares.d.ts +47 -0
- package/dist/src/builder.d.ts +28 -21
- package/dist/src/context.d.ts +11 -0
- package/dist/src/error.d.ts +1 -1
- package/dist/src/hidden.d.ts +2 -2
- package/dist/src/implementer-chainable.d.ts +7 -3
- package/dist/src/index.d.ts +2 -2
- package/dist/src/middleware-decorated.d.ts +2 -1
- package/dist/src/middleware.d.ts +1 -0
- package/dist/src/procedure-builder-with-input.d.ts +34 -0
- package/dist/src/procedure-builder-with-output.d.ts +33 -0
- package/dist/src/procedure-builder.d.ts +19 -16
- package/dist/src/procedure-decorated.d.ts +8 -8
- package/dist/src/procedure-implementer.d.ts +6 -3
- package/dist/src/procedure.d.ts +4 -2
- package/dist/src/router-builder.d.ts +18 -14
- package/dist/src/router-implementer.d.ts +7 -6
- package/dist/src/router.d.ts +2 -2
- package/package.json +3 -3
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-
|
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/
|
19
|
-
import {
|
20
|
-
|
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
|
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
|
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
|
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
|
143
|
+
middlewares: [...this["~orpc"].middlewares, mappedMiddleware]
|
126
144
|
});
|
127
145
|
}
|
128
146
|
handler(handler) {
|
129
147
|
return new DecoratedProcedure({
|
130
|
-
|
131
|
-
|
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
|
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(
|
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(
|
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,
|
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],
|
669
|
+
chainable[key] = createChainableImplementer(contract[key], options);
|
297
670
|
}
|
298
|
-
const routerImplementer = new RouterImplementer({
|
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
|
685
|
+
return createCallableObject(next, method.bind(routerImplementer));
|
310
686
|
}
|
311
687
|
});
|
312
688
|
return merged;
|
313
689
|
}
|
314
690
|
|
315
|
-
// src/
|
316
|
-
|
317
|
-
|
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
|
713
|
+
return new ProcedureBuilder({
|
327
714
|
...this["~orpc"],
|
328
|
-
contract:
|
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
|
724
|
+
return new ProcedureBuilderWithInput({
|
333
725
|
...this["~orpc"],
|
334
|
-
contract:
|
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
|
735
|
+
return new ProcedureBuilderWithOutput({
|
339
736
|
...this["~orpc"],
|
340
|
-
contract:
|
737
|
+
contract: new ContractProcedure3({
|
738
|
+
InputSchema: void 0,
|
739
|
+
OutputSchema: schema,
|
740
|
+
outputExample: example,
|
741
|
+
errorMap: {}
|
742
|
+
})
|
341
743
|
});
|
342
744
|
}
|
343
|
-
|
344
|
-
return new
|
745
|
+
handler(handler) {
|
746
|
+
return new DecoratedProcedure({
|
345
747
|
...this["~orpc"],
|
346
|
-
contract:
|
748
|
+
contract: new ContractProcedure3({
|
749
|
+
InputSchema: void 0,
|
750
|
+
OutputSchema: void 0,
|
751
|
+
errorMap: {}
|
752
|
+
}),
|
753
|
+
handler
|
347
754
|
});
|
348
755
|
}
|
349
|
-
|
350
|
-
|
351
|
-
|
352
|
-
|
353
|
-
|
354
|
-
|
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
|
-
|
362
|
-
return new
|
763
|
+
tag(...tags) {
|
764
|
+
return new RouterBuilder({
|
363
765
|
middlewares: this["~orpc"].middlewares,
|
364
|
-
|
365
|
-
|
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
|
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
|
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
|
806
|
+
return new BuilderWithMiddlewares({
|
382
807
|
...this["~orpc"],
|
383
|
-
|
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:
|
392
|
-
|
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:
|
823
|
+
errorMap: {}
|
397
824
|
})
|
398
825
|
});
|
399
826
|
}
|
400
827
|
input(schema, example) {
|
401
|
-
return new
|
402
|
-
middlewares:
|
403
|
-
|
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:
|
836
|
+
errorMap: {}
|
408
837
|
})
|
409
838
|
});
|
410
839
|
}
|
411
840
|
output(schema, example) {
|
412
|
-
return new
|
413
|
-
middlewares:
|
414
|
-
|
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:
|
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:
|
435
|
-
|
855
|
+
middlewares: [],
|
856
|
+
inputValidationIndex: 0,
|
857
|
+
outputValidationIndex: 0,
|
858
|
+
contract: new ContractProcedure4({
|
436
859
|
InputSchema: void 0,
|
437
860
|
OutputSchema: void 0,
|
438
|
-
errorMap:
|
861
|
+
errorMap: {}
|
439
862
|
}),
|
440
863
|
handler
|
441
864
|
});
|
442
865
|
}
|
443
866
|
prefix(prefix) {
|
444
867
|
return new RouterBuilder({
|
445
|
-
middlewares:
|
868
|
+
middlewares: [],
|
869
|
+
errorMap: {},
|
446
870
|
prefix
|
447
871
|
});
|
448
872
|
}
|
449
873
|
tag(...tags) {
|
450
874
|
return new RouterBuilder({
|
451
|
-
middlewares:
|
875
|
+
middlewares: [],
|
876
|
+
errorMap: {},
|
452
877
|
tags
|
453
878
|
});
|
454
879
|
}
|
455
880
|
router(router) {
|
456
|
-
return new RouterBuilder(
|
881
|
+
return new RouterBuilder({
|
882
|
+
middlewares: [],
|
883
|
+
errorMap: []
|
884
|
+
}).router(router);
|
457
885
|
}
|
458
886
|
lazy(loader) {
|
459
|
-
return new RouterBuilder(
|
887
|
+
return new RouterBuilder({
|
888
|
+
middlewares: [],
|
889
|
+
errorMap: {}
|
890
|
+
}).lazy(loader);
|
460
891
|
}
|
461
892
|
contract(contract) {
|
462
|
-
return createChainableImplementer(contract,
|
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
|