@nsxbet/react-relay-network-modern 1.0.0

package/dist/middlewares/logger.d.ts

@@ -0,0 +1,9 @@
+import { Middleware } from "../definition.js";
+
+//#region src/middlewares/logger.d.ts
+interface LoggerMiddlewareOpts {
+  logger?: Function;
+}
+declare function loggerMiddleware(opts?: LoggerMiddlewareOpts): Middleware;
+//#endregion
+export { LoggerMiddlewareOpts, loggerMiddleware };

package/dist/middlewares/logger.js

@@ -0,0 +1,43 @@
+import RelayRequest from "../RelayRequest.js";
+import RelayRequestBatch from "../RelayRequestBatch.js";
+//#region src/middlewares/logger.ts
+function loggerMiddleware(opts) {
+	const logger = opts && opts.logger || console.log.bind(console, "[RELAY-NETWORK]");
+	return (next) => (req) => {
+		const start = (/* @__PURE__ */ new Date()).getTime();
+		logger(`Run ${req.getID()}`, req);
+		return next(req).then((res) => {
+			const end = (/* @__PURE__ */ new Date()).getTime();
+			let queryId;
+			let queryData;
+			if (req instanceof RelayRequest) {
+				queryId = req.getID();
+				queryData = {
+					query: req.getQueryString(),
+					variables: req.getVariables()
+				};
+			} else if (req instanceof RelayRequestBatch) {
+				queryId = req.getID();
+				queryData = {
+					requestList: req.requests,
+					responseList: res.json
+				};
+			} else {
+				queryId = "CustomRequest";
+				queryData = {};
+			}
+			logger(`Done ${queryId} in ${end - start}ms`, {
+				...queryData,
+				req,
+				res
+			});
+			if (res.status !== 200) logger(`Status ${res.status}: ${res.statusText || ""} for ${queryId}`);
+			return res;
+		}, (error) => {
+			if (error && error.name && error.name === "AbortError") logger(`Cancelled ${req.getID()}`);
+			throw error;
+		});
+	};
+}
+//#endregion
+export { loggerMiddleware as default };

package/dist/middlewares/perf.cjs

@@ -0,0 +1,13 @@
+//#region src/middlewares/perf.ts
+function performanceMiddleware(opts) {
+	const logger = opts && opts.logger || console.log.bind(console, "[RELAY-NETWORK]");
+	return (next) => (req) => {
+		const start = (/* @__PURE__ */ new Date()).getTime();
+		return next(req).then((res) => {
+			logger(`[${(/* @__PURE__ */ new Date()).getTime() - start}ms] ${req.getID()}`, req, res);
+			return res;
+		});
+	};
+}
+//#endregion
+exports.default = performanceMiddleware;

package/dist/middlewares/perf.d.cts

@@ -0,0 +1,9 @@
+import { Middleware } from "../definition.cjs";
+
+//#region src/middlewares/perf.d.ts
+interface PerfMiddlewareOpts {
+  logger?: Function;
+}
+declare function performanceMiddleware(opts?: PerfMiddlewareOpts): Middleware;
+//#endregion
+export { PerfMiddlewareOpts, performanceMiddleware };

package/dist/middlewares/perf.d.ts

@@ -0,0 +1,9 @@
+import { Middleware } from "../definition.js";
+
+//#region src/middlewares/perf.d.ts
+interface PerfMiddlewareOpts {
+  logger?: Function;
+}
+declare function performanceMiddleware(opts?: PerfMiddlewareOpts): Middleware;
+//#endregion
+export { PerfMiddlewareOpts, performanceMiddleware };

package/dist/middlewares/perf.js

@@ -0,0 +1,13 @@
+//#region src/middlewares/perf.ts
+function performanceMiddleware(opts) {
+	const logger = opts && opts.logger || console.log.bind(console, "[RELAY-NETWORK]");
+	return (next) => (req) => {
+		const start = (/* @__PURE__ */ new Date()).getTime();
+		return next(req).then((res) => {
+			logger(`[${(/* @__PURE__ */ new Date()).getTime() - start}ms] ${req.getID()}`, req, res);
+			return res;
+		});
+	};
+}
+//#endregion
+export { performanceMiddleware as default };

