@onmax/nuxt-better-auth 0.0.1 → 0.0.2-alpha.10

package/dist/runtime/app/components/BetterAuthState.d.vue.ts

@@ -0,0 +1,20 @@
+declare var __VLS_1: {
+    loggedIn: any;
+    user: any;
+    session: any;
+    signOut: any;
+}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    placeholder?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/app/components/BetterAuthState.vue

@@ -0,0 +1,8 @@
+<script setup>
+const { loggedIn, user, session, signOut, ready } = useUserSession();
+</script>
+
+<template>
+  <slot v-if="ready" v-bind="{ loggedIn, user, session, signOut }" />
+  <slot v-else name="placeholder" />
+</template>

package/dist/runtime/app/components/BetterAuthState.vue.d.ts

@@ -0,0 +1,20 @@
+declare var __VLS_1: {
+    loggedIn: any;
+    user: any;
+    session: any;
+    signOut: any;
+}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    placeholder?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/app/composables/useUserSession.d.ts

@@ -0,0 +1,22 @@
+import type { AppAuthClient, AuthSession, AuthUser } from '#nuxt-better-auth';
+import type { ComputedRef, Ref } from 'vue';
+export interface SignOutOptions {
+    onSuccess?: () => void | Promise<void>;
+}
+export interface UseUserSessionReturn {
+    client: AppAuthClient | null;
+    session: Ref<AuthSession | null>;
+    user: Ref<AuthUser | null>;
+    loggedIn: ComputedRef<boolean>;
+    ready: ComputedRef<boolean>;
+    signIn: NonNullable<AppAuthClient>['signIn'];
+    signUp: NonNullable<AppAuthClient>['signUp'];
+    signOut: (options?: SignOutOptions) => Promise<void>;
+    waitForSession: () => Promise<void>;
+    fetchSession: (options?: {
+        headers?: HeadersInit;
+        force?: boolean;
+    }) => Promise<void>;
+    updateUser: (updates: Partial<AuthUser>) => void;
+}
+export declare function useUserSession(): UseUserSessionReturn;

package/dist/runtime/app/composables/useUserSession.js

@@ -0,0 +1,159 @@
+import { createAppAuthClient } from "#auth/client";
+import { computed, nextTick, useRequestHeaders, useRequestURL, useRuntimeConfig, useState, watch } from "#imports";
+let _client = null;
+function getClient(baseURL) {
+  if (!_client)
+    _client = createAppAuthClient(baseURL);
+  return _client;
+}
+export function useUserSession() {
+  const runtimeConfig = useRuntimeConfig();
+  const requestURL = useRequestURL();
+  const client = import.meta.client ? getClient(runtimeConfig.public.siteUrl || requestURL.origin) : null;
+  const session = useState("auth:session", () => null);
+  const user = useState("auth:user", () => null);
+  const authReady = useState("auth:ready", () => false);
+  const ready = computed(() => authReady.value);
+  const loggedIn = computed(() => Boolean(session.value && user.value));
+  function clearSession() {
+    session.value = null;
+    user.value = null;
+  }
+  function updateUser(updates) {
+    if (user.value)
+      user.value = { ...user.value, ...updates };
+  }
+  if (import.meta.client && client) {
+    const clientSession = client.useSession();
+    watch(
+      () => clientSession.value,
+      (newSession) => {
+        if (newSession?.data?.session && newSession?.data?.user) {
+          const { token: _, ...safeSession } = newSession.data.session;
+          session.value = safeSession;
+          user.value = newSession.data.user;
+        } else if (!newSession?.isPending) {
+          clearSession();
+        }
+        if (!authReady.value && !newSession?.isPending)
+          authReady.value = true;
+      },
+      { immediate: true, deep: true }
+    );
+  }
+  function waitForSession() {
+    return new Promise((resolve) => {
+      if (loggedIn.value) {
+        resolve();
+        return;
+      }
+      const unwatch = watch(loggedIn, (isLoggedIn) => {
+        if (isLoggedIn) {
+          unwatch();
+          resolve();
+        }
+      });
+      setTimeout(() => {
+        unwatch();
+        resolve();
+      }, 5e3);
+    });
+  }
+  function wrapOnSuccess(cb) {
+    return async (ctx) => {
+      await fetchSession({ force: true });
+      if (!loggedIn.value)
+        await waitForSession();
+      await nextTick();
+      await cb(ctx);
+    };
+  }
+  function wrapAuthMethod(method) {
+    return (async (...args) => {
+      const [data, options] = args;
+      if (data?.fetchOptions?.onSuccess) {
+        return method({ ...data, fetchOptions: { ...data.fetchOptions, onSuccess: wrapOnSuccess(data.fetchOptions.onSuccess) } }, options);
+      }
+      if (options?.onSuccess) {
+        return method(data, { ...options, onSuccess: wrapOnSuccess(options.onSuccess) });
+      }
+      return method(data, options);
+    });
+  }
+  const signIn = client?.signIn ? new Proxy(client.signIn, {
+    get(target, prop) {
+      const targetRecord = target;
+      const method = targetRecord[prop];
+      if (typeof method !== "function")
+        return method;
+      return wrapAuthMethod((...args) => targetRecord[prop](...args));
+    }
+  }) : new Proxy({}, {
+    get: (_, prop) => {
+      throw new Error(`signIn.${String(prop)}() can only be called on client-side`);
+    }
+  });
+  const signUp = client?.signUp ? new Proxy(client.signUp, {
+    get(target, prop) {
+      const targetRecord = target;
+      const method = targetRecord[prop];
+      if (typeof method !== "function")
+        return method;
+      return wrapAuthMethod((...args) => targetRecord[prop](...args));
+    }
+  }) : new Proxy({}, {
+    get: (_, prop) => {
+      throw new Error(`signUp.${String(prop)}() can only be called on client-side`);
+    }
+  });
+  async function fetchSession(options = {}) {
+    if (import.meta.server) {
+      if (!authReady.value)
+        authReady.value = true;
+      return;
+    }
+    if (client) {
+      try {
+        const headers = options.headers || useRequestHeaders(["cookie"]);
+        const fetchOptions = headers ? { headers } : void 0;
+        const query = options.force ? { disableCookieCache: true } : void 0;
+        const result = await client.getSession({ query }, fetchOptions);
+        const data = result.data;
+        if (data?.session && data?.user) {
+          const { token: _, ...safeSession } = data.session;
+          session.value = safeSession;
+          user.value = data.user;
+        } else {
+          clearSession();
+        }
+      } catch (error) {
+        clearSession();
+        console.error("[nuxt-better-auth] Failed to fetch session:", error);
+      } finally {
+        if (!authReady.value)
+          authReady.value = true;
+      }
+    }
+  }
+  async function signOut(options) {
+    if (!client)
+      throw new Error("signOut can only be called on client-side");
+    await client.signOut();
+    clearSession();
+    if (options?.onSuccess)
+      await options.onSuccess();
+  }
+  return {
+    client,
+    session,
+    user,
+    loggedIn,
+    ready,
+    signIn,
+    signUp,
+    signOut,
+    waitForSession,
+    fetchSession,
+    updateUser
+  };
+}

