@better-auth/core 1.5.0-beta.8 → 1.5.0

package/src/db/adapter/factory.ts

@@ -38,20 +38,20 @@ let debugLogs: { instance: string; args: any[] }[] = [];
 let transactionId = -1;
 
 const createAsIsTransaction =
-	(adapter: DBAdapter<BetterAuthOptions>) =>
-	<R>(fn: (trx: DBTransactionAdapter<BetterAuthOptions>) => Promise<R>) =>
+	<Options extends BetterAuthOptions>(adapter: DBAdapter<Options>) =>
+	<R>(fn: (trx: DBTransactionAdapter<Options>) => Promise<R>) =>
 		fn(adapter);
 
-export type AdapterFactory = (
-	options: BetterAuthOptions,
-) => DBAdapter<BetterAuthOptions>;
+export type AdapterFactory<Options extends BetterAuthOptions> = (
+	options: Options,
+) => DBAdapter<Options>;
 
 export const createAdapterFactory =
-	({
+	<Options extends BetterAuthOptions>({
 		adapter: customAdapter,
 		config: cfg,
-	}: AdapterFactoryOptions): AdapterFactory =>
-	(options: BetterAuthOptions): DBAdapter<BetterAuthOptions> => {
+	}: AdapterFactoryOptions): AdapterFactory<Options> =>
+	(options: Options): DBAdapter<Options> => {
 		const uniqueAdapterFactoryInstanceId = Math.random()
 			.toString(36)
 			.substring(2, 15);
@@ -71,9 +71,7 @@ export const createAdapterFactory =
 			disableTransformJoin: cfg.disableTransformJoin ?? false,
 		} satisfies AdapterFactoryConfig;
 
-		const useNumberId =
-			options.advanced?.database?.useNumberId === true ||
-			options.advanced?.database?.generateId === "serial";
+		const useNumberId = options.advanced?.database?.generateId === "serial";
 		if (useNumberId && config.supportsNumericIds === false) {
 			throw new BetterAuthError(
 				`[${config.adapterName}] Your database or database adapter does not support numeric ids. Please disable "useNumberId" in your config.`,
@@ -189,9 +187,7 @@ export const createAdapterFactory =
 			const fields = schema[defaultModelName]!.fields;
 
 			const newMappedKeys = config.mapKeysTransformInput ?? {};
-			const useNumberId =
-				options.advanced?.database?.useNumberId ||
-				options.advanced?.database?.generateId === "serial";
+			const useNumberId = options.advanced?.database?.generateId === "serial";
 			fields.id = idField({
 				customModelName: defaultModelName,
 				forceAllowId: forceAllowId && "id" in data,
@@ -309,9 +305,7 @@ export const createAdapterFactory =
 				const idKey = Object.entries(newMappedKeys).find(
 					([_, v]) => v === "id",
 				)?.[0];
-				const useNumberId =
-					options.advanced?.database?.useNumberId ||
-					options.advanced?.database?.generateId === "serial";
+				const useNumberId = options.advanced?.database?.generateId === "serial";
 				tableSchema[idKey ?? "id"] = {
 					type: useNumberId ? "number" : "string",
 				};
@@ -523,9 +517,7 @@ export const createAdapterFactory =
 					model: defaultModelName,
 				});
 
-				const useNumberId =
-					options.advanced?.database?.useNumberId ||
-					options.advanced?.database?.generateId === "serial";
+				const useNumberId = options.advanced?.database?.generateId === "serial";
 
 				if (
 					defaultFieldName === "id" ||
@@ -548,12 +540,32 @@ export const createAdapterFactory =
 					newValue = value.toISOString();
 				}
 
+				if (fieldAttr.type === "boolean" && typeof newValue === "string") {
+					newValue = newValue === "true";
+				}
+
+				if (fieldAttr.type === "number") {
+					if (typeof newValue === "string" && newValue.trim() !== "") {
+						const parsed = Number(newValue);
+						if (!Number.isNaN(parsed)) {
+							newValue = parsed;
+						}
+					} else if (Array.isArray(newValue)) {
+						const parsed = newValue.map((v) =>
+							typeof v === "string" && v.trim() !== "" ? Number(v) : NaN,
+						);
+						if (parsed.every((n) => !Number.isNaN(n))) {
+							newValue = parsed;
+						}
+					}
+				}
+
 				if (
 					fieldAttr.type === "boolean" &&
-					typeof value === "boolean" &&
+					typeof newValue === "boolean" &&
 					!config.supportsBooleans
 				) {
-					newValue = value ? 1 : 0;
+					newValue = newValue ? 1 : 0;
 				}
 
 				if (
@@ -793,10 +805,8 @@ export const createAdapterFactory =
 			transformWhereClause,
 		});
 
-		let lazyLoadTransaction:
-			| DBAdapter<BetterAuthOptions>["transaction"]
-			| null = null;
-		const adapter: DBAdapter<BetterAuthOptions> = {
+		let lazyLoadTransaction: DBAdapter<Options>["transaction"] | null = null;
+		const adapter: DBAdapter<Options> = {
 			transaction: async (cb) => {
 				if (!lazyLoadTransaction) {
 					if (!config.transaction) {
@@ -1083,6 +1093,7 @@ export const createAdapterFactory =
 				model: unsafeModel,
 				where: unsafeWhere,
 				limit: unsafeLimit,
+				select,
 				sortBy,
 				offset,
 				join: unsafeJoin,
@@ -1090,6 +1101,7 @@ export const createAdapterFactory =
 				model: string;
 				where?: Where[];
 				limit?: number;
+				select?: string[] | undefined;
 				sortBy?: { field: string; direction: "asc" | "desc" };
 				offset?: number;
 				join?: JoinOption;
@@ -1110,13 +1122,10 @@ export const createAdapterFactory =
 				let join: JoinConfig | undefined;
 				let passJoinToAdapter = true;
 				if (!config.disableTransformJoin) {
-					const result = transformJoinClause(
-						unsafeModel,
-						unsafeJoin,
-						undefined,
-					);
+					const result = transformJoinClause(unsafeModel, unsafeJoin, select);
 					if (result) {
 						join = result.join;
+						select = result.select;
 					}
 					// If adapter doesn't support joins and we have joins, don't pass them to the adapter
 					const experimentalJoins = options.experimental?.joins;
@@ -1137,6 +1146,7 @@ export const createAdapterFactory =
 					model,
 					where,
 					limit: limit,
+					select,
 					sortBy,
 					offset,
 					join: passJoinToAdapter ? join : undefined,
@@ -1284,42 +1294,6 @@ export const createAdapterFactory =
 							delete tables.session;
 						}
 
-						if (
-							options.rateLimit &&
-							options.rateLimit.storage === "database" &&
-							// rate-limit will default to enabled in production,
-							// and given storage is database, it will try to use the rate-limit table,
-							// so we should make sure to generate rate-limit table schema
-							(typeof options.rateLimit.enabled === "undefined" ||
-								// and of course if they forcefully set to true, then they want rate-limit,
-								// thus we should also generate rate-limit table schema
-								options.rateLimit.enabled === true)
-						) {
-							tables.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",
-										required: true,
-										bigint: true,
-										defaultValue: () => Date.now(),
-										fieldName:
-											options.rateLimit.fields?.lastRequest ?? "lastRequest",
-									},
-								},
-							};
-						}
 						return adapterInstance.createSchema!({ file, tables });
 					}
 				: undefined,
@@ -1390,9 +1364,3 @@ function formatMethod(method: string) {
 function formatAction(action: string) {
 	return `${TTY_COLORS.dim}(${action})${TTY_COLORS.reset}`;
 }
-
-/**
- * @deprecated Use `createAdapterFactory` instead. This export will be removed in a future version.
- * @alias
- */
-export const createAdapter = createAdapterFactory;

package/src/db/adapter/get-id-field.ts

@@ -31,9 +31,7 @@ export const initGetIdField = ({
 		customModelName?: string;
 		forceAllowId?: boolean;
 	}) => {
-		const useNumberId =
-			options.advanced?.database?.useNumberId ||
-			options.advanced?.database?.generateId === "serial";
+		const useNumberId = options.advanced?.database?.generateId === "serial";
 		const useUUIDs = options.advanced?.database?.generateId === "uuid";
 
 		const shouldGenerateId: boolean = (() => {

package/src/db/adapter/index.ts

@@ -301,25 +301,27 @@ export interface DBAdapterFactoryConfig<
 	disableTransformJoin?: boolean | undefined;
 }
 
+export const whereOperators = [
+	"eq",
+	"ne",
+	"lt",
+	"lte",
+	"gt",
+	"gte",
+	"in",
+	"not_in",
+	"contains",
+	"starts_with",
+	"ends_with",
+] as const;
+
+export type WhereOperator = (typeof whereOperators)[number];
+
 export type Where = {
 	/**
 	 * @default eq
 	 */
-	operator?:
-		| (
-				| "eq"
-				| "ne"
-				| "lt"
-				| "lte"
-				| "gt"
-				| "gte"
-				| "in"
-				| "not_in"
-				| "contains"
-				| "starts_with"
-				| "ends_with"
-		  )
-		| undefined;
+	operator?: WhereOperator | undefined;
 	value: string | number | boolean | string[] | number[] | Date | null;
 	field: string;
 	/**
@@ -405,6 +407,7 @@ export type DBAdapter<Options extends BetterAuthOptions = BetterAuthOptions> = {
 		model: string;
 		where?: Where[] | undefined;
 		limit?: number | undefined;
+		select?: string[] | undefined;
 		sortBy?:
 			| {
 					field: string;
@@ -493,6 +496,7 @@ export interface CustomAdapter {
 		model,
 		where,
 		limit,
+		select,
 		sortBy,
 		offset,
 		join,
@@ -500,6 +504,7 @@ export interface CustomAdapter {
 		model: string;
 		where?: CleanedWhere[] | undefined;
 		limit: number;
+		select?: string[] | undefined;
 		sortBy?: { field: string; direction: "asc" | "desc" } | undefined;
 		offset?: number | undefined;
 		join?: JoinConfig | undefined;

package/src/db/adapter/types.ts

@@ -1,9 +1,8 @@
 import type { BetterAuthOptions } from "../../types";
-import type { Prettify } from "../../types/helper";
 import type { BetterAuthDBSchema, DBFieldAttribute } from "../type";
 import type {
-	DBAdapterSchemaCreation as AdapterSchemaCreation,
-	CustomAdapter as CoreCustomAdapter,
+	CleanedWhere,
+	CustomAdapter,
 	DBAdapterFactoryConfig,
 	JoinConfig,
 	DBTransactionAdapter as TransactionAdapter,
@@ -127,45 +126,7 @@ export type AdapterFactoryCustomizeAdapterCreator = (config: {
 	}) => W extends undefined ? undefined : CleanedWhere[];
 }) => CustomAdapter;
 
-/**
- * @deprecated Use `CustomAdapter` from `@better-auth/core/db/adapter` instead.
- */
-export interface CustomAdapter extends Omit<CoreCustomAdapter, "createSchema"> {
-	createSchema?:
-		| ((props: {
-				/**
-				 * The file the user may have passed in to the `generate` command as the expected schema file output path.
-				 */
-				file?: string;
-				/**
-				 * The tables from the user's Better-Auth instance schema.
-				 */
-				tables: BetterAuthDBSchema;
-		  }) => Promise<AdapterSchemaCreation>)
-		| undefined;
-}
-
-/**
- * @deprecated Use `CleanedWhere` from `@better-auth/core/db/adapter` instead.
- */
-export type CleanedWhere = Prettify<Required<Where>>;
-
 export type AdapterTestDebugLogs = {
 	resetDebugLogs: () => void;
 	printDebugLogs: () => void;
 };
-
-/**
- * @deprecated Use `AdapterFactoryOptions` instead. This export will be removed in a future version.
- */
-export type CreateAdapterOptions = AdapterFactoryOptions;
-
-/**
- * @deprecated Use `AdapterFactoryConfig` instead. This export will be removed in a future version.
- */
-export type AdapterConfig = AdapterFactoryConfig;
-
-/**
- * @deprecated Use `AdapterFactoryCustomizeAdapterCreator` instead. This export will be removed in a future version.
- */
-export type CreateCustomAdapter = AdapterFactoryCustomizeAdapterCreator;

package/src/db/get-tables.ts

@@ -32,16 +32,21 @@ export const getAuthTables = (
 			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(),
 				},
 			},
 		},
@@ -50,6 +55,46 @@ export const getAuthTables = (
 	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",
@@ -242,43 +287,9 @@ export const getAuthTables = (
 			},
 			order: 3,
 		},
-		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,
-		},
+		...(!options.secondaryStorage || options.verification?.storeInDatabase
+			? verificationTable
+			: {}),
 		...pluginTables,
 		...(shouldAddRateLimitTable ? rateLimitTable : {}),
 	} satisfies BetterAuthDBSchema;

package/src/db/index.ts

@@ -1,11 +1,27 @@
 export { getAuthTables } from "./get-tables";
 export type { BetterAuthPluginDBSchema } from "./plugin";
-export { type Account, accountSchema } from "./schema/account";
-export { type RateLimit, rateLimitSchema } from "./schema/rate-limit";
-export { type Session, sessionSchema } from "./schema/session";
+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 User, userSchema } from "./schema/user";
-export { type Verification, verificationSchema } from "./schema/verification";
+export { type BaseUser, type User, userSchema } from "./schema/user";
+export {
+	type BaseVerification,
+	type Verification,
+	verificationSchema,
+} from "./schema/verification";
 export type {
 	BaseModelNames,
 	BetterAuthDBSchema,
@@ -13,6 +29,15 @@ export type {
 	DBFieldAttributeConfig,
 	DBFieldType,
 	DBPrimitive,
+	InferDBFieldInput,
+	InferDBFieldOutput,
+	InferDBFieldsFromOptions,
+	InferDBFieldsFromOptionsInput,
+	InferDBFieldsFromPlugins,
+	InferDBFieldsFromPluginsInput,
+	InferDBFieldsInput,
+	InferDBFieldsOutput,
+	InferDBValueType,
 	ModelNames,
 	SecondaryStorage,
 } from "./type";

package/src/db/schema/account.ts

@@ -1,4 +1,10 @@
 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({
@@ -26,9 +32,16 @@ export const accountSchema = coreSchema.extend({
 	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
- *
- * todo: we should use generics to extend this type with additional fields from plugins and options in the future
  */
-export type Account = z.infer<typeof accountSchema>;
+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

@@ -1,4 +1,9 @@
 import * as z from "zod";
+import type { BetterAuthOptions, Prettify } from "../../types";
+import type {
+	InferDBFieldsFromOptions,
+	InferDBFieldsFromPlugins,
+} from "../type";
 
 export const rateLimitSchema = z.object({
 	/**
@@ -15,7 +20,17 @@ export const rateLimitSchema = z.object({
 	lastRequest: z.number(),
 });
 
+export type BaseRateLimit = z.infer<typeof rateLimitSchema>;
+
 /**
  * Rate limit schema type used by better-auth for rate limiting
  */
-export type RateLimit = z.infer<typeof rateLimitSchema>;
+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

@@ -1,4 +1,9 @@
 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({
@@ -9,9 +14,16 @@ export const sessionSchema = coreSchema.extend({
 	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
- *
- * todo: we should use generics to extend this type with additional fields from plugins and options in the future
  */
-export type Session = z.infer<typeof sessionSchema>;
+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/user.ts

@@ -1,4 +1,9 @@
 import * as z from "zod";
+import type { BetterAuthOptions, Prettify } from "../../types";
+import type {
+	InferDBFieldsFromOptions,
+	InferDBFieldsFromPlugins,
+} from "../type";
 import { coreSchema } from "./shared";
 
 export const userSchema = coreSchema.extend({
@@ -8,9 +13,16 @@ export const userSchema = coreSchema.extend({
 	image: z.string().nullish(),
 });
 
+export type BaseUser = z.infer<typeof userSchema>;
+
 /**
  * User schema type used by better-auth, note that it's possible that user could have additional fields
- *
- * todo: we should use generics to extend this type with additional fields from plugins and options in the future
  */
-export type User = z.infer<typeof userSchema>;
+export type User<
+	DBOptions extends BetterAuthOptions["user"] = BetterAuthOptions["user"],
+	Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"],
+> = Prettify<
+	BaseUser &
+		InferDBFieldsFromOptions<DBOptions> &
+		InferDBFieldsFromPlugins<"user", Plugins>
+>;

package/src/db/schema/verification.ts

@@ -1,4 +1,9 @@
 import * as z from "zod";
+import type { BetterAuthOptions, Prettify } from "../../types";
+import type {
+	InferDBFieldsFromOptions,
+	InferDBFieldsFromPlugins,
+} from "../type";
 import { coreSchema } from "./shared";
 
 export const verificationSchema = coreSchema.extend({
@@ -7,9 +12,17 @@ export const verificationSchema = coreSchema.extend({
 	identifier: z.string(),
 });
 
+export type BaseVerification = z.infer<typeof verificationSchema>;
+
 /**
  * Verification schema type used by better-auth, note that it's possible that verification could have additional fields
- *
- * todo: we should use generics to extend this type with additional fields from plugins and options in the future
  */
-export type Verification = z.infer<typeof verificationSchema>;
+export type Verification<
+	DBOptions extends
+		BetterAuthOptions["verification"] = BetterAuthOptions["verification"],
+	Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"],
+> = Prettify<
+	BaseVerification &
+		InferDBFieldsFromOptions<DBOptions> &
+		InferDBFieldsFromPlugins<"verification", Plugins>
+>;