@nsxbet/react-relay-network-modern 1.0.0

package/dist/definition.d.ts

@@ -0,0 +1,95 @@
+import { RelayRequest } from "./RelayRequest.js";
+import { RelayRequestBatch } from "./RelayRequestBatch.js";
+import { RelayResponse } from "./RelayResponse.js";
+
+//#region src/definition.d.ts
+type RelayRequestAny = RelayRequest | RelayRequestBatch;
+type MiddlewareNextFn = (req: RelayRequestAny) => Promise<RelayResponse>;
+type Middleware = (next: MiddlewareNextFn) => MiddlewareNextFn;
+type MiddlewareRawNextFn = (req: RelayRequestAny) => Promise<FetchResponse>;
+interface MiddlewareRaw {
+  (next: MiddlewareRawNextFn): MiddlewareRawNextFn;
+  isRawMiddleware: true;
+}
+interface MiddlewareSync {
+  execute: (operation: ConcreteBatch, variables: Variables, cacheConfig: CacheConfig, uploadables?: UploadableMap | null) => ObservableFromValue<QueryPayload> | null | undefined;
+}
+interface FetchOpts {
+  url?: string;
+  method: 'POST' | 'GET';
+  headers: {
+    [name: string]: string;
+  };
+  body: string | FormData;
+  credentials?: 'same-origin' | 'include' | 'omit';
+  mode?: 'cors' | 'websocket' | 'navigate' | 'no-cors' | 'same-origin';
+  cache?: 'default' | 'no-store' | 'reload' | 'no-cache' | 'force-cache' | 'only-if-cached';
+  redirect?: 'follow' | 'error' | 'manual';
+  signal?: AbortSignal;
+  [name: string]: unknown;
+}
+type FetchResponse = Response;
+type GraphQLResponseErrors = Array<{
+  message: string;
+  locations?: Array<{
+    column: number;
+    line: number;
+  }>;
+  stack?: Array<string>;
+}>;
+interface GraphQLResponse {
+  data?: any;
+  errors?: GraphQLResponseErrors;
+}
+type RNLExecuteFunction = (operation: ConcreteBatch, variables: Variables, cacheConfig: CacheConfig, uploadables?: UploadableMap | null) => RelayObservable<QueryPayload>;
+interface Variables {
+  [name: string]: any;
+}
+interface ConcreteBatch {
+  kind: 'Batch';
+  fragment: any;
+  id: string | null;
+  metadata: {
+    [key: string]: unknown;
+  };
+  name: string;
+  query: any;
+  text: string | null;
+  operationKind: string;
+}
+interface CacheConfig {
+  force?: boolean | null;
+  poll?: number | null;
+  rerunParamExperimental?: any;
+  skipBatch?: boolean | null;
+}
+interface Disposable {
+  dispose(): void;
+}
+type Uploadable = File | Blob;
+interface UploadableMap {
+  [key: string]: Uploadable;
+}
+interface PayloadData {
+  [key: string]: unknown;
+}
+type QueryPayload = {
+  data?: PayloadData | null;
+  errors?: Array<any>;
+  rerunVariables?: Variables;
+} | RelayResponse;
+type UnsubscribeFunction = () => void;
+interface Sink<T> {
+  next: (value: T) => void;
+  complete: () => void;
+  error: (value: T) => void;
+}
+interface RelayObservable<T> {
+  subscribe: (sink: Sink<T>) => UnsubscribeFunction;
+}
+type ObservableFromValue<T> = RelayObservable<T> | Promise<T> | T;
+type FetchFunction = (operation: ConcreteBatch, variables: Variables, cacheConfig: CacheConfig, uploadables?: UploadableMap | null) => ObservableFromValue<QueryPayload>;
+type FetchHookFunction = (operation: ConcreteBatch, variables: Variables, cacheConfig: CacheConfig, uploadables?: UploadableMap | null) => void | ObservableFromValue<QueryPayload>;
+type SubscribeFunction = (operation: ConcreteBatch, variables: Variables, cacheConfig: CacheConfig, observer: any) => RelayObservable<QueryPayload> | Disposable;
+//#endregion
+export { CacheConfig, ConcreteBatch, Disposable, FetchFunction, FetchHookFunction, FetchOpts, FetchResponse, GraphQLResponse, GraphQLResponseErrors, Middleware, MiddlewareNextFn, MiddlewareRaw, MiddlewareRawNextFn, MiddlewareSync, ObservableFromValue, PayloadData, QueryPayload, RNLExecuteFunction, RelayObservable, RelayRequestAny, SubscribeFunction, Uploadable, UploadableMap, Variables };

