@masheev/better-auth 0.0.0-stage → 1.7.5

package/dist/client/proxy.mjs

@@ -0,0 +1,78 @@
+import { isAtom } from "../utils/is-atom.mjs";
+import { toKebabCase } from "@better-auth/core/utils/string";
+//#region src/client/proxy.ts
+function getMethod(path, knownPathMethods, args) {
+	const method = knownPathMethods[path];
+	const { fetchOptions, query: _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(toKebabCase).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 || options.disableSignal) return;
+						/**
+						* We trigger listeners
+						*/
+						const matches = atomListeners.filter((s) => s.matcher(routePath));
+						if (!matches.length) return;
+						const visited = /* @__PURE__ */ new Set();
+						for (const match of matches) {
+							const signal = atoms[match.signal];
+							if (!signal) return;
+							if (visited.has(match.signal)) continue;
+							visited.add(match.signal);
+							/**
+							* To avoid race conditions we set the signal in a setTimeout
+							*/
+							const val = signal.get();
+							setTimeout(() => {
+								signal.set(!val);
+							}, 10);
+							match.callback?.(routePath);
+						}
+					}
+				});
+			}
+		});
+	}
+	return createProxy();
+}
+//#endregion
+export { createDynamicPathProxy };

package/dist/client/query.d.mts

@@ -0,0 +1,23 @@
+import { SessionQueryParams } from "./types.mjs";
+import { ClientFetchOption } from "@better-auth/core";
+import { PreinitializedWritableAtom } from "nanostores";
+import { BetterFetch, BetterFetchError } from "@better-fetch/fetch";
+
+//#region src/client/query.d.ts
+type AuthQueryState<T> = {
+  data: null | T;
+  error: null | BetterFetchError;
+  isPending: boolean;
+  isRefetching: boolean;
+  refetch: (queryParams?: {
+    query?: SessionQueryParams;
+  } | undefined) => Promise<void>;
+};
+type AuthQueryAtom<T> = PreinitializedWritableAtom<AuthQueryState<T>>;
+declare const useAuthQuery: <T>(initializedAtom: PreinitializedWritableAtom<any> | PreinitializedWritableAtom<any>[], path: string, $fetch: BetterFetch, options?: (((value: {
+  data: null | T;
+  error: null | BetterFetchError;
+  isPending: boolean;
+}) => ClientFetchOption) | ClientFetchOption) | undefined) => AuthQueryAtom<T>;
+//#endregion
+export { AuthQueryAtom, AuthQueryState, useAuthQuery };

package/dist/client/query.mjs

@@ -0,0 +1,124 @@
+import { isJsonEqual, withEquality } from "./equality.mjs";
+import { atom, onMount } from "nanostores";
+//#region src/client/query.ts
+const isServer = () => typeof window === "undefined";
+function isAuthQueryStateEqual(a, b) {
+	return isJsonEqual(a.data, b.data) && a.error === b.error && a.isPending === b.isPending && a.isRefetching === b.isRefetching && a.refetch === b.refetch;
+}
+const useAuthQuery = (initializedAtom, path, $fetch, options) => {
+	const value = atom({
+		data: null,
+		error: null,
+		isPending: true,
+		isRefetching: false,
+		refetch: (queryParams) => fn(queryParams)
+	});
+	onMount(value, () => withEquality(value, isAuthQueryStateEqual));
+	const fn = async (queryParams) => {
+		return new Promise((resolve) => {
+			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) {
+					const current = value.get();
+					const stableData = current.data != null && context.data != null && isJsonEqual(current.data, context.data) ? current.data : context.data;
+					value.set({
+						data: stableData,
+						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;
+					const isUnauthorized = context.error.status === 401;
+					value.set({
+						error: context.error,
+						data: isUnauthorized ? null : value.get().data,
+						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: value.get().data,
+					isPending: false,
+					isRefetching: false,
+					refetch: value.value.refetch
+				});
+			}).finally(() => {
+				resolve(void 0);
+			});
+		});
+	};
+	initializedAtom = Array.isArray(initializedAtom) ? initializedAtom : [initializedAtom];
+	let isMountFetchPending = false;
+	let isMounted = false;
+	let shouldRefetchAfterPending = false;
+	const fetchOnMount = () => {
+		if (isMountFetchPending) {
+			shouldRefetchAfterPending = true;
+			return;
+		}
+		isMountFetchPending = true;
+		fn().finally(() => {
+			isMountFetchPending = false;
+			const shouldRefetch = shouldRefetchAfterPending && isMounted;
+			shouldRefetchAfterPending = false;
+			if (shouldRefetch) fetchOnMount();
+		});
+	};
+	onMount(value, () => {
+		if (isServer()) return;
+		isMounted = true;
+		let isInitialized = false;
+		let timeoutId;
+		const cleanups = initializedAtom.map((initAtom) => initAtom.listen(() => {
+			if (isInitialized) fn();
+			else {
+				isInitialized = true;
+				clearTimeout(timeoutId);
+				fetchOnMount();
+			}
+		}));
+		timeoutId = setTimeout(() => {
+			isInitialized = true;
+			fetchOnMount();
+		}, 0);
+		return () => {
+			isMounted = false;
+			for (const cleanup of cleanups) cleanup();
+			clearTimeout(timeoutId);
+		};
+	});
+	return value;
+};
+//#endregion
+export { useAuthQuery };