package/dist/runtime/app/middleware/auth.global.d.ts

@@ -0,0 +1,13 @@
+import type { AuthMeta } from '../../types.js';
+declare module '#app' {
+    interface PageMeta {
+        auth?: AuthMeta;
+    }
+}
+declare module 'vue-router' {
+    interface RouteMeta {
+        auth?: AuthMeta;
+    }
+}
+declare const _default: any;
+export default _default;

package/dist/runtime/app/middleware/auth.global.js

@@ -0,0 +1,37 @@
+import { createError, defineNuxtRouteMiddleware, getRouteRules, navigateTo, useNuxtApp, useRequestHeaders, useRuntimeConfig, useUserSession } from "#imports";
+import { matchesUser } from "../../utils/match-user.js";
+export default defineNuxtRouteMiddleware(async (to) => {
+  const nuxtApp = useNuxtApp();
+  if (import.meta.client) {
+    const isPrerendered = nuxtApp.payload.prerenderedAt || nuxtApp.payload.isCached;
+    if (isPrerendered && nuxtApp.isHydrating)
+      return;
+  }
+  if (to.meta.auth === void 0) {
+    const rules = await getRouteRules({ path: to.path });
+    if (rules.auth !== void 0)
+      to.meta.auth = rules.auth;
+  }
+  const auth = to.meta.auth;
+  if (auth === void 0 || auth === false)
+    return;
+  const config = useRuntimeConfig().public.auth;
+  const { fetchSession, user, loggedIn } = useUserSession();
+  if (!loggedIn.value) {
+    const headers = import.meta.server ? useRequestHeaders(["cookie"]) : void 0;
+    await fetchSession({ headers });
+  }
+  const mode = typeof auth === "string" ? auth : auth?.only ?? "user";
+  const redirectTo = typeof auth === "object" ? auth.redirectTo : void 0;
+  if (mode === "guest") {
+    if (loggedIn.value)
+      return navigateTo(redirectTo ?? config?.redirects?.guest ?? "/");
+    return;
+  }
+  if (!loggedIn.value)
+    return navigateTo(redirectTo ?? config?.redirects?.login ?? "/login");
+  if (typeof auth === "object" && auth.user) {
+    if (!user.value || !matchesUser(user.value, auth.user))
+      throw createError({ statusCode: 403, statusMessage: "Access denied" });
+  }
+});

package/dist/runtime/app/pages/__better-auth-devtools.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;