package/dist/express-middleware/graphqlBatchHTTPWrapper.cjs

@@ -0,0 +1,60 @@
+//#region src/express-middleware/graphqlBatchHTTPWrapper.ts
+function graphqlBatchHTTPWrapper_default(graphqlHTTPMiddleware) {
+	return (req, res) => {
+		const subResponses = [];
+		return Promise.all(req.body.map((data) => new Promise((resolve) => {
+			const subRequest = {
+				__proto__: req.__proto__,
+				...req,
+				body: data
+			};
+			const subResponse = {
+				...res,
+				status(st) {
+					this.statusCode = st;
+					return this;
+				},
+				set() {
+					return this;
+				},
+				send(payload) {
+					resolve({
+						status: this.statusCode,
+						id: data.id,
+						payload
+					});
+				},
+				setHeader() {
+					return this;
+				},
+				header() {},
+				write(payload) {
+					this.payload = payload;
+				},
+				end(payload) {
+					if (payload) this.payload = payload;
+					resolve({
+						status: this.statusCode,
+						id: data.id,
+						payload: this.payload
+					});
+				}
+			};
+			subResponses.push(subResponse);
+			graphqlHTTPMiddleware(subRequest, subResponse);
+		}))).then((responses) => {
+			let response = "";
+			responses.forEach(({ status, id, payload }, idx) => {
+				if (status) res.status(status);
+				const comma = responses.length - 1 > idx ? "," : "";
+				response += `{ "id":"${id}", "payload":${payload} }${comma}`;
+			});
+			res.set("Content-Type", "application/json");
+			res.send(`[${response}]`);
+		}).catch((err) => {
+			res.status(500).send({ error: err.message });
+		});
+	};
+}
+//#endregion
+exports.default = graphqlBatchHTTPWrapper_default;

package/dist/express-middleware/graphqlBatchHTTPWrapper.d.cts

@@ -0,0 +1,5 @@
+//#region src/express-middleware/graphqlBatchHTTPWrapper.d.ts
+type ExpressMiddleware = (req: any, res: any) => any;
+declare function export_default(graphqlHTTPMiddleware: ExpressMiddleware): ExpressMiddleware;
+//#endregion
+export { export_default };

package/dist/express-middleware/graphqlBatchHTTPWrapper.d.ts

@@ -0,0 +1,5 @@
+//#region src/express-middleware/graphqlBatchHTTPWrapper.d.ts
+type ExpressMiddleware = (req: any, res: any) => any;
+declare function export_default(graphqlHTTPMiddleware: ExpressMiddleware): ExpressMiddleware;
+//#endregion
+export { export_default };

package/dist/express-middleware/graphqlBatchHTTPWrapper.js

@@ -0,0 +1,60 @@
+//#region src/express-middleware/graphqlBatchHTTPWrapper.ts
+function graphqlBatchHTTPWrapper_default(graphqlHTTPMiddleware) {
+	return (req, res) => {
+		const subResponses = [];
+		return Promise.all(req.body.map((data) => new Promise((resolve) => {
+			const subRequest = {
+				__proto__: req.__proto__,
+				...req,
+				body: data
+			};
+			const subResponse = {
+				...res,
+				status(st) {
+					this.statusCode = st;
+					return this;
+				},
+				set() {
+					return this;
+				},
+				send(payload) {
+					resolve({
+						status: this.statusCode,
+						id: data.id,
+						payload
+					});
+				},
+				setHeader() {
+					return this;
+				},
+				header() {},
+				write(payload) {
+					this.payload = payload;
+				},
+				end(payload) {
+					if (payload) this.payload = payload;
+					resolve({
+						status: this.statusCode,
+						id: data.id,
+						payload: this.payload
+					});
+				}
+			};
+			subResponses.push(subResponse);
+			graphqlHTTPMiddleware(subRequest, subResponse);
+		}))).then((responses) => {
+			let response = "";
+			responses.forEach(({ status, id, payload }, idx) => {
+				if (status) res.status(status);
+				const comma = responses.length - 1 > idx ? "," : "";
+				response += `{ "id":"${id}", "payload":${payload} }${comma}`;
+			});
+			res.set("Content-Type", "application/json");
+			res.send(`[${response}]`);
+		}).catch((err) => {
+			res.status(500).send({ error: err.message });
+		});
+	};
+}
+//#endregion
+export { graphqlBatchHTTPWrapper_default as default };

