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