@better-auth/kysely-adapter 1.7.1 → 1.7.3

package/dist/{d1-sqlite-dialect-BZmaVTp8.mjs → d1-sqlite-dialect-D4qp4-wW.mjs}

@@ -1,6 +1,36 @@
 import { n as DEFAULT_MIGRATION_TABLE, t as DEFAULT_MIGRATION_LOCK_TABLE } from "./kysely-migration-tables-DFfmKhq-.mjs";
 import { SqliteAdapter, SqliteQueryCompiler } from "kysely";
 //#region src/d1-sqlite-dialect.ts
+function quoteSqliteStringLiteral(value) {
+	return `'${value.replaceAll("'", "''")}'`;
+}
+function createD1IndexIntrospector(database) {
+	return async (tableNames) => {
+		if (tableNames.length === 0) return [];
+		const indexes = (await database.batch(tableNames.map((tableName) => database.prepare(`PRAGMA index_list(${quoteSqliteStringLiteral(tableName)})`)))).flatMap((indexList, tablePosition) => {
+			const tableName = tableNames[tablePosition];
+			if (!tableName) return [];
+			return indexList.results.map((index) => ({
+				...index,
+				tableName
+			}));
+		});
+		if (indexes.length === 0) return [];
+		const indexColumns = await database.batch(indexes.map((index) => database.prepare(`PRAGMA index_info(${quoteSqliteStringLiteral(index.name)})`)));
+		return indexes.map((index, indexPosition) => ({
+			columns: (indexColumns[indexPosition]?.results ?? []).map((column) => ({
+				fullLength: column.name !== null,
+				name: column.name,
+				position: column.seqno
+			})),
+			name: index.name,
+			partial: index.partial !== 0,
+			table: index.tableName,
+			unique: index.unique !== 0,
+			valid: true
+		}));
+	};
+}
 var D1SqliteAdapter = class extends SqliteAdapter {};
 var D1SqliteDriver = class {
 	#config;
@@ -111,4 +141,4 @@ var D1SqliteDialect = class {
 	}
 };
 //#endregion
-export { D1SqliteDialect };
+export { D1SqliteDialect, createD1IndexIntrospector };

package/dist/index.d.mts

@@ -1,15 +1,46 @@
-import { Kysely } from "kysely";
+import { Kysely, TableMetadata } from "kysely";
 import { DBAdapter, DBAdapterDebugLogOption } from "@better-auth/core/db/adapter";
+import { ExpectedSchema, IntrospectedTable } from "@better-auth/core/db/internal";
 import { BetterAuthOptions } from "@better-auth/core";
 
 //#region src/types.d.ts
 type KyselyDatabaseType = "postgres" | "mysql" | "sqlite" | "mssql";
+/**
+ * Metadata for a column that participates in a database index.
+ */
+interface DatabaseIndexColumnMetadata {
+  /**
+   * Whether the index covers the complete column value rather than a prefix.
+   */
+  readonly fullLength: boolean;
+  readonly name: string | null;
+  readonly position: number;
+}
+/**
+ * Database-agnostic metadata for an index.
+ */
+interface DatabaseIndexMetadata {
+  readonly columns: readonly DatabaseIndexColumnMetadata[];
+  readonly name: string;
+  readonly partial: boolean;
+  readonly table: string;
+  readonly unique: boolean;
+  /**
+   * Whether the database reports the index as complete and usable.
+   */
+  readonly valid: boolean;
+}
+/**
+ * Reads normalized index metadata for the provided database tables.
+ */
+type DatabaseIndexIntrospector = (tableNames: readonly string[]) => Promise<readonly DatabaseIndexMetadata[]>;
 //#endregion
 //#region src/dialect.d.ts
 declare function getKyselyDatabaseType(db: BetterAuthOptions["database"]): KyselyDatabaseType | null;
 declare const createKyselyAdapter: (config: BetterAuthOptions) => Promise<{
   kysely: Kysely<any> | null;
   databaseType: KyselyDatabaseType | null;
+  introspectIndexes: DatabaseIndexIntrospector | undefined;
   transaction: boolean | undefined;
 }>;
 //#endregion
@@ -55,4 +86,24 @@ interface KyselyAdapterConfig {
 }
 declare const kyselyAdapter: (db: Kysely<any>, config?: KyselyAdapterConfig | undefined) => (options: BetterAuthOptions) => DBAdapter<BetterAuthOptions>;
 //#endregion
