@nuxtjs/better-auth 0.3.1 → 0.3.3

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

@@ -1,7 +1,9 @@
 import { matchesUser } from "../../utils/match-user.js";
-import { createAuthError, splitCookiesString } from "../internal/nitro-compat.js";
+import { createAuthError } from "../internal/nitro-compat.js";
+import { appendCookieHeader, appendSetCookieHeaders } 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");
 const signingAlgorithm = { name: "HMAC", hash: "SHA-256" };
 const cookiePairSeparatorRE = /;\s*/;
 const fallbackRequestSessionContext = /* @__PURE__ */ new WeakMap();
@@ -23,9 +25,15 @@ function getIncomingRequestHeaders(event) {
 function getRequestHeaders(event) {
   return getRequestSessionContext(event).requestHeaders ?? getIncomingRequestHeaders(event);
 }
-function loadSession(event) {
+async function loadSession(event) {
   const auth = serverAuth(event);
-  return auth.api.getSession({ headers: getRequestHeaders(event) });
+  const result = await auth.api.getSession({
+    headers: getRequestHeaders(event),
+    returnHeaders: true
+  });
+  if (result && typeof result === "object" && "headers" in result && result.headers instanceof Headers && "response" in result)
+    return result;
+  return { headers: new Headers(), response: result };
 }
 function loadFreshSession(event) {
   const auth = serverAuth(event);
@@ -105,33 +113,11 @@ async function signCookieValue(value, secret) {
 async function serializeSignedCookie(name, value, secret, attributes = {}) {
   return serializeCookieHeader(name, await signCookieValue(value, secret), attributes, true);
 }
-function appendCookieHeader(event, header) {
-  const nodeResponse = event.node?.res;
-  if (nodeResponse?.setHeader) {
-    const current = nodeResponse.getHeader?.("set-cookie");
-    if (Array.isArray(current))
-      nodeResponse.setHeader("set-cookie", [...current, header]);
-    else if (typeof current === "string")
-      nodeResponse.setHeader("set-cookie", [current, header]);
-    else
-      nodeResponse.setHeader("set-cookie", [header]);
-    return;
-  }
-  const eventWithResponse = event;
-  const responseHeaders = eventWithResponse.res?.headers ?? eventWithResponse.response?.headers;
-  responseHeaders?.append("set-cookie", header);
-}
-function getSetCookieHeaders(headers) {
-  const getSetCookie = headers.getSetCookie;
-  const cookies = getSetCookie?.call(headers);
-  if (cookies?.length)
-    return cookies.flatMap((cookie) => splitCookiesString(cookie));
-  const header = headers.get("set-cookie");
-  return header ? splitCookiesString(header) : [];
+function getRequestSessionMutation(context) {
+  return context[requestSessionMutationKey] ?? 0;
 }
-function appendSetCookieHeaders(event, headers) {
-  for (const header of getSetCookieHeaders(headers))
-    appendCookieHeader(event, header);
+function markRequestSessionMutation(context) {
+  context[requestSessionMutationKey] = getRequestSessionMutation(context) + 1;
 }
 function parseRequestCookies(cookieHeader) {
   const cookies = /* @__PURE__ */ new Map();
@@ -199,7 +185,11 @@ export async function getRequestSession(event) {
     return inFlight;
   if (context.requestSession !== void 0)
     return context.requestSession;
-  const load = loadSession(event);
+  const load = loadSession(event).then(({ headers, response }) => {
+    if (context[requestSessionLoadKey] === load)
+      appendSetCookieHeaders(event, headers);
+    return response;
+  });
   context[requestSessionLoadKey] = load;
   try {
     const session = await load;
@@ -218,10 +208,15 @@ export async function getUserSession(event) {
     return inFlight;
   if (context.requestSession !== void 0)
     return context.requestSession;
-  return loadSession(event);
+  const mutation = getRequestSessionMutation(context);
+  const { headers, response } = await loadSession(event);
+  if (getRequestSessionMutation(context) === mutation)
+    appendSetCookieHeaders(event, headers);
+  return response;
 }
 export function setRequestSession(event, session) {
   const context = getRequestSessionContext(event);
+  markRequestSessionMutation(context);
   context.requestSession = session;
   delete context[requestSessionLoadKey];
 }
@@ -239,6 +234,7 @@ export async function refreshSessionCookieCache(event) {
     context.requestSession = response;
     return response;
   });
+  markRequestSessionMutation(context);
   context[requestSessionLoadKey] = load;
   try {
     return await load;
@@ -262,6 +258,7 @@ export async function setSessionCookie(event, token) {
   expireCookies(event, context.authCookies.sessionData);
   expireCookies(event, context.authCookies.dontRememberToken);
   const requestContext = getRequestSessionContext(event);
+  markRequestSessionMutation(requestContext);
   delete requestContext.requestSession;
   delete requestContext[requestSessionLoadKey];
   updateRequestHeaders(event, sessionCookie, [
@@ -271,7 +268,12 @@ export async function setSessionCookie(event, token) {
 }
 export async function createSession(event, userId) {
   const context = await getServerAuthContext(event);
-  return context.internalAdapter.createSession?.(userId, false);
+  if (typeof context.internalAdapter.createSession !== "function") {
+    throw new TypeError(
+      "[@nuxtjs/better-auth] Cannot create a session: the installed Better Auth version does not expose internalAdapter.createSession()."
+    );
+  }
+  return context.internalAdapter.createSession(userId, false);
 }
 export async function requireUserSession(event, options) {
   const session = await getRequestSession(event);

package/dist/runtime/test-utils/e2e.d.ts

@@ -0,0 +1,18 @@
+import type { TestOptions } from '@nuxt/test-utils/e2e';
+import type { AuthSession, AuthUser } from '#nuxt-better-auth';
+import type { LoginResult, TestHelpers } from 'better-auth/plugins';
+export type TestLoginOptions = Parameters<TestHelpers['login']>[0];
+export type TestLoginResult = Omit<LoginResult, 'user' | 'session'> & {
+    user: AuthUser;
+    session: AuthSession;
+};
+/** Create isolated auth fixtures in the Nuxt server started by @nuxt/test-utils. */
+export declare function createAuthTestContext(options?: Partial<TestOptions>): Promise<{
+    setupOptions: Partial<TestOptions>;
+    /** Create a user with Better Auth's factory and track it for cleanup. */
+    createUser: (overrides?: Partial<AuthUser> & Record<string, unknown>) => Promise<AuthUser>;
+    /** Create a real session for a user created by this context. */
+    login(options: TestLoginOptions): Promise<TestLoginResult>;
+    /** Delete users created by this context, including their sessions. */
+    clear(): Promise<void>;
+}>;

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

@@ -0,0 +1,48 @@
+import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { url } from "@nuxt/test-utils/e2e";
+import { parseJSON } from "better-auth/client";
+import { getRandomPort } from "get-port-please";
+import { defu } from "defu";
+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.");
+  const port = options.port || await getRandomPort("127.0.0.1");
+  const siteUrl = `http://127.0.0.1:${port}`;
+  const token = randomUUID();
+  const endpoint = "/api/auth/__test__";
+  const setupOptions = defu({
+    port,
+    dev: false,
+    env: { NUXT_PUBLIC_SITE_URL: siteUrl },
+    nuxtConfig: {
+      test: true,
+      runtimeConfig: { public: { siteUrl } },
+      modules: [[fileURLToPath(new URL("./module", import.meta.url)), { token }]]
+    }
+  }, options);
+  async function call(action, data = {}) {
+    const response = await fetch(url(endpoint), {
+      method: "POST",
+      headers: { "content-type": "application/json", "x-nuxt-auth-test": token },
+      body: JSON.stringify({ action, data })
+    });
+    if (!response.ok)
+      throw new Error(`[nuxt-better-auth] Test helper ${action} failed (${response.status}): ${await response.text()}`);
+    return parseJSON(await response.text());
+  }
+  return {
+    setupOptions,
+    /** Create a user with Better Auth's factory and track it for cleanup. */
+    createUser: (overrides = {}) => call("createUser", overrides),
+    /** Create a real session for a user created by this context. */
+    async login(options2) {
+      const result = await call("login", options2);
+      return { ...result, headers: new Headers(result.headers) };
+    },
+    /** Delete users created by this context, including their sessions. */
+    async clear() {
+      await call("clear");
+    }
+  };
+}

package/dist/runtime/test-utils/module.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@nuxt/schema").NuxtModule<{
+    token: string;
+}, {
+    token: string;
+}, false>;
+export default _default;

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

@@ -0,0 +1,18 @@
+import { addServerHandler, createResolver, defineNuxtModule } from "@nuxt/kit";
+export default defineNuxtModule({
+  meta: { name: "@nuxtjs/better-auth/test-utils" },
+  setup(options, nuxt) {
+    if (!nuxt.options.test || !options.token)
+      throw new Error("[nuxt-better-auth] Auth test helpers must be installed through createAuthTestContext() in a test build.");
+    nuxt.hook("ready", () => {
+      if (!nuxt.options.alias["#auth/server"])
+        throw new Error("[nuxt-better-auth] Auth E2E helpers require a local Better Auth server.");
+    });
+    const resolver = createResolver(import.meta.url);
+    nuxt.hook("better-auth:plugins:extend", (sources) => {
+      sources.server = [...sources.server || [], resolver.resolve("./server/plugin")];
+    });
+    nuxt.options.runtimeConfig.betterAuthTestToken = options.token;
+    addServerHandler({ route: "/api/auth/__test__", method: "post", handler: resolver.resolve("./server/handler") });
+  }
+});

package/dist/runtime/test-utils/runtime.d.ts

@@ -0,0 +1,25 @@
+import type { AuthUser, AuthUserUpdateInput, ClientAuthSession } from '#nuxt-better-auth';
+export interface MockUserSession {
+    user: AuthUser;
+    session: ClientAuthSession;
+}
+/** Reactive replacement for useUserSession in Nuxt runtime tests. */
+export declare function createUserSessionMock(initial?: MockUserSession | null): {
+    setSession: (value: MockUserSession | null, options?: {
+        ready?: boolean;
+    }) => void;
+    reset: () => void;
+    user: import("vue").Ref<AuthUser | null>;
+    session: import("vue").Ref<ClientAuthSession | null>;
+    loggedIn: import("vue").ComputedRef<boolean>;
+    ready: import("vue").ComputedRef<boolean>;
+    fetchSession: (options?: {
+        headers?: HeadersInit;
+        force?: boolean;
+    }) => Promise<void>;
+    waitForSession: () => Promise<void>;
+    signOut: (options?: {
+        onSuccess?: () => void | Promise<void>;
+    }) => Promise<void>;
+    updateUser: (updates: AuthUserUpdateInput) => Promise<void>;
+};

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

@@ -0,0 +1,56 @@
+import { computed, ref, shallowRef, toRaw, watch } from "vue";
+export function createUserSessionMock(initial = null) {
+  function cloneSession(value) {
+    return value && structuredClone({ user: toRaw(value.user), session: toRaw(value.session) });
+  }
+  const initialSession = cloneSession(initial);
+  const user = ref(null);
+  const session = ref(null);
+  const resolved = shallowRef(true);
+  const loggedIn = computed(() => Boolean(user.value && session.value));
+  function setSession(value, options = {}) {
+    const snapshot = cloneSession(value);
+    user.value = snapshot?.user ?? null;
+    session.value = snapshot?.session ?? null;
+    resolved.value = options.ready ?? true;
+  }
+  function reset() {
+    setSession(initialSession);
+  }
+  const auth = {
+    user,
+    session,
+    loggedIn,
+    ready: computed(() => resolved.value),
+    async fetchSession() {
+    },
+    async waitForSession() {
+      if (loggedIn.value)
+        return;
+      await new Promise((resolve) => {
+        let timeout;
+        const stop = watch(loggedIn, (authenticated) => {
+          if (authenticated) {
+            clearTimeout(timeout);
+            stop();
+            resolve();
+          }
+        });
+        timeout = setTimeout(() => {
+          stop();
+          resolve();
+        }, 5e3);
+      });
+    },
+    async signOut(options) {
+      setSession(null);
+      await options?.onSuccess?.();
+    },
+    async updateUser(updates) {
+      if (user.value)
+        user.value = { ...user.value, ...updates };
+    }
+  };
+  reset();
+  return { ...auth, setSession, reset };
+}

package/dist/runtime/test-utils/server/handler.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/test-utils/server/handler.js

@@ -0,0 +1,34 @@
+import { parseJSON } from "better-auth/client";
+import { z } from "zod";
+import { createAuthError, defineEventHandler, toWebRequest, useRuntimeConfig } from "../../server/internal/nitro-compat.js";
+import { serverAuth } from "../../server/utils/auth.js";
+const requestSchema = z.discriminatedUnion("action", [
+  z.object({ action: z.literal("createUser"), data: z.record(z.string(), z.unknown()) }),
+  z.object({ action: z.literal("login"), data: z.object({ userId: z.string() }).passthrough() }),
+  z.object({ action: z.literal("clear") })
+]);
+const ownedUsers = /* @__PURE__ */ new Set();
+export default defineEventHandler(async (event) => {
+  const token = useRuntimeConfig(event).betterAuthTestToken;
+  if (!token || toWebRequest(event).headers.get("x-nuxt-auth-test") !== token)
+    throw createAuthError(404, "Not found");
+  const body = requestSchema.parse(parseJSON(await toWebRequest(event).text()));
+  const context = await serverAuth(event).$context;
+  const test = context.test;
+  if (body.action === "createUser") {
+    const user = await test.saveUser(test.createUser(body.data));
+    ownedUsers.add(user.id);
+    return user;
+  }
+  if (body.action === "login") {
+    if (!ownedUsers.has(body.data.userId))
+      throw createAuthError(403, "Create the user through this test context before logging in.");
+    const result = await test.login(body.data);
+    return { ...result, headers: Array.from(result.headers.entries()) };
+  }
+  for (const id of ownedUsers) {
+    await test.deleteUser(id);
+    ownedUsers.delete(id);
+  }
+  return { ok: true };
+});

package/dist/runtime/test-utils/server/plugin.d.ts

@@ -0,0 +1,23 @@
+declare const _default: {
+    id: "test-utils";
+    version: string;
+    init(ctx: import("better-auth").AuthContext): {
+        context: {
+            test: import("better-auth/plugins").TestHelpers;
+        };
+        options: {
+            databaseHooks: {
+                verification: {
+                    create: {
+                        after(verification: {
+                            identifier: string;
+                            value: string;
+                        } | null): Promise<void>;
+                    };
+                };
+            };
+        } | undefined;
+    };
+    options: import("better-auth/plugins").TestUtilsOptions;
+};
+export default _default;

package/dist/runtime/test-utils/server/plugin.js

@@ -0,0 +1,2 @@
+import { testUtils } from "better-auth/plugins";
+export default testUtils();

package/dist/runtime/types.d.ts

@@ -2,7 +2,7 @@ import type { AuthSocialProviderRegistry, AuthUser, UserMatch } from '#nuxt-bett
 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;
+} ? Extract<T, string> : string;
 export type { Auth, InferPluginTypes, InferSessionFromClient as InferSession, InferUserFromClient as InferUser } from 'better-auth';
 export interface AuthActionError {
     message: string;

package/dist/types.d.mts

@@ -1,11 +1,5 @@
-import type { NuxtModule } from '@nuxt/schema'
+export { type BetterAuthModuleOptions, type ModuleOptions, type defineClientAuth, type defineServerAuth } from '../dist/runtime/config.js'
 
-import type { default as Module } from './module.mjs'
-
-export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
-
-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 AuthSocialProviderId, 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 ClientAuthSession, 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": "@nuxtjs/better-auth",
   "type": "module",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Nuxt module for Better Auth integration with NuxtHub, route protection, session management, and role-based access",
   "author": "onmax",
   "license": "MIT",
@@ -12,7 +12,7 @@
   },
   "exports": {
     ".": {
-      "types": "./dist/types.d.mts",
+      "types": "./dist/module.d.mts",
       "import": "./dist/module.mjs"
     },
     "./composables": {
@@ -22,19 +22,33 @@
     "./config": {
       "types": "./dist/runtime/config.d.ts",
       "import": "./dist/runtime/config.js"
+    },
+    "./test-utils/runtime": {
+      "types": "./dist/runtime/test-utils/runtime.d.ts",
+      "import": "./dist/runtime/test-utils/runtime.js"
+    },
+    "./test-utils/e2e": {
+      "types": "./dist/runtime/test-utils/e2e.d.ts",
+      "import": "./dist/runtime/test-utils/e2e.js"
     }
   },
   "main": "./dist/module.mjs",
   "typesVersions": {
     "*": {
       ".": [
-        "./dist/types.d.mts"
+        "./dist/module.d.mts"
       ],
       "composables": [
         "./dist/runtime/composables.d.ts"
       ],
       "config": [
         "./dist/runtime/config.d.ts"
+      ],
+      "test-utils/runtime": [
+        "./dist/runtime/test-utils/runtime.d.ts"
+      ],
+      "test-utils/e2e": [
+        "./dist/runtime/test-utils/e2e.d.ts"
       ]
     }
   },
@@ -45,10 +59,14 @@
     "node": "^22.19.0 || ^24.11.0 || >=26.0.0"
   },
   "peerDependencies": {
+    "@nuxt/test-utils": "^4.1.0",
     "@nuxthub/core": ">=0.10.5",
     "better-auth": ">=1.7.3 <2"
   },
   "peerDependenciesMeta": {
+    "@nuxt/test-utils": {
+      "optional": true
+    },
     "@nuxthub/core": {
       "optional": true
     }
@@ -56,11 +74,15 @@
   "dependencies": {
     "@nuxt/devtools-kit": "^3.4.1",
     "@nuxt/kit": "^4.5.2",
+    "@types/node": "^24.13.3",
     "auth": "1.7.3",
     "consola": "^3.4.2",
+    "cookie-es": "^3.1.1",
     "defu": "^6.1.7",
+    "get-port-please": "^3.2.0",
     "h3": "^1.15.11",
     "jiti": "^2.7.0",
+    "nostics": "^1.2.0",
     "pathe": "^2.0.3",
     "radix3": "^1.1.2",
     "std-env": "^4.2.0",
@@ -78,17 +100,19 @@
     "@nuxthub/core": "^0.10.8",
     "@pinia/nuxt": "^1.0.2",
     "@types/better-sqlite3": "^9.6.0",
-    "@types/node": "^24.13.3",
+    "@vue/test-utils": "^2.4.6",
     "better-auth": "1.7.3",
     "better-call": "1.4.0",
     "better-sqlite3": "^12.11.1",
     "drizzle-kit": "^0.31.10",
     "drizzle-orm": "^0.45.2",
     "eslint": "^10.8.1",
+    "happy-dom": "^20.8.9",
     "nitropack": "2.13.4",
     "nuxt": "^4.5.2",
     "pinia": "^4.0.3",
     "pkg-pr-new": "0.0.88",
+    "playwright-core": "1.58.2",
     "postgres": "^3.4.9",
     "typescript": "~5.9.3",
     "unstorage": "^1.17.5",
@@ -112,6 +136,7 @@
     "typecheck:runtime-server": "cd test/cases/plugins-type-inference && nuxi prepare && vue-tsc --noEmit --pretty false -p .nuxt/tsconfig.server.json",
     "typecheck:playground": "pnpm -C playground exec nuxi prepare && pnpm -C playground exec vue-tsc --noEmit -p .nuxt/tsconfig.app.json",
     "test": "vitest run",
-    "test:watch": "vitest watch"
+    "test:watch": "vitest watch",
+    "test:runtime": "vitest run --config vitest.runtime.config.ts"
   }
 }