@orpc/server 0.0.0-next.c59d67c → 0.0.0-next.cba521d

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 (51) hide show
  1. package/dist/chunk-3EVCPLVI.js +301 -0
  2. package/dist/chunk-OUPZ7QGV.js +245 -0
  3. package/dist/chunk-WUOGVGWG.js +1 -0
  4. package/dist/fetch.js +11 -102
  5. package/dist/hono.js +30 -0
  6. package/dist/index.js +442 -274
  7. package/dist/next.js +36 -0
  8. package/dist/node.js +87 -0
  9. package/dist/src/adapters/fetch/index.d.ts +6 -0
  10. package/dist/src/adapters/fetch/orpc-handler.d.ts +20 -0
  11. package/dist/src/adapters/fetch/orpc-payload-codec.d.ts +16 -0
  12. package/dist/src/adapters/fetch/orpc-procedure-matcher.d.ts +12 -0
  13. package/dist/src/adapters/fetch/super-json.d.ts +12 -0
  14. package/dist/src/adapters/fetch/types.d.ts +21 -0
  15. package/dist/src/adapters/hono/index.d.ts +3 -0
  16. package/dist/src/adapters/hono/middleware.d.ts +12 -0
  17. package/dist/src/adapters/next/index.d.ts +3 -0
  18. package/dist/src/adapters/next/serve.d.ts +19 -0
  19. package/dist/src/adapters/node/index.d.ts +5 -0
  20. package/dist/src/adapters/node/orpc-handler.d.ts +12 -0
  21. package/dist/src/adapters/node/request-listener.d.ts +28 -0
  22. package/dist/src/adapters/node/types.d.ts +22 -0
  23. package/dist/src/builder.d.ts +30 -43
  24. package/dist/src/error.d.ts +10 -0
  25. package/dist/src/hidden.d.ts +6 -0
  26. package/dist/src/implementer-chainable.d.ts +10 -0
  27. package/dist/src/index.d.ts +14 -4
  28. package/dist/src/lazy-decorated.d.ts +7 -0
  29. package/dist/src/lazy-utils.d.ts +4 -0
  30. package/dist/src/lazy.d.ts +18 -0
  31. package/dist/src/middleware-decorated.d.ts +9 -0
  32. package/dist/src/middleware.d.ts +22 -12
  33. package/dist/src/procedure-builder.d.ts +19 -26
  34. package/dist/src/procedure-client.d.ts +22 -0
  35. package/dist/src/procedure-decorated.d.ts +26 -0
  36. package/dist/src/procedure-implementer.d.ts +17 -15
  37. package/dist/src/procedure-utils.d.ts +17 -0
  38. package/dist/src/procedure.d.ts +40 -25
  39. package/dist/src/router-builder.d.ts +24 -17
  40. package/dist/src/router-client.d.ts +26 -0
  41. package/dist/src/router-implementer.d.ts +18 -17
  42. package/dist/src/router.d.ts +11 -15
  43. package/dist/src/types.d.ts +10 -4
  44. package/package.json +22 -11
  45. package/dist/chunk-TDFYNRZV.js +0 -190
  46. package/dist/src/fetch/handle.d.ts +0 -7
  47. package/dist/src/fetch/handler.d.ts +0 -3
  48. package/dist/src/fetch/index.d.ts +0 -4
  49. package/dist/src/fetch/types.d.ts +0 -35
  50. package/dist/src/procedure-caller.d.ts +0 -19
  51. package/dist/src/router-caller.d.ts +0 -22
package/dist/index.js CHANGED
@@ -1,394 +1,562 @@
1
1
  import {
2
+ LAZY_LOADER_SYMBOL,
2
3
  Procedure,
3
- createProcedureCaller,
4
- decorateMiddleware,
5
- decorateProcedure,
4
+ createORPCErrorConstructorMap,
5
+ createProcedureClient,
6
+ flatLazy,
7
+ getRouterChild,
8
+ isLazy,
6
9
  isProcedure,
7
- mergeContext
8
- } from "./chunk-TDFYNRZV.js";
10
+ lazy,
11
+ mergeContext,
12
+ middlewareOutputFn,
13
+ unlazy
14
+ } from "./chunk-OUPZ7QGV.js";
9
15
 
