better-auth-nuxt 0.0.9 → 0.0.10-beta.20

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.d.vue.ts

@@ -0,0 +1,20 @@
+declare var __VLS_1: {
+    loggedIn: boolean;
+    user: import("../../types.js").AuthUser | null;
+    session: import("../../types.js").AuthSession | null;
+    signOut: (options?: import("#imports").SignOutOptions) => Promise<void>;
+}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    placeholder?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,9 @@
+<script setup>
+import { useUserSession } from "#imports";
+const { loggedIn, user, session, signOut, ready } = useUserSession();
+</script>
+
+<template>
+  <slot v-if="ready" v-bind="{ loggedIn, user, session, signOut }" />
+  <slot v-else name="placeholder" />
+</template>

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

@@ -0,0 +1,20 @@
+declare var __VLS_1: {
+    loggedIn: boolean;
+    user: import("../../types.js").AuthUser | null;
+    session: import("../../types.js").AuthSession | null;
+    signOut: (options?: import("#imports").SignOutOptions) => Promise<void>;
+}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    placeholder?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,22 @@
+import type { AppAuthClient, AuthSession, AuthUser } from '#nuxt-better-auth';
+import type { ComputedRef, Ref } from 'vue';
+export interface SignOutOptions {
+    onSuccess?: () => void | Promise<void>;
+}
+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

@@ -0,0 +1,159 @@
+import createAppAuthClient from "#auth/client";
+import { computed, nextTick, useRequestHeaders, useRequestURL, useRuntimeConfig, useState, watch } from "#imports";
+let _client = null;
+function getClient(baseURL) {
+  if (!_client)
+    _client = createAppAuthClient(baseURL);
+  return _client;
+}
+export function useUserSession() {
+  const runtimeConfig = useRuntimeConfig();
+  const requestURL = useRequestURL();
+  const client = import.meta.client ? getClient(runtimeConfig.public.siteUrl || requestURL.origin) : null;
+  const session = useState("auth:session", () => null);
+  const user = useState("auth:user", () => null);
+  const authReady = useState("auth:ready", () => false);
+  const ready = computed(() => authReady.value);
+  const loggedIn = computed(() => Boolean(session.value && user.value));
+  function clearSession() {
+    session.value = null;
+    user.value = null;
+  }
+  function updateUser(updates) {
+    if (user.value)
+      user.value = { ...user.value, ...updates };
+  }
+  if (import.meta.client && client) {
+    const clientSession = client.useSession();
+    watch(
+      () => clientSession.value,
+      (newSession) => {
+        if (newSession?.data?.session && newSession?.data?.user) {
+          const { token: _, ...safeSession } = newSession.data.session;
+          session.value = safeSession;
+          user.value = newSession.data.user;
+        } else if (!newSession?.isPending) {
+          clearSession();
+        }
+        if (!authReady.value && !newSession?.isPending)
+          authReady.value = true;
+      },
+      { immediate: true, deep: true }
+    );
+  }
+  function waitForSession() {
+    return new Promise((resolve) => {
+      if (loggedIn.value) {
+        resolve();
+        return;
+      }
+      const unwatch = watch(loggedIn, (isLoggedIn) => {
+        if (isLoggedIn) {
+          unwatch();
+          resolve();
+        }
+      });
+      setTimeout(() => {
+        unwatch();
+        resolve();
+      }, 5e3);
+    });
+  }
+  function wrapOnSuccess(cb) {
+    return async (ctx) => {
+      await fetchSession({ force: true });
+      if (!loggedIn.value)
+        await waitForSession();
+      await nextTick();
+      await cb(ctx);
+    };
+  }
+  function wrapAuthMethod(method) {
+    return (async (...args) => {
+      const [data, options] = args;
+      if (data?.fetchOptions?.onSuccess) {
+        return method({ ...data, fetchOptions: { ...data.fetchOptions, onSuccess: wrapOnSuccess(data.fetchOptions.onSuccess) } }, options);
+      }
+      if (options?.onSuccess) {
+        return method(data, { ...options, onSuccess: wrapOnSuccess(options.onSuccess) });
+      }
+      return method(data, options);
+    });
+  }
+  const signIn = client?.signIn ? new Proxy(client.signIn, {
+    get(target, prop) {
+      const targetRecord = target;
+      const method = targetRecord[prop];
+      if (typeof method !== "function")
+        return method;
+      return wrapAuthMethod((...args) => targetRecord[prop](...args));
+    }
+  }) : new Proxy({}, {
+    get: (_, prop) => {
+      throw new Error(`signIn.${String(prop)}() can only be called on client-side`);
+    }
+  });
+  const signUp = client?.signUp ? new Proxy(client.signUp, {
+    get(target, prop) {
+      const targetRecord = target;
+      const method = targetRecord[prop];
+      if (typeof method !== "function")
+        return method;
+      return wrapAuthMethod((...args) => targetRecord[prop](...args));
+    }
+  }) : new Proxy({}, {
+    get: (_, prop) => {
+      throw new Error(`signUp.${String(prop)}() can only be called on client-side`);
+    }
+  });
+  async function fetchSession(options = {}) {
+    if (import.meta.server) {
+      if (!authReady.value)
+        authReady.value = true;
+      return;
+    }
+    if (client) {
+      try {
+        const headers = options.headers || useRequestHeaders(["cookie"]);
+        const fetchOptions = headers ? { headers } : void 0;
+        const query = options.force ? { disableCookieCache: true } : void 0;
+        const result = await client.getSession({ query }, fetchOptions);
+        const data = result.data;
+        if (data?.session && data?.user) {
+          const { token: _, ...safeSession } = data.session;
+          session.value = safeSession;
+          user.value = data.user;
+        } else {
+          clearSession();
+        }
+      } catch (error) {
+        clearSession();
+        console.error("[nuxt-better-auth] Failed to fetch session:", error);
+      } finally {
+        if (!authReady.value)
+          authReady.value = true;
+      }
+    }
+  }
+  async function signOut(options) {
+    if (!client)
+      throw new Error("signOut can only be called on client-side");
+    await client.signOut();
+    clearSession();
+    if (options?.onSuccess)
+      await options.onSuccess();
+  }
+  return {
+    client,
+    session,
+    user,
+    loggedIn,
+    ready,
+    signIn,
+    signUp,
+    signOut,
+    waitForSession,
+    fetchSession,
+    updateUser
+  };
+}

