@depup/better-auth__core 1.6.23-depup.2

package/dist/db/adapter/types.d.mts

@@ -0,0 +1,105 @@
+import { BetterAuthDBSchema, DBFieldAttribute } from "../type.mjs";
+import { CleanedWhere, CustomAdapter, DBAdapterFactoryConfig, DBTransactionAdapter, JoinConfig, Where } from "./index.mjs";
+import { BetterAuthOptions } from "../../types/init-options.mjs";
+//#region src/db/adapter/types.d.ts
+type AdapterFactoryOptions = {
+  config: AdapterFactoryConfig;
+  adapter: AdapterFactoryCustomizeAdapterCreator;
+};
+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: DBTransactionAdapter) => Promise<R>) => Promise<R>)) | undefined;
+}
+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;
+  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;
+type AdapterTestDebugLogs = {
+  resetDebugLogs: () => void;
+  printDebugLogs: () => void;
+};
+//#endregion
+export { AdapterFactoryConfig, AdapterFactoryCustomizeAdapterCreator, AdapterFactoryOptions, AdapterTestDebugLogs };

package/dist/db/adapter/utils.d.mts

@@ -0,0 +1,7 @@
+import { DBFieldAttribute } from "../type.mjs";
+
+//#region src/db/adapter/utils.d.ts
+declare function withApplyDefault(value: any, field: DBFieldAttribute, action: "create" | "update" | "findOne" | "findMany"): any;
+declare function deepmerge<T>(target: T, source: Partial<T>): T;
+//#endregion
+export { deepmerge, withApplyDefault };

package/dist/db/adapter/utils.mjs

@@ -0,0 +1,37 @@
+//#region src/db/adapter/utils.ts
+function withApplyDefault(value, field, action) {
+	if (action === "update") {
+		if (value === void 0 && field.onUpdate !== void 0) {
+			if (typeof field.onUpdate === "function") return field.onUpdate();
+			return field.onUpdate;
+		}
+		return value;
+	}
+	if (action === "create") {
+		if (value === void 0 || field.required === true && value === null) {
+			if (field.defaultValue !== void 0) {
+				if (typeof field.defaultValue === "function") return field.defaultValue();
+				return field.defaultValue;
+			}
+		}
+	}
+	return value;
+}
+function isObject(item) {
+	return item !== null && typeof item === "object" && !Array.isArray(item);
+}
+function deepmerge(target, source) {
+	if (Array.isArray(target) && Array.isArray(source)) return [...target, ...source];
+	else if (isObject(target) && isObject(source)) {
+		const result = { ...target };
+		for (const [key, value] of Object.entries(source)) {
+			if (value === void 0) continue;
+			if (key in target) result[key] = deepmerge(target[key], value);
+			else result[key] = value;
+		}
+		return result;
+	}
+	return source;
+}
+//#endregion
+export { deepmerge, withApplyDefault };

package/dist/db/get-tables.d.mts

@@ -0,0 +1,6 @@
+import { BetterAuthDBSchema } from "./type.mjs";
+import { BetterAuthOptions } from "../types/init-options.mjs";
+//#region src/db/get-tables.d.ts
+declare const getAuthTables: (options: BetterAuthOptions) => BetterAuthDBSchema;
+//#endregion
+export { getAuthTables };

package/dist/db/get-tables.mjs

