create-fluxstack 1.0.0 → 1.0.2

package/core/utils/logger/index.ts

@@ -1,161 +0,0 @@
-/**
- * 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

@@ -1,106 +0,0 @@
-/**
- * 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

@@ -1,212 +0,0 @@
-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/tsconfig.json

@@ -1,51 +0,0 @@
-{
-  "compilerOptions": {
-    // Enable latest features
-    "lib": ["ESNext", "DOM", "DOM.Iterable"],
-    "target": "ES2022",
-    "module": "ES2022",
-    "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
-    "types": ["node"],
-    "typeRoots": ["./types", "./node_modules/@types"],
-
-    // Bundler mode
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "noEmit": true,
-    "downlevelIteration": true,
-
-    // Path mapping (alias support)
-    "baseUrl": ".",
-    "paths": {
-      "@/*": ["./*"],
-      "@/core/*": ["./core/*"],
-      "@/app/*": ["./app/*"],
-      "@/config/*": ["./config/*"],
-      "@/shared/*": ["./app/shared/*"]
-    },
-
-    // Best practices
-    "strict": false,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "noImplicitAny": false,
-    "strictNullChecks": false,
-    "strictFunctionTypes": false,
-    "noImplicitReturns": false,
-    "noImplicitThis": false,
-
-    // Some stricter flags (disabled by default)
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
-  },
-  "exclude": [
-    "examples/**/*",
-    "**/*.test.ts",
-    "**/__tests__/**/*",
-    "run-env-tests.ts"
-  ]
-}

package/vite.config.ts

@@ -1,42 +0,0 @@
-import { defineConfig } from 'vite'
-import react from '@vitejs/plugin-react'
-import tailwindcss from '@tailwindcss/vite'
-import { resolve } from 'path'
-import { fileURLToPath, URL } from 'node:url'
-
-const __dirname = fileURLToPath(new URL('.', import.meta.url))
-
-// https://vite.dev/config/
-export default defineConfig({
-  plugins: [react(), tailwindcss()],
-  root: 'app/client',
-  server: {
-    port: 5173,
-    host: true,
-    proxy: {
-      '/api': {
-        target: 'http://localhost:3000',
-        changeOrigin: true,
-        secure: false,
-      }
-    }
-  },
-  build: {
-    outDir: '../../dist/client'
-  },
-  resolve: {
-    alias: {
-      '@': resolve(__dirname, './app/client/src'),
-      '@/core': resolve(__dirname, './core'),
-      '@/app': resolve(__dirname, './app'),
-      '@/config': resolve(__dirname, './config'),
-      '@/shared': resolve(__dirname, './app/shared'),
-      '@/components': resolve(__dirname, './app/client/src/components'),
-      '@/utils': resolve(__dirname, './app/client/src/utils'),
-      '@/hooks': resolve(__dirname, './app/client/src/hooks'),
-      '@/assets': resolve(__dirname, './app/client/src/assets'),
-      '@/lib': resolve(__dirname, './app/client/src/lib'),
-      '@/types': resolve(__dirname, './app/client/src/types')
-    }
-  }
-})