package/dist/runtime/app/middleware/auth.global.d.ts

@@ -0,0 +1,13 @@
+import type { AuthMeta } from '../../types.js';
+declare module '#app' {
+    interface PageMeta {
+        auth?: AuthMeta;
+    }
+}
+declare module 'vue-router' {
+    interface RouteMeta {
+        auth?: AuthMeta;
+    }
+}
+declare const _default: import("#app").RouteMiddleware;
+export default _default;

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

@@ -0,0 +1,37 @@
+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)
+      to.meta.auth = rules.auth;
+  }
+  const auth = to.meta.auth;
+  if (auth === void 0 || auth === false)
+    return;
+  const config = useRuntimeConfig().public.auth;
+  const { fetchSession, user, loggedIn } = useUserSession();
+  if (!loggedIn.value) {
+    const headers = import.meta.server ? useRequestHeaders(["cookie"]) : void 0;
+    await fetchSession({ headers });
+  }
+  const mode = typeof auth === "string" ? auth : auth?.only ?? "user";
+  const redirectTo = typeof auth === "object" ? auth.redirectTo : void 0;
+  if (mode === "guest") {
+    if (loggedIn.value)
+      return navigateTo(redirectTo ?? config?.redirects?.guest ?? "/");
+    return;
+  }
+  if (!loggedIn.value)
+    return navigateTo(redirectTo ?? config?.redirects?.login ?? "/login");
+  if (typeof auth === "object" && auth.user) {
+    if (!user.value || !matchesUser(user.value, auth.user))
+      throw createError({ statusCode: 403, statusMessage: "Access denied" });
+  }
+});

package/dist/runtime/app/pages/__better-auth-devtools.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;