@@ -0,0 +1,266 @@
+//#region src/db/get-tables.ts
+const getAuthTables = (options) => {
+	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;
+	}, {});
+	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()
+			}
+		}
+	} };
+	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: () => /* @__PURE__ */ new Date(),
+				fieldName: options.verification?.fields?.createdAt || "createdAt"
+			},
+			updatedAt: {
+				type: "date",
+				required: true,
+				defaultValue: () => /* @__PURE__ */ new Date(),
+				onUpdate: () => /* @__PURE__ */ new Date(),
+				fieldName: options.verification?.fields?.updatedAt || "updatedAt"
+			},
+			...verification?.fields,
+			...options.verification?.additionalFields
+		},
+		order: 4
+	} };
+	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: () => /* @__PURE__ */ new Date()
+			},
+			updatedAt: {
+				type: "date",
+				required: true,
+				fieldName: options.session?.fields?.updatedAt || "updatedAt",
+				onUpdate: () => /* @__PURE__ */ 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
+	} };
+	return {
+		user: {
+			modelName: options.user?.modelName || "user",
+			fields: {
+				name: {
+					type: "string",
+					required: true,
+					fieldName: options.user?.fields?.name || "name",
+					sortable: true
+				},
+				email: {
+					type: "string",
+					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: () => /* @__PURE__ */ new Date(),
+					required: true,
+					fieldName: options.user?.fields?.createdAt || "createdAt"
+				},
+				updatedAt: {
+					type: "date",
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date(),
+					required: true,
+					fieldName: options.user?.fields?.updatedAt || "updatedAt"
+				},
+				...user?.fields,
+				...options.user?.additionalFields
+			},
+			order: 1
+		},
+		...!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: () => /* @__PURE__ */ new Date()
+				},
+				updatedAt: {
+					type: "date",
+					required: true,
+					fieldName: options.account?.fields?.updatedAt || "updatedAt",
+					onUpdate: () => /* @__PURE__ */ new Date()
+				},
+				...account?.fields,
+				...options.account?.additionalFields
+			},
+			order: 3
+		},
+		...!options.secondaryStorage || options.verification?.storeInDatabase ? verificationTable : {},
+		...pluginTables,
+		...shouldAddRateLimitTable ? rateLimitTable : {}
+	};
+};
+//#endregion
+export { getAuthTables };

package/dist/db/index.d.mts

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

package/dist/db/index.mjs

@@ -0,0 +1,8 @@
+import { getAuthTables } from "./get-tables.mjs";
+import { coreSchema } from "./schema/shared.mjs";
+import { accountSchema } from "./schema/account.mjs";
+import { rateLimitSchema } from "./schema/rate-limit.mjs";
+import { sessionSchema } from "./schema/session.mjs";
+import { userSchema } from "./schema/user.mjs";
+import { verificationSchema } from "./schema/verification.mjs";
+export { accountSchema, coreSchema, getAuthTables, rateLimitSchema, sessionSchema, userSchema, verificationSchema };

package/dist/db/plugin.d.mts

@@ -0,0 +1,12 @@
+import { DBFieldAttribute } from "./type.mjs";
+
+//#region src/db/plugin.d.ts
+type BetterAuthPluginDBSchema = { [table in string]: {
+  fields: {
+    [field: string]: DBFieldAttribute;
+  };
+  disableMigration?: boolean | undefined;
+  modelName?: string | undefined;
+} };
+//#endregion
+export { BetterAuthPluginDBSchema };

package/dist/db/schema/account.d.mts

@@ -0,0 +1,28 @@
+import { InferDBFieldsFromOptions, InferDBFieldsFromPlugins } from "../type.mjs";
+import { Prettify } from "../../types/helper.mjs";
+import { BetterAuthOptions } from "../../types/init-options.mjs";
+import * as z from "zod";
+
+//#region src/db/schema/account.d.ts
+declare const accountSchema: z.ZodObject<{
+  id: z.ZodString;
+  createdAt: z.ZodDefault<z.ZodDate>;
+  updatedAt: z.ZodDefault<z.ZodDate>;
+  providerId: z.ZodString;
+  accountId: z.ZodString;
+  userId: z.ZodCoercedString<unknown>;
+  accessToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  refreshToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  idToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  accessTokenExpiresAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+  refreshTokenExpiresAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+  scope: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  password: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type BaseAccount = z.infer<typeof accountSchema>;
+/**
+ * Account schema type used by better-auth, note that it's possible that account could have additional fields
+ */
+type Account<DBOptions extends BetterAuthOptions["account"] = BetterAuthOptions["account"], Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"]> = Prettify<BaseAccount & InferDBFieldsFromOptions<DBOptions> & InferDBFieldsFromPlugins<"account", Plugins>>;
+//#endregion
+export { Account, BaseAccount, accountSchema };

package/dist/db/schema/account.mjs

@@ -0,0 +1,17 @@
+import { coreSchema } from "./shared.mjs";
+import * as z from "zod";
+//#region src/db/schema/account.ts
+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(),
+	accessTokenExpiresAt: z.date().nullish(),
+	refreshTokenExpiresAt: z.date().nullish(),
+	scope: z.string().nullish(),
+	password: z.string().nullish()
+});
+//#endregion
+export { accountSchema };

