better-auth-studio 1.0.6 → 1.0.8

package/src/config.ts

@@ -1,320 +0,0 @@
-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',
-    'lib/auth.ts',
-    'lib/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

@@ -1,351 +0,0 @@
-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;
-}