@depup/better-auth__core 1.6.23-depup.2

package/src/db/adapter/types.ts

@@ -0,0 +1,134 @@
+import type { BetterAuthOptions } from "../../types";
+import type { BetterAuthDBSchema, DBFieldAttribute } from "../type";
+import type {
+	CleanedWhere,
+	CustomAdapter,
+	DBAdapterFactoryConfig,
+	JoinConfig,
+	DBTransactionAdapter as TransactionAdapter,
+	Where,
+} from "./index";
+
+export type AdapterFactoryOptions = {
+	config: AdapterFactoryConfig;
+	adapter: AdapterFactoryCustomizeAdapterCreator;
+};
+
+export interface AdapterFactoryConfig
+	extends Omit<DBAdapterFactoryConfig<BetterAuthOptions>, "transaction"> {
+	/**
+	 * Execute multiple operations in a transaction.
+	 *
+	 * If the database doesn't support transactions, set this to `false` and operations will be executed sequentially.
+	 *
+	 * @default false
+	 */
+	transaction?:
+		| (
+				| false
+				| (<R>(callback: (trx: TransactionAdapter) => Promise<R>) => Promise<R>)
+		  )
+		| undefined;
+}
+
+export type AdapterFactoryCustomizeAdapterCreator = (config: {
+	options: BetterAuthOptions;
+	/**
+	 * The schema of the user's Better-Auth instance.
+	 */
+	schema: BetterAuthDBSchema;
+	/**
+	 * The debug log function.
+	 *
+	 * If the config has defined `debugLogs` as `false`, no logs will be shown.
+	 */
+	debugLog: (...args: unknown[]) => void;
+	/**
+	 * Get the model name which is expected to be saved in the database based on the user's schema.
+	 */
+	getModelName: (model: string) => string;
+	/**
+	 * Get the field name which is expected to be saved in the database based on the user's schema.
+	 */
+	getFieldName: ({ model, field }: { model: string; field: string }) => string;
+	/**
+	 * This function helps us get the default model name from the schema defined by devs.
+	 * Often times, the user will be using the `modelName` which could had been customized by the users.
+	 * This function helps us get the actual model name useful to match against the schema. (eg: schema[model])
+	 *
+	 * If it's still unclear what this does:
+	 *
+	 * 1. User can define a custom modelName.
+	 * 2. When using a custom modelName, doing something like `schema[model]` will not work.
+	 * 3. Using this function helps us get the actual model name based on the user's defined custom modelName.
+	 * 4. Thus allowing us to use `schema[model]`.
+	 */
+	getDefaultModelName: (model: string) => string;
+	/**
+	 * This function helps us get the default field name from the schema defined by devs.
+	 * Often times, the user will be using the `fieldName` which could had been customized by the users.
+	 * This function helps us get the actual field name useful to match against the schema. (eg: schema[model].fields[field])
+	 *
+	 * If it's still unclear what this does:
+	 *
+	 * 1. User can define a custom fieldName.
+	 * 2. When using a custom fieldName, doing something like `schema[model].fields[field]` will not work.
+	 *
+	 */
+	getDefaultFieldName: ({
+		model,
+		field,
+	}: {
+		model: string;
+		field: string;
+	}) => string;
+	/**
+	 * Get the field attributes for a given model and field.
+	 *
+	 * Note: any model name or field name is allowed, whether default to schema or not.
+	 */
+	getFieldAttributes: ({
+		model,
+		field,
+	}: {
+		model: string;
+		field: string;
+	}) => DBFieldAttribute;
+	// The following functions are exposed primarily for the purpose of having wrapper adapters.
+	transformInput: (
+		data: Record<string, unknown>,
+		defaultModelName: string,
+		action: "create" | "update",
+		forceAllowId?: boolean | undefined,
+	) => Promise<Record<string, unknown>>;
+	transformOutput: (
+		data: Record<string, unknown>,
+		defaultModelName: string,
+		select?: string[] | undefined,
+		joinConfig?: JoinConfig | undefined,
+	) => Promise<Record<string, unknown>>;
+	transformWhereClause: <W extends Where[] | undefined>({
+		model,
+		where,
+		action,
+	}: {
+		where: W;
+		model: string;
+		action:
+			| "create"
+			| "update"
+			| "findOne"
+			| "findMany"
+			| "updateMany"
+			| "delete"
+			| "deleteMany"
+			| "consumeOne"
+			| "incrementOne"
+			| "count";
+	}) => W extends undefined ? undefined : CleanedWhere[];
+}) => CustomAdapter;
+
+export type AdapterTestDebugLogs = {
+	resetDebugLogs: () => void;
+	printDebugLogs: () => void;
+};

