better-auth-studio 1.0.0

package/src/config.ts

@@ -0,0 +1,318 @@
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+
+export interface AuthProvider {
+  type: string;
+  clientId?: string;
+  clientSecret?: string;
+  redirectUri?: string;
+  [key: string]: any;
+}
+
+export interface AuthDatabase {
+  url?: string;
+  type?: string;
+  dialect?: string;
+  [key: string]: any;
+}
+
+export interface AuthConfig {
+  database?: AuthDatabase;
+  providers?: AuthProvider[];
+  socialProviders?: Record<string, any>;
+  emailAndPassword?: any;
+  session?: any;
+  secret?: string;
+  rateLimit?: any;
+  [key: string]: any;
+}
+
+export async function findAuthConfig(): Promise<AuthConfig | null> {
+  const possibleConfigFiles = [
+    'studio-config.json',
+    'auth.ts',
+    'auth.js',
+    'src/auth.ts',
+    'src/auth.js',
+    'better-auth.config.ts',
+    'better-auth.config.js',
+    'better-auth.config.json',
+    'auth.config.ts',
+    'auth.config.js',
+    'auth.config.json'
+  ];
+
+  let currentDir = process.cwd();
+  const maxDepth = 10;
+  let depth = 0;
+
+  while (currentDir && depth < maxDepth) {
+    for (const configFile of possibleConfigFiles) {
+      const configPath = join(currentDir, configFile);
+      
+      if (existsSync(configPath)) {
+        try {
+          const config = await loadConfig(configPath);
+          if (config) {
+            return config;
+          }
+        } catch (error) {
+          console.warn(`Failed to load config from ${configPath}:`, error);
+        }
+      }
+    }
+
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+    depth++;
+  }
+
+  return null;
+}
+
+async function loadConfig(configPath: string): Promise<AuthConfig | null> {
+  const ext = configPath.split('.').pop();
+  
+  try {
+    if (ext === 'json') {
+      const content = readFileSync(configPath, 'utf-8');
+      return JSON.parse(content);
+    } else if (ext === 'js' || ext === 'ts') {
+      return await loadTypeScriptConfig(configPath);
+    }
+  } catch (error) {
+    console.warn(`Error loading config from ${configPath}:`, error);
+  }
+
+  return null;
+}
+
+async function loadTypeScriptConfig(configPath: string): Promise<AuthConfig | null> {
+  try {
+    if (configPath.endsWith('.ts')) {
+      try {
+        const authModule = await import(configPath);
+        
+        if (authModule.auth) {
+          console.log('Found auth export, extracting configuration...');
+          const config = authModule.auth.options || authModule.auth;
+          return extractBetterAuthFields(config);
+        } else if (authModule.default) {
+          console.log('Found default export, extracting configuration...');
+          const config = authModule.default.options || authModule.default;
+          return extractBetterAuthFields(config);
+        }
+      } catch (importError) {
+        console.warn(`Failed to import auth config from ${configPath}:`, importError);
+        console.log('Falling back to regex extraction...');
+      }
+    }
+
+    const content = readFileSync(configPath, 'utf-8');
+    const authConfig = extractBetterAuthConfig(content);
+    if (authConfig) {
+      return authConfig;
+    }
+
+    if (configPath.endsWith('.js')) {
+      return await evaluateJSConfig(configPath);
+    }
+
+    return null;
+  } catch (error) {
+    console.warn(`Error loading TypeScript config from ${configPath}:`, error);
+    return null;
+  }
+}
+
+function extractBetterAuthConfig(content: string): AuthConfig | null {
+  console.log('Extracting config from content:', content.substring(0, 500) + '...');
+  
+  const patterns = [
+    /export\s+const\s+\w+\s*=\s*betterAuth\s*\(\s*({[\s\S]*?})\s*\)/,
+    /export\s+const\s+\w+\s*=\s*BetterAuth\s*\(\s*({[\s\S]*?})\s*\)/,
+    /const\s+\w+\s*=\s*betterAuth\s*\(\s*({[\s\S]*?})\s*\)/,
+    /const\s+\w+\s*=\s*BetterAuth\s*\(\s*({[\s\S]*?})\s*\)/,
+    /export\s+default\s+betterAuth\s*\(\s*({[\s\S]*?})\s*\)/,
+    /export\s+default\s+BetterAuth\s*\(\s*({[\s\S]*?})\s*\)/,
+    /module\.exports\s*=\s*betterAuth\s*\(\s*({[\s\S]*?})\s*\)/,
+    /module\.exports\s*=\s*BetterAuth\s*\(\s*({[\s\S]*?})\s*\)/,
+    /export\s+default\s*({[\s\S]*?});?$/m,
+    /module\.exports\s*=\s*({[\s\S]*?});?$/m,
+    /betterAuth\s*\(\s*({[\s\S]*?})\s*\)/,
+    /BetterAuth\s*\(\s*({[\s\S]*?})\s*\)/,
+    /({[\s\S]*?"socialProviders"[\s\S]*?})/,
+    /({[\s\S]*?"emailAndPassword"[\s\S]*?})/,
+    /({[\s\S]*?"database"[\s\S]*?})/
+  ];
+
+  for (let i = 0; i < patterns.length; i++) {
+    const pattern = patterns[i];
+    const match = content.match(pattern);
+    if (match) {
+      console.log(`Pattern ${i + 1} matched!`);
+      console.log('Matched content:', match[1].substring(0, 200) + '...');
+      try {
+        let configStr = match[1];
+        
+        configStr = configStr
+          .replace(/(\d+\s*\*\s*\d+\s*\*\s*\d+\s*\*\s*\d+)/g, (match) => {
+            try {
+              return eval(match).toString();
+            } catch {
+              return match;
+            }
+          })
+          .replace(/(\d+\s*\*\s*\d+\s*\*\s*\d+)/g, (match) => {
+            try {
+              return eval(match).toString();
+            } catch {
+              return match;
+            }
+          })
+          .replace(/(\d+\s*\*\s*\d+)/g, (match) => {
+            try {
+              return eval(match).toString();
+            } catch {
+              return match;
+            }
+          });
+        
+        configStr = configStr
+          .replace(/:\s*process\.env\.(\w+)(\s*\|\|\s*"[^"]*")?/g, ':"$1"') // Replace process.env.VAR || "default" with "VAR"
+          .replace(/:\s*`([^`]*)`/g, ':"$1"') // Replace template literals
+          .replace(/:\s*'([^']*)'/g, ':"$1"') // Replace single quotes
+          .replace(/:\s*"([^"]*)"/g, ':"$1"') // Keep double quotes
+          .replace(/:\s*(\w+)/g, ':"$1"') // Replace unquoted keys
+          .replace(/(\w+):/g, '"$1":') // Quote property names
+          .replace(/,\s*}/g, '}') // Remove trailing commas
+          .replace(/,\s*]/g, ']') // Remove trailing commas in arrays
+          .replace(/\/\/.*$/gm, '') // Remove single-line comments
+          .replace(/\/\*[\s\S]*?\*\//g, '') // Remove multi-line comments
+          .replace(/\s+/g, ' ') // Normalize whitespace
+          .replace(/:\s*(\d+)/g, ':$1') // Keep numbers
+          .replace(/:\s*(true|false)/g, ':$1') // Keep booleans
+          .replace(/:\s*null/g, ':null') // Keep null
+          .trim();
+        
+        console.log('Cleaned config string:', configStr.substring(0, 300) + '...');
+
+        let config;
+        try {
+          config = JSON.parse(configStr);
+        } catch (error) {
+          console.warn(`Failed to parse config: ${error instanceof Error ? error.message : 'Unknown error'}`);
+          console.warn('Config string that failed:', configStr.substring(0, 200) + '...');
+          return null;
+        }
+        
+        return extractBetterAuthFields(config);
+      } catch (error) {
+        console.warn(`Failed to parse config pattern: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        continue;
+      }
+    }
+  }
+
+  return null;
+}
+
+function extractBetterAuthFields(config: any): AuthConfig {
+  console.log('Extracting fields from config:', JSON.stringify(config, null, 2));
+  
+  const authConfig: AuthConfig = {};
+
+  if (config.database) {
+    let dbType = 'postgresql'; // default
+    let dbName = config.database.name;
+    
+    if (config.database.constructor && config.database.constructor.name === 'Database') {
+      dbType = 'sqlite';
+      dbName = config.database.name || './better-auth.db';
+    } else if (config.database.name && config.database.name.endsWith('.db')) {
+      dbType = 'sqlite';
+    } else if (config.database.type) {
+      dbType = config.database.type;
+    } else if (config.database.dialect) {
+      dbType = config.database.dialect;
+    }
+    
+    authConfig.database = {
+      url: config.database.url || config.database.connectionString,
+      name: dbName,
+      type: dbType,
+      dialect: config.database.dialect,
+      casing: config.database.casing
+    };
+  }
+
+  if (config.socialProviders) {
+    if (typeof config.socialProviders === 'object' && !Array.isArray(config.socialProviders)) {
+      authConfig.socialProviders = config.socialProviders;
+      authConfig.providers = Object.entries(config.socialProviders).map(([provider, config]: [string, any]) => ({
+        type: provider,
+        clientId: config.clientId,
+        clientSecret: config.clientSecret,
+        redirectUri: config.redirectUri,
+        ...config
+      }));
+    } else if (Array.isArray(config.socialProviders)) {
+      authConfig.socialProviders = config.socialProviders;
+      authConfig.providers = config.socialProviders;
+    }
+  }
+
+  if (config.providers && Array.isArray(config.providers)) {
+    authConfig.providers = config.providers.map((provider: any) => ({
+      type: provider.type || provider.id,
+      clientId: provider.clientId || provider.client_id,
+      clientSecret: provider.clientSecret || provider.client_secret,
+      ...provider
+    }));
+  }
+
+  if (config.emailAndPassword) {
+    authConfig.emailAndPassword = config.emailAndPassword;
+  }
+
+  if (config.session) {
+    authConfig.session = config.session;
+  }
+
+  if (config.secret) {
+    authConfig.secret = config.secret;
+  }
+
+  if (config.rateLimit) {
+    authConfig.rateLimit = config.rateLimit;
+  }
+
+  if (config.telemetry) {
+    authConfig.telemetry = config.telemetry;
+  }
+  if(config.plugins) {
+    authConfig.plugins = config.plugins.map((plugin: any) => plugin.id);
+  }
+  console.log('Extracted auth config:', JSON.stringify(authConfig, null, 2));
+  return authConfig;
+}
+
+async function evaluateJSConfig(configPath: string): Promise<AuthConfig | null> {
+  try {
+    const config = require(configPath);
+    
+    if (config.default) {
+      return extractBetterAuthFields(config.default);
+    } else if (typeof config === 'object') {
+      return extractBetterAuthFields(config);
+    }
+    
+    return null;
+  } catch (error) {
+    console.warn(`Error evaluating JS config from ${configPath}:`, error);
+    return null;
+  }
+}

