@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.
- package/dist/chunk-3EVCPLVI.js +301 -0
- package/dist/chunk-OUPZ7QGV.js +245 -0
- package/dist/chunk-WUOGVGWG.js +1 -0
- package/dist/fetch.js +11 -102
- package/dist/hono.js +30 -0
- package/dist/index.js +442 -274
- package/dist/next.js +36 -0
- package/dist/node.js +87 -0
- package/dist/src/adapters/fetch/index.d.ts +6 -0
- package/dist/src/adapters/fetch/orpc-handler.d.ts +20 -0
- package/dist/src/adapters/fetch/orpc-payload-codec.d.ts +16 -0
- package/dist/src/adapters/fetch/orpc-procedure-matcher.d.ts +12 -0
- package/dist/src/adapters/fetch/super-json.d.ts +12 -0
- package/dist/src/adapters/fetch/types.d.ts +21 -0
- package/dist/src/adapters/hono/index.d.ts +3 -0
- package/dist/src/adapters/hono/middleware.d.ts +12 -0
- package/dist/src/adapters/next/index.d.ts +3 -0
- package/dist/src/adapters/next/serve.d.ts +19 -0
- package/dist/src/adapters/node/index.d.ts +5 -0
- package/dist/src/adapters/node/orpc-handler.d.ts +12 -0
- package/dist/src/adapters/node/request-listener.d.ts +28 -0
- package/dist/src/adapters/node/types.d.ts +22 -0
- package/dist/src/builder.d.ts +30 -43
- package/dist/src/error.d.ts +10 -0
- package/dist/src/hidden.d.ts +6 -0
- package/dist/src/implementer-chainable.d.ts +10 -0
- package/dist/src/index.d.ts +14 -4
- package/dist/src/lazy-decorated.d.ts +7 -0
- package/dist/src/lazy-utils.d.ts +4 -0
- package/dist/src/lazy.d.ts +18 -0
- package/dist/src/middleware-decorated.d.ts +9 -0
- package/dist/src/middleware.d.ts +22 -12
- package/dist/src/procedure-builder.d.ts +19 -26
- package/dist/src/procedure-client.d.ts +22 -0
- package/dist/src/procedure-decorated.d.ts +26 -0
- package/dist/src/procedure-implementer.d.ts +17 -15
- package/dist/src/procedure-utils.d.ts +17 -0
- package/dist/src/procedure.d.ts +40 -25
- package/dist/src/router-builder.d.ts +24 -17
- package/dist/src/router-client.d.ts +26 -0
- package/dist/src/router-implementer.d.ts +18 -17
- package/dist/src/router.d.ts +11 -15
- package/dist/src/types.d.ts +10 -4
- package/package.json +22 -11
- package/dist/chunk-TDFYNRZV.js +0 -190
- package/dist/src/fetch/handle.d.ts +0 -7
- package/dist/src/fetch/handler.d.ts +0 -3
- package/dist/src/fetch/index.d.ts +0 -4
- package/dist/src/fetch/types.d.ts +0 -35
- package/dist/src/procedure-caller.d.ts +0 -19
- 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
|
-
|
4
|
-
|
5
|
-
|
4
|
+
createORPCErrorConstructorMap,
|
5
|
+
createProcedureClient,
|
6
|
+
flatLazy,
|
7
|
+
getRouterChild,
|
8
|
+
isLazy,
|
6
9
|
isProcedure,
|
7
|
-
|
8
|
-
|
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/
|
17
|
-
import {
|
18
|
-
|
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/
|
22
|
-
|
23
|
-
|
24
|
-
|
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
|
29
|
-
...this
|
30
|
-
|
70
|
+
return new _DecoratedProcedure({
|
71
|
+
...this["~orpc"],
|
72
|
+
postMiddlewares: [...this["~orpc"].postMiddlewares, middleware_]
|
31
73
|
});
|
32
74
|
}
|
33
|
-
|
34
|
-
return
|
35
|
-
|
36
|
-
|
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
|
-
|
45
|
-
|
46
|
-
|
47
|
-
|
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
|
-
*
|
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
|
-
|
53
|
-
return
|
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
|
-
|
61
|
-
|
62
|
-
|
63
|
-
|
64
|
-
|
65
|
-
|
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
|
-
|
70
|
-
|
71
|
-
|
72
|
-
|
73
|
-
|
74
|
-
|
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
|
-
|
80
|
-
|
81
|
-
|
82
|
-
|
83
|
-
|
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
|
-
|
92
|
-
|
93
|
-
|
94
|
-
|
95
|
-
|
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
|
-
|
108
|
-
|
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
|
113
|
-
prefix: `${this.
|
203
|
+
...this["~orpc"],
|
204
|
+
prefix: `${this["~orpc"].prefix ?? ""}${prefix}`
|
114
205
|
});
|
115
206
|
}
|
116
|
-
|
117
|
-
if (!tags.length)
|
118
|
-
return this;
|
207
|
+
tag(...tags) {
|
119
208
|
return new _RouterBuilder({
|
120
|
-
...this
|
121
|
-
tags: [...this.
|
209
|
+
...this["~orpc"],
|
210
|
+
tags: [...this["~orpc"].tags ?? [], ...tags]
|
122
211
|
});
|
123
212
|
}
|
124
|
-
use(middleware
|
125
|
-
const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
|
213
|
+
use(middleware) {
|
126
214
|
return new _RouterBuilder({
|
127
|
-
...this
|
128
|
-
middlewares: [...this.
|
215
|
+
...this["~orpc"],
|
216
|
+
middlewares: [...this["~orpc"].middlewares, middleware]
|
129
217
|
});
|
130
218
|
}
|
131
219
|
router(router) {
|
132
|
-
const
|
133
|
-
|
134
|
-
|
135
|
-
|
136
|
-
|
137
|
-
|
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
|
-
|
164
|
-
|
165
|
-
|
166
|
-
|
167
|
-
|
168
|
-
|
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
|
-
|
172
|
-
|
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
|
-
|
176
|
-
|
177
|
-
|
178
|
-
|
179
|
-
|
180
|
-
|
181
|
-
|
182
|
-
|
183
|
-
|
184
|
-
|
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
|
189
|
-
return Object.assign(implementer, result);
|
190
|
-
}
|
191
|
-
function assertRouterImplementation(contract, router, path = []) {
|
297
|
+
const chainable = {};
|
192
298
|
for (const key in contract) {
|
193
|
-
|
194
|
-
|
195
|
-
|
196
|
-
|
197
|
-
|
198
|
-
|
199
|
-
);
|
200
|
-
|
201
|
-
|
202
|
-
|
203
|
-
|
204
|
-
|
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
|
-
|
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
|
-
|
226
|
-
|
378
|
+
"~type" = "Builder";
|
379
|
+
"~orpc";
|
380
|
+
constructor(def) {
|
381
|
+
this["~orpc"] = def;
|
227
382
|
}
|
228
|
-
/**
|
229
|
-
* Self chainable
|
230
|
-
*/
|
231
383
|
context() {
|
232
|
-
return
|
384
|
+
return new _Builder({
|
385
|
+
middlewares: []
|
386
|
+
});
|
233
387
|
}
|
234
|
-
use(middleware
|
235
|
-
const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
|
388
|
+
use(middleware) {
|
236
389
|
return new _Builder({
|
237
|
-
...this
|
238
|
-
middlewares: [...this.
|
390
|
+
...this["~orpc"],
|
391
|
+
middlewares: [...this["~orpc"].middlewares, middleware]
|
239
392
|
});
|
240
393
|
}
|
241
|
-
|
242
|
-
|
243
|
-
|
244
|
-
route(
|
394
|
+
middleware(middleware) {
|
395
|
+
return decorateMiddleware(middleware);
|
396
|
+
}
|
397
|
+
route(route) {
|
245
398
|
return new ProcedureBuilder({
|
246
|
-
middlewares: this.
|
399
|
+
middlewares: this["~orpc"].middlewares,
|
247
400
|
contract: new ContractProcedure({
|
248
|
-
|
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.
|
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.
|
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
|
-
|
276
|
-
|
277
|
-
|
278
|
-
|
279
|
-
|
280
|
-
|
281
|
-
|
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
|
-
|
291
|
-
|
292
|
-
|
293
|
-
|
294
|
-
|
295
|
-
|
296
|
-
|
297
|
-
})
|
298
|
-
|
299
|
-
|
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
|
-
|
454
|
+
middlewares: this["~orpc"].middlewares,
|
315
455
|
prefix
|
316
456
|
});
|
317
457
|
}
|
318
|
-
|
458
|
+
tag(...tags) {
|
319
459
|
return new RouterBuilder({
|
320
|
-
|
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
|
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/
|
333
|
-
|
334
|
-
|
335
|
-
}
|
336
|
-
|
337
|
-
|
338
|
-
|
339
|
-
|
340
|
-
|
341
|
-
|
342
|
-
|
343
|
-
|
344
|
-
|
345
|
-
|
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
|
-
|
491
|
+
return { default: maybeProcedure };
|
492
|
+
});
|
493
|
+
return lazyProcedure;
|
349
494
|
}
|
350
495
|
|
351
|
-
// src/router-
|
352
|
-
function
|
353
|
-
|
354
|
-
|
355
|
-
|
356
|
-
|
357
|
-
|
358
|
-
|
359
|
-
|
360
|
-
|
361
|
-
|
362
|
-
}
|
363
|
-
|
364
|
-
|
365
|
-
|
366
|
-
|
367
|
-
|
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
|
518
|
+
});
|
519
|
+
return recursive;
|
372
520
|
}
|
373
521
|
|
374
522
|
// src/index.ts
|
375
|
-
|
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
|
-
|
384
|
-
|
385
|
-
|
386
|
-
|
537
|
+
call,
|
538
|
+
configGlobal,
|
539
|
+
createChainableImplementer,
|
540
|
+
createORPCErrorConstructorMap,
|
541
|
+
createProcedureClient,
|
542
|
+
createRouterClient,
|
543
|
+
decorateLazy,
|
387
544
|
decorateMiddleware,
|
388
|
-
|
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
|
-
|
558
|
+
safe,
|
559
|
+
setRouterContract,
|
560
|
+
unlazy
|
393
561
|
};
|
394
562
|
//# sourceMappingURL=index.js.map
|