package/dist/db/schema/rate-limit.d.mts

@@ -0,0 +1,18 @@
+import { InferDBFieldsFromOptions, InferDBFieldsFromPlugins } from "../type.mjs";
+import { Prettify } from "../../types/helper.mjs";
+import { BetterAuthOptions } from "../../types/init-options.mjs";
+import * as z from "zod";
+
+//#region src/db/schema/rate-limit.d.ts
+declare const rateLimitSchema: z.ZodObject<{
+  key: z.ZodString;
+  count: z.ZodNumber;
+  lastRequest: z.ZodNumber;
+}, z.core.$strip>;
+type BaseRateLimit = z.infer<typeof rateLimitSchema>;
+/**
+ * Rate limit schema type used by better-auth for rate limiting
+ */
+type RateLimit<DBOptions extends BetterAuthOptions["rateLimit"] = BetterAuthOptions["rateLimit"], Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"]> = Prettify<BaseRateLimit & InferDBFieldsFromOptions<DBOptions> & InferDBFieldsFromPlugins<"rateLimit", Plugins>>;
+//#endregion
+export { BaseRateLimit, RateLimit, rateLimitSchema };

package/dist/db/schema/rate-limit.mjs

@@ -0,0 +1,9 @@
+import * as z from "zod";
+//#region src/db/schema/rate-limit.ts
+const rateLimitSchema = z.object({
+	key: z.string(),
+	count: z.number(),
+	lastRequest: z.number()
+});
+//#endregion
+export { rateLimitSchema };

package/dist/db/schema/session.d.mts

