@onmax/nuxt-better-auth 0.0.2-alpha.2 → 0.0.2-alpha.21

package/dist/runtime/adapters/convex.d.ts

@@ -0,0 +1,111 @@
+import type { FunctionReference } from 'convex/server';
+interface ConvexCleanedWhere {
+    field: string;
+    value: string | number | boolean | string[] | number[] | null;
+    operator?: 'lt' | 'lte' | 'gt' | 'gte' | 'eq' | 'in' | 'not_in' | 'ne' | 'contains' | 'starts_with' | 'ends_with';
+    connector?: 'AND' | 'OR';
+}
+interface PaginationResult<T> {
+    page: T[];
+    isDone: boolean;
+    continueCursor: string | null;
+    splitCursor?: string;
+    pageStatus?: 'SplitRecommended' | 'SplitRequired' | string;
+    count?: number;
+}
+interface ConvexAuthApi {
+    create: FunctionReference<'mutation', 'public', {
+        input: {
+            model: string;
+            data: Record<string, unknown>;
+        };
+        select?: string[];
+    }, unknown>;
+    findOne: FunctionReference<'query', 'public', {
+        model: string;
+        where?: ConvexCleanedWhere[];
+        select?: string[];
+    }, unknown>;
+    findMany: FunctionReference<'query', 'public', {
+        model: string;
+        where?: ConvexCleanedWhere[];
+        limit?: number;
+        sortBy?: {
+            direction: 'asc' | 'desc';
+            field: string;
+        };
+        paginationOpts: {
+            numItems: number;
+            cursor: string | null;
+        };
+    }, PaginationResult<unknown>>;
+    updateOne: FunctionReference<'mutation', 'public', {
+        input: {
+            model: string;
+            where?: ConvexCleanedWhere[];
+            update: Record<string, unknown>;
+        };
+    }, unknown>;
+    updateMany: FunctionReference<'mutation', 'public', {
+        input: {
+            model: string;
+            where?: ConvexCleanedWhere[];
+            update: Record<string, unknown>;
+        };
+        paginationOpts: {
+            numItems: number;
+            cursor: string | null;
+        };
+    }, PaginationResult<unknown> & {
+        count: number;
+    }>;
+    deleteOne: FunctionReference<'mutation', 'public', {
+        input: {
+            model: string;
+            where?: ConvexCleanedWhere[];
+        };
+    }, unknown>;
+    deleteMany: FunctionReference<'mutation', 'public', {
+        input: {
+            model: string;
+            where?: ConvexCleanedWhere[];
+        };
+        paginationOpts: {
+            numItems: number;
+            cursor: string | null;
+        };
+    }, PaginationResult<unknown> & {
+        count: number;
+    }>;
+}
+export interface ConvexHttpAdapterOptions {
+    /** Convex deployment URL (e.g., https://your-app.convex.cloud) */
+    url: string;
+    /** Convex API functions for auth operations - import from your convex/_generated/api */
+    api: ConvexAuthApi;
+    /** Enable debug logging for adapter operations */
+    debugLogs?: boolean;
+}
+/**
+ * Creates a Better Auth adapter that communicates with Convex via HTTP.
+ * Uses ConvexHttpClient for server-side auth operations.
+ *
+ * @example
+ * ```ts
+ * import { api } from '~/convex/_generated/api'
+ *
+ * export default defineServerAuth(() => ({
+ *   database: createConvexHttpAdapter({
+ *     url: process.env.CONVEX_URL!,
+ *     api: api.auth,
+ *   }),
+ * }))
+ * ```
+ *
+ * @limitations
+ * - `update()` only supports AND-connected where clauses (no OR support)
+ * - `count()` fetches all documents client-side (Convex limitation)
+ * - `offset` pagination not supported in `findMany()`
+ */
+export declare function createConvexHttpAdapter(options: ConvexHttpAdapterOptions): import("better-auth/adapters").AdapterFactory;
+export {};

package/dist/runtime/adapters/convex.js

