@orpc/client 0.38.0 → 0.40.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,105 @@
1
+ // src/event-iterator-state.ts
2
+ var iteratorStates = /* @__PURE__ */ new WeakMap();
3
+ function registerEventIteratorState(iterator, state) {
4
+ iteratorStates.set(iterator, state);
5
+ }
6
+ function updateEventIteratorStatus(state, status) {
7
+ if (state.status !== status) {
8
+ state.status = status;
9
+ state.listeners.forEach((cb) => cb(status));
10
+ }
11
+ }
12
+ function onEventIteratorStatusChange(iterator, callback, notifyImmediately = true) {
13
+ const state = iteratorStates.get(iterator);
14
+ if (!state) {
15
+ throw new Error("Iterator is not registered.");
16
+ }
17
+ if (notifyImmediately) {
18
+ callback(state.status);
19
+ }
20
+ state.listeners.push(callback);
21
+ return () => {
22
+ const index = state.listeners.indexOf(callback);
23
+ if (index !== -1) {
24
+ state.listeners.splice(index, 1);
25
+ }
26
+ };
27
+ }
28
+
29
+ // src/event-iterator.ts
30
+ import { getEventMeta } from "@orpc/server-standard";
31
+ import { retry } from "@orpc/shared";
32
+ var MAX_ALLOWED_RETRY_TIMES = 99;
33
+ function createAutoRetryEventIterator(initial, reconnect, initialLastEventId) {
34
+ const state = {
35
+ status: "connected",
36
+ listeners: []
37
+ };
38
+ const iterator = async function* () {
39
+ let current = initial;
40
+ let lastEventId = initialLastEventId;
41
+ let lastRetry;
42
+ let retryTimes = 0;
43
+ try {
44
+ while (true) {
45
+ try {
46
+ updateEventIteratorStatus(state, "connected");
47
+ const { done, value } = await current.next();
48
+ const meta = getEventMeta(value);
49
+ lastEventId = meta?.id ?? lastEventId;
50
+ lastRetry = meta?.retry ?? lastRetry;
51
+ retryTimes = 0;
52
+ if (done) {
53
+ return value;
54
+ }
55
+ yield value;
56
+ } catch (e) {
57
+ updateEventIteratorStatus(state, "reconnecting");
58
+ const meta = getEventMeta(e);
59
+ lastEventId = meta?.id ?? lastEventId;
60
+ lastRetry = meta?.retry ?? lastRetry;
61
+ let currentError = e;
62
+ current = await retry({ times: MAX_ALLOWED_RETRY_TIMES }, async (exit) => {
63
+ retryTimes += 1;
64
+ if (retryTimes > MAX_ALLOWED_RETRY_TIMES) {
65
+ throw exit(new Error(
66
+ `Exceeded maximum retry attempts (${MAX_ALLOWED_RETRY_TIMES}) for event source. Possible infinite retry loop detected. Please review the retry logic.`,
67
+ { cause: currentError }
68
+ ));
69
+ }
70
+ const reconnected = await (async () => {
71
+ try {
72
+ return await reconnect({
73
+ lastRetry,
74
+ lastEventId,
75
+ retryTimes,
76
+ error: currentError
77
+ });
78
+ } catch (e2) {
79
+ currentError = e2;
80
+ throw e2;
81
+ }
82
+ })();
83
+ if (!reconnected) {
84
+ throw exit(currentError);
85
+ }
86
+ return reconnected;
87
+ });
88
+ }
89
+ }
90
+ } finally {
91
+ updateEventIteratorStatus(state, "closed");
92
+ await current.return?.();
93
+ }
94
+ }();
95
+ registerEventIteratorState(iterator, state);
96
+ return iterator;
97
+ }
98
+
99
+ export {
100
+ registerEventIteratorState,
101
+ updateEventIteratorStatus,
102
+ onEventIteratorStatusChange,
103
+ createAutoRetryEventIterator
104
+ };
105
+ //# sourceMappingURL=chunk-HYT35LXG.js.map
package/dist/fetch.js CHANGED
@@ -1,43 +1,73 @@
1
+ import {
2
+ createAutoRetryEventIterator
3
+ } from "./chunk-HYT35LXG.js";
4
+
1
5
  // src/adapters/fetch/orpc-link.ts
