@onmax/nuxt-better-auth 0.0.2-alpha.30 → 0.0.2-alpha.32

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

@@ -1,8 +1,8 @@
 declare var __VLS_1: {
-    loggedIn: any;
-    user: any;
-    session: any;
-    signOut: any;
+    loggedIn: boolean;
+    user: import("../../types.js").AuthUser | null;
+    session: import("../../types.js").AuthSession | null;
+    signOut: (options?: import("../composables/useUserSession.js").SignOutOptions) => Promise<void>;
 }, __VLS_3: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;

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

@@ -1,5 +1,5 @@
 <script setup>
-import { useUserSession } from "#imports";
+import { useUserSession } from "../composables/useUserSession";
 const { loggedIn, user, session, signOut, ready } = useUserSession();
 </script>
 

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

@@ -1,8 +1,8 @@
 declare var __VLS_1: {
-    loggedIn: any;
-    user: any;
-    session: any;
-    signOut: any;
+    loggedIn: boolean;
+    user: import("../../types.js").AuthUser | null;
+    session: import("../../types.js").AuthSession | null;
+    signOut: (options?: import("../composables/useUserSession.js").SignOutOptions) => Promise<void>;
 }, __VLS_3: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;

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

@@ -0,0 +1,9 @@
+import type { AppAuthClient } from '#nuxt-better-auth';
+interface RuntimeFlags {
+    client: boolean;
+    server: boolean;
+}
+export declare function getAuthRuntimeFlags(): RuntimeFlags;
+export declare function useRawAuthClient(): AppAuthClient | null;
+export declare function useAuthClient(): AppAuthClient | null;
+export {};

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

@@ -0,0 +1,34 @@
+import createAppAuthClient from "#auth/client";
+import { useRequestURL, useRuntimeConfig } from "#imports";
+import { createVueSafeAuthProxy } from "../internal/vue-safe-auth-proxy.js";
+let _client = null;
+let _clientFacade = null;
+export function getAuthRuntimeFlags() {
+  const globalFlags = globalThis.__NUXT_BETTER_AUTH_TEST_FLAGS__;
+  if (globalFlags)
+    return globalFlags;
+  return { client: Boolean(import.meta.client), server: Boolean(import.meta.server) };
+}
+function getClient(baseURL) {
+  if (!_client)
+    _client = createAppAuthClient(baseURL);
+  return _client;
+}
+function getClientFacade(client) {
+  if (!_clientFacade)
+    _clientFacade = createVueSafeAuthProxy(client);
+  return _clientFacade;
+}
+export function useRawAuthClient() {
+  const runtimeFlags = getAuthRuntimeFlags();
+  if (!runtimeFlags.client)
+    return null;
+  const runtimeConfig = useRuntimeConfig();
+  const requestURL = useRequestURL();
+  const siteUrl = typeof runtimeConfig.public.siteUrl === "string" ? runtimeConfig.public.siteUrl : requestURL.origin;
+  return getClient(siteUrl);
+}
+export function useAuthClient() {
+  const rawClient = useRawAuthClient();
+  return rawClient ? getClientFacade(rawClient) : null;
+}

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

@@ -1,5 +1,3 @@
+import type { AppAuthClient } from '#nuxt-better-auth';
 import type { UserAuthActionHandle } from '../internal/auth-action-handles.js';
-import type { UseUserSessionReturn } from './useUserSession.js';
-type AppAuthClient = NonNullable<UseUserSessionReturn['client']>;
 export declare function useAuthClientAction<TArgs extends unknown[], TResult>(select: (client: AppAuthClient) => (...args: TArgs) => Promise<TResult>): UserAuthActionHandle<TArgs, TResult>;
-export {};

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

@@ -1,10 +1,10 @@
-import { useUserSession } from "#imports";
 import { useAction } from "./useAction.js";
