create-fluxstack 1.0.2 → 1.0.3

package/core/utils/logger/index.ts

@@ -0,0 +1,161 @@
+/**
+ * FluxStack Logger
+ * Environment-aware logging system
+ */
+
+// Environment info is handled via process.env directly
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error'
+
+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
+}
+
+class FluxStackLogger implements Logger {
+  private static instance: FluxStackLogger | null = null
+  private logLevel: LogLevel
+  private context: any = {}
+  private timers: Map<string, number> = new Map()
+
+  private constructor(context?: any) {
+    // Default to 'info' level, can be overridden by config
+    this.logLevel = (process.env.LOG_LEVEL as LogLevel) || 'info'
+    this.context = context || {}
+  }
+
+  static getInstance(): FluxStackLogger {
+    if (FluxStackLogger.instance === null) {
+      FluxStackLogger.instance = new FluxStackLogger()
+    }
+    return FluxStackLogger.instance
+  }
+
+  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 formatMessage(level: LogLevel, message: string, meta?: any): string {
+    const timestamp = new Date().toISOString()
+    const levelStr = level.toUpperCase().padEnd(5)
+    
+    let formatted = `[${timestamp}] ${levelStr}`
+    
+    // Add context if available
+    if (Object.keys(this.context).length > 0) {
+      const contextStr = Object.entries(this.context)
+        .map(([key, value]) => `${key}=${value}`)
+        .join(' ')
+      formatted += ` [${contextStr}]`
+    }
+    
+    formatted += ` ${message}`
+    
+    if (meta && typeof meta === 'object') {
+      formatted += ` ${JSON.stringify(meta)}`
+    } else if (meta !== undefined) {
+      formatted += ` ${meta}`
+    }
+    
+    return formatted
+  }
+
+  debug(message: string, meta?: any): void {
+    if (this.shouldLog('debug')) {
+      console.debug(this.formatMessage('debug', message, meta))
+    }
+  }
+
+  info(message: string, meta?: any): void {
+    if (this.shouldLog('info')) {
+      console.info(this.formatMessage('info', message, meta))
+    }
+  }
+
+  warn(message: string, meta?: any): void {
+    if (this.shouldLog('warn')) {
+      console.warn(this.formatMessage('warn', message, meta))
+    }
+  }
+
+  error(message: string, meta?: any): void {
+    if (this.shouldLog('error')) {
+      console.error(this.formatMessage('error', message, meta))
+    }
+  }
+
+  // Contextual logging
+  child(context: any): FluxStackLogger {
+    return new FluxStackLogger({ ...this.context, ...context })
+  }
+
+  // Performance logging
+  time(label: string): void {
+    this.timers.set(label, Date.now())
+  }
+
+  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)
+    }
+  }
+
+  // HTTP request logging
+  request(method: string, path: string, status?: number, duration?: number): void {
+    const statusStr = status ? ` ${status}` : ''
+    const durationStr = duration ? ` (${duration}ms)` : ''
+    this.info(`${method} ${path}${statusStr}${durationStr}`)
+  }
+
+  // Plugin logging
+  plugin(pluginName: string, message: string, meta?: any): void {
+    this.debug(`[${pluginName}] ${message}`, meta)
+  }
+
+  // Framework logging
+  framework(message: string, meta?: any): void {
+    this.info(`[FluxStack] ${message}`, meta)
+  }
+}
+
+// Export singleton instance
+export const logger = FluxStackLogger.getInstance()
+
+// Export convenience functions
+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)
+}

package/core/utils/logger.ts