package/dist/fetchWithMiddleware.cjs

@@ -0,0 +1,43 @@
+const require_createRequestError = require("./createRequestError.cjs");
+const require_RelayResponse = require("./RelayResponse.cjs");
+//#region src/fetchWithMiddleware.ts
+function runFetch(req) {
+	const fetchOpts = req.fetchOpts;
+	let { url } = fetchOpts;
+	if (!url) url = "/graphql";
+	if (!fetchOpts.headers.Accept) fetchOpts.headers.Accept = "*/*";
+	if (!fetchOpts.headers["Content-Type"] && !req.isFormData()) fetchOpts.headers["Content-Type"] = "application/json";
+	return fetch(url, fetchOpts);
+}
+const convertResponse = (next) => async (req) => {
+	const resFromFetch = await next(req);
+	const res = await require_RelayResponse.default.createFromFetch(resFromFetch);
+	if (res.status && res.status >= 400) throw require_createRequestError.createRequestError(req, res);
+	return res;
+};
+function fetchWithMiddleware(req, middlewares, rawFetchMiddlewares, noThrow) {
+	return compose(...middlewares, convertResponse, ...rawFetchMiddlewares)(runFetch)(req).then((res) => {
+		if (!noThrow && (!res || res.errors || !res.data)) throw require_createRequestError.createRequestError(req, res);
+		return res;
+	});
+}
+/**
+* Composes single-argument functions from right to left. The rightmost
+* function can take multiple arguments as it provides the signature for
+* the resulting composite function.
+*
+* @param {...Function} funcs The functions to compose.
+* @returns {Function} A function obtained by composing the argument functions
+* from right to left. For example, compose(f, g, h) is identical to doing
+* (...args) => f(g(h(...args))).
+*/
+function compose(...funcs) {
+	if (funcs.length === 0) return (arg) => arg;
+	else {
+		const last = funcs[funcs.length - 1];
+		const rest = funcs.slice(0, -1);
+		return (...args) => rest.reduceRight((composed, f) => f(composed), last(...args));
+	}
+}
+//#endregion
+exports.default = fetchWithMiddleware;

package/dist/fetchWithMiddleware.js

@@ -0,0 +1,43 @@
+import { createRequestError } from "./createRequestError.js";
+import RelayResponse from "./RelayResponse.js";
+//#region src/fetchWithMiddleware.ts
+function runFetch(req) {
+	const fetchOpts = req.fetchOpts;
+	let { url } = fetchOpts;
+	if (!url) url = "/graphql";
+	if (!fetchOpts.headers.Accept) fetchOpts.headers.Accept = "*/*";
+	if (!fetchOpts.headers["Content-Type"] && !req.isFormData()) fetchOpts.headers["Content-Type"] = "application/json";
+	return fetch(url, fetchOpts);
+}
+const convertResponse = (next) => async (req) => {
+	const resFromFetch = await next(req);
+	const res = await RelayResponse.createFromFetch(resFromFetch);
+	if (res.status && res.status >= 400) throw createRequestError(req, res);
+	return res;
+};
+function fetchWithMiddleware(req, middlewares, rawFetchMiddlewares, noThrow) {
+	return compose(...middlewares, convertResponse, ...rawFetchMiddlewares)(runFetch)(req).then((res) => {
+		if (!noThrow && (!res || res.errors || !res.data)) throw createRequestError(req, res);
+		return res;
+	});
+}
+/**
+* Composes single-argument functions from right to left. The rightmost
+* function can take multiple arguments as it provides the signature for
+* the resulting composite function.
+*
+* @param {...Function} funcs The functions to compose.
+* @returns {Function} A function obtained by composing the argument functions
+* from right to left. For example, compose(f, g, h) is identical to doing
+* (...args) => f(g(h(...args))).
+*/
+function compose(...funcs) {
+	if (funcs.length === 0) return (arg) => arg;
+	else {
+		const last = funcs[funcs.length - 1];
+		const rest = funcs.slice(0, -1);
+		return (...args) => rest.reduceRight((composed, f) => f(composed), last(...args));
+	}
+}
+//#endregion
+export { fetchWithMiddleware as default };

