Options

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

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

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

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

export const auth = faireAuth({
	trustedOrigins: async (request: Request) => {
		// Return an array of trusted origins based on the request
		return ["https://dynamic-origin.com"];
	}
})

export const auth = faireAuth({
	trustedOrigins: [
		"*.example.com",             // Trust all subdomains of example.com
		"https://*.example.com",     // Trust only HTTPS subdomains
		"http://*.dev.example.com"   // Trust HTTP subdomains of dev.example.com
	]
})

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

openssl rand -base64 32

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

import { faireAuth } from "faire-auth";

export const auth = faireAuth({
	// ... other options
    secondaryStorage: {
    	// Your implementation here
    },
})

import { faireAuth } from "faire-auth";
export const auth = faireAuth({
	emailVerification: {
		sendVerificationEmail: async ({ user, url, token }) => {
			// Send verification email to user
		},
		sendOnSignUp: true,
		autoSignInAfterVerification: true,
		expiresIn: 3600 // 1 hour
	},
})

import { faireAuth } from "faire-auth";
export const auth = faireAuth({
	emailAndPassword: {
		enabled: true,
		disableSignUp: false,
		requireEmailVerification: true,
		minPasswordLength: 8,
		maxPasswordLength: 128,
		autoSignIn: true,
		sendResetPassword: async ({ user, url, token }) => {
			// Send reset password email
		},
		resetPasswordTokenExpiresIn: 3600, // 1 hour
		password: {
			hash: async (password) => {
				// Custom password hashing
				return hashedPassword;
			},
			verify: async ({ hash, password }) => {
				// Custom password verification
				return isValid;
			}
		}
	},
})

