@gatwech/auth 1.0.0-beta.18

package/dist/proxy-CL9PZXJA.mjs

@@ -0,0 +1,441 @@
+import { t as getBaseURL } from "./url-VB2gAbTI.mjs";
+import { t as parseJSON } from "./parser-DcrIEuXE.mjs";
+import { BetterFetchError, createFetch } from "@better-fetch/fetch";
+import { atom, onMount } from "nanostores";
+
+//#region src/client/broadcast-channel.ts
+const now$1 = () => Math.floor(Date.now() / 1e3);
+function createBroadcastChannel(name = "payvo-auth.message") {
+	return {
+		receive(onReceive) {
+			const handler = (event) => {
+				if (event.key !== name) return;
+				const message = JSON.parse(event.newValue ?? "{}");
+				if (message?.event !== "session" || !message?.data) return;
+				onReceive(message);
+			};
+			window.addEventListener("storage", handler);
+			return () => window.removeEventListener("storage", handler);
+		},
+		post(message) {
+			if (typeof window === "undefined") return;
+			try {
+				localStorage.setItem(name, JSON.stringify({
+					...message,
+					timestamp: now$1()
+				}));
+			} catch {}
+		}
+	};
+}
+
+//#endregion
+//#region src/client/query.ts
+const isServer = typeof window === "undefined";
+const useAuthQuery = (initializedAtom, path, $fetch, options) => {
+	const value = atom({
+		data: null,
+		error: null,
+		isPending: true,
+		isRefetching: false,
+		refetch: (queryParams) => {
+			return fn(queryParams);
+		}
+	});
+	const fn = (queryParams) => {
+		const opts = typeof options === "function" ? options({
+			data: value.get().data,
+			error: value.get().error,
+			isPending: value.get().isPending
+		}) : options;
+		$fetch(path, {
+			...opts,
+			query: {
+				...opts?.query,
+				...queryParams?.query
+			},
+			async onSuccess(context) {
+				value.set({
+					data: context.data,
+					error: null,
+					isPending: false,
+					isRefetching: false,
+					refetch: value.value.refetch
+				});
+				await opts?.onSuccess?.(context);
+			},
+			async onError(context) {
+				const { request } = context;
+				const retryAttempts = typeof request.retry === "number" ? request.retry : request.retry?.attempts;
+				const retryAttempt = request.retryAttempt || 0;
+				if (retryAttempts && retryAttempt < retryAttempts) return;
+				value.set({
+					error: context.error,
+					data: null,
+					isPending: false,
+					isRefetching: false,
+					refetch: value.value.refetch
+				});
+				await opts?.onError?.(context);
+			},
+			async onRequest(context) {
+				const currentValue = value.get();
+				value.set({
+					isPending: currentValue.data === null,
+					data: currentValue.data,
+					error: null,
+					isRefetching: true,
+					refetch: value.value.refetch
+				});
+				await opts?.onRequest?.(context);
+			}
+		}).catch((error) => {
+			value.set({
+				error,
+				data: null,
+				isPending: false,
+				isRefetching: false,
+				refetch: value.value.refetch
+			});
+		});
+	};
+	initializedAtom = Array.isArray(initializedAtom) ? initializedAtom : [initializedAtom];
+	let isMounted = false;
+	for (const initAtom of initializedAtom) initAtom.subscribe(() => {
+		if (isServer) return;
+		if (isMounted) fn();
+		else onMount(value, () => {
+			const timeoutId = setTimeout(() => {
+				if (!isMounted) {
+					fn();
+					isMounted = true;
+				}
+			}, 0);
+			return () => {
+				value.off();
+				initAtom.off();
+				clearTimeout(timeoutId);
+			};
+		});
+	});
+	return value;
+};
+
+//#endregion
+//#region src/client/session-refresh.ts
+const now = () => Math.floor(Date.now() / 1e3);
+function createSessionRefreshManager(opts) {
+	const { sessionAtom, sessionSignal, options = {} } = opts;
+	const { refetchInterval = 0, refetchOnWindowFocus = true, refetchWhenOffline = false } = options?.sessionOptions || {};
+	const state = {
+		lastSync: 0,
+		cachedSession: void 0
+	};
+	let isOnline = typeof navigator !== "undefined" ? navigator.onLine : true;
+	const broadcast = createBroadcastChannel();
+	const shouldRefetch = () => {
+		if (typeof window === "undefined") return false;
+		return refetchWhenOffline || isOnline;
+	};
+	const triggerRefetch = (event) => {
+		if (!shouldRefetch()) return;
+		if (event?.event === "storage") {
+			state.lastSync = now();
+			sessionSignal.set(!sessionSignal.get());
+			return;
+		}
+		const currentSession = sessionAtom.get();
+		if (currentSession?.data === null || currentSession?.data === void 0 || event?.event === "poll" || event?.event === "visibilitychange") {
+			state.lastSync = now();
+			sessionSignal.set(!sessionSignal.get());
+		}
+	};
+	const broadcastSessionUpdate = (trigger) => {
+		broadcast.post({
+			event: "session",
+			data: { trigger },
+			clientId: Math.random().toString(36).substring(7)
+		});
+	};
+	const setupPolling = () => {
+		if (refetchInterval && refetchInterval > 0) state.pollInterval = setInterval(() => {
+			if (sessionAtom.get()?.data) triggerRefetch({ event: "poll" });
+		}, refetchInterval * 1e3);
+	};
+	const setupBroadcast = () => {
+		state.unsubscribeBroadcast = broadcast.receive(() => {
+			triggerRefetch({ event: "storage" });
+		});
+	};
+	const setupVisibilityChange = () => {
+		if (!refetchOnWindowFocus) return;
+		if (typeof document === "undefined") return;
+		const visibilityHandler = () => {
+			if (document.visibilityState === "visible") triggerRefetch({ event: "visibilitychange" });
+		};
+		document.addEventListener("visibilitychange", visibilityHandler, false);
+		state.unsubscribeVisibility = () => {
+			document.removeEventListener("visibilitychange", visibilityHandler, false);
+		};
+	};
+	const setupOnlineDetection = () => {
+		if (typeof window === "undefined") return;
+		const setOnline = () => {
+			isOnline = true;
+			triggerRefetch({ event: "visibilitychange" });
+		};
+		const setOffline = () => {
+			isOnline = false;
+		};
+		window.addEventListener("online", setOnline);
+		window.addEventListener("offline", setOffline);
+		state.unsubscribeOnline = () => window.removeEventListener("online", setOnline);
+		state.unsubscribeOffline = () => window.removeEventListener("offline", setOffline);
+	};
+	const init = () => {
+		if (typeof window === "undefined") return;
+		setupPolling();
+		setupBroadcast();
+		setupVisibilityChange();
+		setupOnlineDetection();
+	};
+	const cleanup = () => {
+		if (state.pollInterval) {
+			clearInterval(state.pollInterval);
+			state.pollInterval = void 0;
+		}
+		if (state.unsubscribeBroadcast) {
+			state.unsubscribeBroadcast();
+			state.unsubscribeBroadcast = void 0;
+		}
+		if (state.unsubscribeVisibility) {
+			state.unsubscribeVisibility();
+			state.unsubscribeVisibility = void 0;
+		}
+		if (state.unsubscribeOnline) {
+			state.unsubscribeOnline();
+			state.unsubscribeOnline = void 0;
+		}
+		if (state.unsubscribeOffline) {
+			state.unsubscribeOffline();
+			state.unsubscribeOffline = void 0;
+		}
+		state.lastSync = 0;
+		state.cachedSession = void 0;
+	};
+	return {
+		init,
+		cleanup,
+		triggerRefetch,
+		broadcastSessionUpdate
+	};
+}
+
+//#endregion
+//#region src/client/fetch-plugins.ts
+const redirectPlugin = {
+	id: "redirect",
+	name: "Redirect",
+	hooks: { onSuccess(context) {
+		if (context.data?.url && context.data?.redirect) {
+			if (typeof window !== "undefined" && window.location) {
+				if (window.location) try {
+					window.location.href = context.data.url;
+				} catch {}
+			}
+		}
+	} }
+};
+const userAgentPlugin = {
+	id: "user-agent",
+	name: "UserAgent",
+	hooks: { onRequest(context) {
+		context.headers.append("user-agent", "payvo-auth");
+	} }
+};
+
+//#endregion
+//#region src/client/session-atom.ts
+function getSessionAtom($fetch, options) {
+	const $signal = atom(false);
+	const session = useAuthQuery($signal, "/get-session", $fetch, { method: "GET" });
+	if (typeof window !== "undefined") onMount(session, () => {
+		const refreshManager = createSessionRefreshManager({
+			sessionAtom: session,
+			sessionSignal: $signal,
+			$fetch,
+			options
+		});
+		refreshManager.init();
+		return () => {
+			refreshManager.cleanup();
+		};
+	});
+	return {
+		session,
+		$sessionSignal: $signal
+	};
+}
+
+//#endregion
+//#region src/client/config.ts
+const getClientConfig = (options, loadEnv) => {
+	const isCredentialsSupported = "credentials" in Request.prototype;
+	const baseURL = getBaseURL(options?.baseURL, options?.basePath, void 0, loadEnv) ?? "/api/auth";
+	const pluginsFetchPlugins = options?.plugins?.flatMap((plugin) => plugin.fetchPlugins).filter((pl) => pl !== void 0) || [];
+	const lifeCyclePlugin = {
+		id: "lifecycle-hooks",
+		name: "lifecycle-hooks",
+		hooks: {
+			onSuccess: options?.fetchOptions?.onSuccess,
+			onError: options?.fetchOptions?.onError,
+			onRequest: options?.fetchOptions?.onRequest,
+			onResponse: options?.fetchOptions?.onResponse
+		}
+	};
+	const { onSuccess, onError, onRequest, onResponse,...restOfFetchOptions } = options?.fetchOptions || {};
+	const $fetch = createFetch({
+		baseURL,
+		...isCredentialsSupported ? { credentials: "include" } : {},
+		method: "GET",
+		jsonParser(text) {
+			if (!text) return null;
+			return parseJSON(text, { strict: false });
+		},
+		customFetchImpl: fetch,
+		...restOfFetchOptions,
+		plugins: [
+			lifeCyclePlugin,
+			userAgentPlugin,
+			...restOfFetchOptions.plugins || [],
+			...options?.disableDefaultFetchPlugins ? [] : [redirectPlugin],
+			...pluginsFetchPlugins
+		]
+	});
+	const { $sessionSignal, session } = getSessionAtom($fetch, options);
+	const plugins = options?.plugins || [];
+	let pluginsActions = {};
+	let pluginsAtoms = {
+		$sessionSignal,
+		session
+	};
+	let pluginPathMethods = {
+		"/sign-out": "POST",
+		"/revoke-sessions": "POST",
+		"/revoke-other-sessions": "POST",
+		"/delete-user": "POST"
+	};
+	const atomListeners = [{
+		signal: "$sessionSignal",
+		matcher(path) {
+			return path === "/sign-out" || path === "/update-user" || path.startsWith("/sign-in") || path.startsWith("/sign-up") || path === "/delete-user" || path === "/verify-email" || path === "/revoke-sessions" || path === "/revoke-session";
+		}
+	}];
+	for (const plugin of plugins) {
+		if (plugin.getAtoms) Object.assign(pluginsAtoms, plugin.getAtoms?.($fetch));
+		if (plugin.pathMethods) Object.assign(pluginPathMethods, plugin.pathMethods);
+		if (plugin.atomListeners) atomListeners.push(...plugin.atomListeners);
+	}
+	const $store = {
+		notify: (signal) => {
+			pluginsAtoms[signal].set(!pluginsAtoms[signal].get());
+		},
+		listen: (signal, listener) => {
+			pluginsAtoms[signal].subscribe(listener);
+		},
+		atoms: pluginsAtoms
+	};
+	for (const plugin of plugins) if (plugin.getActions) Object.assign(pluginsActions, plugin.getActions?.($fetch, $store, options));
+	return {
+		get baseURL() {
+			return baseURL;
+		},
+		pluginsActions,
+		pluginsAtoms,
+		pluginPathMethods,
+		atomListeners,
+		$fetch,
+		$store
+	};
+};
+
+//#endregion
+//#region src/utils/is-atom.ts
+function isAtom(value) {
+	return typeof value === "object" && value !== null && "get" in value && typeof value.get === "function" && "lc" in value && typeof value.lc === "number";
+}
+
+//#endregion
+//#region src/client/proxy.ts
+function getMethod(path, knownPathMethods, args) {
+	const method = knownPathMethods[path];
+	const { fetchOptions, query,...body } = args || {};
+	if (method) return method;
+	if (fetchOptions?.method) return fetchOptions.method;
+	if (body && Object.keys(body).length > 0) return "POST";
+	return "GET";
+}
+function createDynamicPathProxy(routes, client, knownPathMethods, atoms, atomListeners) {
+	function createProxy(path = []) {
+		return new Proxy(function() {}, {
+			get(_, prop) {
+				if (typeof prop !== "string") return;
+				if (prop === "then" || prop === "catch" || prop === "finally") return;
+				const fullPath = [...path, prop];
+				let current = routes;
+				for (const segment of fullPath) if (current && typeof current === "object" && segment in current) current = current[segment];
+				else {
+					current = void 0;
+					break;
+				}
+				if (typeof current === "function") return current;
+				if (isAtom(current)) return current;
+				return createProxy(fullPath);
+			},
+			apply: async (_, __, args) => {
+				const routePath = "/" + path.map((segment) => segment.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)).join("/");
+				const arg = args[0] || {};
+				const fetchOptions = args[1] || {};
+				const { query, fetchOptions: argFetchOptions,...body } = arg;
+				const options = {
+					...fetchOptions,
+					...argFetchOptions
+				};
+				const method = getMethod(routePath, knownPathMethods, arg);
+				return await client(routePath, {
+					...options,
+					body: method === "GET" ? void 0 : {
+						...body,
+						...options?.body || {}
+					},
+					query: query || options?.query,
+					method,
+					async onSuccess(context) {
+						await options?.onSuccess?.(context);
+						if (!atomListeners) return;
+						/**
+						* We trigger listeners
+						*/
+						const matches = atomListeners.filter((s) => s.matcher(routePath));
+						if (!matches.length) return;
+						for (const match of matches) {
+							const signal = atoms[match.signal];
+							if (!signal) return;
+							/**
+							* To avoid race conditions we set the signal in a setTimeout
+							*/
+							const val = signal.get();
+							setTimeout(() => {
+								signal.set(!val);
+							}, 10);
+						}
+					}
+				});
+			}
+		});
+	}
+	return createProxy();
+}
+
+//#endregion
+export { createBroadcastChannel as a, useAuthQuery as i, getClientConfig as n, createSessionRefreshManager as r, createDynamicPathProxy as t };