@onmax/nuxt-better-auth 0.0.1 → 0.0.2-alpha.10

package/README.md

@@ -1,180 +1,27 @@
-# @onmax/nuxt-better-auth
+<p align="center">
+  <img src="https://raw.githubusercontent.com/onmax/nuxt-better-auth/main/.github/og.png" alt="Nuxt Better Auth" width="100%">
+  <br>
+  <sub>Designed by <a href="https://github.com/HugoRCD">HugoRCD</a></sub>
+</p>
 
-[![npm version][npm-version-src]][npm-version-href]
-[![npm downloads][npm-downloads-src]][npm-downloads-href]
-[![License][license-src]][license-href]
-[![Nuxt][nuxt-src]][nuxt-href]
+<h1 align="center">@onmax/nuxt-better-auth</h1>
 
-Nuxt module for [Better Auth](https://better-auth.com) with auto schema generation, route protection, and session management. Works with [NuxtHub](https://hub.nuxt.com) and future `@nuxt/db`.
+<p align="center">Nuxt module for <a href="https://better-auth.com">Better Auth</a></p>
 
-## Features
+<p align="center">
+  <a href="https://npmjs.com/package/@onmax/nuxt-better-auth"><img src="https://img.shields.io/npm/v/@onmax/nuxt-better-auth/latest.svg?style=flat&colorA=020420&colorB=00DC82" alt="npm version"></a>
+  <a href="https://npm.chart.dev/@onmax/nuxt-better-auth"><img src="https://img.shields.io/npm/dm/@onmax/nuxt-better-auth.svg?style=flat&colorA=020420&colorB=00DC82" alt="npm downloads"></a>
+  <a href="https://npmjs.com/package/@onmax/nuxt-better-auth"><img src="https://img.shields.io/npm/l/@onmax/nuxt-better-auth.svg?style=flat&colorA=020420&colorB=00DC82" alt="License"></a>
+  <a href="https://nuxt.com"><img src="https://img.shields.io/badge/Nuxt-020420?logo=nuxt.js" alt="Nuxt"></a>
+</p>
 
-- **Auto Schema Generation** - Generates Drizzle schema from your better-auth plugins
-- **Route Protection** - Declarative access rules via `routeRules`
-- **Session Management** - SSR-safe session handling with client hydration
-- **Role-Based Access** - Support for `admin`, `user`, and custom roles
-- **Auto-Imports** - `useUserSession`, `requireUserSession`, `getUserSession`
-- **BetterAuthState Component** - Ready-to-use Vue component with slots
+> [!WARNING]
+> This library is a work in progress and not ready for production use.
 
-## Requirements
+## Documentation
 
-- NuxtHub with database enabled (`hub: { database: true }`) or future `@nuxt/db`
-
-## Quick Start
-
-### 1. Install
-
-```bash
-pnpm add @onmax/nuxt-better-auth better-auth drizzle-orm @nuxthub/core
-```
-
-### 2. Configure Nuxt
-
-```ts
-export default defineNuxtConfig({
-  modules: ['@nuxthub/core', '@onmax/nuxt-better-auth'],
-
-  hub: { database: true },
-
-  runtimeConfig: {
-    betterAuthSecret: '', // BETTER_AUTH_SECRET env var
-    public: { siteUrl: 'http://localhost:3000' },
-  },
-
-  routeRules: {
-    '/app/**': { auth: 'user' },
-    '/admin/**': { auth: { role: 'admin' } },
-    '/login': { auth: 'guest' },
-  },
-})
-```
-
-### 3. Create Server Config
-
-Create `server/auth.config.ts`:
-
-```ts
-import { admin } from 'better-auth/plugins'
-import { defineServerAuth } from '@onmax/nuxt-better-auth'
-
-export default defineServerAuth(({ db }) => ({
-  appName: 'My App',
-  plugins: [admin()],
-  emailAndPassword: { enabled: true },
-}))
-```
-
-> Schema is auto-generated from your plugins! No manual Drizzle schema needed.
-
-### 4. Create Client Config
-
-Create `app/auth.client.ts`:
-
-```ts
-import { adminClient } from 'better-auth/client/plugins'
-import { createAuthClient } from 'better-auth/vue'
-
-export function createAppAuthClient(baseURL: string) {
-  return createAuthClient({
-    baseURL,
-    plugins: [adminClient()],
-  })
-}
-
-export type AppAuthClient = ReturnType<typeof createAppAuthClient>
-```
-
-### 5. Add Type Extensions
-
-Create `shared/types/auth.d.ts`:
-
-```ts
-import '#nuxt-better-auth'
-
-declare module '#nuxt-better-auth' {
-  interface AuthUser {
-    role?: string | null
-    banned?: boolean | null
-  }
-}
-```
-
-## Route Rules
-
-| Option | Type | Description |
-|--------|------|-------------|
-| `auth` | `false \| 'guest' \| 'user' \| { role: string }` | Auth requirement |
-
-Examples:
-- `auth: false` - Public (default)
-- `auth: 'guest'` - Only unauthenticated users
-- `auth: 'user'` - Any authenticated user
-- `auth: { role: 'admin' }` - Requires specific role
-
-## Composables
-
-### `useUserSession()`
-
-```ts
-const { user, session, loggedIn, ready, client } = useUserSession()
-```
-
-### `<BetterAuthState>`
-
-```vue
-<BetterAuthState>
-  <template #default="{ loggedIn, user, signOut }">
-    <p v-if="loggedIn">Welcome, {{ user?.name }}</p>
-    <p v-else>Not logged in</p>
-  </template>
-  <template #placeholder>
-    <p>Loading...</p>
-  </template>
-</BetterAuthState>
-```
-
-## Server Utils
-
-```ts
-// Require auth
-const { user, session } = await requireUserSession(event)
-
-// Require admin
-const { user } = await requireUserSession(event, { role: 'admin' })
-
-// Optional session
-const session = await getUserSession(event)
-```
-
-## Module Aliases
-
-| Alias | Points To |
-|-------|-----------|
-| `#auth/server` | `server/auth.config.ts` |
-| `#auth/client` | `app/auth.client.ts` |
-| `#nuxt-better-auth` | Module type augmentation |
-
-## Development
-
-```bash
-pnpm install
-pnpm dev:prepare
-pnpm dev
-```
+**[nuxt-better-auth.onmax.me](https://nuxt-better-auth.onmax.me/)**
 
 ## License
 
 MIT
-
-<!-- Badges -->
-[npm-version-src]: https://img.shields.io/npm/v/@onmax/nuxt-better-auth/latest.svg?style=flat&colorA=020420&colorB=00DC82
-[npm-version-href]: https://npmjs.com/package/@onmax/nuxt-better-auth
-
-[npm-downloads-src]: https://img.shields.io/npm/dm/@onmax/nuxt-better-auth.svg?style=flat&colorA=020420&colorB=00DC82
-[npm-downloads-href]: https://npm.chart.dev/@onmax/nuxt-better-auth
-
-[license-src]: https://img.shields.io/npm/l/@onmax/nuxt-better-auth.svg?style=flat&colorA=020420&colorB=00DC82
-[license-href]: https://npmjs.com/package/@onmax/nuxt-better-auth
-
-[nuxt-src]: https://img.shields.io/badge/Nuxt-020420?logo=nuxt.js
-[nuxt-href]: https://nuxt.com

package/dist/module.d.mts

@@ -1,2 +1,20 @@
-export * from "/home/maxi/nuxt/better-auth/src/module.js";
-export { default } from "/home/maxi/nuxt/better-auth/src/module.js";
+import * as _nuxt_schema from '@nuxt/schema';
+import { BetterAuthModuleOptions } from '../dist/runtime/config.js';
+export { BetterAuthModuleOptions, defineClientAuth, defineServerAuth } from '../dist/runtime/config.js';
+import { BetterAuthOptions } from 'better-auth';
+export { Auth, AuthMeta, AuthMode, AuthRouteRules, AuthSession, AuthUser, InferSession, InferUser, RequireSessionOptions, ServerAuthContext, UserMatch } from '../dist/runtime/types.js';
+
+declare module '@nuxt/schema' {
+    interface NuxtHooks {
+        /**
+         * Extend better-auth config with additional plugins or options.
+         * Called after user's auth.config.ts is loaded.
+         * @param config - Partial config to merge into the auth options
+         */
+        'better-auth:config:extend': (config: Partial<BetterAuthOptions>) => void | Promise<void>;
+    }
+}
+
+declare const _default: _nuxt_schema.NuxtModule<BetterAuthModuleOptions, BetterAuthModuleOptions, false>;
+
+export { _default as default };

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.0.0"
   },
-  "version": "0.0.1",
+  "version": "0.0.2-alpha.10",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,20 +1,438 @@
-import { createJiti } from "file:///home/maxi/nuxt/better-auth/node_modules/.pnpm/jiti@2.6.1/node_modules/jiti/lib/jiti.mjs";
+import { existsSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { defineNuxtModule, createResolver, hasNuxtModule, addTemplate, addTypeTemplate, updateTemplates, addServerImportsDir, addServerScanDir, addServerHandler, addImportsDir, addPlugin, addComponentsDir, extendPages } from '@nuxt/kit';
+import { consola as consola$1 } from 'consola';
+import { defu } from 'defu';
+import { join } from 'pathe';
+import { toRouteMatcher, createRouter } from 'radix3';
+import pluralize from 'pluralize';
+export { defineClientAuth, defineServerAuth } from '../dist/runtime/config.js';
 
-const jiti = createJiti(import.meta.url, {
-  "interopDefault": true,
-  "alias": {
-    "@onmax/nuxt-better-auth": "/home/maxi/nuxt/better-auth"
+function setupDevTools(nuxt) {
+  nuxt.hook("devtools:customTabs", (tabs) => {
+    tabs.push({
+      category: "server",
+      name: "better-auth",
+      title: "Auth",
+      icon: "simple-icons:betterauth",
+      view: {
+        type: "iframe",
+        src: "/__better-auth-devtools"
+      }
+    });
+  });
+}
+
+function toSnakeCase(str) {
+  return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function generateDrizzleSchema(tables, dialect, options) {
+  const typedTables = tables;
+  const imports = getImports(dialect, options);
+  const tableDefinitions = Object.entries(typedTables).map(([tableName, table]) => generateTable(tableName, table, dialect, typedTables, options)).join("\n\n");
+  return `${imports}
+
+${tableDefinitions}
+`;
+}
+function getImports(dialect, options) {
+  switch (dialect) {
+    case "sqlite":
+      return `import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core'`;
+    case "postgresql":
+      return options?.useUuid ? `import { boolean, integer, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core'` : `import { boolean, integer, pgTable, text, timestamp } from 'drizzle-orm/pg-core'`;
+    case "mysql":
+      return `import { boolean, int, mysqlTable, text, timestamp, varchar } from 'drizzle-orm/mysql-core'`;
+  }
+}
+function generateTable(tableName, table, dialect, allTables, options) {
+  const tableFunc = dialect === "sqlite" ? "sqliteTable" : dialect === "postgresql" ? "pgTable" : "mysqlTable";
+  const hasCustomModelName = table.modelName && table.modelName !== tableName;
+  let dbTableName = hasCustomModelName ? table.modelName : tableName;
+  if (options?.casing === "snake_case" && !hasCustomModelName)
+    dbTableName = toSnakeCase(dbTableName);
+  if (options?.usePlural && !hasCustomModelName)
+    dbTableName = pluralize(dbTableName);
+  const fields = Object.entries(table.fields).map(([fieldName, field]) => generateField(fieldName, field, dialect, allTables, options)).join(",\n    ");
+  const idField = generateIdField(dialect, options);
+  return `export const ${tableName} = ${tableFunc}('${dbTableName}', {
+    ${idField},
+    ${fields}
+  })`;
+}
+function generateIdField(dialect, options) {
+  switch (dialect) {
+    case "sqlite":
+      if (options?.useUuid)
+        consola$1.warn("[@onmax/nuxt-better-auth] useUuid ignored for SQLite (no native uuid type). Using text.");
+      return `id: text('id').primaryKey()`;
+    case "postgresql":
+      return options?.useUuid ? `id: uuid('id').defaultRandom().primaryKey()` : `id: text('id').primaryKey()`;
+    case "mysql":
+      return `id: varchar('id', { length: 36 }).primaryKey()`;
+  }
+}
+function generateField(fieldName, field, dialect, allTables, options) {
+  const dbFieldName = options?.casing === "snake_case" ? toSnakeCase(fieldName) : fieldName;
+  const isFkToId = options?.useUuid && field.references?.field === "id";
+  let fieldDef;
+  if (isFkToId && dialect === "postgresql")
+    fieldDef = `uuid('${dbFieldName}')`;
+  else if (isFkToId && dialect === "mysql")
+    fieldDef = `varchar('${dbFieldName}', { length: 36 })`;
+  else
+    fieldDef = getFieldType(field.type, dialect, dbFieldName);
+  if (field.required && field.defaultValue === void 0)
+    fieldDef += ".notNull()";
+  if (field.unique)
+    fieldDef += ".unique()";
+  if (field.defaultValue !== void 0) {
+    if (typeof field.defaultValue === "boolean")
+      fieldDef += `.default(${field.defaultValue})`;
+    else if (typeof field.defaultValue === "string")
+      fieldDef += `.default('${field.defaultValue}')`;
+    else if (typeof field.defaultValue === "function")
+      fieldDef += `.$defaultFn(${field.defaultValue})`;
+    else
+      fieldDef += `.default(${field.defaultValue})`;
+    if (field.required)
+      fieldDef += ".notNull()";
+  }
+  if (typeof field.onUpdate === "function" && field.type === "date")
+    fieldDef += `.$onUpdate(${field.onUpdate})`;
+  if (field.references) {
+    const refTable = field.references.model;
+    if (allTables[refTable])
+      fieldDef += `.references(() => ${refTable}.${field.references.field})`;
+  }
+  return `${fieldName}: ${fieldDef}`;
+}
+function getFieldType(type, dialect, fieldName) {
+  const normalizedType = Array.isArray(type) ? "string" : type;
+  switch (dialect) {
+    case "sqlite":
+      return getSqliteType(normalizedType, fieldName);
+    case "postgresql":
+      return getPostgresType(normalizedType, fieldName);
+    case "mysql":
+      return getMysqlType(normalizedType, fieldName);
+  }
+}
+function getSqliteType(type, fieldName) {
+  switch (type) {
+    case "string":
+      return `text('${fieldName}')`;
+    case "boolean":
+      return `integer('${fieldName}', { mode: 'boolean' })`;
+    case "date":
+      return `integer('${fieldName}', { mode: 'timestamp' })`;
+    case "number":
+      return `integer('${fieldName}')`;
+    default:
+      return `text('${fieldName}')`;
+  }
+}
+function getPostgresType(type, fieldName) {
+  switch (type) {
+    case "string":
+      return `text('${fieldName}')`;
+    case "boolean":
+      return `boolean('${fieldName}')`;
+    case "date":
+      return `timestamp('${fieldName}')`;
+    case "number":
+      return `integer('${fieldName}')`;
+    default:
+      return `text('${fieldName}')`;
+  }
+}
+function getMysqlType(type, fieldName) {
+  switch (type) {
+    case "string":
+      return `text('${fieldName}')`;
+    case "boolean":
+      return `boolean('${fieldName}')`;
+    case "date":
+      return `timestamp('${fieldName}')`;
+    case "number":
+      return `int('${fieldName}')`;
+    default:
+      return `text('${fieldName}')`;
+  }
+}
+async function loadUserAuthConfig(configPath, throwOnError = false) {
+  const { createJiti } = await import('jiti');
+  const jiti = createJiti(import.meta.url, { interopDefault: true });
+  try {
+    const mod = await jiti.import(configPath);
+    const configFn = typeof mod === "object" && mod !== null && "default" in mod ? mod.default : mod;
+    if (typeof configFn === "function") {
+      return configFn({ runtimeConfig: {}, db: null });
+    }
+    if (throwOnError) {
+      throw new Error("auth.config.ts must export default defineServerAuth(...)");
+    }
+    return {};
+  } catch (error) {
+    if (throwOnError) {
+      throw new Error(`Failed to load auth config: ${error instanceof Error ? error.message : error}`);
+    }
+    consola$1.error("[@onmax/nuxt-better-auth] Failed to load auth config for schema generation. Schema may be incomplete:", error);
+    return {};
+  }
+}
+
+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;
+}
+const consola = consola$1.withTag("nuxt-better-auth");
+const module$1 = defineNuxtModule({
+  meta: { name: "@onmax/nuxt-better-auth", configKey: "auth", compatibility: { nuxt: ">=3.0.0" } },
+  defaults: {
+    serverConfig: "server/auth.config",
+    clientConfig: "app/auth.config",
+    redirects: { login: "/login", guest: "/" },
+    secondaryStorage: false
   },
-  "transformOptions": {
-    "babel": {
-      "plugins": []
+  async setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    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 (!serverConfigExists)
+      throw new Error(`[nuxt-better-auth] Missing ${serverConfigFile}.ts - create with defineServerAuth()`);
+    if (!clientConfigExists)
+      throw new Error(`[nuxt-better-auth] Missing ${clientConfigFile}.ts - export createAppAuthClient()`);
+    const hasNuxtHub = hasNuxtModule("@nuxthub/core", nuxt);
+    const hub = hasNuxtHub ? nuxt.options.hub : void 0;
+    const hasHubDb = hasNuxtHub && !!hub?.db;
+    let secondaryStorageEnabled = options.secondaryStorage ?? false;
+    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
+    });
+    const betterAuthSecret = process.env.BETTER_AUTH_SECRET || process.env.NUXT_BETTER_AUTH_SECRET || nuxt.options.runtimeConfig.betterAuthSecret || "";
+    if (!nuxt.options.dev && !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.betterAuthSecret = betterAuthSecret;
+    nuxt.options.runtimeConfig.auth = defu(nuxt.options.runtimeConfig.auth, {
+      secondaryStorage: secondaryStorageEnabled
+    });
+    nuxt.options.alias["#nuxt-better-auth"] = resolver.resolve("./runtime/types/augment");
+    nuxt.options.alias["#auth/server"] = serverConfigPath;
+    nuxt.options.alias["#auth/client"] = clientConfigPath;
+    const secondaryStorageCode = secondaryStorageEnabled ? `import { kv } from '../hub/kv.mjs'
+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;
+    const hubDialect = getHubDialect(hub) ?? "sqlite";
+    const databaseCode = hasHubDb ? `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 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: () => `
+declare module '#auth/secondary-storage' {
+  interface SecondaryStorage {
+    get: (key: string) => Promise<string | null>
+    set: (key: string, value: unknown, ttl?: number) => Promise<void>
+    delete: (key: string) => Promise<void>
   }
-})
+  export function createSecondaryStorage(): SecondaryStorage | undefined
+}
+`
+    });
+    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
+}
+`
+    });
+    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")}'
+`
+    });
+    addTypeTemplate({
+      filename: "types/nuxt-better-auth-infer.d.ts",
+      getContents: () => `
+import type { InferUser, InferSession } from 'better-auth'
+import type { RuntimeConfig } from 'nuxt/schema'
+import type configFn from '${serverConfigPath}'
 
-/** @type {import("/home/maxi/nuxt/better-auth/src/module.js")} */
-const _module = await jiti.import("/home/maxi/nuxt/better-auth/src/module.ts");
+type _Config = ReturnType<typeof configFn>
+
+declare module '#nuxt-better-auth' {
+  interface AuthUser extends InferUser<_Config> {}
+  interface AuthSession { session: InferSession<_Config>['session'], user: InferUser<_Config> }
+  interface ServerAuthContext {
+    runtimeConfig: RuntimeConfig
+    ${hasHubDb ? `db: typeof import('hub:db')['db']` : ""}
+  }
+}
+`
+    });
+    addTypeTemplate({
+      filename: "types/nuxt-better-auth-client.d.ts",
+      getContents: () => `
+import type { createAppAuthClient } from '${clientConfigPath}'
+declare module '#nuxt-better-auth' {
+  export type AppAuthClient = ReturnType<typeof createAppAuthClient>
+}
+`
+    });
+    addTypeTemplate({
+      filename: "types/nuxt-better-auth-nitro.d.ts",
+      getContents: () => `
+declare module 'nitropack/types' {
+  interface NitroRouteRules {
+    auth?: import('${resolver.resolve("./runtime/types")}').AuthMeta
+  }
+}
+`
+    });
+    nuxt.hook("builder:watch", async (_event, relativePath) => {
+      if (relativePath.includes("auth.config")) {
+        await updateTemplates({ filter: (t) => t.filename.includes("nuxt-better-auth") });
+      }
+    });
+    addServerImportsDir(resolver.resolve("./runtime/server/utils"));
+    addServerScanDir(resolver.resolve("./runtime/server/middleware"));
+    addServerHandler({ route: "/api/auth/**", handler: resolver.resolve("./runtime/server/api/auth/[...all]") });
+    addImportsDir(resolver.resolve("./runtime/app/composables"));
+    addImportsDir(resolver.resolve("./runtime/utils"));
+    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);
+    }
+    const isProduction = process.env.NODE_ENV === "production" || !nuxt.options.dev;
+    if (!isProduction) {
+      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.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));
+    });
+  }
+});
+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 { getAuthTables } = await import('better-auth/db');
+    const tables = getAuthTables({
+      plugins,
+      secondaryStorage: options.secondaryStorage ? {
+        get: async (_key) => null,
+        set: async (_key, _value, _ttl) => {
+        },
+        delete: async (_key) => {
+        }
+      } : void 0
+    });
+    const useUuid = userConfig.advanced?.database?.generateId === "uuid";
+    const hubCasing = getHubCasing(hub);
+    const schemaOptions = { ...options.schema, useUuid, casing: options.schema?.casing ?? hubCasing };
+    const schemaCode = generateDrizzleSchema(tables, 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 with ${Object.keys(tables).length} tables`);
+  } 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);
+    }
+  });
+}
 
-export default _module?.default ?? _module;
-export const defineClientAuth = _module.defineClientAuth;
-export const defineServerAuth = _module.defineServerAuth;
+export { module$1 as default };