@nsxbet/react-relay-network-modern 1.0.0

package/dist/middlewares/batch.cjs

@@ -0,0 +1,136 @@
+const require_RRNLError = require("../RRNLError.cjs");
+const require_RelayRequest = require("../RelayRequest.cjs");
+const require_RelayRequestBatch = require("../RelayRequestBatch.cjs");
+const require_utils = require("../utils.cjs");
+//#region src/middlewares/batch.ts
+const DEFAULT_BATCH_SIZE = 102400;
+var RRNLBatchMiddlewareError = class extends require_RRNLError.default {
+	constructor(msg) {
+		super(msg);
+		this.name = "RRNLBatchMiddlewareError";
+	}
+};
+function batchMiddleware(options) {
+	const opts = options || {};
+	const batchTimeout = opts.batchTimeout || 0;
+	const allowMutations = opts.allowMutations || false;
+	const batchUrl = opts.batchUrl || "/graphql/batch";
+	const maxBatchSize = opts.maxBatchSize || DEFAULT_BATCH_SIZE;
+	const singleton = {};
+	const fetchOpts = {};
+	if (opts.method) fetchOpts.method = opts.method;
+	if (opts.credentials) fetchOpts.credentials = opts.credentials;
+	if (opts.mode) fetchOpts.mode = opts.mode;
+	if (opts.cache) fetchOpts.cache = opts.cache;
+	if (opts.redirect) fetchOpts.redirect = opts.redirect;
+	if (opts.headers) fetchOpts.headersOrThunk = opts.headers;
+	return (next) => (req) => {
+		if (req.isMutation() && !allowMutations) return next(req);
+		if (!(req instanceof require_RelayRequest.default)) throw new RRNLBatchMiddlewareError("Relay batch middleware accepts only simple RelayRequest. Did you add batchMiddleware twice?");
+		if (req.isFormData()) return next(req);
+		if (req.cacheConfig.skipBatch) return next(req);
+		return passThroughBatch(req, next, {
+			batchTimeout,
+			batchUrl,
+			singleton,
+			maxBatchSize,
+			fetchOpts
+		});
+	};
+}
+function passThroughBatch(req, next, opts) {
+	const { singleton } = opts;
+	const bodyLength = req.getBody().length;
+	if (!bodyLength) return next(req);
+	if (!singleton.batcher || !singleton.batcher.acceptRequests) singleton.batcher = prepareNewBatcher(next, opts);
+	if (singleton.batcher.bodySize + bodyLength + 1 > opts.maxBatchSize) singleton.batcher = prepareNewBatcher(next, opts);
+	singleton.batcher.bodySize += bodyLength + 1;
+	return new Promise((resolve, reject) => {
+		const { requestList } = singleton.batcher;
+		const requestWrapper = {
+			req,
+			completeOk: (res) => {
+				requestWrapper.done = true;
+				resolve(res);
+				requestWrapper.duplicates.forEach((r) => r.completeOk(res));
+			},
+			completeErr: (err) => {
+				requestWrapper.done = true;
+				reject(err);
+				requestWrapper.duplicates.forEach((r) => r.completeErr(err));
+			},
+			done: false,
+			duplicates: []
+		};
+		const duplicateIndex = requestList.findIndex((wrapper) => req.getBody() === wrapper.req.getBody());
+		if (duplicateIndex !== -1) requestList[duplicateIndex].duplicates.push(requestWrapper);
+		else requestList.push(requestWrapper);
+	});
+}
+function prepareNewBatcher(next, opts) {
+	const batcher = {
+		bodySize: 2,
+		requestList: [],
+		acceptRequests: true
+	};
+	setTimeout(() => {
+		batcher.acceptRequests = false;
+		sendRequests(batcher.requestList, next, opts).then(() => finalizeUncompleted(batcher.requestList)).catch((e) => {
+			if (e && e.name === "AbortError") finalizeCanceled(batcher.requestList, e);
+			else finalizeUncompleted(batcher.requestList);
+		});
+	}, opts.batchTimeout);
+	return batcher;
+}
+async function sendRequests(requestList, next, opts) {
+	if (requestList.length === 1) {
+		const wrapper = requestList[0];
+		const res = await next(wrapper.req);
+		wrapper.completeOk(res);
+		wrapper.duplicates.forEach((r) => r.completeOk(res));
+		return res;
+	} else if (requestList.length > 1) {
+		const batchRequest = new require_RelayRequestBatch.default(requestList.map((wrapper) => wrapper.req));
+		const url = await (require_utils.isFunction(opts.batchUrl) ? opts.batchUrl(requestList) : opts.batchUrl);
+		batchRequest.setFetchOption("url", url);
+		const { headersOrThunk, ...fetchOpts } = opts.fetchOpts;
+		batchRequest.setFetchOptions(fetchOpts);
+		if (headersOrThunk) {
+			const headers = await (require_utils.isFunction(headersOrThunk) ? headersOrThunk(batchRequest) : headersOrThunk);
+			batchRequest.setFetchOption("headers", headers);
+		}
+		try {
+			const batchResponse = await next(batchRequest);
+			if (!batchResponse || !Array.isArray(batchResponse.json)) throw new RRNLBatchMiddlewareError("Wrong response from server. Did your server support batch request?");
+			batchResponse.json.forEach((payload, index) => {
+				if (!payload) return;
+				const request = requestList[index];
+				if (request) {
+					const res = createSingleResponse(batchResponse, payload);
+					request.completeOk(res);
+				}
+			});
+			return batchResponse;
+		} catch (e) {
+			requestList.forEach((request) => request.completeErr(e));
+		}
+	}
+	return Promise.resolve();
+}
+function finalizeCanceled(requestList, error) {
+	requestList.forEach((request) => request.completeErr(error));
+}
+function finalizeUncompleted(requestList) {
+	requestList.forEach((request, index) => {
+		if (!request.done) request.completeErr(new RRNLBatchMiddlewareError(`Server does not return response for request at index ${index}.\nResponse should have an array with ${requestList.length} item(s).`));
+	});
+}
+function createSingleResponse(batchResponse, json) {
+	const data = json.payload || json;
+	const res = batchResponse.clone();
+	res.processJsonData(data);
+	return res;
+}
+//#endregion
+exports.RRNLBatchMiddlewareError = RRNLBatchMiddlewareError;
+exports.default = batchMiddleware;

