create-fluxstack 1.10.1 → 1.12.1

package/config/system/build.config.ts

@@ -0,0 +1,49 @@
+/**
+ * Build Configuration
+ * Server build and optimization settings
+ */
+
+import { defineConfig, defineNestedConfig, config } from '@core/utils/config-schema'
+import { helpers } from '@core/utils/env'
+
+/**
+ * Build optimization schema
+ */
+const optimizationSchema = {
+  minify: config.boolean('BUILD_MINIFY', helpers.isProduction()),
+  treeshake: config.boolean('BUILD_TREESHAKE', true),
+  compress: config.boolean('BUILD_COMPRESS', helpers.isProduction()),
+  splitChunks: config.boolean('BUILD_SPLIT_CHUNKS', true),
+  bundleAnalyzer: config.boolean('BUILD_BUNDLE_ANALYZER', false),
+  removeUnusedCSS: config.boolean('BUILD_REMOVE_UNUSED_CSS', false),
+  optimizeImages: config.boolean('BUILD_OPTIMIZE_IMAGES', false)
+} as const
+
+/**
+ * Build configuration schema
+ */
+const buildSchema = {
+  target: config.enum('BUILD_TARGET', ['bun', 'node', 'docker'] as const, 'bun', true),
+  outDir: config.string('BUILD_OUT_DIR', 'dist', true),
+  sourceMaps: config.boolean('BUILD_SOURCE_MAPS', helpers.isDevelopment()),
+  clean: config.boolean('BUILD_CLEAN', true),
+  mode: config.enum('BUILD_MODE', ['development', 'production'] as const, helpers.isProduction() ? 'production' : 'development'),
+  external: config.array('BUILD_EXTERNAL', []),
+  optimize: config.boolean('BUILD_OPTIMIZE', true)
+} as const
+
+/**
+ * Export build config (nested with optimization)
+ */
+export const buildConfig = defineNestedConfig({
+  build: buildSchema,
+  optimization: optimizationSchema
+})
+
+// Export types
+export type BuildConfig = typeof buildConfig.build
+export type OptimizationConfig = typeof buildConfig.optimization
+export type BuildFullConfig = typeof buildConfig
+
+// Export default
+export default buildConfig

package/config/system/client.config.ts

@@ -0,0 +1,68 @@
+/**
+ * Client & Vite Configuration
+ * Declarative client, proxy and Vite dev server configuration
+ */
+
+import { defineConfig, defineNestedConfig, config } from '../../core/utils/config-schema'
+import { env, helpers } from '../../core/utils/env'
+
+/**
+ * Vite Dev Server Configuration
+ */
+const viteSchema = {
+  port: config.number('VITE_PORT', 5173, true),
+
+  host: config.string('VITE_HOST', 'localhost'),
+
+  strictPort: config.boolean('VITE_STRICT_PORT', true),
+
+  open: config.boolean('VITE_OPEN', false),
+
+  enableLogging: config.boolean('ENABLE_VITE_PROXY_LOGS', false),
+
+  logLevel: config.enum('VITE_LOG_LEVEL', ['error' , 'warn' , 'info', 'silent'], undefined),
+
+  allowedHosts: config.array('VITE_ALLOWED_HOSTS', ['localhost'])
+} as const
+
+/**
+ * Client Build Configuration
+ */
+const buildSchema = {
+  outDir: config.string('CLIENT_OUTDIR', 'dist/client'),
+
+  sourceMaps: config.boolean('CLIENT_SOURCEMAPS', helpers.isDevelopment()),
+
+  minify: config.boolean('CLIENT_MINIFY', helpers.isProduction()),
+
+  target: config.string('CLIENT_TARGET', 'esnext'),
+
+  assetsDir: config.string('CLIENT_ASSETS_DIR', 'assets'),
+
+  cssCodeSplit: config.boolean('CLIENT_CSS_CODE_SPLIT', true),
+
+  chunkSizeWarningLimit: config.number('CLIENT_CHUNK_SIZE_WARNING', 500), // KB
+
+  emptyOutDir: config.boolean('CLIENT_EMPTY_OUTDIR', true)
+} as const
+
+/**
+ * Client Configuration (nested)
+ */
+export const clientConfig = defineNestedConfig({
+  vite: viteSchema,
+  build: buildSchema,
+})
+
+// ℹ️ Proxy config removed: Not needed in FluxStack architecture
+// All requests go through Elysia (localhost:3000):
+//   - /api, /swagger → Elysia handlers (viteExcludePaths)
+//   - Everything else → Proxy to Vite dev server (handled by core/plugins/built-in/vite)
+
+// Export types
+export type ViteConfig = typeof clientConfig.vite
+export type ClientBuildConfig = typeof clientConfig.build
+export type ClientConfig = typeof clientConfig
+
+// Export default
+export default clientConfig

