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

package/dist/module.d.mts

@@ -3,7 +3,7 @@ import { Nuxt } from '@nuxt/schema';
 import { BetterAuthModuleOptions } from '../dist/runtime/config.js';
 export { BetterAuthModuleOptions, defineClientAuth, defineServerAuth } from '../dist/runtime/config.js';
 import { BetterAuthOptions } from 'better-auth';
-export { AppSession, Auth, AuthActionError, AuthMeta, AuthMode, AuthRouteRules, AuthSession, AuthUser, InferSession, InferUser, RequireSessionOptions, ServerAuthContext, UserMatch } from '../dist/runtime/types.js';
+export { AppSession, Auth, AuthActionError, AuthMeta, AuthMode, AuthRouteRules, AuthSession, AuthSocialProviderId, AuthUser, InferSession, InferUser, RequireSessionOptions, ServerAuthContext, UserMatch } from '../dist/runtime/types.js';
 
 interface RuntimeDefineServerAuthFn {
     (...args: unknown[]): unknown;

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@onmax/nuxt-better-auth",
-  "version": "0.0.2-alpha.29",
+  "version": "0.0.2-alpha.30",
   "configKey": "auth",
   "compatibility": {
     "nuxt": ">=4.0.0"

package/dist/module.mjs

@@ -10,7 +10,7 @@ import { randomBytes } from 'node:crypto';
 import { isCI, isTest } from 'std-env';
 export { defineClientAuth, defineServerAuth } from '../dist/runtime/config.js';
 
-const version = "0.0.2-alpha.29";
+const version = "0.0.2-alpha.30";
 
 function resolveDatabaseProvider(input) {
   const enabledProviders = Object.entries(input.providers).filter(([_id, provider]) => provider.isEnabled?.(input.context) ?? true);
@@ -88,7 +88,8 @@ async function registerDevtools(input) {
 }
 function registerRouteRulesMetaHook(nuxt) {
   nuxt.hook("pages:extend", (pages) => {
-    const routeRules = nuxt.options.routeRules || {};
+    const options = nuxt.options;
+    const routeRules = options.nitro?.routeRules || options.routeRules || {};
     if (!Object.keys(routeRules).length)
       return;
     const matcher = toRouteMatcher(createRouter({ routes: routeRules }));
@@ -162,7 +163,7 @@ function setupRuntimeConfig(input) {
     const siteUrl = nuxt.options.runtimeConfig.public.siteUrl;
     if (!siteUrl)
       consola.warn("clientOnly mode: set runtimeConfig.public.siteUrl (or NUXT_PUBLIC_SITE_URL) to your frontend URL");
-    consola.info("clientOnly mode enabled - server utilities (serverAuth, getAppSession, getUserSession, requireUserSession) are not available");
+    consola.info("clientOnly mode enabled - server utilities (serverAuth, getRequestSession, getUserSession, requireUserSession) are not available");
     return { useHubKV, secondaryStorageEnabled };
   }
   const currentSecret = nuxt.options.runtimeConfig.betterAuthSecret;
@@ -203,7 +204,10 @@ async function generateDrizzleSchema(authOptions, dialect, schemaOptions) {
       adapterConfig: { usePlural: schemaOptions?.usePlural ?? false }
     }
   };
-  const result = await generateDrizzleSchema$1({ adapter, options });
+  const result = await generateDrizzleSchema$1({
+    adapter,
+    options
+  });
   if (!result.code) {
     throw new Error(`Schema generation returned empty result for ${dialect}`);
   }
@@ -254,7 +258,7 @@ async function loadUserAuthConfig(configPath, throwOnError = false) {
 
 function resolveSchemaSecondaryStorageInjection(hubSecondaryStorage, userHasSecondaryStorage, isProduction) {
   if (hubSecondaryStorage === true)
-    return { inject: true };
+    return { inject: false };
   if (hubSecondaryStorage !== "custom")
     return { inject: false };
   if (userHasSecondaryStorage)
@@ -541,11 +545,191 @@ declare module '@onmax/nuxt-better-auth/config' {
   export function defineServerAuth<const R>(config: (ctx: _AugmentedServerAuthContext) => R & ServerAuthConfig): (ctx: _AugmentedServerAuthContext) => R
   export function defineServerAuth<const R>(config: R & ServerAuthConfig): (ctx: _AugmentedServerAuthContext) => R
 }
+`
+  }, { nuxt: true, nitro: true, node: true });
+  addTypeTemplate({
+    filename: "types/nuxt-better-auth-social-providers.d.ts",
+    getContents: () => `
+import type createServerAuth from '${serverConfigPath}'
+
+type _RawConfig = ReturnType<typeof createServerAuth>
+type _RawSocialProviders = _RawConfig extends { socialProviders: infer S } ? S : _RawConfig extends { socialProviders?: infer S } ? S : {}
+type _SocialProviderIds = Extract<keyof NonNullable<_RawSocialProviders>, string>
+
+declare module '#nuxt-better-auth' {
+  interface AuthSocialProviderRegistry {
+    ids: _SocialProviderIds
+  }
+}
 `
   }, { nuxt: true, nitro: true, node: true });
   addTypeTemplate({
     filename: "types/nuxt-better-auth-nitro.d.ts",
     getContents: () => `
+import type createServerAuth from '${serverConfigPath}'
+import type { BetterAuthOptions } from 'better-auth'
+import type { getEndpoints } from 'better-auth/api'
+import type { Serialize, Simplify } from 'nitropack/types'
+import type { FetchError } from 'ofetch'
+
+type _RawConfig = ReturnType<typeof createServerAuth>
+type _RawPlugins = _RawConfig extends { plugins: infer P } ? P : _RawConfig extends { plugins?: infer P } ? P : []
+type _Config = Omit<BetterAuthOptions, 'plugins'> & Omit<_RawConfig, 'plugins'> & {
+  plugins?: _RawPlugins
+}
+
+type _AuthApi = ReturnType<typeof getEndpoints<_Config>>['api']
+type _NormalizeMethod<M extends string> = M extends '*' ? 'default' : Lowercase<M>
+type _RouteMethodFromOption<M> = M extends readonly (infer T)[]
+  ? _NormalizeMethod<Extract<T, string>>
+  : M extends string
+      ? _NormalizeMethod<M>
+      : 'default'
+type _RouteMethodFromEndpoint<E> = E extends { options: { method: infer M } } ? _RouteMethodFromOption<M> : 'default'
+type _RoutePathFromEndpoint<E> = E extends { path: infer P extends string }
+  ? string extends P
+      ? never
+      : \`/api/auth\${P}\`
+  : never
+type _RouteResponseFromEndpoint<E> = E extends (...args: any[]) => Promise<infer R> ? Simplify<Serialize<Awaited<R>>> : never
+type _RouteDefaultResponse<E> = never
+type _UnionToIntersection<U> = (U extends unknown ? (value: U) => void : never) extends (value: infer I) => void ? I : never
+
+type _CoreAuthInternalApi = {
+  [K in keyof _AuthApi as _RoutePathFromEndpoint<_AuthApi[K]>]: {
+    [M in _RouteMethodFromEndpoint<_AuthApi[K]> | 'default']: M extends 'default' ? _RouteDefaultResponse<_AuthApi[K]> : _RouteResponseFromEndpoint<_AuthApi[K]>
+  }
+}
+type _PluginEndpointMaps<Plugins> = Plugins extends readonly (infer Plugin)[]
+  ? Plugin extends { endpoints: infer Endpoints extends Record<string, unknown> }
+      ? {
+          [K in keyof Endpoints as _RoutePathFromEndpoint<Endpoints[K]>]: {
+            [M in _RouteMethodFromEndpoint<Endpoints[K]> | 'default']: M extends 'default' ? _RouteDefaultResponse<Endpoints[K]> : _RouteResponseFromEndpoint<Endpoints[K]>
+          }
+        }
+      : {}
+  : Plugins extends (infer Plugin)[]
+      ? Plugin extends { endpoints: infer Endpoints extends Record<string, unknown> }
+          ? {
+              [K in keyof Endpoints as _RoutePathFromEndpoint<Endpoints[K]>]: {
+                [M in _RouteMethodFromEndpoint<Endpoints[K]> | 'default']: M extends 'default' ? _RouteDefaultResponse<Endpoints[K]> : _RouteResponseFromEndpoint<Endpoints[K]>
+              }
+            }
+          : {}
+      : {}
+type _PluginAuthInternalApi = _UnionToIntersection<_PluginEndpointMaps<_RawPlugins>>
+type _GeneratedAuthInternalApi = _CoreAuthInternalApi & _PluginAuthInternalApi
+
+type _RoutePathToRequestPath<Path extends string> = Path extends \`\${infer Prefix}:\${string}/\${infer Rest}\`
+  ? \`\${Prefix}\${string}/\${_RoutePathToRequestPath<Rest>}\`
+  : Path extends \`\${infer Prefix}:\${string}\`
+      ? \`\${Prefix}\${string}\`
+      : Path
+type _AuthApiPatternPath = Extract<keyof _GeneratedAuthInternalApi, string>
+type _AuthApiRequestPath = _RoutePathToRequestPath<_AuthApiPatternPath>
+type _AuthPatternFromRequestPath<Path extends string> = {
+  [Pattern in _AuthApiPatternPath]: Path extends _RoutePathToRequestPath<Pattern> ? Pattern : never
+}[_AuthApiPatternPath]
+type _AuthEndpointMethod<Path extends _AuthApiRequestPath> = Extract<keyof _GeneratedAuthInternalApi[_AuthPatternFromRequestPath<Path>], string>
+
+type _AuthFetchMethod<Path extends _AuthApiRequestPath> = Extract<Exclude<import('nitropack/types').NitroFetchOptions<Path>['method'], undefined>, string>
+type _AuthFetchDefaultMethod<Path extends _AuthApiRequestPath> = 'get'
+type _AuthFetchResolvedMethod<Path extends _AuthApiRequestPath, Method extends string> = Lowercase<Method> extends _AuthEndpointMethod<Path>
+  ? Lowercase<Method>
+  : never
+type _AuthFetchResult<Path extends _AuthApiRequestPath, Method extends string> = _GeneratedAuthInternalApi[_AuthPatternFromRequestPath<Path>][_AuthFetchResolvedMethod<Path, Method>]
+
+declare module '#nuxt-better-auth' {
+  export type AuthApiInternalRoutes = _GeneratedAuthInternalApi
+  export type AuthApiEndpointPatternPath = _AuthApiPatternPath
+  export type AuthApiEndpointPath = _AuthApiRequestPath
+  export type AuthApiEndpointMethod<Path extends AuthApiEndpointPath> = _AuthEndpointMethod<Path>
+  export type AuthApiEndpointResponse<
+    Path extends AuthApiEndpointPath,
+    Method extends AuthApiEndpointMethod<Path> = AuthApiEndpointMethod<Path>,
+  > = AuthApiInternalRoutes[_AuthPatternFromRequestPath<Path>][Method]
+}
+
+declare module 'nuxt/dist/app/composables/fetch' {
+  export function useFetch<
+    ErrorT = FetchError,
+    Path extends import('#nuxt-better-auth').AuthApiEndpointPath = import('#nuxt-better-auth').AuthApiEndpointPath,
+    Method extends _AuthFetchMethod<Path> = _AuthFetchDefaultMethod<Path>,
+    _ResT = _AuthFetchResult<Path, Method>,
+    DataT = _ResT,
+    PickKeys extends import('nuxt/dist/app/composables/asyncData').KeysOf<DataT> = import('nuxt/dist/app/composables/asyncData').KeysOf<DataT>,
+    DefaultT = undefined,
+  >(request: import('vue').Ref<Path> | Path | (() => Path), opts?: import('nuxt/dist/app/composables/fetch').UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, Path, Method>): import('nuxt/dist/app/composables/asyncData').AsyncData<import('nuxt/dist/app/composables/asyncData').PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>
+  export function useFetch<
+    ErrorT = FetchError,
+    Path extends import('#nuxt-better-auth').AuthApiEndpointPath = import('#nuxt-better-auth').AuthApiEndpointPath,
+    Method extends _AuthFetchMethod<Path> = _AuthFetchDefaultMethod<Path>,
+    _ResT = _AuthFetchResult<Path, Method>,
+    DataT = _ResT,
+    PickKeys extends import('nuxt/dist/app/composables/asyncData').KeysOf<DataT> = import('nuxt/dist/app/composables/asyncData').KeysOf<DataT>,
+    DefaultT = DataT,
+  >(request: import('vue').Ref<Path> | Path | (() => Path), opts?: import('nuxt/dist/app/composables/fetch').UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, Path, Method>): import('nuxt/dist/app/composables/asyncData').AsyncData<import('nuxt/dist/app/composables/asyncData').PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>
+
+  export function useLazyFetch<
+    ErrorT = FetchError,
+    Path extends import('#nuxt-better-auth').AuthApiEndpointPath = import('#nuxt-better-auth').AuthApiEndpointPath,
+    Method extends _AuthFetchMethod<Path> = _AuthFetchDefaultMethod<Path>,
+    _ResT = _AuthFetchResult<Path, Method>,
+    DataT = _ResT,
+    PickKeys extends import('nuxt/dist/app/composables/asyncData').KeysOf<DataT> = import('nuxt/dist/app/composables/asyncData').KeysOf<DataT>,
+    DefaultT = undefined,
+  >(request: import('vue').Ref<Path> | Path | (() => Path), opts?: Omit<import('nuxt/dist/app/composables/fetch').UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, Path, Method>, 'lazy'>): import('nuxt/dist/app/composables/asyncData').AsyncData<import('nuxt/dist/app/composables/asyncData').PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>
+  export function useLazyFetch<
+    ErrorT = FetchError,
+    Path extends import('#nuxt-better-auth').AuthApiEndpointPath = import('#nuxt-better-auth').AuthApiEndpointPath,
+    Method extends _AuthFetchMethod<Path> = _AuthFetchDefaultMethod<Path>,
+    _ResT = _AuthFetchResult<Path, Method>,
+    DataT = _ResT,
+    PickKeys extends import('nuxt/dist/app/composables/asyncData').KeysOf<DataT> = import('nuxt/dist/app/composables/asyncData').KeysOf<DataT>,
+    DefaultT = DataT,
+  >(request: import('vue').Ref<Path> | Path | (() => Path), opts?: Omit<import('nuxt/dist/app/composables/fetch').UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, Path, Method>, 'lazy'>): import('nuxt/dist/app/composables/asyncData').AsyncData<import('nuxt/dist/app/composables/asyncData').PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>
+}
+
+declare module 'nuxt/app' {
+  export function useFetch<
+    ErrorT = FetchError,
+    Path extends import('#nuxt-better-auth').AuthApiEndpointPath = import('#nuxt-better-auth').AuthApiEndpointPath,
+    Method extends _AuthFetchMethod<Path> = _AuthFetchDefaultMethod<Path>,
+    _ResT = _AuthFetchResult<Path, Method>,
+    DataT = _ResT,
+    PickKeys extends import('nuxt/dist/app/composables/asyncData').KeysOf<DataT> = import('nuxt/dist/app/composables/asyncData').KeysOf<DataT>,
+    DefaultT = undefined,
+  >(request: import('vue').Ref<Path> | Path | (() => Path), opts?: import('nuxt/dist/app/composables/fetch').UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, Path, Method>): import('nuxt/dist/app/composables/asyncData').AsyncData<import('nuxt/dist/app/composables/asyncData').PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>
+  export function useFetch<
+    ErrorT = FetchError,
+    Path extends import('#nuxt-better-auth').AuthApiEndpointPath = import('#nuxt-better-auth').AuthApiEndpointPath,
+    Method extends _AuthFetchMethod<Path> = _AuthFetchDefaultMethod<Path>,
+    _ResT = _AuthFetchResult<Path, Method>,
+    DataT = _ResT,
+    PickKeys extends import('nuxt/dist/app/composables/asyncData').KeysOf<DataT> = import('nuxt/dist/app/composables/asyncData').KeysOf<DataT>,
+    DefaultT = DataT,
+  >(request: import('vue').Ref<Path> | Path | (() => Path), opts?: import('nuxt/dist/app/composables/fetch').UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, Path, Method>): import('nuxt/dist/app/composables/asyncData').AsyncData<import('nuxt/dist/app/composables/asyncData').PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>
+
+  export function useLazyFetch<
+    ErrorT = FetchError,
+    Path extends import('#nuxt-better-auth').AuthApiEndpointPath = import('#nuxt-better-auth').AuthApiEndpointPath,
+    Method extends _AuthFetchMethod<Path> = _AuthFetchDefaultMethod<Path>,
+    _ResT = _AuthFetchResult<Path, Method>,
+    DataT = _ResT,
+    PickKeys extends import('nuxt/dist/app/composables/asyncData').KeysOf<DataT> = import('nuxt/dist/app/composables/asyncData').KeysOf<DataT>,
+    DefaultT = undefined,
+  >(request: import('vue').Ref<Path> | Path | (() => Path), opts?: Omit<import('nuxt/dist/app/composables/fetch').UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, Path, Method>, 'lazy'>): import('nuxt/dist/app/composables/asyncData').AsyncData<import('nuxt/dist/app/composables/asyncData').PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>
+  export function useLazyFetch<
+    ErrorT = FetchError,
+    Path extends import('#nuxt-better-auth').AuthApiEndpointPath = import('#nuxt-better-auth').AuthApiEndpointPath,
+    Method extends _AuthFetchMethod<Path> = _AuthFetchDefaultMethod<Path>,
+    _ResT = _AuthFetchResult<Path, Method>,
+    DataT = _ResT,
+    PickKeys extends import('nuxt/dist/app/composables/asyncData').KeysOf<DataT> = import('nuxt/dist/app/composables/asyncData').KeysOf<DataT>,
+    DefaultT = DataT,
+  >(request: import('vue').Ref<Path> | Path | (() => Path), opts?: Omit<import('nuxt/dist/app/composables/fetch').UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, Path, Method>, 'lazy'>): import('nuxt/dist/app/composables/asyncData').AsyncData<import('nuxt/dist/app/composables/asyncData').PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>
+}
+
 declare module 'nitropack' {
   interface NitroRouteRules {
     auth?: import('${runtimeTypesPath}').AuthMeta
@@ -553,6 +737,7 @@ declare module 'nitropack' {
   interface NitroRouteConfig {
     auth?: import('${runtimeTypesPath}').AuthMeta
   }
+  interface InternalApi extends _GeneratedAuthInternalApi {}
 }
 declare module 'nitropack/types' {
   interface NitroRouteRules {
@@ -561,6 +746,7 @@ declare module 'nitropack/types' {
   interface NitroRouteConfig {
     auth?: import('${runtimeTypesPath}').AuthMeta
   }
+  interface InternalApi extends _GeneratedAuthInternalApi {}
 }
 export {}
 `
@@ -572,10 +758,10 @@ function registerSharedTypeTemplates(input) {
     getContents: () => `
 import type { AppSession } from '${input.runtimeTypesAugmentPath}'
 export * from '${input.runtimeTypesAugmentPath}'
-export type { AuthMeta, AuthMode, AuthRouteRules, Auth, InferUser, InferSession } from '${input.runtimeTypesPath}'
+export type { AuthMeta, AuthMode, AuthRouteRules, AuthSocialProviderId, Auth, InferUser, InferSession } from '${input.runtimeTypesPath}'
 declare module 'h3' {
   interface H3EventContext {
-    appSession?: AppSession | null
+    requestSession?: AppSession | null
   }
 }
 `
@@ -766,6 +952,21 @@ export { schema }
       runtimeTypesPath: resolver.resolve("./runtime/types"),
       clientConfigPath
     });
+    const runtimeRouteRulesSource = nuxt.options.nitro?.routeRules || nuxt.options.routeRules || {};
+    const authRouteRules = Object.fromEntries(
+      Object.entries(runtimeRouteRulesSource).flatMap(([path, rule]) => {
+        if (!rule || typeof rule !== "object" || !("auth" in rule))
+          return [];
+        return [[path, { auth: rule.auth }]];
+      })
+    );
+    const authRouteRulesTemplate = addTemplate({
+      filename: "better-auth/route-rules.mjs",
+      getContents: () => `export const authRouteRules = ${JSON.stringify(authRouteRules, null, 2)}
+`,
+      write: true
+    });
+    nuxt.options.alias["#auth/route-rules"] = authRouteRulesTemplate.dst;
     registerTemplateHmrHook(nuxt);
     registerServerRuntime({ clientOnly, resolve: resolver.resolve });
     registerAuthMiddlewareHook(nuxt, resolver.resolve);

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

@@ -0,0 +1,2 @@
+import type { UserAuthActionHandle } from '../internal/auth-action-handles.js';
+export declare function useAction<TArgs extends unknown[], TResult>(runner: (...args: TArgs) => Promise<TResult>): UserAuthActionHandle<TArgs, TResult>;

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

@@ -0,0 +1,6 @@
+import { createActionHandle } from "../internal/auth-action-handles.js";
+export function useAction(runner) {
+  if (typeof runner !== "function")
+    throw new TypeError("useAction(runner) requires an async function");
+  return createActionHandle(() => runner);
+}

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

@@ -0,0 +1,6 @@
+import type { AsyncDataOptions } from '#app';
+import { useAuthRequestFetch } from './useAuthRequestFetch.js';
+export interface UseAuthAsyncDataOptions<T> extends Omit<AsyncDataOptions<T | null>, 'default'> {
+    requireAuth?: boolean;
+}
+export declare function useAuthAsyncData<T>(key: string, fetcher: (requestFetch: ReturnType<typeof useAuthRequestFetch>) => Promise<T>, options?: UseAuthAsyncDataOptions<T>): any;

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

@@ -0,0 +1,16 @@
+import { useAsyncData } from "#imports";
+import { useAuthRequestFetch } from "./useAuthRequestFetch.js";
+import { useUserSession } from "./useUserSession.js";
+export function useAuthAsyncData(key, fetcher, options = {}) {
+  const requestFetch = useAuthRequestFetch();
+  const { loggedIn } = useUserSession();
+  const { requireAuth = true, ...asyncDataOptions } = options;
+  return useAsyncData(key, async () => {
+    if (requireAuth && !loggedIn.value)
+      return null;
+    return await fetcher(requestFetch);
+  }, {
+    default: () => null,
+    ...asyncDataOptions
+  });
+}

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,15 @@
+import { useUserSession } from "#imports";
+import { useAction } from "./useAction.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();
+    if (!client)
+      throw new Error("Auth client is unavailable. This action can only run on client-side.");
+    const method = select(client);
+    if (typeof method !== "function")
+      throw new TypeError("useAuthClientAction(select) must resolve to a function");
+    return method(...args);
+  });
+}

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

@@ -0,0 +1,11 @@
+import type { AuthApiEndpointMethod, AuthApiEndpointPath, AuthApiEndpointResponse } from '#nuxt-better-auth';
+import type { NitroFetchOptions } from 'nitropack/types';
+import { useRequestFetch } from '#imports';
+type AuthRequestFetchExtractedMethod<Options> = Options extends undefined ? 'get' : Lowercase<Extract<Exclude<Options extends {
+    method?: infer Method;
+} ? Method : never, undefined>, string>> extends infer NormalizedMethod extends string ? NormalizedMethod : 'get';
+type AuthRequestFetchMethodFromOptions<Path extends AuthApiEndpointPath, Options> = NitroFetchOptions<Path> extends Options ? 'get' : AuthRequestFetchExtractedMethod<Options>;
+type AuthRequestFetchResolvedMethod<Path extends AuthApiEndpointPath, Options> = Extract<AuthRequestFetchMethodFromOptions<Path, Options>, AuthApiEndpointMethod<Path>> extends infer Method extends string ? Method : never;
+type AuthRequestFetch = <Path extends AuthApiEndpointPath, Options extends NitroFetchOptions<Path> = NitroFetchOptions<Path>>(request: Path, opts?: Options) => Promise<AuthApiEndpointResponse<Path, Extract<AuthRequestFetchResolvedMethod<Path, Options>, AuthApiEndpointMethod<Path>>>>;
+export declare function useAuthRequestFetch(): AuthRequestFetch & ReturnType<typeof useRequestFetch>;
+export {};

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

@@ -0,0 +1,4 @@
+import { useRequestFetch } from "#imports";
+export function useAuthRequestFetch() {
+  return useRequestFetch();
+}

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

@@ -0,0 +1,16 @@
+import type { AppAuthClient, AuthSocialProviderRegistry } from '#nuxt-better-auth';
+import type { ActionHandleFor } from '../internal/auth-action-handles.js';
+type SignIn = NonNullable<AppAuthClient>['signIn'];
+type AuthSocialProviderId = AuthSocialProviderRegistry extends {
+    ids: infer T;
+} ? Extract<T, string> : never;
+type TypedSocialMethod<Method> = Method extends (data: infer Data, ...rest: infer Rest) => Promise<infer Result> ? (data: Omit<Extract<Data, Record<string, unknown>>, 'provider'> & {
+    provider: AuthSocialProviderId;
+}, ...rest: Rest) => Promise<Result> : Method;
+type SignInWithTypedSocial = Omit<SignIn, 'social'> & (SignIn extends {
+    social: infer SocialMethod;
+} ? {
+    social: TypedSocialMethod<SocialMethod>;
+} : unknown);
+export declare function useSignIn<MethodKey extends keyof SignInWithTypedSocial>(method: MethodKey): ActionHandleFor<SignInWithTypedSocial[MethodKey]>;
+export {};

package/dist/runtime/app/composables/{useUserSignIn.js → useSignIn.js}

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

package/dist/runtime/app/composables/{useUserSignUp.d.ts → useSignUp.d.ts}

@@ -1,5 +1,5 @@
 import type { AppAuthClient } from '#nuxt-better-auth';
 import type { ActionHandleFor } from '../internal/auth-action-handles.js';
 type SignUp = NonNullable<AppAuthClient>['signUp'];
-export declare function useUserSignUp<MethodKey extends keyof SignUp>(method: MethodKey): ActionHandleFor<SignUp[MethodKey]>;
+export declare function useSignUp<MethodKey extends keyof SignUp>(method: MethodKey): ActionHandleFor<SignUp[MethodKey]>;
 export {};

package/dist/runtime/app/composables/{useUserSignUp.js → useSignUp.js}

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

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

@@ -1,5 +1,5 @@
 import createAppAuthClient from "#auth/client";
-import { computed, navigateTo, nextTick, useNuxtApp, useRequestHeaders, useRequestURL, useRuntimeConfig, useState, watch } from "#imports";
+import { computed, navigateTo, nextTick, useNuxtApp, useRequestFetch, useRequestHeaders, useRequestURL, useRuntimeConfig, useState, watch } from "#imports";
 import { normalizeAuthActionError } from "../internal/auth-action-error.js";
 let _sessionSignalListenerBound = false;
 let _client = null;
@@ -39,13 +39,23 @@ export function useUserSession() {
   const runtimeFlags = getRuntimeFlags();
   const runtimeConfig = useRuntimeConfig();
   const requestURL = useRequestURL();
+  const nuxtApp = useNuxtApp();
   const client = runtimeFlags.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 prerenderReadyResetQueued = useState("auth:prerender-ready-reset-queued", () => false);
+  const hydrationReconcileQueued = useState("auth:hydration-reconcile-queued", () => false);
   const ready = computed(() => authReady.value);
   const loggedIn = computed(() => Boolean(session.value && user.value));
-  const nuxtApp = useNuxtApp();
+  const isPrerenderedPayload = computed(() => Boolean(nuxtApp.payload.prerenderedAt || nuxtApp.payload.isCached));
+  const isPrerenderHydrationEmptySnapshot = computed(() => {
+    if (!runtimeFlags.client)
+      return false;
+    if (!nuxtApp.isHydrating || !nuxtApp.payload.serverRendered || !isPrerenderedPayload.value)
+      return false;
+    return !session.value && !user.value;
+  });
   const skipHydratedSsrGetSession = computed(() => {
     const authConfig = runtimeConfig.public.auth;
     return Boolean(authConfig?.session?.skipHydratedSsrGetSession);
@@ -57,10 +67,21 @@ export function useUserSession() {
       return false;
     if (!nuxtApp.payload.serverRendered)
       return false;
-    if (nuxtApp.payload.prerenderedAt || nuxtApp.payload.isCached)
+    if (isPrerenderedPayload.value)
       return false;
     return Boolean(session.value && user.value);
   });
+  if (isPrerenderHydrationEmptySnapshot.value && authReady.value && !prerenderReadyResetQueued.value) {
+    prerenderReadyResetQueued.value = true;
+    nuxtApp.hook("app:suspense:resolve", () => {
+      try {
+        if (!session.value && !user.value && authReady.value)
+          authReady.value = false;
+      } finally {
+        prerenderReadyResetQueued.value = false;
+      }
+    });
+  }
   if (shouldSkipInitialClientSessionFetch.value && !authReady.value)
     authReady.value = true;
   function clearSession() {
@@ -97,14 +118,28 @@ export function useUserSession() {
     watch(
       () => clientSession.value,
       (newSession) => {
+        const shouldWaitForPrerenderResolution = isPrerenderHydrationEmptySnapshot.value && !newSession?.data?.session && !newSession?.data?.user;
+        if (shouldWaitForPrerenderResolution)
+          return;
         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) {
+        } else if (!newSession?.isPending && !newSession?.isRefetching) {
+          const isHydrationEmptySnapshot = nuxtApp.isHydrating && nuxtApp.payload.serverRendered && Boolean(session.value && user.value) && !newSession?.data?.session && !newSession?.data?.user;
+          if (isHydrationEmptySnapshot) {
+            if (!hydrationReconcileQueued.value) {
+              hydrationReconcileQueued.value = true;
+              nuxtApp.hook("app:mounted", async () => {
+                await fetchSession({ force: true });
+                hydrationReconcileQueued.value = false;
+              });
+            }
+            return;
+          }
           clearSession();
         }
-        if (!authReady.value && !newSession?.isPending)
+        if (!authReady.value && !newSession?.isPending && !newSession?.isRefetching)
           authReady.value = true;
       },
       { immediate: true, deep: true }
@@ -152,6 +187,19 @@ export function useUserSession() {
       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 });
@@ -161,12 +209,15 @@ export function useUserSession() {
       await cb(ctx);
     };
   }
-  function wrapAuthMethod(method) {
+  function wrapAuthMethod(method, wrapOptions = {}) {
     return (async (...args) => {
-      const data = args[0];
+      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;
@@ -219,7 +270,15 @@ export function useUserSession() {
       const method = targetRecord[prop];
       if (typeof method !== "function")
         return method;
-      return wrapAuthMethod((...args) => targetRecord[prop](...args));
+      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) => {
@@ -241,8 +300,23 @@ export function useUserSession() {
   });
   async function fetchSession(options = {}) {
     if (runtimeFlags.server) {
-      if (!authReady.value)
-        authReady.value = true;
+      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) {

package/dist/runtime/app/internal/auth-action-error.d.ts

@@ -1,2 +1,3 @@
 import type { AuthActionError } from '../../types.js';
+export declare const DEFAULT_AUTH_ACTION_ERROR_MESSAGE = "Request failed. Please try again.";
 export declare function normalizeAuthActionError(error: unknown): AuthActionError;

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

@@ -1,3 +1,4 @@
+export const DEFAULT_AUTH_ACTION_ERROR_MESSAGE = "Request failed. Please try again.";
 function isRecord(value) {
   return Boolean(value && typeof value === "object");
 }
@@ -8,7 +9,7 @@ function getMessage(value) {
     return value;
   if (isRecord(value) && typeof value.message === "string")
     return value.message;
-  return "Request failed. Please try again.";
+  return DEFAULT_AUTH_ACTION_ERROR_MESSAGE;
 }
 function getCode(value) {
   if (!isRecord(value))

package/dist/runtime/app/internal/auth-action-handles.d.ts

@@ -7,8 +7,12 @@ export interface UserAuthActionHandle<TArgs extends unknown[], TResult> {
     data: Ref<TResult | null>;
     error: Ref<AuthActionError | null>;
 }
+export interface CreateActionHandleOptions {
+    keepPendingOnRedirect?: boolean;
+}
 export type ActionHandleFor<T> = T extends (...args: infer A) => Promise<infer R> ? UserAuthActionHandle<A, R> : never;
 export type ActionHandleMap<T> = {
     [K in keyof T]: ActionHandleFor<T[K]>;
 };
+export declare function createActionHandle<TArgs extends unknown[], TResult>(getMethod: () => (...args: TArgs) => Promise<TResult>, options?: CreateActionHandleOptions): UserAuthActionHandle<TArgs, TResult>;
 export declare function createActionHandles<T extends object>(getTarget: () => T, targetName: string): ActionHandleMap<T>;

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

@@ -10,7 +10,23 @@ function isErrorResult(value) {
     return false;
   return Boolean(value.error);
 }
-function createActionHandle(getMethod) {
+function isRedirectResult(value) {
+  if (!isRecord(value))
+    return false;
+  return value.redirect === true && typeof value.url === "string" && value.url.length > 0;
+}
+function getRedirectResult(value) {
+  if (isRedirectResult(value))
+    return value;
+  if (!isRecord(value))
+    return null;
+  const nested = value.data;
+  if (isRedirectResult(nested))
+    return nested;
+  return null;
+}
+const REDIRECT_PENDING_FALLBACK_MS = 1e4;
+export function createActionHandle(getMethod, options = {}) {
   const status = ref("idle");
   const data = ref(null);
   const error = ref(null);
@@ -32,6 +48,20 @@ function createActionHandle(getMethod) {
         return;
       }
       if (callId === latestCallId) {
+        if (options.keepPendingOnRedirect !== false) {
+          const redirectResult = getRedirectResult(result);
+          if (redirectResult) {
+            status.value = "pending";
+            data.value = result;
+            error.value = null;
+            setTimeout(() => {
+              if (callId !== latestCallId || status.value !== "pending")
+                return;
+              status.value = "success";
+            }, REDIRECT_PENDING_FALLBACK_MS);
+            return;
+          }
+        }
         status.value = "success";
         data.value = result;
         error.value = null;

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

@@ -1,16 +1,24 @@
 import { createError, defineNuxtRouteMiddleware, getRouteRules, navigateTo, useNuxtApp, useRequestHeaders, useRuntimeConfig, useUserSession } from "#imports";
+import { defu } from "defu";
+import { createRouter, toRouteMatcher } from "radix3";
 import { matchesUser } from "../../utils/match-user.js";
+let authRouteRulesPromise = null;
+let routeRulesMatcherPromise = null;
 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 routeRulesMatcher = await getRouteRulesMatcher();
+    const matches = routeRulesMatcher?.matchAll(to.path);
+    if (matches?.length) {
+      const merged = defu({}, ...matches.reverse());
+      if (merged.auth !== void 0)
+        to.meta.auth = merged.auth;
+    }
+    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)
@@ -19,7 +27,8 @@ export default defineNuxtRouteMiddleware(async (to) => {
   const { fetchSession, user, loggedIn } = useUserSession();
   if (!loggedIn.value) {
     const headers = import.meta.server ? useRequestHeaders(["cookie"]) : void 0;
-    await fetchSession({ headers });
+    const isHydratedPrerenderPayload = (import.meta.client || !import.meta.server) && nuxtApp.isHydrating && Boolean(nuxtApp.payload.prerenderedAt || nuxtApp.payload.isCached);
+    await fetchSession({ headers, ...isHydratedPrerenderPayload ? { force: true } : {} });
   }
   const mode = typeof auth === "string" ? auth : auth?.only ?? "user";
   const redirectTo = typeof auth === "object" ? auth.redirectTo : void 0;
@@ -71,3 +80,19 @@ function resolveLoginRedirect(input) {
   queryObj[redirectQueryKey] = route.fullPath;
   return { to: { path, query: queryObj, ...hash ? { hash: `#${hash}` } : {} }, external: false };
 }
+async function getAuthRouteRules() {
+  if (!authRouteRulesPromise) {
+    authRouteRulesPromise = import("#auth/route-rules").then((mod) => mod.authRouteRules || {}).catch(() => ({}));
+  }
+  return await authRouteRulesPromise;
+}
+async function getRouteRulesMatcher() {
+  if (!routeRulesMatcherPromise) {
+    routeRulesMatcherPromise = getAuthRouteRules().then((authRouteRules) => {
+      if (!Object.keys(authRouteRules).length)
+        return null;
+      return toRouteMatcher(createRouter({ routes: authRouteRules }));
+    });
+  }
+  return await routeRulesMatcherPromise;
+}

package/dist/runtime/server/api/_better-auth/config.get.d.ts

@@ -14,22 +14,22 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
             databaseProvider: "none" | "nuxthub";
         };
         server: {
-            baseURL: string | undefined;
-            basePath: string;
+            baseURL: any;
+            basePath: any;
             socialProviders: string[];
-            plugins: string[];
-            trustedOrigins: string[];
-            configuredTrustedOrigins: string[];
+            plugins: any;
+            trustedOrigins: any;
+            configuredTrustedOrigins: any;
             session: {
                 expiresIn: string;
                 updateAge: string;
-                cookieCache: boolean;
+                cookieCache: any;
             };
             emailAndPassword: boolean;
-            rateLimit: boolean;
+            rateLimit: any;
             advanced: {
-                useSecureCookies: string | boolean;
-                disableCSRFCheck: boolean;
+                useSecureCookies: any;
+                disableCSRFCheck: any;
             };
         };
     };

package/dist/runtime/server/utils/auth.d.ts

@@ -1,6 +1,8 @@
 import type { H3Event } from 'h3';
+import createServerAuth from '#auth/server';
 import { betterAuth } from 'better-auth';
-type AuthInstance = ReturnType<typeof betterAuth>;
+type AuthOptions = ReturnType<typeof createServerAuth>;
+type AuthInstance = ReturnType<typeof betterAuth<AuthOptions>>;
 /** Returns Better Auth instance. Caches per resolved host (or single instance when siteUrl is explicit). */
 export declare function serverAuth(event?: H3Event): AuthInstance;
 export {};

package/dist/runtime/server/utils/session.d.ts

@@ -1,5 +1,5 @@
 import type { AppSession, RequireSessionOptions } from '#nuxt-better-auth';
 import type { H3Event } from 'h3';
-export declare function getAppSession(event: H3Event): Promise<AppSession | null>;
+export declare function getRequestSession(event: H3Event): Promise<AppSession | null>;
 export declare function getUserSession(event: H3Event): Promise<AppSession | null>;
 export declare function requireUserSession(event: H3Event, options?: RequireSessionOptions): Promise<AppSession>;

package/dist/runtime/server/utils/session.js

@@ -1,16 +1,16 @@
 import { createError } from "h3";
 import { matchesUser } from "../../utils/match-user.js";
 import { serverAuth } from "./auth.js";
-const appSessionLoadKey = Symbol.for("nuxt-better-auth.appSessionLoad");
-const fallbackAppSessionContext = /* @__PURE__ */ new WeakMap();
-function getAppSessionContext(event) {
+const requestSessionLoadKey = Symbol.for("nuxt-better-auth.requestSessionLoad");
+const fallbackRequestSessionContext = /* @__PURE__ */ new WeakMap();
+function getRequestSessionContext(event) {
   const eventWithContext = event;
   if (eventWithContext.context && typeof eventWithContext.context === "object")
     return eventWithContext.context;
-  let context = fallbackAppSessionContext.get(event);
+  let context = fallbackRequestSessionContext.get(event);
   if (!context) {
     context = {};
-    fallbackAppSessionContext.set(event, context);
+    fallbackRequestSessionContext.set(event, context);
   }
   return context;
 }
@@ -18,34 +18,34 @@ function loadSession(event) {
   const auth = serverAuth(event);
   return auth.api.getSession({ headers: event.headers });
 }
-export async function getAppSession(event) {
-  const context = getAppSessionContext(event);
-  if (context.appSession !== void 0)
-    return context.appSession;
-  const inFlight = context[appSessionLoadKey];
+export async function getRequestSession(event) {
+  const context = getRequestSessionContext(event);
+  if (context.requestSession !== void 0)
+    return context.requestSession;
+  const inFlight = context[requestSessionLoadKey];
   if (inFlight)
     return inFlight;
   const load = loadSession(event);
-  context[appSessionLoadKey] = load;
+  context[requestSessionLoadKey] = load;
   try {
     const session = await load;
-    context.appSession = session;
+    context.requestSession = session;
     return session;
   } finally {
-    delete context[appSessionLoadKey];
+    delete context[requestSessionLoadKey];
   }
 }
 export async function getUserSession(event) {
-  const context = getAppSessionContext(event);
-  if (context.appSession !== void 0)
-    return context.appSession;
-  const inFlight = context[appSessionLoadKey];
+  const context = getRequestSessionContext(event);
+  if (context.requestSession !== void 0)
+    return context.requestSession;
+  const inFlight = context[requestSessionLoadKey];
   if (inFlight)
     return inFlight;
   return loadSession(event);
 }
 export async function requireUserSession(event, options) {
-  const session = await getAppSession(event);
+  const session = await getRequestSession(event);
   if (!session)
     throw createError({ statusCode: 401, statusMessage: "Authentication required" });
   if (options?.user) {

package/dist/runtime/types/augment.d.ts

@@ -22,6 +22,8 @@ export interface ServerAuthContext {
     runtimeConfig: Record<string, unknown>;
     db: unknown;
 }
+export interface AuthSocialProviderRegistry {
+}
 export interface UserSessionComposable {
     client: unknown;
     user: Ref<AuthUser | null>;

package/dist/runtime/types.d.ts

@@ -1,6 +1,9 @@
-import type { AuthUser, UserMatch } from '#nuxt-better-auth';
+import type { AuthSocialProviderRegistry, AuthUser, UserMatch } from '#nuxt-better-auth';
 import type { NitroRouteRules } from 'nitropack/types';
-export type { AppSession, AuthSession, AuthUser, RequireSessionOptions, ServerAuthContext, UserMatch, UserSessionComposable } from './types/augment.js';
+export type { AppSession, AuthSession, AuthSocialProviderRegistry, AuthUser, RequireSessionOptions, ServerAuthContext, UserMatch, UserSessionComposable } from './types/augment.js';
+export type AuthSocialProviderId = AuthSocialProviderRegistry extends {
+    ids: infer T;
+} ? Extract<T, string> : never;
 export type { Auth, InferPluginTypes, InferSessionFromClient as InferSession, InferUserFromClient as InferUser } from 'better-auth';
 export interface AuthActionError {
     message: string;

package/dist/types.d.mts

@@ -6,6 +6,6 @@ export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<
 
 export { type BetterAuthModuleOptions, type defineClientAuth, type defineServerAuth } from '../dist/runtime/config.js'
 
-export { type AppSession, type Auth, type AuthActionError, type AuthMeta, type AuthMode, type AuthRouteRules, type AuthSession, type AuthUser, type InferSession, type InferUser, type RequireSessionOptions, type ServerAuthContext, type UserMatch } from '../dist/runtime/types.js'
+export { type AppSession, type Auth, type AuthActionError, type AuthMeta, type AuthMode, type AuthRouteRules, type AuthSession, type AuthSocialProviderId, type AuthUser, type InferSession, type InferUser, type RequireSessionOptions, type ServerAuthContext, type UserMatch } from '../dist/runtime/types.js'
 
 export { default } from './module.mjs'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@onmax/nuxt-better-auth",
   "type": "module",
-  "version": "0.0.2-alpha.29",
+  "version": "0.0.2-alpha.30",
   "packageManager": "pnpm@10.15.1",
   "description": "Nuxt module for Better Auth integration with NuxtHub, route protection, session management, and role-based access",
   "author": "onmax",
@@ -70,56 +70,42 @@
     }
   },
   "dependencies": {
-    "@better-auth/cli": "^1.5.0-beta.3",
-    "@nuxt/kit": "^4.2.2",
-    "@nuxt/ui": "^4.2.1",
+    "@better-auth/cli": "1.5.0-beta.13",
+    "@nuxt/kit": "^4.3.1",
+    "@nuxt/ui": "^4.5.0",
     "defu": "^6.1.4",
-    "jiti": "^2.4.2",
+    "jiti": "^2.6.1",
     "pathe": "^2.0.3",
     "radix3": "^1.1.2",
     "std-env": "^3.10.0"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^4.12.0",
-    "@libsql/client": "^0.15.15",
-    "@nuxt/devtools": "^3.1.1",
-    "@nuxt/devtools-kit": "^3.1.1",
+    "@antfu/eslint-config": "^7.6.1",
+    "@libsql/client": "^0.17.0",
+    "@libsql/linux-x64-gnu": "0.5.22",
+    "@nuxt/devtools": "^3.2.2",
+    "@nuxt/devtools-kit": "^3.2.2",
     "@nuxt/module-builder": "^1.0.2",
-    "@nuxt/schema": "^4.2.2",
-    "@nuxt/test-utils": "^3.21.0",
-    "@nuxthub/core": "^0.10.5",
+    "@nuxt/schema": "^4.3.1",
+    "@nuxt/test-utils": "^4.0.0",
+    "@nuxthub/core": "^0.10.6",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "latest",
-    "better-auth": "^1.5.0-beta.3",
-    "better-sqlite3": "^11.9.1",
-    "bumpp": "^10.3.2",
+    "better-auth": "1.5.0",
+    "better-sqlite3": "^12.6.2",
+    "bumpp": "^10.4.1",
     "changelogen": "^0.6.2",
     "consola": "^3.4.2",
-    "drizzle-kit": "^0.31.8",
-    "drizzle-orm": "^0.38.4",
-    "eslint": "^9.39.1",
+    "drizzle-kit": "^0.31.9",
+    "drizzle-orm": "^0.45.1",
+    "eslint": "^10.0.2",
     "npm-agentskills": "https://pkg.pr.new/onmax/npm-agentskills@394499e",
-    "nuxt": "^4.2.2",
+    "nuxt": "^4.3.1",
     "tinyexec": "^1.0.2",
     "typescript": "~5.9.3",
-    "vitest": "^4.0.15",
-    "vitest-package-exports": "^0.1.1",
-    "vue-tsc": "^3.1.7",
+    "vitest": "^4.0.18",
+    "vitest-package-exports": "^1.2.0",
+    "vue-tsc": "^3.2.5",
     "yaml": "^2.8.2"
-  },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "@parcel/watcher",
-      "better-sqlite3",
-      "esbuild",
-      "sharp",
-      "workerd"
-    ],
-    "patchedDependencies": {
-      "@peculiar/x509@1.14.2": "patches/@peculiar__x509@1.14.2.patch"
-    },
-    "overrides": {
-      "reka-ui": "^2.6.1"
-    }
   }
 }

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

@@ -1,5 +0,0 @@
-import type { AppAuthClient } from '#nuxt-better-auth';
-import type { ActionHandleFor } from '../internal/auth-action-handles.js';
-type SignIn = NonNullable<AppAuthClient>['signIn'];
-export declare function useUserSignIn<MethodKey extends keyof SignIn>(method: MethodKey): ActionHandleFor<SignIn[MethodKey]>;
-export {};