package/dist/middlewares/batch.d.cts

@@ -0,0 +1,34 @@
+import { RelayRequest } from "../RelayRequest.cjs";
+import { RelayRequestBatch } from "../RelayRequestBatch.cjs";
+import { FetchOpts, Middleware } from "../definition.cjs";
+import { RRNLError } from "../RRNLError.cjs";
+
+//#region src/middlewares/batch.d.ts
+type Headers = {
+  [name: string]: string;
+};
+interface BatchMiddlewareOpts {
+  batchUrl?: string | Promise<string> | ((requestList: RequestWrapper[]) => string | Promise<string>);
+  batchTimeout?: number;
+  maxBatchSize?: number;
+  allowMutations?: boolean;
+  method?: 'POST' | 'GET';
+  headers?: Headers | Promise<Headers> | ((req: RelayRequestBatch) => Headers | Promise<Headers>);
+  credentials?: FetchOpts['credentials'];
+  mode?: FetchOpts['mode'];
+  cache?: FetchOpts['cache'];
+  redirect?: FetchOpts['redirect'];
+}
+interface RequestWrapper {
+  req: RelayRequest;
+  completeOk: (res: any) => void;
+  completeErr: (e: Error) => void;
+  done: boolean;
+  duplicates: Array<RequestWrapper>;
+}
+declare class RRNLBatchMiddlewareError extends RRNLError {
+  constructor(msg: string);
+}
+declare function batchMiddleware(options?: BatchMiddlewareOpts): Middleware;
+//#endregion
+export { BatchMiddlewareOpts, RRNLBatchMiddlewareError, RequestWrapper, batchMiddleware };

package/dist/middlewares/batch.d.ts