package/src/db/adapter/utils.ts

@@ -0,0 +1,61 @@
+import type { DBFieldAttribute } from "../type";
+
+export function withApplyDefault(
+	value: any,
+	field: DBFieldAttribute,
+	action: "create" | "update" | "findOne" | "findMany",
+) {
+	if (action === "update") {
+		// Apply onUpdate if value is undefined
+		if (value === undefined && field.onUpdate !== undefined) {
+			if (typeof field.onUpdate === "function") {
+				return field.onUpdate();
+			}
+			return field.onUpdate;
+		}
+		return value;
+	}
+	if (action === "create") {
+		// we do not want to apply default values if the value is null & not required
+		if (value === undefined || (field.required === true && value === null)) {
+			if (field.defaultValue !== undefined) {
+				if (typeof field.defaultValue === "function") {
+					return field.defaultValue();
+				}
+				return field.defaultValue;
+			}
+		}
+	}
+	return value;
+}
+
+function isObject(item: unknown): item is Record<string, unknown> {
+	return item !== null && typeof item === "object" && !Array.isArray(item);
+}
+
+export function deepmerge<T>(target: T, source: Partial<T>): T {
+	if (Array.isArray(target) && Array.isArray(source)) {
+		// merge arrays by concatenation
+		return [...target, ...source] as T;
+	} else if (isObject(target) && isObject(source)) {
+		const result: Record<string, unknown> = { ...target };
+
+		for (const [key, value] of Object.entries(source)) {
+			if (value === undefined) continue; // skip undefined
+
+			if (key in target) {
+				result[key] = deepmerge(
+					(target as Record<string, unknown>)[key],
+					value as unknown as Partial<T>,
+				);
+			} else {
+				result[key] = value;
+			}
+		}
+
+		return result as T;
+	}
+
+	// primitives and fallback: source overrides target
+	return source as T;
+}

package/src/db/get-tables.ts