package/dist/client/react/index.d.mts

@@ -0,0 +1,44 @@
+import { ExtractPluginField, HasRequiredKeys, InferPluginFieldFromTuple, IsAny, OverrideMerge, Prettify, PrettifyDeep, RequiredKeysOf, StripEmptyObjects, UnionToIntersection } from "../../types/helper.mjs";
+import { InferActions, InferClientAPI, InferErrorCodes, IsSignal, SessionQueryParams } from "../types.mjs";
+import { getClientConfig } from "../config.mjs";
+import { useStore } from "./react-store.mjs";
+import { BetterAuthClientOptions } from "@better-auth/core";
+import { BASE_ERROR_CODES } from "@better-auth/core/error";
+import { BetterFetchError, BetterFetchResponse } from "@better-fetch/fetch";
+export * from "nanostores";
+export * from "@better-fetch/fetch";
+
+//#region src/client/react/index.d.ts
+type InferResolvedHooks<O extends BetterAuthClientOptions> = O extends {
+  plugins: Array<infer Plugin>;
+} ? UnionToIntersection<Plugin extends {
+  getAtoms?: infer GetAtoms;
+} ? GetAtoms extends ((fetch: any) => infer Atoms) ? Atoms extends Record<string, any> ? { [key in keyof Atoms as IsSignal<key> extends true ? never : key extends string ? `use${Capitalize<key>}` : never]: () => ReturnType<Atoms[key]["get"]> } : {} : {} : {}> : {};
+type ClientConfig = ReturnType<typeof getClientConfig>;
+type ClientSession<Option extends BetterAuthClientOptions> = InferClientAPI<Option> extends {
+  getSession: () => Promise<infer Res>;
+} ? Res extends BetterFetchResponse<infer S> ? S : Res : never;
+/**
+ * React client returned by `createAuthClient`.
+ */
+type ReactAuthClient<Option extends BetterAuthClientOptions> = UnionToIntersection<InferResolvedHooks<Option>> & InferClientAPI<Option> & InferActions<Option> & {
+  hydrateSession(session: NonNullable<ClientSession<Option>> | null): void;
+  useSession: () => {
+    data: ClientSession<Option>;
+    isPending: boolean;
+    isRefetching: boolean;
+    error: BetterFetchError | null;
+    refetch: (queryParams?: {
+      query?: SessionQueryParams;
+    } | undefined) => Promise<void>;
+  };
+  $Infer: {
+    Session: NonNullable<ClientSession<Option>>;
+  };
+  $fetch: ClientConfig["$fetch"];
+  $store: ClientConfig["$store"];
+  $ERROR_CODES: InferErrorCodes<Option> & typeof BASE_ERROR_CODES;
+};
+declare function createAuthClient<Option extends BetterAuthClientOptions>(options?: Option | undefined): ReactAuthClient<Option>;
+//#endregion
+export { ExtractPluginField, HasRequiredKeys, InferPluginFieldFromTuple, IsAny, OverrideMerge, Prettify, PrettifyDeep, ReactAuthClient, RequiredKeysOf, StripEmptyObjects, type UnionToIntersection, createAuthClient, useStore };