-export { KyselyDatabaseType, createKyselyAdapter, getKyselyDatabaseType, kyselyAdapter };
+//#region src/schema-check.d.ts
+/**
+ * Converts Kysely table metadata into the shape `diffSchema` compares.
+ */
+declare function toIntrospectedTables(tables: readonly TableMetadata[]): IntrospectedTable[];
+/**
+ * The expected schema in the identifiers the connection sends. A plugin that
+ * renames identifiers, such as `CamelCasePlugin`, does so in `transformQuery`,
+ * so compiling one select per table through the connection yields the names
+ * the database is asked for. Without such a plugin the schema is unchanged.
+ */
+declare function toPhysicalSchema(db: Kysely<unknown>, expected: ExpectedSchema): ExpectedSchema;
+/**
+ * The default schema for migration tooling. Let PostgreSQL resolve role
+ * names and privileges, retaining the legacy public fallback when none exists.
+ * Runtime validation uses the effective search path instead of this fallback.
+ */
+declare function getPostgresSchema(db: Kysely<unknown>): Promise<string>;
+declare function getMssqlSchema(db: Kysely<unknown>): Promise<string>;
+//#endregion
+export { DatabaseIndexColumnMetadata, DatabaseIndexIntrospector, DatabaseIndexMetadata, KyselyDatabaseType, createKyselyAdapter, getKyselyDatabaseType, getMssqlSchema, getPostgresSchema, kyselyAdapter, toIntrospectedTables, toPhysicalSchema };

package/dist/index.mjs

@@ -1,5 +1,6 @@
-import { Kysely, MssqlDialect, MysqlDialect, PostgresDialect, SqliteDialect, sql } from "kysely";
+import { ColumnNode, Kysely, MssqlDialect, MysqlDialect, PostgresDialect, ReferenceNode, SelectQueryNode, SqliteDialect, TableNode, sql } from "kysely";
 import { createAdapterFactory } from "@better-auth/core/db/adapter";
+import { checksSchema, createSchemaCheck, diffSchema, getExpectedSchema, registerSchemaCheck } from "@better-auth/core/db/internal";
 import { logger } from "@better-auth/core/env";
 import { capitalizeFirstLetter } from "@better-auth/core/utils/string";
 //#region src/dialect.ts
@@ -25,19 +26,23 @@ const createKyselyAdapter = async (config) => {
 	if (!db) return {
 		kysely: null,
 		databaseType: null,
+		introspectIndexes: void 0,
 		transaction: void 0
 	};
 	if ("db" in db) return {
 		kysely: db.db,
 		databaseType: db.type,
+		introspectIndexes: void 0,
 		transaction: db.transaction
 	};
 	if ("dialect" in db) return {
 		kysely: new Kysely({ dialect: db.dialect }),
 		databaseType: db.type,
+		introspectIndexes: void 0,
 		transaction: db.transaction
 	};
 	let dialect = void 0;
+	let introspectIndexes = void 0;
 	let transaction = void 0;
 	const databaseType = getKyselyDatabaseType(db);
 	if ("createDriver" in db) dialect = db;
@@ -77,13 +82,15 @@ const createKyselyAdapter = async (config) => {
 		}
 	}
 	if ("batch" in db && "exec" in db && "prepare" in db) {
-		const { D1SqliteDialect } = await import("./d1-sqlite-dialect-BZmaVTp8.mjs");
+		const { createD1IndexIntrospector, D1SqliteDialect } = await import("./d1-sqlite-dialect-D4qp4-wW.mjs");
 		dialect = new D1SqliteDialect({ database: db });
+		introspectIndexes = createD1IndexIntrospector(db);
 		transaction = false;
 	}
 	return {
 		kysely: dialect ? new Kysely({ dialect }) : null,
 		databaseType,
+		introspectIndexes,
 		transaction
 	};
 };
@@ -135,6 +142,105 @@ function insensitiveNe(columnRef, value) {
 	};
 }
 //#endregion