@@ -0,0 +1,106 @@
+/**
+ * FluxStack Logger
+ * Environment-aware logging system
+ */
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error'
+
+class Logger {
+  private static instance: Logger | null = null
+  private logLevel: LogLevel
+
+  private constructor() {
+    this.logLevel = (process.env.LOG_LEVEL as LogLevel) || 'info'
+  }
+
+  static getInstance(): Logger {
+    if (Logger.instance === null) {
+      Logger.instance = new Logger()
+    }
+    return Logger.instance
+  }
+
+  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 formatMessage(level: LogLevel, message: string, meta?: any): string {
+    const timestamp = new Date().toISOString()
+    const levelStr = level.toUpperCase().padEnd(5)
+    
+    let formatted = `[${timestamp}] ${levelStr} ${message}`
+    
+    if (meta && typeof meta === 'object') {
+      formatted += ` ${JSON.stringify(meta)}`
+    } else if (meta !== undefined) {
+      formatted += ` ${meta}`
+    }
+    
+    return formatted
+  }
+
+  debug(message: string, meta?: any): void {
+    if (this.shouldLog('debug')) {
+      console.debug(this.formatMessage('debug', message, meta))
+    }
+  }
+
+  info(message: string, meta?: any): void {
+    if (this.shouldLog('info')) {
+      console.info(this.formatMessage('info', message, meta))
+    }
+  }
+
+  warn(message: string, meta?: any): void {
+    if (this.shouldLog('warn')) {
+      console.warn(this.formatMessage('warn', message, meta))
+    }
+  }
+
+  error(message: string, meta?: any): void {
+    if (this.shouldLog('error')) {
+      console.error(this.formatMessage('error', message, meta))
+    }
+  }
+
+  // HTTP request logging
+  request(method: string, path: string, status?: number, duration?: number): void {
+    const statusStr = status ? ` ${status}` : ''
+    const durationStr = duration ? ` (${duration}ms)` : ''
+    this.info(`${method} ${path}${statusStr}${durationStr}`)
+  }
+
+  // Plugin logging
+  plugin(pluginName: string, message: string, meta?: any): void {
+    this.debug(`[${pluginName}] ${message}`, meta)
+  }
+
+  // Framework logging
+  framework(message: string, meta?: any): void {
+    this.info(`[FluxStack] ${message}`, meta)
+  }
+}
+
+// Export singleton instance
+export const logger = Logger.getInstance()
+
+// Export convenience functions
+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)
+}

package/core/utils/monitoring/index.ts

