@ubean/auth 0.1.2 → 0.1.4

package/dist/core.d.ts

@@ -0,0 +1,21 @@
+import { a as AuthState, c as ResolvedAuthOptions, d as UbeanAuthOptions, i as AuthSession, n as AuthClient, o as AuthUser, r as AuthError } from "./types-DlL9lr7A.js";
+import { Context, MiddlewareHandler } from "hono";
+import { BetterAuthOptions } from "better-auth";
+//#region src/core.d.ts
+declare function resolveAuthOptions(options?: UbeanAuthOptions): ResolvedAuthOptions;
+declare function defineAuth(config: UbeanAuthOptions | ((ctx: {
+  defaults: BetterAuthOptions;
+}) => UbeanAuthOptions)): UbeanAuthOptions;
+declare function createAuthHandler(options?: UbeanAuthOptions): {
+  handler: (request: Request) => Promise<Response>;
+  resolveAuth: () => Promise<unknown>;
+  getOptions: () => ResolvedAuthOptions;
+};
+declare function authMiddleware(): MiddlewareHandler;
+declare function getUser(): AuthUser | null;
+declare function getSession(): AuthState | null;
+declare function requireAuth(c?: Context): AuthUser;
+declare function createAuthClient(basePath?: string): AuthClient;
+declare function getServerSession(req?: Request): Promise<AuthSession | null>;
+//#endregion
+export { type AuthClient, type AuthError, type AuthSession, type AuthState, type AuthUser, authMiddleware, createAuthClient, createAuthHandler, defineAuth, getServerSession, getSession, getUser, requireAuth, resolveAuthOptions };

package/dist/core.js

