@wats/graph 0.3.9 → 0.3.10
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/index.d.ts +1 -0
- package/dist/index.js +1 -0
- package/dist/reliableTransport.d.ts +17 -0
- package/dist/reliableTransport.js +175 -0
- package/dist/transport.d.ts +2 -0
- package/dist/transport.js +3 -0
- package/package.json +1 -1
package/dist/index.d.ts
CHANGED
|
@@ -12,6 +12,7 @@ export type { PhoneNumberClientConfig } from "./subclients/phoneNumberClient.js"
|
|
|
12
12
|
export { WABAClient, validateWABAClientConfig } from "./subclients/wabaClient.js";
|
|
13
13
|
export type { WABAClientConfig } from "./subclients/wabaClient.js";
|
|
14
14
|
export * from "./transport.js";
|
|
15
|
+
export * from "./reliableTransport.js";
|
|
15
16
|
export { createFetchTransport } from "./createFetchTransport.js";
|
|
16
17
|
export type { CreateFetchTransportOptions } from "./createFetchTransport.js";
|
|
17
18
|
export { paginate, paginateAll, PaginationError } from "./pagination.js";
|
package/dist/index.js
CHANGED
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
import type { Transport, TransportRequest, TransportResponse, TransportRetryPolicy } from "./transport.js";
|
|
2
|
+
export interface ReliableTransportRetryContext {
|
|
3
|
+
readonly attempt: number;
|
|
4
|
+
readonly request: TransportRequest;
|
|
5
|
+
readonly response?: TransportResponse;
|
|
6
|
+
readonly error?: unknown;
|
|
7
|
+
}
|
|
8
|
+
export interface ReliableTransportOptions extends Partial<TransportRetryPolicy> {
|
|
9
|
+
readonly timeoutMs?: number;
|
|
10
|
+
readonly retryOn?: (ctx: ReliableTransportRetryContext) => boolean;
|
|
11
|
+
readonly onRetry?: (ctx: ReliableTransportRetryContext & {
|
|
12
|
+
readonly delayMs: number;
|
|
13
|
+
}) => void | Promise<void>;
|
|
14
|
+
readonly sleep?: (delayMs: number) => Promise<void>;
|
|
15
|
+
readonly random?: () => number;
|
|
16
|
+
}
|
|
17
|
+
export declare function createReliableTransport(inner: Transport, options?: ReliableTransportOptions): Transport;
|
|
@@ -0,0 +1,175 @@
|
|
|
1
|
+
import { GraphNetworkError } from "./errors.js";
|
|
2
|
+
import { DEFAULT_TRANSPORT_RETRY_POLICY } from "./transport.js";
|
|
3
|
+
function assertFiniteNumber(value, name, min) {
|
|
4
|
+
if (typeof value !== "number" || !Number.isFinite(value) || value < min) {
|
|
5
|
+
throw new Error(`ReliableTransportOptions: ${name} must be a finite number >= ${min}.`);
|
|
6
|
+
}
|
|
7
|
+
return value;
|
|
8
|
+
}
|
|
9
|
+
function assertNonNegativeInteger(value, name) {
|
|
10
|
+
if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
|
|
11
|
+
throw new Error(`ReliableTransportOptions: ${name} must be a non-negative integer.`);
|
|
12
|
+
}
|
|
13
|
+
return value;
|
|
14
|
+
}
|
|
15
|
+
function defaultSleep(delayMs) {
|
|
16
|
+
return new Promise((resolve) => setTimeout(resolve, delayMs));
|
|
17
|
+
}
|
|
18
|
+
function resolvePolicy(options) {
|
|
19
|
+
const retries = assertNonNegativeInteger(options?.retries ?? DEFAULT_TRANSPORT_RETRY_POLICY.retries, "retries");
|
|
20
|
+
const baseDelayMs = assertFiniteNumber(options?.baseDelayMs ?? DEFAULT_TRANSPORT_RETRY_POLICY.baseDelayMs, "baseDelayMs", 0);
|
|
21
|
+
const maxDelayMs = assertFiniteNumber(options?.maxDelayMs ?? DEFAULT_TRANSPORT_RETRY_POLICY.maxDelayMs, "maxDelayMs", 1);
|
|
22
|
+
if (baseDelayMs > maxDelayMs)
|
|
23
|
+
throw new Error("ReliableTransportOptions: baseDelayMs must be <= maxDelayMs.");
|
|
24
|
+
if (options?.timeoutMs !== undefined)
|
|
25
|
+
assertFiniteNumber(options.timeoutMs, "timeoutMs", 1);
|
|
26
|
+
if (options?.jitter !== undefined && typeof options.jitter !== "function")
|
|
27
|
+
throw new Error("ReliableTransportOptions: jitter must be a function.");
|
|
28
|
+
if (options?.retryOn !== undefined && typeof options.retryOn !== "function")
|
|
29
|
+
throw new Error("ReliableTransportOptions: retryOn must be a function.");
|
|
30
|
+
if (options?.onRetry !== undefined && typeof options.onRetry !== "function")
|
|
31
|
+
throw new Error("ReliableTransportOptions: onRetry must be a function.");
|
|
32
|
+
if (options?.sleep !== undefined && typeof options.sleep !== "function")
|
|
33
|
+
throw new Error("ReliableTransportOptions: sleep must be a function.");
|
|
34
|
+
if (options?.random !== undefined && typeof options.random !== "function")
|
|
35
|
+
throw new Error("ReliableTransportOptions: random must be a function.");
|
|
36
|
+
return {
|
|
37
|
+
retries,
|
|
38
|
+
baseDelayMs,
|
|
39
|
+
maxDelayMs,
|
|
40
|
+
...options?.jitter !== undefined ? { jitter: options.jitter } : {},
|
|
41
|
+
...options?.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {},
|
|
42
|
+
...options?.retryOn !== undefined ? { retryOn: options.retryOn } : {},
|
|
43
|
+
...options?.onRetry !== undefined ? { onRetry: options.onRetry } : {},
|
|
44
|
+
sleep: options?.sleep ?? defaultSleep,
|
|
45
|
+
random: options?.random ?? Math.random
|
|
46
|
+
};
|
|
47
|
+
}
|
|
48
|
+
function isRetryableMethod(method) {
|
|
49
|
+
return method === "GET" || method === "DELETE";
|
|
50
|
+
}
|
|
51
|
+
function defaultRetryOn(ctx) {
|
|
52
|
+
const status = ctx.response?.status;
|
|
53
|
+
if (status === 429)
|
|
54
|
+
return true;
|
|
55
|
+
if (!isRetryableMethod(ctx.request.method))
|
|
56
|
+
return false;
|
|
57
|
+
if (ctx.error instanceof GraphNetworkError)
|
|
58
|
+
return true;
|
|
59
|
+
return typeof status === "number" && status >= 500 && status < 600;
|
|
60
|
+
}
|
|
61
|
+
function parseRetryAfterMs(header, nowMs) {
|
|
62
|
+
if (header === null)
|
|
63
|
+
return null;
|
|
64
|
+
const trimmed = header.trim();
|
|
65
|
+
if (trimmed.length === 0)
|
|
66
|
+
return null;
|
|
67
|
+
if (/^\d+(?:\.\d+)?$/u.test(trimmed)) {
|
|
68
|
+
const seconds = Number(trimmed);
|
|
69
|
+
if (Number.isFinite(seconds))
|
|
70
|
+
return seconds * 1000;
|
|
71
|
+
}
|
|
72
|
+
if (trimmed.startsWith("-"))
|
|
73
|
+
return null;
|
|
74
|
+
const dateMs = Date.parse(trimmed);
|
|
75
|
+
if (Number.isFinite(dateMs))
|
|
76
|
+
return Math.max(0, dateMs - nowMs);
|
|
77
|
+
return null;
|
|
78
|
+
}
|
|
79
|
+
function boundedDelayMs(attempt, response, policy) {
|
|
80
|
+
const retryAfter = parseRetryAfterMs(response?.headers.get("retry-after") ?? null, Date.now());
|
|
81
|
+
if (retryAfter !== null)
|
|
82
|
+
return Math.min(retryAfter, policy.maxDelayMs);
|
|
83
|
+
const exponential = Math.min(policy.baseDelayMs * 2 ** Math.max(0, attempt - 1), policy.maxDelayMs);
|
|
84
|
+
if (policy.jitter !== undefined) {
|
|
85
|
+
const custom = policy.jitter(attempt, policy.baseDelayMs);
|
|
86
|
+
return Math.min(assertFiniteNumber(custom, "jitter result", 0), policy.maxDelayMs);
|
|
87
|
+
}
|
|
88
|
+
const random = policy.random();
|
|
89
|
+
if (typeof random !== "number" || !Number.isFinite(random) || random < 0 || random > 1) {
|
|
90
|
+
throw new Error("ReliableTransportOptions: random must return a finite number in [0, 1].");
|
|
91
|
+
}
|
|
92
|
+
return Math.floor(exponential * random);
|
|
93
|
+
}
|
|
94
|
+
function composeSignal(caller, timeoutMs) {
|
|
95
|
+
if (timeoutMs === undefined)
|
|
96
|
+
return caller;
|
|
97
|
+
const timeoutSignal = AbortSignal.timeout(timeoutMs);
|
|
98
|
+
if (caller === undefined)
|
|
99
|
+
return timeoutSignal;
|
|
100
|
+
return AbortSignal.any([caller, timeoutSignal]);
|
|
101
|
+
}
|
|
102
|
+
function throwIfAborted(signal) {
|
|
103
|
+
if (signal?.aborted) {
|
|
104
|
+
const reason = signal.reason;
|
|
105
|
+
if (reason instanceof Error)
|
|
106
|
+
throw reason;
|
|
107
|
+
throw new GraphNetworkError("Transport request aborted by caller.");
|
|
108
|
+
}
|
|
109
|
+
}
|
|
110
|
+
async function cancelRetryResponseBody(response) {
|
|
111
|
+
try {
|
|
112
|
+
await response.body?.cancel();
|
|
113
|
+
} catch {}
|
|
114
|
+
}
|
|
115
|
+
async function sleepWithAbort(sleep, delayMs, signal) {
|
|
116
|
+
if (signal === undefined) {
|
|
117
|
+
await sleep(delayMs);
|
|
118
|
+
return;
|
|
119
|
+
}
|
|
120
|
+
throwIfAborted(signal);
|
|
121
|
+
let onAbort;
|
|
122
|
+
const aborted = new Promise((_resolve, reject) => {
|
|
123
|
+
onAbort = () => {
|
|
124
|
+
const reason = signal.reason;
|
|
125
|
+
reject(reason instanceof Error ? reason : new GraphNetworkError("Transport request aborted by caller."));
|
|
126
|
+
};
|
|
127
|
+
signal.addEventListener("abort", onAbort, { once: true });
|
|
128
|
+
});
|
|
129
|
+
try {
|
|
130
|
+
await Promise.race([sleep(delayMs), aborted]);
|
|
131
|
+
} finally {
|
|
132
|
+
if (onAbort !== undefined)
|
|
133
|
+
signal.removeEventListener("abort", onAbort);
|
|
134
|
+
}
|
|
135
|
+
}
|
|
136
|
+
export function createReliableTransport(inner, options) {
|
|
137
|
+
if (inner === null || typeof inner !== "object" || typeof inner.request !== "function") {
|
|
138
|
+
throw new Error("ReliableTransportOptions: inner transport must implement request().");
|
|
139
|
+
}
|
|
140
|
+
return {
|
|
141
|
+
async request(req, opts) {
|
|
142
|
+
const policy = resolvePolicy(options);
|
|
143
|
+
let attempt = 0;
|
|
144
|
+
for (;; ) {
|
|
145
|
+
throwIfAborted(opts?.signal);
|
|
146
|
+
attempt += 1;
|
|
147
|
+
const composedSignal = composeSignal(opts?.signal, policy.timeoutMs);
|
|
148
|
+
const attemptOpts = composedSignal !== undefined ? { signal: composedSignal } : undefined;
|
|
149
|
+
try {
|
|
150
|
+
const response = await inner.request(req, attemptOpts);
|
|
151
|
+
const ctx = { attempt, request: req, response };
|
|
152
|
+
const shouldRetry = (policy.retryOn ?? defaultRetryOn)(ctx);
|
|
153
|
+
if (!shouldRetry || attempt > policy.retries)
|
|
154
|
+
return response;
|
|
155
|
+
await cancelRetryResponseBody(response);
|
|
156
|
+
throwIfAborted(opts?.signal);
|
|
157
|
+
const delayMs = boundedDelayMs(attempt, response, policy);
|
|
158
|
+
await policy.onRetry?.({ ...ctx, delayMs });
|
|
159
|
+
await sleepWithAbort(policy.sleep, delayMs, opts?.signal);
|
|
160
|
+
} catch (error) {
|
|
161
|
+
if (opts?.signal?.aborted)
|
|
162
|
+
throw error;
|
|
163
|
+
const ctx = { attempt, request: req, error };
|
|
164
|
+
const shouldRetry = (policy.retryOn ?? defaultRetryOn)(ctx);
|
|
165
|
+
if (!shouldRetry || attempt > policy.retries)
|
|
166
|
+
throw error;
|
|
167
|
+
throwIfAborted(opts?.signal);
|
|
168
|
+
const delayMs = boundedDelayMs(attempt, undefined, policy);
|
|
169
|
+
await policy.onRetry?.({ ...ctx, delayMs });
|
|
170
|
+
await sleepWithAbort(policy.sleep, delayMs, opts?.signal);
|
|
171
|
+
}
|
|
172
|
+
}
|
|
173
|
+
}
|
|
174
|
+
};
|
|
175
|
+
}
|
package/dist/transport.d.ts
CHANGED
|
@@ -30,3 +30,5 @@ export interface TransportInterceptor {
|
|
|
30
30
|
onRequest?(req: TransportRequest): TransportRequest | Promise<TransportRequest>;
|
|
31
31
|
onResponse?(req: TransportRequest, res: TransportResponse): TransportResponse | Promise<TransportResponse>;
|
|
32
32
|
}
|
|
33
|
+
export { createReliableTransport } from "./reliableTransport.js";
|
|
34
|
+
export type { ReliableTransportOptions, ReliableTransportRetryContext } from "./reliableTransport.js";
|
package/dist/transport.js
CHANGED