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

package/dist/module.mjs

@@ -1,17 +1,26 @@
-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, installModule, extendPages } from '@nuxt/kit';
+import { updateTemplates, addServerImportsDir, addServerImports, addServerScanDir, addServerHandler, addImportsDir, addPlugin, addComponentsDir, hasNuxtModule, installModule, extendPages, addTemplate, addTypeTemplate, defineNuxtModule, createResolver } from '@nuxt/kit';
 import { consola as consola$1 } from 'consola';
-import { defu } from 'defu';
 import { join, dirname } from 'pathe';
+import { defu } from 'defu';
 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';
+import { randomBytes } from 'node:crypto';
+import { isCI, isTest } from 'std-env';
 export { defineClientAuth, defineServerAuth } from '../dist/runtime/config.js';
 
-const version = "0.0.2-alpha.21";
+const version = "0.0.2-alpha.23";
+
+function resolveDatabaseProvider(input) {
+  const enabledProviders = Object.entries(input.providers).filter(([_id, provider]) => provider.isEnabled?.(input.context) ?? true);
+  if (!enabledProviders.length) {
+    throw new Error("[nuxt-better-auth] No database provider is enabled. Register one with the better-auth:database:providers hook.");
+  }
+  enabledProviders.sort((a, b) => (b[1].priority ?? 0) - (a[1].priority ?? 0));
+  const [id, definition] = enabledProviders[0];
+  return { id, definition };
+}
 
 function setupDevTools(nuxt) {
   nuxt.hook("devtools:customTabs", (tabs) => {
@@ -28,6 +37,141 @@ function setupDevTools(nuxt) {
   });
 }
 
+function registerTemplateHmrHook(nuxt) {
+  nuxt.hook("builder:watch", async (_event, relativePath) => {
+    if (relativePath.includes("auth.config"))
+      await updateTemplates({ filter: (t) => t.filename.includes("nuxt-better-auth") });
+  });
+}
+function registerServerRuntime(input) {
+  const { clientOnly, resolve } = input;
+  if (!clientOnly) {
+    addServerImportsDir(resolve("./runtime/server/utils"));
+    addServerImports([{ name: "defineServerAuth", from: resolve("./runtime/config") }]);
+    addServerScanDir(resolve("./runtime/server/middleware"));
+    addServerHandler({ route: "/api/auth/**", handler: resolve("./runtime/server/api/auth/[...all]") });
+  }
+  addImportsDir(resolve("./runtime/app/composables"));
+  addImportsDir(resolve("./runtime/utils"));
+  if (!clientOnly)
+    addPlugin({ src: resolve("./runtime/app/plugins/session.server"), mode: "server" });
+  addPlugin({ src: resolve("./runtime/app/plugins/session.client"), mode: "client" });
+  addComponentsDir({ path: resolve("./runtime/app/components") });
+}
+function registerAuthMiddlewareHook(nuxt, resolve) {
+  nuxt.hook("app:resolve", (app) => {
+    app.middleware.push({ name: "auth", path: resolve("./runtime/app/middleware/auth.global"), global: true });
+  });
+}
+async function registerDevtools(input) {
+  const { nuxt, clientOnly, hasHubDb, resolve } = input;
+  const isProduction = process.env.NODE_ENV === "production" || !nuxt.options.dev;
+  if (isProduction || clientOnly)
+    return;
+  if (!hasNuxtModule("@nuxt/ui"))
+    await installModule("@nuxt/ui");
+  setupDevTools(nuxt);
+  addServerHandler({ route: "/api/_better-auth/config", method: "get", handler: resolve("./runtime/server/api/_better-auth/config.get") });
+  if (hasHubDb) {
+    const handlers = [
+      { route: "/api/_better-auth/sessions", method: "get", handler: resolve("./runtime/server/api/_better-auth/sessions.get") },
+      { route: "/api/_better-auth/sessions", method: "delete", handler: resolve("./runtime/server/api/_better-auth/sessions.delete") },
+      { route: "/api/_better-auth/users", method: "get", handler: resolve("./runtime/server/api/_better-auth/users.get") },
+      { route: "/api/_better-auth/accounts", method: "get", handler: resolve("./runtime/server/api/_better-auth/accounts.get") }
+    ];
+    handlers.forEach((handler) => addServerHandler(handler));
+  }
+  extendPages((pages) => {
+    pages.push({ name: "better-auth-devtools", path: "/__better-auth-devtools", file: resolve("./runtime/app/pages/__better-auth-devtools.vue") });
+  });
+}
+function registerRouteRulesMetaHook(nuxt) {
+  nuxt.hook("pages:extend", (pages) => {
+    const routeRules = nuxt.options.routeRules || {};
+    if (!Object.keys(routeRules).length)
+      return;
+    const matcher = toRouteMatcher(createRouter({ routes: routeRules }));
+    const applyMetaFromRules = (page) => {
+      const matches = matcher.matchAll(page.path);
+      if (!matches.length)
+        return;
+      const matchedRules = defu({}, ...matches.reverse());
+      if (matchedRules.auth !== void 0) {
+        page.meta = page.meta || {};
+        page.meta.auth = matchedRules.auth;
+      }
+      page.children?.forEach((child) => applyMetaFromRules(child));
+    };
+    pages.forEach((page) => applyMetaFromRules(page));
+  });
+}
+
+function getHubDialect(hub) {
+  if (!hub?.db)
+    return void 0;
+  if (typeof hub.db === "string")
+    return hub.db;
+  if (typeof hub.db === "object" && hub.db !== null)
+    return hub.db.dialect;
+  return void 0;
+}
+function getHubCasing(hub) {
+  if (!hub?.db || typeof hub.db !== "object" || hub.db === null)
+    return void 0;
+  return hub.db.casing;
+}
+
+function resolveSecondaryStorageEnabled(input) {
+  const { options, clientOnly, hasNuxtHub, hub, consola } = input;
+  let secondaryStorageEnabled = options.secondaryStorage ?? false;
+  if (secondaryStorageEnabled && clientOnly) {
+    consola.warn("secondaryStorage is not available in clientOnly mode. Disabling.");
+    secondaryStorageEnabled = false;
+  } else if (secondaryStorageEnabled && (!hasNuxtHub || !hub?.kv)) {
+    consola.warn("secondaryStorage requires @nuxthub/core with hub.kv: true. Disabling.");
+    secondaryStorageEnabled = false;
+  }
+  return secondaryStorageEnabled;
+}
+function setupRuntimeConfig(input) {
+  const { nuxt, options, clientOnly, databaseProvider, consola } = input;
+  const secondaryStorageEnabled = resolveSecondaryStorageEnabled(input);
+  nuxt.options.runtimeConfig.public = nuxt.options.runtimeConfig.public || {};
+  const configuredSiteUrl = nuxt.options.runtimeConfig.public.siteUrl;
+  if (!configuredSiteUrl && process.env.NUXT_PUBLIC_SITE_URL)
+    nuxt.options.runtimeConfig.public.siteUrl = process.env.NUXT_PUBLIC_SITE_URL;
+  nuxt.options.runtimeConfig.public.auth = defu(nuxt.options.runtimeConfig.public.auth, {
+    redirects: { login: options.redirects?.login ?? "/login", guest: options.redirects?.guest ?? "/" },
+    useDatabase: databaseProvider !== "none",
+    databaseProvider,
+    databaseSource: "module",
+    clientOnly,
+    session: {
+      skipHydratedSsrGetSession: options.session?.skipHydratedSsrGetSession ?? false
+    }
+  });
+  if (clientOnly) {
+    const siteUrl = nuxt.options.runtimeConfig.public.siteUrl;
+    if (!siteUrl)
+      consola.warn("clientOnly mode: set runtimeConfig.public.siteUrl (or NUXT_PUBLIC_SITE_URL) to your frontend URL");
+    consola.info("clientOnly mode enabled - server utilities (serverAuth, getUserSession, requireUserSession) are not available");
+    return { secondaryStorageEnabled };
+  }
+  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 && !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) {
+    throw new Error("[nuxt-better-auth] BETTER_AUTH_SECRET must be at least 32 characters for security");
+  }
+  nuxt.options.runtimeConfig.auth = defu(nuxt.options.runtimeConfig.auth, {
+    secondaryStorage: secondaryStorageEnabled
+  });
+  return { secondaryStorageEnabled };
+}
+
 function dialectToProvider(dialect) {
   return dialect === "postgresql" ? "pg" : dialect;
 }