10
16
  // src/builder.ts
11
- import {
12
- ContractProcedure,
13
- isContractProcedure as isContractProcedure2
14
- } from "@orpc/contract";
17
+ import { ContractProcedure } from "@orpc/contract";
15
18
 
16
- // src/procedure-builder.ts
17
- import {
18
- DecoratedContractProcedure
19
- } from "@orpc/contract";
19
+ // src/implementer-chainable.ts
20
+ import { isContractProcedure } from "@orpc/contract";
21
+ import { createCallableObject as createCallableObject2 } from "@orpc/shared";
20
22
 
21
- // src/procedure-implementer.ts
22
- var ProcedureImplementer = class _ProcedureImplementer {
23
- constructor(zz$pi) {
24
- this.zz$pi = zz$pi;
23
+ // src/middleware-decorated.ts
24
+ function decorateMiddleware(middleware) {
25
+ const decorated = middleware;
26
+ decorated.mapInput = (mapInput) => {
27
+ const mapped = decorateMiddleware(
28
+ (options, input, ...rest) => middleware(options, mapInput(input), ...rest)
29
+ );
30
+ return mapped;
31
+ };
32
+ decorated.concat = (concatMiddleware, mapInput) => {
33
+ const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
34
+ const concatted = decorateMiddleware((options, input, output, ...rest) => {
35
+ const next = async (nextOptions) => {
36
+ return mapped({ ...options, context: mergeContext(nextOptions.context, options.context) }, input, output, ...rest);
37
+ };
38
+ const merged = middleware({ ...options, next }, input, output, ...rest);
39
+ return merged;
40
+ });
41
+ return concatted;
42
+ };
43
+ return decorated;
44
+ }
45
+
46
+ // src/procedure-decorated.ts
47
+ import { DecoratedContractProcedure } from "@orpc/contract";
48
+ import { createCallableObject } from "@orpc/shared";
49
+ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
50
+ static decorate(procedure) {
51
+ if (procedure instanceof _DecoratedProcedure) {
52
+ return procedure;
53
+ }
54
+ return new _DecoratedProcedure(procedure["~orpc"]);
55
+ }
56
+ prefix(prefix) {
57
+ return new _DecoratedProcedure({
58
+ ...this["~orpc"],
59
+ contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).prefix(prefix)
60
+ });
61
+ }
62
+ route(route) {
63
+ return new _DecoratedProcedure({
64
+ ...this["~orpc"],
65
+ contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).route(route)
66
+ });
25
67
  }