package/dist/index.cjs

@@ -0,0 +1,49 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_RRNLError = require("./RRNLError.cjs");
+const require_RelayRequest = require("./RelayRequest.cjs");
+const require_createRequestError = require("./createRequestError.cjs");
+const require_RelayResponse = require("./RelayResponse.cjs");
+const require_RelayNetworkLayer = require("./RelayNetworkLayer.cjs");
+const require_RelayRequestBatch = require("./RelayRequestBatch.cjs");
+const require_batch = require("./middlewares/batch.cjs");
+const require_retry = require("./middlewares/retry.cjs");
+const require_url = require("./middlewares/url.cjs");
+const require_auth = require("./middlewares/auth.cjs");
+const require_perf = require("./middlewares/perf.cjs");
+const require_logger = require("./middlewares/logger.cjs");
+const require_persistedQueries = require("./middlewares/persistedQueries.cjs");
+const require_error = require("./middlewares/error.cjs");
+const require_cache = require("./middlewares/cache.cjs");
+const require_progress = require("./middlewares/progress.cjs");
+const require_upload = require("./middlewares/upload.cjs");
+const require_graphqlBatchHTTPWrapper = require("./express-middleware/graphqlBatchHTTPWrapper.cjs");
+let relay_runtime = require("relay-runtime");
+Object.defineProperty(exports, "QueryResponseCache", {
+	enumerable: true,
+	get: function() {
+		return relay_runtime.QueryResponseCache;
+	}
+});
+exports.RRNLAuthMiddlewareError = require_auth.RRNLAuthMiddlewareError;
+exports.RRNLBatchMiddlewareError = require_batch.RRNLBatchMiddlewareError;
+exports.RRNLError = require_RRNLError.default;
+exports.RRNLRequestError = require_createRequestError.RRNLRequestError;
+exports.RRNLRetryMiddlewareError = require_retry.RRNLRetryMiddlewareError;
+exports.RelayNetworkLayer = require_RelayNetworkLayer.default;
+exports.RelayNetworkLayerRequest = require_RelayRequest.default;
+exports.RelayNetworkLayerRequestBatch = require_RelayRequestBatch.default;
+exports.RelayNetworkLayerResponse = require_RelayResponse.default;
+exports.authMiddleware = require_auth.default;
+exports.batchMiddleware = require_batch.default;
+exports.cacheMiddleware = require_cache.default;
+exports.createRequestError = require_createRequestError.createRequestError;
+exports.errorMiddleware = require_error.default;
+exports.formatGraphQLErrors = require_createRequestError.formatGraphQLErrors;
+exports.graphqlBatchHTTPWrapper = require_graphqlBatchHTTPWrapper.default;
+exports.loggerMiddleware = require_logger.default;
+exports.perfMiddleware = require_perf.default;
+exports.persistedQueriesMiddleware = require_persistedQueries.default;
+exports.progressMiddleware = require_progress.default;
+exports.retryMiddleware = require_retry.default;
+exports.uploadMiddleware = require_upload.default;
+exports.urlMiddleware = require_url.default;

package/dist/index.d.cts

