@nuxtjs/better-auth 0.3.5 → 0.3.7

package/dist/module.json

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

package/dist/module.mjs

@@ -13,7 +13,7 @@ import { isCI, isTest } from 'std-env';
 import { isInternalAssetPath } from '../dist/runtime/internal/auth-route-rules.js';
 export { defineClientAuth, defineServerAuth } from '../dist/runtime/config.js';
 
-const version = "0.3.5";
+const version = "0.3.7";
 
 const CONFIG_EXTENSIONS = [".ts", ".js", ".mts", ".cts", ".mjs", ".cjs"];
 const CONFIG_EXTENSION_RE = /\.[cm]?[jt]s$/;
@@ -332,8 +332,7 @@ function registerPrepareTypesHook(input) {
     nodeTsConfig.compilerOptions.paths ||= {};
     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-database.d.ts")
     ];
     if (hasHubDb)
       projectReferenceTypePaths.push(join(nuxt.options.buildDir, "hub/db.d.ts"));
@@ -342,7 +341,8 @@ function registerPrepareTypesHook(input) {
       "#auth/server": nuxt.options.alias["#auth/server"],
       "#auth/client": nuxt.options.alias["#auth/client"],
       "#auth/database": nuxt.options.alias["#auth/database"],
-      "#auth/schema": nuxt.options.alias["#auth/schema"],
+      // An exact .mjs path bypasses declaration lookup in TypeScript paths.
+      "#auth/schema": join(nuxt.options.buildDir, "better-auth/schema"),
       "#auth/route-rules": nuxt.options.alias["#auth/route-rules"]
     };
     for (const [key, value] of Object.entries(exactNodeAliases)) {
@@ -607,6 +607,18 @@ async function setupBetterAuthSchema(nuxt, serverConfigPath, options, consola, h
     const hubCasing = getHubCasing(hub);
     const schemaOptions = { ...options.schema, useUuid: userConfig.advanced?.database?.generateId === "uuid", casing: options.schema?.casing ?? hubCasing };
     const schemaCode = await generateDrizzleSchema(authOptions, dialect, schemaOptions);
+    const { getAuthTables } = await import('better-auth/db');
+    const { initGetModelName } = await import('better-auth/adapters');
+    const authTables = getAuthTables(authOptions);
+    const getModelName = initGetModelName({
+      schema: authTables,
+      usePlural: schemaOptions.usePlural ?? false
+    });
+    const modelNames = {};
+    for (const name of ["user", "session", "account", "verification"]) {
+      if (authTables[name])
+        modelNames[name] = getModelName(name);
+    }
     const schemaDir = join(nuxt.options.buildDir, "better-auth");
     const schemaPathTs = join(schemaDir, `schema.${dialect}.ts`);
     const schemaPathMjs = join(schemaDir, `schema.${dialect}.mjs`);
@@ -622,6 +634,7 @@ async function setupBetterAuthSchema(nuxt, serverConfigPath, options, consola, h
     addTemplate({ filename: `better-auth/schema.${dialect}.ts`, getContents: () => schemaCode, write: true });
     addTemplate({ filename: `better-auth/schema.${dialect}.mjs`, getContents: () => schemaCode, write: true });
     consola.info(`Generated ${dialect} schema (.ts + .mjs)`);
+    return modelNames;
   } catch (error) {
     throw error instanceof Diagnostic ? error : diagnostics.NUXT_AUTH_SCHEMA_GENERATION_FAILED({ cause: error });
   }
@@ -755,7 +768,7 @@ function setupRuntimeConfig(input) {
   if (clientOnly) {
     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.warn("clientOnly mode: set runtimeConfig.public.siteUrl (or NUXT_PUBLIC_SITE_URL) to your auth backend URL, or set baseURL in defineClientAuth()");
     consola.info("clientOnly mode enabled - server utilities (serverAuth, getRequestSession, getUserSession, requireUserSession) are not available");
     return { secondaryStorageEnabled };
   }
@@ -914,7 +927,7 @@ export { db }`;
   return `export function createDatabase() { return undefined }
 export const db = undefined`;
 }
-function buildSchemaExportCode(hasHubDb, hubDialect) {
+function buildSchemaExportCode(hasHubDb, hubDialect, modelNames = {}) {
   if (!hasHubDb) {
     return `export const user = undefined
 export const session = undefined
@@ -927,13 +940,43 @@ export const schema = undefined
 import * as generatedSchema from './schema.${hubDialect}.mjs'
 
 const getGeneratedTable = name => generatedSchema[name] ?? generatedSchema[\`\${name}s\`]
-export const user = getGeneratedTable('user')
-export const session = getGeneratedTable('session')
-export const account = getGeneratedTable('account')
-export const verification = getGeneratedTable('verification')
+export const user = getGeneratedTable(${JSON.stringify(modelNames.user ?? "user")})
+export const session = getGeneratedTable(${JSON.stringify(modelNames.session ?? "session")})
+export const account = getGeneratedTable(${JSON.stringify(modelNames.account ?? "account")})
+export const verification = getGeneratedTable(${JSON.stringify(modelNames.verification ?? "verification")})
 export const schema = { ...generatedSchema, user, session, account, verification }
 `;
 }
+function buildSchemaExportTypes(hasHubDb, hubDialect, modelNames = {}) {
+  if (!hasHubDb) {
+    return `export declare const user: undefined
+export declare const session: undefined
+export declare const account: undefined
+export declare const verification: undefined
+export declare const schema: undefined
+`;
+  }
+  return `export * from './schema.${hubDialect}.js'
+
+type GeneratedSchema = typeof import('./schema.${hubDialect}.js')
+type GeneratedTable<Name extends string> = Name extends keyof GeneratedSchema
+  ? GeneratedSchema[Name]
+  : \`\${Name}s\` extends keyof GeneratedSchema
+    ? GeneratedSchema[\`\${Name}s\`]
+    : undefined
+
+export declare const user: GeneratedTable<${JSON.stringify(modelNames.user ?? "user")}>
+export declare const session: GeneratedTable<${JSON.stringify(modelNames.session ?? "session")}>
+export declare const account: GeneratedTable<${JSON.stringify(modelNames.account ?? "account")}>
+export declare const verification: GeneratedTable<${JSON.stringify(modelNames.verification ?? "verification")}>
+export declare const schema: GeneratedSchema & {
+  user: typeof user
+  session: typeof session
+  account: typeof account
+  verification: typeof verification
+}
+`;
+}
 function buildAuthRouteRulesCode(authRouteRules) {
   return `export const authRouteRules = ${JSON.stringify(authRouteRules, null, 2)}
 `;
@@ -1165,24 +1208,6 @@ declare module '#auth/database' {
   export function createDatabase(event?: import('${h3TypesPath}').H3Event): BetterAuthOptions['database']
   export const db: ${hasHubDb ? `typeof import('@nuxthub/db')['db']` : "undefined"}
 }
-`
-  }, { nitro: true });
-  addTypeTemplate({
-    filename: "types/auth-schema.d.ts",
-    getContents: () => `
-declare module '#auth/schema' {
-  export const user: any
-  export const session: any
-  export const account: any
-  export const verification: any
-  export const schema: {
-    user: any
-    session: any
-    account: any
-    verification: any
-    [key: string]: any
-  } | undefined
-}
 `
   }, { nitro: true });
   addTypeTemplate({
@@ -1190,7 +1215,6 @@ declare module '#auth/schema' {
     getContents: () => `
 /// <reference path="./nitro-imports.d.ts" />
 /// <reference path="./auth-database.d.ts" />
-/// <reference path="./auth-schema.d.ts" />
 ${hasHubDb ? '/// <reference path="../hub/db.d.ts" />' : ""}
 
 export {}
@@ -1646,6 +1670,7 @@ const module$1 = defineNuxtModule({
       });
       let serverConfigPath = setup.aliases["#auth/server"];
       let clientConfigPath = setup.aliases["#auth/client"];
+      let schemaModelNames;
       if (serverConfigPath && setup.pluginSources.server.length) {
         const serverConfigCode = buildExtendedServerAuthCode(setup.configs.server.path, setup.pluginSources.server);
         serverConfigPath = addTemplate({
@@ -1675,10 +1700,15 @@ const module$1 = defineNuxtModule({
         nuxt.options.alias["#auth/database"] = databaseTemplate.dst;
         const schemaTemplate = addTemplate({
           filename: "better-auth/schema.mjs",
-          getContents: () => buildSchemaExportCode(setup.database.hasHubDb, setup.database.buildContext?.hubDialect ?? "sqlite"),
+          getContents: () => buildSchemaExportCode(setup.database.hasHubDb, setup.database.buildContext?.hubDialect ?? "sqlite", schemaModelNames),
           write: true
         });
         nuxt.options.alias["#auth/schema"] = schemaTemplate.dst;
+        addTemplate({
+          filename: "better-auth/schema.d.ts",
+          getContents: () => buildSchemaExportTypes(setup.database.hasHubDb, setup.database.buildContext?.hubDialect ?? "sqlite", schemaModelNames),
+          write: true
+        });
         if (setup.schemaGeneration)
           await ensureSchemaBootstrap(schemaTemplate.dst, setup.database.buildContext?.hubDialect ?? "sqlite");
       }
@@ -1717,7 +1747,7 @@ const module$1 = defineNuxtModule({
       if (setup.schemaGeneration) {
         if (setup.schemaGeneration.externalizeNuxtHubDatabase)
           registerNuxtHubDatabaseExternalHook(nuxt);
-        await setupBetterAuthSchema(
+        schemaModelNames = await setupBetterAuthSchema(
           nuxt,
           serverConfigPath,
           options,

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

@@ -1,5 +1,6 @@
 import createAppAuthClient from "#auth/client";
 import { useRequestURL, useRuntimeConfig } from "#imports";
+import { resolveAuthBaseURL } from "../../internal/auth-base-url.js";
 import { createVueSafeAuthProxy } from "../internal/vue-safe-auth-proxy.js";
 let _client = null;
 let _clientFacade = null;
@@ -27,7 +28,9 @@ export function useRawAuthClient() {
   const requestURL = useRequestURL();
   const configuredSiteUrl = runtimeConfig.public.siteUrl;
   const siteUrl = typeof configuredSiteUrl === "string" && configuredSiteUrl ? configuredSiteUrl : requestURL.origin;
-  return getClient(siteUrl);
+  const clientOnly = runtimeConfig.public.auth?.clientOnly;
+  const appBaseURL = runtimeConfig.app?.baseURL;
+  return getClient(clientOnly ? siteUrl : resolveAuthBaseURL(siteUrl, appBaseURL));
 }
 export function useAuthClient() {
   const rawClient = useRawAuthClient();

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

@@ -11,14 +11,30 @@ export function useAuthRequestFetch() {
   const clientOptions = createAppAuthClient.resolveOptions(siteUrl);
   const configuredBaseURL = clientOptions.baseURL ?? siteUrl;
   const baseURL = configuredBaseURL && new URL(configuredBaseURL).pathname.replace(/\/+$/, "") ? configuredBaseURL : joinURL(configuredBaseURL || "/", clientOptions.basePath ?? "/api/auth");
-  const externalRequestFetch = requestFetch;
-  return ((request, opts) => {
-    if (typeof request !== "string" || !/^\/api\/auth(?=\/|$)/.test(request))
-      return externalRequestFetch(request, opts);
-    return externalRequestFetch(request.slice("/api/auth".length), {
-      ...opts,
-      baseURL,
-      credentials: "include"
+  function wrapRequestFetch(fetch) {
+    const methods = /* @__PURE__ */ new Map();
+    return new Proxy(fetch, {
+      apply(target, thisArg, args) {
+        const [request, opts] = args;
+        if (typeof request !== "string" || !/^\/api\/auth(?=\/|$)/.test(request))
+          return Reflect.apply(target, thisArg, args);
+        return Reflect.apply(target, thisArg, [request.slice("/api/auth".length), {
+          ...opts,
+          baseURL,
+          credentials: "include"
+        }]);
+      },
+      get(target, prop, receiver) {
+        if (methods.has(prop))
+          return methods.get(prop);
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value !== "function" || prop !== "raw" && prop !== "create")
+          return value;
+        const method = prop === "raw" ? wrapRequestFetch(value) : (...args) => wrapRequestFetch(Reflect.apply(value, target, args));
+        methods.set(prop, method);
+        return method;
+      }
     });
-  });
+  }
+  return wrapRequestFetch(requestFetch);
 }

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

@@ -74,6 +74,7 @@ export function useUserSession() {
       return;
     const previousUser = user.value;
     user.value = { ...user.value, ...updates };
+    const optimisticUser = user.value;
     if (!rawClient)
       return;
     try {
@@ -86,7 +87,8 @@ export function useUserSession() {
         throw new Error(normalizedError.message);
       }
     } catch (error) {
-      user.value = previousUser;
+      if (user.value === optimisticUser)
+        user.value = previousUser;
       if (!(error instanceof Error)) {
         const normalizedError = normalizeAuthActionError(error);
         throw new Error(normalizedError.message);

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

@@ -1,5 +1,6 @@
 import { defu } from "defu";
 import { createRouter, toRouteMatcher } from "radix3";
+import { parsePath, parseQuery } from "ufo";
 import { createError, defineNuxtRouteMiddleware, getRouteRules, navigateTo, useNuxtApp, useRequestHeaders, useRuntimeConfig } from "#imports";
 import { shouldSkipAuthRouteRules } from "../../internal/auth-route-rules.js";
 import { matchesUser } from "../../utils/match-user.js";
@@ -64,11 +65,11 @@ function resolveLoginRedirect(input) {
     return { to: loginTarget, external: false };
   if (!loginTarget.startsWith("/") || loginTarget.startsWith("//"))
     return { to: loginTarget, external: false };
-  const [beforeHash, hash = ""] = loginTarget.split("#", 2);
-  const [path, query = ""] = beforeHash.split("?", 2);
+  const { pathname: path, search, hash } = parsePath(loginTarget);
+  const query = search.slice(1);
   try {
-    const params2 = new URLSearchParams(query);
-    if (params2.has(redirectQueryKey))
+    const params = new URLSearchParams(query);
+    if (params.has(redirectQueryKey))
       return { to: loginTarget, external: false };
   } catch {
     return { to: loginTarget, external: false };
@@ -76,15 +77,13 @@ function resolveLoginRedirect(input) {
   if (import.meta.server) {
     const separator = query ? "&" : "";
     const encodedRedirect = encodeURIComponent(route.fullPath);
-    const url = `${path}?${query}${separator}${redirectQueryKey}=${encodedRedirect}${hash ? `#${hash}` : ""}`;
+    const encodedKey = encodeURIComponent(redirectQueryKey);
+    const url = `${path}?${query}${separator}${encodedKey}=${encodedRedirect}${hash}`;
     return { to: url, external: true };
   }
-  const params = new URLSearchParams(query);
-  const queryObj = {};
-  for (const [k, v] of params.entries())
-    queryObj[k] = v;
+  const queryObj = parseQuery(query);
   queryObj[redirectQueryKey] = route.fullPath;
-  return { to: { path, query: queryObj, ...hash ? { hash: `#${hash}` } : {} }, external: false };
+  return { to: { path, query: queryObj, ...hash ? { hash } : {} }, external: false };
 }
 async function getAuthRouteRules() {
   if (!authRouteRulesPromise) {

package/dist/runtime/internal/auth-base-url.d.ts

@@ -0,0 +1,2 @@
+/** Better Auth treats a path in baseURL as the complete auth endpoint path. */
+export declare function resolveAuthBaseURL(siteUrl: string, appBaseURL?: string): string;

package/dist/runtime/internal/auth-base-url.js

@@ -0,0 +1,5 @@
+import { joinURL } from "ufo";
+export function resolveAuthBaseURL(siteUrl, appBaseURL) {
+  const origin = new URL(siteUrl).origin;
+  return appBaseURL && appBaseURL !== "/" ? joinURL(origin, appBaseURL, "/api/auth") : origin;
+}

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

@@ -1,3 +1,5 @@
+import type { Account, Session, User } from 'better-auth/types';
+import type { AnyColumn, Table } from 'drizzle-orm';
 import { z } from 'zod';
 export declare const paginationQuerySchema: z.ZodObject<{
     page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
@@ -6,3 +8,8 @@ export declare const paginationQuerySchema: z.ZodObject<{
 }, z.core.$strip>;
 export type PaginationQuery = z.infer<typeof paginationQuerySchema>;
 export declare function sanitizeSearchPattern(search: string): string;
+export type DevtoolsSchema = {
+    user?: Table & Record<keyof User, AnyColumn>;
+    session?: Table & Record<keyof Session, AnyColumn>;
+    account?: Table & Record<keyof Account, AnyColumn>;
+} | undefined;

package/dist/runtime/server/api/_better-auth/accounts.get.js

@@ -21,7 +21,14 @@ export default defineEventHandler(async (event) => {
       dbQuery.orderBy(desc(schema.account.createdAt)).limit(limit).offset(offset),
       countQuery
     ]);
-    return { accounts, total: totalResult[0]?.count ?? 0, page, limit };
+    const safeAccounts = accounts.map((account) => ({
+      id: account.id,
+      userId: account.userId,
+      providerId: account.providerId,
+      accountId: account.accountId,
+      createdAt: account.createdAt
+    }));
+    return { accounts: safeAccounts, total: totalResult[0]?.count ?? 0, page, limit };
   } catch (error) {
     console.error("[DevTools] Fetch accounts failed:", error);
     return { accounts: [], total: 0, error: "Failed to fetch accounts" };

package/dist/runtime/server/internal/cookie-headers.d.ts

@@ -1,3 +1,4 @@
 import type { ServerEvent } from './nitro-compat.js';
 export declare function appendCookieHeader(event: ServerEvent, header: string): void;
+export declare function getSetCookieHeaders(headers: Headers): string[];
 export declare function appendSetCookieHeaders(event: ServerEvent, headers: Headers): void;

package/dist/runtime/server/internal/cookie-headers.js

@@ -14,7 +14,7 @@ export function appendCookieHeader(event, header) {
   const responseHeaders = eventWithResponse.res?.headers ?? eventWithResponse.response?.headers;
   responseHeaders?.append("set-cookie", header);
 }
-function getSetCookieHeaders(headers) {
+export function getSetCookieHeaders(headers) {
   const cookieHeaders = headers;
   const getSetCookie = cookieHeaders.getSetCookie;
   if (getSetCookie)

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

@@ -1,8 +1,8 @@
 import { betterAuth, env } from "better-auth";
-import { withoutProtocol } from "ufo";
 import { createDatabase, db } from "#auth/database";
 import createServerAuth from "#auth/server";
 import { getRequestHost, getRequestProtocol, useRuntimeConfig } from "../internal/nitro-compat.js";
+import { resolveAuthBaseURL } from "../../internal/auth-base-url.js";
 import { resolveCustomSecondaryStorageRequirement } from "./custom-secondary-storage.js";
 const _authCache = /* @__PURE__ */ new Map();
 const requestAuthKey = Symbol.for("nuxt-better-auth.requestAuth");
@@ -82,33 +82,25 @@ function getNitroOrigin() {
   let port;
   if (import.meta.dev)
     port = process.env.NITRO_PORT || process.env.PORT || "3000";
-  let protocol = cert && key || !import.meta.dev ? "https" : "http";
+  const protocol = cert && key || !import.meta.dev ? "https" : "http";
   try {
     if ((import.meta.dev || import.meta.prerender) && process.env.__NUXT_DEV__) {
-      const origin = JSON.parse(process.env.__NUXT_DEV__).proxy.url;
-      host = withoutProtocol(origin);
-      protocol = origin.includes("https") ? "https" : "http";
+      const url = new URL(JSON.parse(process.env.__NUXT_DEV__).proxy.url);
+      if (url.protocol === "http:" || url.protocol === "https:")
+        return url.origin;
     } else if ((import.meta.dev || import.meta.prerender) && process.env.NUXT_VITE_NODE_OPTIONS) {
-      const origin = JSON.parse(process.env.NUXT_VITE_NODE_OPTIONS).baseURL.replace("/__nuxt_vite_node__", "");
-      host = withoutProtocol(origin);
-      protocol = origin.includes("https") ? "https" : "http";
+      const url = new URL(JSON.parse(process.env.NUXT_VITE_NODE_OPTIONS).baseURL);
+      if (url.protocol === "http:" || url.protocol === "https:")
+        return url.origin;
     }
   } catch {
   }
   if (!host)
     return void 0;
-  if (host.startsWith("[") && host.includes("]:")) {
-    const lastBracketColon = host.lastIndexOf("]:");
-    const extractedPort = host.slice(lastBracketColon + 2);
-    host = host.slice(0, lastBracketColon + 1);
-    if (extractedPort)
-      port = extractedPort;
-  } else if (host.includes(":") && !host.startsWith("[")) {
-    const hostParts = host.split(":");
-    port = hostParts.pop();
-    host = hostParts.join(":");
-  }
-  const portSuffix = port ? `:${port}` : "";
+  if (!host.startsWith("[") && host.indexOf(":") !== host.lastIndexOf(":"))
+    host = `[${host}]`;
+  const hasExplicitPort = host.startsWith("[") ? host.includes("]:") : host.includes(":");
+  const portSuffix = !hasExplicitPort && port ? `:${port}` : "";
   return `${protocol}://${host}${portSuffix}`;
 }
 function resolveEnvironmentOrigin() {
@@ -161,8 +153,7 @@ function getDevTrustedOrigins() {
   try {
     const url = new URL(nitroOrigin);
     const protocol = url.protocol === "https:" ? "https" : "http";
-    const port = url.port || "3000";
-    const localhostOrigin = `${protocol}://localhost:${port}`;
+    const localhostOrigin = `${protocol}://localhost${url.port ? `:${url.port}` : ""}`;
     return dedupeOrigins([localhostOrigin, url.origin]);
   } catch {
     return [fallbackOrigin];
@@ -254,7 +245,7 @@ export function serverAuth(event) {
     ...rateLimit ? { rateLimit } : {},
     ...database ? { database } : {},
     secret: betterAuthSecret,
-    baseURL: siteUrl,
+    baseURL: resolveAuthBaseURL(siteUrl, runtimeConfig.app?.baseURL),
     trustedOrigins
   };
   const auth = betterAuth(authOptions);

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

@@ -1,6 +1,6 @@
 import { matchesUser } from "../../utils/match-user.js";
 import { createAuthError } from "../internal/nitro-compat.js";
-import { appendCookieHeader, appendSetCookieHeaders } from "../internal/cookie-headers.js";
+import { appendCookieHeader, appendSetCookieHeaders, getSetCookieHeaders } from "../internal/cookie-headers.js";
 import { serverAuth } from "./auth.js";
 const requestSessionLoadKey = Symbol.for("nuxt-better-auth.requestSessionLoad");
 const requestSessionMutationKey = Symbol.for("nuxt-better-auth.requestSessionMutation");
@@ -162,6 +162,30 @@ function expireCookies(event, cookie) {
   for (const cookieName of getChunkedCookieNames(event, cookie.name))
     expireCookie(event, cookieName, cookie.attributes);
 }
+function isCookieOrChunk(name, cookieName) {
+  if (name === cookieName)
+    return true;
+  if (!name.startsWith(`${cookieName}.`))
+    return false;
+  const suffix = name.slice(cookieName.length + 1);
+  const index = Number(suffix);
+  return Number.isSafeInteger(index) && index >= 0 && String(index) === suffix;
+}
+function expireUnrefreshedSessionCookieCache(event, headers, cookie) {
+  const cookieName = getCookieName(cookie.name, cookie.attributes.prefix);
+  if (!cookieName)
+    return;
+  const responseHandlesCache = getSetCookieHeaders(headers).some((header) => {
+    const name = header.slice(0, header.indexOf("="));
+    return isCookieOrChunk(name, cookieName);
+  });
+  if (responseHandlesCache)
+    return;
+  for (const name of parseRequestCookies(getRequestHeaders(event).get("cookie")).keys()) {
+    if (isCookieOrChunk(name, cookieName))
+      expireCookie(event, name, cookie.attributes);
+  }
+}
 function updateRequestHeaders(event, sessionCookie, clearedCookieNames) {
   const requestContext = getRequestSessionContext(event);
   const incomingHeaders = getIncomingRequestHeaders(event);
@@ -227,10 +251,14 @@ export async function refreshSessionCookieCache(event) {
     if (context[requestSessionLoadKey] !== load)
       return context.requestSession ?? null;
     delete context.requestSession;
-    const { headers, response } = await loadFreshSession(event);
+    const [{ headers, response }, authContext] = await Promise.all([
+      loadFreshSession(event),
+      getServerAuthContext(event)
+    ]);
     if (context[requestSessionLoadKey] !== load)
       return context.requestSession ?? null;
     appendSetCookieHeaders(event, headers);
+    expireUnrefreshedSessionCookieCache(event, headers, authContext.authCookies.sessionData);
     context.requestSession = response;
     return response;
   });

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

@@ -8,10 +8,6 @@ declare module '#imports' {
   export function useRuntimeConfig(): any
 }
 
-declare module '#auth/schema' {
-  export const schema: any
-}
-
 declare module '#auth/server' {
   const createServerAuth: any
   export default createServerAuth

package/dist/runtime/test-utils/e2e.js

@@ -1,9 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
-import { url } from "@nuxt/test-utils/e2e";
+import { url, useTestContext } from "@nuxt/test-utils/e2e";
 import { parseJSON } from "better-auth/client";
 import { getRandomPort } from "get-port-please";
 import { defu } from "defu";
+import { joinURL } from "ufo";
 export async function createAuthTestContext(options = {}) {
   if (options.host || options.dev || options.build === false || options.server === false)
     throw new Error("[nuxt-better-auth] Auth E2E helpers require a local test build. Use setup() with build and server enabled, without dev or host.");
@@ -22,7 +23,8 @@ export async function createAuthTestContext(options = {}) {
     }
   }, options);
   async function call(action, data = {}) {
-    const response = await fetch(url(endpoint), {
+    const baseURL = useTestContext().nuxt?.options.app.baseURL ?? "/";
+    const response = await fetch(url(joinURL(baseURL, endpoint)), {
       method: "POST",
       headers: { "content-type": "application/json", "x-nuxt-auth-test": token },
       body: JSON.stringify({ action, data })

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nuxtjs/better-auth",
   "type": "module",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Nuxt module for Better Auth integration with NuxtHub, route protection, session management, and role-based access",
   "author": "onmax",
   "license": "MIT",
@@ -75,7 +75,7 @@
     "@nuxt/devtools-kit": "^3.4.1",
     "@nuxt/kit": "^4.5.2",
     "@types/node": "^24.13.3",
-    "auth": "1.7.3",
+    "auth": "1.7.7",
     "consola": "^3.4.2",
     "cookie-es": "^3.1.1",
     "defu": "^6.1.7",
@@ -102,7 +102,7 @@
     "@pinia/nuxt": "^1.0.2",
     "@types/better-sqlite3": "^9.6.0",
     "@vue/test-utils": "^2.4.6",
-    "better-auth": "1.7.3",
+    "better-auth": "1.7.7",
     "better-call": "1.4.0",
     "better-sqlite3": "^12.11.1",
     "drizzle-kit": "^0.31.10",