package/dist/middlewares/persistedQueries.cjs

@@ -0,0 +1,33 @@
+//#region src/middlewares/persistedQueries.ts
+async function makePersistedQueryRequestWithFallback(o, original = false, hasRunFallback = false) {
+	const makeFallback = async (prevError) => {
+		if (hasRunFallback) throw prevError;
+		return makePersistedQueryRequestWithFallback(o, true, true);
+	};
+	const makeRequest = async () => {
+		try {
+			const persistedQueriesReq = JSON.parse(JSON.stringify(o.req));
+			const { cacheID, id, text: queryText } = persistedQueriesReq.operation;
+			const queryId = id || cacheID;
+			if (!queryId && (!o.options?.hash || !queryText)) throw new Error("Either query id or hashing function & query must be defined!");
+			const body = JSON.parse(persistedQueriesReq.fetchOpts.body);
+			delete body.query;
+			body.doc_id = queryId;
+			persistedQueriesReq.fetchOpts.body = JSON.stringify(body);
+			delete persistedQueriesReq.operation.text;
+			return await o.next(original ? o.req : persistedQueriesReq);
+		} catch (e) {
+			return makeFallback(e);
+		}
+	};
+	return makeRequest();
+}
+function persistedQueriesMiddleware(options) {
+	return (next) => (req) => makePersistedQueryRequestWithFallback({
+		req,
+		next,
+		options
+	});
+}
+//#endregion
+exports.default = persistedQueriesMiddleware;

package/dist/middlewares/persistedQueries.d.cts

@@ -0,0 +1,9 @@
+import { Middleware } from "../definition.cjs";
+
+//#region src/middlewares/persistedQueries.d.ts
+interface PersistedQueriesMiddlewareOpts {
+  hash: string;
+}
+declare function persistedQueriesMiddleware(options?: PersistedQueriesMiddlewareOpts): Middleware;
+//#endregion
+export { PersistedQueriesMiddlewareOpts, persistedQueriesMiddleware };

package/dist/middlewares/persistedQueries.d.ts

@@ -0,0 +1,9 @@
+import { Middleware } from "../definition.js";
+
+//#region src/middlewares/persistedQueries.d.ts
+interface PersistedQueriesMiddlewareOpts {
+  hash: string;
+}
+declare function persistedQueriesMiddleware(options?: PersistedQueriesMiddlewareOpts): Middleware;
+//#endregion
+export { PersistedQueriesMiddlewareOpts, persistedQueriesMiddleware };

package/dist/middlewares/persistedQueries.js

@@ -0,0 +1,33 @@
+//#region src/middlewares/persistedQueries.ts
+async function makePersistedQueryRequestWithFallback(o, original = false, hasRunFallback = false) {
+	const makeFallback = async (prevError) => {
+		if (hasRunFallback) throw prevError;
+		return makePersistedQueryRequestWithFallback(o, true, true);
+	};
+	const makeRequest = async () => {
+		try {
+			const persistedQueriesReq = JSON.parse(JSON.stringify(o.req));
+			const { cacheID, id, text: queryText } = persistedQueriesReq.operation;
+			const queryId = id || cacheID;
+			if (!queryId && (!o.options?.hash || !queryText)) throw new Error("Either query id or hashing function & query must be defined!");
+			const body = JSON.parse(persistedQueriesReq.fetchOpts.body);
+			delete body.query;
+			body.doc_id = queryId;
+			persistedQueriesReq.fetchOpts.body = JSON.stringify(body);
+			delete persistedQueriesReq.operation.text;
+			return await o.next(original ? o.req : persistedQueriesReq);
+		} catch (e) {
+			return makeFallback(e);
+		}
+	};
+	return makeRequest();
+}
+function persistedQueriesMiddleware(options) {
+	return (next) => (req) => makePersistedQueryRequestWithFallback({
+		req,
+		next,
+		options
+	});
+}
+//#endregion
+export { persistedQueriesMiddleware as default };