@@ -0,0 +1,520 @@
+import { consola } from "consola";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { defu } from "defu";
+//#region src/core.ts
+const AUTH_CONTEXT_SYMBOL = Symbol.for("ubean.authContext.v1");
+function getAuthAsyncLocalStorage() {
+	const g = globalThis;
+	if (!g[AUTH_CONTEXT_SYMBOL]) g[AUTH_CONTEXT_SYMBOL] = new AsyncLocalStorage();
+	return g[AUTH_CONTEXT_SYMBOL];
+}
+const authContext = getAuthAsyncLocalStorage();
+const authInstance = {
+	handler: null,
+	api: null,
+	options: null
+};
+function resetAuthInstance() {
+	authInstance.handler = null;
+	authInstance.api = null;
+	authInstance.options = null;
+}
+function resolveAuthOptions(options = {}) {
+	return defu(options, {
+		enabled: true,
+		basePath: "/api/auth",
+		baseURL: "",
+		secret: process.env.BETTER_AUTH_SECRET || process.env.AUTH_SECRET || "ubean-dev-secret-change-me",
+		clientOptions: {
+			fetchOptions: {},
+			plugins: []
+		},
+		redirectTo: {
+			login: "/login",
+			signup: "/signup",
+			callback: "/"
+		},
+		session: {
+			cookieName: "ubean_session",
+			expiresIn: 3600 * 24 * 7,
+			updateAge: 3600 * 24
+		}
+	});
+}
+function defineAuth(config) {
+	if (typeof config === "function") return config({ defaults: {
+		basePath: "/api/auth",
+		emailAndPassword: { enabled: true }
+	} });
+	return config;
+}
+function createFallbackAuth(resolved) {
+	consola.warn("[auth] better-auth not installed, using minimal fallback auth implementation");
+	consola.warn("[auth] Install better-auth with: pnpm add better-auth");
+	const users = /* @__PURE__ */ new Map();
+	const sessions = /* @__PURE__ */ new Map();
+	function generateId() {
+		return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+	}
+	function hashPassword(password) {
+		return Buffer.from(password).toString("base64");
+	}
+	function createSession(userId) {
+		const token = generateId();
+		const expiresAt = new Date(Date.now() + resolved.session.expiresIn * 1e3);
+		sessions.set(token, {
+			userId,
+			token,
+			expiresAt
+		});
+		return {
+			token,
+			expiresAt
+		};
+	}
+	function findSessionByToken(token) {
+		if (!token) return null;
+		const session = sessions.get(token);
+		if (!session) return null;
+		if (session.expiresAt < /* @__PURE__ */ new Date()) {
+			sessions.delete(token);
+			return null;
+		}
+		return session;
+	}
+	const fallbackHandler = async (request) => {
+		const path = new URL(request.url).pathname.replace(resolved.basePath, "");
+		const method = request.method;
+		const setSessionCookie = (token, expiresAt) => {
+			const headers = new Headers({ "content-type": "application/json" });
+			if (token) headers.append("set-cookie", `${resolved.session.cookieName}=${token}; Path=/; HttpOnly; SameSite=Lax; Expires=${expiresAt?.toUTCString()}`);
+			else headers.append("set-cookie", `${resolved.session.cookieName}=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0`);
+			return headers;
+		};
+		const getTokenFromCookie = (req) => {
+			return (req.headers.get("cookie") || "").match(new RegExp(`${resolved.session.cookieName}=([^;]+)`))?.[1];
+		};
+		try {
+			if (path === "/sign-up/email" && method === "POST") {
+				const { email, password, name } = await request.json().catch(() => ({}));
+				if (!email || !password) return new Response(JSON.stringify({ error: "Email and password required" }), {
+					status: 400,
+					headers: { "content-type": "application/json" }
+				});
+				for (const [, u] of users) if (u.email === email) return new Response(JSON.stringify({ error: "User already exists" }), {
+					status: 400,
+					headers: { "content-type": "application/json" }
+				});
+				const id = generateId();
+				users.set(id, {
+					id,
+					email,
+					password: hashPassword(password),
+					name: name || email.split("@")[0],
+					createdAt: /* @__PURE__ */ new Date()
+				});
+				const { token, expiresAt } = createSession(id);
+				const user = users.get(id);
+				return new Response(JSON.stringify({
+					token,
+					user: {
+						id: user.id,
+						email: user.email,
+						name: user.name,
+						emailVerified: false,
+						createdAt: user.createdAt,
+						updatedAt: user.createdAt
+					}
+				}), {
+					status: 200,
+					headers: setSessionCookie(token, expiresAt)
+				});
+			}
+			if (path === "/sign-in/email" && method === "POST") {
+				const { email, password } = await request.json().catch(() => ({}));
+				let foundUser = null;
+				for (const [, u] of users) if (u.email === email && u.password === hashPassword(password)) {
+					foundUser = u;
+					break;
+				}
+				if (!foundUser) return new Response(JSON.stringify({ error: "Invalid credentials" }), {
+					status: 401,
+					headers: { "content-type": "application/json" }
+				});
+				const { token, expiresAt } = createSession(foundUser.id);
+				return new Response(JSON.stringify({
+					token,
+					user: {
+						id: foundUser.id,
+						email: foundUser.email,
+						name: foundUser.name,
+						emailVerified: false,
+						createdAt: foundUser.createdAt,
+						updatedAt: foundUser.createdAt
+					}
+				}), {
+					status: 200,
+					headers: setSessionCookie(token, expiresAt)
+				});
+			}
+			if (path === "/sign-out" && method === "POST") {
+				const token = getTokenFromCookie(request);
+				if (token) sessions.delete(token);
+				return new Response(JSON.stringify({ success: true }), {
+					status: 200,
+					headers: setSessionCookie(null)
+				});
+			}
+			if (path === "/get-session" && method === "GET") {
+				const session = findSessionByToken(getTokenFromCookie(request));
+				if (!session) return new Response(JSON.stringify(null), {
+					status: 200,
+					headers: { "content-type": "application/json" }
+				});
+				const u = users.get(session.userId);
+				return new Response(JSON.stringify({
+					session: {
+						id: session.token,
+						userId: u.id,
+						token: session.token,
+						expiresAt: session.expiresAt,
+						createdAt: /* @__PURE__ */ new Date(),
+						updatedAt: /* @__PURE__ */ new Date()
+					},
+					user: {
+						id: u.id,
+						email: u.email,
+						name: u.name,
+						emailVerified: false,
+						createdAt: u.createdAt,
+						updatedAt: u.createdAt
+					}
+				}), {
+					status: 200,
+					headers: { "content-type": "application/json" }
+				});
+			}
+			return new Response(JSON.stringify({ error: "Not found" }), {
+				status: 404,
+				headers: { "content-type": "application/json" }
+			});
+		} catch {
+			return new Response(JSON.stringify({ error: "Internal error" }), {
+				status: 500,
+				headers: { "content-type": "application/json" }
+			});
+		}
+	};
+	authInstance.handler = fallbackHandler;
+	authInstance.api = { getSession: (async (headersInput) => {
+		const session = findSessionByToken(((headersInput instanceof Headers ? headersInput : new Headers(headersInput)).get("cookie") || "").match(new RegExp(`${resolved.session.cookieName}=([^;]+)`))?.[1]);
+		if (!session) return null;
+		const u = users.get(session.userId);
+		if (!u) return null;
+		return {
+			session: {
+				id: session.token,
+				userId: u.id,
+				token: session.token,
+				expiresAt: session.expiresAt,
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date()
+			},
+			user: {
+				id: u.id,
+				email: u.email,
+				name: u.name,
+				emailVerified: false,
+				createdAt: u.createdAt,
+				updatedAt: u.createdAt
+			}
+		};
+	}) };
+	return {
+		handler: fallbackHandler,
+		api: authInstance.api
+	};
+}
+function createAuthHandler(options = {}) {
+	const resolved = resolveAuthOptions(options);
+	resetAuthInstance();
+	authInstance.options = resolved;
+	const hasBetterAuthConfig = !!(resolved.betterAuth && Object.keys(resolved.betterAuth).length > 0) || !!resolved.database;
+	async function initBetterAuth() {
+		if (!hasBetterAuthConfig) return createFallbackAuth(resolved);
+		try {
+			const { betterAuth } = await import("better-auth");
+			const defaults = {
+				baseURL: resolved.baseURL || void 0,
+				basePath: resolved.basePath,
+				secret: resolved.secret,
+				trustedOrigins: resolved.baseURL ? [resolved.baseURL] : [],
+				database: resolved.database,
+				session: {
+					expiresIn: resolved.session.expiresIn,
+					updateAge: resolved.session.updateAge
+				},
+				emailAndPassword: { enabled: true }
+			};
+			let betterAuthOpts;
+			if (typeof options.betterAuth === "function") betterAuthOpts = options.betterAuth({ defaults });
+			else betterAuthOpts = defu(options.betterAuth, defaults);
+			const auth = betterAuth(betterAuthOpts);
+			authInstance.handler = auth.handler;
+			authInstance.api = auth.api;
+			return auth;
+		} catch {
+			return createFallbackAuth(resolved);
+		}
+	}
+	let initPromise = null;
+	async function resolveAuth() {
+		if (!initPromise) initPromise = initBetterAuth();
+		return initPromise;
+	}
+	async function handler(request) {
+		await resolveAuth();
+		if (authInstance.handler) return authInstance.handler(request);
+		return new Response(JSON.stringify({ error: "Auth handler not initialized" }), {
+			status: 500,
+			headers: { "content-type": "application/json" }
+		});
+	}
+	return {
+		handler,
+		resolveAuth,
+		getOptions: () => resolved
+	};
+}
+function authMiddleware() {
+	return async (c, next) => {
+		const opts = authInstance.options || resolveAuthOptions();
+		try {
+			const request = c.req.raw;
+			const sessionCookieMatch = (request.headers.get("cookie") || "").match(new RegExp(`${opts.session.cookieName}=([^;]+)`));
+			const bearerMatch = (request.headers.get("authorization") || "").match(/^Bearer\s+(.+)$/i);
+			const token = sessionCookieMatch?.[1] || bearerMatch?.[1];
+			let user = null;
+			let session = null;
+			await (authInstance.handler ? Promise.resolve() : Promise.resolve(createAuthHandler(opts)).then(({ resolveAuth }) => resolveAuth()));
+			if (authInstance.api?.getSession && token) try {
+				const headers = new Headers({ cookie: `${opts.session.cookieName}=${token}` });
+				const result = await authInstance.api.getSession(headers);
+				if (result) {
+					session = result.session;
+					user = result.user;
+				}
+			} catch {}
+			if (user) c.set("user", user);
+			if (session) c.set("session", session);
+			await authContext.run({
+				user,
+				session
+			}, next);
+		} catch {
+			await next();
+		}
+	};
+}
+function getUser() {
+	return authContext.getStore()?.user ?? null;
+}
+function getSession() {
+	const store = authContext.getStore();
+	if (!store?.user || !store?.session) return null;
+	return {
+		user: store.user,
+		session: store.session
+	};
+}
+function requireAuth(c) {
+	if (c) {
+		const user = c.get("user");
+		if (!user) {
+			const err = /* @__PURE__ */ new Error("Unauthorized");
+			err.status = 401;
+			throw err;
+		}
+		return user;
+	}
+	const user = getUser();
+	if (!user) {
+		const err = /* @__PURE__ */ new Error("Unauthorized");
+		err.status = 401;
+		throw err;
+	}
+	return user;
+}
+function createAuthClient(basePath = "/api/auth") {
+	async function authFetch(path, init) {
+		const res = await fetch(`${basePath}${path}`, {
+			credentials: "include",
+			headers: {
+				"content-type": "application/json",
+				...init?.headers
+			},
+			...init
+		});
+		if (!res.ok) throw await res.json().catch(() => ({ message: res.statusText }));
+		return await res.json().catch(() => null);
+	}
+	function buildFetchOptions(body) {
+		return {
+			method: "POST",
+			body: body ? JSON.stringify(body) : void 0
+		};
+	}
+	return {
+		signIn: {
+			email: async ({ email, password, callbackURL, rememberMe }) => {
+				try {
+					const data = await authFetch("/sign-in/email", buildFetchOptions({
+						email,
+						password,
+						rememberMe
+					}));
+					if (callbackURL && typeof window !== "undefined") window.location.href = callbackURL;
+					return { data };
+				} catch (error) {
+					return { error };
+				}
+			},
+			social: (provider, opts) => {
+				if (typeof window === "undefined") return Promise.resolve();
+				const redirect = opts?.callbackURL || window.location.href;
+				window.location.href = `${basePath}/sign-in/social/${provider}?callbackURL=${encodeURIComponent(redirect)}`;
+				return Promise.resolve();
+			}
+		},
+		signUp: { email: async ({ email, password, name, callbackURL }) => {
+			try {
+				const data = await authFetch("/sign-up/email", buildFetchOptions({
+					email,
+					password,
+					name
+				}));
+				if (callbackURL && typeof window !== "undefined") window.location.href = callbackURL;
+				return { data };
+			} catch (error) {
+				return { error };
+			}
+		} },
+		signOut: async () => {
+			try {
+				return { data: await authFetch("/sign-out", buildFetchOptions()) };
+			} catch (error) {
+				return { error };
+			}
+		},
+		getSession: async () => {
+			try {
+				return await authFetch("/get-session");
+			} catch {
+				return null;
+			}
+		},
+		sendVerificationEmail: async (email, opts) => {
+			try {
+				return { data: await authFetch("/send-verification-email", buildFetchOptions({
+					email,
+					...opts
+				})) };
+			} catch (error) {
+				return { error };
+			}
+		},
+		resetPassword: async (newPassword, token) => {
+			try {
+				return { data: await authFetch("/reset-password", buildFetchOptions({
+					newPassword,
+					token
+				})) };
+			} catch (error) {
+				return { error };
+			}
+		},
+		forgetPassword: async (email, opts) => {
+			try {
+				return { data: await authFetch("/forget-password", buildFetchOptions({
+					email,
+					...opts
+				})) };
+			} catch (error) {
+				return { error };
+			}
+		},
+		updateUser: async (data) => {
+			try {
+				return { data: (await authFetch("/update-user", buildFetchOptions(data))).user };
+			} catch (error) {
+				return { error };
+			}
+		},
+		changeEmail: async (newEmail, callbackURL) => {
+			try {
+				return { data: await authFetch("/change-email", buildFetchOptions({
+					newEmail,
+					callbackURL
+				})) };
+			} catch (error) {
+				return { error };
+			}
+		},
+		changePassword: async (currentPassword, newPassword, revokeOtherSessions) => {
+			try {
+				return { data: await authFetch("/change-password", buildFetchOptions({
+					currentPassword,
+					newPassword,
+					revokeOtherSessions
+				})) };
+			} catch (error) {
+				return { error };
+			}
+		},
+		listSessions: async () => {
+			try {
+				return { data: (await authFetch("/list-sessions")).sessions };
+			} catch (error) {
+				return { error };
+			}
+		},
+		revokeSession: async (sessionId) => {
+			try {
+				return { data: await authFetch("/revoke-session", buildFetchOptions({ sessionId })) };
+			} catch (error) {
+				return { error };
+			}
+		},
+		revokeSessions: async () => {
+			try {
+				return { data: await authFetch("/revoke-sessions", buildFetchOptions()) };
+			} catch (error) {
+				return { error };
+			}
+		},
+		$fetch: (input, init) => fetch(input, {
+			credentials: "include",
+			...init
+		})
+	};
+}
+async function getServerSession(req) {
+	if (!authInstance.handler) createAuthHandler();
+	await new Promise((resolve) => {
+		if (authInstance.handler) resolve();
+		else setTimeout(() => resolve(), 100);
+	});
+	const current = authContext.getStore();
+	if (current?.user && current?.session) return {
+		session: current.session,
+		user: current.user
+	};
+	if (req && authInstance.api?.getSession) try {
+		return await authInstance.api.getSession(req.headers);
+	} catch {
+		return null;
+	}
+	return null;
+}
+//#endregion
+export { authMiddleware, createAuthClient, createAuthHandler, defineAuth, getServerSession, getSession, getUser, requireAuth, resolveAuthOptions };

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { a as AuthState, c as ResolvedAuthOptions, d as UbeanAuthOptions, f as UseAuthReturn, i as AuthSession, l as Session, m as Verification, n as AuthClient, o as AuthUser, p as User, r as AuthError, s as BetterAuthOptions, t as Account, u as SocialProviderConfig } from "./types-DlL9lr7A.js";
+import { authMiddleware, createAuthClient, createAuthHandler, defineAuth, getServerSession, getSession, getUser, requireAuth, resolveAuthOptions } from "./core.js";
+import ubeanAuthPlugin, { defineAuthConfig } from "./vite.js";
+import { getSessionFromHeaders, protectRoute, useAuth, useSession } from "./runtime.js";
+export { type Account, type AuthClient, type AuthError, type AuthSession, type AuthState, type AuthUser, type BetterAuthOptions as BetterAuthConfig, type BetterAuthOptions, type ResolvedAuthOptions, type Session, type SocialProviderConfig, type UbeanAuthOptions, type UseAuthReturn, type User, type Verification, authMiddleware, createAuthClient, createAuthHandler, defineAuth, defineAuthConfig, getSession as getAuthSession, getServerSession, getSessionFromHeaders, getUser, protectRoute, requireAuth, resolveAuthOptions, ubeanAuthPlugin, useAuth, useSession };

