better-auth-studio 1.1.2-beta.2 → 1.1.2-beta.21

package/dist/utils/auth-callbacks-injector.d.ts

@@ -1,3 +1,3 @@
-import type { StudioConfig } from '../types/handler.js';
-export declare function wrapAuthCallbacks(auth: any, eventsConfig: StudioConfig['events']): void;
+import type { StudioConfig } from "../types/handler.js";
+export declare function wrapAuthCallbacks(auth: any, eventsConfig: StudioConfig["events"]): void;
 //# sourceMappingURL=auth-callbacks-injector.d.ts.map

package/dist/utils/auth-callbacks-injector.js

@@ -1,4 +1,4 @@
-import { emitEvent } from './event-ingestion.js';
+import { emitEvent } from "./event-ingestion.js";
 /**
  * Helper to extract request info from Better Auth request object
  */
@@ -12,18 +12,18 @@ function getRequestInfo(request) {
                     headersObj[key] = value;
                 });
                 ip =
-                    request.headers.get('x-forwarded-for') || request.headers.get('x-real-ip') || undefined;
+                    request.headers.get("x-forwarded-for") || request.headers.get("x-real-ip") || undefined;
             }
             else if (request.headers) {
-                if (typeof request.headers.get === 'function') {
+                if (typeof request.headers.get === "function") {
                     ip =
-                        request.headers.get('x-forwarded-for') || request.headers.get('x-real-ip') || undefined;
+                        request.headers.get("x-forwarded-for") || request.headers.get("x-real-ip") || undefined;
                     request.headers.forEach?.((value, key) => {
                         headersObj[key] = value;
                     });
                 }
                 else {
-                    ip = request.headers['x-forwarded-for'] || request.headers['x-real-ip'] || undefined;
+                    ip = request.headers["x-forwarded-for"] || request.headers["x-real-ip"] || undefined;
                     Object.entries(request.headers).forEach(([key, value]) => {
                         headersObj[key] = String(value);
                     });
@@ -53,7 +53,7 @@ export function wrapAuthCallbacks(auth, eventsConfig) {
                 const data = eventData(args);
                 const requestInfo = getRequestInfo(args[args.length - 1]);
                 emitEvent(eventType, {
-                    status: 'success',
+                    status: "success",
                     ...data,
                     request: requestInfo,
                 }, capturedConfig).catch(() => { });
@@ -62,7 +62,7 @@ export function wrapAuthCallbacks(auth, eventsConfig) {
         const deleteUserConfig = auth.options?.user?.deleteUser || auth.user?.deleteUser;
         if (deleteUserConfig && !deleteUserConfig.__studio_wrapped) {
             const originalSendDeleteVerification = deleteUserConfig.sendDeleteAccountVerification;
-            deleteUserConfig.sendDeleteAccountVerification = wrapCallback(originalSendDeleteVerification, 'user.delete_verification_requested', (args) => {
+            deleteUserConfig.sendDeleteAccountVerification = wrapCallback(originalSendDeleteVerification, "user.delete_verification_requested", (args) => {
                 const data = args[0];
                 const user = data?.user;
                 return {
@@ -76,7 +76,7 @@ export function wrapAuthCallbacks(auth, eventsConfig) {
             });
             // Wrap afterDelete callback
             const originalAfterDelete = deleteUserConfig.afterDelete;
-            deleteUserConfig.afterDelete = wrapCallback(originalAfterDelete, 'user.deleted', (args) => {
+            deleteUserConfig.afterDelete = wrapCallback(originalAfterDelete, "user.deleted", (args) => {
                 const user = args[0];
                 return {
                     userId: user?.id,
@@ -91,7 +91,7 @@ export function wrapAuthCallbacks(auth, eventsConfig) {
         const emailVerificationConfig = auth.options?.emailVerification || auth.emailVerification;
         if (emailVerificationConfig && !emailVerificationConfig.__studio_wrapped) {
             const originalOnEmailVerification = emailVerificationConfig.onEmailVerification;
-            emailVerificationConfig.onEmailVerification = wrapCallback(originalOnEmailVerification, 'user.email_verified', (args) => {
+            emailVerificationConfig.onEmailVerification = wrapCallback(originalOnEmailVerification, "user.email_verified", (args) => {
                 const user = args[0];
                 return {
                     userId: user?.id,
@@ -107,7 +107,7 @@ export function wrapAuthCallbacks(auth, eventsConfig) {
         const emailAndPasswordConfig = auth.options?.emailAndPassword || auth.emailAndPassword;
         if (emailAndPasswordConfig && !emailAndPasswordConfig.__studio_wrapped) {
             const originalOnPasswordChange = emailAndPasswordConfig.onPasswordChange;
-            emailAndPasswordConfig.onPasswordChange = wrapCallback(originalOnPasswordChange, 'user.password_changed', (args) => {
+            emailAndPasswordConfig.onPasswordChange = wrapCallback(originalOnPasswordChange, "user.password_changed", (args) => {
                 const data = args[0];
                 return {
                     userId: data?.user?.id,
@@ -129,15 +129,15 @@ export function wrapAuthCallbacks(auth, eventsConfig) {
                     // Mark this email as using token-based reset
                     const email = data?.user?.email?.toLowerCase();
                     if (email) {
-                        passwordResetMethod.set(email, 'token');
+                        passwordResetMethod.set(email, "token");
                     }
                     const originalPromise = originalSendResetPassword(...args);
-                    const eventPromise = emitEvent('password.reset_requested', {
-                        status: 'success',
+                    const eventPromise = emitEvent("password.reset_requested", {
+                        status: "success",
                         userId: data?.user?.id,
                         metadata: {
                             email: data?.user?.email,
-                            name: data?.user?.name || data?.user?.email || 'Someone',
+                            name: data?.user?.name || data?.user?.email || "Someone",
                             requestedAt: new Date().toISOString(),
                         },
                         request: requestInfo,
@@ -156,43 +156,43 @@ export function wrapAuthCallbacks(auth, eventsConfig) {
                 const requestInfo = getRequestInfo(request);
                 const userEmail = data?.user?.email?.toLowerCase();
                 const method = userEmail ? passwordResetMethod.get(userEmail) : undefined;
-                const isOtpReset = method === 'otp';
+                const isOtpReset = method === "otp";
                 if (userEmail) {
                     passwordResetMethod.delete(userEmail);
                 }
-                const eventType = isOtpReset ? 'password.reset_completed_otp' : 'password.reset_completed';
+                const eventType = isOtpReset ? "password.reset_completed_otp" : "password.reset_completed";
                 emitEvent(eventType, {
-                    status: 'success',
+                    status: "success",
                     userId: data?.user?.id,
                     metadata: {
                         email: data?.user?.email,
-                        name: data?.user?.name || data?.user?.email || 'Someone',
+                        name: data?.user?.name || data?.user?.email || "Someone",
                         resetAt: new Date().toISOString(),
-                        method: isOtpReset ? 'email_otp' : 'token',
+                        method: isOtpReset ? "email_otp" : "token",
                     },
                     request: requestInfo,
                 }, capturedConfig).catch(() => { });
             };
             emailAndPasswordConfig.__studio_wrapped = true;
         }
-        const emailOtpPlugin = auth.options?.plugins?.find((p) => p?.id === 'email-otp');
+        const emailOtpPlugin = auth.options?.plugins?.find((p) => p?.id === "email-otp");
         // TODO: Fix email-otp sendVerificationOTP callback wrapping because of plugin closure
         if (emailOtpPlugin && !emailOtpPlugin.__studio_wrapped) {
             const originalSendVerificationOTP = emailOtpPlugin.options?.sendVerificationOTP;
             if (originalSendVerificationOTP) {
                 const wrappedSendVerificationOTP = async (data, ctx) => {
                     const requestInfo = getRequestInfo(ctx?.request || ctx);
-                    if (data.type === 'forget-password') {
+                    if (data.type === "forget-password") {
                         const email = data.email.toLowerCase();
-                        passwordResetMethod.set(email, 'otp');
+                        passwordResetMethod.set(email, "otp");
                     }
                     const originalPromise = originalSendVerificationOTP(data, ctx);
-                    if (data.type === 'forget-password') {
-                        const eventPromise = emitEvent('password.reset_requested_otp', {
-                            status: 'success',
+                    if (data.type === "forget-password") {
+                        const eventPromise = emitEvent("password.reset_requested_otp", {
+                            status: "success",
                             metadata: {
                                 email: data.email,
-                                type: 'forget-password',
+                                type: "forget-password",
                                 requestedAt: new Date().toISOString(),
                             },
                             request: requestInfo,
@@ -206,7 +206,7 @@ export function wrapAuthCallbacks(auth, eventsConfig) {
                 };
                 emailOtpPlugin.options.sendVerificationOTP = wrappedSendVerificationOTP;
                 const originalInit = emailOtpPlugin.init;
-                if (originalInit && typeof originalInit === 'function') {
+                if (originalInit && typeof originalInit === "function") {
                     emailOtpPlugin.init = async (authInstance) => {
                         emailOtpPlugin.options.sendVerificationOTP = wrappedSendVerificationOTP;
                         await originalInit(authInstance);

package/dist/utils/auth-callbacks-wrapper.d.ts

@@ -1,7 +1,7 @@
-import type { StudioConfig } from '../types/handler.js';
+import type { StudioConfig } from "../types/handler.js";
 /**
  * Wraps Better Auth callbacks to automatically emit events
  * This should be called during Better Auth initialization
  */
-export declare function wrapAuthCallbacks(auth: any, eventsConfig: StudioConfig['events']): void;
-//# sourceMappingURL=auth-callbacks-wrapper.d.ts.map
+export declare function wrapAuthCallbacks(auth: any, eventsConfig: StudioConfig["events"]): void;
+//# sourceMappingURL=auth-callbacks-wrapper.d.ts.map

package/dist/utils/auth-callbacks-wrapper.js

@@ -1,123 +1,133 @@
-import { emitEvent } from './event-ingestion.js';
+import { emitEvent } from "./event-ingestion.js";
 /**
  * Helper to extract request info from Better Auth request object
  */
 function getRequestInfo(request) {
-    const headersObj = {};
-    let ip;
-    if (request) {
-        try {
-            if (request instanceof Request) {
-                // Standard Request object
-                request.headers.forEach((value, key) => {
-                    headersObj[key] = value;
-                });
-                ip = request.headers.get('x-forwarded-for') || request.headers.get('x-real-ip') || undefined;
-            }
-            else if (request.headers) {
-                // Object with headers property
-                if (typeof request.headers.get === 'function') {
-                    ip = request.headers.get('x-forwarded-for') || request.headers.get('x-real-ip') || undefined;
-                    request.headers.forEach?.((value, key) => {
-                        headersObj[key] = value;
-                    });
-                }
-                else {
-                    ip = request.headers['x-forwarded-for'] || request.headers['x-real-ip'] || undefined;
-                    Object.entries(request.headers).forEach(([key, value]) => {
-                        headersObj[key] = String(value);
-                    });
-                }
-            }
-        }
-        catch (e) {
-            // Ignore errors
+  const headersObj = {};
+  let ip;
+  if (request) {
+    try {
+      if (request instanceof Request) {
+        // Standard Request object
+        request.headers.forEach((value, key) => {
+          headersObj[key] = value;
+        });
+        ip =
+          request.headers.get("x-forwarded-for") || request.headers.get("x-real-ip") || undefined;
+      } else if (request.headers) {
+        // Object with headers property
+        if (typeof request.headers.get === "function") {
+          ip =
+            request.headers.get("x-forwarded-for") || request.headers.get("x-real-ip") || undefined;
+          request.headers.forEach?.((value, key) => {
+            headersObj[key] = value;
+          });
+        } else {
+          ip = request.headers["x-forwarded-for"] || request.headers["x-real-ip"] || undefined;
+          Object.entries(request.headers).forEach(([key, value]) => {
+            headersObj[key] = String(value);
+          });
         }
+      }
+    } catch (e) {
+      // Ignore errors
     }
-    return { headers: headersObj, ip };
+  }
+  return { headers: headersObj, ip };
 }
 /**
  * Wraps Better Auth callbacks to automatically emit events
  * This should be called during Better Auth initialization
  */
 export function wrapAuthCallbacks(auth, eventsConfig) {
-    if (!auth || !eventsConfig?.enabled) {
-        return;
-    }
-    try {
-        const capturedConfig = eventsConfig;
-        // Helper to wrap a callback function
-        const wrapCallback = (originalCallback, eventType, eventData) => {
-            return (async (...args) => {
-                // Call original callback if it exists
-                if (originalCallback) {
-                    await originalCallback(...args);
-                }
-                // Emit event
-                const data = eventData(args);
-                const requestInfo = getRequestInfo(args[args.length - 1]); // Last arg is usually request
-                emitEvent(eventType, {
-                    status: 'success',
-                    ...data,
-                    request: requestInfo,
-                }, capturedConfig).catch(() => { });
-            });
-        };
-        // Wrap user.deleteUser.afterDelete callback
-        // Check multiple possible locations
-        const deleteUserConfig = auth.options?.user?.deleteUser || auth.user?.deleteUser;
-        if (deleteUserConfig && !deleteUserConfig.__studio_wrapped) {
-            const originalAfterDelete = deleteUserConfig.afterDelete;
-            deleteUserConfig.afterDelete = wrapCallback(originalAfterDelete, 'user.deleted', (args) => {
-                const user = args[0];
-                return {
-                    userId: user?.id,
-                    metadata: {
-                        email: user?.email,
-                        name: user?.name,
-                    },
-                };
-            });
-            deleteUserConfig.__studio_wrapped = true;
-        }
-        // Wrap emailVerification.onEmailVerification callback
-        const emailVerificationConfig = auth.options?.emailVerification || auth.emailVerification;
-        if (emailVerificationConfig && !emailVerificationConfig.__studio_wrapped) {
-            const originalOnEmailVerification = emailVerificationConfig.onEmailVerification;
-            emailVerificationConfig.onEmailVerification = wrapCallback(originalOnEmailVerification, 'user.email_verified', (args) => {
-                const user = args[0];
-                return {
-                    userId: user?.id,
-                    metadata: {
-                        email: user?.email,
-                        name: user?.name,
-                        verifiedAt: new Date().toISOString(),
-                    },
-                };
-            });
-            emailVerificationConfig.__studio_wrapped = true;
-        }
-        // Wrap emailAndPassword.onPasswordChange callback
-        const emailAndPasswordConfig = auth.options?.emailAndPassword || auth.emailAndPassword;
-        if (emailAndPasswordConfig && !emailAndPasswordConfig.__studio_wrapped) {
-            const originalOnPasswordChange = emailAndPasswordConfig.onPasswordChange;
-            emailAndPasswordConfig.onPasswordChange = wrapCallback(originalOnPasswordChange, 'user.password_changed', (args) => {
-                const data = args[0];
-                return {
-                    userId: data?.user?.id,
-                    metadata: {
-                        email: data?.user?.email,
-                        name: data?.user?.name,
-                        revokeOtherSessions: data?.revokeOtherSessions || false,
-                        changedAt: new Date().toISOString(),
-                    },
-                };
-            });
-            emailAndPasswordConfig.__studio_wrapped = true;
+  if (!auth || !eventsConfig?.enabled) {
+    return;
+  }
+  try {
+    const capturedConfig = eventsConfig;
+    // Helper to wrap a callback function
+    const wrapCallback = (originalCallback, eventType, eventData) => {
+      return async (...args) => {
+        // Call original callback if it exists
+        if (originalCallback) {
+          await originalCallback(...args);
         }
+        // Emit event
+        const data = eventData(args);
+        const requestInfo = getRequestInfo(args[args.length - 1]); // Last arg is usually request
+        emitEvent(
+          eventType,
+          {
+            status: "success",
+            ...data,
+            request: requestInfo,
+          },
+          capturedConfig,
+        ).catch(() => {});
+      };
+    };
+    // Wrap user.deleteUser.afterDelete callback
+    // Check multiple possible locations
+    const deleteUserConfig = auth.options?.user?.deleteUser || auth.user?.deleteUser;
+    if (deleteUserConfig && !deleteUserConfig.__studio_wrapped) {
+      const originalAfterDelete = deleteUserConfig.afterDelete;
+      deleteUserConfig.afterDelete = wrapCallback(originalAfterDelete, "user.deleted", (args) => {
+        const user = args[0];
+        return {
+          userId: user?.id,
+          metadata: {
+            email: user?.email,
+            name: user?.name,
+          },
+        };
+      });
+      deleteUserConfig.__studio_wrapped = true;
+    }
+    // Wrap emailVerification.onEmailVerification callback
+    const emailVerificationConfig = auth.options?.emailVerification || auth.emailVerification;
+    if (emailVerificationConfig && !emailVerificationConfig.__studio_wrapped) {
+      const originalOnEmailVerification = emailVerificationConfig.onEmailVerification;
+      emailVerificationConfig.onEmailVerification = wrapCallback(
+        originalOnEmailVerification,
+        "user.email_verified",
+        (args) => {
+          const user = args[0];
+          return {
+            userId: user?.id,
+            metadata: {
+              email: user?.email,
+              name: user?.name,
+              verifiedAt: new Date().toISOString(),
+            },
+          };
+        },
+      );
+      emailVerificationConfig.__studio_wrapped = true;
     }
-    catch (error) {
-        console.error('[Auth Callbacks] Failed to wrap callbacks:', error);
+    // Wrap emailAndPassword.onPasswordChange callback
+    const emailAndPasswordConfig = auth.options?.emailAndPassword || auth.emailAndPassword;
+    if (emailAndPasswordConfig && !emailAndPasswordConfig.__studio_wrapped) {
+      const originalOnPasswordChange = emailAndPasswordConfig.onPasswordChange;
+      emailAndPasswordConfig.onPasswordChange = wrapCallback(
+        originalOnPasswordChange,
+        "user.password_changed",
+        (args) => {
+          const data = args[0];
+          return {
+            userId: data?.user?.id,
+            metadata: {
+              email: data?.user?.email,
+              name: data?.user?.name,
+              revokeOtherSessions: data?.revokeOtherSessions || false,
+              changedAt: new Date().toISOString(),
+            },
+          };
+        },
+      );
+      emailAndPasswordConfig.__studio_wrapped = true;
     }
+  } catch (error) {
+    console.error("[Auth Callbacks] Failed to wrap callbacks:", error);
+  }
 }
-//# sourceMappingURL=auth-callbacks-wrapper.js.map
+//# sourceMappingURL=auth-callbacks-wrapper.js.map

package/dist/utils/database-detection.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseDetectionResult, DetectionInfo } from '../types';
+import type { DatabaseDetectionResult, DetectionInfo } from "../types";
 /**
  * Detect database type and version from installed packages
  * @param cwd - Current working directory to search in

package/dist/utils/database-detection.js

@@ -1,23 +1,23 @@
-import { getPackageVersion } from './package-json.js';
+import { getPackageVersion } from "./package-json.js";
 const DATABASES = {
-    'drizzle-orm': 'drizzle',
-    '@prisma/client': 'prisma',
-    mongoose: 'mongodb',
-    mongodb: 'mongodb',
-    pg: 'postgresql',
-    mysql: 'mysql',
-    mariadb: 'mariadb',
-    sqlite3: 'sqlite',
-    'better-sqlite3': 'sqlite',
+    "drizzle-orm": "drizzle",
+    "@prisma/client": "prisma",
+    mongoose: "mongodb",
+    mongodb: "mongodb",
+    pg: "postgresql",
+    mysql: "mysql",
+    mariadb: "mariadb",
+    sqlite3: "sqlite",
+    "better-sqlite3": "sqlite",
 };
 const _DATABASE_DIALECTS = {
-    postgresql: ['pg', 'postgres'],
-    mysql: ['mysql', 'mysql2'],
-    mariadb: ['mariadb'],
-    sqlite: ['sqlite3', 'better-sqlite3'],
-    prisma: ['@prisma/client'],
-    mongodb: ['mongoose', 'mongodb'],
-    drizzle: ['drizzle-orm'],
+    postgresql: ["pg", "postgres"],
+    mysql: ["mysql", "mysql2"],
+    mariadb: ["mariadb"],
+    sqlite: ["sqlite3", "better-sqlite3"],
+    prisma: ["@prisma/client"],
+    mongodb: ["mongoose", "mongodb"],
+    drizzle: ["drizzle-orm"],
 };
 /**
  * Detect database type and version from installed packages
@@ -44,39 +44,39 @@ export async function detectDatabaseWithDialect(cwd) {
     let dialect = detection.name;
     let adapter = detection.name;
     switch (detection.name) {
-        case 'postgresql':
-            dialect = 'postgresql';
-            adapter = 'pg';
+        case "postgresql":
+            dialect = "postgresql";
+            adapter = "pg";
             break;
-        case 'mysql':
-            dialect = 'mysql';
-            adapter = 'mysql2';
+        case "mysql":
+            dialect = "mysql";
+            adapter = "mysql2";
             break;
-        case 'sqlite': {
-            const sqlite3Version = await getPackageVersion('sqlite3', cwd);
-            const betterSqlite3Version = await getPackageVersion('better-sqlite3', cwd);
+        case "sqlite": {
+            const sqlite3Version = await getPackageVersion("sqlite3", cwd);
+            const betterSqlite3Version = await getPackageVersion("better-sqlite3", cwd);
             if (betterSqlite3Version) {
-                adapter = 'better-sqlite3';
+                adapter = "better-sqlite3";
             }
             else if (sqlite3Version) {
-                adapter = 'sqlite3';
+                adapter = "sqlite3";
             }
             break;
         }
-        case 'prisma': {
+        case "prisma": {
             const prismaDialect = await detectPrismaDialect(cwd);
             if (prismaDialect) {
                 dialect = prismaDialect;
             }
-            adapter = 'prisma';
+            adapter = "prisma";
             break;
         }
-        case 'drizzle': {
+        case "drizzle": {
             const drizzleDialect = await detectDrizzleDialect(cwd);
             if (drizzleDialect) {
                 dialect = drizzleDialect;
             }
-            adapter = 'drizzle';
+            adapter = "drizzle";
             break;
         }
     }
@@ -89,10 +89,10 @@ export async function detectDatabaseWithDialect(cwd) {
 }
 async function detectPrismaDialect(cwd) {
     const drivers = [
-        { pkg: 'pg', dialect: 'postgresql' },
-        { pkg: 'mysql2', dialect: 'mysql' },
-        { pkg: 'sqlite3', dialect: 'sqlite' },
-        { pkg: 'better-sqlite3', dialect: 'sqlite' },
+        { pkg: "pg", dialect: "postgresql" },
+        { pkg: "mysql2", dialect: "mysql" },
+        { pkg: "sqlite3", dialect: "sqlite" },
+        { pkg: "better-sqlite3", dialect: "sqlite" },
     ];
     for (const { pkg, dialect } of drivers) {
         const version = await getPackageVersion(pkg, cwd);
@@ -103,14 +103,14 @@ async function detectPrismaDialect(cwd) {
 }
 async function detectDrizzleDialect(cwd) {
     const drizzleDrivers = [
-        { pkg: 'drizzle-orm/postgres-js', dialect: 'postgresql' },
-        { pkg: 'drizzle-orm/node-postgres', dialect: 'postgresql' },
-        { pkg: 'drizzle-orm/mysql2', dialect: 'mysql' },
-        { pkg: 'drizzle-orm/better-sqlite3', dialect: 'sqlite' },
-        { pkg: 'drizzle-orm/libsql', dialect: 'sqlite' },
-        { pkg: 'postgres', dialect: 'postgresql' },
-        { pkg: 'mysql2', dialect: 'mysql' },
-        { pkg: 'better-sqlite3', dialect: 'sqlite' },
+        { pkg: "drizzle-orm/postgres-js", dialect: "postgresql" },
+        { pkg: "drizzle-orm/node-postgres", dialect: "postgresql" },
+        { pkg: "drizzle-orm/mysql2", dialect: "mysql" },
+        { pkg: "drizzle-orm/better-sqlite3", dialect: "sqlite" },
+        { pkg: "drizzle-orm/libsql", dialect: "sqlite" },
+        { pkg: "postgres", dialect: "postgresql" },
+        { pkg: "mysql2", dialect: "mysql" },
+        { pkg: "better-sqlite3", dialect: "sqlite" },
     ];
     for (const { pkg, dialect } of drizzleDrivers) {
         try {

package/dist/utils/database-hook-injector.d.ts

@@ -1,3 +1,3 @@
-import type { StudioConfig } from '../types/handler.js';
-export declare function wrapDatabaseHooks(auth: any, eventsConfig: StudioConfig['events']): void;
-//# sourceMappingURL=database-hook-injector.d.ts.map
+import type { StudioConfig } from "../types/handler.js";
+export declare function wrapDatabaseHooks(auth: any, eventsConfig: StudioConfig["events"]): void;
+//# sourceMappingURL=database-hook-injector.d.ts.map