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