package/dist/index.js

@@ -0,0 +1,4 @@
+import { authMiddleware, createAuthClient, createAuthHandler, defineAuth, getServerSession, getSession, getUser, requireAuth, resolveAuthOptions } from "./core.js";
+import ubeanAuthPlugin, { defineAuthConfig } from "./vite.js";
+import { getSessionFromHeaders, protectRoute, useAuth, useSession } from "./runtime.js";
+export { authMiddleware, createAuthClient, createAuthHandler, defineAuth, defineAuthConfig, getSession as getAuthSession, getServerSession, getSessionFromHeaders, getUser, protectRoute, requireAuth, resolveAuthOptions, ubeanAuthPlugin, useAuth, useSession };

package/dist/runtime.d.ts

@@ -0,0 +1,62 @@
+import { f as UseAuthReturn, i as AuthSession, n as AuthClient, p as User, r as AuthError } from "./types-DlL9lr7A.js";
+import { createAuthClient } from "./core.js";
+//#region src/runtime.d.ts
+declare function useAuth(basePath?: string): UseAuthReturn;
+declare function useSession(basePath?: string): {
+  data: import("vue").Ref<{
+    session: {
+      id: string;
+      createdAt: Date;
+      updatedAt: Date;
+      userId: string;
+      expiresAt: Date;
+      token: string;
+      ipAddress?: string | null | undefined;
+      userAgent?: string | null | undefined;
+    };
+    user: {
+      id: string;
+      createdAt: Date;
+      updatedAt: Date;
+      email: string;
+      emailVerified: boolean;
+      name: string;
+      image?: string | null | undefined;
+    };
+  } | null, AuthSession | {
+    session: {
+      id: string;
+      createdAt: Date;
+      updatedAt: Date;
+      userId: string;
+      expiresAt: Date;
+      token: string;
+      ipAddress?: string | null | undefined;
+      userAgent?: string | null | undefined;
+    };
+    user: {
+      id: string;
+      createdAt: Date;
+      updatedAt: Date;
+      email: string;
+      emailVerified: boolean;
+      name: string;
+      image?: string | null | undefined;
+    };
+  } | null>;
+  isPending: import("vue").Ref<boolean, boolean>;
+  error: import("vue").Ref<{
+    message: string;
+    code?: string | undefined;
+    statusCode?: number | undefined;
+  } | null, AuthError | {
+    message: string;
+    code?: string | undefined;
+    statusCode?: number | undefined;
+  } | null>;
+  refetch: () => Promise<void>;
+};
+declare function getSessionFromHeaders(headers: Headers, basePath?: string): Promise<AuthSession | null>;
+declare function protectRoute(redirectTo?: string): void;
+//#endregion
+export { type AuthClient, type AuthError, type AuthSession, type UseAuthReturn, type User, createAuthClient, getSessionFromHeaders, protectRoute, useAuth, useSession };