@@ -0,0 +1,212 @@
+export interface Metric {
+  name: string
+  type: 'counter' | 'gauge' | 'histogram'
+  help: string
+  labels?: string[]
+  value?: number
+  values?: number[]
+}
+
+export interface Counter extends Metric {
+  type: 'counter'
+  inc(value?: number, labels?: Record<string, string>): void
+}
+
+export interface Gauge extends Metric {
+  type: 'gauge'
+  set(value: number, labels?: Record<string, string>): void
+  inc(value?: number, labels?: Record<string, string>): void
+  dec(value?: number, labels?: Record<string, string>): void
+}
+
+export interface Histogram extends Metric {
+  type: 'histogram'
+  observe(value: number, labels?: Record<string, string>): void
+  buckets: number[]
+}
+
+export interface SystemMetrics {
+  memoryUsage: {
+    rss: number
+    heapTotal: number
+    heapUsed: number
+    external: number
+  }
+  cpuUsage: {
+    user: number
+    system: number
+  }
+  eventLoopLag: number
+  uptime: number
+}
+
+export interface HttpMetrics {
+  requestsTotal: number
+  requestDuration: number[]
+  requestSize: number[]
+  responseSize: number[]
+  errorRate: number
+}
+
+export class MetricsCollector {
+  private metrics: Map<string, Metric> = new Map()
+  private httpMetrics: HttpMetrics = {
+    requestsTotal: 0,
+    requestDuration: [],
+    requestSize: [],
+    responseSize: [],
+    errorRate: 0
+  }
+
+  // Create metrics
+  createCounter(name: string, help: string, labels?: string[]): Counter {
+    const counter: Counter = {
+      name,
+      type: 'counter',
+      help,
+      labels,
+      value: 0,
+      inc: (value = 1, _labels) => {
+        counter.value = (counter.value || 0) + value
+      }
+    }
+    
+    this.metrics.set(name, counter)
+    return counter
+  }
+
+  createGauge(name: string, help: string, labels?: string[]): Gauge {
+    const gauge: Gauge = {
+      name,
+      type: 'gauge',
+      help,
+      labels,
+      value: 0,
+      set: (value, _labels) => {
+        gauge.value = value
+      },
+      inc: (value = 1, _labels) => {
+        gauge.value = (gauge.value || 0) + value
+      },
+      dec: (value = 1, _labels) => {
+        gauge.value = (gauge.value || 0) - value
+      }
+    }
+    
+    this.metrics.set(name, gauge)
+    return gauge
+  }
+
+  createHistogram(name: string, help: string, buckets: number[] = [0.1, 0.5, 1, 2.5, 5, 10]): Histogram {
+    const histogram: Histogram = {
+      name,
+      type: 'histogram',
+      help,
+      buckets,
+      values: [],
+      observe: (value, _labels) => {
+        histogram.values = histogram.values || []
+        histogram.values.push(value)
+      }
+    }
+    
+    this.metrics.set(name, histogram)
+    return histogram
+  }
+
+  // HTTP metrics
+  recordHttpRequest(_method: string, _path: string, statusCode: number, duration: number, requestSize?: number, responseSize?: number): void {
+    this.httpMetrics.requestsTotal++
+    this.httpMetrics.requestDuration.push(duration)
+    
+    if (requestSize) {
+      this.httpMetrics.requestSize.push(requestSize)
+    }
+    
+    if (responseSize) {
+      this.httpMetrics.responseSize.push(responseSize)
+    }
+    
+    if (statusCode >= 400) {
+      this.httpMetrics.errorRate = this.calculateErrorRate()
+    }
+  }
+
+  // System metrics
+  getSystemMetrics(): SystemMetrics {
+    const memUsage = process.memoryUsage()
+    const cpuUsage = process.cpuUsage()
+    
+    return {
+      memoryUsage: {
+        rss: memUsage.rss,
+        heapTotal: memUsage.heapTotal,
+        heapUsed: memUsage.heapUsed,
+        external: memUsage.external
+      },
+      cpuUsage: {
+        user: cpuUsage.user,
+        system: cpuUsage.system
+      },
+      eventLoopLag: this.measureEventLoopLag(),
+      uptime: process.uptime()
+    }
+  }
+
+  // Get all metrics
+  getAllMetrics(): Map<string, Metric> {
+    return new Map(this.metrics)
+  }
+
+  getHttpMetrics(): HttpMetrics {
+    return { ...this.httpMetrics }
+  }
+
+  // Export metrics in Prometheus format
+  exportPrometheus(): string {
+    let output = ''
+    
+    for (const metric of this.metrics.values()) {
+      output += `# HELP ${metric.name} ${metric.help}\n`
+      output += `# TYPE ${metric.name} ${metric.type}\n`
+      
+      if (metric.type === 'counter' || metric.type === 'gauge') {
+        output += `${metric.name} ${metric.value || 0}\n`
+      } else if (metric.type === 'histogram' && metric.values) {
+        const values = metric.values.sort((a, b) => a - b)
+        const buckets = (metric as Histogram).buckets
+        
+        for (const bucket of buckets) {
+          const count = values.filter(v => v <= bucket).length
+          output += `${metric.name}_bucket{le="${bucket}"} ${count}\n`
+        }
+        
+        output += `${metric.name}_bucket{le="+Inf"} ${values.length}\n`
+        output += `${metric.name}_count ${values.length}\n`
+        output += `${metric.name}_sum ${values.reduce((sum, v) => sum + v, 0)}\n`
+      }
+      
+      output += '\n'
+    }
+    
+    return output
+  }
+
+  private calculateErrorRate(): number {
+    const totalRequests = this.httpMetrics.requestsTotal
+    if (totalRequests === 0) return 0
+    
+    // This is a simplified calculation - in a real implementation,
+    // you'd track error counts separately
+    return 0 // Placeholder
+  }
+
+  private measureEventLoopLag(): number {
+    const start = process.hrtime.bigint()
+    setImmediate(() => {
+      const lag = Number(process.hrtime.bigint() - start) / 1e6 // Convert to milliseconds
+      return lag
+    })
+    return 0 // Placeholder - actual implementation would be more complex
+  }
+}

package/create-fluxstack.ts

@@ -53,7 +53,7 @@ program
       mkdirSync(projectPath, { recursive: true })
       
       // Copy only essential FluxStack files (not node_modules, not test apps, etc.)