package/dist/client/react/index.mjs

@@ -0,0 +1,22 @@
+import { getClientConfig } from "../config.mjs";
+import { createDynamicPathProxy } from "../proxy.mjs";
+import { useStore } from "./react-store.mjs";
+import { capitalizeFirstLetter } from "@better-auth/core/utils/string";
+//#region src/client/react/index.ts
+function getAtomKey(str) {
+	return `use${capitalizeFirstLetter(str)}`;
+}
+function createAuthClient(options) {
+	const { pluginPathMethods, pluginsActions, pluginsAtoms, hydrateSession, $fetch, $store, atomListeners } = getClientConfig(options);
+	const resolvedHooks = {};
+	for (const [key, value] of Object.entries(pluginsAtoms)) resolvedHooks[getAtomKey(key)] = () => useStore(value);
+	return createDynamicPathProxy({
+		...pluginsActions,
+		...resolvedHooks,
+		hydrateSession,
+		$fetch,
+		$store
+	}, $fetch, pluginPathMethods, pluginsAtoms, atomListeners);
+}
+//#endregion
+export { createAuthClient, useStore };

package/dist/client/react/react-store.d.mts

@@ -0,0 +1,46 @@
+import { Store, StoreValue } from "nanostores";
+import { DependencyList } from "react";
+
+//#region src/client/react/react-store.d.ts
+type StoreKeys<T> = T extends {
+  setKey: (k: infer K, v: any) => unknown;
+} ? K : never;
+interface UseStoreOptions<SomeStore> {
+  /**
+   * @default
+   * ```ts
+   * [store, options.keys]
+   * ```
+   */
+  deps?: DependencyList | undefined;
+  /**
+   * Will re-render components only on specific key changes.
+   */
+  keys?: StoreKeys<SomeStore>[] | undefined;
+}
+/**
+ * Subscribe to store changes and get store's value.
+ *
+ * Can be used with store builder too.
+ *
+ * ```js
+ * import { useStore } from 'nanostores/react'
+ *
+ * import { router } from '../store/router'
+ *
+ * export const Layout = () => {
+ *   let page = useStore(router)
+ *   if (page.route === 'home') {
+ *     return <HomePage />
+ *   } else {
+ *     return <Error404 />
+ *   }
+ * }
+ * ```
+ *
+ * @param store Store instance.
+ * @returns Store value.
+ */
+declare function useStore<SomeStore extends Store>(store: SomeStore, options?: UseStoreOptions<SomeStore>): StoreValue<SomeStore>;
+//#endregion
+export { useStore };

package/dist/client/react/react-store.mjs

@@ -0,0 +1,44 @@
+import { listenKeys } from "nanostores";
+import { useCallback, useRef, useSyncExternalStore } from "react";
+//#region src/client/react/react-store.ts
+/**
+* Subscribe to store changes and get store's value.
+*
+* Can be used with store builder too.
+*
+* ```js
+* import { useStore } from 'nanostores/react'
+*
+* import { router } from '../store/router'
+*
+* export const Layout = () => {
+*   let page = useStore(router)
+*   if (page.route === 'home') {
+*     return <HomePage />
+*   } else {
+*     return <Error404 />
+*   }
+* }
+* ```
+*
+* @param store Store instance.
+* @returns Store value.
+*/
+function useStore(store, options = {}) {
+	const snapshotRef = useRef(store.get());
+	const { keys, deps = [store, keys] } = options;
+	const subscribe = useCallback((onChange) => {
+		const emitChange = (value) => {
+			if (snapshotRef.current === value) return;
+			snapshotRef.current = value;
+			onChange();
+		};
+		emitChange(store.value);
+		if (keys?.length) return listenKeys(store, keys, emitChange);
+		return store.listen(emitChange);
+	}, deps);
+	const get = () => snapshotRef.current;
+	return useSyncExternalStore(subscribe, get, get);
+}
+//#endregion
+export { useStore };