@@ -57,101 +201,6 @@ 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');
@@ -186,34 +235,79 @@ async function loadUserAuthConfig(configPath, throwOnError = false) {
   }
 }
 
-function getHubDialect(hub) {
-  if (!hub?.db)
-    return void 0;
-  if (typeof hub.db === "string")
-    return hub.db;
-  if (typeof hub.db === "object" && hub.db !== null)
-    return hub.db.dialect;
-  return void 0;
+function isInsideNodeModules(path) {
+  return path.split(/[\\/]/).includes("node_modules");
 }
-function getHubCasing(hub) {
-  if (!hub?.db || typeof hub.db !== "object" || hub.db === null)
-    return void 0;
-  return hub.db.casing;
+function resolveHubSchemaPath(buildDir, rootDir, dialect, exists = existsSync) {
+  const rootTsPath = join(rootDir, ".nuxt", "better-auth", `schema.${dialect}.ts`);
+  if (isInsideNodeModules(buildDir) && exists(rootTsPath))
+    return rootTsPath;
+  const tsPath = join(buildDir, "better-auth", `schema.${dialect}.ts`);
+  if (exists(tsPath))
+    return tsPath;
+  const mjsPath = join(buildDir, "better-auth", `schema.${dialect}.mjs`);
+  if (exists(mjsPath))
+    return mjsPath;
+  return null;
 }
-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 "";
+async function loadAuthOptions(context) {
+  const isProduction = !context.nuxt.options.dev;
+  const configFile = `${context.serverConfigPath}.ts`;
+  const userConfig = await loadUserAuthConfig(configFile, isProduction);
+  const extendedConfig = {};
+  await context.nuxt.callHook("better-auth:config:extend", extendedConfig);
+  const plugins = [...userConfig.plugins || [], ...extendedConfig.plugins || []];
+  return { userConfig, plugins };
 }
+async function setupBetterAuthSchema(nuxt, serverConfigPath, options, consola) {
+  const hub = nuxt.options.hub;
+  const dialect = getHubDialect(hub);
+  if (!dialect || !["sqlite", "postgresql", "mysql"].includes(dialect)) {
+    consola.warn(`Unsupported database dialect: ${dialect}`);
+    return;
+  }
+  const context = { nuxt, serverConfigPath };
+  try {
+    const { userConfig, plugins } = await loadAuthOptions(context);
+    const authOptions = {
+      ...userConfig,
+      plugins,
+      secondaryStorage: options.secondaryStorage ? { get: async (_key) => null, set: async (_key, _value, _ttl) => {
+      }, delete: async (_key) => {
+      } } : void 0
+    };
+    const hubCasing = getHubCasing(hub);
+    const schemaOptions = { ...options.schema, useUuid: userConfig.advanced?.database?.generateId === "uuid", casing: options.schema?.casing ?? hubCasing };
+    const schemaCode = await generateDrizzleSchema(authOptions, dialect, schemaOptions);
+    const schemaDir = join(nuxt.options.buildDir, "better-auth");
+    const schemaPathTs = join(schemaDir, `schema.${dialect}.ts`);
+    const schemaPathMjs = join(schemaDir, `schema.${dialect}.mjs`);
+    await mkdir(schemaDir, { recursive: true });
+    await writeFile(schemaPathTs, schemaCode);
+    await writeFile(schemaPathMjs, schemaCode);
+    if (isInsideNodeModules(nuxt.options.buildDir)) {
+      const rootSchemaDir = join(nuxt.options.rootDir, ".nuxt", "better-auth");
+      const rootSchemaPathTs = join(rootSchemaDir, `schema.${dialect}.ts`);
+      await mkdir(rootSchemaDir, { recursive: true });
+      await writeFile(rootSchemaPathTs, schemaCode);
+    }
+    addTemplate({ filename: `better-auth/schema.${dialect}.ts`, getContents: () => schemaCode, write: true });
+    addTemplate({ filename: `better-auth/schema.${dialect}.mjs`, getContents: () => schemaCode, write: true });
+    consola.info(`Generated ${dialect} schema (.ts + .mjs)`);
+    const nuxtWithHubHooks = nuxt;
+    nuxtWithHubHooks.hook("hub:db:schema:extend", ({ paths, dialect: hookDialect }) => {
+      const schemaPath = resolveHubSchemaPath(nuxt.options.buildDir, nuxt.options.rootDir, hookDialect);
+      if (schemaPath)
+        paths.unshift(schemaPath);
+    });
+  } catch (error) {
+    const isProduction = !nuxt.options.dev;
+    if (isProduction)
+      throw error;
+    consola.error("Failed to generate schema:", error);
+  }
+}
+
 const generateSecret = () => randomBytes(32).toString("hex");
 function readEnvFile(rootDir) {
   const envPath = join(rootDir, ".env");
@@ -232,7 +326,7 @@ function appendSecretToEnv(rootDir, secret) {
 `;
   writeFileSync(envPath, content, "utf-8");
 }
-async function promptForSecret(rootDir) {
+async function promptForSecret(rootDir, consola) {
   if (process.env.BETTER_AUTH_SECRET || hasEnvSecret(rootDir))
     return void 0;
   if (isCI || isTest) {
@@ -278,161 +372,37 @@ Proceed?`, { type: "confirm", initial: true, cancel: "null" });
   consola.success("Added BETTER_AUTH_SECRET to .env");
   return secret;
 }
-const module$1 = defineNuxtModule({
-  meta: { name: "@onmax/nuxt-better-auth", version, configKey: "auth", compatibility: { nuxt: ">=3.0.0" } },
-  defaults: {
-    clientOnly: false,
-    serverConfig: "server/auth.config",
-    clientConfig: "app/auth.config",
-    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;
-    const serverConfigPath = resolver.resolve(nuxt.options.rootDir, serverConfigFile);
-    const clientConfigPath = resolver.resolve(nuxt.options.rootDir, clientConfigFile);
-    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 - export default defineServerAuth(...)`);
-    if (!clientConfigExists)
-      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.");
-      secondaryStorageEnabled = false;
-    } else if (secondaryStorageEnabled && (!hasNuxtHub || !hub?.kv)) {
-      consola.warn("secondaryStorage requires @nuxthub/core with hub.kv: true. Disabling.");
-      secondaryStorageEnabled = false;
-    }
-    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 || hasConvexDb,
-      clientOnly
-    });
-    if (clientOnly) {
-      const siteUrl = process.env.NUXT_PUBLIC_SITE_URL || nuxt.options.runtimeConfig.public.siteUrl;
-      if (!siteUrl) {
-        consola.warn("clientOnly mode: NUXT_PUBLIC_SITE_URL should be set to your frontend URL");
-      }
-      consola.info("clientOnly mode enabled - server utilities (serverAuth, getUserSession, requireUserSession) are not available");
-    }
-    if (!clientOnly) {
-      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 && !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) {
-        throw new Error("[nuxt-better-auth] BETTER_AUTH_SECRET must be at least 32 characters for security");
-      }
-      nuxt.options.runtimeConfig.auth = defu(nuxt.options.runtimeConfig.auth, {
-        secondaryStorage: secondaryStorageEnabled
-      });
-    }
-    nuxt.options.alias["#nuxt-better-auth"] = resolver.resolve("./runtime/types/augment");
-    if (!clientOnly)
-      nuxt.options.alias["#auth/server"] = serverConfigPath;
-    nuxt.options.alias["#auth/client"] = clientConfigPath;
-    if (!clientOnly) {
-      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 '@nuxthub/kv'
+function buildSecondaryStorageCode(enabled) {
+  if (!enabled)
+    return "export function createSecondaryStorage() { return undefined }";
+  return `import { kv } from '@nuxthub/kv'
 export function createSecondaryStorage() {
   return {
     get: async (key) => kv.get(\`_auth:\${key}\`),
     set: async (key, value, ttl) => kv.set(\`_auth:\${key}\`, value, { ttl }),
     delete: async (key) => kv.del(\`_auth:\${key}\`),
   }
-}` : `export function createSecondaryStorage() { return undefined }`;
-      const secondaryStorageTemplate = addTemplate({ filename: "better-auth/secondary-storage.mjs", getContents: () => secondaryStorageCode, write: true });
-      nuxt.options.alias["#auth/secondary-storage"] = secondaryStorageTemplate.dst;
-      if (hasHubDb && !nuxt.options.alias["hub:db"]) {
-        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 usePlural = options.schema?.usePlural ?? false;
-      const camelCase = (options.schema?.casing ?? getHubCasing(hub)) !== "snake_case";
-      let databaseCode;
-      if (hasHubDb) {
-        databaseCode = `import { db, schema } from '@nuxthub/db'
+}`;
+}
+function buildDatabaseCode(input) {
+  if (input.provider === "nuxthub") {
+    return `import { db, schema } from '@nuxthub/db'
 import { drizzleAdapter } from 'better-auth/adapters/drizzle'
-const rawDialect = '${hubDialect}'
+const rawDialect = '${input.hubDialect}'
 const dialect = rawDialect === 'postgresql' ? 'pg' : rawDialect
-export function createDatabase() { return drizzleAdapter(db, { provider: dialect, schema, usePlural: ${usePlural}, camelCase: ${camelCase} }) }
+export function createDatabase() { return drizzleAdapter(db, { provider: dialect, schema, usePlural: ${input.usePlural}, camelCase: ${input.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 }
+  }
+  return `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({
-        filename: "types/auth-secondary-storage.d.ts",
-        getContents: () => `
+}
+
+function registerServerTypeTemplates(input) {
+  const { serverConfigPath, hasHubDb, runtimeTypesPath } = input;
+  addTypeTemplate({
+    filename: "types/auth-secondary-storage.d.ts",
+    getContents: () => `
 declare module '#auth/secondary-storage' {
   interface SecondaryStorage {
     get: (key: string) => Promise<string | null>
@@ -442,214 +412,287 @@ declare module '#auth/secondary-storage' {
   export function createSecondaryStorage(): SecondaryStorage | undefined
 }
 `
-      }, { nitro: true, node: true });
-      addTypeTemplate({
-        filename: "types/auth-database.d.ts",
-        getContents: () => `
+  }, { nitro: true, node: true });
+  addTypeTemplate({
+    filename: "types/auth-database.d.ts",
+    getContents: () => `
 declare module '#auth/database' {
-  import type { drizzleAdapter } from 'better-auth/adapters/drizzle'
-  export function createDatabase(): ReturnType<typeof drizzleAdapter> | undefined
-  export const db: unknown
+  import type { BetterAuthOptions } from 'better-auth'
+  export function createDatabase(): BetterAuthOptions['database']
+  export const db: ${hasHubDb ? `typeof import('@nuxthub/db')['db']` : "undefined"}
 }
 `
-      }, { nitro: true, node: true });
-      addTypeTemplate({
-        filename: "types/nuxt-better-auth-infer.d.ts",
-        getContents: () => `
-import type { InferUser, InferSession, InferPluginTypes } from 'better-auth'
+  }, { nitro: true, node: true });
+  addTypeTemplate({
+    filename: "types/nuxt-better-auth-infer.d.ts",
+    getContents: () => `
+import type { BetterAuthOptions, BetterAuthPlugin, InferPluginTypes, UnionToIntersection } from 'better-auth'
+import type { InferFieldsOutput } from 'better-auth/db'
 import type { RuntimeConfig } from 'nuxt/schema'
 import type createServerAuth from '${serverConfigPath}'
 
-type _Config = ReturnType<typeof createServerAuth>
+type _RawConfig = ReturnType<typeof createServerAuth>
+type _RawPlugins = _RawConfig extends { plugins: infer P } ? P : _RawConfig extends { plugins?: infer P } ? P : []
+type _NormalizedPlugins = _RawPlugins extends readonly (infer T)[]
+  ? Array<T & BetterAuthPlugin>
+  : _RawPlugins extends (infer T)[]
+      ? Array<T & BetterAuthPlugin>
+      : BetterAuthPlugin[]
+type _Config = Omit<BetterAuthOptions, 'plugins'> & Omit<_RawConfig, 'plugins'> & {
+  plugins?: _NormalizedPlugins
+}
+
+type _InferModelFieldsFromPlugins<P, M extends string> = P extends readonly (infer Plugin)[]
+  ? UnionToIntersection<Plugin extends { schema: { [K in M]: { fields: infer F } } } ? InferFieldsOutput<F> : {}>
+  : P extends (infer Plugin)[]
+      ? UnionToIntersection<Plugin extends { schema: { [K in M]: { fields: infer F } } } ? InferFieldsOutput<F> : {}>
+      : {}
+
+type _InferModelFieldsFromOptions<C, M extends 'user' | 'session'> = C extends { [K in M]: { additionalFields: infer F } }
+  ? InferFieldsOutput<F>
+  : {}
+
+type _UserFallback = _InferModelFieldsFromPlugins<_RawPlugins, 'user'> & _InferModelFieldsFromOptions<_RawConfig, 'user'>
+type _SessionFallback = _InferModelFieldsFromPlugins<_RawPlugins, 'session'> & _InferModelFieldsFromOptions<_RawConfig, 'session'>
 
 declare module '#nuxt-better-auth' {
-  interface AuthUser extends InferUser<_Config> {}
-  interface AuthSession extends InferSession<_Config> {}
+  interface AuthUser extends _UserFallback {}
+  interface AuthSession extends _SessionFallback {}
   interface ServerAuthContext {
     runtimeConfig: RuntimeConfig
-    ${hasHubDb ? `db: typeof import('@nuxthub/db')['db']` : ""}
+    db: ${hasHubDb ? `typeof import('@nuxthub/db')['db']` : "undefined"}
   }
   type PluginTypes = InferPluginTypes<_Config>
 }
 
-// Augment the config module to use the extended ServerAuthContext
 interface _AugmentedServerAuthContext {
   runtimeConfig: RuntimeConfig
-  ${hasHubDb ? `db: typeof import('@nuxthub/db')['db']` : "db: unknown"}
+  db: ${hasHubDb ? `typeof import('@nuxthub/db')['db']` : "undefined"}
 }
 
 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: T | ((ctx: _AugmentedServerAuthContext) => T)): (ctx: _AugmentedServerAuthContext) => T
+  import type { BetterAuthOptions, BetterAuthPlugin } from 'better-auth'
+  type ServerAuthConfig = Omit<BetterAuthOptions, 'secret' | 'baseURL'> & {
+    plugins?: readonly BetterAuthPlugin[]
+  }
+  export function defineServerAuth<const R extends ServerAuthConfig>(config: R): (ctx: _AugmentedServerAuthContext) => R
+  export function defineServerAuth<const R extends ServerAuthConfig>(config: (ctx: _AugmentedServerAuthContext) => R): (ctx: _AugmentedServerAuthContext) => R
 }
 `
-      }, { nuxt: true, nitro: true, node: true });
-      addTypeTemplate({
-        filename: "types/nuxt-better-auth-nitro.d.ts",
-        getContents: () => `
+  }, { nuxt: true, nitro: true, node: true });
+  addTypeTemplate({
+    filename: "types/nuxt-better-auth-nitro.d.ts",
+    getContents: () => `
 declare module 'nitropack' {
   interface NitroRouteRules {
-    auth?: import('${resolver.resolve("./runtime/types")}').AuthMeta
+    auth?: import('${runtimeTypesPath}').AuthMeta
   }
   interface NitroRouteConfig {
-    auth?: import('${resolver.resolve("./runtime/types")}').AuthMeta
+    auth?: import('${runtimeTypesPath}').AuthMeta
   }
 }
 declare module 'nitropack/types' {
   interface NitroRouteRules {
-    auth?: import('${resolver.resolve("./runtime/types")}').AuthMeta
+    auth?: import('${runtimeTypesPath}').AuthMeta
   }
   interface NitroRouteConfig {
-    auth?: import('${resolver.resolve("./runtime/types")}').AuthMeta
+    auth?: import('${runtimeTypesPath}').AuthMeta
   }
 }
 export {}
 `
-      }, { nuxt: true, nitro: true, node: true });
-    }
-    addTypeTemplate({
-      filename: "types/nuxt-better-auth.d.ts",
-      getContents: () => `
-export * from '${resolver.resolve("./runtime/types/augment")}'
-export type { AuthMeta, AuthMode, AuthRouteRules, UserMatch, RequireSessionOptions, Auth, InferUser, InferSession } from '${resolver.resolve("./runtime/types")}'
+  }, { nuxt: true, nitro: true, node: true });
+}
+function registerSharedTypeTemplates(input) {
+  addTypeTemplate({
+    filename: "types/nuxt-better-auth.d.ts",
+    getContents: () => `
+import type { AuthSession, AuthUser } from '${input.runtimeTypesAugmentPath}'
+import type { UserMatch } from '${input.runtimeTypesPath}'
+export * from '${input.runtimeTypesAugmentPath}'
+export type { AuthMeta, AuthMode, AuthRouteRules, UserMatch, Auth, InferUser, InferSession } from '${input.runtimeTypesPath}'
+export interface RequireSessionOptions {
+  user?: UserMatch<AuthUser>
+  rule?: (ctx: { user: AuthUser, session: AuthSession }) => boolean | Promise<boolean>
+}
 `
-    });
-    addTypeTemplate({
-      filename: "types/nuxt-better-auth-client.d.ts",
-      getContents: () => `
-import type createAppAuthClient from '${clientConfigPath}'
+  });
+  addTypeTemplate({
+    filename: "types/nuxt-better-auth-client.d.ts",
+    getContents: () => `
+import type createAppAuthClient from '${input.clientConfigPath}'
 declare module '#nuxt-better-auth' {
   export type AppAuthClient = ReturnType<typeof createAppAuthClient>
 }
 `
-    });
-    nuxt.hook("builder:watch", async (_event, relativePath) => {
-      if (relativePath.includes("auth.config")) {
-        await updateTemplates({ filter: (t) => t.filename.includes("nuxt-better-auth") });
-      }
-    });
-    if (!clientOnly) {
-      addServerImportsDir(resolver.resolve("./runtime/server/utils"));
-      addServerImports([{ name: "defineServerAuth", from: resolver.resolve("./runtime/config") }]);
-      addServerScanDir(resolver.resolve("./runtime/server/middleware"));
-      addServerHandler({ route: "/api/auth/**", handler: resolver.resolve("./runtime/server/api/auth/[...all]") });
+  });
+}
+
+const consola = consola$1.withTag("nuxt-better-auth");
+function resolveDefaultClientConfig(options, rootDir, srcDir) {
+  if (options.clientConfig !== "app/auth.config")
+    return;
+  const srcDirRelative = srcDir.replace(`${rootDir}/`, "");
+  options.clientConfig = srcDirRelative === srcDir ? "auth.config" : `${srcDirRelative}/auth.config`;
+}
+async function createDefaultAuthConfigFiles(rootDir, srcDir) {
+  const serverPath = join(rootDir, "server/auth.config.ts");
+  const clientPath = join(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(`${rootDir}/`, "");
+    consola.success(`Created ${relativePath}`);
+  }
+}
+const module$1 = defineNuxtModule({
+  meta: { name: "@onmax/nuxt-better-auth", version, configKey: "auth", compatibility: { nuxt: ">=4.0.0" } },
+  defaults: {
+    clientOnly: false,
+    serverConfig: "server/auth.config",
+    clientConfig: "app/auth.config",
+    redirects: { login: "/login", guest: "/" },
+    secondaryStorage: false
+  },
+  async onInstall(nuxt) {
+    const generatedSecret = await promptForSecret(nuxt.options.rootDir, consola);
+    if (generatedSecret)
+      process.env.BETTER_AUTH_SECRET = generatedSecret;
+    await createDefaultAuthConfigFiles(nuxt.options.rootDir, nuxt.options.srcDir);
+  },
+  async setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    resolveDefaultClientConfig(options, nuxt.options.rootDir, nuxt.options.srcDir);
+    const clientOnly = options.clientOnly;
+    const serverConfigFile = options.serverConfig;
+    const clientConfigFile = options.clientConfig;
+    const serverConfigPath = resolver.resolve(nuxt.options.rootDir, serverConfigFile);
+    const clientConfigPath = resolver.resolve(nuxt.options.rootDir, clientConfigFile);
+    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 - export default defineServerAuth(...)`);
+    if (!clientConfigExists)
+      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 hasHubDbAvailable = !clientOnly && hasNuxtHub && !!hub?.db;
+    const deprecatedProvider = options.database?.provider;
+    if (deprecatedProvider) {
+      throw new Error(
+        `[nuxt-better-auth] auth.database.provider has been removed. Remove auth.database.provider="${deprecatedProvider}". To configure a database, either set "database" directly in server/auth.config.ts (defineServerAuth) or install a provider module that registers better-auth:database:providers.`
+      );
     }
-    addImportsDir(resolver.resolve("./runtime/app/composables"));
-    addImportsDir(resolver.resolve("./runtime/utils"));
+    let databaseProvider = "none";
+    let hasHubDb = false;
+    nuxt.options.alias["#nuxt-better-auth"] = resolver.resolve("./runtime/types/augment");
     if (!clientOnly)
-      addPlugin({ src: resolver.resolve("./runtime/app/plugins/session.server"), mode: "server" });
-    addPlugin({ src: resolver.resolve("./runtime/app/plugins/session.client"), mode: "client" });
-    addComponentsDir({ path: resolver.resolve("./runtime/app/components") });
-    nuxt.hook("app:resolve", (app) => {
-      app.middleware.push({ name: "auth", path: resolver.resolve("./runtime/app/middleware/auth.global"), global: true });
-    });
-    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) {
-        addServerHandler({ route: "/api/_better-auth/sessions", method: "get", handler: resolver.resolve("./runtime/server/api/_better-auth/sessions.get") });
-        addServerHandler({ route: "/api/_better-auth/sessions", method: "delete", handler: resolver.resolve("./runtime/server/api/_better-auth/sessions.delete") });
-        addServerHandler({ route: "/api/_better-auth/users", method: "get", handler: resolver.resolve("./runtime/server/api/_better-auth/users.get") });
-        addServerHandler({ route: "/api/_better-auth/accounts", method: "get", handler: resolver.resolve("./runtime/server/api/_better-auth/accounts.get") });
-      }
-      extendPages((pages) => {
-        pages.push({ name: "better-auth-devtools", path: "/__better-auth-devtools", file: resolver.resolve("./runtime/app/pages/__better-auth-devtools.vue") });
+      nuxt.options.alias["#auth/server"] = serverConfigPath;
+    nuxt.options.alias["#auth/client"] = clientConfigPath;
+    if (clientOnly) {
+      setupRuntimeConfig({
+        nuxt,
+        options,
+        clientOnly,
+        databaseProvider,
+        hasNuxtHub,
+        hub,
+        consola
       });
-    }
-    nuxt.hook("pages:extend", (pages) => {
-      const routeRules = nuxt.options.routeRules || {};
-      if (!Object.keys(routeRules).length)
-        return;
-      const matcher = toRouteMatcher(createRouter({ routes: routeRules }));
-      const applyMetaFromRules = (page) => {
-        const matches = matcher.matchAll(page.path);
-        if (!matches.length)
-          return;
-        const matchedRules = defu({}, ...matches.reverse());
-        if (matchedRules.auth !== void 0) {
-          page.meta = page.meta || {};
-          page.meta.auth = matchedRules.auth;
+    } else {
+      const hubDialect = getHubDialect(hub) ?? "sqlite";
+      const usePlural = options.schema?.usePlural ?? false;
+      const camelCase = (options.schema?.casing ?? getHubCasing(hub)) !== "snake_case";
+      const providers = {
+        nuxthub: {
+          priority: 100,
+          isEnabled: ({ hasHubDbAvailable: hasHubDbAvailable2 }) => hasHubDbAvailable2,
+          buildDatabaseCode: () => buildDatabaseCode({
+            provider: "nuxthub",
+            hubDialect,
+            usePlural,
+            camelCase
+          })
+        },
+        none: {
+          priority: 0,
+          buildDatabaseCode: () => buildDatabaseCode({
+            provider: "none",
+            hubDialect,
+            usePlural,
+            camelCase
+          })
         }
-        page.children?.forEach((child) => applyMetaFromRules(child));
       };
-      pages.forEach((page) => applyMetaFromRules(page));
+      const enabledCtx = { nuxt, options, clientOnly, hasHubDbAvailable };
+      await nuxt.callHook("better-auth:database:providers", providers);
+      const resolvedProvider = resolveDatabaseProvider({ providers, context: enabledCtx });
+      databaseProvider = resolvedProvider.id;
+      hasHubDb = databaseProvider === "nuxthub";
+      const { secondaryStorageEnabled } = setupRuntimeConfig({
+        nuxt,
+        options,
+        clientOnly,
+        databaseProvider,
+        hasNuxtHub,
+        hub,
+        consola
+      });
+      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 secondaryStorageTemplate = addTemplate({
+        filename: "better-auth/secondary-storage.mjs",
+        getContents: () => buildSecondaryStorageCode(secondaryStorageEnabled),
+        write: true
+      });
+      nuxt.options.alias["#auth/secondary-storage"] = secondaryStorageTemplate.dst;
+      if (hasHubDb && !nuxt.options.alias["hub:db"]) {
+        throw new Error("[nuxt-better-auth] hub:db not found. Ensure @nuxthub/core is loaded before this module and hub.db is configured.");
+      }
+      const setupCtx = { nuxt, options, clientOnly };
+      await resolvedProvider.definition.setup?.(setupCtx);
+      const buildCtx = { hubDialect, usePlural, camelCase };
+      const databaseTemplate = addTemplate({
+        filename: "better-auth/database.mjs",
+        getContents: () => resolvedProvider.definition.buildDatabaseCode(buildCtx),
+        write: true
+      });
+      nuxt.options.alias["#auth/database"] = databaseTemplate.dst;
+      registerServerTypeTemplates({
+        serverConfigPath,
+        hasHubDb,
+        runtimeTypesPath: resolver.resolve("./runtime/types")
+      });
+      if (hasHubDb)
+        await setupBetterAuthSchema(nuxt, serverConfigPath, options, consola);
+    }
+    registerSharedTypeTemplates({
+      runtimeTypesAugmentPath: resolver.resolve("./runtime/types/augment"),
+      runtimeTypesPath: resolver.resolve("./runtime/types"),
+      clientConfigPath
     });
+    registerTemplateHmrHook(nuxt);
+    registerServerRuntime({ clientOnly, resolve: resolver.resolve });
+    registerAuthMiddlewareHook(nuxt, resolver.resolve);
+    await registerDevtools({ nuxt, clientOnly, hasHubDb, resolve: resolver.resolve });
+    registerRouteRulesMetaHook(nuxt);
   }
 });
-async function setupBetterAuthSchema(nuxt, serverConfigPath, options) {
-  const hub = nuxt.options.hub;
-  const dialect = getHubDialect(hub);
-  if (!dialect || !["sqlite", "postgresql", "mysql"].includes(dialect)) {
-    consola.warn(`Unsupported database dialect: ${dialect}`);
-    return;
-  }
-  const isProduction = !nuxt.options.dev;
-  try {
-    const configFile = `${serverConfigPath}.ts`;
-    const userConfig = await loadUserAuthConfig(configFile, isProduction);
-    const extendedConfig = {};
-    await nuxt.callHook("better-auth:config:extend", extendedConfig);
-    const plugins = [...userConfig.plugins || [], ...extendedConfig.plugins || []];
-    const authOptions = {
-      ...userConfig,
-      plugins,
-      secondaryStorage: options.secondaryStorage ? { get: async (_key) => null, set: async (_key, _value, _ttl) => {
-      }, delete: async (_key) => {
-      } } : void 0
-    };
-    const hubCasing = getHubCasing(hub);
-    const schemaOptions = { ...options.schema, useUuid: userConfig.advanced?.database?.generateId === "uuid", casing: options.schema?.casing ?? hubCasing };
-    const schemaCode = await generateDrizzleSchema(authOptions, dialect, schemaOptions);
-    const schemaDir = join(nuxt.options.buildDir, "better-auth");
-    const schemaPath = join(schemaDir, `schema.${dialect}.ts`);
-    await mkdir(schemaDir, { recursive: true });
-    await writeFile(schemaPath, schemaCode);
-    addTemplate({ filename: `better-auth/schema.${dialect}.ts`, getContents: () => schemaCode, write: true });
-    consola.info(`Generated ${dialect} schema`);
-  } catch (error) {
-    if (isProduction) {
-      throw error;
-    }
-    consola.error("Failed to generate schema:", error);
-  }
-  const nuxtWithHubHooks = nuxt;
-  nuxtWithHubHooks.hook("hub:db:schema:extend", ({ paths, dialect: hookDialect }) => {
-    const schemaPath = join(nuxt.options.buildDir, "better-auth", `schema.${hookDialect}.ts`);
-    if (existsSync(schemaPath)) {
-      paths.unshift(schemaPath);
-    }
-  });
-}
-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 };