@onmax/nuxt-better-auth 0.0.2-alpha.15 → 0.0.2-alpha.17

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@onmax/nuxt-better-auth",
-  "version": "0.0.2-alpha.15",
+  "version": "0.0.2-alpha.17",
   "configKey": "auth",
   "compatibility": {
     "nuxt": ">=3.0.0"

package/dist/module.mjs

@@ -8,9 +8,10 @@ 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.15";
+const version = "0.0.2-alpha.17";
 
 function setupDevTools(nuxt) {
   nuxt.hook("devtools:customTabs", (tabs) => {
@@ -56,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');
@@ -105,6 +201,19 @@ 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");
@@ -226,6 +335,12 @@ 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.");
@@ -237,7 +352,7 @@ export default defineClientAuth({})
     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) {
@@ -269,7 +384,7 @@ export default defineClientAuth({})
       if (secondaryStorageEnabled && !nuxt.options.alias["hub:kv"]) {
         throw new Error("[nuxt-better-auth] hub:kv not found. Ensure @nuxthub/core is loaded before this module and hub.kv is enabled.");
       }
-      const secondaryStorageCode = secondaryStorageEnabled ? `import { kv } from '../hub/kv.mjs'
+      const secondaryStorageCode = secondaryStorageEnabled ? `import { kv } from 'hub:kv'
 export function createSecondaryStorage() {
   return {
     get: async (key) => kv.get(\`_auth:\${key}\`),
@@ -285,13 +400,34 @@ export function createSecondaryStorage() {
       const hubDialect = getHubDialect(hub) ?? "sqlite";
       const usePlural = options.schema?.usePlural ?? false;
       const camelCase = (options.schema?.casing ?? getHubCasing(hub)) !== "snake_case";
-      const databaseCode = hasHubDb ? `import { db, schema } from '../hub/db.mjs'
+      let databaseCode;
+      if (hasHubDb) {
+        databaseCode = `import { db, schema } from 'hub:db'
 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, usePlural: ${usePlural}, camelCase: ${camelCase} }) }
-export { db }` : `export function createDatabase() { return undefined }
+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({
@@ -411,6 +547,9 @@ 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"))
@@ -491,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 {};

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@onmax/nuxt-better-auth",
   "type": "module",
-  "version": "0.0.2-alpha.15",
+  "version": "0.0.2-alpha.17",
   "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"
       ]
     }
   },
@@ -60,11 +67,15 @@
   },
   "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": {
@@ -85,7 +96,7 @@
     "@nuxt/module-builder": "^1.0.2",
     "@nuxt/schema": "^4.2.2",
     "@nuxt/test-utils": "^3.21.0",
-    "@nuxthub/core": "^0.10.3",
+    "@nuxthub/core": "^0.10.5",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "latest",
     "better-auth": "^1.5.0-beta.3",