create-fluxstack 1.1.0 → 1.4.1

package/core/utils/logger/index.ts

@@ -1,280 +1,229 @@
 /**
- * FluxStack Logger
- * Enhanced logging system with multiple transports and formatters
+ * FluxStack Logger - Main Entry Point
+ * Unified logging system based on Winston with automatic module detection
  */
 
-import { ConsoleTransport, FileTransport, JSONTransport } from './transports'
-import { PrettyFormatter, JSONFormatter, SimpleFormatter } from './formatters'
-import type { LogTransport, LogEntry, LogLevel } from './transports'
-import type { LogFormatter } from './formatters'
+import chalk from 'chalk'
+import { getCallerInfo, formatCallerInfo } from './stack-trace'
+import { getColorForModule } from './colors'
+import { getLoggerForModule } from './winston-logger'
+import {
+  formatMessage,
+  formatSection,
+  formatImportant,
+  formatOperationStart,
+  formatOperationSuccess
+} from './formatter'
+
+// Re-export types and utilities
+export { LOGGER_CONFIG } from './config'
+export type { LoggerConfig } from './config'
+export type { CallerInfo } from './stack-trace'
+export { clearColorCache } from './colors'
+export { clearCallerCache } from './stack-trace'
+export { clearLoggerCache } from './winston-logger'
+
+// Re-export banner utilities for custom banners
+export { displayStartupBanner, type StartupInfo } from './startup-banner'
 