package/dist/runtime.js

@@ -0,0 +1,155 @@
+import { createAuthClient } from "./core.js";
+import { computed, onMounted, ref } from "vue";
+//#region src/runtime.ts
+function useAuth(basePath = "/api/auth") {
+	const client = createAuthClient(basePath);
+	const session = ref(null);
+	const isLoading = ref(false);
+	const isPending = ref(true);
+	const error = ref(null);
+	const user = computed(() => session.value?.user || null);
+	const isAuthenticated = computed(() => !!session.value?.user);
+	async function fetchSession() {
+		if (typeof window === "undefined") return;
+		isLoading.value = true;
+		isPending.value = true;
+		error.value = null;
+		try {
+			const result = await client.getSession();
+			session.value = result;
+		} catch (err) {
+			session.value = null;
+			error.value = err;
+		} finally {
+			isLoading.value = false;
+			isPending.value = false;
+		}
+	}
+	const signIn = {
+		email: async ({ email, password, callbackURL }) => {
+			isLoading.value = true;
+			try {
+				const result = await client.signIn.email({
+					email,
+					password,
+					callbackURL
+				});
+				if (result.data) {
+					session.value = result.data;
+					if (callbackURL && typeof window !== "undefined") window.location.href = callbackURL;
+				}
+				if (result.error) error.value = result.error;
+				return result;
+			} finally {
+				isLoading.value = false;
+			}
+		},
+		social: (provider, opts) => {
+			return client.signIn.social(provider, opts);
+		}
+	};
+	const signUp = { email: async ({ email, password, name, callbackURL }) => {
+		isLoading.value = true;
+		try {
+			const result = await client.signUp.email({
+				email,
+				password,
+				name,
+				callbackURL
+			});
+			if (result.data) {
+				session.value = result.data;
+				if (callbackURL && typeof window !== "undefined") window.location.href = callbackURL;
+			}
+			if (result.error) error.value = result.error;
+			return result;
+		} finally {
+			isLoading.value = false;
+		}
+	} };
+	async function signOut() {
+		isLoading.value = true;
+		try {
+			const result = await client.signOut();
+			session.value = null;
+			return result;
+		} finally {
+			isLoading.value = false;
+		}
+	}
+	async function refreshSession() {
+		await fetchSession();
+	}
+	onMounted(() => {
+		fetchSession();
+		if (typeof window !== "undefined") {
+			window.addEventListener("focus", fetchSession);
+			document.addEventListener("visibilitychange", () => {
+				if (document.visibilityState === "visible") fetchSession();
+			});
+		}
+	});
+	return {
+		session,
+		user,
+		isLoading,
+		isPending,
+		isAuthenticated,
+		error,
+		signIn,
+		signUp,
+		signOut,
+		getSession: client.getSession,
+		updateUser: client.updateUser,
+		refreshSession
+	};
+}
+function useSession(basePath = "/api/auth") {
+	const data = ref(null);
+	const isPending = ref(true);
+	const error = ref(null);
+	const client = createAuthClient(basePath);
+	const refetch = async () => {
+		isPending.value = true;
+		error.value = null;
+		try {
+			data.value = await client.getSession();
+		} catch (err) {
+			data.value = null;
+			error.value = err;
+		} finally {
+			isPending.value = false;
+		}
+	};
+	onMounted(refetch);
+	if (typeof window !== "undefined") {
+		window.addEventListener("focus", refetch);
+		document.addEventListener("visibilitychange", () => {
+			if (document.visibilityState === "visible") refetch();
+		});
+	}
+	return {
+		data,
+		isPending,
+		error,
+		refetch
+	};
+}
+function getSessionFromHeaders(headers, basePath = "/api/auth") {
+	return fetch(`${basePath}/get-session`, {
+		headers: { cookie: headers.get("cookie") || "" },
+		credentials: "include"
+	}).then((r) => r.json()).then((data) => {
+		if (data?.session && data?.user) return data;
+		return null;
+	}).catch(() => null);
+}
+function protectRoute(redirectTo = "/login") {
+	const auth = useAuth();
+	if (typeof window !== "undefined" && !auth.isPending.value && !auth.isAuthenticated.value) {
+		const redirectUrl = `${redirectTo}?redirect=${encodeURIComponent(window.location.pathname)}`;
+		window.location.href = redirectUrl;
+	}
+}
+//#endregion
+export { createAuthClient, getSessionFromHeaders, protectRoute, useAuth, useSession };