+//#region src/schema-check.ts
+/**
+* Converts Kysely table metadata into the shape `diffSchema` compares.
+*/
+function toIntrospectedTables(tables) {
+	return tables.map((table) => ({
+		name: table.name,
+		schema: table.schema,
+		columns: table.columns.map((column) => ({
+			name: column.name,
+			nullable: column.isNullable,
+			hasDefault: column.hasDefaultValue || column.isAutoIncrementing
+		}))
+	}));
+}
+/**
+* The expected schema in the identifiers the connection sends. A plugin that
+* renames identifiers, such as `CamelCasePlugin`, does so in `transformQuery`,
+* so compiling one select per table through the connection yields the names
+* the database is asked for. Without such a plugin the schema is unchanged.
+*/
+function toPhysicalSchema(db, expected) {
+	const physical = {};
+	for (const [table, definition] of Object.entries(expected)) {
+		const entries = Object.entries(definition.fields);
+		const sent = sentIdentifiers(db, table, [definition.idColumn ?? "id", ...entries.map(([column]) => column)]);
+		const fields = {};
+		entries.forEach(([column, attribute], index) => {
+			fields[sent.columns[index + 1] ?? column] = attribute;
+		});
+		physical[sent.table] = {
+			...definition,
+			fields,
+			schema: sent.schema ?? definition.schema,
+			...sent.columns[0] !== "id" && { idColumn: sent.columns[0] }
+		};
+	}
+	return physical;
+}
+/**
+* Compiles a select of `columns` from `table` and reads the identifiers back
+* out of the transformed query, including the schema a plugin such as
+* `WithSchemaPlugin` qualifies the table with. A node the query does not
+* carry in the expected shape leaves its identifier undefined.
+*/
+function sentIdentifiers(db, table, columns) {
+	const { query } = db.selectFrom(table).select(columns).compile();
+	if (!SelectQueryNode.is(query)) return {
+		table,
+		columns: []
+	};
+	const from = query.from?.froms[0];
+	const sentTable = from && TableNode.is(from) ? from.table : void 0;
+	return {
+		schema: sentTable?.schema?.name,
+		table: sentTable?.identifier.name ?? table,
+		columns: (query.selections ?? []).map(({ selection }) => ReferenceNode.is(selection) && ColumnNode.is(selection.column) ? selection.column.column.name : void 0)
+	};
+}
+/**
+* The default schema for migration tooling. Let PostgreSQL resolve role
+* names and privileges, retaining the legacy public fallback when none exists.
+* Runtime validation uses the effective search path instead of this fallback.
+*/
+async function getPostgresSchema(db) {
+	return (await sql`
+		SELECT pg_catalog.current_schema() AS schema
+	`.execute(db.withoutPlugins())).rows[0]?.schema ?? "public";
+}
+async function getMssqlSchema(db) {
+	return (await sql`
+		SELECT SCHEMA_NAME() AS "schemaName"
+	`.execute(db.withoutPlugins())).rows[0]?.schemaName || "dbo";
+}
+async function schemaSearchPath(db, dbType) {
+	if (dbType === "postgres") return (await sql`
+			SELECT pg_catalog.current_schemas(true)::text[] AS schemas
+		`.execute(db.withoutPlugins())).rows[0]?.schemas ?? [];
+	if (dbType === "mssql") return [await getMssqlSchema(db), "dbo"];
+}
+/**
+* Compares the live database with the tables this configuration writes. Both
+* sides are read in the identifiers the connection sends: a plugin that
+* renames identifiers or qualifies them with a schema is applied to the
+* expected side, and introspection reports what the database stores.
+*/
+async function findSchemaProblems(db, dbType, expected) {
+	const physical = toPhysicalSchema(db, expected);
+	return db.connection().execute(async (connection) => {
+		const searchPath = await schemaSearchPath(connection, dbType);
+		const tables = toIntrospectedTables(await connection.introspection.getTables());
+		for (const [name, table] of Object.entries(physical)) {
+			if (table.schema !== void 0 || !searchPath) continue;
+			table.schema = searchPath.find((schema) => tables.some((candidate) => candidate.name === name && candidate.schema === schema)) ?? "";
+		}
+		return diffSchema(physical, tables);
+	});
+}
+//#endregion
 //#region src/kysely-adapter.ts
 const kyselyAdapter = (db, config) => {
 	let lazyOptions = null;
@@ -583,8 +689,10 @@ const kyselyAdapter = (db, config) => {
 	const adapter = createAdapterFactory(adapterOptions);
 	return (options) => {
 		lazyOptions = options;
-		return adapter(options);
+		const instance = adapter(options);
+		if (checksSchema(options)) registerSchemaCheck(instance, createSchemaCheck(() => findSchemaProblems(db, config?.type, getExpectedSchema(options, { usePlural: config?.usePlural })), "database", options.database));
+		return instance;
 	};
 };
 //#endregion
-export { createKyselyAdapter, getKyselyDatabaseType, kyselyAdapter };
+export { createKyselyAdapter, getKyselyDatabaseType, getMssqlSchema, getPostgresSchema, kyselyAdapter, toIntrospectedTables, toPhysicalSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@better-auth/kysely-adapter",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "description": "Kysely adapter for Better Auth",
   "type": "module",
   "license": "MIT",
@@ -42,7 +42,7 @@
   "peerDependencies": {
     "@better-auth/utils": "0.4.2",
     "kysely": "^0.28.17 || ^0.29.0",
-    "@better-auth/core": "^1.7.1"
+    "@better-auth/core": "^1.7.3"
   },
   "peerDependenciesMeta": {
     "kysely": {
@@ -52,10 +52,12 @@
   "devDependencies": {
     "@better-auth/utils": "0.4.2",
     "@cloudflare/workers-types": "^4.20250121.0",
+    "@types/pg": "^8.20.0",
     "kysely": "^0.28.17 || ^0.29.0",
+    "pg": "^8.0.0",
     "tsdown": "0.21.10",
     "typescript": "^6.0.3",
-    "@better-auth/core": "1.7.1"
+    "@better-auth/core": "1.7.3"
   },
   "scripts": {
     "build": "tsdown",