@@ -0,0 +1,21 @@
+import { RelayRequest } from "./RelayRequest.cjs";
+import { RelayRequestBatch } from "./RelayRequestBatch.cjs";
+import { RelayResponse } from "./RelayResponse.cjs";
+import { CacheConfig, ConcreteBatch, Disposable, FetchFunction, FetchHookFunction, FetchOpts, FetchResponse, GraphQLResponse, GraphQLResponseErrors, Middleware, MiddlewareNextFn, MiddlewareRaw, MiddlewareRawNextFn, MiddlewareSync, ObservableFromValue, PayloadData, QueryPayload, RelayObservable, RelayRequestAny, SubscribeFunction, Uploadable, UploadableMap, Variables } from "./definition.cjs";
+import { RelayNetworkLayer, RelayNetworkLayerOpts } from "./RelayNetworkLayer.cjs";
+import { RRNLError } from "./RRNLError.cjs";
+import { BatchMiddlewareOpts, RRNLBatchMiddlewareError, RequestWrapper, batchMiddleware } from "./middlewares/batch.cjs";
+import { AbortFn, BeforeRetryCb, ForceRetryFn, RRNLRetryMiddlewareError, RetryAfterFn, RetryMiddlewareOpts, StatusCheckFn, retryMiddleware } from "./middlewares/retry.cjs";
+import { UrlMiddlewareOpts, urlMiddleware } from "./middlewares/url.cjs";
+import { AuthMiddlewareOpts, RRNLAuthMiddlewareError, authMiddleware } from "./middlewares/auth.cjs";
+import { PerfMiddlewareOpts, performanceMiddleware } from "./middlewares/perf.cjs";
+import { LoggerMiddlewareOpts, loggerMiddleware } from "./middlewares/logger.cjs";
+import { PersistedQueriesMiddlewareOpts, persistedQueriesMiddleware } from "./middlewares/persistedQueries.cjs";
+import { GqlErrorMiddlewareOpts, errorMiddleware } from "./middlewares/error.cjs";
+import { CacheMiddlewareOpts, cacheMiddleware } from "./middlewares/cache.cjs";
+import { ProgressOpts, progressMiddleware } from "./middlewares/progress.cjs";
+import { uploadMiddleware } from "./middlewares/upload.cjs";
+import { export_default } from "./express-middleware/graphqlBatchHTTPWrapper.cjs";
+import { RRNLRequestError, createRequestError, formatGraphQLErrors } from "./createRequestError.cjs";
+import { QueryResponseCache } from "relay-runtime";
+export { type AbortFn, type AuthMiddlewareOpts, type BatchMiddlewareOpts, type BeforeRetryCb, type CacheConfig, type CacheMiddlewareOpts, type ConcreteBatch, type Disposable, type FetchFunction, type FetchHookFunction, type FetchOpts, type FetchResponse, type ForceRetryFn, type GqlErrorMiddlewareOpts, type GraphQLResponse, type GraphQLResponseErrors, type LoggerMiddlewareOpts, type Middleware, type MiddlewareNextFn, type MiddlewareRaw, type MiddlewareRawNextFn, type MiddlewareSync, type ObservableFromValue, type PayloadData, type PerfMiddlewareOpts, type PersistedQueriesMiddlewareOpts, type ProgressOpts, type QueryPayload, QueryResponseCache, RRNLAuthMiddlewareError, RRNLBatchMiddlewareError, RRNLError, RRNLRequestError, RRNLRetryMiddlewareError, RelayNetworkLayer, type RelayNetworkLayerOpts, RelayRequest as RelayNetworkLayerRequest, RelayRequestBatch as RelayNetworkLayerRequestBatch, RelayResponse as RelayNetworkLayerResponse, type RelayObservable, type RelayRequestAny, type RequestWrapper, type RetryAfterFn, type RetryMiddlewareOpts, type StatusCheckFn, type SubscribeFunction, type Uploadable, type UploadableMap, type UrlMiddlewareOpts, type Variables, authMiddleware, batchMiddleware, cacheMiddleware, createRequestError, errorMiddleware, formatGraphQLErrors, export_default as graphqlBatchHTTPWrapper, loggerMiddleware, performanceMiddleware as perfMiddleware, persistedQueriesMiddleware, progressMiddleware, retryMiddleware, uploadMiddleware, urlMiddleware };

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import { RelayRequest } from "./RelayRequest.js";
+import { RelayRequestBatch } from "./RelayRequestBatch.js";
+import { RelayResponse } from "./RelayResponse.js";
+import { CacheConfig, ConcreteBatch, Disposable, FetchFunction, FetchHookFunction, FetchOpts, FetchResponse, GraphQLResponse, GraphQLResponseErrors, Middleware, MiddlewareNextFn, MiddlewareRaw, MiddlewareRawNextFn, MiddlewareSync, ObservableFromValue, PayloadData, QueryPayload, RelayObservable, RelayRequestAny, SubscribeFunction, Uploadable, UploadableMap, Variables } from "./definition.js";
+import { RelayNetworkLayer, RelayNetworkLayerOpts } from "./RelayNetworkLayer.js";
+import { RRNLError } from "./RRNLError.js";
+import { BatchMiddlewareOpts, RRNLBatchMiddlewareError, RequestWrapper, batchMiddleware } from "./middlewares/batch.js";
+import { AbortFn, BeforeRetryCb, ForceRetryFn, RRNLRetryMiddlewareError, RetryAfterFn, RetryMiddlewareOpts, StatusCheckFn, retryMiddleware } from "./middlewares/retry.js";
+import { UrlMiddlewareOpts, urlMiddleware } from "./middlewares/url.js";
+import { AuthMiddlewareOpts, RRNLAuthMiddlewareError, authMiddleware } from "./middlewares/auth.js";
+import { PerfMiddlewareOpts, performanceMiddleware } from "./middlewares/perf.js";
+import { LoggerMiddlewareOpts, loggerMiddleware } from "./middlewares/logger.js";
+import { PersistedQueriesMiddlewareOpts, persistedQueriesMiddleware } from "./middlewares/persistedQueries.js";
+import { GqlErrorMiddlewareOpts, errorMiddleware } from "./middlewares/error.js";
+import { CacheMiddlewareOpts, cacheMiddleware } from "./middlewares/cache.js";
+import { ProgressOpts, progressMiddleware } from "./middlewares/progress.js";
+import { uploadMiddleware } from "./middlewares/upload.js";
+import { export_default } from "./express-middleware/graphqlBatchHTTPWrapper.js";
+import { RRNLRequestError, createRequestError, formatGraphQLErrors } from "./createRequestError.js";
+import { QueryResponseCache } from "relay-runtime";
+export { type AbortFn, type AuthMiddlewareOpts, type BatchMiddlewareOpts, type BeforeRetryCb, type CacheConfig, type CacheMiddlewareOpts, type ConcreteBatch, type Disposable, type FetchFunction, type FetchHookFunction, type FetchOpts, type FetchResponse, type ForceRetryFn, type GqlErrorMiddlewareOpts, type GraphQLResponse, type GraphQLResponseErrors, type LoggerMiddlewareOpts, type Middleware, type MiddlewareNextFn, type MiddlewareRaw, type MiddlewareRawNextFn, type MiddlewareSync, type ObservableFromValue, type PayloadData, type PerfMiddlewareOpts, type PersistedQueriesMiddlewareOpts, type ProgressOpts, type QueryPayload, QueryResponseCache, RRNLAuthMiddlewareError, RRNLBatchMiddlewareError, RRNLError, RRNLRequestError, RRNLRetryMiddlewareError, RelayNetworkLayer, type RelayNetworkLayerOpts, RelayRequest as RelayNetworkLayerRequest, RelayRequestBatch as RelayNetworkLayerRequestBatch, RelayResponse as RelayNetworkLayerResponse, type RelayObservable, type RelayRequestAny, type RequestWrapper, type RetryAfterFn, type RetryMiddlewareOpts, type StatusCheckFn, type SubscribeFunction, type Uploadable, type UploadableMap, type UrlMiddlewareOpts, type Variables, authMiddleware, batchMiddleware, cacheMiddleware, createRequestError, errorMiddleware, formatGraphQLErrors, export_default as graphqlBatchHTTPWrapper, loggerMiddleware, performanceMiddleware as perfMiddleware, persistedQueriesMiddleware, progressMiddleware, retryMiddleware, uploadMiddleware, urlMiddleware };

