@better-auth/core 1.7.0-rc.1 → 1.7.0-rc.2

package/dist/db/database-index.d.mts

@@ -0,0 +1,44 @@
+import { DBFieldAttribute, DBTableIndex } from "./type.mjs";
+//#region src/db/database-index.d.ts
+declare function getPortableDatabaseIdentifierKey(identifier: string): string;
+/** A table-level index resolved to physical database columns. */
+interface ResolvedDBTableIndex extends Omit<DBTableIndex, "fields"> {
+  /** Physical database column names, in index order. */
+  columns: readonly [string, ...string[]];
+  name: string;
+}
+interface DBTableIndexSource {
+  fields: Readonly<Record<string, DBFieldAttribute>>;
+  indexes: readonly DBTableIndex[] | undefined;
+  tableName: string;
+}
+type BoundedDatabaseIndexDialect = "mssql" | "mysql";
+/** Returns the stable database name for a table-level index. */
+declare function getDatabaseIndexName(tableName: string, index: DBTableIndex): string;
+/** Returns the database name used by legacy field-level index metadata. */
+declare function getDatabaseFieldIndexName(tableName: string, columnName: string, unique: boolean): string;
+/** Resolves logical index fields to their configured database column names. */
+declare function resolveDatabaseTableIndexes({ fields, indexes, tableName }: {
+  fields: Readonly<Record<string, DBFieldAttribute>>;
+  indexes: readonly DBTableIndex[] | undefined;
+  tableName: string;
+}): readonly ResolvedDBTableIndex[];
+/**
+ * Returns a safe generated string length for a column across all of its table
+ * indexes in byte-limited SQL dialects.
+ */
+declare function getDatabaseIndexStringLength({ columnName, dialect, fields, indexes }: {
+  columnName: string;
+  dialect: BoundedDatabaseIndexDialect;
+  fields: Readonly<Record<string, DBFieldAttribute>>;
+  indexes: readonly ResolvedDBTableIndex[];
+}): number | undefined;
+/**
+ * Resolves and validates every table index as one portable database schema.
+ *
+ * Index names are schema-wide because SQLite and PostgreSQL do not scope them
+ * to an individual table.
+ */
+declare function resolveDatabaseSchemaIndexes(sources: readonly DBTableIndexSource[]): ReadonlyMap<string, readonly ResolvedDBTableIndex[]>;
+//#endregion
+export { BoundedDatabaseIndexDialect, DBTableIndexSource, ResolvedDBTableIndex, getDatabaseFieldIndexName, getDatabaseIndexName, getDatabaseIndexStringLength, getPortableDatabaseIdentifierKey, resolveDatabaseSchemaIndexes, resolveDatabaseTableIndexes };

package/dist/db/database-index.mjs

