@onmax/nuxt-better-auth 0.0.2-alpha.14 → 0.0.2-alpha.16

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/composables/useUserSession.js

@@ -1,4 +1,4 @@
-import { createAppAuthClient } from "#auth/client";
+import createAppAuthClient from "#auth/client";
 import { computed, nextTick, useRequestHeaders, useRequestURL, useRuntimeConfig, useState, watch } from "#imports";
 let _client = null;
 function getClient(baseURL) {

package/dist/runtime/config.d.ts

@@ -2,12 +2,13 @@ import type { BetterAuthOptions } from 'better-auth';
 import type { ClientOptions } 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<ClientOptions, 'baseURL'> & {
     baseURL?: string;
 };
 export type ServerAuthConfigFn = (ctx: ServerAuthContext) => ServerAuthConfig;
@@ -44,5 +45,5 @@ export interface AuthRuntimeConfig {
 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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@onmax/nuxt-better-auth",
   "type": "module",
-  "version": "0.0.2-alpha.14",
+  "version": "0.0.2-alpha.16",
   "packageManager": "pnpm@10.15.1",
   "description": "Nuxt module for Better Auth integration with NuxtHub, route protection, session management, and role-based access",
   "author": "onmax",
@@ -26,6 +26,10 @@
     "./config": {
       "types": "./dist/runtime/config.d.ts",
       "import": "./dist/runtime/config.js"
+    },
+    "./adapters/convex": {
+      "types": "./dist/runtime/adapters/convex.d.ts",
+      "import": "./dist/runtime/adapters/convex.js"
     }
   },
   "main": "./dist/module.mjs",
@@ -36,6 +40,9 @@
       ],
       "config": [
         "./dist/runtime/config.d.ts"
+      ],
+      "adapters/convex": [
+        "./dist/runtime/adapters/convex.d.ts"
       ]
     }
   },
@@ -50,7 +57,7 @@
     "dev:prepare": "nuxt-module-build build --stub && nuxi prepare playground",
     "dev:docs": "nuxi dev docs",
     "build:docs": "nuxi build docs",
