@onmax/nuxt-better-auth 0.0.2-alpha.9 → 0.0.3

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

@@ -1,32 +1,238 @@
+import { betterAuth } from "better-auth";
+import { getRequestHost, getRequestProtocol } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { withoutProtocol } from "ufo";
 import { createDatabase, db } from "#auth/database";
 import { createSecondaryStorage } from "#auth/secondary-storage";
 import createServerAuth from "#auth/server";
-import { betterAuth } from "better-auth";
-import { consola } from "consola";
-import { getRequestURL } from "h3";
-import { useRuntimeConfig } from "nitropack/runtime";
-const logger = consola.withTag("nuxt-better-auth");
-function getBaseURL(event, siteUrl) {
-  if (siteUrl)
-    return siteUrl;
-  const origin = getRequestURL(event).origin;
-  if (process.env.NODE_ENV === "production")
-    throw new Error("siteUrl must be configured in production. Set NUXT_PUBLIC_SITE_URL or configure in nuxt.config.");
-  logger.warn("siteUrl not set, auto-detected:", origin);
+import { resolveCustomSecondaryStorageRequirement } from "./custom-secondary-storage.js";
+const _authCache = /* @__PURE__ */ new Map();
+const requestAuthKey = Symbol.for("nuxt-better-auth.requestAuth");
+let _baseURLInferenceLogged = false;
+let _customSecondaryStorageMisconfigWarned = false;
+const fallbackRequestAuthContext = /* @__PURE__ */ new WeakMap();
+function getRequestAuthContext(event) {
+  const eventWithContext = event;
+  if (eventWithContext.context && typeof eventWithContext.context === "object")
+    return eventWithContext.context;
+  let context = fallbackRequestAuthContext.get(event);
+  if (!context) {
+    context = {};
+    fallbackRequestAuthContext.set(event, context);
+  }
+  return context;
+}
+function normalizeLoopbackOrigin(origin) {
+  if (!import.meta.dev)
+    return origin;
+  try {
+    const url = new URL(origin);
+    if (url.hostname === "127.0.0.1" || url.hostname === "::1" || url.hostname === "[::1]") {
+      url.hostname = "localhost";
+      return url.origin;
+    }
+  } catch {
+  }
   return origin;
 }
-export async function serverAuth(event) {
-  if (event.context._betterAuth)
-    return event.context._betterAuth;
+function logInferredBaseURL(baseURL, source) {
+  if (!import.meta.dev || _baseURLInferenceLogged)
+    return;
+  _baseURLInferenceLogged = true;
+  console.warn(`[nuxt-better-auth] Using inferred baseURL "${baseURL}" from ${source}. Set runtimeConfig.public.siteUrl for deterministic OAuth callbacks.`);
+}
+function validateURL(url) {
+  try {
+    return normalizeLoopbackOrigin(new URL(url).origin);
+  } catch {
+    throw new Error(`Invalid siteUrl: "${url}". Must be a valid URL.`);
+  }
+}
+function resolveConfiguredSiteUrl(config) {
+  if (typeof config.public.siteUrl !== "string" || !config.public.siteUrl)
+    return void 0;
+  return validateURL(config.public.siteUrl);
+}
+function resolveEventOrigin(event) {
+  if (!event)
+    return void 0;
+  const host = getRequestHost(event, { xForwardedHost: true });
+  const protocol = getRequestProtocol(event, { xForwardedProto: true });
+  if (!host || !protocol)
+    return void 0;
+  try {
+    return validateURL(`${protocol}://${host}`);
+  } catch {
+    return void 0;
+  }
+}
+function getNitroOrigin() {
+  const cert = process.env.NITRO_SSL_CERT;
+  const key = process.env.NITRO_SSL_KEY;
+  let host = process.env.NITRO_HOST || process.env.HOST;
+  let port;
+  if (import.meta.dev)
+    port = process.env.NITRO_PORT || process.env.PORT || "3000";
+  let 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";
+    } 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";
+    }
+  } 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}` : "";
+  return `${protocol}://${host}${portSuffix}`;
+}
+function resolveEnvironmentOrigin() {
+  const nitroOrigin = getNitroOrigin();
+  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" };
+  if (process.env.URL)
+    return { origin: validateURL(process.env.URL.startsWith("http") ? process.env.URL : `https://${process.env.URL}`), source: "URL" };
+  return void 0;
+}
+function resolveDevFallback() {
+  if (!import.meta.dev)
+    return void 0;
+  return { origin: "http://localhost:3000", source: "development fallback" };
+}
+function getBaseURL(event) {
+  const config = useRuntimeConfig();
+  const configuredSiteUrl = resolveConfiguredSiteUrl(config);
+  if (configuredSiteUrl)
+    return configuredSiteUrl;
+  const eventOrigin = resolveEventOrigin(event);
+  if (eventOrigin) {
+    logInferredBaseURL(eventOrigin, "request origin");
+    return eventOrigin;
+  }
+  const environmentOrigin = resolveEnvironmentOrigin();
+  if (environmentOrigin) {
+    logInferredBaseURL(environmentOrigin.origin, environmentOrigin.source);
+    return environmentOrigin.origin;
+  }
+  const devFallback = resolveDevFallback();
+  if (devFallback) {
+    logInferredBaseURL(devFallback.origin, devFallback.source);
+    return devFallback.origin;
+  }
+  throw new Error("siteUrl required. Set NUXT_PUBLIC_SITE_URL.");
+}
+function dedupeOrigins(origins) {
+  return [...new Set(origins)];
+}
+function getDevTrustedOrigins() {
+  const fallbackOrigin = "http://localhost:3000";
+  const nitroOrigin = getNitroOrigin();
+  if (!nitroOrigin)
+    return [fallbackOrigin];
+  try {
+    const url = new URL(nitroOrigin);
+    const protocol = url.protocol === "https:" ? "https" : "http";
+    const port = url.port || "3000";
+    const localhostOrigin = `${protocol}://localhost:${port}`;
+    return dedupeOrigins([localhostOrigin, url.origin]);
+  } catch {
+    return [fallbackOrigin];
+  }
+}
+function getRequestOrigin(request) {
+  if (!request)
+    return void 0;
+  try {
+    return new URL(request.url).origin;
+  } catch {
+    return void 0;
+  }
+}
+function withDevTrustedOrigins(trustedOrigins) {
+  if (!import.meta.dev)
+    return trustedOrigins;
+  const devOrigins = getDevTrustedOrigins();
+  const mergeOrigins = (origins, request) => {
+    const validOrigins = origins.filter((origin) => typeof origin === "string");
+    const requestOrigin = getRequestOrigin(request);
+    return dedupeOrigins(requestOrigin ? [...validOrigins, ...devOrigins, requestOrigin] : [...validOrigins, ...devOrigins]);
+  };
+  if (typeof trustedOrigins === "function") {
+    return async (request) => {
+      const resolvedOrigins = await trustedOrigins(request);
+      return mergeOrigins(resolvedOrigins, request);
+    };
+  }
+  if (Array.isArray(trustedOrigins)) {
+    const baseOrigins = mergeOrigins(trustedOrigins);
+    return async (request) => {
+      return mergeOrigins(baseOrigins, request);
+    };
+  }
+  return async (request) => {
+    return mergeOrigins([], request);
+  };
+}
+export function serverAuth(event) {
   const runtimeConfig = useRuntimeConfig();
-  const database = createDatabase();
-  const userConfig = createServerAuth({ runtimeConfig, db });
-  event.context._betterAuth = betterAuth({
+  const siteUrl = getBaseURL(event);
+  const requestOrigin = resolveEventOrigin(event);
+  const hasExplicitSiteUrl = runtimeConfig.public.siteUrl && typeof runtimeConfig.public.siteUrl === "string";
+  const cacheKey = hasExplicitSiteUrl ? "__explicit__" : siteUrl;
+  const requestContext = event ? getRequestAuthContext(event) : void 0;
+  if (requestContext?.[requestAuthKey])
+    return requestContext[requestAuthKey];
+  const database = createDatabase(event);
+  const userConfig = createServerAuth({ runtimeConfig, db, requestOrigin });
+  const trustedOrigins = withDevTrustedOrigins(userConfig.trustedOrigins);
+  const hubSecondaryStorage = runtimeConfig.auth?.hubSecondaryStorage;
+  const customSecondaryStorage = resolveCustomSecondaryStorageRequirement(hubSecondaryStorage, userConfig.secondaryStorage != null, Boolean(import.meta.dev));
+  if (customSecondaryStorage?.shouldThrow)
+    throw new Error(customSecondaryStorage.message);
+  if (customSecondaryStorage?.shouldWarn && !_customSecondaryStorageMisconfigWarned) {
+    _customSecondaryStorageMisconfigWarned = true;
+    console.warn(customSecondaryStorage.message);
+  }
+  if (!database) {
+    const cached = _authCache.get(cacheKey);
+    if (cached) {
+      if (requestContext)
+        requestContext[requestAuthKey] = cached;
+      return cached;
+    }
+  }
+  const authOptions = {
     ...userConfig,
-    ...database && { database },
-    secondaryStorage: createSecondaryStorage(),
+    ...database ? { database } : {},
+    ...hubSecondaryStorage === true ? { secondaryStorage: createSecondaryStorage() } : {},
     secret: runtimeConfig.betterAuthSecret,
-    baseURL: getBaseURL(event, runtimeConfig.public.siteUrl)
-  });
-  return event.context._betterAuth;
+    baseURL: siteUrl,
+    trustedOrigins
+  };
+  const auth = betterAuth(authOptions);
+  if (requestContext)
+    requestContext[requestAuthKey] = auth;
+  if (!database)
+    _authCache.set(cacheKey, auth);
+  return auth;
 }