@@ -0,0 +1,23 @@
+import { InferDBFieldsFromOptions, InferDBFieldsFromPlugins } from "../type.mjs";
+import { Prettify } from "../../types/helper.mjs";
+import { BetterAuthOptions } from "../../types/init-options.mjs";
+import * as z from "zod";
+
+//#region src/db/schema/session.d.ts
+declare const sessionSchema: z.ZodObject<{
+  id: z.ZodString;
+  createdAt: z.ZodDefault<z.ZodDate>;
+  updatedAt: z.ZodDefault<z.ZodDate>;
+  userId: z.ZodCoercedString<unknown>;
+  expiresAt: z.ZodDate;
+  token: z.ZodString;
+  ipAddress: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type BaseSession = z.infer<typeof sessionSchema>;
+/**
+ * Session schema type used by better-auth, note that it's possible that session could have additional fields
+ */
+type Session<DBOptions extends BetterAuthOptions["session"] = BetterAuthOptions["session"], Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"]> = Prettify<z.infer<typeof sessionSchema> & InferDBFieldsFromOptions<DBOptions> & InferDBFieldsFromPlugins<"session", Plugins>>;
+//#endregion
+export { BaseSession, Session, sessionSchema };

package/dist/db/schema/session.mjs

@@ -0,0 +1,12 @@
+import { coreSchema } from "./shared.mjs";
+import * as z from "zod";
+//#region src/db/schema/session.ts
+const sessionSchema = coreSchema.extend({
+	userId: z.coerce.string(),
+	expiresAt: z.date(),
+	token: z.string(),
+	ipAddress: z.string().nullish(),
+	userAgent: z.string().nullish()
+});
+//#endregion
+export { sessionSchema };

package/dist/db/schema/shared.d.mts

@@ -0,0 +1,10 @@
+import * as z from "zod";
+
+//#region src/db/schema/shared.d.ts
+declare const coreSchema: z.ZodObject<{
+  id: z.ZodString;
+  createdAt: z.ZodDefault<z.ZodDate>;
+  updatedAt: z.ZodDefault<z.ZodDate>;
+}, z.core.$strip>;
+//#endregion
+export { coreSchema };

package/dist/db/schema/shared.mjs

@@ -0,0 +1,9 @@
+import * as z from "zod";
+//#region src/db/schema/shared.ts
+const coreSchema = z.object({
+	id: z.string(),
+	createdAt: z.date().default(() => /* @__PURE__ */ new Date()),
+	updatedAt: z.date().default(() => /* @__PURE__ */ new Date())
+});
+//#endregion
+export { coreSchema };

package/dist/db/schema/user.d.mts

@@ -0,0 +1,22 @@
+import { InferDBFieldsFromOptions, InferDBFieldsFromPlugins } from "../type.mjs";
+import { Prettify } from "../../types/helper.mjs";
+import { BetterAuthOptions } from "../../types/init-options.mjs";
+import * as z from "zod";
+
+//#region src/db/schema/user.d.ts
+declare const userSchema: z.ZodObject<{
+  id: z.ZodString;
+  createdAt: z.ZodDefault<z.ZodDate>;
+  updatedAt: z.ZodDefault<z.ZodDate>;
+  email: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+  emailVerified: z.ZodDefault<z.ZodBoolean>;
+  name: z.ZodString;
+  image: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type BaseUser = z.infer<typeof userSchema>;
+/**
+ * User schema type used by better-auth, note that it's possible that user could have additional fields
+ */
+type User<DBOptions extends BetterAuthOptions["user"] = BetterAuthOptions["user"], Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"]> = Prettify<BaseUser & InferDBFieldsFromOptions<DBOptions> & InferDBFieldsFromPlugins<"user", Plugins>>;
+//#endregion
+export { BaseUser, User, userSchema };

package/dist/db/schema/user.mjs

@@ -0,0 +1,11 @@
+import { coreSchema } from "./shared.mjs";
+import * as z from "zod";
+//#region src/db/schema/user.ts
+const userSchema = coreSchema.extend({
+	email: z.string().transform((val) => val.toLowerCase()),
+	emailVerified: z.boolean().default(false),
+	name: z.string(),
+	image: z.string().nullish()
+});
+//#endregion
+export { userSchema };

package/dist/db/schema/verification.d.mts

@@ -0,0 +1,21 @@
+import { InferDBFieldsFromOptions, InferDBFieldsFromPlugins } from "../type.mjs";
+import { Prettify } from "../../types/helper.mjs";
+import { BetterAuthOptions } from "../../types/init-options.mjs";
+import * as z from "zod";
+
+//#region src/db/schema/verification.d.ts
+declare const verificationSchema: z.ZodObject<{
+  id: z.ZodString;
+  createdAt: z.ZodDefault<z.ZodDate>;
+  updatedAt: z.ZodDefault<z.ZodDate>;
+  value: z.ZodString;
+  expiresAt: z.ZodDate;
+  identifier: z.ZodString;
+}, z.core.$strip>;
+type BaseVerification = z.infer<typeof verificationSchema>;
+/**
+ * Verification schema type used by better-auth, note that it's possible that verification could have additional fields
+ */
+type Verification<DBOptions extends BetterAuthOptions["verification"] = BetterAuthOptions["verification"], Plugins extends BetterAuthOptions["plugins"] = BetterAuthOptions["plugins"]> = Prettify<BaseVerification & InferDBFieldsFromOptions<DBOptions> & InferDBFieldsFromPlugins<"verification", Plugins>>;
+//#endregion
+export { BaseVerification, Verification, verificationSchema };

package/dist/db/schema/verification.mjs

@@ -0,0 +1,10 @@
+import { coreSchema } from "./shared.mjs";
+import * as z from "zod";
+//#region src/db/schema/verification.ts
+const verificationSchema = coreSchema.extend({
+	value: z.string(),
+	expiresAt: z.date(),
+	identifier: z.string()
+});
+//#endregion
+export { verificationSchema };