@nsxbet/react-relay-network-modern 1.0.0

package/dist/RelayRequest.js

@@ -0,0 +1,90 @@
+import RRNLError from "./RRNLError.js";
+//#region src/RelayRequest.ts
+function getFormDataInterface() {
+	return typeof window !== "undefined" && window.FormData || global && global.FormData;
+}
+var RelayRequest = class {
+	static lastGenId;
+	id;
+	fetchOpts;
+	operation;
+	variables;
+	cacheConfig;
+	uploadables;
+	controller;
+	constructor(operation, variables, cacheConfig, uploadables) {
+		this.operation = operation;
+		this.variables = variables;
+		this.cacheConfig = cacheConfig;
+		this.uploadables = uploadables;
+		this.id = this.operation.id || this.operation.name || this._generateID();
+		const fetchOpts = {
+			method: "POST",
+			headers: {},
+			body: this.prepareBody()
+		};
+		this.controller = typeof window !== "undefined" && window.AbortController ? new window.AbortController() : null;
+		if (this.controller) fetchOpts.signal = this.controller.signal;
+		this.fetchOpts = fetchOpts;
+	}
+	getBody() {
+		return this.fetchOpts.body;
+	}
+	prepareBody() {
+		const { uploadables } = this;
+		if (uploadables) {
+			const _FormData_ = getFormDataInterface();
+			if (!_FormData_) throw new RRNLError("Uploading files without `FormData` interface does not supported.");
+			const formData = new _FormData_();
+			formData.append("id", this.getID());
+			formData.append("query", this.getQueryString());
+			formData.append("variables", JSON.stringify(this.getVariables()));
+			Object.keys(uploadables).forEach((key) => {
+				if (Object.prototype.hasOwnProperty.call(uploadables, key)) formData.append(key, uploadables[key]);
+			});
+			return formData;
+		}
+		return JSON.stringify({
+			id: this.getID(),
+			query: this.getQueryString(),
+			variables: this.getVariables()
+		});
+	}
+	getID() {
+		return this.id;
+	}
+	_generateID() {
+		const ctor = this.constructor;
+		if (!ctor.lastGenId) ctor.lastGenId = 0;
+		ctor.lastGenId += 1;
+		return ctor.lastGenId.toString();
+	}
+	getQueryString() {
+		return this.operation.text || "";
+	}
+	getVariables() {
+		return this.variables;
+	}
+	isMutation() {
+		return this.operation.operationKind === "mutation";
+	}
+	isFormData() {
+		const _FormData_ = getFormDataInterface();
+		return !!_FormData_ && this.fetchOpts.body instanceof _FormData_;
+	}
+	cancel() {
+		if (this.controller) {
+			this.controller.abort();
+			return true;
+		}
+		return false;
+	}
+	clone() {
+		const newRequest = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+		newRequest.fetchOpts = { ...this.fetchOpts };
+		newRequest.fetchOpts.headers = { ...this.fetchOpts.headers };
+		return newRequest;
+	}
+};
+//#endregion
+export { RelayRequest as default };

package/dist/RelayRequestBatch.cjs

@@ -0,0 +1,56 @@
+const require_RRNLError = require("./RRNLError.cjs");
+//#region src/RelayRequestBatch.ts
+var RelayRequestBatch = class {
+	fetchOpts;
+	requests;
+	constructor(requests) {
+		this.requests = requests;
+		this.fetchOpts = {
+			method: "POST",
+			headers: {},
+			body: this.prepareBody()
+		};
+	}
+	setFetchOption(name, value) {
+		this.fetchOpts[name] = value;
+	}
+	setFetchOptions(opts) {
+		this.fetchOpts = {
+			...this.fetchOpts,
+			...opts
+		};
+	}
+	getBody() {
+		if (!this.fetchOpts.body) this.fetchOpts.body = this.prepareBody();
+		return this.fetchOpts.body || "";
+	}
+	prepareBody() {
+		return `[${this.requests.map((r) => r.getBody()).join(",")}]`;
+	}
+	getIds() {
+		return this.requests.map((r) => r.getID());
+	}
+	getID() {
+		return `BATCH_REQUEST:${this.getIds().join(":")}`;
+	}
+	isMutation() {
+		return false;
+	}
+	isFormData() {
+		return false;
+	}
+	clone() {
+		const newRequest = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+		newRequest.fetchOpts = { ...this.fetchOpts };
+		newRequest.fetchOpts.headers = { ...this.fetchOpts.headers };
+		return newRequest;
+	}
+	getVariables() {
+		throw new require_RRNLError.default("Batch request does not have variables.");
+	}
+	getQueryString() {
+		return this.prepareBody();
+	}
+};
+//#endregion
+exports.default = RelayRequestBatch;