@@ -0,0 +1,34 @@
+import { RelayRequest } from "../RelayRequest.js";
+import { RelayRequestBatch } from "../RelayRequestBatch.js";
+import { FetchOpts, Middleware } from "../definition.js";
+import { RRNLError } from "../RRNLError.js";
+
+//#region src/middlewares/batch.d.ts
+type Headers = {
+  [name: string]: string;
+};
+interface BatchMiddlewareOpts {
+  batchUrl?: string | Promise<string> | ((requestList: RequestWrapper[]) => string | Promise<string>);
+  batchTimeout?: number;
+  maxBatchSize?: number;
+  allowMutations?: boolean;
+  method?: 'POST' | 'GET';
+  headers?: Headers | Promise<Headers> | ((req: RelayRequestBatch) => Headers | Promise<Headers>);
+  credentials?: FetchOpts['credentials'];
+  mode?: FetchOpts['mode'];
+  cache?: FetchOpts['cache'];
+  redirect?: FetchOpts['redirect'];
+}
+interface RequestWrapper {
+  req: RelayRequest;
+  completeOk: (res: any) => void;
+  completeErr: (e: Error) => void;
+  done: boolean;
+  duplicates: Array<RequestWrapper>;
+}
+declare class RRNLBatchMiddlewareError extends RRNLError {
+  constructor(msg: string);
+}
+declare function batchMiddleware(options?: BatchMiddlewareOpts): Middleware;
+//#endregion
+export { BatchMiddlewareOpts, RRNLBatchMiddlewareError, RequestWrapper, batchMiddleware };

package/dist/middlewares/batch.js