package/dist/client/session-atom.d.mts

@@ -0,0 +1,11 @@
+import { Session, User } from "../types/models.mjs";
+import { BetterAuthClientOptions } from "@better-auth/core";
+import { BetterFetch } from "@better-fetch/fetch";
+
+//#region src/client/session-atom.d.ts
+type SessionData = {
+  user: User;
+  session: Session;
+} & Record<string, any>;
+//#endregion
+export { SessionData };

package/dist/client/session-atom.mjs

@@ -0,0 +1,178 @@
+import { isJsonEqual, withEquality } from "./equality.mjs";
+import { createSessionRefreshManager } from "./session-refresh.mjs";
+import { STORE_UNMOUNT_DELAY, atom, onMount } from "nanostores";
+//#region src/client/session-atom.ts
+const isServer = () => typeof window === "undefined";
+const SESSION_MOUNT_DEDUPE_INTERVAL = STORE_UNMOUNT_DELAY;
+function hydrateSessionAtom(sessionAtom, session) {
+	if (typeof window === "undefined") return;
+	const currentSession = sessionAtom.get();
+	if (currentSession.data !== null || session === null) return;
+	sessionAtom.set({
+		...currentSession,
+		data: session,
+		error: null,
+		isPending: false
+	});
+}
+/**
+* Normalize $fetch response: `throw: true` returns data directly,
+* otherwise `{ data, error }`.
+*/
+function normalizeSessionResponse(res) {
+	if (typeof res === "object" && res !== null && "data" in res && "error" in res) return res;
+	return {
+		data: res,
+		error: null
+	};
+}
+function normalizeSessionData(data) {
+	if (!data) return null;
+	if (data.session === null && data.user === null) return null;
+	return data;
+}
+function isSessionAtomEqual(a, b) {
+	return isJsonEqual(a.data, b.data) && a.error === b.error && a.isPending === b.isPending && a.isRefetching === b.isRefetching && a.refetch === b.refetch;
+}
+function getSessionAtom($fetch, options) {
+	const $signal = atom(false);
+	let flight;
+	let freshUntil = 0;
+	let sessionRevision = 0;
+	$signal.listen(() => {
+		sessionRevision++;
+		freshUntil = 0;
+	});
+	const refetch = (queryParams) => fetchSession(queryParams);
+	const session = atom({
+		data: null,
+		error: null,
+		isPending: true,
+		isRefetching: false,
+		refetch
+	});
+	withEquality(session, isSessionAtomEqual);
+	const executeSessionFetch = async (signal, queryParams) => {
+		const current = session.value;
+		session.set({
+			...current,
+			isPending: current.data === null,
+			isRefetching: true,
+			error: null,
+			refetch
+		});
+		if (signal.aborted) return "aborted";
+		try {
+			const res = await $fetch("/get-session", {
+				method: "GET",
+				query: queryParams?.query,
+				signal
+			});
+			if (signal.aborted) return "aborted";
+			let { data, error } = normalizeSessionResponse(res);
+			let outcome = "fresh";
+			if (data?.needsRefresh) try {
+				const refreshRes = await $fetch("/get-session", {
+					method: "POST",
+					signal
+				});
+				if (signal.aborted) return "aborted";
+				({data, error} = normalizeSessionResponse(refreshRes));
+			} catch {
+				if (signal.aborted) return "aborted";
+				outcome = "stale";
+			}
+			if (error) {
+				const latest = session.value;
+				const isUnauthorized = error?.status === 401;
+				session.set({
+					data: isUnauthorized ? null : latest.data,
+					error,
+					isPending: false,
+					isRefetching: false,
+					refetch
+				});
+				return "failed";
+			}
+			const sessionData = normalizeSessionData(data);
+			const current = session.value;
+			const stableData = current.data != null && sessionData != null && isJsonEqual(current.data, sessionData) ? current.data : sessionData;
+			session.set({
+				data: stableData,
+				error: null,
+				isPending: false,
+				isRefetching: false,
+				refetch
+			});
+			return outcome;
+		} catch (fetchError) {
+			if (signal.aborted) return "aborted";
+			const latest = session.value;
+			session.set({
+				data: latest.data,
+				error: fetchError,
+				isPending: false,
+				isRefetching: false,
+				refetch
+			});
+			return "failed";
+		}
+	};
+	const getFreshUntil = () => {
+		const expiresAt = session.value.data?.session?.expiresAt;
+		const sessionExpiresAt = expiresAt instanceof Date ? expiresAt.getTime() : Number.POSITIVE_INFINITY;
+		return Math.min(Date.now() + SESSION_MOUNT_DEDUPE_INTERVAL, sessionExpiresAt);
+	};
+	const fetchSession = (queryParams) => {
+		freshUntil = 0;
+		flight?.cancel();
+		const controller = new AbortController();
+		const request = {
+			cancel: () => controller.abort(),
+			promise: Promise.resolve().then(() => {
+				if (controller.signal.aborted) return "aborted";
+				return executeSessionFetch(controller.signal, queryParams);
+			}),
+			revision: sessionRevision
+		};
+		flight = request;
+		const settleFlight = (outcome) => {
+			if (flight !== request) return;
+			flight = void 0;
+			if (outcome === "fresh" && request.revision === sessionRevision) freshUntil = getFreshUntil();
+		};
+		request.promise.then(settleFlight, () => settleFlight("failed"));
+		return request.promise.then(() => void 0);
+	};
+	const fetchSessionOnMount = () => {
+		if (flight?.revision === sessionRevision) return flight.promise.then(() => void 0);
+		if (Date.now() < freshUntil) return Promise.resolve();
+		return fetchSession();
+	};
+	let broadcastSessionUpdate = () => {};
+	onMount(session, () => {
+		let timeoutId;
+		if (!isServer()) timeoutId = setTimeout(() => {
+			fetchSessionOnMount();
+		}, 0);
+		const refreshManager = createSessionRefreshManager({
+			fetchSession,
+			shouldPollSession: () => session.value.data != null,
+			sessionSignal: $signal,
+			options
+		});
+		refreshManager.init();
+		broadcastSessionUpdate = refreshManager.broadcastSessionUpdate;
+		return () => {
+			if (timeoutId) clearTimeout(timeoutId);
+			refreshManager.cleanup();
+		};
+	});
+	return {
+		session,
+		$sessionSignal: $signal,
+		broadcastSessionUpdate: (trigger) => broadcastSessionUpdate(trigger)
+	};
+}
+//#endregion
+export { getSessionAtom, hydrateSessionAtom };

package/dist/client/session-refresh.d.mts

@@ -0,0 +1,20 @@
+import { BetterAuthClientOptions } from "@better-auth/core";
+import { WritableAtom } from "nanostores";
+
+//#region src/client/session-refresh.d.ts
+interface SessionRefreshOptions {
+  fetchSession: () => Promise<void>;
+  shouldPollSession?: () => boolean;
+  sessionSignal: WritableAtom<boolean>;
+  options?: BetterAuthClientOptions | undefined;
+}
+declare function createSessionRefreshManager(opts: SessionRefreshOptions): {
+  init: () => void;
+  cleanup: () => void;
+  triggerRefetch: (event?: {
+    event?: "poll" | "visibilitychange" | "storage";
+  } | undefined) => void;
+  broadcastSessionUpdate: (trigger: "signout" | "getSession" | "updateUser") => void;
+};
+//#endregion
+export { SessionRefreshOptions, createSessionRefreshManager };