package/dist/RelayRequestBatch.d.cts

@@ -0,0 +1,23 @@
+import { RelayRequest } from "./RelayRequest.cjs";
+import { FetchOpts, Variables } from "./definition.cjs";
+
+//#region src/RelayRequestBatch.d.ts
+type Requests = RelayRequest[];
+declare class RelayRequestBatch {
+  fetchOpts: Partial<FetchOpts>;
+  requests: Requests;
+  constructor(requests: Requests);
+  setFetchOption(name: string, value: unknown): void;
+  setFetchOptions(opts: Partial<FetchOpts>): void;
+  getBody(): string;
+  prepareBody(): string;
+  getIds(): string[];
+  getID(): string;
+  isMutation(): boolean;
+  isFormData(): boolean;
+  clone(): RelayRequestBatch;
+  getVariables(): Variables;
+  getQueryString(): string;
+}
+//#endregion
+export { RelayRequestBatch };

package/dist/RelayRequestBatch.d.ts

@@ -0,0 +1,23 @@
+import { RelayRequest } from "./RelayRequest.js";
+import { FetchOpts, Variables } from "./definition.js";
+
+//#region src/RelayRequestBatch.d.ts
+type Requests = RelayRequest[];
+declare class RelayRequestBatch {
+  fetchOpts: Partial<FetchOpts>;
+  requests: Requests;
+  constructor(requests: Requests);
+  setFetchOption(name: string, value: unknown): void;
+  setFetchOptions(opts: Partial<FetchOpts>): void;
+  getBody(): string;
+  prepareBody(): string;
+  getIds(): string[];
+  getID(): string;
+  isMutation(): boolean;
+  isFormData(): boolean;
+  clone(): RelayRequestBatch;
+  getVariables(): Variables;
+  getQueryString(): string;
+}
+//#endregion
+export { RelayRequestBatch };

package/dist/RelayRequestBatch.js

@@ -0,0 +1,56 @@
+import RRNLError from "./RRNLError.js";
+//#region src/RelayRequestBatch.ts
+var RelayRequestBatch = class {
+	fetchOpts;
+	requests;
+	constructor(requests) {
+		this.requests = requests;
+		this.fetchOpts = {
+			method: "POST",
+			headers: {},
+			body: this.prepareBody()
+		};
+	}
+	setFetchOption(name, value) {
+		this.fetchOpts[name] = value;
+	}
+	setFetchOptions(opts) {
+		this.fetchOpts = {
+			...this.fetchOpts,
+			...opts
+		};
+	}
+	getBody() {
+		if (!this.fetchOpts.body) this.fetchOpts.body = this.prepareBody();
+		return this.fetchOpts.body || "";
+	}
+	prepareBody() {
+		return `[${this.requests.map((r) => r.getBody()).join(",")}]`;
+	}
+	getIds() {
+		return this.requests.map((r) => r.getID());
+	}
+	getID() {
+		return `BATCH_REQUEST:${this.getIds().join(":")}`;
+	}
+	isMutation() {
+		return false;
+	}
+	isFormData() {
+		return false;
+	}
+	clone() {
+		const newRequest = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+		newRequest.fetchOpts = { ...this.fetchOpts };
+		newRequest.fetchOpts.headers = { ...this.fetchOpts.headers };
+		return newRequest;
+	}
+	getVariables() {
+		throw new RRNLError("Batch request does not have variables.");
+	}
+	getQueryString() {
+		return this.prepareBody();
+	}
+};
+//#endregion
+export { RelayRequestBatch as default };