@@ -0,0 +1,168 @@
+import { BetterAuthError } from "../error/index.mjs";
+//#region src/db/database-index.ts
+const MAX_DATABASE_INDEX_NAME_BYTES = 63;
+const MAX_DATABASE_INDEX_FIELDS = 16;
+function getPortableDatabaseIdentifierKey(identifier) {
+	return identifier.toLowerCase();
+}
+function getUtf8ByteLength(value) {
+	return new TextEncoder().encode(value).length;
+}
+function truncateUtf8(value, maxBytes) {
+	let result = "";
+	let byteLength = 0;
+	for (const character of value) {
+		const characterByteLength = getUtf8ByteLength(character);
+		if (byteLength + characterByteLength > maxBytes) break;
+		result += character;
+		byteLength += characterByteLength;
+	}
+	return result;
+}
+function getStableIndexNameHash(value) {
+	let hash = 2166136261;
+	for (let index = 0; index < value.length; index++) {
+		hash ^= value.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(16).padStart(8, "0");
+}
+/** Returns the stable database name for a table-level index. */
+function getDatabaseIndexName(tableName, index) {
+	if (index.name !== void 0) {
+		if (index.name.trim().length === 0) throw new BetterAuthError("Database index names must contain at least one visible character.");
+		if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(index.name)) throw new BetterAuthError("Database index names must start with a letter or underscore and contain only letters, numbers, and underscores.");
+		if (getUtf8ByteLength(index.name) > MAX_DATABASE_INDEX_NAME_BYTES) throw new BetterAuthError(`Database index names must be at most ${MAX_DATABASE_INDEX_NAME_BYTES} UTF-8 bytes.`);
+		return index.name;
+	}
+	const indexKind = index.unique ? "uidx" : "idx";
+	const generatedName = `${tableName}_${index.fields.join("_")}_${indexKind}`;
+	if (getUtf8ByteLength(generatedName) <= MAX_DATABASE_INDEX_NAME_BYTES) return generatedName;
+	const suffix = `_${getStableIndexNameHash(generatedName)}_${indexKind}`;
+	return `${truncateUtf8(generatedName.slice(0, -indexKind.length - 1), MAX_DATABASE_INDEX_NAME_BYTES - getUtf8ByteLength(suffix))}${suffix}`;
+}
+/** Returns the database name used by legacy field-level index metadata. */
+function getDatabaseFieldIndexName(tableName, columnName, unique) {
+	return getDatabaseIndexName(tableName, {
+		fields: [columnName],
+		unique
+	});
+}
+/** Resolves logical index fields to their configured database column names. */
+function resolveDatabaseTableIndexes({ fields, indexes, tableName }) {
+	const resolvedIndexes = (indexes ?? []).map((index) => {
+		if (index.fields.length === 0) throw new BetterAuthError(`Index on table "${tableName}" must include at least one field.`);
+		if (index.fields.length > MAX_DATABASE_INDEX_FIELDS) throw new BetterAuthError(`Index on table "${tableName}" can include at most ${MAX_DATABASE_INDEX_FIELDS} fields so it works across supported databases.`);
+		if (new Set(index.fields).size !== index.fields.length) throw new BetterAuthError(`Index on table "${tableName}" contains the same field more than once.`);
+		if (index.unique && index.fields.some((fieldName) => fields[fieldName]?.required === false)) throw new BetterAuthError(`Unique index on table "${tableName}" can only include required fields so its behavior is consistent across databases.`);
+		const unsupportedField = index.fields.find((fieldName) => {
+			const fieldType = fields[fieldName]?.type;
+			return fieldType === "json" || fieldType === "string[]" || fieldType === "number[]";
+		});
+		if (unsupportedField) throw new BetterAuthError(`Index on table "${tableName}" references field "${unsupportedField}", whose type is not portably indexable.`);
+		const resolveFieldName = (fieldName) => {
+			const field = fields[fieldName];
+			if (!field) throw new BetterAuthError(`Index on table "${tableName}" references unknown field "${fieldName}".`);
+			return field.fieldName || fieldName;
+		};
+		const [firstField, ...remainingFields] = index.fields;
+		const columns = [resolveFieldName(firstField), ...remainingFields.map(resolveFieldName)];
+		if (new Set(columns.map(getPortableDatabaseIdentifierKey)).size !== columns.length) throw new BetterAuthError(`Index on table "${tableName}" resolves more than one field to the same database column.`);
+		return {
+			columns,
+			name: getDatabaseIndexName(tableName, {
+				...index,
+				fields: columns
+			}),
+			unique: index.unique
+		};
+	});
+	const definitionsByName = /* @__PURE__ */ new Map();
+	const deduplicatedIndexes = [];
+	for (const index of resolvedIndexes) {
+		const definition = JSON.stringify([index.columns, index.unique ?? false]);
+		const identifierKey = getPortableDatabaseIdentifierKey(index.name);
+		const existingDefinition = definitionsByName.get(identifierKey);
+		if (existingDefinition && existingDefinition !== definition) throw new BetterAuthError(`Database index name "${index.name}" identifies more than one index on table "${tableName}".`);
+		if (existingDefinition) continue;
+		definitionsByName.set(identifierKey, definition);
+		deduplicatedIndexes.push(index);
+	}
+	return deduplicatedIndexes;
+}
+/**
+* Returns a safe generated string length for a column across all of its table
+* indexes in byte-limited SQL dialects.
+*/
+function getDatabaseIndexStringLength({ columnName, dialect, fields, indexes }) {
+	const fieldsByColumn = new Map(Object.entries(fields).map(([fieldName, field]) => [field.fieldName || fieldName, field]));
+	const containingIndexes = indexes.filter((index) => index.columns.includes(columnName));
+	if (containingIndexes.length === 0) return void 0;
+	const byteBudget = dialect === "mysql" ? 3072 : 1700;
+	const bytesPerCharacter = dialect === "mysql" ? 4 : 1;
+	const defaultLength = dialect === "mysql" ? 191 : 255;
+	return containingIndexes.reduce((length, index) => {
+		const stringColumnCount = index.columns.filter((column) => {
+			const type = fieldsByColumn.get(column)?.type;
+			return type === "string" || Array.isArray(type);
+		}).length;
+		if (stringColumnCount === 0) return length;
+		const nonStringColumnBytes = (index.columns.length - stringColumnCount) * 16;
+		const safeLength = Math.floor(Math.max(1, byteBudget - nonStringColumnBytes) / bytesPerCharacter / stringColumnCount);
+		return Math.min(length, safeLength);
+	}, defaultLength);
+}
+/**
+* Resolves and validates every table index as one portable database schema.
+*
+* Index names are schema-wide because SQLite and PostgreSQL do not scope them
+* to an individual table.
+*/
+function resolveDatabaseSchemaIndexes(sources) {
+	const mergedSourcesByTable = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const existingSource = mergedSourcesByTable.get(source.tableName);
+		if (existingSource) {
+			if (existingSource.indexes.length > 0 || (source.indexes?.length ?? 0) > 0) throw new BetterAuthError(`Database schema resolves more than one indexed logical table to "${source.tableName}". Define table-level indexes through one logical schema key instead of aliasing multiple keys to the same database table.`);
+			Object.assign(existingSource.fields, source.fields);
+			continue;
+		}
+		const mergedSource = {
+			fields: {},
+			indexes: [],
+			tableName: source.tableName
+		};
+		Object.assign(mergedSource.fields, source.fields);
+		mergedSource.indexes.push(...source.indexes ?? []);
+		mergedSourcesByTable.set(source.tableName, mergedSource);
+	}
+	const indexesByTable = /* @__PURE__ */ new Map();
+	const indexOwnerByName = /* @__PURE__ */ new Map();
+	const tableNamesByIdentifier = new Map([...mergedSourcesByTable.keys()].map((tableName) => [getPortableDatabaseIdentifierKey(tableName), tableName]));
+	const fieldIndexOwnerByName = /* @__PURE__ */ new Map();
+	for (const source of mergedSourcesByTable.values()) for (const [fieldName, field] of Object.entries(source.fields)) {
+		if (!field.index && !field.unique) continue;
+		const indexName = getDatabaseFieldIndexName(source.tableName, field.fieldName || fieldName, field.unique ?? false);
+		const identifierKey = getPortableDatabaseIdentifierKey(indexName);
+		if (tableNamesByIdentifier.has(identifierKey)) throw new BetterAuthError(`Database index name "${indexName}" conflicts with a table name. Index and table names must be unique across the schema.`);
+		const existingOwner = fieldIndexOwnerByName.get(identifierKey);
+		if (existingOwner) throw new BetterAuthError(`Database field-level index name "${indexName}" is used by both table "${existingOwner}" and table "${source.tableName}".`);
+		fieldIndexOwnerByName.set(identifierKey, source.tableName);
+	}
+	for (const source of mergedSourcesByTable.values()) {
+		const resolvedIndexes = resolveDatabaseTableIndexes(source);
+		indexesByTable.set(source.tableName, [...resolvedIndexes]);
+		for (const index of resolvedIndexes) {
+			const identifierKey = getPortableDatabaseIdentifierKey(index.name);
+			if (tableNamesByIdentifier.has(identifierKey)) throw new BetterAuthError(`Database index name "${index.name}" conflicts with a table name. Index and table names must be unique across the schema.`);
+			const fieldIndexOwner = fieldIndexOwnerByName.get(identifierKey);
+			if (fieldIndexOwner) throw new BetterAuthError(`Database index name "${index.name}" is already reserved by field-level index metadata on table "${fieldIndexOwner}". Remove the duplicate table-level index or give it a distinct name.`);
+			const indexOwner = indexOwnerByName.get(identifierKey);
+			if (indexOwner && indexOwner !== source.tableName) throw new BetterAuthError(`Database index name "${index.name}" is used by both table "${indexOwner}" and table "${source.tableName}". Index names must be unique across the schema.`);
+			indexOwnerByName.set(identifierKey, source.tableName);
+		}
+	}
+	return indexesByTable;
+}
+//#endregion
+export { getDatabaseFieldIndexName, getDatabaseIndexName, getDatabaseIndexStringLength, getPortableDatabaseIdentifierKey, resolveDatabaseSchemaIndexes, resolveDatabaseTableIndexes };

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