import { faireAuth } from "faire-auth";
export const auth = faireAuth({
	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 { faireAuth } from "faire-auth";
import { organization, twoFactor } from "faire-auth/plugins";

export const auth = faireAuth({
	plugins: [
		organization(),
		twoFactor(),
	],
})

import { faireAuth } from "faire-auth";
export const auth = faireAuth({
	user: {
		modelName: "users",
		fields: {
			email: "emailAddress",
			name: "fullName"
		},
		additionalFields: {
			customField: {
				type: "string",
			}
		},
		changeEmail: {
			enabled: true,
			sendChangeEmailVerification: async ({ user, newEmail, url, token }) => {
				// Send change email verification
			}
		},
		deleteUser: {
			enabled: true,
			sendDeleteAccountVerification: async ({ user, url, token }) => {
				// Send delete account verification
			},
			beforeDelete: async (user) => {
				// Perform actions before user deletion
			},
			afterDelete: async (user) => {
				// Perform cleanup after user deletion
			}
		}
	},
})

import { faireAuth } from "faire-auth";
export const auth = faireAuth({
	session: {
		modelName: "sessions",
		fields: {
			userId: "user_id"
		},
		expiresIn: 604800, // 7 days
		updateAge: 86400, // 1 day
		disableSessionRefresh: true, // Disable session refresh so that the session is not updated regardless of the `updateAge` option. (default: `false`)
		additionalFields: { // Additional fields for the session table
			customField: {
				type: "string",
			}
		},
		storeSessionInDatabase: true, // Store session in database when secondary storage is provided (default: `false`)
		preserveSessionInDatabase: false, // Preserve session records in database when deleted from secondary storage (default: `false`)
		cookieCache: {
			enabled: true, // Enable caching session in cookie (default: `false`)
			maxAge: 300, // 5 minutes
			strategy: "compact", // "compact" | "jwt" | "jwe" (default: "compact")
			refreshCache: true, // Auto-refresh before expiry without DB query (default: false)
			version: "1", // Bump to invalidate all existing caches
		},
		freshAge: 86400, // 1 day — how fresh a session must be for sensitive operations
	},
})

import { faireAuth } from "faire-auth";
export const auth = faireAuth({
	account: {
		modelName: "accounts",
		fields: {
			userId: "user_id"
		},
		encryptOAuthTokens: true, // Encrypt OAuth tokens before storing them in the database
		accountLinking: {
			enabled: true,
			trustedProviders: ["google", "github", "email-password"],
			allowDifferentEmails: false
		}
	},
})

import { faireAuth } from "faire-auth";
export const auth = faireAuth({
	verification: {
		modelName: "verifications",
		fields: {
			userId: "user_id"
		},
		disableCleanup: false
	},
})

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

import { faireAuth } from "faire-auth";
export const auth = faireAuth({
	advanced: {
		ipAddress: {
			ipAddressHeaders: ["x-client-ip", "x-forwarded-for"],
			disableIpTracking: false
		},
		useSecureCookies: true,
		disableCSRFCheck: 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
		},
		cookiePrefix: "myapp",
		database: {
			// If your DB is using auto-incrementing IDs, set this to true.
			useNumberId: false,
			// Use your own custom ID generator, or disable generating IDs as a whole.
			generateId: (((options: {
				model: LiteralUnion<Models, string>;
				size?: number;
			}) => {
				return "my-super-unique-id";
			})) | false,
			defaultFindManyLimit: 100,
		}
	},
})

import { faireAuth } from "faire-auth";
export const auth = faireAuth({
	logger: {
		disabled: false,
		disableColors: false,
		level: "error",
		log: (level, message, ...args) => {
			// Custom logging implementation
			console.log(`[${level}] ${message}`, ...args);
		}
	}
})

import { faireAuth } from "faire-auth";
export const auth = faireAuth({
	logger: {
		level: "info",
		log: (level, message, ...args) => {
			// Send logs to a custom logging service
			myLoggingService.log({
				level,
				message,
				metadata: args,
				timestamp: new Date().toISOString()
			});
		}
	}
})

import { faireAuth } from "faire-auth";
export const auth = faireAuth({
	databaseHooks: {
		user: {
			create: {
				before: async (user, ctx) => {
					// Modify user data before creation
					// ctx is the Hono Context (optional)
					return { data: { ...user, customField: "value" } };
				},
				after: async (user, ctx) => {
					// Perform actions after user creation
				}
			},
			update: {
				before: async (userData, ctx) => {
					// Modify user data before update
					// Return false to prevent the update
					return { data: { ...userData, updatedAt: new Date() } };
				},
				after: async (user, ctx) => {
					// Perform actions after user update
				}
			},
			delete: {
				before: async (user, ctx) => {
					// Return false to prevent deletion
				},
				after: async (user, ctx) => {
					// Cleanup after user deletion
				}
			}
		},
		session: {
			// Same create/update/delete hooks as user
		},
		account: {
			// Same create/update/delete hooks as user
		},
		verification: {
			// Same create/update/delete hooks as user
		}
	},
})

import { faireAuth } from "faire-auth";
export const auth = faireAuth({
	onAPIError: {
		throw: true,
		onError: (error, ctx) => {
			// Custom error handling
			console.error("Auth error:", error);
		},
		errorURL: "/auth/error"
	},
})

import { faireAuth } from "faire-auth";
import { createHook } from "faire-auth/plugins";

export const auth = faireAuth({
	hooks: {
		before: (options) => createHook()(async (ctx) => {
			// Execute before processing the request
			console.log("Request path:", ctx.req.path);
		}),
		after: (options) => createHook()(async (ctx) => {
			// Execute after processing the request
		})
	},
})

import { faireAuth, defineOptions } from "faire-auth";
import { createMiddleware } from "faire-auth/plugins";

const cfg = defineOptions({
	baseURL: "http://localhost:3000",
	middleware: {
		getSession: createMiddleware()(async (ctx, next) => {
			console.log("getSession called");
			await next();
		}),
	},
})

import { defineOptions } from "faire-auth";

const cfg = defineOptions({
	baseURL: "http://localhost:3000",
	routeHooks: {
		signUpEmail: (result, ctx) => {
			if (!result.success) return;
			const { email } = result.data.json;
			if (!email.endsWith("@company.com")) {
				return ctx.json({ error: "Only company emails" }, 403);
			}
		},
	},
})

import { defineOptions } from "faire-auth";

const cfg = defineOptions({
	baseURL: "http://localhost:3000",
	dto: {
		user: (user) => ({
			id: user.id,
			name: user.name,
			email: user.email,
		}),
	},
})

import { faireAuth, defineOptions } from "faire-auth";

const cfg = defineOptions({
	baseURL: "http://localhost:3000",
	hono: {
		init: {
			// Hono constructor options (e.g. custom getPath, strict mode)
		},
		openapi: {
			enabled: true,
			path: "/openapi.json",
			version: "3.1",
			config: {
				openapi: "3.1.1",
				info: {
					title: "My Auth API",
					version: "1.0.0",
				},
			},
		},
	},
})

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

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