@@ -0,0 +1,304 @@
+import type { BetterAuthOptions } from "../types";
+import type { BetterAuthDBSchema, DBFieldAttribute } from "./type";
+
+export const getAuthTables = (
+	options: BetterAuthOptions,
+): BetterAuthDBSchema => {
+	const pluginSchema = (options.plugins ?? []).reduce(
+		(acc, plugin) => {
+			const schema = plugin.schema;
+			if (!schema) return acc;
+			for (const [key, value] of Object.entries(schema)) {
+				acc[key] = {
+					fields: {
+						...acc[key]?.fields,
+						...value.fields,
+					},
+					modelName: value.modelName || key,
+					disableMigrations:
+						value.disableMigration ?? acc[key]?.disableMigrations,
+				};
+			}
+			return acc;
+		},
+		{} as Record<
+			string,
+			{
+				fields: Record<string, DBFieldAttribute>;
+				modelName: string;
+				disableMigrations?: boolean | undefined;
+			}
+		>,
+	);
+
+	const shouldAddRateLimitTable = options.rateLimit?.storage === "database";
+	const rateLimitTable = {
+		rateLimit: {
+			modelName: options.rateLimit?.modelName || "rateLimit",
+			fields: {
+				key: {
+					type: "string",
+					unique: true,
+					required: true,
+					fieldName: options.rateLimit?.fields?.key || "key",
+				},
+				count: {
+					type: "number",
+					required: true,
+					fieldName: options.rateLimit?.fields?.count || "count",
+				},
+				lastRequest: {
+					type: "number",
+					bigint: true,
+					required: true,
+					fieldName: options.rateLimit?.fields?.lastRequest || "lastRequest",
+					defaultValue: () => Date.now(),
+				},
+			},
+		},
+	} satisfies BetterAuthDBSchema;
+
+	const { user, session, account, verification, ...pluginTables } =
+		pluginSchema;
+
+	const verificationTable = {
+		verification: {
+			modelName: options.verification?.modelName || "verification",
+			fields: {
+				identifier: {
+					type: "string",
+					required: true,
+					fieldName: options.verification?.fields?.identifier || "identifier",
+					index: true,
+				},
+				value: {
+					type: "string",
+					required: true,
+					fieldName: options.verification?.fields?.value || "value",
+				},
+				expiresAt: {
+					type: "date",
+					required: true,
+					fieldName: options.verification?.fields?.expiresAt || "expiresAt",
+				},
+				createdAt: {
+					type: "date",
+					required: true,
+					defaultValue: () => new Date(),
+					fieldName: options.verification?.fields?.createdAt || "createdAt",
+				},
+				updatedAt: {
+					type: "date",
+					required: true,
+					defaultValue: () => new Date(),
+					onUpdate: () => new Date(),
+					fieldName: options.verification?.fields?.updatedAt || "updatedAt",
+				},
+				...verification?.fields,
+				...options.verification?.additionalFields,
+			},
+			order: 4,
+		},
+	} satisfies BetterAuthDBSchema;
+
+	const sessionTable = {
+		session: {
+			modelName: options.session?.modelName || "session",
+			fields: {
+				expiresAt: {
+					type: "date",
+					required: true,
+					fieldName: options.session?.fields?.expiresAt || "expiresAt",
+				},
+				token: {
+					type: "string",
+					required: true,
+					fieldName: options.session?.fields?.token || "token",
+					unique: true,
+				},
+				createdAt: {
+					type: "date",
+					required: true,
+					fieldName: options.session?.fields?.createdAt || "createdAt",
+					defaultValue: () => new Date(),
+				},
+				updatedAt: {
+					type: "date",
+					required: true,
+					fieldName: options.session?.fields?.updatedAt || "updatedAt",
+					onUpdate: () => new Date(),
+				},
+				ipAddress: {
+					type: "string",
+					required: false,
+					fieldName: options.session?.fields?.ipAddress || "ipAddress",
+				},
+				userAgent: {
+					type: "string",
+					required: false,
+					fieldName: options.session?.fields?.userAgent || "userAgent",
+				},
+				userId: {
+					type: "string",
+					fieldName: options.session?.fields?.userId || "userId",
+					references: {
+						model: options.user?.modelName || "user",
+						field: "id",
+						onDelete: "cascade",
+					},
+					required: true,
+					index: true,
+				},
+				...session?.fields,
+				...options.session?.additionalFields,
+			},
+			order: 2,
+		},
+	} satisfies BetterAuthDBSchema;
+
+	return {
+		user: {
+			modelName: options.user?.modelName || "user",
+			fields: {
+				name: {
+					type: "string",
+					required: true,
+					fieldName: options.user?.fields?.name || "name",
+					sortable: true,
+				},
+				email: {
+					type: "string",
+					// TODO(#9124): drop required+unique in v2; use a partial unique
+					// index where email is not null (see schema/user.ts).
+					unique: true,
+					required: true,
+					fieldName: options.user?.fields?.email || "email",
+					sortable: true,
+				},
+				emailVerified: {
+					type: "boolean",
+					defaultValue: false,
+					required: true,
+					fieldName: options.user?.fields?.emailVerified || "emailVerified",
+					input: false,
+				},
+				image: {
+					type: "string",
+					required: false,
+					fieldName: options.user?.fields?.image || "image",
+				},
+				createdAt: {
+					type: "date",
+					defaultValue: () => new Date(),
+					required: true,
+					fieldName: options.user?.fields?.createdAt || "createdAt",
+				},
+				updatedAt: {
+					type: "date",
+					defaultValue: () => new Date(),
+					onUpdate: () => new Date(),
+					required: true,
+					fieldName: options.user?.fields?.updatedAt || "updatedAt",
+				},
+				...user?.fields,
+				...options.user?.additionalFields,
+			},
+			order: 1,
+		},
+		//only add session table if it's not stored in secondary storage
+		...(!options.secondaryStorage || options.session?.storeSessionInDatabase
+			? sessionTable
+			: {}),
+		account: {
+			modelName: options.account?.modelName || "account",
+			fields: {
+				accountId: {
+					type: "string",
+					required: true,
+					fieldName: options.account?.fields?.accountId || "accountId",
+				},
+				providerId: {
+					type: "string",
+					required: true,
+					fieldName: options.account?.fields?.providerId || "providerId",
+				},
+				userId: {
+					type: "string",
+					references: {
+						model: options.user?.modelName || "user",
+						field: "id",
+						onDelete: "cascade",
+					},
+					required: true,
+					fieldName: options.account?.fields?.userId || "userId",
+					index: true,
+				},
+				accessToken: {
+					type: "string",
+					required: false,
+					returned: false,
+					fieldName: options.account?.fields?.accessToken || "accessToken",
+				},
+				refreshToken: {
+					type: "string",
+					required: false,
+					returned: false,
+					fieldName: options.account?.fields?.refreshToken || "refreshToken",
+				},
+				idToken: {
+					type: "string",
+					required: false,
+					returned: false,
+					fieldName: options.account?.fields?.idToken || "idToken",
+				},
+				accessTokenExpiresAt: {
+					type: "date",
+					required: false,
+					returned: false,
+					fieldName:
+						options.account?.fields?.accessTokenExpiresAt ||
+						"accessTokenExpiresAt",
+				},
+				refreshTokenExpiresAt: {
+					type: "date",
+					required: false,
+					returned: false,
+					fieldName:
+						options.account?.fields?.refreshTokenExpiresAt ||
+						"refreshTokenExpiresAt",
+				},
+				scope: {
+					type: "string",
+					required: false,
+					fieldName: options.account?.fields?.scope || "scope",
+				},
+				password: {
+					type: "string",
+					required: false,
+					returned: false,
+					fieldName: options.account?.fields?.password || "password",
+				},
+				createdAt: {
+					type: "date",
+					required: true,
+					fieldName: options.account?.fields?.createdAt || "createdAt",
+					defaultValue: () => new Date(),
+				},
+				updatedAt: {
+					type: "date",
+					required: true,
+					fieldName: options.account?.fields?.updatedAt || "updatedAt",
+					onUpdate: () => new Date(),
+				},
+				...account?.fields,
+				...options.account?.additionalFields,
+			},
+			order: 3,
+		},
+		...(!options.secondaryStorage || options.verification?.storeInDatabase
+			? verificationTable
+			: {}),
+		...pluginTables,
+		...(shouldAddRateLimitTable ? rateLimitTable : {}),
+	} satisfies BetterAuthDBSchema;
+};