@@ -1,6 +1,12 @@
 import { BetterAuthDBSchema } from "./type.mjs";
+import { ResolvedDBTableIndex } from "./database-index.mjs";
 import { BetterAuthOptions } from "../types/init-options.mjs";
+import "../types/index.mjs";
 //#region src/db/get-tables.d.ts
+declare function getAuthTablesWithResolvedIndexes(options: BetterAuthOptions): {
+  indexesByTable: ReadonlyMap<string, readonly ResolvedDBTableIndex[]>;
+  tables: BetterAuthDBSchema;
+};
 declare const getAuthTables: (options: BetterAuthOptions) => BetterAuthDBSchema;
 //#endregion
-export { getAuthTables };
+export { getAuthTables, getAuthTablesWithResolvedIndexes };

package/dist/db/get-tables.mjs

@@ -1,5 +1,21 @@
+import { resolveDatabaseSchemaIndexes } from "./database-index.mjs";
 //#region src/db/get-tables.ts
-const getAuthTables = (options) => {
+function mergeTableIndexes(...indexCollections) {
+	const indexes = [];
+	const seenIndexDefinitions = /* @__PURE__ */ new Set();
+	for (const index of indexCollections.flatMap((collection) => collection ?? [])) {
+		const definition = JSON.stringify([
+			index.name ?? null,
+			index.fields,
+			index.unique ?? false
+		]);
+		if (seenIndexDefinitions.has(definition)) continue;
+		seenIndexDefinitions.add(definition);
+		indexes.push(index);
+	}
+	return indexes;
+}
+const buildAuthTables = (options) => {
 	const pluginSchema = (options.plugins ?? []).reduce((acc, plugin) => {
 		const schema = plugin.schema;
 		if (!schema) return acc;
@@ -8,6 +24,7 @@ const getAuthTables = (options) => {
 				...acc[key]?.fields,
 				...value.fields
 			},
+			indexes: mergeTableIndexes(acc[key]?.indexes, value.indexes),
 			modelName: value.modelName || key,
 			disableMigrations: value.disableMigration ?? acc[key]?.disableMigrations
 		};
@@ -40,6 +57,7 @@ const getAuthTables = (options) => {
 	const { user, session, account, verification, ...pluginTables } = pluginSchema;
 	const verificationTable = { verification: {
 		modelName: options.verification?.modelName || "verification",
+		indexes: verification?.indexes,
 		fields: {
 			identifier: {
 				type: "string",
@@ -77,6 +95,7 @@ const getAuthTables = (options) => {
 	} };
 	const sessionTable = { session: {
 		modelName: options.session?.modelName || "session",
+		indexes: session?.indexes,
 		fields: {
 			expiresAt: {
 				type: "date",
@@ -115,7 +134,7 @@ const getAuthTables = (options) => {
 				type: "string",
 				fieldName: options.session?.fields?.userId || "userId",
 				references: {
-					model: options.user?.modelName || "user",
+					model: "user",
 					field: "id",
 					onDelete: "cascade"
 				},
@@ -130,6 +149,7 @@ const getAuthTables = (options) => {
 	return {
 		user: {
 			modelName: options.user?.modelName || "user",
+			indexes: user?.indexes,
 			fields: {
 				name: {
 					type: "string",
@@ -177,11 +197,20 @@ const getAuthTables = (options) => {
 		...!options.secondaryStorage || options.session?.storeSessionInDatabase ? sessionTable : {},
 		account: {
 			modelName: options.account?.modelName || "account",
+			indexes: mergeTableIndexes([{
+				fields: ["issuer", "providerAccountId"],
+				unique: true
+			}], account?.indexes),
 			fields: {
-				accountId: {
+				issuer: {
+					type: "string",
+					required: true,
+					fieldName: options.account?.fields?.issuer || "issuer"
+				},
+				providerAccountId: {
 					type: "string",
 					required: true,
-					fieldName: options.account?.fields?.accountId || "accountId"
+					fieldName: options.account?.fields?.providerAccountId || "providerAccountId"
 				},
 				providerId: {
 					type: "string",
@@ -191,7 +220,7 @@ const getAuthTables = (options) => {
 				userId: {
 					type: "string",
 					references: {
-						model: options.user?.modelName || "user",
+						model: "user",
 						field: "id",
 						onDelete: "cascade"
 					},
@@ -262,5 +291,17 @@ const getAuthTables = (options) => {
 		...shouldAddRateLimitTable ? rateLimitTable : {}
 	};
 };
+function getAuthTablesWithResolvedIndexes(options) {
+	const tables = buildAuthTables(options);
+	return {
+		indexesByTable: resolveDatabaseSchemaIndexes(Object.values(tables).filter((table) => !("disableMigrations" in table) || !table.disableMigrations).map((table) => ({
+			fields: table.fields,
+			indexes: "indexes" in table ? table.indexes : void 0,
+			tableName: table.modelName
+		}))),
+		tables
+	};
+}
+const getAuthTables = (options) => getAuthTablesWithResolvedIndexes(options).tables;
 //#endregion
-export { getAuthTables };
+export { getAuthTables, getAuthTablesWithResolvedIndexes };

package/dist/db/index.d.mts

@@ -1,10 +1,10 @@
-import { BaseModelNames, BetterAuthDBSchema, DBFieldAttribute, DBFieldAttributeConfig, DBFieldType, DBPrimitive, InferDBFieldInput, InferDBFieldOutput, InferDBFieldsFromOptions, InferDBFieldsFromOptionsInput, InferDBFieldsFromPlugins, InferDBFieldsFromPluginsInput, InferDBFieldsInput, InferDBFieldsOutput, InferDBValueType, ModelNames, SecondaryStorage } from "./type.mjs";
+import { BaseModelNames, BetterAuthDBSchema, DBFieldAttribute, DBFieldAttributeConfig, DBFieldType, DBPrimitive, DBTableIndex, 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 { Account, AccountKey, BaseAccount, accountSchema, createLocalAccountIssuer, createOAuthAccountIssuer } 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 };
+export { type Account, type AccountKey, 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 DBTableIndex, 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, createLocalAccountIssuer, createOAuthAccountIssuer, getAuthTables, rateLimitSchema, sessionSchema, userSchema, verificationSchema };

package/dist/db/index.mjs

@@ -1,8 +1,8 @@
 import { getAuthTables } from "./get-tables.mjs";
 import { coreSchema } from "./schema/shared.mjs";
-import { accountSchema } from "./schema/account.mjs";
+import { accountSchema, createLocalAccountIssuer, createOAuthAccountIssuer } 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 };
+export { accountSchema, coreSchema, createLocalAccountIssuer, createOAuthAccountIssuer, getAuthTables, rateLimitSchema, sessionSchema, userSchema, verificationSchema };

package/dist/db/internal.d.mts

@@ -0,0 +1,3 @@
+import { BoundedDatabaseIndexDialect, DBTableIndexSource, ResolvedDBTableIndex, getDatabaseFieldIndexName, getDatabaseIndexName, getDatabaseIndexStringLength, getPortableDatabaseIdentifierKey, resolveDatabaseSchemaIndexes, resolveDatabaseTableIndexes } from "./database-index.mjs";
+import { getAuthTablesWithResolvedIndexes } from "./get-tables.mjs";
+export { type BoundedDatabaseIndexDialect, type DBTableIndexSource, type ResolvedDBTableIndex, getAuthTablesWithResolvedIndexes, getDatabaseFieldIndexName, getDatabaseIndexName, getDatabaseIndexStringLength, getPortableDatabaseIdentifierKey, resolveDatabaseSchemaIndexes, resolveDatabaseTableIndexes };

package/dist/db/internal.mjs

@@ -0,0 +1,3 @@
+import { getDatabaseFieldIndexName, getDatabaseIndexName, getDatabaseIndexStringLength, getPortableDatabaseIdentifierKey, resolveDatabaseSchemaIndexes, resolveDatabaseTableIndexes } from "./database-index.mjs";
+import { getAuthTablesWithResolvedIndexes } from "./get-tables.mjs";
+export { getAuthTablesWithResolvedIndexes, getDatabaseFieldIndexName, getDatabaseIndexName, getDatabaseIndexStringLength, getPortableDatabaseIdentifierKey, resolveDatabaseSchemaIndexes, resolveDatabaseTableIndexes };

package/dist/db/plugin.d.mts

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

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

@@ -1,15 +1,16 @@
 import { InferDBFieldsFromOptions, InferDBFieldsFromPlugins } from "../type.mjs";
 import { Prettify } from "../../types/helper.mjs";
 import { BetterAuthOptions } from "../../types/init-options.mjs";
+import "../../types/index.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;
+  issuer: z.ZodString;
+  providerAccountId: z.ZodString;
   userId: z.ZodCoercedString<unknown>;
   accessToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
   refreshToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -20,9 +21,21 @@ declare const accountSchema: z.ZodObject<{
   password: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
 type BaseAccount = z.infer<typeof accountSchema>;
+/** The stable provider-side key used to recognize an account. */
+type AccountKey = Readonly<Pick<BaseAccount, "issuer" | "providerAccountId">>;
+/**
+ * Creates the synthetic issuer used by providers without an issuer of their own.
+ */
+declare function createLocalAccountIssuer(providerId: string): string;
+/**
+ * Creates the synthetic issuer used by OAuth providers without an issuer of
+ * their own. OAuth identities use a distinct namespace so a provider ID
+ * cannot collide with an internal local authentication method.
+ */
+declare function createOAuthAccountIssuer(providerId: string): string;
 /**
  * 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 };
+export { Account, AccountKey, BaseAccount, accountSchema, createLocalAccountIssuer, createOAuthAccountIssuer };

package/dist/db/schema/account.mjs

@@ -3,15 +3,48 @@ import * as z from "zod";
 //#region src/db/schema/account.ts
 const accountSchema = coreSchema.extend({
 	providerId: z.string(),
-	accountId: z.string(),
+	issuer: z.string(),
+	providerAccountId: 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 set of OAuth scopes the user has granted to this account, stored
+	* as a comma-separated list. Represents the accumulated grant rather
+	* than the latest token's `scope` claim, since per RFC 6749 Section 1.5 a
+	* token's scope may be narrower than the user's grant.
+	*/
 	scope: z.string().nullish(),
+	/**
+	* Password is only stored in the credential provider
+	*/
 	password: z.string().nullish()
 });
+function encodeAccountIssuerProviderId(providerId) {
+	return encodeURIComponent(providerId);
+}
+/**
+* Creates the synthetic issuer used by providers without an issuer of their own.
+*/
+function createLocalAccountIssuer(providerId) {
+	return `local:${encodeAccountIssuerProviderId(providerId)}`;
+}
+/**
+* Creates the synthetic issuer used by OAuth providers without an issuer of
+* their own. OAuth identities use a distinct namespace so a provider ID
+* cannot collide with an internal local authentication method.
+*/
+function createOAuthAccountIssuer(providerId) {
+	return `local:oauth:${encodeAccountIssuerProviderId(providerId)}`;
+}
 //#endregion
-export { accountSchema };
+export { accountSchema, createLocalAccountIssuer, createOAuthAccountIssuer };

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

@@ -1,8 +1,8 @@
 import { InferDBFieldsFromOptions, InferDBFieldsFromPlugins } from "../type.mjs";
 import { Prettify } from "../../types/helper.mjs";
 import { BetterAuthOptions } from "../../types/init-options.mjs";
+import "../../types/index.mjs";
 import * as z from "zod";
-
 //#region src/db/schema/rate-limit.d.ts
 declare const rateLimitSchema: z.ZodObject<{
   key: z.ZodString;

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

@@ -1,8 +1,17 @@
 import * as z from "zod";
 //#region src/db/schema/rate-limit.ts
 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()
 });
 //#endregion

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

@@ -1,8 +1,8 @@
 import { InferDBFieldsFromOptions, InferDBFieldsFromPlugins } from "../type.mjs";
 import { Prettify } from "../../types/helper.mjs";
 import { BetterAuthOptions } from "../../types/init-options.mjs";
+import "../../types/index.mjs";
 import * as z from "zod";
-
 //#region src/db/schema/session.d.ts
 declare const sessionSchema: z.ZodObject<{
   id: z.ZodString;

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

@@ -1,5 +1,4 @@
 import * as z from "zod";
-
 //#region src/db/schema/shared.d.ts
 declare const coreSchema: z.ZodObject<{
   id: z.ZodString;

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

@@ -1,8 +1,8 @@
 import { InferDBFieldsFromOptions, InferDBFieldsFromPlugins } from "../type.mjs";
 import { Prettify } from "../../types/helper.mjs";
 import { BetterAuthOptions } from "../../types/init-options.mjs";
+import "../../types/index.mjs";
 import * as z from "zod";
-
 //#region src/db/schema/user.d.ts
 declare const userSchema: z.ZodObject<{
   id: z.ZodString;

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

@@ -1,8 +1,8 @@
 import { InferDBFieldsFromOptions, InferDBFieldsFromPlugins } from "../type.mjs";
 import { Prettify } from "../../types/helper.mjs";
 import { BetterAuthOptions } from "../../types/init-options.mjs";
+import "../../types/index.mjs";
 import * as z from "zod";
-
 //#region src/db/schema/verification.d.ts
 declare const verificationSchema: z.ZodObject<{
   id: z.ZodString;

package/dist/db/type.d.mts

@@ -1,15 +1,15 @@
 import { Awaitable, LiteralString, UnionToIntersection } from "../types/helper.mjs";
 import { BetterAuthOptions } from "../types/init-options.mjs";
+import "../types/index.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
-
 //#region src/db/type.d.ts
 type BaseModelNames = "user" | "account" | "session" | "verification";
 type ModelNames<T extends string = LiteralString> = BaseModelNames | T | "rate-limit";
 type InferDBValueType<T extends DBFieldType> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T extends "date" ? Date : T extends "json" ? Record<string, any> : T extends `${infer U}[]` ? U extends "string" ? string[] : number[] : T extends Array<any> ? T[number] : never;
 type InferDBFieldOutput<T extends DBFieldAttribute> = T["returned"] extends false ? never : T["required"] extends false ? InferDBValueType<T["type"]> | undefined | null : InferDBValueType<T["type"]>;
 type InferDBFieldInput<T extends DBFieldAttribute> = InferDBValueType<T["type"]>;
-type InferDBFieldsInput<Field> = Field extends Record<infer Key, DBFieldAttribute> ? { [key in Key as Field[key]["required"] extends false ? never : Field[key]["defaultValue"] extends string | number | boolean | Date ? never : Field[key]["input"] extends false ? never : key]: InferDBFieldInput<Field[key]> } & { [key in Key as Field[key]["input"] extends false ? never : key]?: InferDBFieldInput<Field[key]> | undefined | null } : {};
-type InferDBFieldsOutput<Fields extends Record<string, DBFieldAttribute>> = Fields extends Record<infer Key, DBFieldAttribute> ? { [key in Key as Fields[key]["returned"] extends false ? never : Fields[key]["required"] extends false ? Fields[key]["defaultValue"] extends boolean | string | number | Date ? key : never : key]: InferDBFieldOutput<Fields[key]> } & { [key in Key as Fields[key]["returned"] extends false ? never : Fields[key]["required"] extends false ? Fields[key]["defaultValue"] extends boolean | string | number | Date ? never : key : never]?: InferDBFieldOutput<Fields[key]> | null } : never;
+type InferDBFieldsInput<Field> = Field extends Record<infer Key, DBFieldAttribute> ? { [key in Key as Field[key]["required"] extends false ? never : Field[key]["defaultValue"] extends string | number | boolean | Date ? never : Field[key]["input"] extends false ? never : key]: InferDBFieldInput<Field[key]>; } & { [key in Key as Field[key]["input"] extends false ? never : key]?: InferDBFieldInput<Field[key]> | undefined | null; } : {};
+type InferDBFieldsOutput<Fields extends Record<string, DBFieldAttribute>> = Fields extends Record<infer Key, DBFieldAttribute> ? { [key in Key as Fields[key]["returned"] extends false ? never : Fields[key]["required"] extends false ? Fields[key]["defaultValue"] extends boolean | string | number | Date ? key : never : key]: InferDBFieldOutput<Fields[key]>; } & { [key in Key as Fields[key]["returned"] extends false ? never : Fields[key]["required"] extends false ? Fields[key]["defaultValue"] extends boolean | string | number | Date ? never : key : never]?: InferDBFieldOutput<Fields[key]> | null; } : never;
 type InferDBFieldsFromOptionsInput<DBOptions extends BetterAuthOptions["session"] | BetterAuthOptions["user"] | BetterAuthOptions["verification"] | BetterAuthOptions["account"] | BetterAuthOptions["rateLimit"]> = DBOptions extends {
   additionalFields: Record<string, DBFieldAttribute>;
 } ? InferDBFieldsInput<DBOptions["additionalFields"]> : {};
@@ -19,12 +19,12 @@ type InferDBFieldsFromOptions<DBOptions extends BetterAuthOptions["session"] | B
 type InferDBFieldsFromPluginsInput<ModelName extends string, Plugins extends unknown[] | undefined> = Plugins extends [] ? {} : Plugins extends [infer P, ...infer Rest] ? P extends {
   schema: { [key in ModelName]: {
     fields: infer Fields;
-  } };
+  }; };
 } ? Fields extends Record<string, DBFieldAttribute> ? UnionToIntersection<InferDBFieldsInput<Fields> & InferDBFieldsFromPluginsInput<ModelName, Rest>> : InferDBFieldsFromPluginsInput<ModelName, Rest> : InferDBFieldsFromPluginsInput<ModelName, Rest> : {};
 type InferDBFieldsFromPlugins<ModelName extends string, Plugins extends unknown[] | undefined> = Plugins extends [] ? {} : Plugins extends [infer P, ...infer Rest] ? P extends {
   schema: { [key in ModelName]: {
     fields: infer Fields;
-  } };
+  }; };
 } ? Fields extends Record<string, DBFieldAttribute> ? UnionToIntersection<InferDBFieldsOutput<Fields> & InferDBFieldsFromPlugins<ModelName, Rest>> : InferDBFieldsFromPlugins<ModelName, Rest> : InferDBFieldsFromPlugins<ModelName, Rest> : {};
 type DBFieldType = "string" | "number" | "boolean" | "date" | "json" | `${"string" | "number"}[]` | Array<LiteralString>;
 type DBPrimitive = string | number | boolean | Date | null | undefined | string[] | number[] | (Record<string, unknown> | unknown[]);
@@ -115,6 +115,15 @@ type DBFieldAttributeConfig = {
 type DBFieldAttribute<T extends DBFieldType = DBFieldType> = {
   type: T;
 } & DBFieldAttributeConfig;
+/** A database index spanning one or more logical schema fields. */
+interface DBTableIndex {
+  /** One to sixteen logical field names included in the index, in index order. */
+  fields: readonly [string, ...string[]];
+  /** Portable database index name of at most 63 UTF-8 bytes. */
+  name?: string | undefined;
+  /** Whether the indexed field tuple must be unique. */
+  unique?: boolean | undefined;
+}
 type BetterAuthDBSchema = Record<string, {
   /**
    * The name of the table in the database
@@ -124,6 +133,8 @@ type BetterAuthDBSchema = Record<string, {
    * The fields of the table
    */
   fields: Record<string, DBFieldAttribute>;
+  /** Table-level indexes, including compound indexes. */
+  indexes?: readonly DBTableIndex[] | undefined;
   /**
    * Whether to disable migrations for this table
    * @default false
@@ -162,17 +173,14 @@ interface SecondaryStorage {
   /**
    * Key to store
    */
-
   key: string,
   /**
    * Value to store
    */
-
   value: string,
   /**
    * Time to live in seconds
    */
-
   ttl?: number | undefined) => Awaitable<void | null | unknown>;
   /**
    *
@@ -181,4 +189,4 @@ interface SecondaryStorage {
   delete: (key: string) => Awaitable<void | null | string>;
 }
 //#endregion
-export { BaseModelNames, BetterAuthDBSchema, DBFieldAttribute, DBFieldAttributeConfig, DBFieldType, DBPrimitive, InferDBFieldInput, InferDBFieldOutput, InferDBFieldsFromOptions, InferDBFieldsFromOptionsInput, InferDBFieldsFromPlugins, InferDBFieldsFromPluginsInput, InferDBFieldsInput, InferDBFieldsOutput, InferDBValueType, ModelNames, SecondaryStorage };
+export { BaseModelNames, BetterAuthDBSchema, DBFieldAttribute, DBFieldAttributeConfig, DBFieldType, DBPrimitive, DBTableIndex, InferDBFieldInput, InferDBFieldOutput, InferDBFieldsFromOptions, InferDBFieldsFromOptionsInput, InferDBFieldsFromPlugins, InferDBFieldsFromPluginsInput, InferDBFieldsInput, InferDBFieldsOutput, InferDBValueType, ModelNames, SecondaryStorage };