@orpc/client 0.0.0-next.a4ecb29 → 0.0.0-next.a65f345

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.
@@ -1,7 +1,152 @@
1
- export { C as CompositeClientPlugin } from '../shared/client.CvnV7_uV.mjs';
2
- import { isAsyncIteratorObject, value } from '@orpc/shared';
1
+ import { isAsyncIteratorObject, value, splitInHalf, toArray } from '@orpc/shared';
2
+ import { toBatchRequest, parseBatchResponse } from '@orpc/standard-server/batch';
3
3
  import { getEventMeta } from '@orpc/standard-server';
4
4
 
5
+ class BatchLinkPlugin {
6
+ groups;
7
+ maxSize;
8
+ batchUrl;
9
+ maxUrlLength;
10
+ batchHeaders;
11
+ mapRequestItem;
12
+ exclude;
13
+ pending;
14
+ order = 5e6;
15
+ constructor(options) {
16
+ this.groups = options.groups;
17
+ this.pending = /* @__PURE__ */ new Map();
18
+ this.maxSize = options.maxSize ?? 10;
19
+ this.maxUrlLength = options.maxUrlLength ?? 2083;
20
+ this.batchUrl = options.url ?? (([options2]) => `${options2.request.url.origin}${options2.request.url.pathname}/__batch__`);
21
+ this.batchHeaders = options.headers ?? (([options2, ...rest]) => {
22
+ const headers = {};
23
+ for (const [key, value2] of Object.entries(options2.request.headers)) {
24
+ if (rest.every((item) => item.request.headers[key] === value2)) {
25
+ headers[key] = value2;
26
+ }
27
+ }
28
+ return headers;
29
+ });
30
+ this.mapRequestItem = options.mapRequestItem ?? (({ request, batchHeaders }) => {
31
+ const headers = {};
32
+ for (const [key, value2] of Object.entries(request.headers)) {
33
+ if (batchHeaders[key] !== value2) {
34
+ headers[key] = value2;
35
+ }
36
+ }
37
+ return {
38
+ method: request.method,
39
+ url: request.url,
40
+ headers,
41
+ body: request.body,
42
+ signal: request.signal
43
+ };
44
+ });
45
+ this.exclude = options.exclude ?? (() => false);
46
+ }
47
+ init(options) {
48
+ options.clientInterceptors ??= [];
49
+ options.clientInterceptors.push((options2) => {
50
+ if (options2.request.headers["x-orpc-batch"] !== "1") {
51
+ return options2.next();
52
+ }
53
+ return options2.next({
54
+ ...options2,
55
+ request: {
56
+ ...options2.request,
57
+ headers: {
58
+ ...options2.request.headers,
59
+ "x-orpc-batch": void 0
60
+ }
61
+ }
62
+ });
63
+ });
64
+ options.clientInterceptors.push((options2) => {
65
+ if (this.exclude(options2) || options2.request.body instanceof Blob || options2.request.body instanceof FormData || isAsyncIteratorObject(options2.request.body)) {
66
+ return options2.next();
67
+ }
68
+ const group = this.groups.find((group2) => group2.condition(options2));
69
+ if (!group) {
70
+ return options2.next();
71
+ }
72
+ return new Promise((resolve, reject) => {
73
+ this.#enqueueRequest(group, options2, resolve, reject);
74
+ setTimeout(() => this.#processPendingBatches());
75
+ });
76
+ });
77
+ }
78
+ #enqueueRequest(group, options, resolve, reject) {
79
+ const items = this.pending.get(group);
80
+ if (items) {
81
+ items.push([options, resolve, reject]);
82
+ } else {
83
+ this.pending.set(group, [[options, resolve, reject]]);
84
+ }
85
+ }
86
+ async #processPendingBatches() {
87
+ const pending = this.pending;
88
+ this.pending = /* @__PURE__ */ new Map();
89
+ for (const [group, items] of pending) {
90
+ const getItems = items.filter(([options]) => options.request.method === "GET");
91
+ const restItems = items.filter(([options]) => options.request.method !== "GET");
92
+ this.#executeBatch("GET", group, getItems);
93
+ this.#executeBatch("POST", group, restItems);
94
+ }
95
+ }
96
+ async #executeBatch(method, group, groupItems) {
97
+ if (!groupItems.length) {
98
+ return;
99
+ }
100
+ const batchItems = groupItems;
101
+ if (batchItems.length === 1) {
102
+ batchItems[0][0].next().then(batchItems[0][1]).catch(batchItems[0][2]);
103
+ return;
104
+ }
105
+ try {
106
+ const options = batchItems.map(([options2]) => options2);
107
+ const maxSize = await value(this.maxSize, options);
108
+ if (batchItems.length > maxSize) {
109
+ const [first, second] = splitInHalf(batchItems);
110
+ this.#executeBatch(method, group, first);
111
+ this.#executeBatch(method, group, second);
112
+ return;
113
+ }
114
+ const batchUrl = new URL(await value(this.batchUrl, options));
115
+ const batchHeaders = await value(this.batchHeaders, options);
116
+ const mappedItems = batchItems.map(([options2]) => this.mapRequestItem({ ...options2, batchUrl, batchHeaders }));
117
+ const batchRequest = toBatchRequest({
118
+ method,
119
+ url: batchUrl,
120
+ headers: batchHeaders,
121
+ requests: mappedItems
122
+ });
123
+ const maxUrlLength = await value(this.maxUrlLength, options);
124
+ if (batchRequest.url.toString().length > maxUrlLength) {
125
+ const [first, second] = splitInHalf(batchItems);
126
+ this.#executeBatch(method, group, first);
127
+ this.#executeBatch(method, group, second);
128
+ return;
129
+ }
130
+ const lazyResponse = await options[0].next({
131
+ request: { ...batchRequest, headers: { ...batchRequest.headers, "x-orpc-batch": "1" } },
132
+ signal: batchRequest.signal,
133
+ context: group.context,
134
+ input: group.input,
135
+ path: toArray(group.path)
136
+ });
137
+ const parsed = parseBatchResponse({ ...lazyResponse, body: await lazyResponse.body() });
138
+ for await (const item of parsed) {
139
+ batchItems[item.index]?.[1]({ ...item, body: () => Promise.resolve(item.body) });
140
+ }
141
+ throw new Error("Something went wrong make batch response not contains enough responses. This can be a bug please report it.");
142
+ } catch (error) {
143
+ for (const [, , reject] of batchItems) {
144
+ reject(error);
145
+ }
146
+ }
147
+ }
148
+ }
149
+
5
150
  class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
