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

package/dist/module.json

@@ -1,10 +1,10 @@
 {
   "name": "@onmax/nuxt-better-auth",
+  "version": "0.0.2-alpha.16",
   "configKey": "auth",
   "compatibility": {
     "nuxt": ">=3.0.0"
   },
-  "version": "0.0.2-alpha.14",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,13 +1,18 @@
-import { existsSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { existsSync, writeFileSync, readFileSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
-import { defineNuxtModule, createResolver, hasNuxtModule, addTemplate, addTypeTemplate, updateTemplates, addServerImportsDir, addServerImports, addServerScanDir, addServerHandler, addImportsDir, addPlugin, addComponentsDir, extendPages } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, hasNuxtModule, addTemplate, addTypeTemplate, updateTemplates, addServerImportsDir, addServerImports, addServerScanDir, addServerHandler, addImportsDir, addPlugin, addComponentsDir, installModule, extendPages } from '@nuxt/kit';
 import { consola as consola$1 } from 'consola';
 import { defu } from 'defu';
-import { join } from 'pathe';
+import { join, dirname } from 'pathe';
 import { toRouteMatcher, createRouter } from 'radix3';
+import { isCI, isTest } from 'std-env';
 import { generateDrizzleSchema as generateDrizzleSchema$1 } from '@better-auth/cli/api';
+import { getAuthTables } from 'better-auth/db';
 export { defineClientAuth, defineServerAuth } from '../dist/runtime/config.js';
 
+const version = "0.0.2-alpha.16";
+
 function setupDevTools(nuxt) {
   nuxt.hook("devtools:customTabs", (tabs) => {
     tabs.push({
@@ -52,6 +57,101 @@ async function generateDrizzleSchema(authOptions, dialect, schemaOptions) {
   }
   return result.code;
 }
+const convexIndexFields = {
+  account: ["accountId", ["accountId", "providerId"], ["providerId", "userId"]],
+  rateLimit: ["key"],
+  session: ["expiresAt", ["expiresAt", "userId"]],
+  verification: ["expiresAt", "identifier"],
+  user: [["email", "name"], "name", "userId"],
+  passkey: ["credentialID"],
+  oauthConsent: [["clientId", "userId"]]
+};
+function getConvexSpecialFields(tables) {
+  return Object.fromEntries(
+    Object.entries(tables).map(([key, table]) => {
+      const fields = Object.fromEntries(
+        Object.entries(table.fields).map(([fieldKey, field]) => [
+          field.fieldName ?? fieldKey,
+          {
+            ...field.sortable ? { sortable: true } : {},
+            ...field.unique ? { unique: true } : {},
+            ...field.references ? { references: field.references } : {}
+          }
+        ]).filter(([_key, value]) => typeof value === "object" ? Object.keys(value).length > 0 : true)
+      );
+      return [key, fields];
+    }).filter(([_key, value]) => typeof value === "object" ? Object.keys(value).length > 0 : true)
+  );
+}
+function getMergedConvexIndexFields(tables) {
+  return Object.fromEntries(
+    Object.entries(tables).map(([key, table]) => {
+      const manualIndexes = convexIndexFields[key]?.map((index) => {
+        return typeof index === "string" ? table.fields[index]?.fieldName ?? index : index.map((i) => table.fields[i]?.fieldName ?? i);
+      }) || [];
+      const specialFieldsObj = getConvexSpecialFields(tables);
+      const specialFieldIndexes = Object.keys(specialFieldsObj[key] || {}).filter(
+        (index) => !manualIndexes.some((m) => Array.isArray(m) ? m[0] === index : m === index)
+      );
+      return [key, manualIndexes.concat(specialFieldIndexes)];
+    })
+  );
+}
+async function generateConvexSchema(authOptions) {
+  const tables = getAuthTables(authOptions);
+  let code = `/**
+ * Auto-generated Better Auth tables for Convex.
+ * Import these tables in your convex/schema.ts:
+ *
+ * import { defineSchema } from 'convex/server'
+ * import { authTables } from './_generated/auth-tables'
+ *
+ * export default defineSchema({ ...authTables, ...yourTables })
+ */
+
+import { defineTable } from 'convex/server'
+import { v } from 'convex/values'
+
+export const authTables = {
+`;
+  const getType = (_name, field) => {
+    const type = field.type;
+    const typeMap = {
+      "string": "v.string()",
+      "boolean": "v.boolean()",
+      "number": "v.number()",
+      "date": "v.number()",
+      "json": "v.string()",
+      "number[]": "v.array(v.number())",
+      "string[]": "v.array(v.string())"
+    };
+    return typeMap[type];
+  };
+  for (const tableKey in tables) {
+    const table = tables[tableKey];
+    const modelName = table.modelName;
+    const fields = Object.fromEntries(Object.entries(table.fields).filter(([key]) => key !== "id"));
+    const indexes = getMergedConvexIndexFields(tables)[tableKey]?.map((index) => {
+      const indexArray = Array.isArray(index) ? index.sort() : [index];
+      const indexName = indexArray.join("_");
+      return `.index('${indexName}', ${JSON.stringify(indexArray)})`;
+    }) || [];
+    const schema = `${modelName}: defineTable({
+${Object.keys(fields).map((field) => {
+      const attr = fields[field];
+      const type = getType(field, attr);
+      const optional = (fieldSchema) => attr.required ? fieldSchema : `v.optional(v.union(v.null(), ${fieldSchema}))`;
+      return `    ${attr.fieldName ?? field}: ${optional(type)},`;
+    }).join("\n")}
+  })${indexes.length > 0 ? `
+    ${indexes.join("\n    ")}` : ""},
+`;
+    code += `  ${schema}`;
+  }
+  code += `}
+`;
+  return code;
+}
 async function loadUserAuthConfig(configPath, throwOnError = false) {
   const { createJiti } = await import('jiti');
   const { defineServerAuth } = await import('../dist/runtime/config.js');
@@ -63,11 +163,11 @@ async function loadUserAuthConfig(configPath, throwOnError = false) {
   globalThis.defineServerAuth._count++;
   try {
     const mod = await jiti.import(configPath);
-    const configFn = typeof mod === "object" && mod !== null && "default" in mod ? mod.default : mod;
+    const configFn = mod.default;
     if (typeof configFn === "function") {
       return configFn({ runtimeConfig: {}, db: null });
     }
-    consola$1.warn("[@onmax/nuxt-better-auth] auth.config.ts does not export a function. Expected: export default defineServerAuth(...)");
+    consola$1.warn("[@onmax/nuxt-better-auth] auth.config.ts does not export default. Expected: export default defineServerAuth(...)");
     if (throwOnError) {
       throw new Error("auth.config.ts must export default defineServerAuth(...)");
     }
@@ -101,8 +201,85 @@ function getHubCasing(hub) {
   return hub.db.casing;
 }
 const consola = consola$1.withTag("nuxt-better-auth");
+function resolveConvexUrl(nuxt) {
+  const convexConfig = nuxt.options.convex;
+  if (convexConfig?.url)
+    return convexConfig.url;
+  const runtimeUrl = nuxt.options.runtimeConfig.public?.convex?.url;
+  if (runtimeUrl)
+    return runtimeUrl;
+  if (process.env.CONVEX_URL)
+    return process.env.CONVEX_URL;
+  if (process.env.NUXT_PUBLIC_CONVEX_URL)
+    return process.env.NUXT_PUBLIC_CONVEX_URL;
+  return "";
+}
+const generateSecret = () => randomBytes(32).toString("hex");
+function readEnvFile(rootDir) {
+  const envPath = join(rootDir, ".env");
+  return existsSync(envPath) ? readFileSync(envPath, "utf-8") : "";
+}
+function hasEnvSecret(rootDir) {
+  const match = readEnvFile(rootDir).match(/^BETTER_AUTH_SECRET=(.+)$/m);
+  return !!match && !!match[1] && match[1].trim().length > 0;
+}
+function appendSecretToEnv(rootDir, secret) {
+  const envPath = join(rootDir, ".env");
+  let content = readEnvFile(rootDir);
+  if (content.length > 0 && !content.endsWith("\n"))
+    content += "\n";
+  content += `BETTER_AUTH_SECRET=${secret}
+`;
+  writeFileSync(envPath, content, "utf-8");
+}
+async function promptForSecret(rootDir) {
+  if (process.env.BETTER_AUTH_SECRET || hasEnvSecret(rootDir))
+    return void 0;
+  if (isCI || isTest) {
+    const secret2 = generateSecret();
+    appendSecretToEnv(rootDir, secret2);
+    consola.info("Generated BETTER_AUTH_SECRET and added to .env (CI mode)");
+    return secret2;
+  }
+  consola.box("BETTER_AUTH_SECRET is required for authentication.\nThis will be appended to your .env file.");
+  const choice = await consola.prompt("How do you want to set it?", {
+    type: "select",
+    options: [
+      { label: "Generate for me", value: "generate", hint: "uses crypto.randomBytes(32)" },
+      { label: "Enter manually", value: "paste" },
+      { label: "Skip", value: "skip", hint: "will fail in production" }
+    ],
+    cancel: "null"
+  });
+  if (typeof choice === "symbol" || choice === "skip") {
+    consola.warn("Skipping BETTER_AUTH_SECRET. Auth will fail without it in production.");
+    return void 0;
+  }
+  let secret;
+  if (choice === "generate") {
+    secret = generateSecret();
+  } else {
+    const input = await consola.prompt("Paste your secret (min 32 chars):", { type: "text", cancel: "null" });
+    if (typeof input === "symbol" || !input || input.length < 32) {
+      consola.warn("Invalid secret. Skipping.");
+      return void 0;
+    }
+    secret = input;
+  }
+  const preview = `${secret.slice(0, 8)}...${secret.slice(-4)}`;
+  const confirm = await consola.prompt(`Add to .env:
+BETTER_AUTH_SECRET=${preview}
+Proceed?`, { type: "confirm", initial: true, cancel: "null" });
+  if (typeof confirm === "symbol" || !confirm) {
+    consola.info("Cancelled. Secret not written.");
+    return void 0;
+  }
+  appendSecretToEnv(rootDir, secret);
+  consola.success("Added BETTER_AUTH_SECRET to .env");
+  return secret;
+}
 const module$1 = defineNuxtModule({
-  meta: { name: "@onmax/nuxt-better-auth", configKey: "auth", compatibility: { nuxt: ">=3.0.0" } },
+  meta: { name: "@onmax/nuxt-better-auth", version, configKey: "auth", compatibility: { nuxt: ">=3.0.0" } },
   defaults: {
     clientOnly: false,
     serverConfig: "server/auth.config",
@@ -110,8 +287,40 @@ const module$1 = defineNuxtModule({
     redirects: { login: "/login", guest: "/" },
     secondaryStorage: false
   },
+  async onInstall(nuxt) {
+    const generatedSecret = await promptForSecret(nuxt.options.rootDir);
+    if (generatedSecret)
+      process.env.BETTER_AUTH_SECRET = generatedSecret;
+    const serverPath = join(nuxt.options.rootDir, "server/auth.config.ts");
+    const clientPath = join(nuxt.options.srcDir, "auth.config.ts");
+    const serverTemplate = `import { defineServerAuth } from '@onmax/nuxt-better-auth/config'
+
+export default defineServerAuth({
+  emailAndPassword: { enabled: true },
+})
+`;
+    const clientTemplate = `import { defineClientAuth } from '@onmax/nuxt-better-auth/config'
+
+export default defineClientAuth({})
+`;
+    if (!existsSync(serverPath)) {
+      await mkdir(dirname(serverPath), { recursive: true });
+      await writeFile(serverPath, serverTemplate);
+      consola.success("Created server/auth.config.ts");
+    }
+    if (!existsSync(clientPath)) {
+      await mkdir(dirname(clientPath), { recursive: true });
+      await writeFile(clientPath, clientTemplate);
+      const relativePath = clientPath.replace(`${nuxt.options.rootDir}/`, "");
+      consola.success(`Created ${relativePath}`);
+    }
+  },
   async setup(options, nuxt) {
     const resolver = createResolver(import.meta.url);
+    if (options.clientConfig === "app/auth.config") {
+      const srcDirRelative = nuxt.options.srcDir.replace(`${nuxt.options.rootDir}/`, "");
+      options.clientConfig = srcDirRelative === nuxt.options.srcDir ? "auth.config" : `${srcDirRelative}/auth.config`;
+    }
     const clientOnly = options.clientOnly;
     const serverConfigFile = options.serverConfig;
     const clientConfigFile = options.clientConfig;
@@ -120,12 +329,18 @@ const module$1 = defineNuxtModule({
     const serverConfigExists = existsSync(`${serverConfigPath}.ts`) || existsSync(`${serverConfigPath}.js`);
     const clientConfigExists = existsSync(`${clientConfigPath}.ts`) || existsSync(`${clientConfigPath}.js`);
     if (!clientOnly && !serverConfigExists)
-      throw new Error(`[nuxt-better-auth] Missing ${serverConfigFile}.ts - create with defineServerAuth()`);
+      throw new Error(`[nuxt-better-auth] Missing ${serverConfigFile}.ts - export default defineServerAuth(...)`);
     if (!clientConfigExists)
-      throw new Error(`[nuxt-better-auth] Missing ${clientConfigFile}.ts - export createAppAuthClient()`);
+      throw new Error(`[nuxt-better-auth] Missing ${clientConfigFile}.ts - export default defineClientAuth(...)`);
     const hasNuxtHub = hasNuxtModule("@nuxthub/core", nuxt);
     const hub = hasNuxtHub ? nuxt.options.hub : void 0;
     const hasHubDb = !clientOnly && hasNuxtHub && !!hub?.db;
+    const hasConvex = hasNuxtModule("nuxt-convex", nuxt);
+    const convexUrl = resolveConvexUrl(nuxt);
+    const hasConvexDb = !clientOnly && hasConvex && !!convexUrl && !hasHubDb;
+    if (hasConvexDb) {
+      consola.info("Detected Convex - using Convex HTTP adapter for Better Auth database");
+    }
     let secondaryStorageEnabled = options.secondaryStorage ?? false;
     if (secondaryStorageEnabled && clientOnly) {
       consola.warn("secondaryStorage is not available in clientOnly mode. Disabling.");
@@ -137,7 +352,7 @@ const module$1 = defineNuxtModule({
     nuxt.options.runtimeConfig.public = nuxt.options.runtimeConfig.public || {};
     nuxt.options.runtimeConfig.public.auth = defu(nuxt.options.runtimeConfig.public.auth, {
       redirects: { login: options.redirects?.login ?? "/login", guest: options.redirects?.guest ?? "/" },
-      useDatabase: hasHubDb,
+      useDatabase: hasHubDb || hasConvexDb,
       clientOnly
     });
     if (clientOnly) {
@@ -151,7 +366,7 @@ const module$1 = defineNuxtModule({
       const currentSecret = nuxt.options.runtimeConfig.betterAuthSecret;
       nuxt.options.runtimeConfig.betterAuthSecret = currentSecret || process.env.BETTER_AUTH_SECRET || "";
       const betterAuthSecret = nuxt.options.runtimeConfig.betterAuthSecret;
-      if (!nuxt.options.dev && !betterAuthSecret) {
+      if (!nuxt.options.dev && !nuxt.options._prepare && !betterAuthSecret) {
         throw new Error("[nuxt-better-auth] BETTER_AUTH_SECRET is required in production. Set BETTER_AUTH_SECRET or NUXT_BETTER_AUTH_SECRET environment variable.");
       }
       if (betterAuthSecret && betterAuthSecret.length < 32) {
@@ -183,13 +398,36 @@ export function createSecondaryStorage() {
         throw new Error("[nuxt-better-auth] hub:db not found. Ensure @nuxthub/core is loaded before this module and hub.db is configured.");
       }
       const hubDialect = getHubDialect(hub) ?? "sqlite";
-      const databaseCode = hasHubDb ? `import { db, schema } from '../hub/db.mjs'
+      const usePlural = options.schema?.usePlural ?? false;
+      const camelCase = (options.schema?.casing ?? getHubCasing(hub)) !== "snake_case";
+      let databaseCode;
+      if (hasHubDb) {
+        databaseCode = `import { db, schema } from '../hub/db.mjs'
 import { drizzleAdapter } from 'better-auth/adapters/drizzle'
 const rawDialect = '${hubDialect}'
 const dialect = rawDialect === 'postgresql' ? 'pg' : rawDialect
-export function createDatabase() { return drizzleAdapter(db, { provider: dialect, schema }) }
-export { db }` : `export function createDatabase() { return undefined }
+export function createDatabase() { return drizzleAdapter(db, { provider: dialect, schema, usePlural: ${usePlural}, camelCase: ${camelCase} }) }
+export { db }`;
+      } else if (hasConvexDb) {
+        nuxt.options.runtimeConfig.betterAuth = defu(
+          nuxt.options.runtimeConfig.betterAuth || {},
+          { convexUrl }
+        );
+        databaseCode = `import { useRuntimeConfig } from '#imports'
+import { createConvexHttpAdapter } from '@onmax/nuxt-better-auth/adapters/convex'
+import { api } from '#convex/api'
+
+export function createDatabase() {
+  const config = useRuntimeConfig()
+  const convexUrl = config.betterAuth?.convexUrl || config.public?.convex?.url
+  if (!convexUrl) throw new Error('[nuxt-better-auth] CONVEX_URL not configured')
+  return createConvexHttpAdapter({ url: convexUrl, api: api.auth })
+}
+export const db = undefined`;
+      } else {
+        databaseCode = `export function createDatabase() { return undefined }
 export const db = undefined`;
+      }
       const databaseTemplate = addTemplate({ filename: "better-auth/database.mjs", getContents: () => databaseCode, write: true });
       nuxt.options.alias["#auth/database"] = databaseTemplate.dst;
       addTypeTemplate({
@@ -220,9 +458,9 @@ declare module '#auth/database' {
         getContents: () => `
 import type { InferUser, InferSession, InferPluginTypes } from 'better-auth'
 import type { RuntimeConfig } from 'nuxt/schema'
-import type configFn from '${serverConfigPath}'
+import type createServerAuth from '${serverConfigPath}'
 
-type _Config = ReturnType<typeof configFn>
+type _Config = ReturnType<typeof createServerAuth>
 
 declare module '#nuxt-better-auth' {
   interface AuthUser extends InferUser<_Config> {}
@@ -243,7 +481,7 @@ interface _AugmentedServerAuthContext {
 declare module '@onmax/nuxt-better-auth/config' {
   import type { BetterAuthOptions } from 'better-auth'
   type ServerAuthConfig = Omit<BetterAuthOptions, 'database' | 'secret' | 'baseURL'>
-  export function defineServerAuth<T extends ServerAuthConfig>(config: (ctx: _AugmentedServerAuthContext) => T): (ctx: _AugmentedServerAuthContext) => T
+  export function defineServerAuth<T extends ServerAuthConfig>(config: T | ((ctx: _AugmentedServerAuthContext) => T)): (ctx: _AugmentedServerAuthContext) => T
 }
 `
       }, { nuxt: true, nitro: true, node: true });
@@ -280,7 +518,7 @@ export type { AuthMeta, AuthMode, AuthRouteRules, UserMatch, RequireSessionOptio
     addTypeTemplate({
       filename: "types/nuxt-better-auth-client.d.ts",
       getContents: () => `
-import type { createAppAuthClient } from '${clientConfigPath}'
+import type createAppAuthClient from '${clientConfigPath}'
 declare module '#nuxt-better-auth' {
   export type AppAuthClient = ReturnType<typeof createAppAuthClient>
 }
@@ -309,8 +547,13 @@ declare module '#nuxt-better-auth' {
     if (hasHubDb) {
       await setupBetterAuthSchema(nuxt, serverConfigPath, options);
     }
+    if (hasConvexDb) {
+      await setupConvexAuthSchema(nuxt, serverConfigPath);
+    }
     const isProduction = process.env.NODE_ENV === "production" || !nuxt.options.dev;
     if (!isProduction && !clientOnly) {
+      if (!hasNuxtModule("@nuxt/ui"))
+        await installModule("@nuxt/ui");
       setupDevTools(nuxt);
       addServerHandler({ route: "/api/_better-auth/config", method: "get", handler: resolver.resolve("./runtime/server/api/_better-auth/config.get") });
       if (hasHubDb) {
@@ -387,5 +630,26 @@ async function setupBetterAuthSchema(nuxt, serverConfigPath, options) {
     }
   });
 }
+async function setupConvexAuthSchema(nuxt, serverConfigPath) {
+  const isProduction = !nuxt.options.dev;
+  try {
+    const configFile = `${serverConfigPath}.ts`;
+    const userConfig = await loadUserAuthConfig(configFile, isProduction);
+    const authOptions = { ...userConfig };
+    const schemaCode = await generateConvexSchema(authOptions);
+    const schemaDir = join(nuxt.options.buildDir, "better-auth");
+    const schemaPath = join(schemaDir, "auth-tables.convex.ts");
+    await mkdir(schemaDir, { recursive: true });
+    await writeFile(schemaPath, schemaCode);
+    addTemplate({ filename: "better-auth/auth-tables.convex.ts", getContents: () => schemaCode, write: true });
+    nuxt.options.alias["#auth/convex-schema"] = schemaPath;
+    consola.info("Generated Convex auth schema at .nuxt/better-auth/auth-tables.convex.ts");
+  } catch (error) {
+    if (isProduction) {
+      throw error;
+    }
+    consola.error("Failed to generate Convex schema:", error);
+  }
+}
 
 export { module$1 as default };

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