@@ -0,0 +1,213 @@
+import { createAdapterFactory } from "better-auth/adapters";
+import { ConvexHttpClient } from "convex/browser";
+function parseWhere(where) {
+  if (!where)
+    return [];
+  const whereArray = Array.isArray(where) ? where : [where];
+  return whereArray.map((w) => {
+    if (w.value instanceof Date)
+      return { ...w, value: w.value.getTime() };
+    return w;
+  });
+}
+async function handlePagination(next, { limit } = {}) {
+  const state = { isDone: false, cursor: null, docs: [], count: 0 };
+  const onResult = (result) => {
+    state.cursor = result.pageStatus === "SplitRecommended" || result.pageStatus === "SplitRequired" ? result.splitCursor ?? result.continueCursor : result.continueCursor;
+    if (result.page) {
+      state.docs.push(...result.page);
+      state.isDone = limit && state.docs.length >= limit || result.isDone;
+      return;
+    }
+    if (result.count) {
+      state.count += result.count;
+      state.isDone = limit && state.count >= limit || result.isDone;
+      return;
+    }
+    state.isDone = result.isDone;
+  };
+  do {
+    const result = await next({
+      paginationOpts: {
+        numItems: Math.min(200, (limit ?? 200) - state.docs.length, 200),
+        cursor: state.cursor
+      }
+    });
+    onResult(result);
+  } while (!state.isDone);
+  return state;
+}
+export function createConvexHttpAdapter(options) {
+  if (!options.url.startsWith("https://") || !options.url.includes(".convex.")) {
+    throw new Error(`Invalid Convex URL: ${options.url}. Expected format: https://your-app.convex.cloud`);
+  }
+  const client = new ConvexHttpClient(options.url);
+  return createAdapterFactory({
+    config: {
+      adapterId: "convex-http",
+      adapterName: "Convex HTTP Adapter",
+      debugLogs: options.debugLogs ?? false,
+      disableIdGeneration: true,
+      transaction: false,
+      supportsNumericIds: false,
+      supportsJSON: false,
+      supportsDates: false,
+      supportsArrays: true,
+      usePlural: false,
+      mapKeysTransformInput: { id: "_id" },
+      mapKeysTransformOutput: { _id: "id" },
+      customTransformInput: ({ data, fieldAttributes }) => {
+        if (data && fieldAttributes.type === "date")
+          return new Date(data).getTime();
+        return data;
+      },
+      customTransformOutput: ({ data, fieldAttributes }) => {
+        if (data && fieldAttributes.type === "date")
+          return new Date(data).getTime();
+        return data;
+      }
+    },
+    adapter: ({ options: authOptions }) => {
+      authOptions.telemetry = { enabled: false };
+      return {
+        id: "convex-http",
+        create: async ({ model, data, select }) => {
+          return client.mutation(options.api.create, {
+            input: { model, data },
+            select
+          });
+        },
+        findOne: async (data) => {
+          if (data.where?.every((w) => w.connector === "OR")) {
+            for (const w of data.where) {
+              const result = await client.query(options.api.findOne, {
+                ...data,
+                model: data.model,
+                where: parseWhere(w)
+              });
+              if (result)
+                return result;
+            }
+            return null;
+          }
+          return client.query(options.api.findOne, {
+            ...data,
+            model: data.model,
+            where: parseWhere(data.where)
+          });
+        },
+        findMany: async (data) => {
+          if (data.offset)
+            throw new Error("offset not supported");
+          if (data.where?.some((w) => w.connector === "OR")) {
+            const results = await Promise.all(
+              data.where.map(
+                async (w) => handlePagination(async ({ paginationOpts }) => {
+                  return client.query(options.api.findMany, {
+                    ...data,
+                    model: data.model,
+                    where: parseWhere(w),
+                    paginationOpts
+                  });
+                }, { limit: data.limit })
+              )
+            );
+            const allDocs = results.flatMap((r) => r.docs);
+            const uniqueDocs = [...new Map(allDocs.map((d) => [d._id, d])).values()];
+            if (data.sortBy) {
+              return uniqueDocs.sort((a, b) => {
+                const aVal = a[data.sortBy.field];
+                const bVal = b[data.sortBy.field];
+                const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+                return data.sortBy.direction === "asc" ? cmp : -cmp;
+              });
+            }
+            return uniqueDocs;
+          }
+          const result = await handlePagination(
+            async ({ paginationOpts }) => client.query(options.api.findMany, {
+              ...data,
+              model: data.model,
+              where: parseWhere(data.where),
+              paginationOpts
+            }),
+            { limit: data.limit }
+          );
+          return result.docs;
+        },
+        // Note: Convex doesn't have a native count query, so we fetch all docs and count client-side.
+        // This is inefficient for large datasets but acceptable for auth tables (typically small).
+        count: async (data) => {
+          if (data.where?.some((w) => w.connector === "OR")) {
+            const results = await Promise.all(
+              data.where.map(
+                async (w) => handlePagination(async ({ paginationOpts }) => {
+                  return client.query(options.api.findMany, {
+                    ...data,
+                    model: data.model,
+                    where: parseWhere(w),
+                    paginationOpts
+                  });
+                })
+              )
+            );
+            const allDocs = results.flatMap((r) => r.docs);
+            const uniqueDocs = [...new Map(allDocs.map((d) => [d._id, d])).values()];
+            return uniqueDocs.length;
+          }
+          const result = await handlePagination(async ({ paginationOpts }) => client.query(options.api.findMany, {
+            ...data,
+            model: data.model,
+            where: parseWhere(data.where),
+            paginationOpts
+          }));
+          return result.docs.length;
+        },
+        // Supports single eq or multiple AND-connected conditions (Better Auth's common patterns)
+        update: async (data) => {
+          const hasOrConnector = data.where?.some((w) => w.connector === "OR");
+          if (hasOrConnector) {
+            throw new Error("update() does not support OR conditions - use updateMany() or split into multiple calls");
+          }
+          return client.mutation(options.api.updateOne, {
+            input: {
+              model: data.model,
+              where: parseWhere(data.where),
+              update: data.update
+            }
+          });
+        },
+        updateMany: async (data) => {
+          const result = await handlePagination(async ({ paginationOpts }) => client.mutation(options.api.updateMany, {
+            input: {
+              ...data,
+              model: data.model,
+              where: parseWhere(data.where)
+            },
+            paginationOpts
+          }));
+          return result.count;
+        },
+        delete: async (data) => {
+          await client.mutation(options.api.deleteOne, {
+            input: {
+              model: data.model,
+              where: parseWhere(data.where)
+            }
+          });
+        },
+        deleteMany: async (data) => {
+          const result = await handlePagination(async ({ paginationOpts }) => client.mutation(options.api.deleteMany, {
+            input: {
+              ...data,
+              model: data.model,
+              where: parseWhere(data.where)
+            },
+            paginationOpts
+          }));
+          return result.count;
+        }
+      };
+    }
+  });
+}

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