package/src/data.ts

@@ -0,0 +1,351 @@
+import { AuthConfig } from './config';
+import { getAuthAdapter } from './auth-adapter';
+
+export interface User {
+  id: string;
+  email?: string;
+  name?: string;
+  image?: string;
+  emailVerified?: Date;
+  createdAt: Date;
+  updatedAt: Date;
+  provider?: string;
+  lastSignIn?: Date;
+}
+
+export interface Session {
+  id: string;
+  userId: string;
+  expires: Date;
+  createdAt: Date;
+  userAgent?: string;
+  ip?: string;
+}
+
+export interface AuthStats {
+  totalUsers: number;
+  activeUsers: number;
+  totalSessions: number;
+  activeSessions: number;
+  usersByProvider: Record<string, number>;
+  recentSignups: User[];
+  recentLogins: Session[];
+}
+
+export interface PaginatedResult<T> {
+  data: T[];
+  total: number;
+  page: number;
+  limit: number;
+  totalPages: number;
+}
+
+export async function getAuthData(
+  authConfig: AuthConfig,
+  type: 'stats' | 'users' | 'sessions' | 'providers' | 'deleteUser' | 'updateUser' = 'stats',
+  options?: any
+): Promise<any> {
+  try {
+    const adapter = await getAuthAdapter();
+
+    if (!adapter) {
+      console.log('No adapter available, falling back to mock data');
+      return getMockData(type, options);
+    }
+
+    switch (type) {
+      case 'stats':
+        return await getRealStats(adapter);
+      case 'users':
+        return await getRealUsers(adapter, options);
+      case 'sessions':
+        return await getRealSessions(adapter, options);
+      case 'providers':
+        return await getRealProviderStats(adapter);
+      case 'deleteUser':
+        return await deleteRealUser(adapter, options.id);
+      case 'updateUser':
+        console.log({adapter})
+        return await updateRealUser(adapter, options.id, options.userData);
+      default:
+        throw new Error(`Unknown data type: ${type}`);
+    }
+  } catch (error) {
+    console.error(`Error fetching ${type} data:`, error);
+    return getMockData(type, options);
+  }
+}
+
+async function getRealStats(adapter: any): Promise<AuthStats> {
+  try {
+    const users = adapter.getUsers ? await adapter.getUsers() : [];
+    const sessions = adapter.getSessions ? await adapter.getSessions() : [];
+
+    const now = new Date();
+    const activeSessions = sessions.filter((s: any) => new Date(s.expiresAt || s.expires) > now);
+    const activeUsers = new Set(activeSessions.map((s: any) => s.userId)).size;
+
+    const usersByProvider: Record<string, number> = {
+      email: users.length,
+      github: 0
+    };
+
+    const recentSignups = users
+      .sort((a: any, b: any) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
+      .slice(0, 5)
+      .map((user: any) => ({
+        ...user,
+        provider: 'email'
+      }));
+
+    const recentLogins = activeSessions
+      .sort((a: any, b: any) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
+      .slice(0, 5);
+
+    return {
+      totalUsers: users.length,
+      activeUsers,
+      totalSessions: sessions.length,
+      activeSessions: activeSessions.length,
+      usersByProvider,
+      recentSignups,
+      recentLogins
+    };
+  } catch (error) {
+    console.error('Error fetching stats from adapter:', error);
+    return getMockData('stats');
+  }
+}
+
+async function getRealUsers(adapter: any, options: { page: number; limit: number; search?: string }): Promise<PaginatedResult<User>> {
+  const { page, limit, search } = options;
+
+  try {
+    if (adapter.getUsers) {
+      const allUsers = await adapter.getUsers();
+
+      let filteredUsers = allUsers;
+      if (search) {
+        filteredUsers = allUsers.filter((user: any) =>
+          user.email?.toLowerCase().includes(search.toLowerCase()) ||
+          user.name?.toLowerCase().includes(search.toLowerCase())
+        );
+      }
+
+      const startIndex = (page - 1) * limit;
+      const endIndex = startIndex + limit;
+      const paginatedUsers = filteredUsers.slice(startIndex, endIndex);
+
+      return {
+        data: paginatedUsers,
+        total: filteredUsers.length,
+        page,
+        limit,
+        totalPages: Math.ceil(filteredUsers.length / limit)
+      };
+    }
+
+    return getMockData('users', options);
+  } catch (error) {
+    console.error('Error fetching users from adapter:', error);
+    return getMockData('users', options);
+  }
+}
+
+async function getRealSessions(adapter: any, options: { page: number; limit: number }): Promise<PaginatedResult<Session>> {
+  const { page, limit } = options;
+
+  try {
+    if (adapter.getSessions) {
+      const allSessions = await adapter.getSessions();
+
+      const startIndex = (page - 1) * limit;
+      const endIndex = startIndex + limit;
+      const paginatedSessions = allSessions.slice(startIndex, endIndex);
+
+      return {
+        data: paginatedSessions,
+        total: allSessions.length,
+        page,
+        limit,
+        totalPages: Math.ceil(allSessions.length / limit)
+      };
+    }
+
+    return getMockData('sessions', options);
+  } catch (error) {
+    console.error('Error fetching sessions from adapter:', error);
+    return getMockData('sessions', options);
+  }
+}
+
+async function getRealProviderStats(adapter: any) {
+  try {
+    return [
+      { type: 'email', users: 0, active: 0 },
+      { type: 'github', users: 0, active: 0 }
+    ];
+  } catch (error) {
+    console.error('Error fetching provider stats from adapter:', error);
+    return getMockData('providers');
+  }
+}
+
+async function deleteRealUser(adapter: any, userId: string): Promise<void> {
+  try {
+    if (adapter.delete) {
+      await adapter.delete({ model: 'user', where: [{ field: 'id', value: userId }] });
+    } else {
+      console.warn('Delete method not available on adapter');
+    }
+  } catch (error) {
+    console.error('Error deleting user from adapter:', error);
+    throw error;
+  }
+}
+
+async function updateRealUser(adapter: any, userId: string, userData: Partial<User>): Promise<User> {
+  console.log({userId, userData})
+  try {
+      const updatedUser = await adapter.update({
+        model: 'user',
+        where: [
+          {
+            field: 'id',
+            value: userId
+          }
+        ],
+        update: {...userData}
+      });
+      console.log({updatedUser})
+      return updatedUser;
+   
+  } catch (error) {
+    console.error('Error updating user from adapter:', error);
+    throw error;
+  }
+}
+
+function getMockData(type: string, options?: any): any {
+  switch (type) {
+    case 'stats':
+      return getMockStats();
+    case 'users':
+      return getMockUsers(options);
+    case 'sessions':
+      return getMockSessions(options);
+    case 'providers':
+      return getMockProviderStats();
+    case 'deleteUser':
+      return Promise.resolve();
+    case 'updateUser':
+      return Promise.resolve(generateMockUsers(1)[0]);
+    default:
+      throw new Error(`Unknown data type: ${type}`);
+  }
+}
+
+function getMockStats(): AuthStats {
+  return {
+    totalUsers: 1247,
+    activeUsers: 892,
+    totalSessions: 3456,
+    activeSessions: 1234,
+    usersByProvider: {
+      'google': 456,
+      'github': 234,
+      'email': 557
+    },
+    recentSignups: generateMockUsers(5),
+    recentLogins: generateMockSessions(5)
+  };
+}
+
+function getMockUsers(options: { page: number; limit: number; search?: string }): PaginatedResult<User> {
+  const { page, limit, search } = options;
+  const allUsers = generateMockUsers(100);
+
+  let filteredUsers = allUsers;
+  if (search) {
+    filteredUsers = allUsers.filter(user =>
+      user.email?.toLowerCase().includes(search.toLowerCase()) ||
+      user.name?.toLowerCase().includes(search.toLowerCase())
+    );
+  }
+
+  const start = (page - 1) * limit;
+  const end = start + limit;
+  const data = filteredUsers.slice(start, end);
+
+  return {
+    data,
+    total: filteredUsers.length,
+    page,
+    limit,
+    totalPages: Math.ceil(filteredUsers.length / limit)
+  };
+}
+
+function getMockSessions(options: { page: number; limit: number }): PaginatedResult<Session> {
+  const { page, limit } = options;
+  const allSessions = generateMockSessions(200);
+
+  const start = (page - 1) * limit;
+  const end = start + limit;
+  const data = allSessions.slice(start, end);
+
+  return {
+    data,
+    total: allSessions.length,
+    page,
+    limit,
+    totalPages: Math.ceil(allSessions.length / limit)
+  };
+}
+
+function getMockProviderStats() {
+  return [
+    { type: 'google', users: 456, active: 234 },
+    { type: 'github', users: 234, active: 123 },
+    { type: 'email', users: 557, active: 345 }
+  ];
+}
+
+function generateMockUsers(count: number): User[] {
+  const users: User[] = [];
+  const providers = ['google', 'github', 'email'];
+
+  for (let i = 0; i < count; i++) {
+    const provider = providers[Math.floor(Math.random() * providers.length)];
+    users.push({
+      id: `user_${i + 1}`,
+      email: `user${i + 1}@example.com`,
+      name: `User ${i + 1}`,
+      image: `https://api.dicebear.com/7.x/avataaars/svg?seed=user${i + 1}`,
+      emailVerified: Math.random() > 0.3 ? new Date() : undefined,
+      createdAt: new Date(Date.now() - Math.random() * 30 * 24 * 60 * 60 * 1000),
+      updatedAt: new Date(),
+      provider,
+      lastSignIn: new Date(Date.now() - Math.random() * 7 * 24 * 60 * 60 * 1000)
+    });
+  }
+
+  return users;
+}
+
+function generateMockSessions(count: number): Session[] {
+  const sessions: Session[] = [];
+
+  for (let i = 0; i < count; i++) {
+    sessions.push({
+      id: `session_${i + 1}`,
+      userId: `user_${Math.floor(Math.random() * 100) + 1}`,
+      expires: new Date(Date.now() + Math.random() * 24 * 60 * 60 * 1000),
+      createdAt: new Date(Date.now() - Math.random() * 7 * 24 * 60 * 60 * 1000),
+      userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
+      ip: `192.168.1.${Math.floor(Math.random() * 255)}`
+    });
+  }
+
+  return sessions;
+}