-export type { LogLevel, LogTransport, LogEntry } from './transports'
-export type { LogFormatter } from './formatters'
-
-export interface Logger {
-  debug(message: string, meta?: any): void
-  info(message: string, meta?: any): void
-  warn(message: string, meta?: any): void
-  error(message: string, meta?: any): void
-  
-  // Contextual logging
-  child(context: any): Logger
-  
-  // Performance logging
-  time(label: string): void
-  timeEnd(label: string): void
-  
-  // Request logging
-  request(method: string, path: string, status?: number, duration?: number): void
-  
-  // Transport management
-  addTransport(transport: LogTransport): void
-  removeTransport(name: string): void
-  
-  // Cleanup
-  close(): Promise<void>
+/**
+ * Core log function that handles all log levels
+ */
+function logMessage(level: 'debug' | 'info' | 'warn' | 'error', message: unknown, ...args: unknown[]): void {
+  const { file: callerFile, line: callerLine, function: callerFunction } = getCallerInfo()
+  const logger = getLoggerForModule(callerFile)
+  const moduleColor = getColorForModule(callerFile)
+
+  // Format caller context
+  const context = formatCallerInfo(
+    { file: callerFile, line: callerLine, function: callerFunction },
+    (str) => moduleColor(str)
+  )
+
+  // Format the message
+  const finalMessage = formatMessage(message, args)
+
+  // Log with appropriate level
+  logger.log({
+    level,
+    message: `${context} ${finalMessage}`
+  })
 }
 
-export interface LoggerConfig {
-  level?: LogLevel
-  transports?: LogTransport[]
-  defaultMeta?: any
+/**
+ * Log info message
+ */
+export function LOG(message: unknown, ...args: unknown[]): void {
+  logMessage('info', message, ...args)
 }
 
-class FluxStackLogger implements Logger {
-  private static instance: FluxStackLogger | null = null
-  private logLevel: LogLevel
-  private context: any = {}
-  private timers: Map<string, number> = new Map()
-  private transports: Map<string, LogTransport> = new Map()
-  private defaultMeta: any = {}
-
-  constructor(config?: LoggerConfig) {
-    this.logLevel = config?.level || (process.env.LOG_LEVEL as LogLevel) || 'info'
-    this.context = {}
-    this.defaultMeta = config?.defaultMeta || {}
-    
-    // Setup default transports if none provided
-    if (config?.transports) {
-      config.transports.forEach(transport => {
-        this.transports.set(transport.name, transport)
-      })
-    } else {
-      this.setupDefaultTransports()
-    }
-  }
-
-  static getInstance(config?: LoggerConfig): FluxStackLogger {
-    if (FluxStackLogger.instance === null) {
-      FluxStackLogger.instance = new FluxStackLogger(config)
-    }
-    return FluxStackLogger.instance
-  }
-
-  private setupDefaultTransports(): void {
-    const isDevelopment = process.env.NODE_ENV !== 'production'
-    
-    if (isDevelopment) {
-      // Development: Pretty console output
-      this.transports.set('console', new ConsoleTransport({
-        level: this.logLevel,
-        colors: true,
-        timestamp: true
-      }))
-    } else {
-      // Production: JSON output for structured logging
-      this.transports.set('json', new JSONTransport({
-        level: this.logLevel,
-        pretty: false
-      }))
-      
-      // Also add file transport for production
-      this.transports.set('file', new FileTransport({
-        level: this.logLevel,
-        filename: 'logs/fluxstack.log',
-        maxSize: 10 * 1024 * 1024, // 10MB
-        maxFiles: 5,
-        compress: true
-      }))
-    }
-  }
-
-  private shouldLog(level: LogLevel): boolean {
-    const levels: Record<LogLevel, number> = {
-      debug: 0,
-      info: 1,
-      warn: 2,
-      error: 3
-    }
-
-    return levels[level] >= levels[this.logLevel]
-  }
-
-  private async writeToTransports(level: LogLevel, message: string, meta?: any): Promise<void> {
-    if (!this.shouldLog(level)) return
-
-    const entry: LogEntry = {
-      timestamp: new Date().toISOString(),
-      level,
-      message,
-      meta: { ...this.defaultMeta, ...meta },
-      context: Object.keys(this.context).length > 0 ? this.context : undefined
-    }
-
-    // Write to all transports
-    const writePromises = Array.from(this.transports.values()).map(async transport => {
-      try {
-        await transport.write(entry)
-      } catch (error) {
-        // Fallback to console if transport fails
-        console.error(`Transport ${transport.name} failed:`, error)
-      }
-    })
-
-    await Promise.all(writePromises)
-  }
-
-  debug(message: string, meta?: any): void {
-    this.writeToTransports('debug', message, meta).catch(err => {
-      console.error('Logger error:', err)
-    })
-  }
+/**
+ * Log warning message
+ */
+export function WARN(message: unknown, ...args: unknown[]): void {
+  logMessage('warn', message, ...args)
+}
 
-  info(message: string, meta?: any): void {
-    this.writeToTransports('info', message, meta).catch(err => {
-      console.error('Logger error:', err)
-    })
-  }
+/**
+ * Log error message
+ */
+export function ERROR(message: unknown, ...args: unknown[]): void {
+  logMessage('error', message, ...args)
+}
 
-  warn(message: string, meta?: any): void {
-    this.writeToTransports('warn', message, meta).catch(err => {
-      console.error('Logger error:', err)
-    })
-  }
+/**
+ * Log debug message
+ */
+export function DEBUG(message: unknown, ...args: unknown[]): void {
+  logMessage('debug', message, ...args)
+}
 
-  error(message: string, meta?: any): void {
-    this.writeToTransports('error', message, meta).catch(err => {
-      console.error('Logger error:', err)
-    })
+/**
+ * Log operation start
+ */
+export function START(operation: string, details?: unknown): void {
+  const message = formatOperationStart(operation)
+  if (details) {
+    logMessage('info', message, details)
+  } else {
+    logMessage('info', message)
   }
+}
 
-  // Contextual logging
-  child(context: any): FluxStackLogger {
-    const childLogger = new FluxStackLogger({
-      level: this.logLevel,
-      transports: Array.from(this.transports.values()),
-      defaultMeta: this.defaultMeta
-    })
-    childLogger.context = { ...this.context, ...context }
-    return childLogger
+/**
+ * Log operation success
+ */
+export function SUCCESS(operation: string, details?: unknown): void {
+  const message = formatOperationSuccess(operation)
+  if (details) {
+    logMessage('info', message, details)
+  } else {
+    logMessage('info', message)
   }
+}
 
-  // Performance logging
-  time(label: string): void {
-    this.timers.set(label, Date.now())
-  }
+/**
+ * Log important information
+ */
+export function IMPORTANT(title: string, message: unknown): void {
+  const formattedTitle = chalk.bold.cyan(formatImportant(title))
+  logMessage('info', `${formattedTitle}\n${formatMessage(message)}`)
+}
 
-  timeEnd(label: string): void {
-    const startTime = this.timers.get(label)
-    if (startTime) {
-      const duration = Date.now() - startTime
-      this.info(`Timer ${label}: ${duration}ms`)
-      this.timers.delete(label)
-    }
-  }
+/**
+ * Log a section (group of related logs)
+ */
+export function SECTION(sectionName: string, callback: () => void): void {
+  const sectionTitle = chalk.bold.cyan(formatSection(sectionName))
+  logMessage('info', sectionTitle)
+  callback()
+  logMessage('info', chalk.bold.cyan(formatSection(`FIM: ${sectionName}`)))
+}
 
-  // HTTP request logging
-  request(method: string, path: string, status?: number, duration?: number): void {
-    const meta: any = { method, path }
-    if (status) meta.status = status
-    if (duration) meta.duration = duration
-    
-    const statusStr = status ? ` ${status}` : ''
-    const durationStr = duration ? ` (${duration}ms)` : ''
-    this.info(`${method} ${path}${statusStr}${durationStr}`, meta)
-  }
+/**
+ * HTTP request logging (compatibility with Elysia)
+ */
+export function request(method: string, path: string, status?: number, duration?: number): void {
+  const statusStr = status ? ` ${status}` : ''
+  const durationStr = duration ? ` (${duration}ms)` : ''
+  LOG(`${method} ${path}${statusStr}${durationStr}`)
+}
 
-  // Transport management
-  addTransport(transport: LogTransport): void {
-    this.transports.set(transport.name, transport)
-  }
+/**
+ * Plugin logging (compatibility with plugin system)
+ */
+export function plugin(pluginName: string, message: string, meta?: unknown): void {
+  DEBUG(`[${pluginName}] ${message}`, meta)
+}
 
-  removeTransport(name: string): void {
-    const transport = this.transports.get(name)
-    if (transport && transport.close) {
-      const closeResult = transport.close()
-      if (closeResult instanceof Promise) {
-        closeResult.catch(console.error)
-      }
-    }
-    this.transports.delete(name)
-  }
+/**
+ * Framework logging (compatibility with framework)
+ */
+export function framework(message: string, meta?: unknown): void {
+  LOG(`[FluxStack] ${message}`, meta)
+}
 
-  // Cleanup
-  async close(): Promise<void> {
-    const closePromises = Array.from(this.transports.values())
-      .filter(transport => transport.close)
-      .map(transport => transport.close!())
-    
-    await Promise.all(closePromises)
-    this.transports.clear()
-  }
+/**
+ * Performance timing
+ */
+const timers = new Map<string, number>()
 
-  // Plugin logging
-  plugin(pluginName: string, message: string, meta?: any): void {
-    this.debug(`[${pluginName}] ${message}`, { plugin: pluginName, ...meta })
-  }
+export function time(label: string): void {
+  timers.set(label, Date.now())
+}
 
-  // Framework logging
-  framework(message: string, meta?: any): void {
-    this.info(`[FluxStack] ${message}`, { component: 'framework', ...meta })
+export function timeEnd(label: string): void {
+  const startTime = timers.get(label)
+  if (startTime) {
+    const duration = Date.now() - startTime
+    LOG(`Timer ${label}: ${duration}ms`)
+    timers.delete(label)
+  } else {
+    WARN(`Timer not found: ${label}`)
   }
 }
 
-// Export transport and formatter classes
-export { ConsoleTransport, FileTransport, JSONTransport } from './transports'
-export { PrettyFormatter, JSONFormatter, SimpleFormatter } from './formatters'
-
-// Export performance utilities
-export { 
-  RequestLogger, 
-  PerformanceLogger, 
-  createRequestLoggingMiddleware 
-} from './performance'
-export type { RequestContext, PerformanceTimer } from './performance'
-
-// Export middleware utilities
-export {
-  createElysiaLoggerMiddleware,
-  createDatabaseLoggerMiddleware,
-  createPluginLoggerMiddleware,
-  createBuildLoggerMiddleware
-} from './middleware'
+/**
+ * Clear all caches (useful for testing)
+ */
+export function clearCache(): void {
+  const { clearColorCache } = require('./colors')
+  const { clearCallerCache } = require('./stack-trace')
+  const { clearLoggerCache } = require('./winston-logger')
+
+  clearColorCache()
+  clearCallerCache()
+  clearLoggerCache()
+}
 
-// Export singleton instance
-export const logger = FluxStackLogger.getInstance()
+/**
+ * Legacy compatibility - logger object with methods
+ */
+export const logger = {
+  debug: DEBUG,
+  info: LOG,
+  warn: WARN,
+  error: ERROR,
+  request,
+  plugin,
+  framework,
+  time,
+  timeEnd
+}
 
-// Export convenience functions
+/**
+ * Convenience log object (similar to old implementation)
+ */
 export const log = {
-  debug: (message: string, meta?: any) => logger.debug(message, meta),
-  info: (message: string, meta?: any) => logger.info(message, meta),
-  warn: (message: string, meta?: any) => logger.warn(message, meta),
-  error: (message: string, meta?: any) => logger.error(message, meta),
-  request: (method: string, path: string, status?: number, duration?: number) => 
-    logger.request(method, path, status, duration),
-  plugin: (pluginName: string, message: string, meta?: any) => 
-    logger.plugin(pluginName, message, meta),
-  framework: (message: string, meta?: any) => 
-    logger.framework(message, meta),
-  child: (context: any) => logger.child(context),
-  time: (label: string) => logger.time(label),
-  timeEnd: (label: string) => logger.timeEnd(label),
-  addTransport: (transport: LogTransport) => logger.addTransport(transport),
-  removeTransport: (name: string) => logger.removeTransport(name),
-  close: () => logger.close()
+  debug: DEBUG,
+  info: LOG,
+  warn: WARN,
+  error: ERROR,
+  request,
+  plugin,
+  framework,
+  time,
+  timeEnd
 }
 
-// Factory function for creating configured loggers
-export function createLogger(config: LoggerConfig): Logger {
-  return new FluxStackLogger(config)
-}
+/**
+ * Default export for easy importing
+ */
+export default {
+  LOG,
+  WARN,
+  ERROR,
+  DEBUG,
+  START,
+  SUCCESS,
+  IMPORTANT,
+  SECTION,
+  request,
+  plugin,
+  framework,
+  time,
+  timeEnd,
+  logger,
+  log,
+  clearCache
+}

package/core/utils/logger/stack-trace.ts

@@ -0,0 +1,92 @@
+/**
+ * FluxStack Logger - Stack Trace Analysis
+ * Extracts caller information from stack traces
+ */
+
+import { relative } from 'path'
+
+export interface CallerInfo {
+  file: string
+  line: number
+  function: string
+}
+
+// Cache for caller information
+const callerCache = new Map<string, CallerInfo>()
+const MAX_CACHE_SIZE = 1000
+
+/**
+ * Get information about the caller (file, line, function)
+ */
+export function getCallerInfo(): CallerInfo {
+  const originalFunc = Error.prepareStackTrace
+  let callerInfo: CallerInfo = { file: 'unknown', line: 0, function: 'unknown' }
+
+  try {
+    const err = new Error()
+    let stack: NodeJS.CallSite[] = []
+
+    Error.prepareStackTrace = (_: Error, stackTraces: NodeJS.CallSite[]) => stackTraces
+    stack = err.stack as unknown as NodeJS.CallSite[]
+
+    // Find the first frame that is not from the logger
+    for (let i = 2; i < stack.length; i++) {
+      const callSite = stack[i]
+      const fileName = callSite.getFileName()
+
+      if (
+        fileName &&
+        !fileName.includes('logger') &&
+        !fileName.includes('node_modules') &&
+        !fileName.includes('bun:') &&
+        !fileName.includes('<anonymous>')
+      ) {
+        const relativeFile = relative(process.cwd(), fileName)
+        const lineNumber = callSite.getLineNumber() || 0
+        const cacheKey = `${relativeFile}:${lineNumber}`
+
+        // Check cache
+        if (callerCache.has(cacheKey)) {
+          return callerCache.get(cacheKey)!
+        }
+
+        callerInfo = {
+          file: relativeFile,
+          line: lineNumber,
+          function: callSite.getFunctionName() || 'anonymous'
+        }
+
+        // Cache the result
+        if (callerCache.size >= MAX_CACHE_SIZE) {
+          // Remove oldest entry
+          const firstKey = callerCache.keys().next().value
+          callerCache.delete(firstKey)
+        }
+
+        callerCache.set(cacheKey, callerInfo)
+        break
+      }
+    }
+  } catch (error) {
+    // Silently fail - return default caller info
+  }
+
+  Error.prepareStackTrace = originalFunc
+  return callerInfo
+}
+
+/**
+ * Clear caller cache (useful for testing)
+ */
+export function clearCallerCache(): void {
+  callerCache.clear()
+}
+
+/**
+ * Format caller info for display
+ */
+export function formatCallerInfo(info: CallerInfo, colorFn: (str: string) => string): string {
+  const fileInfo = colorFn(`[${info.file}:${info.line}]`)
+  const functionInfo = info.function !== 'unknown' ? colorFn(`[${info.function}]`) : ''
+  return functionInfo ? `${fileInfo} ${functionInfo}` : fileInfo
+}

package/core/utils/logger/startup-banner.ts

@@ -0,0 +1,92 @@
+/**
+ * FluxStack Logger - Startup Banner
+ * Clean and beautiful startup display
+ *
+ * Developers can customize the banner by:
+ * 1. Setting showBanner: false in server config
+ * 2. Using displayStartupBanner() in app.listen() callback
+ * 3. Creating completely custom banners with chalk
+ */
+
+import chalk from 'chalk'
+import { LOG } from './index'
+import { FLUXSTACK_VERSION } from '../version'
+
+export interface StartupInfo {
+  port: number
+  apiPrefix?: string
+  environment: string
+  pluginCount?: number
+  vitePort?: number
+  viteEmbedded?: boolean // true when Vite runs programmatically with backend
+  swaggerPath?: string
+}
+
+/**
+ * Display clean startup banner
+ */
+export function displayStartupBanner(info: StartupInfo): void {
+  const {
+    port,
+    apiPrefix = '/api',
+    environment,
+    pluginCount = 0,
+    vitePort,
+    viteEmbedded = false,
+    swaggerPath
+  } = info
+
+  console.log('\n' + chalk.cyan.bold('⚡ FluxStack') + chalk.gray(` v${FLUXSTACK_VERSION}\n`))
+
+  // Server info
+  console.log(chalk.bold('🚀 Server'))
+  console.log(`   ${chalk.gray('→')} http://localhost:${port}`)
+  console.log(`   ${chalk.gray('→')} API: http://localhost:${port}${apiPrefix}`)
+  console.log(`   ${chalk.gray('→')} Health: http://localhost:${port}${apiPrefix}/health`)
+
+  // Frontend info (only if Vite is running standalone, NOT embedded)
+  if (vitePort && !viteEmbedded) {
+    console.log('')
+    console.log(chalk.bold('⚛️  Frontend'))
+    console.log(`   ${chalk.gray('→')} http://localhost:${vitePort}`)
+  }
+
+  // Swagger docs (if enabled)
+  if (swaggerPath) {
+    console.log('')
+    console.log(chalk.bold('📋 Documentation'))
+    console.log(`   ${chalk.gray('→')} Swagger: http://localhost:${port}${swaggerPath}`)
+  }
+
+  // Environment and plugins
+  console.log('')
+  console.log(chalk.bold('ℹ️  Info'))
+  console.log(`   ${chalk.gray('→')} Environment: ${chalk.green(environment)}`)
+  console.log(`   ${chalk.gray('→')} Plugins: ${chalk.yellow(pluginCount)}`)
+
+  // Show Vite embedded status when applicable
+  if (viteEmbedded && vitePort) {
+    console.log(`   ${chalk.gray('→')} Vite: ${chalk.magenta('embedded')} ${chalk.gray(`(port ${vitePort})`)}`)
+  }
+
+  console.log('\n' + chalk.green('✨ Ready!') + chalk.gray(' Press Ctrl+C to stop\n'))
+}
+
+/**
+ * Display simple plugin loaded message
+ */
+export function logPluginLoaded(name: string, version?: string): void {
+  const versionStr = version ? chalk.gray(`v${version}`) : ''
+  LOG(`${chalk.green('✓')} Plugin loaded: ${chalk.cyan(name)} ${versionStr}`)
+}
+
+/**
+ * Display plugin count summary
+ */
+export function logPluginsSummary(count: number): void {
+  if (count === 0) {
+    LOG(chalk.yellow('⚠  No plugins loaded'))
+  } else {
+    LOG(chalk.green(`✓ ${count} plugin${count > 1 ? 's' : ''} loaded successfully`))
+  }
+}