package/src/db/index.ts

@@ -0,0 +1,43 @@
+export { getAuthTables } from "./get-tables";
+export type { BetterAuthPluginDBSchema } from "./plugin";
+export {
+	type Account,
+	accountSchema,
+	type BaseAccount,
+} from "./schema/account";
+export {
+	type BaseRateLimit,
+	type RateLimit,
+	rateLimitSchema,
+} from "./schema/rate-limit";
+export {
+	type BaseSession,
+	type Session,
+	sessionSchema,
+} from "./schema/session";
+export { coreSchema } from "./schema/shared";
+export { type BaseUser, type User, userSchema } from "./schema/user";
+export {
+	type BaseVerification,
+	type Verification,
+	verificationSchema,
+} from "./schema/verification";
+export type {
+	BaseModelNames,
+	BetterAuthDBSchema,
+	DBFieldAttribute,
+	DBFieldAttributeConfig,
+	DBFieldType,
+	DBPrimitive,
+	InferDBFieldInput,
+	InferDBFieldOutput,
+	InferDBFieldsFromOptions,
+	InferDBFieldsFromOptionsInput,
+	InferDBFieldsFromPlugins,
+	InferDBFieldsFromPluginsInput,
+	InferDBFieldsInput,
+	InferDBFieldsOutput,
+	InferDBValueType,
+	ModelNames,
+	SecondaryStorage,
+} from "./type";

package/src/db/plugin.ts

@@ -0,0 +1,11 @@
+import type { DBFieldAttribute } from "./type";
+
+export type BetterAuthPluginDBSchema = {
+	[table in string]: {
+		fields: {
+			[field: string]: DBFieldAttribute;
+		};
+		disableMigration?: boolean | undefined;
+		modelName?: string | undefined;
+	};
+};