2
6
  import { ORPCError } from "@orpc/contract";
3
- import { fetchReToStandardBody } from "@orpc/server/fetch";
7
+ import { isAsyncIteratorObject } from "@orpc/server-standard";
8
+ import { toFetchBody, toStandardBody } from "@orpc/server-standard-fetch";
4
9
  import { RPCSerializer } from "@orpc/server/standard";
5
- import { isObject, trim } from "@orpc/shared";
6
- import { contentDisposition } from "@tinyhttp/content-disposition";
10
+ import { trim, value } from "@orpc/shared";
11
+ var InvalidEventSourceRetryResponse = class extends Error {
12
+ };
7
13
  var RPCLink = class {
8
14
  fetch;
9
15
  rpcSerializer;
10
- maxURLLength;
16
+ maxUrlLength;
11
17
  fallbackMethod;
12
- getMethod;
13
- getHeaders;
18
+ method;
19
+ headers;
14
20
  url;
21
+ eventSourceMaxNumberOfRetries;
22
+ eventSourceRetryDelay;
23
+ eventSourceRetry;
15
24
  constructor(options) {
16
25
  this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
17
26
  this.rpcSerializer = options.rpcSerializer ?? new RPCSerializer();
18
- this.maxURLLength = options.maxURLLength ?? 2083;
27
+ this.maxUrlLength = options.maxUrlLength ?? 2083;
19
28
  this.fallbackMethod = options.fallbackMethod ?? "POST";
20
29
  this.url = options.url;
21
- this.getMethod = async (path, input, context) => {
22
- return await options.method?.(path, input, context) ?? this.fallbackMethod;
23
- };
24
- this.getHeaders = async (path, input, context) => {
25
- return new Headers(await options.headers?.(path, input, context));
26
- };
30
+ this.eventSourceMaxNumberOfRetries = options.eventSourceMaxNumberOfRetries ?? 5;
31
+ this.method = options.method ?? this.fallbackMethod;
32
+ this.headers = options.headers ?? {};
33
+ this.eventSourceRetry = options.eventSourceRetry ?? true;
34
+ this.eventSourceRetryDelay = options.eventSourceRetryDelay ?? (({ retryTimes, lastRetry }) => lastRetry ?? 1e3 * 2 ** retryTimes);
27
35
  }
28
36
  async call(path, input, options) {
29
- const clientContext = options.context ?? {};
30
- const encoded = await this.encode(path, input, options);
31
- if (encoded.body instanceof Blob && !encoded.headers.has("content-disposition")) {
32
- encoded.headers.set("content-disposition", contentDisposition(encoded.body instanceof File ? encoded.body.name : "blob"));
37
+ const output = await this.performCall(path, input, options);
38
+ if (!isAsyncIteratorObject(output)) {
39
+ return output;
40
+ }
41
+ return createAutoRetryEventIterator(output, async (reconnectOptions) => {
42
+ if (options.signal?.aborted || reconnectOptions.retryTimes > this.eventSourceMaxNumberOfRetries) {
43
+ return null;
44
+ }
45
+ if (!await value(this.eventSourceRetry, reconnectOptions, options, path, input)) {
46
+ return null;
47
+ }
48
+ const delay = await value(this.eventSourceRetryDelay, reconnectOptions, options, path, input);
49
+ await new Promise((resolve) => setTimeout(resolve, delay));
50
+ const updatedOptions = { ...options, lastEventId: reconnectOptions.lastEventId };
51
+ const maybeIterator = await this.performCall(path, input, updatedOptions);
52
+ if (!isAsyncIteratorObject(maybeIterator)) {
53
+ throw new InvalidEventSourceRetryResponse("Invalid EventSource retry response");
54
+ }
55
+ return maybeIterator;
56
+ }, void 0);
57
+ }
58
+ async performCall(path, input, options) {
59
+ const encoded = await this.encodeRequest(path, input, options);
60
+ const fetchBody = toFetchBody(encoded.body, encoded.headers);
61
+ if (options.lastEventId !== void 0) {
62
+ encoded.headers.set("last-event-id", options.lastEventId);
33
63
  }
34
64
  const response = await this.fetch(encoded.url, {
35
65
  method: encoded.method,
36
66
  headers: encoded.headers,
37
- body: encoded.body,
67
+ body: fetchBody,
38
68
  signal: options.signal
39
- }, clientContext);
40
- const body = await fetchReToStandardBody(response);
69
+ }, options, path, input);
70
+ const body = await toStandardBody(response);
41
71
  const deserialized = (() => {
42
72
  try {
43
73
  return this.rpcSerializer.deserialize(body);
@@ -53,59 +83,44 @@ var RPCLink = class {
53
83
  });
54
84
  }
55
85
  })();