@@ -0,0 +1,135 @@
+import RRNLError from "../RRNLError.js";
+import RelayRequest from "../RelayRequest.js";
+import RelayRequestBatch from "../RelayRequestBatch.js";
+import { isFunction } from "../utils.js";
+//#region src/middlewares/batch.ts
+const DEFAULT_BATCH_SIZE = 102400;
+var RRNLBatchMiddlewareError = class extends RRNLError {
+	constructor(msg) {
+		super(msg);
+		this.name = "RRNLBatchMiddlewareError";
+	}
+};
+function batchMiddleware(options) {
+	const opts = options || {};
+	const batchTimeout = opts.batchTimeout || 0;
+	const allowMutations = opts.allowMutations || false;
+	const batchUrl = opts.batchUrl || "/graphql/batch";
+	const maxBatchSize = opts.maxBatchSize || DEFAULT_BATCH_SIZE;
+	const singleton = {};
+	const fetchOpts = {};
+	if (opts.method) fetchOpts.method = opts.method;
+	if (opts.credentials) fetchOpts.credentials = opts.credentials;
+	if (opts.mode) fetchOpts.mode = opts.mode;
+	if (opts.cache) fetchOpts.cache = opts.cache;
+	if (opts.redirect) fetchOpts.redirect = opts.redirect;
+	if (opts.headers) fetchOpts.headersOrThunk = opts.headers;
+	return (next) => (req) => {
+		if (req.isMutation() && !allowMutations) return next(req);
+		if (!(req instanceof RelayRequest)) throw new RRNLBatchMiddlewareError("Relay batch middleware accepts only simple RelayRequest. Did you add batchMiddleware twice?");
+		if (req.isFormData()) return next(req);
+		if (req.cacheConfig.skipBatch) return next(req);
+		return passThroughBatch(req, next, {
+			batchTimeout,
+			batchUrl,
+			singleton,
+			maxBatchSize,
+			fetchOpts
+		});
+	};
+}
+function passThroughBatch(req, next, opts) {
+	const { singleton } = opts;
+	const bodyLength = req.getBody().length;
+	if (!bodyLength) return next(req);
+	if (!singleton.batcher || !singleton.batcher.acceptRequests) singleton.batcher = prepareNewBatcher(next, opts);
+	if (singleton.batcher.bodySize + bodyLength + 1 > opts.maxBatchSize) singleton.batcher = prepareNewBatcher(next, opts);
+	singleton.batcher.bodySize += bodyLength + 1;
+	return new Promise((resolve, reject) => {
+		const { requestList } = singleton.batcher;
+		const requestWrapper = {
+			req,
+			completeOk: (res) => {
+				requestWrapper.done = true;
+				resolve(res);
+				requestWrapper.duplicates.forEach((r) => r.completeOk(res));
+			},
+			completeErr: (err) => {
+				requestWrapper.done = true;
+				reject(err);
+				requestWrapper.duplicates.forEach((r) => r.completeErr(err));
+			},
+			done: false,
+			duplicates: []
+		};
+		const duplicateIndex = requestList.findIndex((wrapper) => req.getBody() === wrapper.req.getBody());
+		if (duplicateIndex !== -1) requestList[duplicateIndex].duplicates.push(requestWrapper);
+		else requestList.push(requestWrapper);
+	});
+}
+function prepareNewBatcher(next, opts) {
+	const batcher = {
+		bodySize: 2,
+		requestList: [],
+		acceptRequests: true
+	};
+	setTimeout(() => {
+		batcher.acceptRequests = false;
+		sendRequests(batcher.requestList, next, opts).then(() => finalizeUncompleted(batcher.requestList)).catch((e) => {
+			if (e && e.name === "AbortError") finalizeCanceled(batcher.requestList, e);
+			else finalizeUncompleted(batcher.requestList);
+		});
+	}, opts.batchTimeout);
+	return batcher;
+}
+async function sendRequests(requestList, next, opts) {
+	if (requestList.length === 1) {
+		const wrapper = requestList[0];
+		const res = await next(wrapper.req);
+		wrapper.completeOk(res);
+		wrapper.duplicates.forEach((r) => r.completeOk(res));
+		return res;
+	} else if (requestList.length > 1) {
+		const batchRequest = new RelayRequestBatch(requestList.map((wrapper) => wrapper.req));
+		const url = await (isFunction(opts.batchUrl) ? opts.batchUrl(requestList) : opts.batchUrl);
+		batchRequest.setFetchOption("url", url);
+		const { headersOrThunk, ...fetchOpts } = opts.fetchOpts;
+		batchRequest.setFetchOptions(fetchOpts);
+		if (headersOrThunk) {
+			const headers = await (isFunction(headersOrThunk) ? headersOrThunk(batchRequest) : headersOrThunk);
+			batchRequest.setFetchOption("headers", headers);
+		}
+		try {
+			const batchResponse = await next(batchRequest);
+			if (!batchResponse || !Array.isArray(batchResponse.json)) throw new RRNLBatchMiddlewareError("Wrong response from server. Did your server support batch request?");
+			batchResponse.json.forEach((payload, index) => {
+				if (!payload) return;
+				const request = requestList[index];
+				if (request) {
+					const res = createSingleResponse(batchResponse, payload);
+					request.completeOk(res);
+				}
+			});
+			return batchResponse;
+		} catch (e) {
+			requestList.forEach((request) => request.completeErr(e));
+		}
+	}
+	return Promise.resolve();
+}
+function finalizeCanceled(requestList, error) {
+	requestList.forEach((request) => request.completeErr(error));
+}
+function finalizeUncompleted(requestList) {
+	requestList.forEach((request, index) => {
+		if (!request.done) request.completeErr(new RRNLBatchMiddlewareError(`Server does not return response for request at index ${index}.\nResponse should have an array with ${requestList.length} item(s).`));
+	});
+}
+function createSingleResponse(batchResponse, json) {
+	const data = json.payload || json;
+	const res = batchResponse.clone();
+	res.processJsonData(data);
+	return res;
+}
+//#endregion
+export { RRNLBatchMiddlewareError, batchMiddleware as default };

package/dist/middlewares/cache.cjs