package/dist/middlewares/progress.cjs

@@ -0,0 +1,35 @@
+//#region src/middlewares/progress.ts
+function createProgressHandler(opts) {
+	const { onProgress, sizeHeader = "Content-Length" } = opts || {};
+	return async (res) => {
+		const { body, headers } = res;
+		if (!body) return;
+		const totalResponseSize = headers.get(sizeHeader);
+		let totalSize = null;
+		if (totalResponseSize !== null) totalSize = parseInt(totalResponseSize, 10);
+		const reader = body.getReader();
+		let completed = false;
+		let runningTotal = 0;
+		do {
+			const { done, value } = await reader.read();
+			const length = value && value.length || 0;
+			completed = done;
+			if (!completed) {
+				runningTotal += length;
+				onProgress(runningTotal, totalSize);
+			}
+		} while (!completed);
+	};
+}
+function progressMiddleware(opts) {
+	const progressHandler = createProgressHandler(opts);
+	const mw = (next) => async (req) => {
+		const res = await next(req);
+		progressHandler(res.clone());
+		return res;
+	};
+	mw.isRawMiddleware = true;
+	return mw;
+}
+//#endregion
+exports.default = progressMiddleware;

package/dist/middlewares/progress.d.cts

@@ -0,0 +1,10 @@
+import { MiddlewareRaw } from "../definition.cjs";
+
+//#region src/middlewares/progress.d.ts
+interface ProgressOpts {
+  sizeHeader?: string;
+  onProgress: (runningTotal: number, totalSize: number | null) => any;
+}
+declare function progressMiddleware(opts: ProgressOpts): MiddlewareRaw;
+//#endregion
+export { ProgressOpts, progressMiddleware };

package/dist/middlewares/progress.d.ts

@@ -0,0 +1,10 @@
+import { MiddlewareRaw } from "../definition.js";
+
+//#region src/middlewares/progress.d.ts
+interface ProgressOpts {
+  sizeHeader?: string;
+  onProgress: (runningTotal: number, totalSize: number | null) => any;
+}
+declare function progressMiddleware(opts: ProgressOpts): MiddlewareRaw;
+//#endregion
+export { ProgressOpts, progressMiddleware };

package/dist/middlewares/progress.js

@@ -0,0 +1,35 @@
+//#region src/middlewares/progress.ts
+function createProgressHandler(opts) {
+	const { onProgress, sizeHeader = "Content-Length" } = opts || {};
+	return async (res) => {
+		const { body, headers } = res;
+		if (!body) return;
+		const totalResponseSize = headers.get(sizeHeader);
+		let totalSize = null;
+		if (totalResponseSize !== null) totalSize = parseInt(totalResponseSize, 10);
+		const reader = body.getReader();
+		let completed = false;
+		let runningTotal = 0;
+		do {
+			const { done, value } = await reader.read();
+			const length = value && value.length || 0;
+			completed = done;
+			if (!completed) {
+				runningTotal += length;
+				onProgress(runningTotal, totalSize);
+			}
+		} while (!completed);
+	};
+}
+function progressMiddleware(opts) {
+	const progressHandler = createProgressHandler(opts);
+	const mw = (next) => async (req) => {
+		const res = await next(req);
+		progressHandler(res.clone());
+		return res;
+	};
+	mw.isRawMiddleware = true;
+	return mw;
+}
+//#endregion
+export { progressMiddleware as default };

package/dist/middlewares/retry.cjs

