@nuxtjs/better-auth 0.2.4 → 0.3.0

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxtjs/better-auth",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "configKey": "auth",
   "compatibility": {
     "nuxt": ">=4.0.0"

package/dist/module.mjs

@@ -1,6 +1,6 @@
 import { existsSync, statSync, writeFileSync, readFileSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
-import { getLayerDirectories, updateTemplates, addServerImportsDir, addServerImports, addServerScanDir, addServerHandler, addImportsDir, addPlugin, addComponentsDir, extendPages, addTemplate, hasNuxtModule, addTypeTemplate, defineNuxtModule, createResolver } from '@nuxt/kit';
+import { getLayerDirectories, updateTemplates, addServerImports, addServerScanDir, addServerHandler, addImports, addPlugin, addComponentsDir, extendPages, addTemplate, hasNuxtModule, addTypeTemplate, defineNuxtModule, createResolver } from '@nuxt/kit';
 import { consola as consola$1 } from 'consola';
 import { isAbsolute, join, resolve, relative, dirname } from 'pathe';
 import { defu } from 'defu';
@@ -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.2.4";
+const version = "0.3.0";
 
 const CONFIG_EXTENSIONS = [".ts", ".js"];
 const CONFIG_EXTENSION_RE$1 = /\.(?:ts|js)$/;
@@ -177,13 +177,31 @@ function registerTemplateHmrHook(nuxt) {
 function registerServerRuntime(input) {
   const { clientOnly, resolve } = input;
   if (!clientOnly) {
-    addServerImportsDir(resolve("./runtime/server/utils"));
-    addServerImports([{ name: "defineServerAuth", from: resolve("./runtime/config") }]);
+    addServerImports([
+      { name: "defineServerAuth", from: resolve("./runtime/config") },
+      { name: "serverAuth", from: resolve("./runtime/server/utils/auth") },
+      ...["getRequestSession", "getUserSession", "setRequestSession", "refreshSessionCookieCache", "setSessionCookie", "createSession", "requireUserSession"].map((name) => ({ name, from: resolve("./runtime/server/utils/session") }))
+    ]);
     addServerScanDir(resolve("./runtime/server/middleware"));
     addServerHandler({ route: "/api/auth/**", handler: resolve("./runtime/server/api/auth/[...all]") });
   }
-  addImportsDir(resolve("./runtime/app/composables"));
-  addImportsDir(resolve("./runtime/utils"));
+  addImports([
+    "runWithSessionRefresh",
+    "useAction",
+    "useAuthAsyncData",
+    "useAuthClient",
+    "useAuthClientAction",
+    "useAuthRequestFetch",
+    "useSignIn",
+    "useSignOut",
+    "useSignUp",
+    "useUserSession",
+    "useUserSessionState"
+  ].map((name) => ({ name, from: resolve("./runtime/composables") })));
+  addImports([
+    ...["SignOutOptions", "UseUserSessionReturn", "UseUserSessionStateReturn"].map((name) => ({ name, type: true, from: resolve("./runtime/composables") })),
+    { name: "UseAuthAsyncDataOptions", type: true, from: resolve("./runtime/app/composables/useAuthAsyncData") }
+  ]);
   if (!clientOnly)
     addPlugin({ src: resolve("./runtime/app/plugins/session.server"), mode: "server" });
   addPlugin({ src: resolve("./runtime/app/plugins/session.client"), mode: "client" });
@@ -202,8 +220,7 @@ function registerPrepareTypesHook(input) {
     const projectReferenceTypePaths = [
       join(nuxt.options.buildDir, "types/nitro-imports.d.ts"),
       join(nuxt.options.buildDir, "types/auth-database.d.ts"),
-      join(nuxt.options.buildDir, "types/auth-schema.d.ts"),
-      join(nuxt.options.buildDir, "types/auth-secondary-storage.d.ts")
+      join(nuxt.options.buildDir, "types/auth-schema.d.ts")
     ];
     if (hasHubDb)
       projectReferenceTypePaths.push(join(nuxt.options.buildDir, "hub/db.d.ts"));
@@ -213,7 +230,6 @@ function registerPrepareTypesHook(input) {
       "#auth/client": nuxt.options.alias["#auth/client"],
       "#auth/database": nuxt.options.alias["#auth/database"],
       "#auth/schema": nuxt.options.alias["#auth/schema"],
-      "#auth/secondary-storage": nuxt.options.alias["#auth/secondary-storage"],
       "#auth/route-rules": nuxt.options.alias["#auth/route-rules"]
     };
     for (const [key, value] of Object.entries(exactNodeAliases)) {
@@ -668,9 +684,6 @@ ${plugins.imports}
 export default extendClientAuth(createAppAuthClient, [${plugins.names}])
 `;
 }
-function buildSecondaryStorageCode() {
-  return "export function createSecondaryStorage() { return undefined }";
-}
 function buildDatabaseCode(input) {
   if (input.provider === "nuxthub") {
     if (input.hubDialect === "postgresql") {
@@ -946,6 +959,21 @@ async function resolveAuthModuleSetup(input, dependencies = {}) {
   };
 }
 
+function buildNuxtFetchFallback(name) {
+  const options = "import('nuxt/app').UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, ReqT, Method>";
+  return ["undefined", "DataT"].map((defaultType) => `
+  export function ${name}<
+    ResT = void,
+    ErrorT = _NuxtFetchError,
+    ReqT extends NitroFetchRequest = NitroFetchRequest,
+    const Method extends _NuxtFetchMethod<ReqT> = ResT extends void ? 'get' extends _NuxtFetchMethod<ReqT> ? 'get' : _NuxtFetchMethod<ReqT> : _NuxtFetchMethod<ReqT>,
+    _ResT = ResT extends void ? import('nuxt/app').FetchResult<ReqT, Method> : ResT,
+    DataT = _ResT,
+    PickKeys extends _NuxtKeysOf<DataT> = _NuxtKeysOf<DataT>,
+    DefaultT = ${defaultType},
+  >(request: import('vue').Ref<ReqT> | ReqT | (() => ReqT), opts?: ${name === "useLazyFetch" ? `Omit<${options}, 'lazy'>` : options}): import('nuxt/app').AsyncData<_NuxtPickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>
+`).join("");
+}
 function registerServerTypeTemplates(input) {
   const { serverConfigPath, hasHubDb, runtimeTypesPath, sharedServerConfigSafe, h3TypesPath, nitroTypesPath } = input;
   const routeRuleAugmentations = (nitroTypesPath === "nitro/types" ? [nitroTypesPath] : ["nitropack", nitroTypesPath]).map((moduleName) => `declare module '${moduleName}' {
@@ -957,14 +985,6 @@ function registerServerTypeTemplates(input) {
   }
 }`).join("\n");
   const serverConfigTypeTemplateOptions = sharedServerConfigSafe ? { nuxt: true, nitro: true, node: true, shared: true } : { nuxt: true, nitro: true, node: true };
-  addTypeTemplate({
-    filename: "types/auth-secondary-storage.d.ts",
-    getContents: () => `
-declare module '#auth/secondary-storage' {
-  export function createSecondaryStorage(): undefined
-}
-`
-  }, { nitro: true });
   addTypeTemplate({
     filename: "types/auth-database.d.ts",
     getContents: () => `
@@ -999,7 +1019,6 @@ declare module '#auth/schema' {
 /// <reference path="./nitro-imports.d.ts" />
 /// <reference path="./auth-database.d.ts" />
 /// <reference path="./auth-schema.d.ts" />
-/// <reference path="./auth-secondary-storage.d.ts" />
 ${hasHubDb ? '/// <reference path="../hub/db.d.ts" />' : ""}
 
 export {}
@@ -1024,7 +1043,7 @@ declare module '@nuxtjs/better-auth/config' {
     filename: "types/nuxt-better-auth-infer.d.ts",
     getContents: () => `
 import type { BetterAuthOptions, BetterAuthPlugin, InferPluginTypes, UnionToIntersection } from 'better-auth'
-import type { InferFieldsOutput } from 'better-auth/db'
+import type { InferFieldsInputClient, InferFieldsOutput } from 'better-auth/db'
 import type createServerAuth from '${serverConfigPath}'
 
 type _RawConfig = ReturnType<typeof createServerAuth>
@@ -1048,11 +1067,24 @@ type _InferModelFieldsFromOptions<C, M extends 'user' | 'session'> = C extends {
   ? InferFieldsOutput<F>
   : {}
 
+type _UserFields = NonNullable<NonNullable<BetterAuthOptions['user']>['additionalFields']>
+
+type _InferUserInputFromPlugins<P> = P extends readonly (infer Plugin)[]
+  ? UnionToIntersection<Plugin extends { schema: { user: { fields: infer F extends _UserFields } } } ? InferFieldsInputClient<F> : {}>
+  : {}
+
+type _UserInputFallback = Partial<_InferUserInputFromPlugins<_RawPlugins> & (
+  _RawConfig extends { user: { additionalFields: infer F extends _UserFields } }
+    ? InferFieldsInputClient<F>
+    : {}
+)>
+
 type _UserFallback = _InferModelFieldsFromPlugins<_RawPlugins, 'user'> & _InferModelFieldsFromOptions<_RawConfig, 'user'>
 type _SessionFallback = _InferModelFieldsFromPlugins<_RawPlugins, 'session'> & _InferModelFieldsFromOptions<_RawConfig, 'session'>
 
 declare module '#nuxt-better-auth' {
   interface AuthUser extends _UserFallback {}
+  interface AuthUserUpdateInput extends _UserInputFallback {}
   interface AuthSession extends _SessionFallback {}
   type PluginTypes = InferPluginTypes<_Config>
 }
@@ -1080,8 +1112,10 @@ declare module '#nuxt-better-auth' {
 import type createServerAuth from '${serverConfigPath}'
 import type { BetterAuthOptions } from 'better-auth'
 import type { getEndpoints } from 'better-auth/api'
-import type { Serialize, Simplify } from '${nitroTypesPath}'
-import type { FetchError } from 'ofetch'
+import type { AvailableRouterMethod, NitroFetchRequest, Serialize, Simplify } from '${nitroTypesPath}'
+import type { useFetch as _NuxtUseFetch } from '#app/composables/fetch'
+
+type _NuxtFetchError = NonNullable<ReturnType<typeof _NuxtUseFetch<void>>['error']['value']>
 
 type _RawConfig = ReturnType<typeof createServerAuth>
 type _RawPlugins = _RawConfig extends { plugins: infer P } ? P : _RawConfig extends { plugins?: infer P } ? P : []
@@ -1143,7 +1177,11 @@ type _AuthPatternFromRequestPath<Path extends string> = {
 }[_AuthApiPatternPath]
 type _AuthEndpointMethod<Path extends _AuthApiRequestPath> = Extract<keyof _GeneratedAuthInternalApi[_AuthPatternFromRequestPath<Path>], string>
 
-type _AuthFetchMethod<Path extends _AuthApiRequestPath> = Extract<Exclude<import('${nitroTypesPath}').NitroFetchOptions<Path>['method'], undefined>, string>
+type _NuxtKeysOf<T> = Array<T extends T ? keyof T extends string ? keyof T : never : never>
+type _NuxtPickFrom<T, Keys extends string[]> = T extends unknown[] ? T : T extends Record<string, any> ? keyof T extends Keys[number] ? T : Keys[number] extends never ? T : Pick<T, Keys[number]> : T
+type _NuxtFetchMethod<ReqT extends NitroFetchRequest> = AvailableRouterMethod<ReqT> | Uppercase<AvailableRouterMethod<ReqT>>
+
+type _AuthFetchMethod = _NuxtFetchMethod<string>
 type _AuthFetchDefaultMethod<Path extends _AuthApiRequestPath> = 'get'
 type _AuthFetchResolvedMethod<Path extends _AuthApiRequestPath, Method extends string> = Lowercase<Method> extends _AuthEndpointMethod<Path>
   ? Lowercase<Method>
@@ -1161,88 +1199,50 @@ declare module '#nuxt-better-auth' {
   > = 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 useFetch(request: string | import('vue').Ref<string> | (() => string), opts?: any): any
-
-  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>
-  export function useLazyFetch(request: string | import('vue').Ref<string> | (() => string), opts?: any): any
-}
-
 declare module 'nuxt/app' {
   export function useFetch<
-    ErrorT = FetchError,
+    ResT = void,
+    ErrorT = _NuxtFetchError,
     Path extends import('#nuxt-better-auth').AuthApiEndpointPath = import('#nuxt-better-auth').AuthApiEndpointPath,
-    Method extends _AuthFetchMethod<Path> = _AuthFetchDefaultMethod<Path>,
-    _ResT = _AuthFetchResult<Path, Method>,
+    const Method extends _AuthFetchMethod = _AuthFetchDefaultMethod<Path>,
+    _ResT = ResT extends void ? _AuthFetchResult<Path, Method> : ResT,
     DataT = _ResT,
-    PickKeys extends import('nuxt/dist/app/composables/asyncData').KeysOf<DataT> = import('nuxt/dist/app/composables/asyncData').KeysOf<DataT>,
+    PickKeys extends _NuxtKeysOf<DataT> = _NuxtKeysOf<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>
+  >(request: import('vue').Ref<Path> | Path | (() => Path), opts?: import('nuxt/app').UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, Path, Method>): import('nuxt/app').AsyncData<_NuxtPickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>
   export function useFetch<
-    ErrorT = FetchError,
+    ResT = void,
+    ErrorT = _NuxtFetchError,
     Path extends import('#nuxt-better-auth').AuthApiEndpointPath = import('#nuxt-better-auth').AuthApiEndpointPath,
-    Method extends _AuthFetchMethod<Path> = _AuthFetchDefaultMethod<Path>,
-    _ResT = _AuthFetchResult<Path, Method>,
+    const Method extends _AuthFetchMethod = _AuthFetchDefaultMethod<Path>,
+    _ResT = ResT extends void ? _AuthFetchResult<Path, Method> : ResT,
     DataT = _ResT,
-    PickKeys extends import('nuxt/dist/app/composables/asyncData').KeysOf<DataT> = import('nuxt/dist/app/composables/asyncData').KeysOf<DataT>,
+    PickKeys extends _NuxtKeysOf<DataT> = _NuxtKeysOf<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 useFetch(request: string | import('vue').Ref<string> | (() => string), opts?: any): any
+  >(request: import('vue').Ref<Path> | Path | (() => Path), opts?: import('nuxt/app').UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, Path, Method>): import('nuxt/app').AsyncData<_NuxtPickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>
+${buildNuxtFetchFallback("useFetch")}
 
   export function useLazyFetch<
-    ErrorT = FetchError,
+    ResT = void,
+    ErrorT = _NuxtFetchError,
     Path extends import('#nuxt-better-auth').AuthApiEndpointPath = import('#nuxt-better-auth').AuthApiEndpointPath,
-    Method extends _AuthFetchMethod<Path> = _AuthFetchDefaultMethod<Path>,
-    _ResT = _AuthFetchResult<Path, Method>,
+    const Method extends _AuthFetchMethod = _AuthFetchDefaultMethod<Path>,
+    _ResT = ResT extends void ? _AuthFetchResult<Path, Method> : ResT,
     DataT = _ResT,
-    PickKeys extends import('nuxt/dist/app/composables/asyncData').KeysOf<DataT> = import('nuxt/dist/app/composables/asyncData').KeysOf<DataT>,
+    PickKeys extends _NuxtKeysOf<DataT> = _NuxtKeysOf<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>
+  >(request: import('vue').Ref<Path> | Path | (() => Path), opts?: Omit<import('nuxt/app').UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, Path, Method>, 'lazy'>): import('nuxt/app').AsyncData<_NuxtPickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>
   export function useLazyFetch<
-    ErrorT = FetchError,
+    ResT = void,
+    ErrorT = _NuxtFetchError,
     Path extends import('#nuxt-better-auth').AuthApiEndpointPath = import('#nuxt-better-auth').AuthApiEndpointPath,
-    Method extends _AuthFetchMethod<Path> = _AuthFetchDefaultMethod<Path>,
-    _ResT = _AuthFetchResult<Path, Method>,
+    const Method extends _AuthFetchMethod = _AuthFetchDefaultMethod<Path>,
+    _ResT = ResT extends void ? _AuthFetchResult<Path, Method> : ResT,
     DataT = _ResT,
-    PickKeys extends import('nuxt/dist/app/composables/asyncData').KeysOf<DataT> = import('nuxt/dist/app/composables/asyncData').KeysOf<DataT>,
+    PickKeys extends _NuxtKeysOf<DataT> = _NuxtKeysOf<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>
-  export function useLazyFetch(request: string | import('vue').Ref<string> | (() => string), opts?: any): any
+  >(request: import('vue').Ref<Path> | Path | (() => Path), opts?: Omit<import('nuxt/app').UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, Path, Method>, 'lazy'>): import('nuxt/app').AsyncData<_NuxtPickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>
+${buildNuxtFetchFallback("useLazyFetch")}
 }
 export {}
 `
@@ -1284,6 +1284,8 @@ declare module '#nuxt-better-auth' {
     userAgent?: string | null
   }
 
+  export type ClientAuthSession = Omit<AuthSession, 'token'>
+
   export interface ServerAuthContext {
     runtimeConfig: Record<string, unknown>
     db: unknown
@@ -1293,15 +1295,20 @@ declare module '#nuxt-better-auth' {
   export interface AuthSocialProviderRegistry {}
   export type AuthSocialProviderId = AuthSocialProviderRegistry extends { ids: infer T } ? Extract<T, string> : never
 
+  export interface AuthUserUpdateInput {
+    name?: string
+    image?: string | null
+  }
+
   export interface UserSessionComposable {
     user: Ref<AuthUser | null>
-    session: Ref<AuthSession | null>
+    session: Ref<ClientAuthSession | null>
     loggedIn: ComputedRef<boolean>
     ready: ComputedRef<boolean>
     fetchSession: (options?: { headers?: HeadersInit, force?: boolean }) => Promise<void>
     waitForSession: () => Promise<void>
     signOut: (options?: { onSuccess?: () => void | Promise<void> }) => Promise<void>
-    updateUser: (updates: Partial<AuthUser>) => Promise<void>
+    updateUser: (updates: AuthUserUpdateInput) => Promise<void>
   }
 
   export type UserMatch<T> = { [K in keyof T]?: T[K] | T[K][] }
@@ -1335,8 +1342,10 @@ export {}
     filename: "types/nuxt-better-auth-client.d.ts",
     getContents: () => `
 import type createAppAuthClient from '${input.clientConfigPath}'
+type _ClientUserUpdateInput = Omit<NonNullable<Parameters<ReturnType<typeof createAppAuthClient>['updateUser']>[0]>, 'fetchOptions'>
 declare module '#nuxt-better-auth' {
   export type AppAuthClient = ReturnType<typeof createAppAuthClient>
+  interface AuthUserUpdateInput extends _ClientUserUpdateInput {}
 }
 `
   });
@@ -1456,12 +1465,6 @@ const module$1 = defineNuxtModule({
         nuxt.options.alias["#auth/server"] = serverConfigPath;
       nuxt.options.alias["#auth/client"] = clientConfigPath;
       if (!setup.clientOnly) {
-        const secondaryStorageTemplate = addTemplate({
-          filename: "better-auth/secondary-storage.mjs",
-          getContents: () => buildSecondaryStorageCode(),
-          write: true
-        });
-        nuxt.options.alias["#auth/secondary-storage"] = secondaryStorageTemplate.dst;
         const databaseTemplate = addTemplate({
           filename: "better-auth/database.mjs",
           getContents: () => setup.database.providerDefinition.buildDatabaseCode(setup.database.buildContext),

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

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

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

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

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

@@ -0,0 +1 @@
+export declare function useSignOut(): import("../internal/auth-action-handles.js").UserAuthActionHandle<[options?: import("./useUserSession.js").SignOutOptions | undefined], void>;

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

@@ -0,0 +1,6 @@
+import { useAction } from "./useAction.js";
+import { useUserSession } from "./useUserSession.js";
+export function useSignOut() {
+  const { signOut } = useUserSession();
+  return useAction(signOut);
+}

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

@@ -1,10 +1,10 @@
 import type { ComputedRef, Ref } from 'vue';
-import type { AuthSession, AuthUser } from '#nuxt-better-auth';
+import type { AuthUser, AuthUserUpdateInput, ClientAuthSession } from '#nuxt-better-auth';
 export interface SignOutOptions {
     onSuccess?: () => void | Promise<void>;
 }
 export interface UseUserSessionReturn {
-    session: Ref<AuthSession | null>;
+    session: Ref<ClientAuthSession | null>;
     user: Ref<AuthUser | null>;
     loggedIn: ComputedRef<boolean>;
     ready: ComputedRef<boolean>;
@@ -14,7 +14,7 @@ export interface UseUserSessionReturn {
         headers?: HeadersInit;
         force?: boolean;
     }) => Promise<void>;
-    updateUser: (updates: Partial<AuthUser>) => Promise<void>;
+    updateUser: (updates: AuthUserUpdateInput) => Promise<void>;
 }
 export declare function useUserSession(): UseUserSessionReturn;
 export declare function useAuthActionNamespaces(): {

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

@@ -7,6 +7,7 @@ import { createVueSafeAuthFacade, isAuthProxyProbeKey } from "../internal/vue-sa
 import { wrapAuthMethod } from "../internal/wrap-auth-method.js";
 import { getAuthRuntimeFlags, useRawAuthClient } from "./useAuthClient.js";
 let _signOutPromise = null;
+const _sessionSyncApps = /* @__PURE__ */ new WeakSet();
 function createServerOnlyActionNamespace(path) {
   return new Proxy({}, {
     get(_target, prop) {
@@ -96,7 +97,7 @@ export function useUserSession() {
       hydrationReconcileQueued.value = false;
     });
   }
-  if (runtimeFlags.client && rawClient) {
+  if (runtimeFlags.client && rawClient && !_sessionSyncApps.has(nuxtApp)) {
     const clientSession = rawClient.useSession();
     const initialClientSession = clientSession.value;
     const shouldReconcileInitialHydration = nuxtApp.isHydrating && nuxtApp.payload.serverRendered && Boolean(session.value && user.value) && !initialClientSession?.data?.session && !initialClientSession?.data?.user && !initialClientSession?.isPending && !initialClientSession?.isRefetching;
@@ -123,6 +124,7 @@ export function useUserSession() {
           authReady.value = true;
       }
     );
+    _sessionSyncApps.add(nuxtApp);
   }
   function waitForSession() {
     return new Promise((resolve) => {
@@ -150,7 +152,9 @@ export function useUserSession() {
       return;
     }
     _signOutPromise = (async () => {
-      await rawClient.signOut();
+      const result = await rawClient.signOut();
+      if (isRecord(result) && result.error)
+        throw new Error(normalizeAuthActionError(result.error).message);
       clearSession();
       if (options?.onSuccess) {
         await options.onSuccess();

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

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

package/dist/runtime/app/internal/session-fetch.js

@@ -1,3 +1,4 @@
+import { parseJSON } from "better-auth/client";
 import { useRequestFetch, useRequestHeaders } from "#imports";
 import { normalizeAuthActionError } from "./auth-action-error.js";
 export function stripToken(session) {
@@ -14,7 +15,11 @@ export async function fetchSessionServer(session, user, authReady, options = {})
   try {
     const headers = options.headers || useRequestHeaders(["cookie"]);
     const requestFetch = useRequestFetch();
-    const data = await requestFetch("/api/auth/get-session", { headers });
+    const data = await requestFetch("/api/auth/get-session", {
+      headers,
+      parseResponse: parseJSON,
+      ...options.force ? { query: { disableCookieCache: true } } : {}
+    });
     if (data?.session && data?.user) {
       session.value = stripToken(data.session);
       user.value = data.user;
@@ -33,7 +38,7 @@ export async function fetchSessionServer(session, user, authReady, options = {})
 export async function fetchSessionClient(client, session, user, authReady, options = {}) {
   try {
     const headers = options.headers || useRequestHeaders(["cookie"]);
-    const fetchOptions = headers ? { headers } : void 0;
+    const fetchOptions = { ...headers ? { headers } : {}, throw: false };
     const query = options.force ? { disableCookieCache: true } : void 0;
     const result = await client.getSession({ query }, fetchOptions);
     const data = result.data;

package/dist/runtime/app/plugins/session.server.js

@@ -1,3 +1,4 @@
+import { parseJSON } from "better-auth/client";
 import { defineNuxtPlugin, useRequestEvent, useRequestHeaders, useState } from "#imports";
 export default defineNuxtPlugin({
   name: "auth:session-init",
@@ -10,7 +11,7 @@ export default defineNuxtPlugin({
     if (event) {
       try {
         const headers = useRequestHeaders(["cookie"]);
-        const data = await $fetch("/api/auth/get-session", { headers });
+        const data = await $fetch("/api/auth/get-session", { headers, parseResponse: parseJSON });
         if (data?.session && data?.user) {
           const { token: _, ...safeSession } = data.session;
           session.value = safeSession;

package/dist/runtime/composables.d.ts

@@ -5,6 +5,7 @@ export { useAuthClient } from './app/composables/useAuthClient.js';
 export { useAuthClientAction } from './app/composables/useAuthClientAction.js';
 export { useAuthRequestFetch } from './app/composables/useAuthRequestFetch.js';
 export { useSignIn } from './app/composables/useSignIn.js';
+export { useSignOut } from './app/composables/useSignOut.js';
 export { useSignUp } from './app/composables/useSignUp.js';
 export { useUserSession } from './app/composables/useUserSession.js';
 export type { SignOutOptions, UseUserSessionReturn } from './app/composables/useUserSession.js';

package/dist/runtime/composables.js

@@ -5,6 +5,7 @@ export { useAuthClient } from "./app/composables/useAuthClient.js";
 export { useAuthClientAction } from "./app/composables/useAuthClientAction.js";
 export { useAuthRequestFetch } from "./app/composables/useAuthRequestFetch.js";
 export { useSignIn } from "./app/composables/useSignIn.js";
+export { useSignOut } from "./app/composables/useSignOut.js";
 export { useSignUp } from "./app/composables/useSignUp.js";
 export { useUserSession } from "./app/composables/useUserSession.js";
 export { useUserSessionState } from "./app/composables/useUserSessionState.js";

package/dist/runtime/config.d.ts

@@ -9,7 +9,9 @@ export type SchemaCasing = 'snake_case' | 'camelCase';
 export interface ClientAuthContext {
     siteUrl: string;
 }
-export type ServerAuthConfig = Omit<BetterAuthOptions, 'secret' | 'baseURL'> & {
+export type ServerAuthConfig = Omit<BetterAuthOptions, 'secret' | 'baseURL' | 'basePath'> & {
+    /** The module registers its server handler at /api/auth. */
+    basePath?: '/api/auth';
     plugins?: readonly BetterAuthPlugin[];
 };
 export type ClientAuthConfig = Omit<BetterAuthClientOptions, 'baseURL'> & {
@@ -104,7 +106,7 @@ export interface AuthPrivateRuntimeConfig {
     hubSecondaryStorage: boolean | 'custom';
 }
 export declare function defineServerAuth<const R>(config: (ctx: ServerAuthContext) => R & ServerAuthConfig): (ctx: ServerAuthContext) => R;
-export declare function defineServerAuth<const R>(config: R & ServerAuthConfig): (ctx: ServerAuthContext) => R;
+export declare function defineServerAuth<const R>(config: R & ServerAuthConfig & (R extends (...args: never[]) => unknown ? never : unknown)): (ctx: ServerAuthContext) => R;
 export declare function extendServerAuth<const R extends ServerAuthConfig, const P extends readonly BetterAuthPlugin[]>(createConfig: (ctx: ServerAuthContext) => R, plugins: P): (ctx: ServerAuthContext) => ExtendedServerAuthConfig<R, P>;
 export declare function defineClientAuth<T extends ClientAuthConfig>(config: T | ((ctx: ClientAuthContext) => T)): ClientAuthFactory<T>;
 export declare function extendClientAuth<T extends ClientAuthConfig, const P extends BetterAuthClientPlugin[]>(createClient: ClientAuthFactory<T>, plugins: P): ClientAuthFactory<ExtendedClientAuthConfig<T, P>>;

package/dist/runtime/config.js

@@ -1,6 +1,11 @@
 import { createAuthClient } from "better-auth/vue";
 export function defineServerAuth(config) {
-  return typeof config === "function" ? config : () => config;
+  return (ctx) => {
+    const resolved = typeof config === "function" ? config(ctx) : config;
+    if (resolved.basePath !== void 0 && resolved.basePath !== "/api/auth")
+      throw new Error("[nuxt-better-auth] Server basePath must be /api/auth. Remove basePath from defineServerAuth() or set it to /api/auth. External clientOnly backends may use a custom client basePath.");
+    return resolved;
+  };
 }
 export function extendServerAuth(createConfig, plugins) {
   return (ctx) => {

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

@@ -103,13 +103,13 @@ function getNitroOrigin() {
   return `${protocol}://${host}${portSuffix}`;
 }
 function resolveEnvironmentOrigin() {
-  const nitroOrigin = getNitroOrigin();
+  const nitroOrigin = import.meta.dev ? getNitroOrigin() : void 0;
   if (nitroOrigin)
     return { origin: validateURL(nitroOrigin), source: "Nitro environment detection" };
   if (process.env.VERCEL_URL)
     return { origin: validateURL(`https://${process.env.VERCEL_URL}`), source: "VERCEL_URL" };
   if (process.env.CF_PAGES_URL)
-    return { origin: validateURL(`https://${process.env.CF_PAGES_URL}`), source: "CF_PAGES_URL" };
+    return { origin: validateURL(process.env.CF_PAGES_URL), source: "CF_PAGES_URL" };
   if (process.env.URL)
     return { origin: validateURL(process.env.URL.startsWith("http") ? process.env.URL : `https://${process.env.URL}`), source: "URL" };
   return void 0;
@@ -124,7 +124,7 @@ function getBaseURL(event) {
   const configuredSiteUrl = resolveConfiguredSiteUrl(config);
   if (configuredSiteUrl)
     return configuredSiteUrl;
-  const eventOrigin = resolveEventOrigin(event);
+  const eventOrigin = import.meta.dev ? resolveEventOrigin(event) : void 0;
   if (eventOrigin) {
     logInferredBaseURL(eventOrigin, "request origin");
     return eventOrigin;
@@ -139,7 +139,7 @@ function getBaseURL(event) {
     logInferredBaseURL(devFallback.origin, devFallback.source);
     return devFallback.origin;
   }
-  throw new Error("siteUrl required. Set NUXT_PUBLIC_SITE_URL.");
+  throw new Error("siteUrl required in production. Set NUXT_PUBLIC_SITE_URL to the public application URL or provide VERCEL_URL, CF_PAGES_URL, or URL.");
 }
 function dedupeOrigins(origins) {
   return [...new Set(origins)];

package/dist/runtime/server/virtual-modules.d.ts

@@ -8,10 +8,6 @@ declare module '#imports' {
   export function useRuntimeConfig(): any
 }
 
-declare module '#auth/secondary-storage' {
-  export function createSecondaryStorage(...args: any[]): any
-}
-
 declare module '#auth/schema' {
   export const schema: any
 }

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

@@ -18,6 +18,7 @@ export interface AuthSession {
     ipAddress?: string | null;
     userAgent?: string | null;
 }
+export type ClientAuthSession = Omit<AuthSession, 'token'>;
 export interface ServerAuthContext {
     runtimeConfig: Record<string, unknown>;
     db: unknown;
@@ -25,9 +26,13 @@ export interface ServerAuthContext {
 }
 export interface AuthSocialProviderRegistry {
 }
+export interface AuthUserUpdateInput {
+    name?: string;
+    image?: string | null;
+}
 export interface UserSessionComposable {
     user: Ref<AuthUser | null>;
-    session: Ref<AuthSession | null>;
+    session: Ref<ClientAuthSession | null>;
     loggedIn: ComputedRef<boolean>;
     ready: ComputedRef<boolean>;
     fetchSession: (options?: {
@@ -38,7 +43,7 @@ export interface UserSessionComposable {
     signOut: (options?: {
         onSuccess?: () => void | Promise<void>;
     }) => Promise<void>;
-    updateUser: (updates: Partial<AuthUser>) => Promise<void>;
+    updateUser: (updates: AuthUserUpdateInput) => Promise<void>;
 }
 export type UserMatch<T> = {
     [K in keyof T]?: T[K] | T[K][];

package/dist/runtime/types.d.ts

@@ -1,5 +1,5 @@
 import type { AuthSocialProviderRegistry, AuthUser, UserMatch } from '#nuxt-better-auth';
-export type { AppSession, AuthSession, AuthSocialProviderRegistry, AuthUser, RequireSessionOptions, ServerAuthContext, UserMatch, UserSessionComposable } from './types/augment.js';
+export type { AppSession, AuthSession, AuthSocialProviderRegistry, AuthUser, AuthUserUpdateInput, ClientAuthSession, RequireSessionOptions, ServerAuthContext, UserMatch, UserSessionComposable } from './types/augment.js';
 export type AuthSocialProviderId = AuthSocialProviderRegistry extends {
     ids: infer T;
 } ? Extract<T, string> : never;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nuxtjs/better-auth",
   "type": "module",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "Nuxt module for Better Auth integration with NuxtHub, route protection, session management, and role-based access",
   "author": "onmax",
   "license": "MIT",
@@ -81,7 +81,7 @@
     "@types/node": "^24.13.3",
     "better-auth": "1.7.1",
     "better-call": "1.4.0",
-    "better-sqlite3": "^12.6.2",
+    "better-sqlite3": "^12.11.1",
     "drizzle-kit": "^0.31.10",
     "drizzle-orm": "^0.45.2",
     "eslint": "^10.8.1",