@@ -0,0 +1,43 @@
+const require_utils = require("../utils.cjs");
+let relay_runtime = require("relay-runtime");
+//#region src/middlewares/cache.ts
+function cacheMiddleware(opts) {
+	const { size, ttl, onInit, allowMutations, allowFormData, clearOnMutation, cacheErrors, updateTTLOnGet } = opts || {};
+	const cache = new relay_runtime.QueryResponseCache({
+		size: size || 100,
+		ttl: ttl || 900 * 1e3
+	});
+	if (require_utils.isFunction(onInit)) onInit(cache);
+	return (next) => async (req) => {
+		if (req.isMutation()) {
+			if (clearOnMutation) cache.clear();
+			if (!allowMutations) return next(req);
+		}
+		if (req.isFormData() && !allowFormData) return next(req);
+		const cacheConfig = req.cacheConfig;
+		if (cacheConfig && cacheConfig.force) {
+			const queryId = req.getID();
+			const variables = req.getVariables();
+			const res = await next(req);
+			if (!res.errors || res.errors && cacheErrors) cache.set(queryId, variables, res);
+			return res;
+		}
+		try {
+			const queryId = req.getID();
+			const variables = req.getVariables();
+			const cachedRes = cache.get(queryId, variables);
+			if (cachedRes) {
+				if (updateTTLOnGet) cache.set(queryId, variables, cachedRes);
+				return cachedRes;
+			}
+			const res = await next(req);
+			if (!res.errors || res.errors && cacheErrors) cache.set(queryId, variables, res);
+			return res;
+		} catch (e) {
+			console.log(e);
+		}
+		return next(req);
+	};
+}
+//#endregion
+exports.default = cacheMiddleware;

package/dist/middlewares/cache.d.cts

@@ -0,0 +1,17 @@
+import { Middleware } from "../definition.cjs";
+import { QueryResponseCache } from "relay-runtime";
+
+//#region src/middlewares/cache.d.ts
+interface CacheMiddlewareOpts {
+  size?: number;
+  ttl?: number;
+  onInit?: (cache: QueryResponseCache) => any;
+  allowMutations?: boolean;
+  allowFormData?: boolean;
+  clearOnMutation?: boolean;
+  cacheErrors?: boolean;
+  updateTTLOnGet?: boolean;
+}
+declare function cacheMiddleware(opts?: CacheMiddlewareOpts): Middleware;
+//#endregion
+export { CacheMiddlewareOpts, cacheMiddleware };

package/dist/middlewares/cache.d.ts

@@ -0,0 +1,17 @@
+import { Middleware } from "../definition.js";
+import { QueryResponseCache } from "relay-runtime";
+
+//#region src/middlewares/cache.d.ts
+interface CacheMiddlewareOpts {
+  size?: number;
+  ttl?: number;
+  onInit?: (cache: QueryResponseCache) => any;
+  allowMutations?: boolean;
+  allowFormData?: boolean;
+  clearOnMutation?: boolean;
+  cacheErrors?: boolean;
+  updateTTLOnGet?: boolean;
+}
+declare function cacheMiddleware(opts?: CacheMiddlewareOpts): Middleware;
+//#endregion
+export { CacheMiddlewareOpts, cacheMiddleware };

package/dist/middlewares/cache.js

@@ -0,0 +1,43 @@
+import { isFunction } from "../utils.js";
+import { QueryResponseCache } from "relay-runtime";
+//#region src/middlewares/cache.ts
+function cacheMiddleware(opts) {
+	const { size, ttl, onInit, allowMutations, allowFormData, clearOnMutation, cacheErrors, updateTTLOnGet } = opts || {};
+	const cache = new QueryResponseCache({
+		size: size || 100,
+		ttl: ttl || 900 * 1e3
+	});
+	if (isFunction(onInit)) onInit(cache);
+	return (next) => async (req) => {
+		if (req.isMutation()) {
+			if (clearOnMutation) cache.clear();
+			if (!allowMutations) return next(req);
+		}
+		if (req.isFormData() && !allowFormData) return next(req);
+		const cacheConfig = req.cacheConfig;
+		if (cacheConfig && cacheConfig.force) {
+			const queryId = req.getID();
+			const variables = req.getVariables();
+			const res = await next(req);
+			if (!res.errors || res.errors && cacheErrors) cache.set(queryId, variables, res);
+			return res;
+		}
+		try {
+			const queryId = req.getID();
+			const variables = req.getVariables();
+			const cachedRes = cache.get(queryId, variables);
+			if (cachedRes) {
+				if (updateTTLOnGet) cache.set(queryId, variables, cachedRes);
+				return cachedRes;
+			}
+			const res = await next(req);
+			if (!res.errors || res.errors && cacheErrors) cache.set(queryId, variables, res);
+			return res;
+		} catch (e) {
+			console.log(e);
+		}
+		return next(req);
+	};
+}
+//#endregion
+export { cacheMiddleware as default };

