create-fluxstack 1.1.0 → 1.4.0

package/config/build.config.ts

@@ -0,0 +1,24 @@
+/**
+ * Build & Client Configuration
+ * Declarative build and client config for FluxStack framework
+ */
+
+import { defineConfig, config } from '@/core/utils/config-schema'
+
+export const buildConfig = defineConfig({
+  // Client build settings
+  clientBuildDir: config.string('CLIENT_BUILD_DIR', 'dist/client'),
+  clientSourceMaps: config.boolean('CLIENT_SOURCEMAPS', false),
+  clientMinify: config.boolean('CLIENT_MINIFY', true),
+  clientTarget: config.string('CLIENT_TARGET', 'es2020'),
+
+  // API proxy settings
+  apiUrl: config.string('API_URL', 'http://localhost:3000'),
+  proxyChangeOrigin: config.boolean('PROXY_CHANGE_ORIGIN', true),
+
+  // Monitoring
+  monitoringEnabled: config.boolean('MONITORING_ENABLED', false)
+})
+
+export type BuildConfig = typeof buildConfig
+export default buildConfig

package/config/database.config.ts

@@ -0,0 +1,99 @@
+/**
+ * Database Configuration
+ * Laravel-style declarative config with validation
+ */
+
+import { defineConfig, config } from '@/core/utils/config-schema'
+
+/**
+ * Database configuration schema
+ */
+export const databaseConfig = defineConfig({
+  // Connection
+  url: {
+    type: 'string',
+    env: 'DATABASE_URL',
+    default: undefined,
+    required: false,
+    validate: (value) => {
+      if (!value) return true // Optional
+      if (!value.includes('://')) {
+        return 'DATABASE_URL must be a valid connection string (e.g., postgres://...)'
+      }
+      return true
+    },
+    description: 'Full database connection URL (overrides individual settings)'
+  },
+
+  host: config.string('DB_HOST', 'localhost'),
+
+  port: config.number('DB_PORT', 5432),
+
+  database: {
+    type: 'string',
+    env: 'DB_NAME',
+    default: undefined,
+    required: false,
+    description: 'Database name'
+  },
+
+  user: {
+    type: 'string',
+    env: 'DB_USER',
+    default: undefined,
+    required: false
+  },
+
+  password: {
+    type: 'string',
+    env: 'DB_PASSWORD',
+    default: undefined,
+    required: false
+  },
+
+  // Connection pool
+  poolMin: {
+    type: 'number',
+    env: 'DB_POOL_MIN',
+    default: 2,
+    validate: (value) => value >= 0 || 'Pool min must be >= 0'
+  },
+
+  poolMax: {
+    type: 'number',
+    env: 'DB_POOL_MAX',
+    default: 10,
+    validate: (value) => value > 0 || 'Pool max must be > 0'
+  },
+
+  // SSL
+  ssl: config.boolean('DB_SSL', false),
+
+  // Timeouts
+  connectionTimeout: {
+    type: 'number',
+    env: 'DB_CONNECTION_TIMEOUT',
+    default: 30000,
+    description: 'Connection timeout in milliseconds'
+  },
+
+  queryTimeout: {
+    type: 'number',
+    env: 'DB_QUERY_TIMEOUT',
+    default: 60000,
+    description: 'Query timeout in milliseconds'
+  },
+
+  // Features
+  enableLogging: config.boolean('DB_ENABLE_LOGGING', false),
+
+  enableMigrations: config.boolean('DB_ENABLE_MIGRATIONS', true),
+
+  migrationsTable: config.string('DB_MIGRATIONS_TABLE', 'migrations')
+})
+
+// Export type
+export type DatabaseConfig = typeof databaseConfig
+
+// Export default
+export default databaseConfig

package/config/index.ts