package/dist/index.js

@@ -0,0 +1,20 @@
+import RRNLError from "./RRNLError.js";
+import RelayRequest from "./RelayRequest.js";
+import { RRNLRequestError, createRequestError, formatGraphQLErrors } from "./createRequestError.js";
+import RelayResponse from "./RelayResponse.js";
+import RelayNetworkLayer from "./RelayNetworkLayer.js";
+import RelayRequestBatch from "./RelayRequestBatch.js";
+import batchMiddleware, { RRNLBatchMiddlewareError } from "./middlewares/batch.js";
+import retryMiddleware, { RRNLRetryMiddlewareError } from "./middlewares/retry.js";
+import urlMiddleware from "./middlewares/url.js";
+import authMiddleware, { RRNLAuthMiddlewareError } from "./middlewares/auth.js";
+import performanceMiddleware from "./middlewares/perf.js";
+import loggerMiddleware from "./middlewares/logger.js";
+import persistedQueriesMiddleware from "./middlewares/persistedQueries.js";
+import errorMiddleware from "./middlewares/error.js";
+import cacheMiddleware from "./middlewares/cache.js";
+import progressMiddleware from "./middlewares/progress.js";
+import uploadMiddleware from "./middlewares/upload.js";
+import graphqlBatchHTTPWrapper_default from "./express-middleware/graphqlBatchHTTPWrapper.js";
+import { QueryResponseCache } from "relay-runtime";
+export { QueryResponseCache, RRNLAuthMiddlewareError, RRNLBatchMiddlewareError, RRNLError, RRNLRequestError, RRNLRetryMiddlewareError, RelayNetworkLayer, RelayRequest as RelayNetworkLayerRequest, RelayRequestBatch as RelayNetworkLayerRequestBatch, RelayResponse as RelayNetworkLayerResponse, authMiddleware, batchMiddleware, cacheMiddleware, createRequestError, errorMiddleware, formatGraphQLErrors, graphqlBatchHTTPWrapper_default as graphqlBatchHTTPWrapper, loggerMiddleware, performanceMiddleware as perfMiddleware, persistedQueriesMiddleware, progressMiddleware, retryMiddleware, uploadMiddleware, urlMiddleware };