package/dist/RelayResponse.cjs

@@ -0,0 +1,56 @@
+//#region src/RelayResponse.ts
+var RelayResponse = class RelayResponse {
+	_res;
+	data;
+	errors;
+	ok;
+	status;
+	statusText;
+	headers;
+	url;
+	text;
+	json;
+	static async createFromFetch(res) {
+		const r = new RelayResponse();
+		r._res = res;
+		r.ok = res.ok;
+		r.status = res.status;
+		r.url = res.url;
+		r.headers = res.headers;
+		if (res.status < 200 || res.status >= 300) r.text = await res.text();
+		else r.processJsonData(await res.json());
+		return r;
+	}
+	static async createFromGraphQL(res) {
+		const r = new RelayResponse();
+		r._res = res;
+		r.ok = true;
+		r.status = 200;
+		r.data = res.data;
+		r.errors = res.errors;
+		return r;
+	}
+	processJsonData(json) {
+		this.json = json;
+		if (json) {
+			const j = json;
+			if (j.data) this.data = j.data;
+			if (j.errors) this.errors = j.errors;
+		}
+	}
+	clone() {
+		return Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+	}
+	toString() {
+		return [
+			`Response:`,
+			`   Url: ${this.url || ""}`,
+			`   Status code: ${this.status || ""}`,
+			`   Status text: ${this.statusText || ""}`,
+			`   Response headers: ${JSON.stringify(this.headers) || ""}`,
+			`   Response body: ${JSON.stringify(this.json) || ""}`
+		].join("\n");
+	}
+};
+//#endregion
+exports.default = RelayResponse;

package/dist/RelayResponse.d.cts

@@ -0,0 +1,27 @@
+import { FetchResponse, GraphQLResponseErrors, PayloadData } from "./definition.cjs";
+
+//#region src/RelayResponse.d.ts
+declare class RelayResponse {
+  _res: any;
+  data?: PayloadData | null;
+  errors?: GraphQLResponseErrors | null;
+  ok: any;
+  status: number;
+  statusText?: string | null;
+  headers?: {
+    [name: string]: string;
+  } | null;
+  url?: string | null;
+  text?: string | null;
+  json?: unknown;
+  static createFromFetch(res: FetchResponse): Promise<RelayResponse>;
+  static createFromGraphQL(res: {
+    errors?: any;
+    data?: any;
+  }): Promise<RelayResponse>;
+  processJsonData(json: unknown): void;
+  clone(): RelayResponse;
+  toString(): string;
+}
+//#endregion
+export { RelayResponse };

package/dist/RelayResponse.d.ts

@@ -0,0 +1,27 @@
+import { FetchResponse, GraphQLResponseErrors, PayloadData } from "./definition.js";
+
+//#region src/RelayResponse.d.ts
+declare class RelayResponse {
+  _res: any;
+  data?: PayloadData | null;
+  errors?: GraphQLResponseErrors | null;
+  ok: any;
+  status: number;
+  statusText?: string | null;
+  headers?: {
+    [name: string]: string;
+  } | null;
+  url?: string | null;
+  text?: string | null;
+  json?: unknown;
+  static createFromFetch(res: FetchResponse): Promise<RelayResponse>;
+  static createFromGraphQL(res: {
+    errors?: any;
+    data?: any;
+  }): Promise<RelayResponse>;
+  processJsonData(json: unknown): void;
+  clone(): RelayResponse;
+  toString(): string;
+}
+//#endregion
+export { RelayResponse };

package/dist/RelayResponse.js