+import { useAuthClient } from "./useAuthClient.js";
 export function useAuthClientAction(select) {
   if (typeof select !== "function")
     throw new TypeError("useAuthClientAction(select) requires a selector function");
   return useAction(async (...args) => {
-    const { client } = useUserSession();
+    const client = useAuthClient();
     if (!client)
       throw new Error("Auth client is unavailable. This action can only run on client-side.");
     const method = select(client);

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

@@ -1,5 +1,5 @@
-import type { AuthApiEndpointMethod, AuthApiEndpointPath, AuthApiEndpointResponse } from '#nuxt-better-auth';
 import type { NitroFetchOptions } from 'nitropack/types';
+import type { AuthApiEndpointMethod, AuthApiEndpointPath, AuthApiEndpointResponse } from '#nuxt-better-auth';
 import { useRequestFetch } from '#imports';
 type AuthRequestFetchExtractedMethod<Options> = Options extends undefined ? 'get' : Lowercase<Extract<Exclude<Options extends {
     method?: infer Method;

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

@@ -1,8 +1,8 @@
-import { useUserSession } from "#imports";
 import { createActionHandles } from "../internal/auth-action-handles.js";
+import { useAuthActionNamespaces } from "./useUserSession.js";
 export function useSignIn(method) {
   if (method === void 0 || method === null)
     throw new TypeError("useSignIn(method) requires a sign-in method key");
-  const handles = createActionHandles(() => useUserSession().signIn, "signIn");
+  const handles = createActionHandles(() => useAuthActionNamespaces().signIn, "signIn");
   return handles[method];
 }

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

@@ -1,8 +1,8 @@
-import { useUserSession } from "#imports";
 import { createActionHandles } from "../internal/auth-action-handles.js";
+import { useAuthActionNamespaces } from "./useUserSession.js";
 export function useSignUp(method) {
   if (method === void 0 || method === null)
     throw new TypeError("useSignUp(method) requires a sign-up method key");
-  const handles = createActionHandles(() => useUserSession().signUp, "signUp");
+  const handles = createActionHandles(() => useAuthActionNamespaces().signUp, "signUp");
   return handles[method];
 }

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

@@ -1,16 +1,13 @@
-import type { AppAuthClient, AuthSession, AuthUser } from '#nuxt-better-auth';
 import type { ComputedRef, Ref } from 'vue';
+import type { AuthSession, AuthUser } from '#nuxt-better-auth';
 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?: {
@@ -20,3 +17,7 @@ export interface UseUserSessionReturn {
     updateUser: (updates: Partial<AuthUser>) => Promise<void>;
 }
 export declare function useUserSession(): UseUserSessionReturn;
+export declare function useAuthActionNamespaces(): {
+    signIn: any;
+    signUp: any;
+};

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

@@ -1,22 +1,27 @@
-import createAppAuthClient from "#auth/client";
-import { computed, navigateTo, nextTick, useNuxtApp, useRequestFetch, useRequestHeaders, useRequestURL, useRuntimeConfig, useState, watch } from "#imports";
+import { computed, navigateTo, nextTick, useNuxtApp, useRequestURL, useRuntimeConfig, useState, watch } from "#imports";
 import { normalizeAuthActionError } from "../internal/auth-action-error.js";
+import { resolvePostAuthSuccessRedirect, withFallbackSocialCallbackURL } from "../internal/redirect-helpers.js";
+import { fetchSessionClient, fetchSessionServer, stripToken } from "../internal/session-fetch.js";
+import { isRecord } from "../internal/utils.js";
+import { createVueSafeAuthFacade, isAuthProxyProbeKey } from "../internal/vue-safe-auth-proxy.js";
+import { wrapAuthMethod } from "../internal/wrap-auth-method.js";
+import { getAuthRuntimeFlags, useRawAuthClient } from "./useAuthClient.js";
 let _sessionSignalListenerBound = false;
-let _client = null;
-function isRecord(value) {
-  return Boolean(value && typeof value === "object");
-}
-function getClient(baseURL) {
-  if (!_client)
-    _client = createAppAuthClient(baseURL);
-  return _client;
-}
-function getRuntimeFlags() {
-  const globalFlags = globalThis.__NUXT_BETTER_AUTH_TEST_FLAGS__;
-  if (globalFlags)
-    return globalFlags;
-  return { client: Boolean(import.meta.client), server: Boolean(import.meta.server) };
+let _signOutPromise = null;
+function createServerOnlyActionNamespace(path) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (isAuthProxyProbeKey(prop))
+        return void 0;
+      const key = prop;
+      return async () => {
+        throw new Error(`${path}.${key}() can only be called on client-side`);
+      };
+    }
+  });
 }
+const _signInServerOnly = createServerOnlyActionNamespace("signIn");
+const _signUpServerOnly = createServerOnlyActionNamespace("signUp");
 function ensureSessionSignalListener(client, onSignal) {
   if (_sessionSignalListenerBound)
     return;
@@ -36,11 +41,10 @@ function ensureSessionSignalListener(client, onSignal) {
   });
 }
 export function useUserSession() {
-  const runtimeFlags = getRuntimeFlags();
+  const runtimeFlags = getAuthRuntimeFlags();
   const runtimeConfig = useRuntimeConfig();
-  const requestURL = useRequestURL();
   const nuxtApp = useNuxtApp();
-  const client = runtimeFlags.client ? getClient(runtimeConfig.public.siteUrl || requestURL.origin) : null;
+  const rawClient = useRawAuthClient();
   const session = useState("auth:session", () => null);
   const user = useState("auth:user", () => null);
   const authReady = useState("auth:ready", () => false);
@@ -88,15 +92,21 @@ export function useUserSession() {
     session.value = null;
     user.value = null;
   }
+  async function fetchSession(options = {}) {
+    if (runtimeFlags.server)
+      return fetchSessionServer(session, user, authReady, options);
+    if (rawClient)
+      return fetchSessionClient(rawClient, session, user, authReady, options);
+  }
   async function updateUser(updates) {
     if (!user.value)
       return;
     const previousUser = user.value;
     user.value = { ...user.value, ...updates };
-    if (!client)
+    if (!rawClient)
       return;
     try {
-      const clientWithUpdateUser = client;
+      const clientWithUpdateUser = rawClient;
       const result = await clientWithUpdateUser.updateUser(updates);
       if (result?.error) {
         if (result.error instanceof Error)
@@ -113,8 +123,8 @@ export function useUserSession() {
       throw error;
     }
   }
-  if (runtimeFlags.client && client && !shouldSkipInitialClientSessionFetch.value) {
-    const clientSession = client.useSession();
+  if (runtimeFlags.client && rawClient && !shouldSkipInitialClientSessionFetch.value) {
+    const clientSession = rawClient.useSession();
     watch(
       () => clientSession.value,
       (newSession) => {
@@ -122,8 +132,7 @@ export function useUserSession() {
         if (shouldWaitForPrerenderResolution)
           return;
         if (newSession?.data?.session && newSession?.data?.user) {
-          const { token: _, ...safeSession } = newSession.data.session;
-          session.value = safeSession;
+          session.value = stripToken(newSession.data.session);
           user.value = newSession.data.user;
         } else if (!newSession?.isPending && !newSession?.isRefetching) {
           const isHydrationEmptySnapshot = nuxtApp.isHydrating && nuxtApp.payload.serverRendered && Boolean(session.value && user.value) && !newSession?.data?.session && !newSession?.data?.user;
@@ -163,213 +172,77 @@ export function useUserSession() {
       }, 5e3);
     });
   }
-  function isSafeLocalRedirect(redirect) {
-    if (typeof redirect !== "string")
-      return;
-    if (!redirect.startsWith("/") || redirect.startsWith("//"))
-      return;
-    return redirect;
-  }
-  function resolvePostAuthRedirect() {
-    const authConfig = runtimeConfig.public.auth;
-    const redirectQueryKey = authConfig?.redirectQueryKey ?? "redirect";
-    const queryRedirect = requestURL.searchParams?.get(redirectQueryKey);
-    const safeQueryRedirect = isSafeLocalRedirect(queryRedirect);
-    if (safeQueryRedirect)
-      return safeQueryRedirect;
-    return isSafeLocalRedirect(authConfig?.redirects?.authenticated);
-  }
-  function resolvePostAuthSuccessRedirect() {
-    const target = resolvePostAuthRedirect();
-    if (!target)
-      return;
-    return async () => {
-      await navigateTo(target);
-    };
-  }
-  function withFallbackSocialCallbackURL(data) {
-    const callbackURL = resolvePostAuthRedirect();
-    if (!callbackURL)
-      return data;
-    if (!isRecord(data))
-      return { callbackURL };
-    if (typeof data.callbackURL === "string")
-      return data;
-    return {
-      ...data,
-      callbackURL
-    };
-  }
-  function wrapOnSuccess(cb) {
-    return async (ctx) => {
-      await fetchSession({ force: true });
-      if (!loggedIn.value)
-        await waitForSession();
-      await nextTick();
-      await cb(ctx);
-    };
-  }
-  function wrapAuthMethod(method, wrapOptions = {}) {
-    return (async (...args) => {
-      const originalData = args[0];
-      const options = args[1];
-      const data = wrapOptions.transformData?.(originalData, options) ?? originalData;
-      const dataRecord = isRecord(data) ? data : void 0;
-      const optionsRecord = isRecord(options) ? options : void 0;
-      if (wrapOptions.shouldSkipSessionSync?.(data, options))
-        return method(data, options);
-      const fetchOptions = isRecord(dataRecord?.fetchOptions) ? dataRecord.fetchOptions : void 0;
-      const nestedOnSuccess = fetchOptions?.onSuccess;
-      const topLevelOnSuccess = optionsRecord?.onSuccess;
-      const fallbackOnSuccess = resolvePostAuthSuccessRedirect();
-      const wrappedFallbackOnSuccess = fallbackOnSuccess && wrapOnSuccess(async () => {
-        if (!loggedIn.value)
-          return;
-        await fallbackOnSuccess();
-      });
-      if (typeof nestedOnSuccess === "function") {
-        const nextData = {
-          ...dataRecord,
-          fetchOptions: {
-            ...fetchOptions,
-            onSuccess: wrapOnSuccess(nestedOnSuccess)
-          }
-        };
-        return method(nextData, options);
-      }
-      if (typeof topLevelOnSuccess === "function") {
-        const nextOptions = {
-          ...optionsRecord,
-          onSuccess: wrapOnSuccess(topLevelOnSuccess)
-        };
-        return method(data, nextOptions);
-      }
-      if (wrappedFallbackOnSuccess) {
-        if (fetchOptions) {
-          const nextData = {
-            ...dataRecord,
-            fetchOptions: {
-              ...fetchOptions,
-              onSuccess: wrappedFallbackOnSuccess
-            }
-          };
-          return method(nextData, options);
-        }
-        const nextOptions = {
-          ...optionsRecord,
-          onSuccess: wrappedFallbackOnSuccess
-        };
-        return method(data, nextOptions);
-      }
-      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;
-      const shouldSkipSessionSync = prop === "social" ? (data) => {
-        const socialData = isRecord(data) ? data : void 0;
-        return socialData?.disableRedirect !== true;
-      } : void 0;
-      const transformData = prop === "social" ? withFallbackSocialCallbackURL : void 0;
-      return wrapAuthMethod(
-        (...args) => targetRecord[prop](...args),
-        { shouldSkipSessionSync, transformData }
-      );
-    }
-  }) : 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 (runtimeFlags.server) {
-      try {
-        const headers = options.headers || useRequestHeaders(["cookie"]);
-        const requestFetch = useRequestFetch();
-        const data = await requestFetch("/api/auth/get-session", { headers });
-        if (data?.session && data?.user) {
-          const { token: _, ...safeSession } = data.session;
-          session.value = safeSession;
-          user.value = data.user;
-        } else {
-          clearSession();
-        }
-      } catch {
-        clearSession();
-      } finally {
-        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;
-      }
-    }
-  }
-  if (runtimeFlags.client && client && shouldSkipInitialClientSessionFetch.value) {
-    ensureSessionSignalListener(client, () => fetchSession({ force: true }));
+  if (runtimeFlags.client && rawClient && shouldSkipInitialClientSessionFetch.value) {
+    ensureSessionSignalListener(rawClient, () => fetchSession({ force: true }));
   }
   async function signOut(options) {
-    if (!client)
+    if (!rawClient)
       throw new Error("signOut can only be called on client-side");
-    await client.signOut();
-    clearSession();
-    if (options?.onSuccess) {
-      await options.onSuccess();
+    if (_signOutPromise) {
+      await _signOutPromise;
       return;
     }
-    const authConfig = runtimeConfig.public.auth;
-    const logoutRedirect = authConfig?.redirects?.logout;
-    if (logoutRedirect)
-      await navigateTo(logoutRedirect);
+    _signOutPromise = (async () => {
+      await rawClient.signOut();
+      clearSession();
+      if (options?.onSuccess) {
+        await options.onSuccess();
+        return;
+      }
+      const authConfig = runtimeConfig.public.auth;
+      const logoutRedirect = authConfig?.redirects?.logout;
+      if (logoutRedirect) {
+        await nextTick();
+        await navigateTo(logoutRedirect);
+      }
+    })().finally(() => {
+      _signOutPromise = null;
+    });
+    await _signOutPromise;
   }
   return {
-    client,
     session,
     user,
     loggedIn,
     ready,
-    signIn,
-    signUp,
     signOut,
     waitForSession,
     fetchSession,
     updateUser
   };
 }
+export function useAuthActionNamespaces() {
+  const rawClient = useRawAuthClient();
+  const auth = useUserSession();
+  const requestURL = useRequestURL();
+  const wrapDeps = {
+    fetchSession: auth.fetchSession,
+    loggedIn: auth.loggedIn,
+    waitForSession: auth.waitForSession,
+    resolvePostAuthSuccessRedirect: () => resolvePostAuthSuccessRedirect(requestURL)
+  };
+  const signIn = rawClient?.signIn ? createVueSafeAuthFacade((prop) => {
+    const targetRecord = rawClient.signIn;
+    const method = targetRecord[prop];
+    if (typeof method !== "function")
+      return method;
+    const shouldSkipSessionSync = prop === "social" ? (data) => {
+      const socialData = isRecord(data) ? data : void 0;
+      return socialData?.disableRedirect !== true;
+    } : void 0;
+    const transformData = prop === "social" ? (data) => withFallbackSocialCallbackURL(data, requestURL) : void 0;
+    return wrapAuthMethod(
+      (...args) => targetRecord[prop](...args),
+      wrapDeps,
+      { shouldSkipSessionSync, transformData }
+    );
+  }) : _signInServerOnly;
+  const signUp = rawClient?.signUp ? createVueSafeAuthFacade((prop) => {
+    const targetRecord = rawClient.signUp;
+    const method = targetRecord[prop];
+    if (typeof method !== "function")
+      return method;
+    return wrapAuthMethod((...args) => targetRecord[prop](...args), wrapDeps);
+  }) : _signUpServerOnly;
+  return { signIn, signUp };
+}

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

@@ -0,0 +1,3 @@
+import type { UseUserSessionReturn } from './useUserSession.js';
+export type UseUserSessionStateReturn = UseUserSessionReturn;
+export declare function useUserSessionState(): UseUserSessionStateReturn;

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

@@ -0,0 +1,4 @@
+import { useUserSession } from "./useUserSession.js";
+export function useUserSessionState() {
+  return useUserSession();
+}

package/dist/runtime/app/internal/auth-action-error.js

@@ -1,7 +1,5 @@
+import { isRecord } from "./utils.js";
 export const DEFAULT_AUTH_ACTION_ERROR_MESSAGE = "Request failed. Please try again.";
-function isRecord(value) {
-  return Boolean(value && typeof value === "object");
-}
 function getMessage(value) {
   if (value instanceof Error)
     return value.message;

package/dist/runtime/app/internal/auth-action-handles.js

@@ -1,8 +1,6 @@
 import { ref } from "#imports";
 import { normalizeAuthActionError } from "./auth-action-error.js";
-function isRecord(value) {
-  return Boolean(value && typeof value === "object");
-}
+import { isRecord } from "./utils.js";
 function isErrorResult(value) {
   if (!isRecord(value))
     return false;

package/dist/runtime/app/internal/redirect-helpers.d.ts

@@ -0,0 +1,4 @@
+export declare function isSafeLocalRedirect(redirect: unknown): string | undefined;
+export declare function resolvePostAuthRedirect(requestURL: URL): string | undefined;
+export declare function resolvePostAuthSuccessRedirect(requestURL: URL): (() => Promise<void>) | undefined;
+export declare function withFallbackSocialCallbackURL(data: unknown, requestURL: URL): unknown;

package/dist/runtime/app/internal/redirect-helpers.js

@@ -0,0 +1,37 @@
+import { navigateTo, useRuntimeConfig } from "#imports";
+import { isRecord } from "./utils.js";
+export function isSafeLocalRedirect(redirect) {
+  if (typeof redirect !== "string")
+    return;
+  if (!redirect.startsWith("/") || redirect.startsWith("//"))
+    return;
+  return redirect;
+}
+export function resolvePostAuthRedirect(requestURL) {
+  const runtimeConfig = useRuntimeConfig();
+  const authConfig = runtimeConfig.public.auth;
+  const redirectQueryKey = authConfig?.redirectQueryKey ?? "redirect";
+  const queryRedirect = requestURL.searchParams?.get(redirectQueryKey);
+  const safeQueryRedirect = isSafeLocalRedirect(queryRedirect);
+  if (safeQueryRedirect)
+    return safeQueryRedirect;
+  return isSafeLocalRedirect(authConfig?.redirects?.authenticated);
+}
+export function resolvePostAuthSuccessRedirect(requestURL) {
+  const target = resolvePostAuthRedirect(requestURL);
+  if (!target)
+    return;
+  return async () => {
+    await navigateTo(target);
+  };
+}
+export function withFallbackSocialCallbackURL(data, requestURL) {
+  const callbackURL = resolvePostAuthRedirect(requestURL);
+  if (!callbackURL)
+    return data;
+  if (!isRecord(data))
+    return { callbackURL };
+  if (typeof data.callbackURL === "string")
+    return data;
+  return { ...data, callbackURL };
+}

package/dist/runtime/app/internal/session-fetch.d.ts

@@ -0,0 +1,12 @@
+import type { Ref } from 'vue';
+import type { AppAuthClient, AuthSession, AuthUser } from '#nuxt-better-auth';
+export declare function stripToken(session: AuthSession & {
+    token?: string;
+}): AuthSession;
+export declare function fetchSessionServer(session: Ref<AuthSession | null>, user: Ref<AuthUser | null>, authReady: Ref<boolean>, options?: {
+    headers?: HeadersInit;
+}): Promise<void>;
+export declare function fetchSessionClient(client: AppAuthClient, session: Ref<AuthSession | null>, user: Ref<AuthUser | null>, authReady: Ref<boolean>, options?: {
+    headers?: HeadersInit;
+    force?: boolean;
+}): Promise<void>;