@@ -0,0 +1,146 @@
+const require_RRNLError = require("../RRNLError.cjs");
+const require_utils = require("../utils.cjs");
+//#region src/middlewares/retry.ts
+function noopFn() {}
+var RRNLRetryMiddlewareError = class extends require_RRNLError.default {
+	constructor(msg) {
+		super(msg);
+		this.name = "RRNLRetryMiddlewareError";
+	}
+};
+function retryMiddleware(options) {
+	const opts = options || {};
+	const timeout = opts.fetchTimeout || 15e3;
+	const retryDelays = opts.retryDelays || [1e3, 3e3];
+	const statusCodes = opts.statusCodes || false;
+	const logger = opts.logger === false ? () => {} : opts.logger || console.log.bind(console, "[RELAY-NETWORK]");
+	const allowMutations = opts.allowMutations || false;
+	const allowFormData = opts.allowFormData || false;
+	const forceRetryFn = opts.forceRetry || false;
+	const beforeRetry = opts.beforeRetry || false;
+	let retryAfterMs = () => false;
+	if (retryDelays) {
+		if (Array.isArray(retryDelays)) retryAfterMs = (attempt) => {
+			if (retryDelays.length >= attempt) return retryDelays[attempt];
+			return false;
+		};
+		else if (require_utils.isFunction(retryDelays)) retryAfterMs = retryDelays;
+	}
+	let timeoutAfterMs;
+	if (typeof timeout === "number") timeoutAfterMs = () => timeout;
+	else timeoutAfterMs = timeout;
+	let retryOnStatusCode = (status, req, res) => {
+		return res.status < 200 || res.status > 300;
+	};
+	if (statusCodes) {
+		if (Array.isArray(statusCodes)) retryOnStatusCode = (status, req, res) => statusCodes.indexOf(res.status) !== -1;
+		else if (require_utils.isFunction(statusCodes)) retryOnStatusCode = statusCodes;
+	}
+	return (next) => (req) => {
+		if (req.isMutation() && !allowMutations) return next(req);
+		if (req.isFormData() && !allowFormData) return next(req);
+		return makeRetriableRequest({
+			req,
+			next,
+			timeoutAfterMs,
+			retryAfterMs,
+			retryOnStatusCode,
+			forceRetryFn,
+			beforeRetry,
+			logger
+		});
+	};
+}
+async function makeRetriableRequest(o, delay = 0, attempt = 0, lastError = null) {
+	const makeRetry = async (prevError) => {
+		const retryDelay = o.retryAfterMs(attempt);
+		if (retryDelay) {
+			o.logger(prevError.message);
+			o.logger(`will retry in ${retryDelay} milliseconds`);
+			return makeRetriableRequest(o, retryDelay, attempt + 1, prevError);
+		}
+		throw prevError;
+	};
+	const makeRequest = async () => {
+		try {
+			const timeout = o.timeoutAfterMs(attempt);
+			return await promiseWithTimeout(o.next(o.req), timeout, () => {
+				return makeRetry(new RRNLRetryMiddlewareError(`Reached request timeout in ${timeout} ms`));
+			});
+		} catch (e) {
+			if (e && !e.res && !(e instanceof RRNLRetryMiddlewareError) && e.name !== "AbortError") return makeRetry(e);
+			if (e && e.res && o.retryOnStatusCode(e.res.status, o.req, e.res)) return makeRetry(new RRNLRetryMiddlewareError(`Wrong response status ${e.res.status}, retrying...`));
+			throw e;
+		}
+	};
+	if (attempt === 0) return makeRequest();
+	else {
+		const { promise, forceExec, abort } = delayedExecution(makeRequest, delay);
+		if (o.forceRetryFn) o.forceRetryFn(forceExec, delay);
+		if (o.beforeRetry) o.beforeRetry({
+			abort,
+			forceRetry: forceExec,
+			attempt,
+			delay,
+			lastError,
+			req: o.req
+		});
+		return promise;
+	}
+}
+/**
+* This function delays execution of some function for some period of time.
+* Returns a promise, with ability to run execution immidiately, or abort it.
+*/
+function delayedExecution(execFn, delay = 0) {
+	let abort = noopFn;
+	let forceExec = noopFn;
+	if (delay <= 0) return {
+		abort,
+		forceExec,
+		promise: execFn()
+	};
+	const promise = new Promise((resolve, reject) => {
+		let delayId;
+		abort = (msg) => {
+			if (delayId) {
+				clearTimeout(delayId);
+				delayId = null;
+			}
+			reject(new RRNLRetryMiddlewareError(msg || "Aborted in beforeRetry() callback"));
+		};
+		forceExec = () => {
+			if (delayId) {
+				clearTimeout(delayId);
+				delayId = null;
+				resolve(execFn());
+			}
+		};
+		delayId = setTimeout(() => {
+			resolve(execFn());
+		}, delay);
+	});
+	return {
+		forceExec,
+		abort,
+		promise
+	};
+}
+function promiseWithTimeout(promise, timeoutMS, onTimeout) {
+	if (!timeoutMS) return promise;
+	return new Promise((resolve, reject) => {
+		const timeoutId = setTimeout(() => {
+			onTimeout().then(resolve).catch(reject);
+		}, timeoutMS);
+		promise.then((res) => {
+			clearTimeout(timeoutId);
+			resolve(res);
+		}).catch((err) => {
+			clearTimeout(timeoutId);
+			reject(err);
+		});
+	});
+}
+//#endregion
+exports.RRNLRetryMiddlewareError = RRNLRetryMiddlewareError;
+exports.default = retryMiddleware;

