选项

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	appName: "My App",
})

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	baseURL: "https://example.com",
})

import { betterAuth } from "better-auth";

export const auth = betterAuth({
	baseURL: {
		allowedHosts: [
			"myapp.com",
			"www.myapp.com",
			"*.vercel.app",
		],
		protocol: "https",
		fallback: "https://myapp.com",
	},
})

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	basePath: "/api/auth",
})

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	trustedOrigins: ["http://localhost:3000", "https://example.com"],
})

export const auth = betterAuth({
	trustedOrigins: async (request) => {
		// 初始化和调用 auth.api 时 request 为 undefined
		if (!request) {
			return ["https://my-frontend.com"];
		}
		// 根据请求动态逻辑
		return ["https://dynamic-origin.com"];
	}
})

export const auth = betterAuth({
	trustedOrigins: [
		"https://*.example.com", // 信任 example.com 的所有 HTTPS 子域
		"http://*.dev.example.com" // 信任 dev.example.com 的所有 HTTP 子域
	]
})

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	secret: "your-secret-key",
})

openssl rand -base64 32

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	secrets: [
		{ version: 2, value: "new-secret-key" },
		{ version: 1, value: "old-secret-key" },
	],
})

BETTER_AUTH_SECRETS=2:new-secret-base64,1:old-secret-base64

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	database: {
		dialect: "postgres",
		type: "postgres",
		casing: "camel"
	},
})

import { betterAuth } from "better-auth";

export const auth = betterAuth({
	// ... 其他选项
    secondaryStorage: {
    	// 你的实现
    },
})

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	emailVerification: {
		sendVerificationEmail: async ({ user, url, token }) => {
			// 向用户发送验证邮件
		},
		sendOnSignUp: true,
		autoSignInAfterVerification: true,
		expiresIn: 3600 // 1 小时
	},
})

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	emailAndPassword: {
		enabled: true,
		disableSignUp: false,
		requireEmailVerification: true,
		minPasswordLength: 8,
		maxPasswordLength: 128,
		autoSignIn: true,
		sendResetPassword: async ({ user, url, token }) => {
			// 发送重置密码邮件
		},
		resetPasswordTokenExpiresIn: 3600, // 1 小时
		password: {
			hash: async (password) => {
				// 自定义密码哈希
				return hashedPassword;
			},
			verify: async ({ hash, password }) => {
				// 自定义密码验证
				return isValid;
			}
		},
	},
})

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	socialProviders: {
		google: {
			clientId: "your-client-id",
			clientSecret: "your-client-secret",
			redirectURI: "https://example.com/api/auth/callback/google"
		},
		github: {
			clientId: "your-client-id",
			clientSecret: "your-client-secret",
			redirectURI: "https://example.com/api/auth/callback/github"
		}
	},
})

import { betterAuth } from "better-auth";
import { emailOTP } from "better-auth/plugins";

export const auth = betterAuth({
	plugins: [
		emailOTP({
			sendVerificationOTP: async ({ email, otp, type }) => {
				// 向用户邮箱发送 OTP
			}
		})
	],
})

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	user: {
		modelName: "users",
		fields: {
			email: "emailAddress",
			name: "fullName"
		},
		additionalFields: {
			customField: {
				type: "string",
			}
		},
		changeEmail: {
			enabled: true,
			sendChangeEmailConfirmation: async ({ user, newEmail, url, token }) => {
				// 向旧邮箱发送变更确认邮件
			},
			updateEmailWithoutVerification: false // 用户未验证时是否直接更新邮箱
		},
		deleteUser: {
			enabled: true,
			sendDeleteAccountVerification: async ({ user, url, token }) => {
				// 发送删除账号验证邮件
			},
			beforeDelete: async (user) => {
				// 删除用户前执行操作
			},
			afterDelete: async (user) => {
				// 删除用户后清理工作
			}
		}
	},
})

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	session: {
		modelName: "sessions",
		fields: {
			userId: "user_id"
		},
		expiresIn: 604800, // 7 天
		updateAge: 86400, // 1 天
		disableSessionRefresh: true, // 禁用会话刷新，不根据 `updateAge` 更新会话（默认：`false`）
		additionalFields: { // 会话表额外字段
			customField: {
				type: "string",
			}
		},
		storeSessionInDatabase: true, // 提供二级存储时存数据库（默认：`false`）
		preserveSessionInDatabase: false, // 在二级存储删除后保留数据库中会话记录（默认：`false`）
		cookieCache: {
			enabled: true, // 启用 cookie 缓存会话（默认：`false`）
			maxAge: 300 // 5 分钟
		}
	},
})

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	account: {
		modelName: "accounts",
		fields: {
			userId: "user_id"
		},
		encryptOAuthTokens: true, // 在存入数据库前加密 OAuth 令牌
		storeStateStrategy: "database", // 将 OAuth 状态负载存储在验证存储中
		storeAccountCookie: true, // 在 OAuth 流程后将账号数据存入 cookie（适用于无数据库流程）
		accountLinking: {
			enabled: true,
			trustedProviders: ["google", "github", "email-password"], // 或异步函数 (request) => ["google", "github"]
			allowDifferentEmails: false
		},
	},
})