@@ -0,0 +1,56 @@
+//#region src/RelayResponse.ts
+var RelayResponse = class RelayResponse {
+	_res;
+	data;
+	errors;
+	ok;
+	status;
+	statusText;
+	headers;
+	url;
+	text;
+	json;
+	static async createFromFetch(res) {
+		const r = new RelayResponse();
+		r._res = res;
+		r.ok = res.ok;
+		r.status = res.status;
+		r.url = res.url;
+		r.headers = res.headers;
+		if (res.status < 200 || res.status >= 300) r.text = await res.text();
+		else r.processJsonData(await res.json());
+		return r;
+	}
+	static async createFromGraphQL(res) {
+		const r = new RelayResponse();
+		r._res = res;
+		r.ok = true;
+		r.status = 200;
+		r.data = res.data;
+		r.errors = res.errors;
+		return r;
+	}
+	processJsonData(json) {
+		this.json = json;
+		if (json) {
+			const j = json;
+			if (j.data) this.data = j.data;
+			if (j.errors) this.errors = j.errors;
+		}
+	}
+	clone() {
+		return Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+	}
+	toString() {
+		return [
+			`Response:`,
+			`   Url: ${this.url || ""}`,
+			`   Status code: ${this.status || ""}`,
+			`   Status text: ${this.statusText || ""}`,
+			`   Response headers: ${JSON.stringify(this.headers) || ""}`,
+			`   Response body: ${JSON.stringify(this.json) || ""}`
+		].join("\n");
+	}
+};
+//#endregion
+export { RelayResponse as default };

package/dist/createRequestError.cjs

@@ -0,0 +1,48 @@
+const require_RRNLError = require("./RRNLError.cjs");
+const require_RelayRequest = require("./RelayRequest.cjs");
+//#region src/createRequestError.ts
+var RRNLRequestError = class extends require_RRNLError.default {
+	req;
+	res;
+	constructor(msg) {
+		super(msg);
+		this.name = "RRNLRequestError";
+	}
+};
+/**
+* Formats an error response from GraphQL server request.
+*/
+function formatGraphQLErrors(request, errors) {
+	const CONTEXT_BEFORE = 20;
+	const CONTEXT_LENGTH = 60;
+	if (!request.getQueryString) return errors.join("\n");
+	let queryLines = [];
+	const queryString = request.getQueryString();
+	if (queryString) queryLines = queryString.split("\n");
+	return errors.map(({ locations, message }, ii) => {
+		const prefix = `${ii + 1}. `;
+		const indent = " ".repeat(prefix.length);
+		const locationMessage = locations && queryLines.length ? "\n" + locations.map(({ column, line }) => {
+			const queryLine = queryLines[line - 1];
+			const offset = Math.min(column - 1, CONTEXT_BEFORE);
+			return [queryLine.substr(column - 1 - offset, CONTEXT_LENGTH), `${" ".repeat(Math.max(offset, 0))}^^^`].map((messageLine) => indent + messageLine).join("\n");
+		}).join("\n") : "";
+		return prefix + message + locationMessage;
+	}).join("\n");
+}
+function createRequestError(req, res) {
+	let errorReason = "";
+	if (!res) errorReason = "Server return empty response.";
+	else if (res.errors) if (req instanceof require_RelayRequest.default) errorReason = formatGraphQLErrors(req, res.errors);
+	else errorReason = JSON.stringify(res.errors);
+	else if (!res.json) errorReason = (res.text ? res.text : `Server return empty response with Status Code: ${res.status}.`) + (res ? `\n\n${res.toString()}` : "");
+	else if (!res.data) errorReason = "Server return empty response.data.\n\n" + res.toString();
+	const error = new RRNLRequestError(`Relay request for \`${req.getID()}\` failed by the following reasons:\n\n${errorReason}`);
+	error.req = req;
+	error.res = res;
+	return error;
+}
+//#endregion
+exports.RRNLRequestError = RRNLRequestError;
+exports.createRequestError = createRequestError;
+exports.formatGraphQLErrors = formatGraphQLErrors;

package/dist/createRequestError.d.cts