package/dist/types-DlL9lr7A.d.ts

@@ -0,0 +1,220 @@
+import { Account, BetterAuthOptions as BetterAuthOptions$1, Session, User, Verification } from "better-auth";
+//#region src/types.d.ts
+interface AuthUser {
+  id: string;
+  email: string;
+  emailVerified: boolean;
+  name: string;
+  image?: string | null;
+  createdAt: string | Date;
+  updatedAt: string | Date;
+  [key: string]: unknown;
+}
+interface AuthState {
+  session: Session;
+  user: AuthUser;
+}
+interface UbeanAuthOptions {
+  enabled?: boolean;
+  basePath?: string;
+  baseURL?: string;
+  secret?: string;
+  betterAuth?: Omit<BetterAuthOptions$1, 'baseURL' | 'basePath' | 'trustedOrigins'> | ((ctx: {
+    defaults: BetterAuthOptions$1;
+  }) => BetterAuthOptions$1);
+  clientOptions?: {
+    fetchOptions?: Record<string, unknown>;
+    plugins?: Array<{
+      id: string;
+      [key: string]: unknown;
+    }>;
+  };
+  redirectTo?: {
+    login?: string;
+    signup?: string;
+    callback?: string;
+  };
+  session?: {
+    cookieName?: string;
+    expiresIn?: number;
+    updateAge?: number;
+  };
+  socialProviders?: Record<string, SocialProviderConfig>;
+  database?: BetterAuthOptions$1['database'];
+}
+interface SocialProviderConfig {
+  clientId: string;
+  clientSecret: string;
+  redirectURI?: string;
+  [key: string]: unknown;
+}
+interface ResolvedAuthOptions extends Required<Omit<UbeanAuthOptions, 'betterAuth' | 'socialProviders' | 'database'>> {
+  enabled: boolean;
+  basePath: string;
+  baseURL: string;
+  secret: string;
+  clientOptions: {
+    fetchOptions: Record<string, unknown>;
+    plugins: Array<{
+      id: string;
+      [key: string]: unknown;
+    }>;
+  };
+  redirectTo: {
+    login: string;
+    signup: string;
+    callback: string;
+  };
+  session: {
+    cookieName: string;
+    expiresIn: number;
+    updateAge: number;
+  };
+  betterAuth?: BetterAuthOptions$1;
+  database?: BetterAuthOptions$1['database'];
+  socialProviders?: Record<string, SocialProviderConfig>;
+}
+interface AuthSession {
+  session: Session;
+  user: User;
+}
+interface AuthClient {
+  signIn: {
+    email: (credentials: {
+      email: string;
+      password: string;
+      callbackURL?: string;
+      rememberMe?: boolean;
+    }) => Promise<{
+      data?: AuthSession;
+      error?: AuthError;
+    }>;
+    social: (provider: string, opts?: {
+      callbackURL?: string;
+    }) => Promise<void>;
+  };
+  signUp: {
+    email: (credentials: {
+      email: string;
+      password: string;
+      name: string;
+      callbackURL?: string;
+    }) => Promise<{
+      data?: AuthSession;
+      error?: AuthError;
+    }>;
+  };
+  signOut: () => Promise<{
+    data?: {
+      success: boolean;
+    };
+    error?: AuthError;
+  }>;
+  getSession: () => Promise<AuthSession | null>;
+  sendVerificationEmail: (email: string, opts?: {
+    callbackURL?: string;
+  }) => Promise<{
+    data?: {
+      status: boolean;
+    };
+    error?: AuthError;
+  }>;
+  resetPassword: (newPassword: string, token: string) => Promise<{
+    data?: {
+      status: boolean;
+    };
+    error?: AuthError;
+  }>;
+  forgetPassword: (email: string, opts?: {
+    redirectTo?: string;
+  }) => Promise<{
+    data?: {
+      status: boolean;
+    };
+    error?: AuthError;
+  }>;
+  updateUser: (data: Partial<User> & {
+    currentPassword?: string;
+    newPassword?: string;
+  }) => Promise<{
+    data?: User;
+    error?: AuthError;
+  }>;
+  changeEmail: (newEmail: string, callbackURL?: string) => Promise<{
+    data?: {
+      status: boolean;
+    };
+    error?: AuthError;
+  }>;
+  changePassword: (currentPassword: string, newPassword: string, revokeOtherSessions?: boolean) => Promise<{
+    data?: {
+      status: boolean;
+    };
+    error?: AuthError;
+  }>;
+  listSessions: () => Promise<{
+    data?: Session[];
+    error?: AuthError;
+  }>;
+  revokeSession: (sessionId: string) => Promise<{
+    data?: {
+      status: boolean;
+    };
+    error?: AuthError;
+  }>;
+  revokeSessions: () => Promise<{
+    data?: {
+      status: boolean;
+    };
+    error?: AuthError;
+  }>;
+  $fetch: typeof fetch;
+}
+interface AuthError {
+  message: string;
+  code?: string;
+  statusCode?: number;
+}
+interface UseAuthReturn {
+  session: import('vue').Ref<AuthSession | null>;
+  user: import('vue').ComputedRef<User | null>;
+  isLoading: import('vue').Ref<boolean>;
+  isPending: import('vue').Ref<boolean>;
+  isAuthenticated: import('vue').ComputedRef<boolean>;
+  error: import('vue').Ref<AuthError | null>;
+  signIn: {
+    email: (credentials: {
+      email: string;
+      password: string;
+      callbackURL?: string;
+    }) => Promise<{
+      data?: AuthSession;
+      error?: AuthError;
+    }>;
+    social: (provider: string, opts?: {
+      callbackURL?: string;
+    }) => Promise<void>;
+  };
+  signUp: {
+    email: (credentials: {
+      email: string;
+      password: string;
+      name: string;
+      callbackURL?: string;
+    }) => Promise<{
+      data?: AuthSession;
+      error?: AuthError;
+    }>;
+  };
+  signOut: () => Promise<{
+    data?: {
+      success: boolean;
+    };
+    error?: AuthError;
+  }>;
+  getSession: () => Promise<AuthSession | null>;
+  updateUser: AuthClient['updateUser'];
+  refreshSession: () => Promise<void>;
+}
+//#endregion
+export { AuthState as a, ResolvedAuthOptions as c, UbeanAuthOptions as d, UseAuthReturn as f, AuthSession as i, Session as l, Verification as m, AuthClient as n, AuthUser as o, User as p, AuthError as r, BetterAuthOptions$1 as s, Account as t, SocialProviderConfig as u };