import { createAuthMiddleware } from "better-auth/api";
import { getAccountCookie } from "better-auth/cookies";

const hook = createAuthMiddleware(async (ctx) => {
	const account = await getAccountCookie(ctx);
});

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	secondaryStorage: {
		// 你的 Redis 或 KV 实现
	},
	verification: {
		disableCleanup: false,
		storeIdentifier: "hashed",
		storeInDatabase: false
	},
})

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	rateLimit: {
		enabled: true,
		window: 10,
		max: 100,
		customRules: {
			"/example/path": {
				window: 10,
				max: 100
			}
		},
		storage: "memory",
		modelName: "rateLimit"
	}
})

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	advanced: {
		ipAddress: {
			ipAddressHeaders: ["x-client-ip", "x-forwarded-for"],
			disableIpTracking: false
		},
		useSecureCookies: true,
		disableCSRFCheck: false,
		disableOriginCheck: false,
		crossSubDomainCookies: {
			enabled: true,
			additionalCookies: ["custom_cookie"],
			domain: "example.com"
		},
		cookies: {
			session_token: {
				name: "custom_session_token",
				attributes: {
					httpOnly: true,
					secure: true
				}
			}
		},
		defaultCookieAttributes: {
			httpOnly: true,
			secure: true
		},
		// OAuth 状态配置已移至 account 选项
		// 使用 account.storeStateStrategy 和 account.skipStateCookieCheck
		cookiePrefix: "myapp",
		database: {
			// 自定义 ID 生成器，
			// 禁用生成 ID，让数据库自动生成，
			// 或使用 "serial" 使用数据库自增 ID，或 "uuid" 使用随机 UUID。
			generateId: (((options: {
				model: LiteralUnion<Models, string>;
				size?: number;
			}) => {
				return "my-super-unique-id";
			})) | false | "serial" | "uuid",
			defaultFindManyLimit: 100,
			experimentalJoins: false,
		},
		backgroundTasks: {
			handler: (promise) => { /* 如 waitUntil(promise) */ }
		},
		skipTrailingSlashes: true
	},
})

import { betterAuth } from "better-auth";

export const auth = betterAuth({
	advanced: {
		database: {
			generateId: "uuid",
			defaultFindManyLimit: 50,
		},
	},
});

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	logger: {
		disabled: false,
		disableColors: false,
		level: "warn",
		log: (level, message, ...args) => {
			// 自定义日志实现
			console.log(`[${level}] ${message}`, ...args);
		}
	}
})

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	logger: {
		level: "info",
		log: (level, message, ...args) => {
			// 将日志发送到自定义日志服务
			myLoggingService.log({
				level,
				message,
				metadata: args,
				timestamp: new Date().toISOString()
			});
		}
	}
})

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	databaseHooks: {
		user: {
			create: {
				before: async (user) => {
					// 创建用户前修改数据
					return { data: { ...user, customField: "value" } };
				},
				after: async (user) => {
					// 创建用户后执行操作
				}
			},
			update: {
				before: async (userData) => {
					// 更新用户前修改数据
					return { data: { ...userData, updatedAt: new Date() } };
				},
				after: async (user) => {
					// 更新用户后执行操作
				}
			}
		},
		session: {
			// 会话钩子
		},
		account: {
			// 账号钩子
		},
		verification: {
			// 验证钩子
		}
	},
})

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	onAPIError: {
		throw: true,
		onError: (error, ctx) => {
			// 自定义错误处理
			console.error("Auth error:", error);
		},
		errorURL: "/auth/error",
		customizeDefaultErrorPage: {
			colors: {
				background: "#ffffff",
				foreground: "#000000",
				primary: "#0070f3",
				primaryForeground: "#ffffff",
				mutedForeground: "#666666",
				border: "#e0e0e0",
				destructive: "#ef4444",
				titleBorder: "#0070f3",
				titleColor: "#000000",
				gridColor: "#f0f0f0",
				cardBackground: "#ffffff",
				cornerBorder: "#0070f3"
			},
			size: {
				radiusSm: "0.25rem",
				radiusMd: "0.5rem",
				radiusLg: "1rem",
				textSm: "0.875rem",
				text2xl: "1.5rem",
				text4xl: "2.25rem",
				text6xl: "3.75rem"
			},
			font: {
				defaultFamily: "system-ui, sans-serif",
				monoFamily: "monospace"
			},
			disableTitleBorder: false,
			disableCornerDecorations: false,
			disableBackgroundGrid: false
		}
	},
})

import { betterAuth } from "better-auth";
import { createAuthMiddleware } from "better-auth/api";

export const auth = betterAuth({
	hooks: {
		before: createAuthMiddleware(async (ctx) => {
			// 请求处理前执行
			console.log("Request path:", ctx.path);
		}),
		after: createAuthMiddleware(async (ctx) => {
			// 请求处理后执行
			console.log("Response:", ctx.context.returned);
		})
	},
})

import { betterAuth } from "better-auth";
export const auth = betterAuth({
	disabledPaths: ["/sign-up/email", "/sign-in/email"],
})

import { betterAuth } from "better-auth";
export const auth = betterAuth({
  telemetry: {
    enabled: false,
  }
})