package/dist/middlewares/error.cjs

@@ -0,0 +1,71 @@
+const require_RelayRequest = require("../RelayRequest.cjs");
+const require_RelayRequestBatch = require("../RelayRequestBatch.cjs");
+//#region src/middlewares/error.ts
+function errorMiddleware(options) {
+	const opts = options || {};
+	const logger = opts.logger || console.error.bind(console);
+	const prefix = opts.prefix || "[RELAY-NETWORK] GRAPHQL SERVER ERROR:\n\n";
+	const disableServerMiddlewareTip = opts.disableServerMiddlewareTip || false;
+	function displayErrors(errors, reqRes) {
+		return errors.forEach((error) => {
+			const { message, stack, ...rest } = error;
+			let msg = `${prefix}`;
+			const fmt = [];
+			if (stack && Array.isArray(stack)) {
+				msg = `${msg}%c${stack.shift()}\n%c${stack.join("\n")}`;
+				fmt.push("font-weight: bold;", "font-weight: normal;");
+			} else {
+				msg = `${msg}%c${message} %c`;
+				fmt.push("font-weight: bold;", "font-weight: normal;");
+			}
+			if (rest && Object.keys(rest).length) {
+				msg = `${msg}\n  %O`;
+				fmt.push(rest);
+			}
+			msg = `${msg}\n\n%cRequest Response data:\n  %c%O`;
+			fmt.push("font-weight: bold;", "font-weight: normal;", reqRes);
+			if (!stack && !disableServerMiddlewareTip) {
+				msg = `${msg}\n\n%cNotice:%c${noticeAbsentStack()}`;
+				fmt.push("font-weight: bold;", "font-weight: normal;");
+			}
+			logger(`${msg}\n\n`, ...fmt);
+		});
+	}
+	return (next) => (req) => {
+		return next(req).then((res) => {
+			if (req instanceof require_RelayRequest.default) {
+				if (Array.isArray(res.errors)) displayErrors(res.errors, {
+					req,
+					res
+				});
+			} else if (req instanceof require_RelayRequestBatch.default) {
+				if (Array.isArray(res.json)) res.json.forEach((payload) => {
+					if (Array.isArray(payload.errors)) displayErrors(payload.errors, {
+						req,
+						res
+					});
+				});
+			}
+			return res;
+		});
+	};
+}
+function noticeAbsentStack() {
+	return `
+    If you using 'express-graphql', you may get server stack-trace for error.
+    Just tune 'formatError' to return 'stack' with stack-trace:
+
+    import graphqlHTTP from 'express-graphql';
+
+    const graphQLMiddleware = graphqlHTTP({
+      schema: myGraphQLSchema,
+      formatError: (error) => ({
+        message: error.message,
+        stack: process.env​.NODE_ENV === 'development' ? error.stack.split('\\n') : null,
+      })
+    });
+
+    app.use('/graphql', graphQLMiddleware);`;
+}
+//#endregion
+exports.default = errorMiddleware;

package/dist/middlewares/error.d.cts

@@ -0,0 +1,11 @@
+import { Middleware } from "../definition.cjs";
+
+//#region src/middlewares/error.d.ts
+interface GqlErrorMiddlewareOpts {
+  logger?: Function;
+  prefix?: string;
+  disableServerMiddlewareTip?: boolean;
+}
+declare function errorMiddleware(options?: GqlErrorMiddlewareOpts): Middleware;
+//#endregion
+export { GqlErrorMiddlewareOpts, errorMiddleware };