package/src/db/schema/account.ts

@@ -0,0 +1,47 @@
+import * as z from "zod";
+import type { Prettify } from "../../types";
+import type { BetterAuthOptions } from "../../types/init-options";
+import type {
+	InferDBFieldsFromOptions,
+	InferDBFieldsFromPlugins,
+} from "../type";
+import { coreSchema } from "./shared";
+
+export const accountSchema = coreSchema.extend({
+	providerId: z.string(),
+	accountId: z.string(),
+	userId: z.coerce.string(),
+	accessToken: z.string().nullish(),
+	refreshToken: z.string().nullish(),
+	idToken: z.string().nullish(),
+	/**
+	 * Access token expires at
+	 */
+	accessTokenExpiresAt: z.date().nullish(),
+	/**
+	 * Refresh token expires at
+	 */
+	refreshTokenExpiresAt: z.date().nullish(),
+	/**
+	 * The scopes that the user has authorized
+	 */
+	scope: z.string().nullish(),
+	/**
+	 * Password is only stored in the credential provider
+	 */
+	password: z.string().nullish(),
+});
+
+export type BaseAccount = z.infer<typeof accountSchema>;
+
+/**
+ * Account schema type used by better-auth, note that it's possible that account could have additional fields
+ */
+export type Account<
+	DBOptions extends BetterAuthOptions["account"] = BetterAuthOptions["account"],
+	Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"],
+> = Prettify<
+	BaseAccount &
+		InferDBFieldsFromOptions<DBOptions> &
+		InferDBFieldsFromPlugins<"account", Plugins>
+>;

package/src/db/schema/rate-limit.ts

@@ -0,0 +1,36 @@
+import * as z from "zod";
+import type { BetterAuthOptions, Prettify } from "../../types";
+import type {
+	InferDBFieldsFromOptions,
+	InferDBFieldsFromPlugins,
+} from "../type";
+
+export const rateLimitSchema = z.object({
+	/**
+	 * The key to use for rate limiting
+	 */
+	key: z.string(),
+	/**
+	 * The number of requests made
+	 */
+	count: z.number(),
+	/**
+	 * The last request time in milliseconds
+	 */
+	lastRequest: z.number(),
+});
+
+export type BaseRateLimit = z.infer<typeof rateLimitSchema>;
+
+/**
+ * Rate limit schema type used by better-auth for rate limiting
+ */
+export type RateLimit<
+	DBOptions extends
+		BetterAuthOptions["rateLimit"] = BetterAuthOptions["rateLimit"],
+	Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"],
+> = Prettify<
+	BaseRateLimit &
+		InferDBFieldsFromOptions<DBOptions> &
+		InferDBFieldsFromPlugins<"rateLimit", Plugins>
+>;

package/src/db/schema/session.ts

@@ -0,0 +1,29 @@
+import * as z from "zod";
+import type { BetterAuthOptions, Prettify } from "../../types";
+import type {
+	InferDBFieldsFromOptions,
+	InferDBFieldsFromPlugins,
+} from "../type";
+import { coreSchema } from "./shared";
+
+export const sessionSchema = coreSchema.extend({
+	userId: z.coerce.string(),
+	expiresAt: z.date(),
+	token: z.string(),
+	ipAddress: z.string().nullish(),
+	userAgent: z.string().nullish(),
+});
+
+export type BaseSession = z.infer<typeof sessionSchema>;
+
+/**
+ * Session schema type used by better-auth, note that it's possible that session could have additional fields
+ */
+export type Session<
+	DBOptions extends BetterAuthOptions["session"] = BetterAuthOptions["session"],
+	Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"],
+> = Prettify<
+	z.infer<typeof sessionSchema> &
+		InferDBFieldsFromOptions<DBOptions> &
+		InferDBFieldsFromPlugins<"session", Plugins>
+>;

package/src/db/schema/shared.ts

@@ -0,0 +1,7 @@
+import * as z from "zod";
+
+export const coreSchema = z.object({
+	id: z.string(),
+	createdAt: z.date().default(() => new Date()),
+	updatedAt: z.date().default(() => new Date()),
+});