@@ -0,0 +1,18 @@
+import { RelayRequest } from "./RelayRequest.cjs";
+import { RelayResponse } from "./RelayResponse.cjs";
+import { GraphQLResponseErrors, RelayRequestAny } from "./definition.cjs";
+import { RRNLError } from "./RRNLError.cjs";
+
+//#region src/createRequestError.d.ts
+declare class RRNLRequestError extends RRNLError {
+  req: RelayRequestAny;
+  res?: RelayResponse | null;
+  constructor(msg: string);
+}
+/**
+ * Formats an error response from GraphQL server request.
+ */
+declare function formatGraphQLErrors(request: RelayRequest, errors: GraphQLResponseErrors): string;
+declare function createRequestError(req: RelayRequestAny, res?: RelayResponse | null): RRNLRequestError;
+//#endregion
+export { RRNLRequestError, createRequestError, formatGraphQLErrors };

package/dist/createRequestError.d.ts

@@ -0,0 +1,18 @@
+import { RelayRequest } from "./RelayRequest.js";
+import { RelayResponse } from "./RelayResponse.js";
+import { GraphQLResponseErrors, RelayRequestAny } from "./definition.js";
+import { RRNLError } from "./RRNLError.js";
+
+//#region src/createRequestError.d.ts
+declare class RRNLRequestError extends RRNLError {
+  req: RelayRequestAny;
+  res?: RelayResponse | null;
+  constructor(msg: string);
+}
+/**
+ * Formats an error response from GraphQL server request.
+ */
+declare function formatGraphQLErrors(request: RelayRequest, errors: GraphQLResponseErrors): string;
+declare function createRequestError(req: RelayRequestAny, res?: RelayResponse | null): RRNLRequestError;
+//#endregion
+export { RRNLRequestError, createRequestError, formatGraphQLErrors };

package/dist/createRequestError.js

@@ -0,0 +1,46 @@
+import RRNLError from "./RRNLError.js";
+import RelayRequest from "./RelayRequest.js";
+//#region src/createRequestError.ts
+var RRNLRequestError = class extends RRNLError {
+	req;
+	res;
+	constructor(msg) {
+		super(msg);
+		this.name = "RRNLRequestError";
+	}
+};
+/**
+* Formats an error response from GraphQL server request.
+*/
+function formatGraphQLErrors(request, errors) {
+	const CONTEXT_BEFORE = 20;
+	const CONTEXT_LENGTH = 60;
+	if (!request.getQueryString) return errors.join("\n");
+	let queryLines = [];
+	const queryString = request.getQueryString();
+	if (queryString) queryLines = queryString.split("\n");
+	return errors.map(({ locations, message }, ii) => {
+		const prefix = `${ii + 1}. `;
+		const indent = " ".repeat(prefix.length);
+		const locationMessage = locations && queryLines.length ? "\n" + locations.map(({ column, line }) => {
+			const queryLine = queryLines[line - 1];
+			const offset = Math.min(column - 1, CONTEXT_BEFORE);
+			return [queryLine.substr(column - 1 - offset, CONTEXT_LENGTH), `${" ".repeat(Math.max(offset, 0))}^^^`].map((messageLine) => indent + messageLine).join("\n");
+		}).join("\n") : "";
+		return prefix + message + locationMessage;
+	}).join("\n");
+}
+function createRequestError(req, res) {
+	let errorReason = "";
+	if (!res) errorReason = "Server return empty response.";
+	else if (res.errors) if (req instanceof RelayRequest) errorReason = formatGraphQLErrors(req, res.errors);
+	else errorReason = JSON.stringify(res.errors);
+	else if (!res.json) errorReason = (res.text ? res.text : `Server return empty response with Status Code: ${res.status}.`) + (res ? `\n\n${res.toString()}` : "");
+	else if (!res.data) errorReason = "Server return empty response.data.\n\n" + res.toString();
+	const error = new RRNLRequestError(`Relay request for \`${req.getID()}\` failed by the following reasons:\n\n${errorReason}`);
+	error.req = req;
+	error.res = res;
+	return error;
+}
+//#endregion
+export { RRNLRequestError, createRequestError, formatGraphQLErrors };

package/dist/definition.d.cts

@@ -0,0 +1,95 @@
+import { RelayRequest } from "./RelayRequest.cjs";
+import { RelayRequestBatch } from "./RelayRequestBatch.cjs";
+import { RelayResponse } from "./RelayResponse.cjs";
+
+//#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 };