package/dist/middlewares/retry.d.cts

@@ -0,0 +1,34 @@
+import { RelayResponse } from "../RelayResponse.cjs";
+import { Middleware, RelayRequestAny } from "../definition.cjs";
+import { RRNLError } from "../RRNLError.cjs";
+
+//#region src/middlewares/retry.d.ts
+type RetryAfterFn = (attempt: number) => number | false;
+type TimeoutAfterFn = (attempt: number) => number;
+type ForceRetryFn = (runNow: Function, delay: number) => any;
+type AbortFn = (msg?: string | null) => any;
+type BeforeRetryCb = (meta: {
+  forceRetry: Function;
+  abort: AbortFn;
+  delay: number;
+  attempt: number;
+  lastError: Error | null;
+  req: RelayRequestAny;
+}) => any;
+type StatusCheckFn = (statusCode: number, req: RelayRequestAny, res: RelayResponse) => boolean;
+interface RetryMiddlewareOpts {
+  fetchTimeout?: number | TimeoutAfterFn;
+  retryDelays?: number[] | RetryAfterFn;
+  statusCodes?: number[] | false | StatusCheckFn;
+  logger?: Function | false;
+  allowMutations?: boolean;
+  allowFormData?: boolean;
+  forceRetry?: ForceRetryFn | false;
+  beforeRetry?: BeforeRetryCb | false;
+}
+declare class RRNLRetryMiddlewareError extends RRNLError {
+  constructor(msg: string);
+}
+declare function retryMiddleware(options?: RetryMiddlewareOpts): Middleware;
+//#endregion
+export { AbortFn, BeforeRetryCb, ForceRetryFn, RRNLRetryMiddlewareError, RetryAfterFn, RetryMiddlewareOpts, StatusCheckFn, retryMiddleware };

package/dist/middlewares/retry.d.ts