6
151
  }
7
152
  class ClientRetryPlugin {
@@ -11,78 +156,64 @@ class ClientRetryPlugin {
11
156
  defaultOnRetry;
12
157
  constructor(options = {}) {
13
158
  this.defaultRetry = options.default?.retry ?? 0;
14
- this.defaultRetryDelay = options.default?.retryDelay ?? ((o) => o.eventIteratorLastRetry ?? 2e3);
159
+ this.defaultRetryDelay = options.default?.retryDelay ?? ((o) => o.lastEventRetry ?? 2e3);
15
160
  this.defaultShouldRetry = options.default?.shouldRetry ?? true;
16
161
  this.defaultOnRetry = options.default?.onRetry;
17
162
  }
18
163
  init(options) {
19
164
  options.interceptors ??= [];
20
165
  options.interceptors.push(async (interceptorOptions) => {
21
- const maxAttempts = interceptorOptions.options.context.retry ?? this.defaultRetry;
22
- const retryDelay = interceptorOptions.options.context.retryDelay ?? this.defaultRetryDelay;
23
- const shouldRetry = interceptorOptions.options.context.shouldRetry ?? this.defaultShouldRetry;
24
- const onRetry = interceptorOptions.options.context.onRetry ?? this.defaultOnRetry;
166
+ const maxAttempts = await value(
167
+ interceptorOptions.context.retry ?? this.defaultRetry,
168
+ interceptorOptions
169
+ );
170
+ const retryDelay = interceptorOptions.context.retryDelay ?? this.defaultRetryDelay;
171
+ const shouldRetry = interceptorOptions.context.shouldRetry ?? this.defaultShouldRetry;
172
+ const onRetry = interceptorOptions.context.onRetry ?? this.defaultOnRetry;
25
173
  if (maxAttempts <= 0) {
26
174
  return interceptorOptions.next();
27
175
  }
28
- let eventIteratorLastEventId = interceptorOptions.options.lastEventId;
29
- let eventIteratorLastRetry;
30
- let unsubscribe;
176
+ let lastEventId = interceptorOptions.lastEventId;
177
+ let lastEventRetry;
178
+ let callback;
31
179
  let attemptIndex = 0;
32
- const next = async (initial) => {
33
- let current = initial;
180
+ const next = async (initialError) => {
181
+ let currentError = initialError;
34
182
  while (true) {
35
- if (current) {
183
+ const updatedInterceptorOptions = { ...interceptorOptions, lastEventId };
184
+ if (currentError) {
36
185
  if (attemptIndex >= maxAttempts) {
37
- throw current.error;
186
+ throw currentError.error;
38
187
  }
39
188
  const attemptOptions = {
189
+ ...updatedInterceptorOptions,
40
190
  attemptIndex,
41
- error: current.error,
42
- eventIteratorLastEventId,
43
- eventIteratorLastRetry
191
+ error: currentError.error,
192
+ lastEventRetry
44
193
  };
45
194
  const shouldRetryBool = await value(
46
195
  shouldRetry,
47
- attemptOptions,
48
- interceptorOptions.options,
49
- interceptorOptions.path,
50
- interceptorOptions.input
196
+ attemptOptions
51
197
  );
52
198
  if (!shouldRetryBool) {
53
- throw current.error;
199
+ throw currentError.error;
54
200
  }
55
- unsubscribe = onRetry?.(
56
- attemptOptions,
57
- interceptorOptions.options,
58
- interceptorOptions.path,
59
- interceptorOptions.input
60
- );
61
- const retryDelayMs = await value(
62
- retryDelay,
63
- attemptOptions,
64
- interceptorOptions.options,
65
- interceptorOptions.path,
66
- interceptorOptions.input
67
- );
201
+ callback = onRetry?.(attemptOptions);
202
+ const retryDelayMs = await value(retryDelay, attemptOptions);
68
203
  await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
69
204
  attemptIndex++;
70
205
  }
71
206
  try {
72
- const newClientOptions = { ...interceptorOptions.options, lastEventId: eventIteratorLastEventId };
73
- const output2 = await interceptorOptions.next({
74
- ...interceptorOptions,
75
- options: newClientOptions
76
- });
77
- return output2;
207
+ currentError = void 0;
208
+ return await interceptorOptions.next(updatedInterceptorOptions);
78
209
  } catch (error) {
79
- if (interceptorOptions.options.signal?.aborted === true) {
210
+ currentError = { error };
211
+ if (updatedInterceptorOptions.signal?.aborted === true) {
80
212
  throw error;
81
213
  }
82
- current = { error };
83
214
  } finally {
84
- unsubscribe?.();
85
- unsubscribe = void 0;
215
+ callback?.(!currentError);
216
+ callback = void 0;
86
217
  }
87
218
  }
88
219
  };
@@ -97,16 +228,16 @@ class ClientRetryPlugin {
97
228
  try {
98
229
  const item = await current.next();
99
230
  const meta = getEventMeta(item.value);
100
- eventIteratorLastEventId = meta?.id ?? eventIteratorLastEventId;
101
- eventIteratorLastRetry = meta?.retry ?? eventIteratorLastRetry;
231
+ lastEventId = meta?.id ?? lastEventId;
232
+ lastEventRetry = meta?.retry ?? lastEventRetry;
102
233
  if (item.done) {
103
234
  return item.value;
104
235
  }
105
236
  yield item.value;
106
237
  } catch (error) {
107
238
  const meta = getEventMeta(error);
108
- eventIteratorLastEventId = meta?.id ?? eventIteratorLastEventId;
109
- eventIteratorLastRetry = meta?.retry ?? eventIteratorLastRetry;
239
+ lastEventId = meta?.id ?? lastEventId;
240
+ lastEventRetry = meta?.retry ?? lastEventRetry;
110
241
  const maybeEventIterator = await next({ error });
111
242
  if (!isAsyncIteratorObject(maybeEventIterator)) {
112
243
  throw new ClientRetryPluginInvalidEventIteratorRetryResponse(
@@ -124,4 +255,37 @@ class ClientRetryPlugin {
124
255
  }
125
256
  }
126
257
 
127
- export { ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse };
258
+ class SimpleCsrfProtectionLinkPlugin {
259
+ headerName;
260
+ headerValue;
261
+ exclude;
262
+ constructor(options = {}) {
263
+ this.headerName = options.headerName ?? "x-csrf-token";
264
+ this.headerValue = options.headerValue ?? "orpc";
265
+ this.exclude = options.exclude ?? false;
266
+ }
267
+ order = 8e6;
268
+ init(options) {
269
+ options.clientInterceptors ??= [];
270
+ options.clientInterceptors.push(async (options2) => {
271
+ const excluded = await value(this.exclude, options2);
272
+ if (excluded) {
273
+ return options2.next();
274
+ }
275
+ const headerName = await value(this.headerName, options2);
276
+ const headerValue = await value(this.headerValue, options2);
277
+ return options2.next({
278
+ ...options2,
279
+ request: {
280
+ ...options2.request,
281
+ headers: {
282
+ ...options2.request.headers,
283
+ [headerName]: headerValue
284
+ }
285
+ }
286
+ });
287
+ });
288
+ }
289
+ }
290
+
291
+ export { BatchLinkPlugin, ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse, SimpleCsrfProtectionLinkPlugin };
@@ -0,0 +1,29 @@
1
+ import { PromiseWithError } from '@orpc/shared';
2
+
3
+ type HTTPPath = `/${string}`;
4
+ type HTTPMethod = 'HEAD' | 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
5
+ type ClientContext = Record<PropertyKey, any>;
6
+ interface ClientOptions<T extends ClientContext> {
7
+ signal?: AbortSignal;
8
+ lastEventId?: string | undefined;
9
+ context: T;
10
+ }
11
+ type FriendlyClientOptions<T extends ClientContext> = Omit<ClientOptions<T>, 'context'> & (Record<never, never> extends T ? {
12
+ context?: T;
13
+ } : {
14
+ context: T;
15
+ });
16
+ type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options: FriendlyClientOptions<TClientContext>];
17
+ type ClientPromiseResult<TOutput, TError> = PromiseWithError<TOutput, TError>;
18
+ interface Client<TClientContext extends ClientContext, TInput, TOutput, TError> {
19
+ (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
20
+ }
21
+ type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
22
+ [k: string]: NestedClient<TClientContext>;
23
+ };
24
+ type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
25
+ interface ClientLink<TClientContext extends ClientContext> {
26
+ call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
27
+ }
28
+
29
+ export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientContext as a, ClientOptions as b, ClientPromiseResult as c, HTTPMethod as d, ClientRest as e, Client as f };
@@ -0,0 +1,29 @@
1
+ import { PromiseWithError } from '@orpc/shared';
2
+
3
+ type HTTPPath = `/${string}`;
4
+ type HTTPMethod = 'HEAD' | 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
5
+ type ClientContext = Record<PropertyKey, any>;
6
+ interface ClientOptions<T extends ClientContext> {
7
+ signal?: AbortSignal;
8
+ lastEventId?: string | undefined;
9
+ context: T;
10
+ }
11
+ type FriendlyClientOptions<T extends ClientContext> = Omit<ClientOptions<T>, 'context'> & (Record<never, never> extends T ? {
12
+ context?: T;
13
+ } : {
14
+ context: T;
15
+ });
16
+ type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options: FriendlyClientOptions<TClientContext>];
17
+ type ClientPromiseResult<TOutput, TError> = PromiseWithError<TOutput, TError>;
18
+ interface Client<TClientContext extends ClientContext, TInput, TOutput, TError> {
19
+ (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
20
+ }
21
+ type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
22
+ [k: string]: NestedClient<TClientContext>;
23
+ };
24
+ type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
25
+ interface ClientLink<TClientContext extends ClientContext> {
26
+ call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
27
+ }
28
+
29
+ export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientContext as a, ClientOptions as b, ClientPromiseResult as c, HTTPMethod as d, ClientRest as e, Client as f };
@@ -0,0 +1,46 @@
1
+ import { Interceptor, ThrowableError } from '@orpc/shared';
2
+ import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
3
+ import { a as ClientContext, b as ClientOptions, C as ClientLink } from './client.4TS_0JaO.js';
4
+
5
+ interface StandardLinkPlugin<T extends ClientContext> {
6
+ order?: number;
7
+ init?(options: StandardLinkOptions<T>): void;
8
+ }
9
+ declare class CompositeStandardLinkPlugin<T extends ClientContext, TPlugin extends StandardLinkPlugin<T>> implements StandardLinkPlugin<T> {
10
+ protected readonly plugins: TPlugin[];
11
+ constructor(plugins?: readonly TPlugin[]);
12
+ init(options: StandardLinkOptions<T>): void;
13
+ }
14
+
15
+ interface StandardLinkCodec<T extends ClientContext> {
16
+ encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
17
+ decode(response: StandardLazyResponse, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<unknown>;
18
+ }
19
+ interface StandardLinkClient<T extends ClientContext> {
20
+ call(request: StandardRequest, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
21
+ }
22
+
23
+ interface StandardLinkInterceptorOptions<T extends ClientContext> extends ClientOptions<T> {
24
+ path: readonly string[];
25
+ input: unknown;
26
+ }
27
+ interface StandardLinkClientInterceptorOptions<T extends ClientContext> extends StandardLinkInterceptorOptions<T> {
28
+ request: StandardRequest;
29
+ }
30
+ interface StandardLinkOptions<T extends ClientContext> {
31
+ interceptors?: Interceptor<StandardLinkInterceptorOptions<T>, unknown, ThrowableError>[];
32
+ clientInterceptors?: Interceptor<StandardLinkClientInterceptorOptions<T>, StandardLazyResponse, ThrowableError>[];
33
+ plugins?: StandardLinkPlugin<T>[];
34
+ }
35
+ declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
36
+ #private;
37
+ readonly codec: StandardLinkCodec<T>;
38
+ readonly sender: StandardLinkClient<T>;
39
+ private readonly interceptors;
40
+ private readonly clientInterceptors;
41
+ constructor(codec: StandardLinkCodec<T>, sender: StandardLinkClient<T>, options?: StandardLinkOptions<T>);
42
+ call(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<unknown>;
43
+ }
44
+
45
+ export { CompositeStandardLinkPlugin as C, StandardLink as d };
46
+ export type { StandardLinkClientInterceptorOptions as S, StandardLinkPlugin as a, StandardLinkOptions as b, StandardLinkInterceptorOptions as c, StandardLinkCodec as e, StandardLinkClient as f };
@@ -0,0 +1,91 @@
1
+ import { a as ClientContext, b as ClientOptions, d as HTTPMethod } from './client.4TS_0JaO.js';
2
+ import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.7ZYxJok_.js';
3
+ import { Segment, Value } from '@orpc/shared';
4
+ import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
5
+
6
+ declare const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES: {
7
+ readonly BIGINT: 0;
8
+ readonly DATE: 1;
9
+ readonly NAN: 2;
10
+ readonly UNDEFINED: 3;
11
+ readonly URL: 4;
12
+ readonly REGEXP: 5;
13
+ readonly SET: 6;
14
+ readonly MAP: 7;
15
+ };
16
+ type StandardRPCJsonSerializedMetaItem = readonly [type: number, ...path: Segment[]];
17
+ type StandardRPCJsonSerialized = [json: unknown, meta: StandardRPCJsonSerializedMetaItem[], maps: Segment[][], blobs: Blob[]];
18
+ interface StandardRPCCustomJsonSerializer {
19
+ type: number;
20
+ condition(data: unknown): boolean;
21
+ serialize(data: any): unknown;
22
+ deserialize(serialized: any): unknown;
23
+ }
24
+ interface StandardRPCJsonSerializerOptions {
25
+ customJsonSerializers?: readonly StandardRPCCustomJsonSerializer[];
26
+ }
27
+ declare class StandardRPCJsonSerializer {
28
+ private readonly customSerializers;
29
+ constructor(options?: StandardRPCJsonSerializerOptions);
30
+ serialize(data: unknown, segments?: Segment[], meta?: StandardRPCJsonSerializedMetaItem[], maps?: Segment[][], blobs?: Blob[]): StandardRPCJsonSerialized;
31
+ deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[]): unknown;
32
+ deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[], maps: readonly Segment[][], getBlob: (index: number) => Blob): unknown;
33
+ }
34
+
35
+ declare class StandardRPCSerializer {
36
+ #private;
37
+ private readonly jsonSerializer;
38
+ constructor(jsonSerializer: StandardRPCJsonSerializer);
39
+ serialize(data: unknown): object;
40
+ deserialize(data: unknown): unknown;
41
+ }
42
+
43
+ interface StandardRPCLinkCodecOptions<T extends ClientContext> {
44
+ /**
45
+ * Base url for all requests.
46
+ */
47
+ url: Value<string | URL, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
48
+ /**
49
+ * The maximum length of the URL.
50
+ *
51
+ * @default 2083
52
+ */
53
+ maxUrlLength?: Value<number, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
54
+ /**
55
+ * The method used to make the request.
56
+ *
57
+ * @default 'POST'
58
+ */
59
+ method?: Value<Exclude<HTTPMethod, 'HEAD'>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
60
+ /**
61
+ * The method to use when the payload cannot safely pass to the server with method return from method function.
62
+ * GET is not allowed, it's very dangerous.
63
+ *
64
+ * @default 'POST'
65
+ */
66
+ fallbackMethod?: Exclude<HTTPMethod, 'HEAD' | 'GET'>;
67
+ /**
68
+ * Inject headers to the request.
69
+ */
70
+ headers?: Value<StandardHeaders, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
71
+ }
72
+ declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
73
+ private readonly serializer;
74
+ private readonly baseUrl;
75
+ private readonly maxUrlLength;
76
+ private readonly fallbackMethod;
77
+ private readonly expectedMethod;
78
+ private readonly headers;
79
+ constructor(serializer: StandardRPCSerializer, options: StandardRPCLinkCodecOptions<T>);
80
+ encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
81
+ decode(response: StandardLazyResponse): Promise<unknown>;
82
+ }
83
+
84
+ interface StandardRPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, StandardRPCJsonSerializerOptions {
85
+ }
86
+ declare class StandardRPCLink<T extends ClientContext> extends StandardLink<T> {
87
+ constructor(linkClient: StandardLinkClient<T>, options: StandardRPCLinkOptions<T>);
88
+ }
89
+
90
+ export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, StandardRPCJsonSerializer as e, StandardRPCLink as g, StandardRPCLinkCodec as i, StandardRPCSerializer as j };
91
+ export type { StandardRPCJsonSerializedMetaItem as a, StandardRPCJsonSerialized as b, StandardRPCCustomJsonSerializer as c, StandardRPCJsonSerializerOptions as d, StandardRPCLinkOptions as f, StandardRPCLinkCodecOptions as h };
@@ -91,8 +91,8 @@ class ORPCError extends Error {
91
91
  status;
92
92
  data;
93
93
  constructor(code, ...[options]) {
94
- if (options?.status && (options.status < 400 || options.status >= 600)) {
95
- throw new Error("[ORPCError] The error status code must be in the 400-599 range.");
94
+ if (options?.status && !isORPCErrorStatus(options.status)) {
95
+ throw new Error("[ORPCError] Invalid error status code.");
96
96
  }
97
97
  const message = fallbackORPCErrorMessage(code, options?.message);
98
98
  super(message, options);
@@ -110,22 +110,6 @@ class ORPCError extends Error {
110
110
  data: this.data
111
111
  };
112
112
  }
113
- static fromJSON(json, options) {
114
- return new ORPCError(json.code, {
115
- ...options,
116
- ...json
117
- });
118
- }
119
- static isValidJSON(json) {
120
- if (!isObject(json)) {
121
- return false;
122
- }
123
- const validKeys = ["defined", "code", "status", "message", "data"];
124
- if (Object.keys(json).some((k) => !validKeys.includes(k))) {
125
- return false;
126
- }
127
- return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && "message" in json && typeof json.message === "string";
128
- }
129
113
  }
130
114
  function isDefinedError(error) {
131
115
  return error instanceof ORPCError && error.defined;
@@ -136,6 +120,25 @@ function toORPCError(error) {
136
120
  cause: error
137
121
  });
138
122
  }
123
+ function isORPCErrorStatus(status) {
124
+ return status < 200 || status >= 400;
125
+ }
126
+ function isORPCErrorJson(json) {
127
+ if (!isObject(json)) {
128
+ return false;
129
+ }
130
+ const validKeys = ["defined", "code", "status", "message", "data"];
131
+ if (Object.keys(json).some((k) => !validKeys.includes(k))) {
132
+ return false;
133
+ }
134
+ return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && isORPCErrorStatus(json.status) && "message" in json && typeof json.message === "string";
135
+ }
136
+ function createORPCErrorFromJson(json, options = {}) {
137
+ return new ORPCError(json.code, {
138
+ ...options,
139
+ ...json
140
+ });
141
+ }
139
142
 
140
143
  function mapEventIterator(iterator, maps) {
141
144
  return async function* () {
@@ -169,4 +172,4 @@ function mapEventIterator(iterator, maps) {
169
172
  }();
170
173
  }
171
174
 
172
- export { COMMON_ORPC_ERROR_DEFS as C, ORPCError as O, fallbackORPCErrorMessage as a, fallbackORPCErrorStatus as f, isDefinedError as i, mapEventIterator as m, toORPCError as t };
175
+ export { COMMON_ORPC_ERROR_DEFS as C, ORPCError as O, fallbackORPCErrorMessage as a, isORPCErrorStatus as b, isORPCErrorJson as c, createORPCErrorFromJson as d, fallbackORPCErrorStatus as f, isDefinedError as i, mapEventIterator as m, toORPCError as t };
@@ -0,0 +1,91 @@
1
+ import { a as ClientContext, b as ClientOptions, d as HTTPMethod } from './client.4TS_0JaO.mjs';
2
+ import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.ds1abV85.mjs';
3
+ import { Segment, Value } from '@orpc/shared';
4
+ import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
5
+
6
+ declare const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES: {
7
+ readonly BIGINT: 0;
8
+ readonly DATE: 1;
9
+ readonly NAN: 2;
10
+ readonly UNDEFINED: 3;
11
+ readonly URL: 4;
12
+ readonly REGEXP: 5;
13
+ readonly SET: 6;
14
+ readonly MAP: 7;
15
+ };
16
+ type StandardRPCJsonSerializedMetaItem = readonly [type: number, ...path: Segment[]];
17
+ type StandardRPCJsonSerialized = [json: unknown, meta: StandardRPCJsonSerializedMetaItem[], maps: Segment[][], blobs: Blob[]];
18
+ interface StandardRPCCustomJsonSerializer {
19
+ type: number;
20
+ condition(data: unknown): boolean;
21
+ serialize(data: any): unknown;
22
+ deserialize(serialized: any): unknown;
23
+ }
24
+ interface StandardRPCJsonSerializerOptions {
25
+ customJsonSerializers?: readonly StandardRPCCustomJsonSerializer[];
26
+ }
27
+ declare class StandardRPCJsonSerializer {
28
+ private readonly customSerializers;
29
+ constructor(options?: StandardRPCJsonSerializerOptions);
30
+ serialize(data: unknown, segments?: Segment[], meta?: StandardRPCJsonSerializedMetaItem[], maps?: Segment[][], blobs?: Blob[]): StandardRPCJsonSerialized;
31
+ deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[]): unknown;
32
+ deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[], maps: readonly Segment[][], getBlob: (index: number) => Blob): unknown;
33
+ }
34
+
35
+ declare class StandardRPCSerializer {
36
+ #private;
37
+ private readonly jsonSerializer;
38
+ constructor(jsonSerializer: StandardRPCJsonSerializer);
39
+ serialize(data: unknown): object;
40
+ deserialize(data: unknown): unknown;
41
+ }
42
+
43
+ interface StandardRPCLinkCodecOptions<T extends ClientContext> {
44
+ /**
45
+ * Base url for all requests.
46
+ */
47
+ url: Value<string | URL, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
48
+ /**
49
+ * The maximum length of the URL.
50
+ *
51
+ * @default 2083
52
+ */
53
+ maxUrlLength?: Value<number, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
54
+ /**
55
+ * The method used to make the request.
56
+ *
57
+ * @default 'POST'
58
+ */
59
+ method?: Value<Exclude<HTTPMethod, 'HEAD'>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
60
+ /**
61
+ * The method to use when the payload cannot safely pass to the server with method return from method function.
62
+ * GET is not allowed, it's very dangerous.
63
+ *
64
+ * @default 'POST'
65
+ */
66
+ fallbackMethod?: Exclude<HTTPMethod, 'HEAD' | 'GET'>;
67
+ /**
68
+ * Inject headers to the request.
69
+ */
70
+ headers?: Value<StandardHeaders, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
71
+ }
72
+ declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
73
+ private readonly serializer;
74
+ private readonly baseUrl;
75
+ private readonly maxUrlLength;
76
+ private readonly fallbackMethod;
77
+ private readonly expectedMethod;
78
+ private readonly headers;
79
+ constructor(serializer: StandardRPCSerializer, options: StandardRPCLinkCodecOptions<T>);
80
+ encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
81
+ decode(response: StandardLazyResponse): Promise<unknown>;
82
+ }
83
+
84
+ interface StandardRPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, StandardRPCJsonSerializerOptions {
85
+ }
86
+ declare class StandardRPCLink<T extends ClientContext> extends StandardLink<T> {
87
+ constructor(linkClient: StandardLinkClient<T>, options: StandardRPCLinkOptions<T>);
88
+ }
89
+
90
+ export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, StandardRPCJsonSerializer as e, StandardRPCLink as g, StandardRPCLinkCodec as i, StandardRPCSerializer as j };
91
+ export type { StandardRPCJsonSerializedMetaItem as a, StandardRPCJsonSerialized as b, StandardRPCCustomJsonSerializer as c, StandardRPCJsonSerializerOptions as d, StandardRPCLinkOptions as f, StandardRPCLinkCodecOptions as h };