56
- if (response.ok) {
57
- return deserialized;
86
+ if (!response.ok) {
87
+ if (ORPCError.isValidJSON(deserialized)) {
88
+ throw ORPCError.fromJSON(deserialized);
89
+ }
90
+ throw new ORPCError("INTERNAL_SERVER_ERROR", {
91
+ message: "Invalid RPC error response",
92
+ cause: deserialized
93
+ });
58
94
  }
59
- throw ORPCError.fromJSON(deserialized);
95
+ return deserialized;
60
96
  }
61
- async encode(path, input, options) {
62
- const clientContext = options.context;
63
- const expectMethod = await this.getMethod(path, input, clientContext);
64
- const headers = await this.getHeaders(path, input, clientContext);
97
+ async encodeRequest(path, input, options) {
98
+ const expectedMethod = await value(this.method, options, path, input);
99
+ const headers = new Headers(await value(this.headers, options, path, input));
65
100
  const url = new URL(`${trim(this.url, "/")}/${path.map(encodeURIComponent).join("/")}`);
66
- headers.append("x-orpc-handler", "rpc");
67
101
  const serialized = this.rpcSerializer.serialize(input);
68
- if (expectMethod === "GET" && isObject(serialized)) {
69
- const tryURL = new URL(url);
70
- tryURL.searchParams.append("data", JSON.stringify(serialized));
71
- if (tryURL.toString().length <= this.maxURLLength) {
102
+ if (expectedMethod === "GET" && !(serialized instanceof FormData) && !isAsyncIteratorObject(serialized)) {
103
+ const getUrl = new URL(url);
104
+ getUrl.searchParams.append("data", JSON.stringify(serialized));
105
+ if (getUrl.toString().length <= this.maxUrlLength) {
72
106
  return {
73
107
  body: void 0,
74
- method: expectMethod,
108
+ method: expectedMethod,
75
109
  headers,
76
- url: tryURL
110
+ url: getUrl
77
111
  };
78
112
  }
79
113
  }
80
- const method = expectMethod === "GET" ? this.fallbackMethod : expectMethod;
81
- if (input === void 0) {
82
- return {
83
- body: void 0,
84
- method,
85
- headers,
86
- url
87
- };
88
- }
89
- if (isObject(serialized)) {
90
- if (!headers.has("content-type")) {
91
- headers.set("content-type", "application/json");
92
- }
93
- return {
94
- body: JSON.stringify(serialized),
95
- method,
96
- headers,
97
- url
98
- };
99
- }
100
114
  return {
101
- body: serialized,
102
- method,
115
+ url,
116
+ method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
103
117
  headers,
104
- url
118
+ body: serialized
105
119
  };
106
120
  }
107
121
  };
108
122
  export {
123
+ InvalidEventSourceRetryResponse,
109
124
  RPCLink
110
125
  };
111
126
  //# sourceMappingURL=fetch.js.map
package/dist/index.js CHANGED
@@ -1,8 +1,20 @@
1
+ import {
2
+ createAutoRetryEventIterator,
3
+ onEventIteratorStatusChange,
4
+ registerEventIteratorState,
5
+ updateEventIteratorStatus
6
+ } from "./chunk-HYT35LXG.js";
7
+
1
8
  // src/client.ts
2
9
  function createORPCClient(link, options) {
3
10
  const path = options?.path ?? [];
4
11
  const procedureClient = async (...[input, options2]) => {
5
- return await link.call(path, input, options2 ?? {});
12
+ const optionsOut = {
13
+ ...options2,
14
+ context: options2?.context ?? {}
15
+ // options.context can be undefined when all field is optional
16
+ };
17
+ return await link.call(path, input, optionsOut);
6
18
  };
7
19
  const recursive = new Proxy(procedureClient, {
8
20
  get(target, key) {
@@ -24,9 +36,8 @@ var DynamicLink = class {
24
36
  this.linkResolver = linkResolver;
25
37
  }
26
38
  async call(path, input, options) {
27
- const clientContext = options.context ?? {};
28
- const resolvedLink = await this.linkResolver(path, input, clientContext);
29
- const output = await resolvedLink.call(path, input, { ...options, context: clientContext });
39
+ const resolvedLink = await this.linkResolver(options, path, input);
40
+ const output = await resolvedLink.call(path, input, options);
30
41
  return output;
31
42
  }
32
43
  };
@@ -36,8 +47,12 @@ import { isDefinedError, ORPCError, safe } from "@orpc/contract";
36
47
  export {
37
48
  DynamicLink,
38
49
  ORPCError,
50
+ createAutoRetryEventIterator,
39
51
  createORPCClient,
40
52
  isDefinedError,
41
- safe
53
+ onEventIteratorStatusChange,
54
+ registerEventIteratorState,
55
+ safe,
56
+ updateEventIteratorStatus
42
57
  };
43
58
  //# sourceMappingURL=index.js.map
@@ -1,8 +1,11 @@
1
- import type { ClientContext, ClientOptions, HTTPMethod } from '@orpc/contract';
2
- import type { Promisable } from '@orpc/shared';
3
- import type { ClientLink } from '../../types';
1
+ import type { ClientContext, HTTPMethod } from '@orpc/contract';
2
+ import type { Value } from '@orpc/shared';
3
+ import type { ClientLink, ClientOptionsOut } from '../../types';
4
4
  import type { FetchWithContext } from './types';
5
5
  import { RPCSerializer } from '@orpc/server/standard';
6
+ import { type EventIteratorReconnectOptions } from '../../event-iterator';
7
+ export declare class InvalidEventSourceRetryResponse extends Error {
8
+ }
6
9
  export interface RPCLinkOptions<TClientContext extends ClientContext> {
7
10
  /**
8
11
  * Base url for all requests.
@@ -13,13 +16,17 @@ export interface RPCLinkOptions<TClientContext extends ClientContext> {
13
16
  *
14
17
  * @default 2083
15
18
  */
16
- maxURLLength?: number;
19
+ maxUrlLength?: number;
17
20
  /**
18
21
  * The method used to make the request.
19
22
  *
20
23
  * @default 'POST'
21
24
  */
22
- method?(path: readonly string[], input: unknown, context: TClientContext): Promisable<HTTPMethod | undefined>;
25
+ method?: Value<HTTPMethod, [
26
+ options: ClientOptionsOut<TClientContext>,
27
+ path: readonly string[],
28
+ input: unknown
29
+ ]>;
23
30
  /**
24
31
  * The method to use when the payload cannot safely pass to the server with method return from method function.
25
32
  * GET is not allowed, it's very dangerous.
@@ -27,20 +34,64 @@ export interface RPCLinkOptions<TClientContext extends ClientContext> {
27
34
  * @default 'POST'
28
35
  */
29
36
  fallbackMethod?: Exclude<HTTPMethod, 'GET'>;
30
- headers?(path: readonly string[], input: unknown, context: TClientContext): Promisable<Headers | Record<string, string>>;
37
+ /**
38
+ * Inject headers to the request.
39
+ */
40
+ headers?: Value<[string, string][] | Record<string, string> | Headers, [
41
+ options: ClientOptionsOut<TClientContext>,
42
+ path: readonly string[],
43
+ input: unknown
44
+ ]>;
45
+ /**
46
+ * Custom fetch implementation.
47
+ *
48
+ * @default globalThis.fetch.bind(globalThis)
49
+ */
31
50
  fetch?: FetchWithContext<TClientContext>;
32
51
  rpcSerializer?: RPCSerializer;
52
+ /**
53
+ * Maximum number of retry attempts for EventSource errors before throwing.
54
+ *
55
+ * @default 5
56
+ */
57
+ eventSourceMaxNumberOfRetries?: number;
58
+ /**
59
+ * Delay (in ms) before retrying an EventSource call.
60
+ *
61
+ * @default ({retryTimes, lastRetry}) => lastRetry ?? (1000 * 2 ** retryTimes)
62
+ */
63
+ eventSourceRetryDelay?: Value<number, [
64
+ reconnectOptions: EventIteratorReconnectOptions,
65
+ options: ClientOptionsOut<TClientContext>,
66
+ path: readonly string[],
67
+ input: unknown
68
+ ]>;
69
+ /**
70
+ * Function to determine if an error is retryable.
71
+ *
72
+ * @default true
73
+ */
74
+ eventSourceRetry?: Value<boolean, [
75
+ reconnectOptions: EventIteratorReconnectOptions,
76
+ options: ClientOptionsOut<TClientContext>,
77
+ path: readonly string[],
78
+ input: unknown
79
+ ]>;
33
80
  }
34
81
  export declare class RPCLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
35
82
  private readonly fetch;
36
83
  private readonly rpcSerializer;
37
- private readonly maxURLLength;
84
+ private readonly maxUrlLength;
38
85
  private readonly fallbackMethod;
39
- private readonly getMethod;
40
- private readonly getHeaders;
86
+ private readonly method;
87
+ private readonly headers;
41
88
  private readonly url;
89
+ private readonly eventSourceMaxNumberOfRetries;
90
+ private readonly eventSourceRetryDelay;
91
+ private readonly eventSourceRetry;
42
92
  constructor(options: RPCLinkOptions<TClientContext>);
43
- call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
44
- private encode;
93
+ call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
94
+ private performCall;
95
+ private encodeRequest;
45
96
  }
46
97
  //# sourceMappingURL=orpc-link.d.ts.map
@@ -1,5 +1,6 @@
1
1
  import type { ClientContext } from '@orpc/contract';
2
+ import type { ClientOptionsOut } from '../../types';
2
3
  export interface FetchWithContext<TClientContext extends ClientContext> {
3
- (url: Request | string | URL, init: RequestInit | undefined, context: TClientContext): Promise<Response>;
4
+ (url: URL, init: RequestInit, options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown): Promise<Response>;
4
5
  }
5
6
  //# sourceMappingURL=types.d.ts.map
@@ -1,13 +1,13 @@
1
- import type { ClientContext, ClientOptions } from '@orpc/contract';
1
+ import type { ClientContext } from '@orpc/contract';
2
2
  import type { Promisable } from '@orpc/shared';
3
- import type { ClientLink } from './types';
3
+ import type { ClientLink, ClientOptionsOut } from './types';
4
4
  /**
5
5
  * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
6
6
  * based on the request path, input, and context.
7
7
  */
8
8
  export declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
9
9
  private readonly linkResolver;
10
- constructor(linkResolver: (path: readonly string[], input: unknown, context: TClientContext) => Promisable<ClientLink<TClientContext>>);
11
- call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
10
+ constructor(linkResolver: (options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
11
+ call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
12
12
  }
13
13
  //# sourceMappingURL=dynamic-link.d.ts.map
@@ -0,0 +1,9 @@
1
+ export type ConnectionStatus = 'reconnecting' | 'connected' | 'closed';
2
+ export interface EventIteratorState {
3
+ status: ConnectionStatus;
4
+ listeners: Array<(newStatus: ConnectionStatus) => void>;
5
+ }
6
+ export declare function registerEventIteratorState(iterator: AsyncIteratorObject<unknown, unknown, void>, state: EventIteratorState): void;
7
+ export declare function updateEventIteratorStatus(state: EventIteratorState, status: ConnectionStatus): void;
8
+ export declare function onEventIteratorStatusChange(iterator: AsyncIteratorObject<unknown, unknown, void>, callback: (status: ConnectionStatus) => void, notifyImmediately?: boolean): () => void;
9
+ //# sourceMappingURL=event-iterator-state.d.ts.map
@@ -0,0 +1,8 @@
1
+ export interface EventIteratorReconnectOptions {
2
+ lastRetry: number | undefined;
3
+ lastEventId: string | undefined;
4
+ retryTimes: number;
5
+ error: unknown;
6
+ }
7
+ export declare function createAutoRetryEventIterator<TYield, TReturn>(initial: AsyncIterator<TYield, TReturn, void>, reconnect: (options: EventIteratorReconnectOptions) => Promise<AsyncIterator<TYield, TReturn, void> | null>, initialLastEventId: string | undefined): AsyncGenerator<TYield, TReturn, void>;
8
+ //# sourceMappingURL=event-iterator.d.ts.map
@@ -1,6 +1,8 @@
1
1
  /** unnoq */
2
2
  export * from './client';
3
3
  export * from './dynamic-link';
4
+ export * from './event-iterator';
5
+ export * from './event-iterator-state';
4
6
  export * from './types';
5
7
  export { isDefinedError, ORPCError, safe } from '@orpc/contract';
6
8
  //# sourceMappingURL=index.d.ts.map
@@ -1,5 +1,8 @@
1
1
  import type { ClientContext, ClientOptions } from '@orpc/contract';
2
+ export type ClientOptionsOut<TClientContext extends ClientContext> = ClientOptions<TClientContext> & {
3
+ context: TClientContext;
4
+ };
2
5
  export interface ClientLink<TClientContext extends ClientContext> {
3
- call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
6
+ call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
4
7
  }
5
8
  //# sourceMappingURL=types.d.ts.map
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "@orpc/client",
3
3
  "type": "module",
4
- "version": "0.38.0",
4
+ "version": "0.40.0",
5
5
  "license": "MIT",
6
6
  "homepage": "https://orpc.unnoq.com",
7
7
  "repository": {
@@ -34,17 +34,18 @@
34
34
  "dist"
35
35
  ],
36
36
  "dependencies": {
37
- "@tinyhttp/content-disposition": "^2.2.2",
38
- "@orpc/contract": "0.38.0",
39
- "@orpc/shared": "0.38.0",
40
- "@orpc/server": "0.38.0"
37
+ "@orpc/server-standard": "^0.4.0",
38
+ "@orpc/server-standard-fetch": "^0.4.0",
39
+ "@orpc/contract": "0.40.0",
40
+ "@orpc/server": "0.40.0",
41
+ "@orpc/shared": "0.40.0"
41
42
  },
42
43
  "devDependencies": {
43
44
  "zod": "^3.24.1",
44
- "@orpc/openapi": "0.38.0"
45
+ "@orpc/openapi": "0.40.0"
45
46
  },
46
47
  "scripts": {
47
- "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/adapters/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
48
+ "build": "tsup --onSuccess='tsc -b --noCheck'",
48
49
  "build:watch": "pnpm run build --watch",
49
50
  "type:check": "tsc -b"
50
51
  }