26
68
  use(middleware, mapInput) {
27
69
  const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
28
- return new _ProcedureImplementer({
29
- ...this.zz$pi,
30
- middlewares: [...this.zz$pi.middlewares ?? [], middleware_]
70
+ return new _DecoratedProcedure({
71
+ ...this["~orpc"],
72
+ postMiddlewares: [...this["~orpc"].postMiddlewares, middleware_]
31
73
  });
32
74
  }
33
- func(func) {
34
- return decorateProcedure({
35
- zz$p: {
36
- middlewares: this.zz$pi.middlewares,
37
- contract: this.zz$pi.contract,
38
- func
39
- }
75
+ unshiftTag(...tags) {
76
+ return new _DecoratedProcedure({
77
+ ...this["~orpc"],
78
+ contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).unshiftTag(...tags)
40
79
  });
41
80
  }
42
- };
43
-
44
- // src/procedure-builder.ts
45
- var ProcedureBuilder = class _ProcedureBuilder {
46
- constructor(zz$pb) {
47
- this.zz$pb = zz$pb;
81
+ unshiftMiddleware(...middlewares) {
82
+ const castedMiddlewares = middlewares;
83
+ if (this["~orpc"].preMiddlewares.length) {
84
+ let min = 0;
85
+ for (let i = 0; i < this["~orpc"].preMiddlewares.length; i++) {
86
+ const index = castedMiddlewares.indexOf(this["~orpc"].preMiddlewares[i], min);
87
+ if (index === -1) {
88
+ castedMiddlewares.push(...this["~orpc"].preMiddlewares.slice(i));
89
+ break;
90
+ }
91
+ min = index + 1;
92
+ }
93
+ }
94
+ return new _DecoratedProcedure({
95
+ ...this["~orpc"],
96
+ preMiddlewares: castedMiddlewares
97
+ });
48
98
  }
49
99
  /**
50
- * Self chainable
100
+ * Make this procedure callable (works like a function while still being a procedure).
101
+ * **Note**: this only takes effect when this method is called at the end of the chain.
51
102
  */
52
- route(opts) {
53
- return new _ProcedureBuilder({
54
- ...this.zz$pb,
55
- contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).route(
56
- opts
57
- )
58
- });
103
+ callable(...rest) {
104
+ return createCallableObject(this, createProcedureClient(this, ...rest));
59
105
  }
60
- input(schema, example) {
61
- return new _ProcedureBuilder({
62
- ...this.zz$pb,
63
- contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).input(
64
- schema,
65
- example
66
- )
67
- });
106
+ /**
107
+ * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
108
+ * **Note**: this only takes effect when this method is called at the end of the chain.
109
+ */
110
+ actionable(...rest) {
111
+ return this.callable(...rest);
68
112
  }
69
- output(schema, example) {
70
- return new _ProcedureBuilder({
71
- ...this.zz$pb,
72
- contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).output(
73
- schema,
74
- example
75
- )
76
- });
113
+ };
114
+
115
+ // src/procedure-implementer.ts
116
+ var ProcedureImplementer = class _ProcedureImplementer {
117
+ "~type" = "ProcedureImplementer";
118
+ "~orpc";
119
+ constructor(def) {
120
+ this["~orpc"] = def;
77
121
  }
78
122
  use(middleware, mapInput) {
79
- if (!mapInput) {
80
- return new ProcedureImplementer({
81
- contract: this.zz$pb.contract,
82
- middlewares: this.zz$pb.middlewares
83
- }).use(middleware);
84
- }
85
- return new ProcedureImplementer({
86
- contract: this.zz$pb.contract,
87
- middlewares: this.zz$pb.middlewares
88
- }).use(middleware, mapInput);
123
+ const mappedMiddleware = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
124
+ return new _ProcedureImplementer({
125
+ ...this["~orpc"],
126
+ postMiddlewares: [...this["~orpc"].postMiddlewares, mappedMiddleware]
127
+ });
89
128
  }
90
- /**
91
- * Convert to Procedure
92
- */
93
- func(func) {
94
- return decorateProcedure({
95
- zz$p: {
96
- middlewares: this.zz$pb.middlewares,
97
- contract: this.zz$pb.contract,
98
- func
99
- }
129
+ handler(handler) {
130
+ return new DecoratedProcedure({
131
+ postMiddlewares: this["~orpc"].postMiddlewares,
132
+ preMiddlewares: this["~orpc"].preMiddlewares,
133
+ contract: this["~orpc"].contract,
134
+ handler
100
135
  });
101
136
  }
102
137
  };
103
138
 
139
+ // src/hidden.ts
140
+ var ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_ROUTER_CONTRACT");
141
+ function setRouterContract(obj, contract) {
142
+ return new Proxy(obj, {
143
+ get(target, key) {
144
+ if (key === ROUTER_CONTRACT_SYMBOL) {
145
+ return contract;
146
+ }
147
+ return Reflect.get(target, key);
148
+ }
149
+ });
150
+ }
151
+ function getRouterContract(obj) {
152
+ return obj[ROUTER_CONTRACT_SYMBOL];
153
+ }
154
+ var LAZY_ROUTER_PREFIX_SYMBOL = Symbol("ORPC_LAZY_ROUTER_PREFIX");
155
+ function deepSetLazyRouterPrefix(router, prefix) {
156
+ return new Proxy(router, {
157
+ get(target, key) {
158
+ if (key !== LAZY_ROUTER_PREFIX_SYMBOL) {
159
+ const val = Reflect.get(target, key);
160
+ if (val && (typeof val === "object" || typeof val === "function")) {
161
+ return deepSetLazyRouterPrefix(val, prefix);
162
+ }
163
+ return val;
164
+ }
165
+ return prefix;
166
+ }
167
+ });
168
+ }
169
+ function getLazyRouterPrefix(obj) {
170
+ return obj[LAZY_ROUTER_PREFIX_SYMBOL];
171
+ }
172
+
173
+ // src/lazy-decorated.ts
174
+ function decorateLazy(lazied) {
175
+ const flattenLazy = flatLazy(lazied);
176
+ const recursive = new Proxy(flattenLazy, {
177
+ get(target, key) {
178
+ if (typeof key !== "string") {
179
+ return Reflect.get(target, key);
180
+ }
181
+ const next = getRouterChild(flattenLazy, key);
182
+ return decorateLazy(next);
183
+ }
184
+ });
185
+ return recursive;
186
+ }
187
+
104
188
  // src/router-builder.ts
105
- import { DecoratedContractProcedure as DecoratedContractProcedure2 } from "@orpc/contract";
106
189
  var RouterBuilder = class _RouterBuilder {
107
- constructor(zz$rb) {
108
- this.zz$rb = zz$rb;
190
+ "~type" = "RouterBuilder";
191
+ "~orpc";
192
+ constructor(def) {
193
+ this["~orpc"] = def;
194
+ if (def.prefix && def.prefix.includes("{")) {
195
+ throw new Error(`
196
+ Dynamic routing in prefix not supported yet.
197
+ Please remove "{" from "${def.prefix}".
198
+ `);
199
+ }
109
200
  }
110
201
  prefix(prefix) {
111
202
  return new _RouterBuilder({
112
- ...this.zz$rb,
113
- prefix: `${this.zz$rb.prefix ?? ""}${prefix}`
203
+ ...this["~orpc"],
204
+ prefix: `${this["~orpc"].prefix ?? ""}${prefix}`
114
205
  });
115
206
  }
116
- tags(...tags) {
117
- if (!tags.length)
118
- return this;
207
+ tag(...tags) {
119
208
  return new _RouterBuilder({
120
- ...this.zz$rb,
121
- tags: [...this.zz$rb.tags ?? [], ...tags]
209
+ ...this["~orpc"],
210
+ tags: [...this["~orpc"].tags ?? [], ...tags]
122
211
  });
123
212
  }
124
- use(middleware, mapInput) {
125
- const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
213
+ use(middleware) {
126
214
  return new _RouterBuilder({
127
- ...this.zz$rb,
128
- middlewares: [...this.zz$rb.middlewares || [], middleware_]
215
+ ...this["~orpc"],
216
+ middlewares: [...this["~orpc"].middlewares, middleware]
129
217
  });
130
218
  }
131
219
  router(router) {
132
- const handled = {};
133
- for (const key in router) {
134
- const item = router[key];
135
- if (isProcedure(item)) {
136
- const builderMiddlewares = this.zz$rb.middlewares ?? [];
137
- const itemMiddlewares = item.zz$p.middlewares ?? [];
138
- const middlewares = [
139
- ...builderMiddlewares,
140
- ...itemMiddlewares.filter(
141
- (item2) => !builderMiddlewares.includes(item2)
142
- )
143
- ];
144
- const contract = DecoratedContractProcedure2.decorate(
145
- item.zz$p.contract
146
- ).addTags(...this.zz$rb.tags ?? []);
147
- handled[key] = decorateProcedure({
148
- zz$p: {
149
- ...item.zz$p,
150
- contract: this.zz$rb.prefix ? contract.prefix(this.zz$rb.prefix) : contract,
151
- middlewares
152
- }
153
- });
154
- } else {
155
- handled[key] = this.router(item);
156
- }
157
- }
158
- return handled;
220
+ const adapted = adapt(router, this["~orpc"]);
221
+ return adapted;
222
+ }
223
+ lazy(loader) {
224
+ const adapted = adapt(flatLazy(lazy(loader)), this["~orpc"]);
225
+ return adapted;
159
226
  }
160
227
  };
228
+ function adapt(item, options) {
229
+ if (isLazy(item)) {
230
+ const adaptedLazy = decorateLazy(lazy(async () => {
231
+ const routerOrProcedure = (await unlazy(item)).default;
232
+ const adapted2 = adapt(routerOrProcedure, options);
233
+ return { default: adapted2 };
234
+ }));
235
+ const lazyPrefix = getLazyRouterPrefix(item);
236
+ if (options.prefix || lazyPrefix) {
237
+ const prefixed = deepSetLazyRouterPrefix(adaptedLazy, `${options.prefix ?? ""}${lazyPrefix ?? ""}`);
238
+ return prefixed;
239
+ }
240
+ return adaptedLazy;
241
+ }
242
+ if (isProcedure(item)) {
243
+ let decorated = DecoratedProcedure.decorate(item);
244
+ if (options.tags?.length) {
245
+ decorated = decorated.unshiftTag(...options.tags);
246
+ }
247
+ if (options.prefix) {
248
+ decorated = decorated.prefix(options.prefix);
249
+ }
250
+ if (options.middlewares?.length) {
251
+ decorated = decorated.unshiftMiddleware(...options.middlewares);
252
+ }
253
+ return decorated;
254
+ }
255
+ const adapted = {};
256
+ for (const key in item) {
257
+ adapted[key] = adapt(item[key], options);
258
+ }
259
+ return adapted;
260
+ }
161
261
 
162
262
  // src/router-implementer.ts
163
- import {
164
- isContractProcedure
165
- } from "@orpc/contract";
166
- var RouterImplementer = class {
167
- constructor(zz$ri) {
168
- this.zz$ri = zz$ri;
263
+ var RouterImplementer = class _RouterImplementer {
264
+ "~type" = "RouterImplementer";
265
+ "~orpc";
266
+ constructor(def) {
267
+ this["~orpc"] = def;
268
+ }
269
+ use(middleware) {
270
+ return new _RouterImplementer({
271
+ ...this["~orpc"],
272
+ middlewares: [...this["~orpc"].middlewares ?? [], middleware]
273
+ });
169
274
  }
170
275
  router(router) {
171
- assertRouterImplementation(this.zz$ri.contract, router);
172
- return router;
276
+ const adapted = new RouterBuilder(this["~orpc"]).router(router);
277
+ const contracted = setRouterContract(adapted, this["~orpc"].contract);
278
+ return contracted;
279
+ }
280
+ lazy(loader) {
281
+ const adapted = new RouterBuilder(this["~orpc"]).lazy(loader);
282
+ const contracted = setRouterContract(adapted, this["~orpc"].contract);
283
+ return contracted;
173
284
  }
174
285
  };
175
- function chainRouterImplementer(contract, middlewares) {
176
- const result = {};
177
- for (const key in contract) {
178
- const item = contract[key];
179
- if (isContractProcedure(item)) {
180
- result[key] = new ProcedureImplementer({
181
- contract: item,
182
- middlewares
183
- });
184
- } else {
185
- result[key] = chainRouterImplementer(item, middlewares);
186
- }
286
+
287
+ // src/implementer-chainable.ts
288
+ function createChainableImplementer(contract, middlewares = []) {
289
+ if (isContractProcedure(contract)) {
290
+ const implementer = new ProcedureImplementer({
291
+ contract,
292
+ preMiddlewares: middlewares,
293
+ postMiddlewares: []
294
+ });
295
+ return implementer;
187
296
  }
188
- const implementer = new RouterImplementer({ contract });
189
- return Object.assign(implementer, result);
190
- }
191
- function assertRouterImplementation(contract, router, path = []) {
297
+ const chainable = {};
192
298
  for (const key in contract) {
193
- const currentPath = [...path, key];
194
- const contractItem = contract[key];
195
- const routerItem = router[key];
196
- if (!routerItem) {
197
- throw new Error(
198
- `Missing implementation for procedure at [${currentPath.join(".")}]`
199
- );
200
- }
201
- if (isContractProcedure(contractItem)) {
202
- if (isProcedure(routerItem)) {
203
- if (routerItem.zz$p.contract !== contractItem) {
204
- throw new Error(
205
- `Mismatch implementation for procedure at [${currentPath.join(".")}]`
206
- );
207
- }
208
- } else {
209
- throw new Error(
210
- `Mismatch implementation for procedure at [${currentPath.join(".")}]`
211
- );
299
+ chainable[key] = createChainableImplementer(contract[key], middlewares);
300
+ }
301
+ const routerImplementer = new RouterImplementer({ contract, middlewares });
302
+ const merged = new Proxy(chainable, {
303
+ get(target, key) {
304
+ const next = Reflect.get(target, key);
305
+ const method = Reflect.get(routerImplementer, key);
306
+ if (typeof key !== "string" || typeof method !== "function") {
307
+ return next;
308
+ }
309
+ if (!next) {
310
+ return method.bind(routerImplementer);
212
311
  }
213
- } else {
214
- assertRouterImplementation(
215
- contractItem,
216
- routerItem,
217
- currentPath
218
- );
312
+ return createCallableObject2(next, method.bind(routerImplementer));
219
313
  }
220
- }
314
+ });
315
+ return merged;
221
316
  }
222
317
 
318
+ // src/procedure-builder.ts
319
+ import {
320
+ DecoratedContractProcedure as DecoratedContractProcedure2
321
+ } from "@orpc/contract";
322
+ var ProcedureBuilder = class _ProcedureBuilder {
323
+ "~type" = "ProcedureBuilder";
324
+ "~orpc";
325
+ constructor(def) {
326
+ this["~orpc"] = def;
327
+ }
328
+ route(route) {
329
+ return new _ProcedureBuilder({
330
+ ...this["~orpc"],
331
+ contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).route(route)
332
+ });
333
+ }
334
+ input(schema, example) {
335
+ return new _ProcedureBuilder({
336
+ ...this["~orpc"],
337
+ contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).input(schema, example)
338
+ });
339
+ }
340
+ output(schema, example) {
341
+ return new _ProcedureBuilder({
342
+ ...this["~orpc"],
343
+ contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).output(schema, example)
344
+ });
345
+ }
346
+ errors(errors) {
347
+ return new _ProcedureBuilder({
348
+ ...this["~orpc"],
349
+ contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).errors(errors)
350
+ });
351
+ }
352
+ use(middleware, mapInput) {
353
+ if (!mapInput) {
354
+ return new ProcedureImplementer({
355
+ contract: this["~orpc"].contract,
356
+ preMiddlewares: this["~orpc"].middlewares,
357
+ postMiddlewares: []
358
+ }).use(middleware);
359
+ }
360
+ return new ProcedureImplementer({
361
+ contract: this["~orpc"].contract,
362
+ preMiddlewares: this["~orpc"].middlewares,
363
+ postMiddlewares: []
364
+ }).use(middleware, mapInput);
365
+ }
366
+ handler(handler) {
367
+ return new DecoratedProcedure({
368
+ preMiddlewares: this["~orpc"].middlewares,
369
+ postMiddlewares: [],
370
+ contract: this["~orpc"].contract,
371
+ handler
372
+ });
373
+ }
374
+ };
375
+
223
376
  // src/builder.ts
224
377
  var Builder = class _Builder {
225
- constructor(zz$b = {}) {
226
- this.zz$b = zz$b;
378
+ "~type" = "Builder";
379
+ "~orpc";
380
+ constructor(def) {
381
+ this["~orpc"] = def;
227
382
  }
228
- /**
229
- * Self chainable
230
- */
231
383
  context() {
232
- return this;
384
+ return new _Builder({
385
+ middlewares: []
386
+ });
233
387
  }
234
- use(middleware, mapInput) {
235
- const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
388
+ use(middleware) {
236
389
  return new _Builder({
237
- ...this.zz$b,
238
- middlewares: [...this.zz$b.middlewares || [], middleware_]
390
+ ...this["~orpc"],
391
+ middlewares: [...this["~orpc"].middlewares, middleware]
239
392
  });
240
393
  }
241
- /**
242
- * Convert to ContractProcedureBuilder
243
- */
244
- route(opts) {
394
+ middleware(middleware) {
395
+ return decorateMiddleware(middleware);
396
+ }
397
+ route(route) {
245
398
  return new ProcedureBuilder({
246
- middlewares: this.zz$b.middlewares,
399
+ middlewares: this["~orpc"].middlewares,
247
400
  contract: new ContractProcedure({
248
- ...opts,
401
+ route,
249
402
  InputSchema: void 0,
250
- OutputSchema: void 0
403
+ OutputSchema: void 0,
404
+ errorMap: void 0
251
405
  })
252
406
  });
253
407
  }
254
408
  input(schema, example) {
255
409
  return new ProcedureBuilder({
256
- middlewares: this.zz$b.middlewares,
410
+ middlewares: this["~orpc"].middlewares,
257
411
  contract: new ContractProcedure({
258
412
  OutputSchema: void 0,
259
413
  InputSchema: schema,
260
- inputExample: example
414
+ inputExample: example,
415
+ errorMap: void 0
261
416
  })
262
417
  });
263
418
  }
264
419
  output(schema, example) {
265
420
  return new ProcedureBuilder({
266
- middlewares: this.zz$b.middlewares,
421
+ middlewares: this["~orpc"].middlewares,
267
422
  contract: new ContractProcedure({
268
423
  InputSchema: void 0,
269
424
  OutputSchema: schema,
270
- outputExample: example
425
+ outputExample: example,
426
+ errorMap: void 0
271
427
  })
272
428
  });
273
429
  }
274
- /**
275
- * Convert to Procedure
276
- */
277
- func(func) {
278
- return decorateProcedure({
279
- zz$p: {
280
- middlewares: this.zz$b.middlewares,
281
- contract: new ContractProcedure({
282
- InputSchema: void 0,
283
- OutputSchema: void 0
284
- }),
285
- func
286
- }
430
+ errors(errors) {
431
+ return new ProcedureBuilder({
432
+ middlewares: this["~orpc"].middlewares,
433
+ contract: new ContractProcedure({
434
+ InputSchema: void 0,
435
+ OutputSchema: void 0,
436
+ errorMap: errors
437
+ })
287
438
  });
288
439
  }
289
- /**
290
- * Convert to ProcedureImplementer | RouterBuilder
291
- */
292
- contract(contract) {
293
- if (isContractProcedure2(contract)) {
294
- return new ProcedureImplementer({
295
- contract,
296
- middlewares: this.zz$b.middlewares
297
- });
298
- }
299
- return chainRouterImplementer(
300
- contract,
301
- this.zz$b.middlewares
302
- );
303
- }
304
- /**
305
- * Create ExtendedMiddleware
306
- */
307
- // TODO: TOutput always any, infer not work at all, because TOutput used inside middleware params,
308
- // solution (maybe): create new generic for .output() method
309
- middleware(middleware) {
310
- return decorateMiddleware(middleware);
440
+ handler(handler) {
441
+ return new DecoratedProcedure({
442
+ preMiddlewares: this["~orpc"].middlewares,
443
+ postMiddlewares: [],
444
+ contract: new ContractProcedure({
445
+ InputSchema: void 0,
446
+ OutputSchema: void 0,
447
+ errorMap: void 0
448
+ }),
449
+ handler
450
+ });
311
451
  }
312
452
  prefix(prefix) {
313
453
  return new RouterBuilder({
314
- ...this.zz$b,
454
+ middlewares: this["~orpc"].middlewares,
315
455
  prefix
316
456
  });
317
457
  }
318
- tags(...tags) {
458
+ tag(...tags) {
319
459
  return new RouterBuilder({
320
- ...this.zz$b,
460
+ middlewares: this["~orpc"].middlewares,
321
461
  tags
322
462
  });
323
463
  }
324
- /**
325
- * Create DecoratedRouter
326
- */
327
464
  router(router) {
328
- return new RouterBuilder(this.zz$b).router(router);
465
+ return new RouterBuilder(this["~orpc"]).router(router);
466
+ }
467
+ lazy(loader) {
468
+ return new RouterBuilder(this["~orpc"]).lazy(loader);
469
+ }
470
+ contract(contract) {
471
+ return createChainableImplementer(contract, this["~orpc"].middlewares);
329
472
  }
330
473
  };
331
474
 
332
- // src/router.ts
333
- import {
334
- isContractProcedure as isContractProcedure3
335
- } from "@orpc/contract";
336
- function toContractRouter(router) {
337
- const contract = {};
338
- for (const key in router) {
339
- const item = router[key];
340
- if (isContractProcedure3(item)) {
341
- contract[key] = item;
342
- } else if (isProcedure(item)) {
343
- contract[key] = item.zz$p.contract;
344
- } else {
345
- contract[key] = toContractRouter(item);
475
+ // src/procedure-utils.ts
476
+ function call(procedure, input, ...rest) {
477
+ return createProcedureClient(procedure, ...rest)(input);
478
+ }
479
+
480
+ // src/lazy-utils.ts
481
+ function createLazyProcedureFormAnyLazy(lazied) {
482
+ const lazyProcedure = lazy(async () => {
483
+ const { default: maybeProcedure } = await unlazy(flatLazy(lazied));
484
+ if (!isProcedure(maybeProcedure)) {
485
+ throw new Error(`
486
+ Expected a lazy<procedure> but got lazy<unknown>.
487
+ This should be caught by TypeScript compilation.
488
+ Please report this issue if this makes you feel uncomfortable.
489
+ `);
346
490
  }
347
- }
348
- return contract;
491
+ return { default: maybeProcedure };
492
+ });
493
+ return lazyProcedure;
349
494
  }
350
495
 
351
- // src/router-caller.ts
352
- function createRouterCaller(options) {
353
- const caller = {};
354
- for (const key in options.router) {
355
- const path = [...options.basePath ?? [], key];
356
- const item = options.router[key];
357
- if (isProcedure(item)) {
358
- caller[key] = createProcedureCaller({
359
- procedure: item,
360
- context: options.context,
361
- path
362
- });
363
- } else {
364
- caller[key] = createRouterCaller({
365
- router: item,
366
- context: options.context,
367
- basePath: path
496
+ // src/router-client.ts
497
+ function createRouterClient(router, ...rest) {
498
+ if (isProcedure(router)) {
499
+ const caller = createProcedureClient(router, ...rest);
500
+ return caller;
501
+ }
502
+ const procedureCaller = isLazy(router) ? createProcedureClient(createLazyProcedureFormAnyLazy(router), ...rest) : {};
503
+ const recursive = new Proxy(procedureCaller, {
504
+ get(target, key) {
505
+ if (typeof key !== "string") {
506
+ return Reflect.get(target, key);
507
+ }
508
+ const next = getRouterChild(router, key);
509
+ if (!next) {
510
+ return Reflect.get(target, key);
511
+ }
512
+ const [options] = rest;
513
+ return createRouterClient(next, {
514
+ ...options,
515
+ path: [...options?.path ?? [], key]
368
516
  });
369
517
  }
370
- }
371
- return caller;
518
+ });
519
+ return recursive;
372
520
  }
373
521
 
374
522
  // src/index.ts
375
- export * from "@orpc/shared/error";
376
- var os = new Builder();
523
+ import { configGlobal, fallbackToGlobalConfig, isDefinedError, ORPCError, safe } from "@orpc/contract";
524
+ var os = new Builder({
525
+ middlewares: []
526
+ });
377
527
  export {
378
528
  Builder,
529
+ DecoratedProcedure,
530
+ LAZY_LOADER_SYMBOL,
531
+ ORPCError,
379
532
  Procedure,
380
533
  ProcedureBuilder,
381
534
  ProcedureImplementer,
535
+ RouterBuilder,
382
536
  RouterImplementer,
383
- assertRouterImplementation,
384
- chainRouterImplementer,
385
- createProcedureCaller,
386
- createRouterCaller,
537
+ call,
538
+ configGlobal,
539
+ createChainableImplementer,
540
+ createORPCErrorConstructorMap,
541
+ createProcedureClient,
542
+ createRouterClient,
543
+ decorateLazy,
387
544
  decorateMiddleware,
388
- decorateProcedure,
545
+ deepSetLazyRouterPrefix,
546
+ fallbackToGlobalConfig,
547
+ flatLazy,
548
+ getLazyRouterPrefix,
549
+ getRouterChild,
550
+ getRouterContract,
551
+ isDefinedError,
552
+ isLazy,
389
553
  isProcedure,
554
+ lazy,
390
555
  mergeContext,
556
+ middlewareOutputFn,
391
557
  os,
392
- toContractRouter
558
+ safe,
559
+ setRouterContract,
560
+ unlazy
393
561
  };
394
562
  //# sourceMappingURL=index.js.map