@@ -0,0 +1,68 @@
+/**
+ * ⚡ FluxStack Configuration Index
+ *
+ * Centralized configuration using Laravel-style declarative schemas
+ *
+ * @example
+ * ```ts
+ * import { appConfig, databaseConfig, servicesConfig } from '@/config'
+ *
+ * // All configs are type-safe and validated!
+ * console.log(appConfig.name)        // string
+ * console.log(appConfig.port)        // number
+ * console.log(appConfig.debug)       // boolean
+ *
+ * // Nested configs
+ * console.log(servicesConfig.email.host)  // string
+ * console.log(servicesConfig.jwt.secret)  // string
+ * ```
+ */
+
+export { appConfig } from './app.config'
+export { databaseConfig } from './database.config'
+export { servicesConfig } from './services.config'
+export { serverConfig } from './server.config'
+export { loggerConfig } from './logger.config'
+export { buildConfig } from './build.config'
+export { appRuntimeConfig } from './runtime.config'
+export { systemConfig, systemRuntimeInfo } from './system.config'
+
+// Re-export types
+export type { AppConfig } from './app.config'
+export type { DatabaseConfig } from './database.config'
+export type { ServerConfig } from './server.config'
+export type { LoggerConfig } from './logger.config'
+export type { BuildConfig } from './build.config'
+export type { SystemConfig, SystemRuntimeInfo } from './system.config'
+export type {
+  EmailConfig,
+  JWTConfig,
+  StorageConfig,
+  RedisConfig
+} from './services.config'
+
+/**
+ * All configs in one object
+ */
+import { appConfig } from './app.config'
+import { databaseConfig } from './database.config'
+import { servicesConfig } from './services.config'
+import { serverConfig } from './server.config'
+import { loggerConfig } from './logger.config'
+import { buildConfig } from './build.config'
+import { appRuntimeConfig } from './runtime.config'
+import { systemConfig, systemRuntimeInfo } from './system.config'
+
+export const config = {
+  app: appConfig,
+  database: databaseConfig,
+  services: servicesConfig,
+  server: serverConfig,
+  logger: loggerConfig,
+  build: buildConfig,
+  runtime: appRuntimeConfig,
+  system: systemConfig,
+  systemRuntime: systemRuntimeInfo
+}
+
+export default config

package/config/logger.config.ts

@@ -0,0 +1,27 @@
+/**
+ * Logger Configuration
+ * Declarative logger config using FluxStack config system
+ */
+
+import { defineConfig, config } from '@/core/utils/config-schema'
+
+export const loggerConfig = defineConfig({
+  // Log level
+  level: config.enum('LOG_LEVEL', ['debug', 'info', 'warn', 'error'] as const, 'info'),
+
+  // Format settings
+  dateFormat: config.string('LOG_DATE_FORMAT', 'YYYY-MM-DD HH:mm:ss'),
+  objectDepth: config.number('LOG_OBJECT_DEPTH', 4),
+
+  // File logging
+  logToFile: config.boolean('LOG_TO_FILE', false),
+  maxSize: config.string('LOG_MAX_SIZE', '20m'),
+  maxFiles: config.string('LOG_MAX_FILES', '14d'),
+
+  // Display options
+  enableColors: config.boolean('LOG_COLORS', true),
+  enableStackTrace: config.boolean('LOG_STACK_TRACE', true)
+})
+
+export type LoggerConfig = typeof loggerConfig
+export default loggerConfig

package/config/runtime.config.ts

