@onmax/nuxt-better-auth 0.0.2-alpha.8 → 0.0.2

package/dist/runtime/config.js

@@ -1,6 +1,13 @@
+import { createAuthClient } from "better-auth/vue";
 export function defineServerAuth(config) {
-  return config;
+  return typeof config === "function" ? config : () => config;
 }
 export function defineClientAuth(config) {
-  return config;
+  return (baseURL) => {
+    const ctx = { siteUrl: baseURL };
+    const resolved = typeof config === "function" ? config(ctx) : config;
+    const { baseURL: configuredBaseURL, ...resolvedOptions } = resolved;
+    const clientOptions = { ...resolvedOptions, baseURL: configuredBaseURL ?? baseURL };
+    return createAuthClient(clientOptions);
+  };
 }

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

@@ -1,8 +1,4 @@
 import { z } from 'zod';
-export declare const paginationQuerySchema: z.ZodObject<{
-    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    search: z.ZodDefault<z.ZodString>;
-}, z.core.$strip>;
+export declare const paginationQuerySchema: any;
 export type PaginationQuery = z.infer<typeof paginationQuerySchema>;
 export declare function sanitizeSearchPattern(search: string): string;

package/dist/runtime/server/api/_better-auth/_schema.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+const SQL_LIKE_ESCAPE_RE = /[%_\\]/g;
 export const paginationQuerySchema = z.object({
   page: z.coerce.number().int().min(1).default(1),
   limit: z.coerce.number().int().min(1).max(100).default(20),
@@ -7,5 +8,5 @@ export const paginationQuerySchema = z.object({
 export function sanitizeSearchPattern(search) {
   if (!search)
     return "";
-  return `%${search.replace(/[%_\\]/g, "\\$&")}%`;
+  return `%${search.replace(SQL_LIKE_ESCAPE_RE, "\\$&")}%`;
 }

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

@@ -7,8 +7,8 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
 } | {
     accounts: any;
     total: any;
-    page: number;
-    limit: number;
+    page: any;
+    limit: any;
     error?: undefined;
 }>>;
 export default _default;

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

@@ -2,8 +2,9 @@ import { defineEventHandler, getQuery } from "h3";
 import { paginationQuerySchema, sanitizeSearchPattern } from "./_schema.js";
 export default defineEventHandler(async (event) => {
   try {
-    const { db, schema } = await import("hub:db");
-    if (!schema.account)
+    const { db } = await import("@nuxthub/db");
+    const { schema } = await import("#auth/schema");
+    if (!schema?.account)
       return { accounts: [], total: 0, error: "Account table not found" };
     const query = paginationQuerySchema.parse(getQuery(event));
     const { page, limit, search } = query;

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

@@ -2,11 +2,16 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     config: {
         module: {
             redirects: {
-                login?: string;
-                guest?: string;
+                login: string;
+                guest: string;
+                authenticated: string | undefined;
+                logout: string | undefined;
             };
-            secondaryStorage: boolean;
+            preserveRedirect: boolean;
+            redirectQueryKey: string;
+            hubSecondaryStorage: boolean | "custom";
             useDatabase: boolean;
+            databaseProvider: "none" | "nuxthub";
         };
         server: {
             baseURL: any;
@@ -14,6 +19,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
             socialProviders: string[];
             plugins: any;
             trustedOrigins: any;
+            configuredTrustedOrigins: any;
             session: {
                 expiresIn: string;
                 updateAge: string;

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

@@ -1,13 +1,16 @@
 import { defineEventHandler } from "h3";
-import { useRuntimeConfig } from "nitropack/runtime";
+import { useRuntimeConfig } from "#imports";
 import { serverAuth } from "../../utils/auth.js";
 export default defineEventHandler(async (event) => {
   try {
-    const auth = await serverAuth(event);
+    const auth = serverAuth(event);
     const options = auth.options;
+    const authContext = await auth.$context;
     const runtimeConfig = useRuntimeConfig();
     const publicAuth = runtimeConfig.public?.auth;
     const privateAuth = runtimeConfig.auth;
+    const configuredTrustedOrigins = Array.isArray(options.trustedOrigins) ? options.trustedOrigins : [];
+    const effectiveTrustedOrigins = authContext?.trustedOrigins || configuredTrustedOrigins;
     const sessionConfig = options.session || {};
     const expiresInDays = sessionConfig.expiresIn ? Math.round(sessionConfig.expiresIn / 86400) : 7;
     const updateAgeDays = sessionConfig.updateAge ? Math.round(sessionConfig.updateAge / 86400) : 1;
@@ -15,9 +18,17 @@ export default defineEventHandler(async (event) => {
       config: {
         // Module config (nuxt.config.ts)
         module: {
-          redirects: publicAuth?.redirects || { login: "/login", guest: "/" },
-          secondaryStorage: privateAuth?.secondaryStorage ?? false,
-          useDatabase: publicAuth?.useDatabase ?? false
+          redirects: {
+            login: publicAuth?.redirects?.login ?? "/login",
+            guest: publicAuth?.redirects?.guest ?? "/",
+            authenticated: publicAuth?.redirects?.authenticated,
+            logout: publicAuth?.redirects?.logout
+          },
+          preserveRedirect: publicAuth?.preserveRedirect ?? true,
+          redirectQueryKey: publicAuth?.redirectQueryKey ?? "redirect",
+          hubSecondaryStorage: privateAuth?.hubSecondaryStorage ?? false,
+          useDatabase: publicAuth?.useDatabase ?? false,
+          databaseProvider: publicAuth?.databaseProvider ?? "none"
         },
         // Server config (server/auth.config.ts)
         server: {
@@ -25,7 +36,8 @@ export default defineEventHandler(async (event) => {
           basePath: options.basePath || "/api/auth",
           socialProviders: Object.keys(options.socialProviders || {}),
           plugins: (options.plugins || []).map((p) => p.id || "unknown"),
-          trustedOrigins: options.trustedOrigins || [],
+          trustedOrigins: effectiveTrustedOrigins,
+          configuredTrustedOrigins,
           session: {
             expiresIn: `${expiresInDays} days`,
             updateAge: `${updateAgeDays} days`,

package/dist/runtime/server/api/_better-auth/sessions.delete.js

@@ -6,8 +6,9 @@ const deleteSessionSchema = z.object({
 export default defineEventHandler(async (event) => {
   try {
     const body = deleteSessionSchema.parse(await readBody(event));
-    const { db, schema } = await import("hub:db");
-    if (!schema.session)
+    const { db } = await import("@nuxthub/db");
+    const { schema } = await import("#auth/schema");
+    if (!schema?.session)
       throw createError({ statusCode: 500, message: "Session table not found" });
     const { eq } = await import("drizzle-orm");
     await db.delete(schema.session).where(eq(schema.session.id, body.id));

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

@@ -1,3 +1,5 @@
+import type { Session } from 'better-auth/types';
+type SafeSession = Pick<Session, 'id' | 'userId' | 'createdAt' | 'updatedAt' | 'expiresAt' | 'ipAddress' | 'userAgent'>;
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
     sessions: never[];
     total: number;
@@ -5,10 +7,10 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     page?: undefined;
     limit?: undefined;
 } | {
-    sessions: any;
+    sessions: SafeSession[];
     total: any;
-    page: number;
-    limit: number;
+    page: any;
+    limit: any;
     error?: undefined;
 }>>;
 export default _default;

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

@@ -2,8 +2,9 @@ import { defineEventHandler, getQuery } from "h3";
 import { paginationQuerySchema, sanitizeSearchPattern } from "./_schema.js";
 export default defineEventHandler(async (event) => {
   try {
-    const { db, schema } = await import("hub:db");
-    if (!schema.session)
+    const { db } = await import("@nuxthub/db");
+    const { schema } = await import("#auth/schema");
+    if (!schema?.session)
       return { sessions: [], total: 0, error: "Session table not found" };
     const query = paginationQuerySchema.parse(getQuery(event));
     const { page, limit, search } = query;

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

@@ -7,8 +7,8 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
 } | {
     users: any;
     total: any;
-    page: number;
-    limit: number;
+    page: any;
+    limit: any;
     error?: undefined;
 }>>;
 export default _default;

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

@@ -2,8 +2,9 @@ import { defineEventHandler, getQuery } from "h3";
 import { paginationQuerySchema, sanitizeSearchPattern } from "./_schema.js";
 export default defineEventHandler(async (event) => {
   try {
-    const { db, schema } = await import("hub:db");
-    if (!schema.user)
+    const { db } = await import("@nuxthub/db");
+    const { schema } = await import("#auth/schema");
+    if (!schema?.user)
       return { users: [], total: 0, error: "User table not found" };
     const query = paginationQuerySchema.parse(getQuery(event));
     const { page, limit, search } = query;

package/dist/runtime/server/api/auth/[...all].js

@@ -1,6 +1,6 @@
 import { defineEventHandler, toWebRequest } from "h3";
 import { serverAuth } from "../../utils/auth.js";
 export default defineEventHandler(async (event) => {
-  const auth = await serverAuth(event);
+  const auth = serverAuth(event);
   return auth.handler(toWebRequest(event));
 });

package/dist/runtime/server/middleware/route-access.js

@@ -1,6 +1,7 @@
 import { createError, defineEventHandler, getRequestURL } from "h3";
-import { getRouteRules } from "nitropack/runtime";
+import { getRouteRules } from "#imports";
 import { matchesUser } from "../../utils/match-user.js";
+import { getUserSession, requireUserSession } from "../utils/session.js";
 export default defineEventHandler(async (event) => {
   const path = getRequestURL(event).pathname;
   if (!path.startsWith("/api/"))

package/dist/runtime/server/tsconfig.json

@@ -1,3 +1,11 @@
 {
-  "extends": "../../../.nuxt/tsconfig.server.json"
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "#nuxt-better-auth": ["../types/augment"]
+    }
+  },
+  "include": ["./**/*.ts", "./**/*.d.ts"],
+  "exclude": ["node_modules"]
 }

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

@@ -1,11 +1,19 @@
-import type { Auth } from 'better-auth';
+import type { BetterAuthOptions } from 'better-auth';
 import type { H3Event } from 'h3';
+import { betterAuth } from 'better-auth';
 import createServerAuth from '#auth/server';
-type AuthInstance = Auth<ReturnType<typeof createServerAuth>>;
-declare module 'h3' {
-    interface H3EventContext {
-        _betterAuth?: AuthInstance;
-    }
-}
-export declare function serverAuth(event: H3Event): Promise<AuthInstance>;
+type AuthOptions = ReturnType<typeof createServerAuth>;
+type UserAuthConfig = AuthOptions & {
+    trustedOrigins?: BetterAuthOptions['trustedOrigins'];
+    secondaryStorage?: BetterAuthOptions['secondaryStorage'];
+};
+type ResolvedAuthOptions = UserAuthConfig & {
+    secret: string;
+    baseURL: string;
+    trustedOrigins?: BetterAuthOptions['trustedOrigins'];
+    database?: BetterAuthOptions['database'];
+};
+type AuthInstance = ReturnType<typeof betterAuth<ResolvedAuthOptions>>;
+/** Returns Better Auth instance. Caches per resolved host (or single instance when siteUrl is explicit). */
+export declare function serverAuth(event?: H3Event): AuthInstance;
 export {};

package/dist/runtime/server/utils/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,7 @@
 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 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>;