@plumile/backoffice-react 0.1.157 → 0.1.159

package/lib/esm/relay/environment.js

@@ -1,58 +1,60 @@
 import { isDevEnv as e } from "./envHelpers.js";
 import { Environment as t, Network as n, Observable as r, RecordSource as i, Store as a } from "relay-runtime";
-import { createClient as o } from "graphql-ws";
 //#region src/relay/environment.ts
-var s = "/api/graphql", c = "/api/ws", l, u, d, f, p = {
+var o = "/api/graphql", s = "/api/ws", c, l, u, d, f = "graphql-transport-ws", p = 5e3, m = 1e4, h = 10, g = 500, _ = {
 	generation: 0,
 	reason: null,
 	status: "idle"
-}, m = /* @__PURE__ */ new Set();
-function h() {}
-var g = h;
-e() && (g = (e) => {
+}, v = /* @__PURE__ */ new Set();
+function y() {}
+var b = y;
+e() && (b = (e) => {
 	console.log("relayFieldLogger: ", e);
 });
-var _ = (e) => {
+var x = (e) => {
 	if (typeof e != "object" || !e) return null;
 	let { id: t } = e;
 	return typeof t != "string" || t.trim() === "" ? null : t;
-}, v = (e, t) => f?.(e, t) ?? _(e, t);
-function y(e, t) {
-	p = {
-		generation: p.generation + 1,
+}, S = (e, t) => d?.(e, t) ?? x(e, t);
+function C(e, t) {
+	_ = {
+		generation: _.generation + 1,
 		reason: t,
 		status: e
 	};
-	for (let e of m) e();
+	for (let e of v) e();
 }
-function b() {
-	if (u != null) {
+function w() {
+	if (l != null) {
 		try {
-			let e = u.dispose();
-			e instanceof Promise && e.catch(() => {});
+			l.dispose();
 		} catch {}
-		u = void 0;
+		l = void 0;
 	}
 }
-function x() {
-	return p;
+function T() {
+	return _;
 }
-function S(e) {
-	return m.add(e), () => {
-		m.delete(e);
+function E(e) {
+	return v.add(e), () => {
+		v.delete(e);
 	};
 }
-function C(e = {}) {
-	b(), y("reconnecting", e.reason ?? "manual_reconnect");
+function D(e = {}) {
+	w(), C("reconnecting", e.reason ?? "manual_reconnect");
+}
+async function O(e = {}) {
+	let t = l;
+	t?.hasActiveConnection() && (await t.refreshAuthentication() || D({ reason: e.reason ?? "auth_refresh_fallback" }));
 }
-function w(e = {}) {
+function k(e = {}) {
 	let { httpUrl: t, wsUrl: n, logEvents: r, getDataId: i, getAuthHeaders: a } = e;
-	typeof t == "string" && t !== "" && (s = t), typeof n == "string" && n !== "" && (c = n), r != null && (g = r ? (e) => {
+	typeof t == "string" && t !== "" && (o = t), typeof n == "string" && n !== "" && (s = n), r != null && (b = r ? (e) => {
 		console.log("relayFieldLogger: ", e);
-	} : h), f = i, d = a, b(), l = void 0, y("configured", "configure");
+	} : y), d = i, u = a, w(), c = void 0, C("configured", "configure");
 }
-function T() {
-	let e = c;
+function A() {
+	let e = s;
 	if (e.startsWith("ws")) return e;
 	if (e.startsWith("http")) return e.replace(/^http/, "ws");
 	if (e.startsWith("/")) {
@@ -62,53 +64,236 @@ function T() {
 	}
 	return e;
 }
-function E() {
-	if (u != null) return u;
-	if (typeof window > "u") throw Error("GraphQL subscriptions unavailable in non-browser environment");
-	return u = o({
-		url: T(),
-		keepAlive: 1e4,
-		lazy: !0,
-		retryAttempts: 10,
-		shouldRetry() {
-			return !0;
-		},
-		async retryWait(e) {
-			let t = Math.min(8e3, 500 * 2 ** e) + Math.random() * 200;
-			await new Promise((e) => {
-				setTimeout(() => {
-					e();
-				}, t);
+function j(...t) {
+	e() && console.log("[RelayNetwork]", ...t);
+}
+async function M() {
+	return u == null ? {} : u();
+}
+var N = class {
+	url;
+	socket = null;
+	connectPromise = null;
+	disposed = !1;
+	acknowledged = !1;
+	retryCount = 0;
+	nextId = 1;
+	keepAliveTimer = null;
+	subscriptions = /* @__PURE__ */ new Map();
+	pendingAuthUpdate = null;
+	constructor(e) {
+		this.url = e;
+	}
+	hasActiveConnection() {
+		return this.socket?.readyState === WebSocket.OPEN && this.acknowledged;
+	}
+	dispose() {
+		this.disposed = !0, this.resolvePendingAuthUpdate(!1), this.stopKeepAlive();
+		let { socket: e } = this;
+		this.socket = null, this.connectPromise = null, this.acknowledged = !1, e != null && e.readyState !== WebSocket.CLOSED && e.close(1e3, "Normal Closure");
+	}
+	subscribe(e, t) {
+		let n = String(this.nextId);
+		return this.nextId += 1, this.subscriptions.set(n, {
+			payload: e,
+			sink: t
+		}), this.connectAndSubscribe(n).catch((e) => {
+			j("subscription websocket connect failed", e), this.scheduleReconnect();
+		}), () => {
+			this.unsubscribe(n);
+		};
+	}
+	async refreshAuthentication() {
+		if (!this.hasActiveConnection()) return !0;
+		let { socket: e } = this;
+		if (e == null) return !0;
+		if (this.pendingAuthUpdate != null) return !1;
+		let t;
+		try {
+			t = await M();
+		} catch {
+			return !1;
+		}
+		return Object.keys(t).length === 0 ? !1 : new Promise((e) => {
+			let n = setTimeout(() => {
+				this.pendingAuthUpdate = null, e(!1);
+			}, p);
+			this.pendingAuthUpdate = {
+				resolve: e,
+				timeout: n
+			}, this.send({
+				type: "connection_auth_update",
+				payload: t
 			});
-		},
-		connectionParams: async () => {
-			if (d == null) return {};
+		});
+	}
+	async connectAndSubscribe(e) {
+		let t = this.hasActiveConnection();
+		if (await this.ensureConnected(), !t) return;
+		let n = this.subscriptions.get(e);
+		n != null && this.send({
+			id: e,
+			type: "subscribe",
+			payload: n.payload
+		});
+	}
+	async ensureConnected() {
+		if (!this.hasActiveConnection()) {
+			if (this.connectPromise != null) {
+				await this.connectPromise;
+				return;
+			}
+			this.connectPromise = this.openSocket();
 			try {
-				return await d();
-			} catch {
-				return {};
+				await this.connectPromise;
+			} finally {
+				this.connectPromise = null;
 			}
 		}
-	}), u;
+	}
+	async openSocket() {
+		if (this.disposed) throw Error("WebSocket client is disposed");
+		await new Promise((e, t) => {
+			let n = !1, r = () => {
+				n || (n = !0, e());
+			}, i = (e) => {
+				n || (n = !0, t(e));
+			}, a = new WebSocket(this.url, f);
+			this.socket = a, this.acknowledged = !1, a.onopen = () => {
+				M().catch(() => ({})).then((e) => {
+					if (a.readyState === WebSocket.OPEN) {
+						if (Object.keys(e).length > 0) {
+							this.send({
+								type: "connection_init",
+								payload: e
+							});
+							return;
+						}
+						this.send({ type: "connection_init" });
+					}
+				}).catch((e) => {
+					i(e);
+				});
+			}, a.onerror = () => {
+				i(/* @__PURE__ */ Error("GraphQL subscription websocket error"));
+			}, a.onmessage = (e) => {
+				this.handleMessage(e.data, r, i);
+			}, a.onclose = () => {
+				i(/* @__PURE__ */ Error("GraphQL subscription websocket closed")), this.handleClose();
+			};
+		});
+	}
+	handleMessage(e, t, n) {
+		let r;
+		try {
+			r = JSON.parse(String(e));
+		} catch {
+			n(/* @__PURE__ */ Error("Invalid GraphQL websocket message")), this.socket?.close(4400, "Invalid websocket message");
+			return;
+		}
+		switch (r.type) {
+			case "connection_ack":
+				this.acknowledged = !0, this.retryCount = 0, this.startKeepAlive(), t(), this.resubscribeActiveOperations();
+				return;
+			case "connection_auth_update_ack":
+				this.resolvePendingAuthUpdate(!0);
+				return;
+			case "next":
+				this.subscriptions.get(r.id)?.sink.next(r.payload);
+				return;
+			case "error":
+				r.id == null ? this.resolvePendingAuthUpdate(!1) : this.failSubscription(r.id, r.payload);
+				return;
+			case "complete":
+				this.completeSubscription(r.id);
+				return;
+			case "ping":
+				this.send({
+					type: "pong",
+					payload: r.payload
+				});
+				return;
+			case "pong": return;
+			default: n(/* @__PURE__ */ Error("Unsupported GraphQL websocket message")), this.socket?.close(4400, "Unsupported websocket message");
+		}
+	}
+	handleClose() {
+		this.acknowledged = !1, this.socket = null, this.connectPromise = null, this.stopKeepAlive(), this.resolvePendingAuthUpdate(!1), !this.disposed && this.subscriptions.size > 0 && this.scheduleReconnect();
+	}
+	scheduleReconnect() {
+		if (this.retryCount >= h) {
+			let e = /* @__PURE__ */ Error("GraphQL subscription websocket retry exhausted");
+			for (let t of [...this.subscriptions.keys()]) this.failSubscription(t, e);
+			return;
+		}
+		let e = Math.min(8e3, g * 2 ** this.retryCount) + Math.random() * 200;
+		this.retryCount += 1, setTimeout(() => {
+			this.disposed || this.subscriptions.size === 0 || this.ensureConnected().catch((e) => {
+				this.scheduleReconnect(), j("subscription websocket reconnect failed", e);
+			});
+		}, e);
+	}
+	resubscribeActiveOperations() {
+		for (let [e, t] of this.subscriptions) this.send({
+			id: e,
+			type: "subscribe",
+			payload: t.payload
+		});
+	}
+	unsubscribe(e) {
+		this.subscriptions.delete(e) && this.socket?.readyState === WebSocket.OPEN && this.send({
+			id: e,
+			type: "complete"
+		});
+	}
+	failSubscription(e, t) {
+		let n = this.subscriptions.get(e);
+		n != null && (this.subscriptions.delete(e), n.sink.error(t));
+	}
+	completeSubscription(e) {
+		let t = this.subscriptions.get(e);
+		t != null && (this.subscriptions.delete(e), t.sink.complete());
+	}
+	startKeepAlive() {
+		this.stopKeepAlive(), this.keepAliveTimer = setInterval(() => {
+			this.socket?.readyState === WebSocket.OPEN && this.send({ type: "ping" });
+		}, m);
+	}
+	stopKeepAlive() {
+		this.keepAliveTimer != null && (clearInterval(this.keepAliveTimer), this.keepAliveTimer = null);
+	}
+	resolvePendingAuthUpdate(e) {
+		let t = this.pendingAuthUpdate;
+		t != null && (clearTimeout(t.timeout), this.pendingAuthUpdate = null, t.resolve(e));
+	}
+	send(e) {
+		let { socket: t } = this;
+		t?.readyState === WebSocket.OPEN && t.send(JSON.stringify(e));
+	}
+};
+function P() {
+	if (l != null) return l;
+	if (typeof window > "u") throw Error("GraphQL subscriptions unavailable in non-browser environment");
+	return l = new N(A()), l;
 }
-function D(e) {
+function F(e) {
 	return typeof File < "u" && e instanceof File || typeof Blob < "u" && e instanceof Blob;
 }
-function O(e, t, n) {
-	if (D(e)) return n.push({
+function I(e, t, n) {
+	if (F(e)) return n.push({
 		path: t,
 		file: e
 	}), null;
-	if (Array.isArray(e)) return e.map((e, r) => O(e, `${t}.${r}`, n));
+	if (Array.isArray(e)) return e.map((e, r) => I(e, `${t}.${r}`, n));
 	if (typeof e == "object" && e) {
 		let r = {};
-		for (let [i, a] of Object.entries(e)) r[i] = O(a, `${t}.${i}`, n);
+		for (let [i, a] of Object.entries(e)) r[i] = I(a, `${t}.${i}`, n);
 		return r;
 	}
 	return e;
 }
-function k(e, t) {
-	let n = [], r = O(t, "variables", n), i = new FormData(), a = {
+function L(e, t) {
+	let n = [], r = I(t, "variables", n), i = new FormData(), a = {
 		query: e,
 		variables: r
 	};
@@ -120,91 +305,88 @@ function k(e, t) {
 		i.append(String(t), e.file);
 	}), i;
 }
-var A = {
+var R = {
 	maxAttempts: 3,
 	baseDelayMs: 300,
 	maxDelayMs: 4e3,
 	fetchTimeoutMs: 6e5
 };
-async function j(e) {
+async function z(e) {
 	await new Promise((t) => {
 		setTimeout(() => {
 			t();
 		}, e);
 	});
 }
-function M(e, t) {
+function B(e, t) {
 	let n = Math.min(t.maxDelayMs, t.baseDelayMs * 2 ** e);
 	return n + Math.random() * .2 * n;
 }
-function N(e) {
+function V(e) {
 	return e === 408 || e === 429 || e >= 500 && e < 600;
 }
-function P(e) {
+function H(e) {
 	return e instanceof TypeError || e instanceof Error && e.name === "AbortError";
 }
-function F(...t) {
-	e() && console.log("[RelayNetwork]", ...t);
-}
-async function I(e, t, n, r) {
+async function U(e, t, n, r) {
 	let i = e.text;
 	if (i == null) throw Error("Missing GraphQL query text");
 	let a = i;
-	async function o(e) {
+	async function s(e) {
 		let n = new AbortController(), r = setTimeout(() => {
 			n.abort();
-		}, A.fetchTimeoutMs);
+		}, R.fetchTimeoutMs);
 		try {
 			let r, i = {};
-			if (d != null) try {
-				Object.assign(i, await d());
+			if (u != null) try {
+				Object.assign(i, await u());
 			} catch {}
 			(() => {
 				try {
 					let e = [t];
 					for (; e.length > 0;) {
 						let t = e.pop();
-						if (D(t)) return !0;
+						if (F(t)) return !0;
 						Array.isArray(t) ? e.push(...t) : typeof t == "object" && t && e.push(...Object.values(t));
 					}
 				} catch {}
 				return !1;
-			})() ? r = k(a, t) : (i["Content-Type"] = "application/json", r = JSON.stringify({
+			})() ? r = L(a, t) : (i["Content-Type"] = "application/json", r = JSON.stringify({
 				query: a,
 				variables: t
 			}));
-			let o = await fetch(s, {
+			let s = await fetch(o, {
 				method: "POST",
 				body: r,
 				headers: i,
 				credentials: "include",
 				signal: n.signal
 			});
-			if (!o.ok) {
-				if (e < A.maxAttempts - 1 && N(o.status)) throw Error(`Retryable HTTP status ${o.status}`);
-				let t = await o.text().catch(() => "");
-				throw Error(`GraphQL HTTP error ${o.status}: ${t}`);
+			if (!s.ok) {
+				if (e < R.maxAttempts - 1 && V(s.status)) throw Error(`Retryable HTTP status ${s.status}`);
+				let t = await s.text().catch(() => "");
+				throw Error(`GraphQL HTTP error ${s.status}: ${t}`);
 			}
-			let c = await o.json();
-			return Array.isArray(c.errors) && c.errors.length > 0 && F("GraphQL errors", c.errors), c;
+			let c = await s.json();
+			return Array.isArray(c.errors) && c.errors.length > 0 && j("GraphQL errors", c.errors), c;
 		} finally {
 			clearTimeout(r);
 		}
 	}
-	for (let e = 0; e < A.maxAttempts; e += 1) try {
-		return await o(e);
+	for (let e = 0; e < R.maxAttempts; e += 1) try {
+		return await s(e);
 	} catch (t) {
-		let n = e === A.maxAttempts - 1;
-		if (!(P(t) || t instanceof Error && t.message.includes("Retryable HTTP status")) || n) throw F("GraphQL fetch error", t), t;
-		await j(M(e, A));
+		let n = e === R.maxAttempts - 1;
+		if (!(H(t) || t instanceof Error && t.message.includes("Retryable HTTP status")) || n) throw j("GraphQL fetch error", t), t;
+		await z(B(e, R));
 	}
 	throw Error("Exhausted retries without returning a result");
 }
-function L(e, t) {
-	return F("subscription:start", e.name, t), r.create((n) => {
+function W(e, t) {
+	return j("subscription:start", e.name, t), r.create((n) => {
 		let r = e.text;
 		if (r == null || r === "") return n.error(/* @__PURE__ */ Error("Subscription operation text is empty")), () => {};
-		let i = E().subscribe({
+		let i = P().subscribe({
 			query: r,
 			variables: t,
 			operationName: e.name
@@ -225,31 +407,32 @@ function L(e, t) {
 		};
 	});
 }
-function R() {
-	return n.create(I, L);
+function G() {
+	return n.create(U, W);
 }
-function z() {
-	return l ??= new t({
-		getDataID: v,
-		relayFieldLogger: g,
-		network: R(),
+function K() {
+	return c ??= new t({
+		getDataID: S,
+		relayFieldLogger: b,
+		network: G(),
 		store: new a(new i())
-	}), l;
+	}), c;
 }
-function B() {
-	let e = z(), t = new i();
+function q() {
+	let e = K(), t = new i();
 	e.getStore().publish(t), e.getStore().notify();
 }
-var V = {
-	buildFormData: k,
-	calcBackoff: M,
-	collectFiles: O,
-	getDataId: v,
-	isNetworkError: P,
-	isRetryableStatus: N,
-	isUploadable: D
+var J = {
+	RelayWebSocketClient: N,
+	buildFormData: L,
+	calcBackoff: B,
+	collectFiles: I,
+	getDataId: S,
+	isNetworkError: H,
+	isRetryableStatus: V,
+	isUploadable: F
 };
 //#endregion
-export { V as __test, w as configureRelayEnvironment, z as getEnvironment, R as getNetwork, x as getRelayTransportSnapshot, C as reconnectRelayWebSocket, B as resetRelayStore, S as subscribeRelayTransport };
+export { J as __test, k as configureRelayEnvironment, K as getEnvironment, G as getNetwork, T as getRelayTransportSnapshot, D as reconnectRelayWebSocket, O as refreshRelayWebSocketAuthentication, q as resetRelayStore, E as subscribeRelayTransport };
 
 //# sourceMappingURL=environment.js.map