-    "release": "bumpp --push",
+    "release": "bumpp --push --no-push-all",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "typecheck": "vue-tsc --noEmit",
@@ -60,20 +67,26 @@
   },
   "peerDependencies": {
     "@nuxthub/core": ">=0.10.0",
-    "better-auth": ">=1.0.0"
+    "better-auth": ">=1.0.0",
+    "convex": ">=1.25.0"
   },
   "peerDependenciesMeta": {
     "@nuxthub/core": {
       "optional": true
+    },
+    "convex": {
+      "optional": true
     }
   },
   "dependencies": {
     "@better-auth/cli": "^1.5.0-beta.3",
     "@nuxt/kit": "^4.2.2",
+    "@nuxt/ui": "^4.2.1",
     "defu": "^6.1.4",
     "jiti": "^2.4.2",
     "pathe": "^2.0.3",
-    "radix3": "^1.1.2"
+    "radix3": "^1.1.2",
+    "std-env": "^3.10.0"
   },
   "devDependencies": {
     "@antfu/eslint-config": "^4.12.0",

package/skills/nuxt-better-auth/SKILL.md

@@ -1,92 +0,0 @@
----
-name: nuxt-better-auth
-description: Use when implementing auth in Nuxt apps with @onmax/nuxt-better-auth - provides useUserSession composable, server auth helpers, route protection, and Better Auth plugins integration.
-license: MIT
----
-
-# Nuxt Better Auth
-
-Authentication module for Nuxt 4+ built on [Better Auth](https://www.better-auth.com/). Provides composables, server utilities, and route protection.
-
-> **Alpha Status**: This module is currently in alpha (v0.0.2-alpha.12) and not recommended for production use. APIs may change.
-
-## When to Use
-
-- Installing/configuring `@onmax/nuxt-better-auth`
-- Implementing login/signup/signout flows
-- Protecting routes (client and server)
-- Accessing user session in API routes
-- Integrating Better Auth plugins (admin, passkey, 2FA)
-- Setting up database with NuxtHub
-- Using clientOnly mode for external auth backends
-
-**For Nuxt patterns:** use `nuxt` skill
-**For NuxtHub database:** use `nuxthub` skill
-
-## Available Guidance
-
-| File                                                                 | Topics                                                                 |
-| -------------------------------------------------------------------- | ---------------------------------------------------------------------- |
-| **[references/installation.md](references/installation.md)**         | Module setup, env vars, config files                                   |
-| **[references/client-auth.md](references/client-auth.md)**           | useUserSession, signIn/signUp/signOut, BetterAuthState, safe redirects |
-| **[references/server-auth.md](references/server-auth.md)**           | serverAuth, getUserSession, requireUserSession                         |
-| **[references/route-protection.md](references/route-protection.md)** | routeRules, definePageMeta, middleware                                 |
-| **[references/plugins.md](references/plugins.md)**                   | Better Auth plugins (admin, passkey, 2FA)                              |
-| **[references/database.md](references/database.md)**                 | NuxtHub integration, Drizzle schema                                    |
-| **[references/client-only.md](references/client-only.md)**           | External auth backend, clientOnly mode, CORS                           |
-| **[references/types.md](references/types.md)**                       | AuthUser, AuthSession, type augmentation                               |
-
-## Usage Pattern
-
-**Load based on context:**
-
-- Installing module? → [references/installation.md](references/installation.md)
-- Login/signup forms? → [references/client-auth.md](references/client-auth.md)
-- API route protection? → [references/server-auth.md](references/server-auth.md)
-- Route rules/page meta? → [references/route-protection.md](references/route-protection.md)
-- Using plugins? → [references/plugins.md](references/plugins.md)
-- Database setup? → [references/database.md](references/database.md)
-- External auth backend? → [references/client-only.md](references/client-only.md)
-- TypeScript types? → [references/types.md](references/types.md)
-
-**DO NOT read all files at once.** Load based on context.
-
-## Key Concepts
-
-| Concept                | Description                                                     |
-| ---------------------- | --------------------------------------------------------------- |
-| `useUserSession()`     | Client composable - user, session, loggedIn, signIn/Out methods |
-| `requireUserSession()` | Server helper - throws 401/403 if not authenticated             |
-| `auth` route mode      | `'user'`, `'guest'`, `{ user: {...} }`, or `false`              |
-| `serverAuth()`         | Get Better Auth instance in server routes                       |
-
-## Quick Reference
-
-```ts
-// Client: useUserSession()
-const { user, loggedIn, signIn, signOut } = useUserSession()
-await signIn.email({ email, password }, { onSuccess: () => navigateTo('/') })
-```
-
-```ts
-// Server: requireUserSession()
-const { user } = await requireUserSession(event, { user: { role: 'admin' } })
-```
-
-```ts
-// nuxt.config.ts: Route protection
-routeRules: {
-  '/admin/**': { auth: { user: { role: 'admin' } } },
-  '/login': { auth: 'guest' },
-  '/app/**': { auth: 'user' }
-}
-```
-
-## Resources
-
-- [Module Docs](https://github.com/onmax/nuxt-better-auth)
-- [Better Auth Docs](https://www.better-auth.com/)
-
----
-
-_Token efficiency: Main skill ~300 tokens, each sub-file ~800-1200 tokens_

package/skills/nuxt-better-auth/references/client-auth.md

@@ -1,153 +0,0 @@
-# Client-Side Authentication
-
-## useUserSession()
-
-Main composable for auth state and methods.
-
-```ts
-const {
-  user,           // Ref<AuthUser | null>
-  session,        // Ref<AuthSession | null>
-  loggedIn,       // ComputedRef<boolean>
-  ready,          // ComputedRef<boolean> - session fetch complete
-  client,         // Better Auth client (client-side only)
-  signIn,         // Proxy to client.signIn
-  signUp,         // Proxy to client.signUp
-  signOut,        // Sign out and clear session
-  fetchSession,   // Manually refresh session
-  updateUser      // Optimistic local user update
-} = useUserSession()
-```
-
-## Sign In
-
-```ts
-// Email/password
-await signIn.email({
-  email: 'user@example.com',
-  password: 'password123'
-}, {
-  onSuccess: () => navigateTo('/dashboard')
-})
-
-// OAuth
-await signIn.social({ provider: 'github' })
-```
-
-## Sign Up
-
-```ts
-await signUp.email({
-  email: 'user@example.com',
-  password: 'password123',
-  name: 'John Doe'
-}, {
-  onSuccess: () => navigateTo('/welcome')
-})
-```
-
-## Sign Out
-
-```ts
-await signOut()
-// or with redirect
-await signOut({ redirect: '/login' })
-```
-
-## Check Auth State
-
-```vue
-<script setup>
-const { user, loggedIn, ready } = useUserSession()
-</script>
-
-<template>
-  <div v-if="!ready">Loading...</div>
-  <div v-else-if="loggedIn">Welcome, {{ user?.name }}</div>
-  <div v-else>Please log in</div>
-</template>
-```
-
-## Safe Redirects
-
-Always validate redirect URLs from query params to prevent open redirects:
-
-```ts
-function getSafeRedirect() {
-  const redirect = route.query.redirect as string
-  // Must start with / and not // (prevents protocol-relative URLs)
-  if (!redirect?.startsWith('/') || redirect.startsWith('//')) {
-    return '/'
-  }
-  return redirect
-}
-
-await signIn.email({
-  email, password
-}, {
-  onSuccess: () => navigateTo(getSafeRedirect())
-})
-```
-
-## Wait for Session
-
-Useful when needing session before rendering:
-
-```ts
-await waitForSession() // 5s timeout
-if (loggedIn.value) {
-  // Session is ready
-}
-```
-
-## Manual Session Refresh
-
-```ts
-// Refetch from server
-await fetchSession({ force: true })
-```
-
-## Session Management
-
-Additional session management via Better Auth client:
-
-```ts
-const { client } = useUserSession()
-
-// List all active sessions for current user
-const sessions = await client.listSessions()
-
-// Revoke a specific session
-await client.revokeSession({ sessionId: 'xxx' })
-
-// Revoke all sessions except current
-await client.revokeOtherSessions()
-
-// Revoke all sessions (logs out everywhere)
-await client.revokeSessions()
-```
-
-These methods require the user to be authenticated.
-
-## BetterAuthState Component
-
-Renders once session hydration completes (`ready === true`), with loading placeholder support.
-
-```vue
-<BetterAuthState>
-  <template #default="{ loggedIn, user, session, signOut }">
-    <p v-if="loggedIn">Hi {{ user?.name }}</p>
-    <button v-else @click="navigateTo('/login')">Sign in</button>
-  </template>
-  <template #placeholder>
-    <p>Loading…</p>
-  </template>
-</BetterAuthState>
-```
-
-**Slots:**
-
-- `default` - Renders when `ready === true`, provides `{ loggedIn, user, session, signOut }`
-- `placeholder` - Renders while session hydrates
-
-Useful in clientOnly mode or for graceful SSR loading states.

package/skills/nuxt-better-auth/references/client-only.md

@@ -1,89 +0,0 @@
-# Client-Only Mode (External Auth Backend)
-
-When Better Auth runs on a separate backend (microservices, standalone server), use `clientOnly` mode.
-
-## Configuration
-
-### 1. Enable in nuxt.config.ts
-
-```ts
-export default defineNuxtConfig({
-  modules: ['@onmax/nuxt-better-auth'],
-  auth: {
-    clientOnly: true,
-  },
-})
-```
-
-### 2. Point client to external server
-
-```ts [app/auth.config.ts]
-import { createAuthClient } from 'better-auth/vue'
-
-export function createAppAuthClient(_baseURL: string) {
-  return createAuthClient({
-    baseURL: 'https://auth.example.com', // External auth server
-  })
-}
-```
-
-### 3. Set frontend URL
-
-```ini [.env]
-NUXT_PUBLIC_SITE_URL="https://your-frontend.com"
-```
-
-## What Changes
-
-| Feature                                                                       | Full Mode       | Client-Only       |
-| ----------------------------------------------------------------------------- | --------------- | ----------------- |
-| `server/auth.config.ts`                                                       | Required        | Not needed        |
-| `/api/auth/**` handlers                                                       | Auto-registered | Skipped           |
-| `NUXT_BETTER_AUTH_SECRET`                                                     | Required        | Not needed        |
-| Server utilities (`serverAuth()`, `getUserSession()`, `requireUserSession()`) | Available       | **Not available** |
-| SSR session hydration                                                         | Server-side     | Client-side only  |
-| `useUserSession()`, route protection, `<BetterAuthState>`                     | Works           | Works             |
-
-## CORS Requirements
-
-Ensure external auth server:
-
-- Allows requests from frontend (CORS with `credentials: true`)
-- Uses `SameSite=None; Secure` cookies (HTTPS required)
-- Includes frontend URL in `trustedOrigins`
-
-## SSR Considerations
-
-Session fetched client-side only:
-
-- Server-rendered pages render as "unauthenticated" initially
-- Hydrates with session data on client
-- Use `<BetterAuthState>` for loading states
-
-```vue
-<BetterAuthState v-slot="{ isLoading, user }">
-  <div v-if="isLoading">Loading...</div>
-  <div v-else-if="user">Welcome, {{ user.name }}</div>
-  <div v-else>Please log in</div>
-</BetterAuthState>
-```
-
-## Use Cases
-
-- **Microservices**: Auth service is separate deployment
-- **Shared auth**: Multiple frontends share one auth backend
-- **Existing backend**: Already have Better Auth server running elsewhere
-
-## Architecture Example
-
-```
-┌─────────────────┐     ┌─────────────────┐
-│   Nuxt App      │────▶│  Auth Server    │
-│  (clientOnly)   │     │ (Better Auth)   │
-│                 │◀────│                 │
-└─────────────────┘     └────────┬────────┘
-                                 │
-                        ┌────────▼────────┐
-                        │    Database     │
-                        └─────────────────┘
-```