package/config/system/database.config.ts

@@ -0,0 +1,17 @@
+/**
+ * Database Configuration
+ * Optional database settings for backward compatibility
+ */
+
+import { defineConfig, config } from '@core/utils/config-schema'
+
+export const databaseConfig = defineConfig({
+  url: config.string('DATABASE_URL', ''),
+  provider: config.enum('DATABASE_PROVIDER', ['postgres', 'mysql', 'sqlite', 'mssql', 'mongodb'] as const, 'postgres'),
+  connectionTimeout: config.number('DATABASE_CONNECTION_TIMEOUT', 5000),
+  ssl: config.boolean('DATABASE_SSL', false)
+})
+
+export type DatabaseConfig = typeof databaseConfig
+
+export default databaseConfig

package/config/system/fluxstack.config.ts

@@ -0,0 +1,114 @@
+/**
+ * FluxStack Main Configuration
+ * Composes all modular system configs into a single unified configuration
+ *
+ * ✨ 100% modular and type-safe using defineConfig
+ * ✨ No composer needed - direct config composition
+ * ✨ All configs use defineConfig for automatic validation and inference
+ */
+
+import { appConfig } from './app.config'
+import { serverConfig } from './server.config'
+import { clientConfig } from './client.config'
+import { buildConfig } from './build.config'
+import { loggerConfig } from './logger.config'
+import { pluginsConfig } from './plugins.config'
+import { monitoringConfig } from './monitoring.config'
+import { appRuntimeConfig } from './runtime.config'
+import { systemConfig } from './system.config'
+import { databaseConfig } from './database.config'
+import { servicesConfig } from './services.config'
+
+const serverWithCors = {
+  ...serverConfig.server,
+  cors: {
+    origins: serverConfig.cors.origins,
+    methods: serverConfig.cors.methods,
+    headers: serverConfig.cors.headers,
+    credentials: serverConfig.cors.credentials,
+    maxAge: serverConfig.cors.maxAge
+  }
+}
+
+const client = {
+  port: clientConfig.vite.port,
+  host: clientConfig.vite.host,
+  build: {
+    ...clientConfig.build,
+    sourceMaps: true
+  }
+}
+
+const monitoring = {
+  ...monitoringConfig.monitoring,
+  metrics: monitoringConfig.metrics,
+  profiling: monitoringConfig.profiling
+}
+
+const environments = {
+  development: {
+    logging: { level: 'debug', format: 'pretty' },
+    build: { optimization: { ...buildConfig.optimization, minify: false } }
+  },
+  production: {
+    logging: { level: 'warn', format: 'json' },
+    monitoring: { enabled: true }
+  },
+  test: {
+    logging: { level: 'error', format: 'pretty' },
+    server: { port: 0 },
+    client: { port: 0 }
+  }
+}
+
+/**
+ * FluxStack complete configuration
+ * Direct composition of all modular configs
+ */
+export const fluxStackConfig = {
+  // Core system configs
+  app: appConfig,
+  server: serverWithCors,
+  client,
+  build: {
+    ...buildConfig.build,
+    optimization: {
+      ...buildConfig.optimization,
+      minify: true
+    }
+  },
+
+  // CORS (from server)
+  cors: serverConfig.cors,
+
+  // Client Build (from client)
+  clientBuild: clientConfig.build,
+
+  // Build optimization
+  optimization: buildConfig.optimization,
+
+  // Logging, plugins, monitoring
+  logging: loggerConfig,
+  plugins: pluginsConfig,
+  monitoring,
+
+  // Runtime & system
+  runtime: appRuntimeConfig.values,
+  system: systemConfig,
+  database: databaseConfig,
+  services: servicesConfig,
+
+  // Environment defaults (backward compatibility)
+  environments
+} as const
+
+/**
+ * Type for the complete FluxStack configuration
+ */
+export type FluxStackConfig = typeof fluxStackConfig
+
+/**
+ * Named exports
+ */
+export default fluxStackConfig
+export { fluxStackConfig as config }

package/config/{logger.config.ts → system/logger.config.ts}

@@ -3,11 +3,12 @@
  * Declarative logger config using FluxStack config system
  */
 