package/dist/middlewares/error.d.ts

@@ -0,0 +1,11 @@
+import { Middleware } from "../definition.js";
+
+//#region src/middlewares/error.d.ts
+interface GqlErrorMiddlewareOpts {
+  logger?: Function;
+  prefix?: string;
+  disableServerMiddlewareTip?: boolean;
+}
+declare function errorMiddleware(options?: GqlErrorMiddlewareOpts): Middleware;
+//#endregion
+export { GqlErrorMiddlewareOpts, errorMiddleware };

package/dist/middlewares/error.js

@@ -0,0 +1,71 @@
+import RelayRequest from "../RelayRequest.js";
+import RelayRequestBatch from "../RelayRequestBatch.js";
+//#region src/middlewares/error.ts
+function errorMiddleware(options) {
+	const opts = options || {};
+	const logger = opts.logger || console.error.bind(console);
+	const prefix = opts.prefix || "[RELAY-NETWORK] GRAPHQL SERVER ERROR:\n\n";
+	const disableServerMiddlewareTip = opts.disableServerMiddlewareTip || false;
+	function displayErrors(errors, reqRes) {
+		return errors.forEach((error) => {
+			const { message, stack, ...rest } = error;
+			let msg = `${prefix}`;
+			const fmt = [];
+			if (stack && Array.isArray(stack)) {
+				msg = `${msg}%c${stack.shift()}\n%c${stack.join("\n")}`;
+				fmt.push("font-weight: bold;", "font-weight: normal;");
+			} else {
+				msg = `${msg}%c${message} %c`;
+				fmt.push("font-weight: bold;", "font-weight: normal;");
+			}
+			if (rest && Object.keys(rest).length) {
+				msg = `${msg}\n  %O`;
+				fmt.push(rest);
+			}
+			msg = `${msg}\n\n%cRequest Response data:\n  %c%O`;
+			fmt.push("font-weight: bold;", "font-weight: normal;", reqRes);
+			if (!stack && !disableServerMiddlewareTip) {
+				msg = `${msg}\n\n%cNotice:%c${noticeAbsentStack()}`;
+				fmt.push("font-weight: bold;", "font-weight: normal;");
+			}
+			logger(`${msg}\n\n`, ...fmt);
+		});
+	}
+	return (next) => (req) => {
+		return next(req).then((res) => {
+			if (req instanceof RelayRequest) {
+				if (Array.isArray(res.errors)) displayErrors(res.errors, {
+					req,
+					res
+				});
+			} else if (req instanceof RelayRequestBatch) {
+				if (Array.isArray(res.json)) res.json.forEach((payload) => {
+					if (Array.isArray(payload.errors)) displayErrors(payload.errors, {
+						req,
+						res
+					});
+				});
+			}
+			return res;
+		});
+	};
+}
+function noticeAbsentStack() {
+	return `
+    If you using 'express-graphql', you may get server stack-trace for error.
+    Just tune 'formatError' to return 'stack' with stack-trace:
+
+    import graphqlHTTP from 'express-graphql';
+
+    const graphQLMiddleware = graphqlHTTP({
+      schema: myGraphQLSchema,
+      formatError: (error) => ({
+        message: error.message,
+        stack: process.env​.NODE_ENV === 'development' ? error.stack.split('\\n') : null,
+      })
+    });
+
+    app.use('/graphql', graphQLMiddleware);`;
+}
+//#endregion
+export { errorMiddleware as default };

package/dist/middlewares/logger.cjs

@@ -0,0 +1,43 @@
+const require_RelayRequest = require("../RelayRequest.cjs");
+const require_RelayRequestBatch = require("../RelayRequestBatch.cjs");
+//#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 require_RelayRequest.default) {
+				queryId = req.getID();
+				queryData = {
+					query: req.getQueryString(),
+					variables: req.getVariables()
+				};
+			} else if (req instanceof require_RelayRequestBatch.default) {
+				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
+exports.default = loggerMiddleware;

package/dist/middlewares/logger.d.cts

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