@@ -1,4 +1,5 @@
 <script setup>
+import { useUserSession } from "#imports";
 const { loggedIn, user, session, signOut, ready } = useUserSession();
 </script>
 

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

@@ -1,20 +1,22 @@
-import type { AuthUser } from '#nuxt-better-auth';
+import type { AppAuthClient, AuthSession, AuthUser } from '#nuxt-better-auth';
+import type { ComputedRef, Ref } from 'vue';
 export interface SignOutOptions {
     onSuccess?: () => void | Promise<void>;
 }
-export declare function useUserSession(): {
-    client: any;
-    session: any;
-    user: any;
-    loggedIn: any;
-    ready: any;
-    signIn: any;
-    signUp: any;
-    signOut: (options?: SignOutOptions) => Promise<any>;
+export interface UseUserSessionReturn {
+    client: AppAuthClient | null;
+    session: Ref<AuthSession | null>;
+    user: Ref<AuthUser | null>;
+    loggedIn: ComputedRef<boolean>;
+    ready: ComputedRef<boolean>;
+    signIn: NonNullable<AppAuthClient>['signIn'];
+    signUp: NonNullable<AppAuthClient>['signUp'];
+    signOut: (options?: SignOutOptions) => Promise<void>;
     waitForSession: () => Promise<void>;
     fetchSession: (options?: {
         headers?: HeadersInit;
         force?: boolean;
     }) => Promise<void>;
     updateUser: (updates: Partial<AuthUser>) => void;
-};
+}
+export declare function useUserSession(): UseUserSessionReturn;

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

@@ -1,6 +1,5 @@
-import { createAppAuthClient } from "#auth/client";
+import createAppAuthClient from "#auth/client";
 import { computed, nextTick, useRequestHeaders, useRequestURL, useRuntimeConfig, useState, watch } from "#imports";