-import { defineConfig, config } from '@/core/utils/config-schema'
+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: config.enum('LOG_FORMAT', ['pretty', 'json'] as const, 'pretty'),
 
   // Format settings
   dateFormat: config.string('LOG_DATE_FORMAT', 'YYYY-MM-DD HH:mm:ss'),
@@ -17,6 +18,7 @@ export const loggerConfig = defineConfig({
   logToFile: config.boolean('LOG_TO_FILE', false),
   maxSize: config.string('LOG_MAX_SIZE', '20m'),
   maxFiles: config.string('LOG_MAX_FILES', '14d'),
+  transports: config.array('LOG_TRANSPORTS', ['console']),
 
   // Display options
   enableColors: config.boolean('LOG_COLORS', true),

package/config/system/monitoring.config.ts

@@ -0,0 +1,114 @@
+/**
+ * Monitoring Configuration
+ * Declarative monitoring, metrics and profiling configuration
+ */
+
+import { defineConfig, defineNestedConfig, config } from '@core/utils/config-schema'
+import { helpers } from '@core/utils/env'
+
+/**
+ * Metrics Configuration Schema
+ */
+const metricsSchema = {
+  enabled: config.boolean('ENABLE_METRICS', false),
+
+  collectInterval: {
+    type: 'number' as const,
+    env: 'METRICS_INTERVAL',
+    default: 5000,
+    validate: (value: number) => {
+      if (value < 1000) {
+        return 'Metrics interval must be at least 1000ms'
+      }
+      return true
+    }
+  },
+
+  httpMetrics: config.boolean('HTTP_METRICS', true),
+
+  systemMetrics: config.boolean('SYSTEM_METRICS', true),
+
+  customMetrics: config.boolean('CUSTOM_METRICS', false),
+
+  // Metric exporters
+  exportToConsole: config.boolean('METRICS_EXPORT_CONSOLE', helpers.isDevelopment()),
+
+  exportToFile: config.boolean('METRICS_EXPORT_FILE', false),
+
+  exportToHttp: config.boolean('METRICS_EXPORT_HTTP', false),
+
+  exportHttpUrl: config.string('METRICS_EXPORT_URL'),
+
+  // Metric storage
+  retentionPeriod: config.number('METRICS_RETENTION_PERIOD', 3600000), // 1 hour in ms
+
+  maxDataPoints: config.number('METRICS_MAX_DATA_POINTS', 1000)
+} as const
+
+/**
+ * Profiling Configuration Schema
+ */
+const profilingSchema = {
+  enabled: config.boolean('PROFILING_ENABLED', false),
+
+  sampleRate: {
+    type: 'number' as const,
+    env: 'PROFILING_SAMPLE_RATE',
+    default: helpers.isProduction() ? 0.01 : 0.1,
+    validate: (value: number) => {
+      if (value < 0 || value > 1) {
+        return 'Sample rate must be between 0 and 1'
+      }
+      return true
+    }
+  },
+
+  memoryProfiling: config.boolean('MEMORY_PROFILING', false),
+
+  cpuProfiling: config.boolean('CPU_PROFILING', false),
+
+  heapSnapshot: config.boolean('HEAP_SNAPSHOT', false),
+
+  // Profiling output
+  outputDir: config.string('PROFILING_OUTPUT_DIR', 'profiling'),
+
+  maxProfiles: config.number('PROFILING_MAX_PROFILES', 10)
+} as const
+
+/**
+ * Monitoring Configuration Schema
+ */
+const monitoringSchema = {
+  enabled: config.boolean('ENABLE_MONITORING', false),
+
+  // Exporters
+  exporters: config.array('MONITORING_EXPORTERS', []),
+
+  // Health checks
+  enableHealthChecks: config.boolean('ENABLE_HEALTH_CHECKS', true),
+
+  healthCheckInterval: config.number('HEALTH_CHECK_INTERVAL', 30000), // 30s
+
+  // Alerting
+  enableAlerts: config.boolean('ENABLE_ALERTS', false),
+
+  alertWebhook: config.string('ALERT_WEBHOOK')
+} as const
+
+/**
+ * Export monitoring config (nested)
+ */
+export const monitoringConfig = defineNestedConfig({
+  monitoring: monitoringSchema,
+  metrics: metricsSchema,
+  profiling: profilingSchema
+})
+
+// Export types
+export type MonitoringConfig = typeof monitoringConfig.monitoring
+export type MetricsConfig = typeof monitoringConfig.metrics
+export type ProfilingConfig = typeof monitoringConfig.profiling
+export type MonitoringFullConfig = typeof monitoringConfig
+
+// Export default
+export default monitoringConfig

package/config/system/plugins.config.ts

@@ -0,0 +1,84 @@
+/**
+ * Plugins Configuration
+ * Declarative plugin management configuration
+ */
+
+import { defineConfig, config } from '@core/utils/config-schema'
+import { FLUXSTACK_VERSION } from '@core/utils/version'
+
+const defaultPluginConfigs = {
+  swagger: {
+    title: 'FluxStack API',
+    version: FLUXSTACK_VERSION,
+    description: 'API documentation for FluxStack application',
+    path: '/swagger'
+  },
+  staticFiles: {
+    publicDir: 'public',
+    uploadsDir: 'uploads'
+  }
+}
+
+export const pluginsConfig = defineConfig({
+  enabled: config.array(
+    'FLUXSTACK_PLUGINS_ENABLED',
+    ['logger', 'swagger', 'vite', 'cors', 'static-files']
+  ),
+
+  disabled: config.array('FLUXSTACK_PLUGINS_DISABLED', []),
+
+  autoDiscover: config.boolean('PLUGINS_AUTO_DISCOVER', true),
+
+  pluginsDir: config.string('PLUGINS_DIR', 'plugins'),
+
+  discoverNpmPlugins: config.boolean('PLUGINS_DISCOVER_NPM', false),
+  discoverProjectPlugins: config.boolean('PLUGINS_DISCOVER_PROJECT', true),
+
+  allowedPlugins: config.array('PLUGINS_ALLOWED', []),
+  config: {
+    type: 'object' as const,
+    default: defaultPluginConfigs
+  },
+
+  loggerEnabled: config.boolean('LOGGER_PLUGIN_ENABLED', true),
+
+  swaggerEnabled: config.boolean('SWAGGER_ENABLED', true),
+  swaggerTitle: config.string('SWAGGER_TITLE', 'FluxStack API'),
+  swaggerVersion: config.string('SWAGGER_VERSION', FLUXSTACK_VERSION),
+  swaggerDescription: config.string(
+    'SWAGGER_DESCRIPTION',
+    'API documentation for FluxStack application'
+  ),
+  swaggerPath: config.string('SWAGGER_PATH', '/swagger'),
+
+  swaggerExcludePaths: config.array('SWAGGER_EXCLUDE_PATHS', []),
+
+  swaggerServers: config.string('SWAGGER_SERVERS', ''),
+
+  swaggerPersistAuthorization: config.boolean('SWAGGER_PERSIST_AUTH', true),
+  swaggerDisplayRequestDuration: config.boolean('SWAGGER_DISPLAY_DURATION', true),
+  swaggerEnableFilter: config.boolean('SWAGGER_ENABLE_FILTER', true),
+  swaggerShowExtensions: config.boolean('SWAGGER_SHOW_EXTENSIONS', true),
+  swaggerTryItOutEnabled: config.boolean('SWAGGER_TRY_IT_OUT', true),
+
+  swaggerAuthEnabled: config.boolean('SWAGGER_AUTH_ENABLED', false),
+  swaggerAuthUsername: config.string('SWAGGER_AUTH_USERNAME', 'admin'),
+  swaggerAuthPassword: config.string('SWAGGER_AUTH_PASSWORD', ''),
+
+  staticFilesEnabled: config.boolean('STATIC_FILES_ENABLED', true),
+  staticPublicDir: config.string('STATIC_PUBLIC_DIR', 'public'),
+  staticUploadsDir: config.string('STATIC_UPLOADS_DIR', 'uploads'),
+  staticCacheMaxAge: config.number('STATIC_CACHE_MAX_AGE', 31536000),
+  staticEnableUploads: config.boolean('STATIC_ENABLE_UPLOADS', true),
+  staticEnablePublic: config.boolean('STATIC_ENABLE_PUBLIC', true),
+
+  viteEnabled: config.boolean('VITE_PLUGIN_ENABLED', true),
+  viteExcludePaths: config.array('VITE_EXCLUDE_PATHS', [
+    '/api',
+    '/swagger'
+  ])
+})
+
+export type PluginsConfig = typeof pluginsConfig
+
+export default pluginsConfig

package/config/{runtime.config.ts → system/runtime.config.ts}

@@ -3,7 +3,7 @@
  * Configs that can be reloaded without server restart
  */
 
-import { defineReactiveConfig, config } from '@/core/utils/config-schema'
+import { defineReactiveConfig, config } from '@core/utils/config-schema'
 
 /**
  * Runtime app configuration

package/config/system/server.config.ts

@@ -0,0 +1,68 @@
+/**
+ * Server Configuration
+ * Server-specific settings (port, host, CORS, middleware)
+ */
+
+import { defineConfig, defineNestedConfig, config } from '@core/utils/config-schema'
+
+/**
+ * CORS configuration schema
+ */
+const corsSchema = {
+  origins: config.array('CORS_ORIGINS', ['http://localhost:3000', 'http://localhost:5173']),
+  methods: config.array('CORS_METHODS', ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS']),
+  headers: config.array('CORS_HEADERS', ['Content-Type', 'Authorization']),
+  credentials: config.boolean('CORS_CREDENTIALS', false),
+  maxAge: config.number('CORS_MAX_AGE', 86400)
+} as const
+
+/**
+ * Server configuration schema
+ */
+const serverSchema = {
+  // Server basics
+  port: {
+    type: 'number' as const,
+    env: 'PORT',
+    default: 3000,
+    required: true,
+    validate: (value: number) => {
+      if (value < 1 || value > 65535) {
+        return 'Port must be between 1 and 65535'
+      }
+      return true
+    }
+  },
+
+  host: config.string('HOST', 'localhost', true),
+
+  apiPrefix: {
+    type: 'string' as const,
+    env: 'API_PREFIX',
+    default: '/api',
+    validate: (value: string) => value.startsWith('/') || 'API prefix must start with /'
+  },
+
+  // Backend-only mode
+  backendPort: config.number('BACKEND_PORT', 3001),
+
+  // Features
+  enableRequestLogging: config.boolean('ENABLE_REQUEST_LOGGING', true),
+  showBanner: config.boolean('SHOW_SERVER_BANNER', true)
+} as const
+
+/**
+ * Export server config (nested with CORS)
+ */
+export const serverConfig = defineNestedConfig({
+  server: serverSchema,
+  cors: corsSchema
+})
+
+// Export types
+export type ServerConfig = typeof serverConfig.server
+export type CorsConfig = typeof serverConfig.cors
+export type ServerFullConfig = typeof serverConfig
+
+// Export default
+export default serverConfig

package/config/system/services.config.ts

@@ -0,0 +1,46 @@
+/**
+ * Services Configuration
+ * Optional service settings (email, JWT, storage, redis) for compatibility
+ */
+
+import { defineNestedConfig, config } from '@core/utils/config-schema'
+
+const emailSchema = {
+  host: config.string('MAIL_HOST', 'smtp.example.com'),
+  port: config.number('MAIL_PORT', 587),
+  username: config.string('MAIL_USERNAME', ''),
+  password: config.string('MAIL_PASSWORD', ''),
+  fromAddress: config.string('MAIL_FROM_ADDRESS', 'no-reply@example.com'),
+  secure: config.boolean('MAIL_SECURE', false)
+} as const
+
+const jwtSchema = {
+  secret: config.string('JWT_SECRET', 'change-me'),
+  expiresIn: config.string('JWT_EXPIRES_IN', '1h'),
+  audience: config.string('JWT_AUDIENCE', 'fluxstack'),
+  issuer: config.string('JWT_ISSUER', 'fluxstack')
+} as const
+
+const storageSchema = {
+  driver: config.enum('STORAGE_DRIVER', ['local', 's3'] as const, 'local'),
+  localDir: config.string('STORAGE_LOCAL_DIR', 'uploads'),
+  s3Bucket: config.string('STORAGE_S3_BUCKET', ''),
+  s3Region: config.string('STORAGE_S3_REGION', ''),
+  s3Endpoint: config.string('STORAGE_S3_ENDPOINT', '')
+} as const
+
+const redisSchema = {
+  enabled: config.boolean('REDIS_ENABLED', false),
+  url: config.string('REDIS_URL', 'redis://localhost:6379')
+} as const
+
+export const servicesConfig = defineNestedConfig({
+  email: emailSchema,
+  jwt: jwtSchema,
+  storage: storageSchema,
+  redis: redisSchema
+})
+
+export type ServicesConfig = typeof servicesConfig
+
+export default servicesConfig

package/config/{system.config.ts → system/system.config.ts}

@@ -3,7 +3,7 @@
  * System information and environment variables
  */
 
-import { defineConfig, config } from '@/core/utils/config-schema'
+import { defineConfig, config } from '@core/utils/config-schema'
 
 /**
  * System environment variables config