package/dist/runtime/server/utils/custom-secondary-storage.d.ts

@@ -0,0 +1,6 @@
+export type HubSecondaryStorageMode = boolean | 'custom' | undefined;
+export declare function resolveCustomSecondaryStorageRequirement(hubSecondaryStorage: HubSecondaryStorageMode, userHasSecondaryStorage: boolean, isDev: boolean): {
+    shouldThrow: boolean;
+    shouldWarn: boolean;
+    message: string;
+} | null;

package/dist/runtime/server/utils/custom-secondary-storage.js

@@ -0,0 +1,8 @@
+export function resolveCustomSecondaryStorageRequirement(hubSecondaryStorage, userHasSecondaryStorage, isDev) {
+  if (hubSecondaryStorage !== "custom")
+    return null;
+  if (userHasSecondaryStorage)
+    return null;
+  const message = '[nuxt-better-auth] hubSecondaryStorage: "custom" requires secondaryStorage in defineServerAuth().';
+  return { shouldThrow: !isDev, shouldWarn: isDev, message };
+}

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

@@ -1,9 +1,8 @@
 import type { H3Event } from 'h3';
-import type { AuthSession, AuthUser, RequireSessionOptions } from '../../types.js';
-interface FullSession {
-    user: AuthUser;
-    session: AuthSession;
-}
-export declare function getUserSession(event: H3Event): Promise<FullSession | null>;
-export declare function requireUserSession(event: H3Event, options?: RequireSessionOptions): Promise<FullSession>;
-export {};
+import type { AppSession, AuthSession, RequireSessionOptions } from '#nuxt-better-auth';
+export declare function getRequestSession(event: H3Event): Promise<AppSession | null>;
+export declare function getUserSession(event: H3Event): Promise<AppSession | null>;
+export declare function refreshSessionCookieCache(event: H3Event): Promise<AppSession | null>;
+export declare function setSessionCookie(event: H3Event, token: string): Promise<void>;
+export declare function createSession(event: H3Event, userId: string): Promise<AuthSession>;
+export declare function requireUserSession(event: H3Event, options?: RequireSessionOptions): Promise<AppSession>;

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