@@ -0,0 +1,92 @@
+/**
+ * Runtime-Reloadable Configuration
+ * Configs that can be reloaded without server restart
+ */
+
+import { defineReactiveConfig, config } from '@/core/utils/config-schema'
+
+/**
+ * Runtime app configuration
+ * Can be reloaded via appRuntimeConfig.reload()
+ */
+export const appRuntimeConfig = defineReactiveConfig({
+  // Features that can be toggled in runtime
+  enableSwagger: config.boolean('ENABLE_SWAGGER', true),
+  enableMetrics: config.boolean('ENABLE_METRICS', false),
+  enableMonitoring: config.boolean('ENABLE_MONITORING', false),
+  enableDebugMode: config.boolean('DEBUG', false),
+
+  // Logging level can be changed in runtime
+  logLevel: config.enum(
+    'LOG_LEVEL',
+    ['debug', 'info', 'warn', 'error'] as const,
+    'info'
+  ),
+
+  logFormat: config.enum(
+    'LOG_FORMAT',
+    ['json', 'pretty'] as const,
+    'pretty'
+  ),
+
+  // Rate limiting
+  rateLimitEnabled: config.boolean('RATE_LIMIT_ENABLED', true),
+
+  rateLimitMax: {
+    type: 'number' as const,
+    env: 'RATE_LIMIT_MAX',
+    default: 100,
+    validate: (value: number) => value > 0 || 'Rate limit must be positive'
+  },
+
+  rateLimitWindow: {
+    type: 'number' as const,
+    env: 'RATE_LIMIT_WINDOW',
+    default: 60000,
+    description: 'Rate limit window in milliseconds'
+  },
+
+  // Request timeout
+  requestTimeout: {
+    type: 'number' as const,
+    env: 'REQUEST_TIMEOUT',
+    default: 30000,
+    validate: (value: number) => value > 0 || 'Timeout must be positive'
+  },
+
+  // Max upload size
+  maxUploadSize: {
+    type: 'number' as const,
+    env: 'MAX_UPLOAD_SIZE',
+    default: 10485760, // 10MB
+    validate: (value: number) => value > 0 || 'Max upload size must be positive'
+  },
+
+  // Allowed origins (can be updated in runtime)
+  corsOrigins: config.array('CORS_ORIGINS', ['*']),
+
+  // Maintenance mode
+  maintenanceMode: config.boolean('MAINTENANCE_MODE', false),
+
+  maintenanceMessage: config.string(
+    'MAINTENANCE_MESSAGE',
+    'System is under maintenance. Please try again later.'
+  )
+})
+
+/**
+ * Setup config watcher with logging
+ */
+appRuntimeConfig.watch((newConfig) => {
+  console.log('🔄 Runtime config reloaded:')
+  console.log('   Debug:', newConfig.enableDebugMode)
+  console.log('   Log Level:', newConfig.logLevel)
+  console.log('   Maintenance:', newConfig.maintenanceMode)
+})
+
+/**
+ * Export type
+ */
+export type AppRuntimeConfig = typeof appRuntimeConfig.values
+
+export default appRuntimeConfig

package/config/server.config.ts