-      const frameworkDir = join(currentDir, '../../') // Navigate to framework root
+      const frameworkDir = currentDir // Use current directory (framework root)
       const filesToCopy = [
         'core',
         'app',

package/create-test-app.ts

@@ -0,0 +1,156 @@
+#!/usr/bin/env bun
+
+/**
+ * Script temporário para testar criação de aplicação FluxStack
+ * Simula o comportamento do create-fluxstack CLI
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+
+interface ProjectOptions {
+  name: string;
+  template: 'basic' | 'minimal' | 'full';
+  targetDir?: string;
+}
+
+async function createTestApp(options: ProjectOptions) {
+  const { name, template } = options;
+  const projectPath = path.resolve('test-apps', name);
+  
+  console.log(`🚀 Creating FluxStack app: ${name}`);
+  console.log(`📁 Location: ${projectPath}`);
+  console.log(`📋 Template: ${template}`);
+  console.log();
+  
+  // Check if directory already exists
+  try {
+    await fs.access(projectPath);
+    console.log(`❌ Directory ${name} already exists`);
+    return;
+  } catch (error: any) {
+    if (error.code !== 'ENOENT') {
+      throw error;
+    }
+  }
+  
+  // Create project directory
+  await fs.mkdir(projectPath, { recursive: true });
+  
+  // Get template path
+  const templatePath = path.resolve('framework-distribution', 'create-fluxstack', 'templates', template);
+  
+  // Copy template files
+  await copyDirectory(templatePath, projectPath);
+  
+  // Process template files (replace placeholders)
+  await processTemplateFiles(projectPath, {
+    PROJECT_NAME: name,
+    PROJECT_DESCRIPTION: `A FluxStack application named ${name}`,
+    PROJECT_NAME_KEBAB: name,
+    PROJECT_NAME_CAMEL: toCamelCase(name),
+    PROJECT_NAME_PASCAL: toPascalCase(name)
+  });
+  
+  console.log('✅ Project created successfully!');
+  console.log();
+  console.log('Next steps:');
+  console.log(`  cd test-apps/${name}`);
+  console.log('  bun install');
+  console.log('  bun run dev');
+  console.log();
+}
+
+async function copyDirectory(src: string, dest: string, exclude: string[] = []) {
+  await fs.mkdir(dest, { recursive: true });
+  
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    if (exclude.includes(entry.name)) continue;
+    
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath, exclude);
+    } else {
+      const content = await fs.readFile(srcPath, 'utf-8');
+      await fs.writeFile(destPath, content, 'utf-8');
+    }
+  }
+}
+
+async function processTemplateFiles(
+  projectPath: string, 
+  replacements: Record<string, string>
+) {
+  const files = await getAllFiles(projectPath);
+  
+  for (const file of files) {
+    // Skip binary files
+    if (isBinaryFile(file)) continue;
+    
+    let content = await fs.readFile(file, 'utf-8');
+    
+    // Replace placeholders
+    for (const [key, value] of Object.entries(replacements)) {
+      const regex = new RegExp(`{{${key}}}`, 'g');
+      content = content.replace(regex, value);
+    }
+    
+    await fs.writeFile(file, content, 'utf-8');
+  }
+}
+
+async function getAllFiles(dirPath: string): Promise<string[]> {
+  const files: string[] = [];
+  
+  const items = await fs.readdir(dirPath, { withFileTypes: true });
+  
+  for (const item of items) {
+    const fullPath = path.join(dirPath, item.name);
+    
+    if (item.isDirectory()) {
+      files.push(...await getAllFiles(fullPath));
+    } else {
+      files.push(fullPath);
+    }
+  }
+  
+  return files;
+}
+
+function isBinaryFile(filePath: string): boolean {
+  const binaryExtensions = [
+    '.png', '.jpg', '.jpeg', '.gif', '.ico', '.svg',
+    '.woff', '.woff2', '.ttf', '.eot',
+    '.zip', '.tar', '.gz', '.rar'
+  ];
+  
+  const ext = path.extname(filePath).toLowerCase();
+  return binaryExtensions.includes(ext);
+}
+
+function toCamelCase(str: string): string {
+  return str
+    .replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : '')
+    .replace(/^[A-Z]/, char => char.toLowerCase());
+}
+
+function toPascalCase(str: string): string {
+  const camelCase = toCamelCase(str);
+  return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+}
+
+// Run the script
+const projectName = process.argv[2] || 'test-todo-app';
+const template = (process.argv[3] as 'basic' | 'minimal' | 'full') || 'basic';
+
+createTestApp({
+  name: projectName,
+  template
+}).catch(error => {
+  console.error('❌ Error creating project:', error);
+  process.exit(1);
+});