@@ -1,13 +1,264 @@
-import { createError } from "h3";
+import { createError, splitCookiesString } from "h3";
 import { matchesUser } from "../../utils/match-user.js";
 import { serverAuth } from "./auth.js";
+const requestSessionLoadKey = Symbol.for("nuxt-better-auth.requestSessionLoad");
+const signingAlgorithm = { name: "HMAC", hash: "SHA-256" };
+const cookiePairSeparatorRE = /;\s*/;
+const fallbackRequestSessionContext = /* @__PURE__ */ new WeakMap();
+function getRequestSessionContext(event) {
+  const eventWithContext = event;
+  if (eventWithContext.context && typeof eventWithContext.context === "object")
+    return eventWithContext.context;
+  let context = fallbackRequestSessionContext.get(event);
+  if (!context) {
+    context = {};
+    fallbackRequestSessionContext.set(event, context);
+  }
+  return context;
+}
+function getRequestHeaders(event) {
+  return getRequestSessionContext(event).requestHeaders ?? event.headers;
+}
+function loadSession(event) {
+  const auth = serverAuth(event);
+  return auth.api.getSession({ headers: getRequestHeaders(event) });
+}
+function loadFreshSession(event) {
+  const auth = serverAuth(event);
+  return auth.api.getSession({
+    headers: getRequestHeaders(event),
+    query: { disableCookieCache: true },
+    returnHeaders: true
+  });
+}
+function getServerAuthContext(event) {
+  const auth = serverAuth(event);
+  return auth.$context;
+}
+function getCookieName(name, prefix) {
+  if (prefix === "secure")
+    return name.startsWith("__Secure-") ? name : `__Secure-${name}`;
+  if (prefix === "host")
+    return name.startsWith("__Host-") ? name : `__Host-${name}`;
+  if (prefix)
+    return void 0;
+  return name;
+}
+function serializeCookieHeader(name, value, attributes = {}, valueIsEncoded = false) {
+  const cookieName = getCookieName(name, attributes.prefix);
+  if (!cookieName)
+    throw new Error(`Unsupported cookie prefix: ${attributes.prefix}`);
+  const cookieValue = valueIsEncoded ? value : encodeURIComponent(value);
+  const cookie = [`${cookieName}=${cookieValue}`];
+  const options = { ...attributes };
+  if (cookieName.startsWith("__Secure-") && !options.secure)
+    options.secure = true;
+  if (cookieName.startsWith("__Host-")) {
+    options.secure = true;
+    options.path = "/";
+    delete options.domain;
+  }
+  if (typeof options.maxAge === "number" && options.maxAge >= 0)
+    cookie.push(`Max-Age=${Math.floor(options.maxAge)}`);
+  if (options.domain && options.prefix !== "host")
+    cookie.push(`Domain=${options.domain}`);
+  if (options.path)
+    cookie.push(`Path=${options.path}`);
+  if (options.expires)
+    cookie.push(`Expires=${options.expires.toUTCString()}`);
+  if (options.httpOnly)
+    cookie.push("HttpOnly");
+  if (options.partitioned)
+    options.secure = true;
+  if (options.secure)
+    cookie.push("Secure");
+  if (options.sameSite) {
+    const normalizedSameSite = options.sameSite.charAt(0).toUpperCase() + options.sameSite.slice(1);
+    cookie.push(`SameSite=${normalizedSameSite}`);
+  }
+  if (options.partitioned)
+    cookie.push("Partitioned");
+  return cookie.join("; ");
+}
+function serializeCookie(name, value, attributes = {}) {
+  return serializeCookieHeader(name, value, attributes);
+}
+async function signCookieValue(value, secret) {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(secret),
+    signingAlgorithm,
+    false,
+    ["sign", "verify"]
+  );
+  const signature = await crypto.subtle.sign(
+    signingAlgorithm.name,
+    key,
+    new TextEncoder().encode(value)
+  );
+  return encodeURIComponent(`${value}.${btoa(String.fromCharCode(...new Uint8Array(signature)))}`);
+}
+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 responseHeaders = event.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 appendSetCookieHeaders(event, headers) {
+  for (const header of getSetCookieHeaders(headers))
+    appendCookieHeader(event, header);
+}
+function parseRequestCookies(cookieHeader) {
+  const cookies = /* @__PURE__ */ new Map();
+  if (!cookieHeader)
+    return cookies;
+  for (const pair of cookieHeader.split(cookiePairSeparatorRE)) {
+    if (!pair)
+      continue;
+    const separatorIndex = pair.indexOf("=");
+    if (separatorIndex < 0)
+      continue;
+    cookies.set(pair.slice(0, separatorIndex), pair.slice(separatorIndex + 1));
+  }
+  return cookies;
+}
+function serializeRequestCookies(cookies) {
+  if (!cookies.size)
+    return null;
+  return Array.from(cookies.entries()).map(([name, value]) => `${name}=${value}`).join("; ");
+}
+function extractResponseCookieValue(header) {
+  const separatorIndex = header.indexOf(";");
+  const cookiePair = separatorIndex >= 0 ? header.slice(0, separatorIndex) : header;
+  return cookiePair.slice(cookiePair.indexOf("=") + 1);
+}
+function getChunkedCookieNames(event, cookieName) {
+  const cookieNames = /* @__PURE__ */ new Set([cookieName]);
+  for (const name of parseRequestCookies(event.headers.get("cookie")).keys()) {
+    if (name.startsWith(`${cookieName}.`))
+      cookieNames.add(name);
+  }
+  return Array.from(cookieNames);
+}
+function expireCookie(event, cookieName, attributes) {
+  appendCookieHeader(event, serializeCookie(cookieName, "", {
+    ...attributes,
+    expires: /* @__PURE__ */ new Date(0),
+    maxAge: 0
+  }));
+}
+function expireCookies(event, cookie) {
+  for (const cookieName of getChunkedCookieNames(event, cookie.name))
+    expireCookie(event, cookieName, cookie.attributes);
+}
+function updateRequestHeaders(event, sessionCookie, clearedCookieNames) {
+  const requestContext = getRequestSessionContext(event);
+  const requestHeaders = new Headers(event.headers);
+  const cookies = parseRequestCookies(event.headers.get("cookie"));
+  for (const name of clearedCookieNames)
+    cookies.delete(name);
+  const sessionTokenName = sessionCookie.slice(0, sessionCookie.indexOf("="));
+  cookies.set(sessionTokenName, extractResponseCookieValue(sessionCookie));
+  const nextCookieHeader = serializeRequestCookies(cookies);
+  if (nextCookieHeader)
+    requestHeaders.set("cookie", nextCookieHeader);
+  else
+    requestHeaders.delete("cookie");
+  requestContext.requestHeaders = requestHeaders;
+}
+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[requestSessionLoadKey] = load;
+  try {
+    const session = await load;
+    context.requestSession = session;
+    return session;
+  } finally {
+    delete context[requestSessionLoadKey];
+  }
+}
 export async function getUserSession(event) {
-  const auth = await serverAuth(event);
-  const session = await auth.api.getSession({ headers: event.headers });
-  return session;
+  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 refreshSessionCookieCache(event) {
+  const context = getRequestSessionContext(event);
+  const inFlight = context[requestSessionLoadKey];
+  if (inFlight)
+    await inFlight.catch(() => void 0);
+  delete context.requestSession;
+  const load = loadFreshSession(event).then(({ headers, response }) => {
+    appendSetCookieHeaders(event, headers);
+    context.requestSession = response;
+    return response;
+  });
+  context[requestSessionLoadKey] = load;
+  try {
+    return await load;
+  } finally {
+    if (context[requestSessionLoadKey] === load)
+      delete context[requestSessionLoadKey];
+  }
+}
+export async function setSessionCookie(event, token) {
+  const context = await getServerAuthContext(event);
+  const sessionCookie = await serializeSignedCookie(
+    context.authCookies.sessionToken.name,
+    token,
+    context.secret,
+    {
+      ...context.authCookies.sessionToken.attributes,
+      maxAge: context.sessionConfig.expiresIn
+    }
+  );
+  appendCookieHeader(event, sessionCookie);
+  expireCookies(event, context.authCookies.sessionData);
+  expireCookies(event, context.authCookies.dontRememberToken);
+  const requestContext = getRequestSessionContext(event);
+  delete requestContext.requestSession;
+  delete requestContext[requestSessionLoadKey];
+  updateRequestHeaders(event, sessionCookie, [
+    ...getChunkedCookieNames(event, context.authCookies.sessionData.name),
+    ...getChunkedCookieNames(event, context.authCookies.dontRememberToken.name)
+  ]);
+}
+export async function createSession(event, userId) {
+  const context = await getServerAuthContext(event);
+  return context.internalAdapter.createSession?.(userId, false);
 }
 export async function requireUserSession(event, options) {
-  const session = await getUserSession(event);
+  const session = await getRequestSession(event);
   if (!session)
     throw createError({ statusCode: 401, statusMessage: "Authentication required" });
   if (options?.user) {

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

@@ -0,0 +1,27 @@
+declare module '#auth/database' {
+  export const db: any
+  export function createDatabase(...args: any[]): any
+}
+
+declare module '#imports' {
+  export function getRouteRules(event: any): any
+  export function useRuntimeConfig(): any
+}
+
+declare module '#auth/secondary-storage' {
+  export function createSecondaryStorage(...args: any[]): any
+}
+
+declare module '#auth/schema' {
+  export const schema: any
+}
+
+declare module '#auth/server' {
+  const createServerAuth: any
+  export default createServerAuth
+}
+
+declare module '@nuxthub/db' {
+  export const db: any
+  export const schema: any
+}

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

@@ -21,15 +21,15 @@ export interface AuthSession {
 export interface ServerAuthContext {
     runtimeConfig: Record<string, unknown>;
     db: unknown;
+    requestOrigin?: string;
+}
+export interface AuthSocialProviderRegistry {
 }
 export interface UserSessionComposable {
-    client: unknown;
     user: Ref<AuthUser | null>;
     session: Ref<AuthSession | null>;
     loggedIn: ComputedRef<boolean>;
     ready: ComputedRef<boolean>;
-    signIn: unknown;
-    signUp: unknown;
     fetchSession: (options?: {
         headers?: HeadersInit;
         force?: boolean;
@@ -38,5 +38,19 @@ export interface UserSessionComposable {
     signOut: (options?: {
         onSuccess?: () => void | Promise<void>;
     }) => Promise<void>;
-    updateUser: (updates: Partial<AuthUser>) => void;
+    updateUser: (updates: Partial<AuthUser>) => Promise<void>;
+}
+export type UserMatch<T> = {
+    [K in keyof T]?: T[K] | T[K][];
+};
+export interface AppSession {
+    user: AuthUser;
+    session: AuthSession;
+}
+export interface RequireSessionOptions {
+    user?: UserMatch<AuthUser>;
+    rule?: (ctx: {
+        user: AuthUser;
+        session: AuthSession;
+    }) => boolean | Promise<boolean>;
 }

package/dist/runtime/types.d.ts

@@ -1,11 +1,17 @@
 import type { NitroRouteRules } from 'nitropack/types';
-import type { AuthSession, AuthUser } from './types/augment.js';
-export type { AuthSession, AuthUser, ServerAuthContext, UserSessionComposable } from './types/augment.js';
-export type { Auth, InferSession, InferUser } from 'better-auth';
+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 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;
+    code?: string;
+    status?: number;
+    raw: unknown;
+}
 export type AuthMode = 'guest' | 'user';
-export type UserMatch<T> = {
-    [K in keyof T]?: T[K] | T[K][];
-};
 export type AuthMeta = false | AuthMode | {
     only?: AuthMode;
     redirectTo?: string;
@@ -14,10 +20,3 @@ export type AuthMeta = false | AuthMode | {
 export type AuthRouteRules = NitroRouteRules & {
     auth?: AuthMeta;
 };
-export interface RequireSessionOptions {
-    user?: UserMatch<AuthUser>;
-    rule?: (ctx: {
-        user: AuthUser;
-        session: AuthSession;
-    }) => boolean | Promise<boolean>;
-}

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 Auth, 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'