@@ -0,0 +1,46 @@
+/**
+ * Server Configuration
+ * Declarative server config using FluxStack config system
+ */
+
+import { defineConfig, config } from '@/core/utils/config-schema'
+
+const serverConfigSchema = {
+  // Server basics
+  port: config.number('PORT', 3000, true),
+  host: config.string('HOST', 'localhost', true),
+  apiPrefix: config.string('API_PREFIX', '/api'),
+
+  // CORS configuration
+  corsOrigins: config.array('CORS_ORIGINS', ['http://localhost:3000', 'http://localhost:5173']),
+  corsMethods: config.array('CORS_METHODS', ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS']),
+  corsHeaders: config.array('CORS_HEADERS', ['Content-Type', 'Authorization']),
+  corsCredentials: config.boolean('CORS_CREDENTIALS', false),
+  corsMaxAge: config.number('CORS_MAX_AGE', 86400),
+
+  // Client config
+  clientPort: config.number('VITE_PORT', 5173),
+  clientTarget: config.string('CLIENT_TARGET', 'es2020'),
+  clientOutDir: config.string('CLIENT_OUTDIR', 'dist'),
+  clientSourceMaps: config.boolean('CLIENT_SOURCEMAPS', false),
+
+  // Backend-only mode
+  backendPort: config.number('BACKEND_PORT', 3001),
+
+  // App info
+  appName: config.string('FLUXSTACK_APP_NAME', 'FluxStack'),
+  appVersion: config.string('FLUXSTACK_APP_VERSION', '1.0.0'),
+
+  // Features
+  enableSwagger: config.boolean('ENABLE_SWAGGER', true),
+  enableMetrics: config.boolean('ENABLE_METRICS', false),
+  enableMonitoring: config.boolean('ENABLE_MONITORING', false),
+
+  // Vite/Development
+  enableViteProxyLogs: config.boolean('ENABLE_VITE_PROXY_LOGS', false)
+} as const
+
+export const serverConfig = defineConfig(serverConfigSchema)
+
+export type ServerConfig = typeof serverConfig
+export default serverConfig

package/config/services.config.ts

@@ -0,0 +1,130 @@
+/**
+ * External Services Configuration
+ * Laravel-style declarative config for third-party services
+ */
+
+import { defineConfig, defineNestedConfig, config } from '@/core/utils/config-schema'
+
+/**
+ * Email service configuration
+ */
+const emailSchema = {
+  // SMTP
+  host: config.string('SMTP_HOST'),
+
+  port: {
+    type: 'number' as const,
+    env: 'SMTP_PORT',
+    default: 587,
+    validate: (value: number) => value > 0 || 'SMTP port must be positive'
+  },
+
+  user: config.string('SMTP_USER'),
+  password: config.string('SMTP_PASSWORD'),
+
+  secure: config.boolean('SMTP_SECURE', false),
+
+  from: {
+    type: 'string' as const,
+    env: 'SMTP_FROM',
+    default: 'noreply@example.com',
+    validate: (value: string) => {
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+      return emailRegex.test(value) || 'From email must be valid'
+    }
+  },
+
+  replyTo: config.string('SMTP_REPLY_TO')
+}
+
+/**
+ * JWT authentication configuration
+ */
+const jwtSchema = {
+  secret: {
+    type: 'string' as const,
+    env: 'JWT_SECRET',
+    default: undefined,
+    required: false,
+    validate: (value: string) => {
+      if (!value) return true // Optional
+      if (value.length < 32) {
+        return 'JWT secret must be at least 32 characters for security'
+      }
+      return true
+    }
+  },
+
+  expiresIn: config.string('JWT_EXPIRES_IN', '24h'),
+
+  algorithm: config.enum(
+    'JWT_ALGORITHM',
+    ['HS256', 'HS384', 'HS512', 'RS256', 'RS384', 'RS512'] as const,
+    'HS256'
+  ),
+
+  issuer: config.string('JWT_ISSUER', 'fluxstack'),
+
+  audience: config.string('JWT_AUDIENCE')
+}
+
+/**
+ * Storage configuration
+ */
+const storageSchema = {
+  provider: config.enum(
+    'STORAGE_PROVIDER',
+    ['local', 's3', 'gcs', 'azure'] as const,
+    'local'
+  ),
+
+  uploadPath: config.string('UPLOAD_PATH', './uploads'),
+
+  maxFileSize: {
+    type: 'number' as const,
+    env: 'MAX_FILE_SIZE',
+    default: 10485760, // 10MB
+    validate: (value: number) => value > 0 || 'Max file size must be positive'
+  },
+
+  allowedTypes: config.array('ALLOWED_FILE_TYPES', ['image/*', 'application/pdf']),
+
+  // S3 specific
+  s3Bucket: config.string('S3_BUCKET'),
+  s3Region: config.string('S3_REGION', 'us-east-1'),
+  s3AccessKey: config.string('S3_ACCESS_KEY'),
+  s3SecretKey: config.string('S3_SECRET_KEY')
+}
+
+/**
+ * Redis configuration
+ */
+const redisSchema = {
+  host: config.string('REDIS_HOST', 'localhost'),
+  port: config.number('REDIS_PORT', 6379),
+  password: config.string('REDIS_PASSWORD'),
+  db: config.number('REDIS_DB', 0),
+
+  keyPrefix: config.string('REDIS_KEY_PREFIX', 'fluxstack:'),
+
+  enableTls: config.boolean('REDIS_TLS', false)
+}
+
+/**
+ * Export all service configs as nested object
+ */
+export const servicesConfig = defineNestedConfig({
+  email: emailSchema,
+  jwt: jwtSchema,
+  storage: storageSchema,
+  redis: redisSchema
+})
+
+// Export types
+export type EmailConfig = typeof servicesConfig.email
+export type JWTConfig = typeof servicesConfig.jwt
+export type StorageConfig = typeof servicesConfig.storage
+export type RedisConfig = typeof servicesConfig.redis
+
+// Export default
+export default servicesConfig

package/config/system.config.ts

@@ -0,0 +1,105 @@
+/**
+ * System Runtime Configuration
+ * System information and environment variables
+ */
+
+import { defineConfig, config } from '@/core/utils/config-schema'
+
+/**
+ * System environment variables config
+ */
+export const systemConfig = defineConfig({
+  // User/System info
+  user: config.string('USER', ''),
+  username: config.string('USERNAME', ''),
+  home: config.string('HOME', ''),
+  userProfile: config.string('USERPROFILE', ''),
+
+  // Paths
+  pwd: config.string('PWD', ''),
+  path: config.string('PATH', ''),
+
+  // Shell
+  shell: config.string('SHELL', ''),
+  term: config.string('TERM', ''),
+
+  // Common environment variables
+  lang: config.string('LANG', 'en_US.UTF-8'),
+  tmpDir: config.string('TMPDIR', ''),
+
+  // CI/CD detection
+  ci: config.boolean('CI', false),
+
+  // Computed helpers (not from env)
+  get currentUser() {
+    return this.user || this.username || 'unknown'
+  },
+
+  get homeDirectory() {
+    return this.home || this.userProfile || ''
+  },
+
+  get isCI() {
+    return this.ci
+  }
+})
+
+/**
+ * System runtime info (from Node.js/Bun process)
+ * These are not from environment variables, but from runtime
+ */
+export const systemRuntimeInfo = {
+  get nodeVersion() {
+    return process.version
+  },
+
+  get bunVersion() {
+    return (process.versions as any).bun || 'N/A'
+  },
+
+  get platform() {
+    return process.platform
+  },
+
+  get architecture() {
+    return process.arch
+  },
+
+  get cpuCount() {
+    return require('os').cpus().length
+  },
+
+  get totalMemory() {
+    const os = require('os')
+    return Math.round(os.totalmem() / 1024 / 1024 / 1024 * 100) / 100 // GB
+  },
+
+  get workingDirectory() {
+    return process.cwd()
+  },
+
+  get executablePath() {
+    return process.execPath
+  },
+
+  get uptime() {
+    return process.uptime()
+  },
+
+  get memoryUsage() {
+    const usage = process.memoryUsage()
+    return {
+      rss: Math.round(usage.rss / 1024 / 1024 * 100) / 100, // MB
+      heapTotal: Math.round(usage.heapTotal / 1024 / 1024 * 100) / 100,
+      heapUsed: Math.round(usage.heapUsed / 1024 / 1024 * 100) / 100,
+      external: Math.round(usage.external / 1024 / 1024 * 100) / 100
+    }
+  }
+}
+
+// Export types
+export type SystemConfig = typeof systemConfig
+export type SystemRuntimeInfo = typeof systemRuntimeInfo
+
+// Export default
+export default systemConfig

package/core/build/index.ts

@@ -1,4 +1,4 @@
-import { copyFileSync, writeFileSync, existsSync, mkdirSync } from "fs"
+import { copyFileSync, writeFileSync, existsSync, mkdirSync, readFileSync } from "fs"
 import { join } from "path"
 import type { FluxStackConfig } from "../config"
 import type { BuildResult, BuildManifest } from "../types/build"
@@ -177,9 +177,15 @@ coverage
     console.log(`  - target path: ${distEnvPath}`)
     
     if (existsSync(envPath)) {
-      console.log(`📄 Copying .env file...`)
-      copyFileSync(envPath, distEnvPath)
-      console.log("📄 Environment file copied to dist/")
+      console.log(`📄 Copying .env file and setting production mode...`)
+      // Read .env content
+      let envContent = readFileSync(envPath, 'utf-8')
+      // Replace development with production
+      envContent = envContent.replace(/NODE_ENV=development/g, 'NODE_ENV=production')
+      envContent = envContent.replace(/VITE_NODE_ENV=development/g, 'VITE_NODE_ENV=production')
+      // Write to dist
+      writeFileSync(distEnvPath, envContent)
+      console.log("📄 Environment file copied to dist/ (NODE_ENV=production)")
     } else if (existsSync(envExamplePath)) {
       console.log(`📄 Copying .env.example file...`)
       copyFileSync(envExamplePath, distEnvPath)

package/core/cli/index.ts

@@ -6,6 +6,7 @@ import { getConfigSync } from "../config"
 import { cliRegistry } from "./command-registry"
 import { pluginDiscovery } from "./plugin-discovery"
 import { generateCommand, interactiveGenerateCommand } from "./generators/index.js"
+import { startGroup, endGroup, logBox, logInGroup } from "../utils/logger/group-logger"
 
 const command = process.argv[2]
 const args = process.argv.slice(3)
@@ -134,12 +135,20 @@ Examples:
       }
     ],
     handler: async (args, options, context) => {
-      console.log("⚡ FluxStack Full-Stack Development")
-      console.log(`🌐 Frontend: http://localhost:${options['frontend-port']}`)  
-      console.log(`🚀 Backend: http://localhost:${options.port}`)
-      console.log("🔄 Backend inicia Vite programaticamente - Zero órfãos!")
-      console.log("📦 Starting backend server...")
-      console.log()
+      // Grouped startup messages
+      startGroup({
+        title: 'FluxStack Development Server',
+        icon: '⚡',
+        color: 'cyan'
+      })
+
+      logInGroup(`Frontend: http://localhost:${options['frontend-port']}`, '🌐')
+      logInGroup(`Backend: http://localhost:${options.port}`, '🚀')
+      logInGroup('Backend inicia Vite programaticamente', '🔄')
+      logInGroup('Starting backend server...', '📦')
+
+      endGroup()
+      console.log('') // Separator line
       
       const { spawn } = await import("child_process")
       const devProcess = spawn("bun", ["--watch", "app/server/index.ts"], {
@@ -293,12 +302,20 @@ async function main() {
 async function handleLegacyCommands() {
   switch (command) {
   case "dev":
-    console.log("⚡ FluxStack Full-Stack Development")
-    console.log("🌐 Frontend: http://localhost:5173")  
-    console.log("🚀 Backend: http://localhost:3000")
-    console.log("🔄 Backend inicia Vite programaticamente - Zero órfãos!")
-    console.log("📦 Starting backend server...")
-    console.log()
+    // Grouped startup messages
+    startGroup({
+      title: 'FluxStack Development Server',
+      icon: '⚡',
+      color: 'cyan'
+    })
+
+    logInGroup('Frontend: http://localhost:5173', '🌐')
+    logInGroup('Backend: http://localhost:3000', '🚀')
+    logInGroup('Backend inicia Vite programaticamente', '🔄')
+    logInGroup('Starting backend server...', '📦')
+
+    endGroup()
+    console.log('') // Separator line
     
     // Start only backend - it will start Vite programmatically
     const { spawn } = await import("child_process")