-import { consola } from "consola";
 let _client = null;
 function getClient(baseURL) {
   if (!_client)
@@ -30,7 +29,8 @@ export function useUserSession() {
       () => clientSession.value,
       (newSession) => {
         if (newSession?.data?.session && newSession?.data?.user) {
-          session.value = newSession.data.session;
+          const { token: _, ...safeSession } = newSession.data.session;
+          session.value = safeSession;
           user.value = newSession.data.user;
         } else if (!newSession?.isPending) {
           clearSession();
@@ -82,10 +82,11 @@ export function useUserSession() {
   }
   const signIn = client?.signIn ? new Proxy(client.signIn, {
     get(target, prop) {
-      const method = target[prop];
+      const targetRecord = target;
+      const method = targetRecord[prop];
       if (typeof method !== "function")
         return method;
-      return wrapAuthMethod((...args) => target[prop](...args));
+      return wrapAuthMethod((...args) => targetRecord[prop](...args));
     }
   }) : new Proxy({}, {
     get: (_, prop) => {
@@ -94,10 +95,11 @@ export function useUserSession() {
   });
   const signUp = client?.signUp ? new Proxy(client.signUp, {
     get(target, prop) {
-      const method = target[prop];
+      const targetRecord = target;
+      const method = targetRecord[prop];
       if (typeof method !== "function")
         return method;
-      return wrapAuthMethod((...args) => target[prop](...args));
+      return wrapAuthMethod((...args) => targetRecord[prop](...args));
     }
   }) : new Proxy({}, {
     get: (_, prop) => {
@@ -118,15 +120,15 @@ export function useUserSession() {
         const result = await client.getSession({ query }, fetchOptions);
         const data = result.data;
         if (data?.session && data?.user) {
-          session.value = data.session;
+          const { token: _, ...safeSession } = data.session;
+          session.value = safeSession;
           user.value = data.user;
         } else {
           clearSession();
         }
       } catch (error) {
         clearSession();
-        if (import.meta.dev)
-          consola.error("Failed to fetch auth session:", error);
+        console.error("[nuxt-better-auth] Failed to fetch session:", error);
       } finally {
         if (!authReady.value)
           authReady.value = true;
@@ -136,11 +138,10 @@ export function useUserSession() {
   async function signOut(options) {
     if (!client)
       throw new Error("signOut can only be called on client-side");
-    const response = await client.signOut();
+    await client.signOut();
     clearSession();
     if (options?.onSuccess)
       await options.onSuccess();
-    return response;
   }
   return {
     client,

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

@@ -1,6 +1,12 @@
-import { createError, defineNuxtRouteMiddleware, getRouteRules, navigateTo, useRequestHeaders, useRuntimeConfig } from "#imports";
+import { createError, defineNuxtRouteMiddleware, getRouteRules, navigateTo, useNuxtApp, useRequestHeaders, useRuntimeConfig, useUserSession } from "#imports";
 import { matchesUser } from "../../utils/match-user.js";
 export default defineNuxtRouteMiddleware(async (to) => {
+  const nuxtApp = useNuxtApp();
+  if (import.meta.client) {
+    const isPrerendered = nuxtApp.payload.prerenderedAt || nuxtApp.payload.isCached;
+    if (isPrerendered && nuxtApp.isHydrating)
+      return;
+  }
   if (to.meta.auth === void 0) {
     const rules = await getRouteRules({ path: to.path });
     if (rules.auth !== void 0)

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

@@ -1,5 +1,4 @@
-import { defineNuxtPlugin } from "#imports";
-import { useUserSession } from "../composables/useUserSession.js";
+import { defineNuxtPlugin, useUserSession } from "#imports";
 export default defineNuxtPlugin(async (nuxtApp) => {
   const { fetchSession } = useUserSession();
   const safeFetch = async () => {

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

@@ -12,7 +12,8 @@ export default defineNuxtPlugin({
         const headers = useRequestHeaders(["cookie"]);
         const data = await $fetch("/api/auth/get-session", { headers });
         if (data?.session && data?.user) {
-          session.value = data.session;
+          const { token: _, ...safeSession } = data.session;
+          session.value = safeSession;
           user.value = data.user;
         }
       } catch {

package/dist/runtime/config.d.ts

@@ -1,17 +1,21 @@
 import type { BetterAuthOptions } from 'better-auth';
-import type { ClientOptions } from 'better-auth/client';
+import type { BetterAuthClientOptions } from 'better-auth/client';
+import type { CasingOption } from '../schema-generator.js';
 import type { ServerAuthContext } from './types/augment.js';
+import { createAuthClient } from 'better-auth/vue';
 export type { ServerAuthContext };
 export interface ClientAuthContext {
     siteUrl: string;
 }
-type ServerAuthConfig = Omit<BetterAuthOptions, 'database' | 'secret' | 'baseURL'>;
-type ClientAuthConfig = Omit<ClientOptions, 'baseURL'> & {
+export type ServerAuthConfig = Omit<BetterAuthOptions, 'database' | 'secret' | 'baseURL'>;
+export type ClientAuthConfig = Omit<BetterAuthClientOptions, 'baseURL'> & {
     baseURL?: string;
 };
 export type ServerAuthConfigFn = (ctx: ServerAuthContext) => ServerAuthConfig;
 export type ClientAuthConfigFn = (ctx: ClientAuthContext) => ClientAuthConfig;
 export interface BetterAuthModuleOptions {
+    /** Client-only mode - skip server setup for external auth backends */
+    clientOnly?: boolean;
     /** Server config path relative to rootDir. Default: 'server/auth.config' */
     serverConfig?: string;
     /** Client config path relative to rootDir. Default: 'app/auth.config' */
@@ -22,15 +26,24 @@ export interface BetterAuthModuleOptions {
     };
     /** Enable KV secondary storage for sessions. Requires hub.kv: true */
     secondaryStorage?: boolean;
+    /** Schema generation options. Must match drizzleAdapter config. */
+    schema?: {
+        /** Plural table names: user → users. Default: false */
+        usePlural?: boolean;
+        /** Column/table name casing. Explicit value takes precedence over hub.db.casing. */
+        casing?: CasingOption;
+    };
 }
 export interface AuthRuntimeConfig {
     redirects: {
         login: string;
         guest: string;
     };
+    useDatabase: boolean;
+    clientOnly: boolean;
 }
 export interface AuthPrivateRuntimeConfig {
     secondaryStorage: boolean;
 }
-export declare function defineServerAuth<T extends ServerAuthConfig>(config: (ctx: ServerAuthContext) => T): (ctx: ServerAuthContext) => T;
-export declare function defineClientAuth(config: ClientAuthConfigFn): ClientAuthConfigFn;
+export declare function defineServerAuth<T extends ServerAuthConfig>(config: T | ((ctx: ServerAuthContext) => T)): (ctx: ServerAuthContext) => T;
+export declare function defineClientAuth<T extends ClientAuthConfig>(config: T | ((ctx: ClientAuthContext) => T)): (baseURL: string) => ReturnType<typeof createAuthClient<T>>;

package/dist/runtime/config.js

@@ -1,6 +1,11 @@
+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;
+    return createAuthClient({ ...resolved, baseURL });
+  };
 }

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

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

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

@@ -9,27 +9,27 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
             useDatabase: boolean;
         };
         server: {
-            baseURL: string | undefined;
-            basePath: string;
+            baseURL: any;
+            basePath: any;
             socialProviders: string[];
-            plugins: any[];
-            trustedOrigins: string[] | ((request: Request) => string[] | Promise<string[]>);
+            plugins: any;
+            trustedOrigins: any;
             session: {
                 expiresIn: string;
                 updateAge: string;
-                cookieCache: boolean;
+                cookieCache: any;
             };
             emailAndPassword: boolean;
-            rateLimit: boolean;
+            rateLimit: any;
             advanced: {
-                useSecureCookies: string | boolean;
-                disableCSRFCheck: boolean;
+                useSecureCookies: any;
+                disableCSRFCheck: any;
             };
         };
     };
     error?: undefined;
 } | {
     config: null;
-    error: any;
+    error: string;
 }>>;
 export default _default;

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

@@ -3,7 +3,7 @@ import { useRuntimeConfig } from "nitropack/runtime";
 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 runtimeConfig = useRuntimeConfig();
     const publicAuth = runtimeConfig.public?.auth;
@@ -41,6 +41,7 @@ export default defineEventHandler(async (event) => {
       }
     };
   } catch (error) {
-    return { config: null, error: error.message || "Failed to fetch config" };
+    console.error("[DevTools] Config fetch failed:", error);
+    return { config: null, error: "Failed to fetch configuration" };
   }
 });

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

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

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

@@ -2,7 +2,7 @@ import { defineEventHandler, getQuery } from "h3";
 import { paginationQuerySchema, sanitizeSearchPattern } from "./_schema.js";
 export default defineEventHandler(async (event) => {
   try {
-    const { db, schema } = await import("hub:db");
+    const { db, schema } = await import("@nuxthub/db");
     if (!schema.session)
       return { sessions: [], total: 0, error: "Session table not found" };
     const query = paginationQuerySchema.parse(getQuery(event));
@@ -26,7 +26,16 @@ export default defineEventHandler(async (event) => {
       dbQuery.orderBy(desc(schema.session.createdAt)).limit(limit).offset(offset),
       countQuery
     ]);
-    return { sessions, total: totalResult[0]?.count ?? 0, page, limit };
+    const safeSessions = sessions.map((s) => ({
+      id: s.id,
+      userId: s.userId,
+      createdAt: s.createdAt,
+      updatedAt: s.updatedAt,
+      expiresAt: s.expiresAt,
+      ipAddress: s.ipAddress,
+      userAgent: s.userAgent
+    }));
+    return { sessions: safeSessions, total: totalResult[0]?.count ?? 0, page, limit };
   } catch (error) {
     console.error("[DevTools] Fetch sessions failed:", error);
     return { sessions: [], total: 0, error: "Failed to fetch sessions" };

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

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

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));
 });