@@ -0,0 +1,34 @@
+import { RelayResponse } from "../RelayResponse.js";
+import { Middleware, RelayRequestAny } from "../definition.js";
+import { RRNLError } from "../RRNLError.js";
+
+//#region src/middlewares/retry.d.ts
+type RetryAfterFn = (attempt: number) => number | false;
+type TimeoutAfterFn = (attempt: number) => number;
+type ForceRetryFn = (runNow: Function, delay: number) => any;
+type AbortFn = (msg?: string | null) => any;
+type BeforeRetryCb = (meta: {
+  forceRetry: Function;
+  abort: AbortFn;
+  delay: number;
+  attempt: number;
+  lastError: Error | null;
+  req: RelayRequestAny;
+}) => any;
+type StatusCheckFn = (statusCode: number, req: RelayRequestAny, res: RelayResponse) => boolean;
+interface RetryMiddlewareOpts {
+  fetchTimeout?: number | TimeoutAfterFn;
+  retryDelays?: number[] | RetryAfterFn;
+  statusCodes?: number[] | false | StatusCheckFn;
+  logger?: Function | false;
+  allowMutations?: boolean;
+  allowFormData?: boolean;
+  forceRetry?: ForceRetryFn | false;
+  beforeRetry?: BeforeRetryCb | false;
+}
+declare class RRNLRetryMiddlewareError extends RRNLError {
+  constructor(msg: string);
+}
+declare function retryMiddleware(options?: RetryMiddlewareOpts): Middleware;
+//#endregion
+export { AbortFn, BeforeRetryCb, ForceRetryFn, RRNLRetryMiddlewareError, RetryAfterFn, RetryMiddlewareOpts, StatusCheckFn, retryMiddleware };

package/dist/middlewares/retry.js

