better-auth-studio 1.1.3-beta.49 → 1.1.3-beta.51

package/README.md

@@ -29,7 +29,7 @@ For the hosted version: **[better-auth.build](https://better-auth.build)**
 
 ### Installation
 
-📖 **[Documentation](https://better-auth-studio.vercel.app)**
+📖 **[Documentation](https://better-auth.studio)**
 
 **Recommended: Install as a dev dependency** (for project-specific versions):
 
@@ -81,7 +81,7 @@ Before using Better Auth Studio, ensure you have:
 
 - **Node.js** (v18 or higher)
 - **A Better Auth project** with a valid `auth.ts` configuration file
-- **Database setup** (Prisma, Drizzle, or SQLite)
+- **Database setup** (Prisma, Drizzle, Kysely, or SQLite)
 
 ## 🔧 Configuration
 
@@ -91,9 +91,10 @@ Better Auth Studio automatically detects and works with:
 
 - **Prisma** (`prismaAdapter`)
 - **Drizzle** (`drizzleAdapter`)
+- **Kysely** (`database: { db, type }`)
 - **SQLite** (`new Database()` from better-sqlite3)
-- **PostgreSQL** (via Prisma or Drizzle)
-- **MySQL** (via Prisma or Drizzle)
+- **PostgreSQL** (via Prisma, Drizzle, or Kysely)
+- **MySQL** (via Prisma, Drizzle, or Kysely)
 
 ### Example Configuration Files
 
@@ -131,6 +132,31 @@ export const auth = betterAuth({
 });
 ```
 
+#### Kysely Setup
+
+```typescript
+// auth.ts
+import { betterAuth } from "better-auth";
+import { Kysely, PostgresDialect } from "kysely";
+import { Pool } from "pg";
+
+const db = new Kysely<any>({
+  dialect: new PostgresDialect({
+    pool: new Pool({
+      connectionString: process.env.DATABASE_URL,
+    }),
+  }),
+});
+
+export const auth = betterAuth({
+  database: {
+    db,
+    type: "postgres", // or "mysql", "sqlite", "mssql"
+  },
+  // ... other config
+});
+```
+
 #### SQLite Setup
 
 ```typescript
@@ -158,7 +184,7 @@ export const auth = betterAuth({
 - **Delete users** - Remove users from the system
 - **Bulk operations** - Seed multiple test users
 - **User details** - View user profiles, and accounts
-- **Last seen** - When events are enabled, the studio injects an optional `lastSeenAt` field on the user model and updates it on each sign-in or session creation. Run your database migration (e.g. `prisma migrate dev` or Drizzle push) to add the `lastSeenAt` column to the user table.
+- **Last seen** - When events are enabled, the studio injects an optional `lastSeenAt` field on the user model and updates it on each sign-in or session creation. Run your database migration (e.g. `prisma migrate dev`, Drizzle push, or a Kysely migration) to add the `lastSeenAt` column to the user table.
 
 ### 🏢 Organization Management
 

package/dist/cli.js

@@ -281,6 +281,12 @@ program
                 else if (content.includes("prismaAdapter")) {
                     databaseInfo = "Prisma";
                 }
+                else if (content.includes("kyselyAdapter") ||
+                    content.includes("Kysely") ||
+                    content.includes('from "kysely"') ||
+                    content.includes("from 'kysely'")) {
+                    databaseInfo = "Kysely";
+                }
                 else if (authConfig.database.adapter && authConfig.database.provider) {
                     const adapter = authConfig.database.adapter;
                     const adapterName = adapter.charAt(0).toUpperCase() + adapter.slice(1);

package/dist/core/handler.js

@@ -33,6 +33,7 @@ export async function initializeEventIngestionAndHooks(config) {
                 case "postgres":
                 case "prisma":
                 case "drizzle":
+                case "kysely":
                     try {
                         provider = createPostgresProvider({
                             client: config.events.client,

package/dist/providers/events/helpers.d.ts

@@ -1,9 +1,10 @@
 import type { AuthEvent, EventIngestionProvider } from "../../types/events.js";
+type PostgresProviderClientType = "postgres" | "prisma" | "drizzle" | "kysely";
 export declare function createPostgresProvider(options: {
     client: any;
     tableName?: string;
     schema?: string;
-    clientType?: "postgres" | "prisma" | "drizzle";
+    clientType?: PostgresProviderClientType;
 }): EventIngestionProvider;
 export declare function createSqliteProvider(options: {
     client: any;
@@ -33,3 +34,4 @@ export declare function createStorageProvider(options: {
     adapter: any;
     tableName?: string;
 }): EventIngestionProvider;
+export {};

package/dist/providers/events/helpers.js

@@ -1,3 +1,37 @@
+function isKyselyClient(client, clientType) {
+    const hasExecuteQuery = typeof client?.executeQuery === "function";
+    if (clientType === "kysely") {
+        return hasExecuteQuery;
+    }
+    return hasExecuteQuery && typeof client?.selectFrom === "function";
+}
+function createKyselyCompiledQuery(sql, parameters = []) {
+    return {
+        sql,
+        parameters,
+        queryId: { queryId: `bas_${Date.now()}_${Math.random().toString(36).slice(2)}` },
+    };
+}
+async function executeKyselyQuery(client, query, params = []) {
+    return await client.executeQuery(createKyselyCompiledQuery(query, params));
+}
+function getEventInsertParams(event) {
+    return [
+        event.id,
+        event.type,
+        event.timestamp,
+        event.status || "success",
+        event.userId || null,
+        event.sessionId || null,
+        event.organizationId || null,
+        JSON.stringify(event.metadata || {}),
+        event.ipAddress || null,
+        event.userAgent || null,
+        event.source,
+        event.display?.message || null,
+        event.display?.severity || null,
+    ];
+}
 export function createPostgresProvider(options) {
     const { client, tableName = "auth_events", schema = "public", clientType } = options;
     // Validate client is provided
@@ -18,12 +52,15 @@ export function createPostgresProvider(options) {
     const hasExecuteRaw = client?.$executeRaw;
     const hasExecute = client?.execute;
     const hasUnsafe = actualClient?.unsafe || client?.$client?.unsafe || client?.unsafe;
-    if (!hasQuery && !hasExecuteRaw && !hasExecute && !hasUnsafe) {
+    const hasKysely = isKyselyClient(client, clientType);
+    if (!hasQuery && !hasExecuteRaw && !hasExecute && !hasUnsafe && !hasKysely) {
         const errorMessage = clientType === "prisma"
             ? "Invalid Prisma client. Client must have a `$executeRaw` method."
             : clientType === "drizzle"
                 ? "Invalid Drizzle client. Drizzle instance must wrap a postgres-js (with `unsafe` method) or pg (with `query` method) client."
-                : "Invalid Postgres client. Client must have either a `query` method (pg Pool/Client) or `$executeRaw` method (Prisma client).";
+                : clientType === "kysely"
+                    ? "Invalid Kysely client. Client must have an `executeQuery` method."
+                    : "Invalid Postgres client. Client must have either a `query` method (pg Pool/Client), `$executeRaw` method (Prisma client), or `executeQuery` method (Kysely client).";
         throw new Error(errorMessage);
     }
     // Ensure table exists
@@ -39,6 +76,11 @@ export function createPostgresProvider(options) {
                     return await client.$executeRawUnsafe(query);
                 };
             }
+            else if (hasKysely) {
+                executeQuery = async (query) => {
+                    return await executeKyselyQuery(client, query);
+                };
+            }
             else if (clientType === "drizzle") {
                 // Drizzle client - use $client which exposes the underlying client
                 if (actualClient?.unsafe) {
@@ -69,7 +111,7 @@ export function createPostgresProvider(options) {
                 };
             }
             else {
-                throw new Error(`Postgres client doesn't support $executeRaw or query method. Available properties: ${Object.keys(client).join(", ")}`);
+                throw new Error(`Postgres client doesn't support $executeRaw, executeQuery, or query method. Available properties: ${Object.keys(client).join(", ")}`);
             }
             // Use CREATE TABLE IF NOT EXISTS (simpler and more reliable)
             const createTableQuery = `
@@ -141,7 +183,32 @@ export function createPostgresProvider(options) {
     return {
         async ingest(event) {
             await ensureTableSync();
-            if (clientType === "prisma" || client.$executeRaw) {
+            if (hasKysely) {
+                try {
+                    await executeKyselyQuery(client, `INSERT INTO ${schema}.${tableName}
+             (id, type, timestamp, status, user_id, session_id, organization_id, metadata, ip_address, user_agent, source, display_message, display_severity)
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`, getEventInsertParams(event));
+                }
+                catch (error) {
+                    console.error(`Failed to insert event (${event.type}) into ${schema}.${tableName}:`, error);
+                    if (error.code === "42P01") {
+                        tableEnsured = false;
+                        await ensureTableSync();
+                        try {
+                            await executeKyselyQuery(client, `INSERT INTO ${schema}.${tableName}
+                 (id, type, timestamp, status, user_id, session_id, organization_id, metadata, ip_address, user_agent, source, display_message, display_severity)
+                 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`, getEventInsertParams(event));
+                            return;
+                        }
+                        catch (retryError) {
+                            console.error(`Retry after table creation also failed:`, retryError);
+                            throw retryError;
+                        }
+                    }
+                    throw error;
+                }
+            }
+            else if (clientType === "prisma" || client.$executeRaw) {
                 const query = `
           INSERT INTO ${schema}.${tableName} 
           (id, type, timestamp, status, user_id, session_id, organization_id, metadata, ip_address, user_agent, source, display_message, display_severity)
@@ -176,7 +243,7 @@ export function createPostgresProvider(options) {
                 if (useUnsafe) {
                     // postgres-js client - use unsafe() for raw SQL
                     const query = `
-            INSERT INTO ${schema}.${tableName} 
+            INSERT INTO ${schema}.${tableName}
             (id, type, timestamp, status, user_id, session_id, organization_id, metadata, ip_address, user_agent, source, display_message, display_severity)
             VALUES ('${event.id}'::uuid, '${event.type}', '${event.timestamp.toISOString()}', '${event.status || "success"}', ${event.userId ? `'${event.userId.replace(/'/g, "''")}'` : "NULL"}, ${event.sessionId ? `'${event.sessionId.replace(/'/g, "''")}'` : "NULL"}, ${event.organizationId ? `'${event.organizationId.replace(/'/g, "''")}'` : "NULL"}, '${JSON.stringify(event.metadata || {}).replace(/'/g, "''")}'::jsonb, ${event.ipAddress ? `'${event.ipAddress.replace(/'/g, "''")}'` : "NULL"}, ${event.userAgent ? `'${event.userAgent.replace(/'/g, "''")}'` : "NULL"}, '${event.source}', ${event.display?.message ? `'${event.display.message.replace(/'/g, "''")}'` : "NULL"}, ${event.display?.severity ? `'${event.display.severity}'` : "NULL"})
           `;
@@ -205,21 +272,7 @@ export function createPostgresProvider(options) {
                     try {
                         await queryClient.query(`INSERT INTO ${schema}.${tableName} 
                (id, type, timestamp, status, user_id, session_id, organization_id, metadata, ip_address, user_agent, source, display_message, display_severity)
-               VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`, [
-                            event.id,
-                            event.type,
-                            event.timestamp,
-                            event.status || "success",
-                            event.userId || null,
-                            event.sessionId || null,
-                            event.organizationId || null,
-                            JSON.stringify(event.metadata || {}),
-                            event.ipAddress || null,
-                            event.userAgent || null,
-                            event.source,
-                            event.display?.message || null,
-                            event.display?.severity || null,
-                        ]);
+               VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`, [...getEventInsertParams(event)]);
                     }
                     catch (error) {
                         console.error(`Failed to insert event (${event.type}) into ${schema}.${tableName}:`, error);
@@ -229,21 +282,7 @@ export function createPostgresProvider(options) {
                             try {
                                 await queryClient.query(`INSERT INTO ${schema}.${tableName} 
                    (id, type, timestamp, status, user_id, session_id, organization_id, metadata, ip_address, user_agent, source, display_message, display_severity)
-                   VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`, [
-                                    event.id,
-                                    event.type,
-                                    event.timestamp,
-                                    event.status || "success",
-                                    event.userId || null,
-                                    event.sessionId || null,
-                                    event.organizationId || null,
-                                    JSON.stringify(event.metadata || {}),
-                                    event.ipAddress || null,
-                                    event.userAgent || null,
-                                    event.source,
-                                    event.display?.message || null,
-                                    event.display?.severity || null,
-                                ]);
+                   VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`, [...getEventInsertParams(event)]);
                                 return;
                             }
                             catch (retryError) {
@@ -271,7 +310,34 @@ export function createPostgresProvider(options) {
                 return;
             await ensureTableSync();
             // Support Prisma client ($executeRaw), Drizzle instance, or standard pg client (query)
-            if (clientType === "prisma" || client.$executeRaw) {
+            if (hasKysely) {
+                const PARAMS_PER_EVENT = 13;
+                const MAX_PARAMS = 65535;
+                const CHUNK_SIZE = Math.floor(MAX_PARAMS / PARAMS_PER_EVENT) - 1;
+                for (let chunkStart = 0; chunkStart < events.length; chunkStart += CHUNK_SIZE) {
+                    const chunk = events.slice(chunkStart, chunkStart + CHUNK_SIZE);
+                    const values = chunk
+                        .map((_, i) => {
+                        const base = i * PARAMS_PER_EVENT;
+                        return `($${base + 1}, $${base + 2}, $${base + 3}, $${base + 4}, $${base + 5}, $${base + 6}, $${base + 7}, $${base + 8}, $${base + 9}, $${base + 10}, $${base + 11}, $${base + 12}, $${base + 13})`;
+                    })
+                        .join(", ");
+                    const query = `
+            INSERT INTO ${schema}.${tableName}
+            (id, type, timestamp, status, user_id, session_id, organization_id, metadata, ip_address, user_agent, source, display_message, display_severity)
+            VALUES ${values}
+          `;
+                    const params = chunk.flatMap((event) => getEventInsertParams(event));
+                    try {
+                        await executeKyselyQuery(client, query, params);
+                    }
+                    catch (error) {
+                        console.error(`Failed to insert batch chunk (${chunk.length} events) into ${schema}.${tableName}:`, error);
+                        throw error;
+                    }
+                }
+            }
+            else if (clientType === "prisma" || client.$executeRaw) {
                 // Prisma client - use $executeRawUnsafe for batch inserts
                 const CHUNK_SIZE = 500; // Reasonable chunk size for string-based queries
                 for (let i = 0; i < events.length; i += CHUNK_SIZE) {
@@ -339,21 +405,7 @@ export function createPostgresProvider(options) {
               (id, type, timestamp, status, user_id, session_id, organization_id, metadata, ip_address, user_agent, source, display_message, display_severity)
               VALUES ${values}
             `;
-                        const params = chunk.flatMap((event) => [
-                            event.id,
-                            event.type,
-                            event.timestamp,
-                            event.status || "success",
-                            event.userId || null,
-                            event.sessionId || null,
-                            event.organizationId || null,
-                            JSON.stringify(event.metadata || {}),
-                            event.ipAddress || null,
-                            event.userAgent || null,
-                            event.source,
-                            event.display?.message || null,
-                            event.display?.severity || null,
-                        ]);
+                        const params = chunk.flatMap((event) => getEventInsertParams(event));
                         try {
                             await batchQueryClient.query(query, params);
                         }
@@ -401,6 +453,11 @@ export function createPostgresProvider(options) {
                     }
                 };
             }
+            else if (hasKysely) {
+                queryFn = async (query, params) => {
+                    return await executeKyselyQuery(client, query, params || []);
+                };
+            }
             else if (client.query) {
                 // Standard pg client (Pool or Client)
                 queryFn = async (query, params) => {
@@ -427,6 +484,9 @@ export function createPostgresProvider(options) {
                         .replace("$2", `'${tableName}'`);
                     checkResult = await client.$queryRawUnsafe(prismaQuery);
                 }
+                else if (hasKysely) {
+                    checkResult = await queryFn(checkTableQuery, [schema, tableName]);
+                }
                 else {
                     // Standard pg client
                     checkResult = await queryFn(checkTableQuery, [schema, tableName]);