package/dist/middlewares/auth.cjs

@@ -0,0 +1,47 @@
+const require_RRNLError = require("../RRNLError.cjs");
+const require_utils = require("../utils.cjs");
+//#region src/middlewares/auth.ts
+var RRNLAuthMiddlewareError = class extends require_RRNLError.default {
+	constructor(msg) {
+		super(msg);
+		this.name = "RRNLAuthMiddlewareError";
+	}
+};
+function authMiddleware(opts) {
+	const { token: tokenOrThunk, tokenRefreshPromise, allowEmptyToken = false, prefix = "Bearer ", header = "Authorization" } = opts || {};
+	let tokenRefreshInProgress = null;
+	return (next) => async (req) => {
+		try {
+			const token = await (require_utils.isFunction(tokenOrThunk) ? tokenOrThunk(req) : tokenOrThunk);
+			if (!token && tokenRefreshPromise && !allowEmptyToken) throw new RRNLAuthMiddlewareError("Empty token");
+			if (token) req.fetchOpts.headers[header] = `${prefix}${token}`;
+			return await next(req);
+		} catch (e) {
+			if (e && tokenRefreshPromise) {
+				if (e.message === "Empty token" || e.res && e.res.status === 401) {
+					if (tokenRefreshPromise) {
+						if (!tokenRefreshInProgress) tokenRefreshInProgress = Promise.resolve(tokenRefreshPromise(req, e.res)).then((newToken) => {
+							tokenRefreshInProgress = null;
+							return newToken;
+						}).catch((err) => {
+							tokenRefreshInProgress = null;
+							throw err;
+						});
+						return tokenRefreshInProgress.then((newToken) => {
+							if (!newToken && !allowEmptyToken) throw new RRNLAuthMiddlewareError("Empty token");
+							const newReq = req.clone();
+							const headers = newReq.fetchOpts.headers;
+							if (newToken) headers[header] = `${prefix}${newToken}`;
+							else delete headers[header];
+							return next(newReq);
+						});
+					}
+				}
+			}
+			throw e;
+		}
+	};
+}
+//#endregion
+exports.RRNLAuthMiddlewareError = RRNLAuthMiddlewareError;
+exports.default = authMiddleware;