package/dist/vite.d.ts

@@ -0,0 +1,7 @@
+import { d as UbeanAuthOptions } from "./types-DlL9lr7A.js";
+import { Plugin } from "vite";
+//#region src/vite.d.ts
+declare function ubeanAuthPlugin(userOptions?: UbeanAuthOptions): Plugin;
+declare function defineAuthConfig(options: UbeanAuthOptions): UbeanAuthOptions;
+//#endregion
+export { ubeanAuthPlugin as default, ubeanAuthPlugin, defineAuthConfig };

package/dist/vite.js

@@ -0,0 +1,155 @@
+import { resolveAuthOptions } from "./core.js";
+import { consola } from "consola";
+//#region src/vite.ts
+const VIRTUAL_AUTH_CLIENT_ID = "virtual:ubean-auth/client";
+const RESOLVED_VIRTUAL_AUTH_CLIENT_ID = `\0${VIRTUAL_AUTH_CLIENT_ID}`;
+const VIRTUAL_AUTH_SERVER_ID = "virtual:ubean-auth/server";
+const RESOLVED_VIRTUAL_AUTH_SERVER_ID = `\0${VIRTUAL_AUTH_SERVER_ID}`;
+function ubeanAuthPlugin(userOptions = {}) {
+	const options = resolveAuthOptions(userOptions);
+	let authHandlerInstance = null;
+	return {
+		name: "ubean:auth",
+		enforce: "pre",
+		resolveId(id) {
+			if (id === VIRTUAL_AUTH_CLIENT_ID) return RESOLVED_VIRTUAL_AUTH_CLIENT_ID;
+			if (id === VIRTUAL_AUTH_SERVER_ID) return RESOLVED_VIRTUAL_AUTH_SERVER_ID;
+			return null;
+		},
+		load(id) {
+			if (id === RESOLVED_VIRTUAL_AUTH_CLIENT_ID) return generateClientCode(options);
+			if (id === RESOLVED_VIRTUAL_AUTH_SERVER_ID) return generateServerCode(options);
+			return null;
+		},
+		configureServer(server) {
+			if (!options.enabled) return;
+			server.middlewares.use((req, res, next) => {
+				const url = req.url || "";
+				if (!url.startsWith(options.basePath)) return next();
+				Promise.resolve().then(async () => {
+					if (!authHandlerInstance) {
+						const { createAuthHandler } = await import("./core.js");
+						authHandlerInstance = createAuthHandler(userOptions);
+						await authHandlerInstance.resolveAuth();
+					}
+					const fullUrl = `${server.config.server.https ? "https" : "http"}://${req.headers.host || "localhost"}${url}`;
+					const request = new Request(fullUrl, {
+						method: req.method,
+						headers: new Headers(req.headers),
+						body: req.method !== "GET" && req.method !== "HEAD" ? req : void 0,
+						duplex: "half"
+					});
+					const response = await authHandlerInstance.handler(request);
+					res.statusCode = response.status;
+					response.headers.forEach((value, key) => {
+						res.setHeader(key, value);
+					});
+					const text = await response.text();
+					res.end(text);
+				}).catch((error) => {
+					consola.error("[auth] Error handling auth request:", error);
+					res.statusCode = 500;
+					res.end(JSON.stringify({ error: "Internal auth error" }));
+				});
+			});
+			consola.success(`[auth] Better Auth routes mounted at ${options.basePath}/*`);
+		}
+	};
+}
+function generateClientCode(options) {
+	return `
+const BASE_URL = ${JSON.stringify(options.basePath)};
+
+async function authFetch(path, init = {}) {
+  const res = await fetch(BASE_URL + path, {
+    credentials: 'include',
+    headers: { 'content-type': 'application/json', ...(init.headers || {}) },
+    ...init
+  });
+  if (!res.ok) {
+    let err = { message: res.statusText };
+    try { err = await res.json(); } catch (_) {}
+    throw err;
+  }
+  return res.json().catch(() => null);
+}
+
+function buildBody(body) {
+  return { method: 'POST', body: body ? JSON.stringify(body) : undefined };
+}
+
+export const authClient = {
+  signIn: {
+    email: async ({ email, password, callbackURL, rememberMe }) => {
+      try {
+        const data = await authFetch('/sign-in/email', buildBody({ email, password, rememberMe }));
+        if (callbackURL && typeof window !== 'undefined') window.location.href = callbackURL;
+        return { data };
+      } catch (error) { return { error }; }
+    },
+    social: (provider, opts) => {
+      if (typeof window === 'undefined') return Promise.resolve();
+      const redirect = opts?.callbackURL || window.location.href;
+      window.location.href = BASE_URL + '/sign-in/social/' + provider + '?callbackURL=' + encodeURIComponent(redirect);
+      return Promise.resolve();
+    }
+  },
+  signUp: {
+    email: async ({ email, password, name, callbackURL }) => {
+      try {
+        const data = await authFetch('/sign-up/email', buildBody({ email, password, name }));
+        if (callbackURL && typeof window !== 'undefined') window.location.href = callbackURL;
+        return { data };
+      } catch (error) { return { error }; }
+    }
+  },
+  signOut: async () => {
+    try { const data = await authFetch('/sign-out', buildBody()); return { data }; }
+    catch (error) { return { error }; }
+  },
+  getSession: async () => {
+    try { return await authFetch('/get-session'); } catch (_) { return null; }
+  },
+  forgetPassword: async (email, opts) => {
+    try { const data = await authFetch('/forget-password', buildBody({ email, ...opts })); return { data }; }
+    catch (error) { return { error }; }
+  },
+  resetPassword: async (newPassword, token) => {
+    try { const data = await authFetch('/reset-password', buildBody({ newPassword, token })); return { data }; }
+    catch (error) { return { error }; }
+  },
+  updateUser: async (data) => {
+    try { const r = await authFetch('/update-user', buildBody(data)); return { data: r.user }; }
+    catch (error) { return { error }; }
+  },
+  changePassword: async (currentPassword, newPassword, revokeOtherSessions) => {
+    try { const data = await authFetch('/change-password', buildBody({ currentPassword, newPassword, revokeOtherSessions })); return { data }; }
+    catch (error) { return { error }; }
+  },
+  listSessions: async () => {
+    try { const d = await authFetch('/list-sessions'); return { data: d.sessions }; }
+    catch (error) { return { error }; }
+  },
+  revokeSession: async (sessionId) => {
+    try { const data = await authFetch('/revoke-session', buildBody({ sessionId })); return { data }; }
+    catch (error) { return { error }; }
+  },
+  revokeSessions: async () => {
+    try { const data = await authFetch('/revoke-sessions', buildBody()); return { data }; }
+    catch (error) { return { error }; }
+  },
+  $fetch: (input, init) => fetch(input, { credentials: 'include', ...init })
+};
+export default authClient;
+`;
+}
+function generateServerCode(_options) {
+	return `
+export { createAuthHandler, authMiddleware, getUser, getSession, requireAuth, getServerSession, defineAuth } from '@ubean/auth/core';
+`;
+}
+function defineAuthConfig(options) {
+	return options;
+}
+//#endregion
+export { ubeanAuthPlugin as default, ubeanAuthPlugin, defineAuthConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ubean/auth",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Better Auth integration for ubean framework",
   "files": [
     "dist"