@@ -0,0 +1,145 @@
+import RRNLError from "../RRNLError.js";
+import { isFunction } from "../utils.js";
+//#region src/middlewares/retry.ts
+function noopFn() {}
+var RRNLRetryMiddlewareError = class extends RRNLError {
+	constructor(msg) {
+		super(msg);
+		this.name = "RRNLRetryMiddlewareError";
+	}
+};
+function retryMiddleware(options) {
+	const opts = options || {};
+	const timeout = opts.fetchTimeout || 15e3;
+	const retryDelays = opts.retryDelays || [1e3, 3e3];
+	const statusCodes = opts.statusCodes || false;
+	const logger = opts.logger === false ? () => {} : opts.logger || console.log.bind(console, "[RELAY-NETWORK]");
+	const allowMutations = opts.allowMutations || false;
+	const allowFormData = opts.allowFormData || false;
+	const forceRetryFn = opts.forceRetry || false;
+	const beforeRetry = opts.beforeRetry || false;
+	let retryAfterMs = () => false;
+	if (retryDelays) {
+		if (Array.isArray(retryDelays)) retryAfterMs = (attempt) => {
+			if (retryDelays.length >= attempt) return retryDelays[attempt];
+			return false;
+		};
+		else if (isFunction(retryDelays)) retryAfterMs = retryDelays;
+	}
+	let timeoutAfterMs;
+	if (typeof timeout === "number") timeoutAfterMs = () => timeout;
+	else timeoutAfterMs = timeout;
+	let retryOnStatusCode = (status, req, res) => {
+		return res.status < 200 || res.status > 300;
+	};
+	if (statusCodes) {
+		if (Array.isArray(statusCodes)) retryOnStatusCode = (status, req, res) => statusCodes.indexOf(res.status) !== -1;
+		else if (isFunction(statusCodes)) retryOnStatusCode = statusCodes;
+	}
+	return (next) => (req) => {
+		if (req.isMutation() && !allowMutations) return next(req);
+		if (req.isFormData() && !allowFormData) return next(req);
+		return makeRetriableRequest({
+			req,
+			next,
+			timeoutAfterMs,
+			retryAfterMs,
+			retryOnStatusCode,
+			forceRetryFn,
+			beforeRetry,
+			logger
+		});
+	};
+}
+async function makeRetriableRequest(o, delay = 0, attempt = 0, lastError = null) {
+	const makeRetry = async (prevError) => {
+		const retryDelay = o.retryAfterMs(attempt);
+		if (retryDelay) {
+			o.logger(prevError.message);
+			o.logger(`will retry in ${retryDelay} milliseconds`);
+			return makeRetriableRequest(o, retryDelay, attempt + 1, prevError);
+		}
+		throw prevError;
+	};
+	const makeRequest = async () => {
+		try {
+			const timeout = o.timeoutAfterMs(attempt);
+			return await promiseWithTimeout(o.next(o.req), timeout, () => {
+				return makeRetry(new RRNLRetryMiddlewareError(`Reached request timeout in ${timeout} ms`));
+			});
+		} catch (e) {
+			if (e && !e.res && !(e instanceof RRNLRetryMiddlewareError) && e.name !== "AbortError") return makeRetry(e);
+			if (e && e.res && o.retryOnStatusCode(e.res.status, o.req, e.res)) return makeRetry(new RRNLRetryMiddlewareError(`Wrong response status ${e.res.status}, retrying...`));
+			throw e;
+		}
+	};
+	if (attempt === 0) return makeRequest();
+	else {
+		const { promise, forceExec, abort } = delayedExecution(makeRequest, delay);
+		if (o.forceRetryFn) o.forceRetryFn(forceExec, delay);
+		if (o.beforeRetry) o.beforeRetry({
+			abort,
+			forceRetry: forceExec,
+			attempt,
+			delay,
+			lastError,
+			req: o.req
+		});
+		return promise;
+	}
+}
+/**
+* This function delays execution of some function for some period of time.
+* Returns a promise, with ability to run execution immidiately, or abort it.
+*/
+function delayedExecution(execFn, delay = 0) {
+	let abort = noopFn;
+	let forceExec = noopFn;
+	if (delay <= 0) return {
+		abort,
+		forceExec,
+		promise: execFn()
+	};
+	const promise = new Promise((resolve, reject) => {
+		let delayId;
+		abort = (msg) => {
+			if (delayId) {
+				clearTimeout(delayId);
+				delayId = null;
+			}
+			reject(new RRNLRetryMiddlewareError(msg || "Aborted in beforeRetry() callback"));
+		};
+		forceExec = () => {
+			if (delayId) {
+				clearTimeout(delayId);
+				delayId = null;
+				resolve(execFn());
+			}
+		};
+		delayId = setTimeout(() => {
+			resolve(execFn());
+		}, delay);
+	});
+	return {
+		forceExec,
+		abort,
+		promise
+	};
+}
+function promiseWithTimeout(promise, timeoutMS, onTimeout) {
+	if (!timeoutMS) return promise;
+	return new Promise((resolve, reject) => {
+		const timeoutId = setTimeout(() => {
+			onTimeout().then(resolve).catch(reject);
+		}, timeoutMS);
+		promise.then((res) => {
+			clearTimeout(timeoutId);
+			resolve(res);
+		}).catch((err) => {
+			clearTimeout(timeoutId);
+			reject(err);
+		});
+	});
+}
+//#endregion
+export { RRNLRetryMiddlewareError, retryMiddleware as default };

package/dist/middlewares/upload.cjs

@@ -0,0 +1,32 @@
+const require_RelayRequestBatch = require("../RelayRequestBatch.cjs");
+let extract_files = require("extract-files");
+//#region src/middlewares/upload.ts
+function uploadMiddleware() {
+	return (next) => async (req) => {
+		if (req instanceof require_RelayRequestBatch.default) throw new Error("RelayRequestBatch is not supported");
+		const { clone: extractedOperations, files } = (0, extract_files.extractFiles)({
+			query: req.operation.text,
+			variables: req.variables
+		});
+		if (files.size) {
+			const formData = new FormData();
+			formData.append("operations", JSON.stringify(extractedOperations));
+			const pathMap = {};
+			let i = 0;
+			files.forEach((paths) => {
+				pathMap[++i] = paths;
+			});
+			formData.append("map", JSON.stringify(pathMap));
+			i = 0;
+			files.forEach((paths, file) => {
+				formData.append(`${++i}`, file, file.name);
+			});
+			req.fetchOpts.method = "POST";
+			req.fetchOpts.body = formData;
+			delete req.fetchOpts.headers["Content-Type"];
+		}
+		return await next(req);
+	};
+}
+//#endregion
+exports.default = uploadMiddleware;