package/dist/middlewares/auth.d.cts

@@ -0,0 +1,18 @@
+import { RelayResponse } from "../RelayResponse.cjs";
+import { Middleware, RelayRequestAny } from "../definition.cjs";
+import { RRNLError } from "../RRNLError.cjs";
+
+//#region src/middlewares/auth.d.ts
+declare class RRNLAuthMiddlewareError extends RRNLError {
+  constructor(msg: string);
+}
+interface AuthMiddlewareOpts {
+  token?: string | Promise<string> | ((req: RelayRequestAny) => string | Promise<string>);
+  tokenRefreshPromise?: (req: RelayRequestAny, res: RelayResponse) => string | Promise<string>;
+  allowEmptyToken?: boolean;
+  prefix?: string;
+  header?: string;
+}
+declare function authMiddleware(opts?: AuthMiddlewareOpts): Middleware;
+//#endregion
+export { AuthMiddlewareOpts, RRNLAuthMiddlewareError, authMiddleware };

package/dist/middlewares/auth.d.ts

@@ -0,0 +1,18 @@
+import { RelayResponse } from "../RelayResponse.js";
+import { Middleware, RelayRequestAny } from "../definition.js";
+import { RRNLError } from "../RRNLError.js";
+
+//#region src/middlewares/auth.d.ts
+declare class RRNLAuthMiddlewareError extends RRNLError {
+  constructor(msg: string);
+}
+interface AuthMiddlewareOpts {
+  token?: string | Promise<string> | ((req: RelayRequestAny) => string | Promise<string>);
+  tokenRefreshPromise?: (req: RelayRequestAny, res: RelayResponse) => string | Promise<string>;
+  allowEmptyToken?: boolean;
+  prefix?: string;
+  header?: string;
+}
+declare function authMiddleware(opts?: AuthMiddlewareOpts): Middleware;
+//#endregion
+export { AuthMiddlewareOpts, RRNLAuthMiddlewareError, authMiddleware };

package/dist/middlewares/auth.js

@@ -0,0 +1,46 @@
+import RRNLError from "../RRNLError.js";
+import { isFunction } from "../utils.js";
+//#region src/middlewares/auth.ts
+var RRNLAuthMiddlewareError = class extends RRNLError {
+	constructor(msg) {
+		super(msg);
+		this.name = "RRNLAuthMiddlewareError";
+	}
+};
+function authMiddleware(opts) {
+	const { token: tokenOrThunk, tokenRefreshPromise, allowEmptyToken = false, prefix = "Bearer ", header = "Authorization" } = opts || {};
+	let tokenRefreshInProgress = null;
+	return (next) => async (req) => {
+		try {
+			const token = await (isFunction(tokenOrThunk) ? tokenOrThunk(req) : tokenOrThunk);
+			if (!token && tokenRefreshPromise && !allowEmptyToken) throw new RRNLAuthMiddlewareError("Empty token");
+			if (token) req.fetchOpts.headers[header] = `${prefix}${token}`;
+			return await next(req);
+		} catch (e) {
+			if (e && tokenRefreshPromise) {
+				if (e.message === "Empty token" || e.res && e.res.status === 401) {
+					if (tokenRefreshPromise) {
+						if (!tokenRefreshInProgress) tokenRefreshInProgress = Promise.resolve(tokenRefreshPromise(req, e.res)).then((newToken) => {
+							tokenRefreshInProgress = null;
+							return newToken;
+						}).catch((err) => {
+							tokenRefreshInProgress = null;
+							throw err;
+						});
+						return tokenRefreshInProgress.then((newToken) => {
+							if (!newToken && !allowEmptyToken) throw new RRNLAuthMiddlewareError("Empty token");
+							const newReq = req.clone();
+							const headers = newReq.fetchOpts.headers;
+							if (newToken) headers[header] = `${prefix}${newToken}`;
+							else delete headers[header];
+							return next(newReq);
+						});
+					}
+				}
+			}
+			throw e;
+		}
+	};
+}
+//#endregion
+export { RRNLAuthMiddlewareError, authMiddleware as default };