create-fluxstack 1.0.2 → 1.0.4

package/teste-final-npm/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/teste-final-npm/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/teste-final-npm/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/teste-final-npm/package-template.json

@@ -0,0 +1,51 @@
+{
+  "name": "PROJECT_NAME",
+  "version": "1.0.0",
+  "description": "PROJECT_NAME - FluxStack application",
+  "keywords": ["fluxstack", "bun", "typescript", "full-stack", "elysia", "react", "vite"],
+  "author": "Your Name",
+  "license": "MIT",
+  "type": "module",
+  "scripts": {
+    "dev": "bun core/cli/index.ts dev",
+    "dev:clean": "bun run-clean.ts",
+    "dev:backend": "bun core/cli/index.ts dev:backend",
+    "dev:frontend": "bun core/cli/index.ts dev:frontend",
+    "build": "bun core/cli/index.ts build",
+    "build:backend": "bun core/cli/index.ts build:backend",
+    "build:frontend": "bun core/cli/index.ts build:frontend",
+    "start": "NODE_ENV=production bun app/server/index.ts",
+    "start:backend": "NODE_ENV=production bun app/server/backend-only.ts",
+    "start:frontend": "NODE_ENV=production bun app/client/frontend-only.ts",
+    "typecheck": "bunx tsc --noEmit",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage"
+  },
+  "dependencies": {
+    "@types/react": "^19.1.2",
+    "@types/react-dom": "^19.1.5",
+    "@vitejs/plugin-react": "^4.3.6",
+    "elysia": "^1.4.6",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "tailwindcss": "^4.1.0",
+    "typescript": "^5.9.2",
+    "vite": "^7.0.4",
+    "vitest": "^2.2.0"
+  },
+  "devDependencies": {
+    "@eden-treaty/elysia": "^1.1.5",
+    "@swagger-ui/dist": "^5.19.2",
+    "@types/bun": "latest",
+    "@vitest/coverage-v8": "^2.2.0",
+    "@vitest/ui": "^2.2.0",
+    "happy-dom": "^16.7.0"
+  },
+  "engines": {
+    "bun": ">=1.2.0",
+    "node": ">=20.0.0"
+  },
+  "preferredPackageManager": "bun",
+  "trustedDependencies": ["esbuild"]
+}

package/teste-final-npm/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "teste-final-npm",
+  "version": "1.0.0",
+  "description": "teste-final-npm - FluxStack application",
+  "keywords": ["fluxstack", "bun", "typescript", "full-stack", "elysia", "react", "vite"],
+  "author": "Your Name",
+  "license": "MIT",
+  "type": "module",
+  "scripts": {
+    "dev": "bun core/cli/index.ts dev",
+    "dev:clean": "bun run-clean.ts",
+    "dev:backend": "bun core/cli/index.ts dev:backend",
+    "dev:frontend": "bun core/cli/index.ts dev:frontend",
+    "build": "bun core/cli/index.ts build",
+    "build:backend": "bun core/cli/index.ts build:backend",
+    "build:frontend": "bun core/cli/index.ts build:frontend",
+    "start": "NODE_ENV=production bun app/server/index.ts",
+    "start:backend": "NODE_ENV=production bun app/server/backend-only.ts",
+    "start:frontend": "NODE_ENV=production bun app/client/frontend-only.ts",
+    "typecheck": "bunx tsc --noEmit",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage"
+  },
+  "dependencies": {
+    "@types/react": "^19.1.2",
+    "@types/react-dom": "^19.1.5",
+    "@vitejs/plugin-react": "^4.3.6",
+    "elysia": "^1.4.6",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "tailwindcss": "^4.1.0",
+    "typescript": "^5.9.2",
+    "vite": "^7.0.4",
+    "vitest": "^2.2.0"
+  },
+  "devDependencies": {
+    "@eden-treaty/elysia": "^1.1.5",
+    "@swagger-ui/dist": "^5.19.2",
+    "@types/bun": "latest",
+    "@vitest/coverage-v8": "^2.2.0",
+    "@vitest/ui": "^2.2.0",
+    "happy-dom": "^16.7.0"
+  },
+  "engines": {
+    "bun": ">=1.2.0",
+    "node": ">=20.0.0"
+  },
+  "preferredPackageManager": "bun",
+  "trustedDependencies": ["esbuild"]
+}

package/teste-final-npm/tsconfig.json

@@ -0,0 +1,51 @@
+{
+  "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/teste-final-npm/vite.config.ts

@@ -0,0 +1,42 @@
+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')
+    }
+  }
+})