create-fluxstack 1.7.5 → 1.8.3

package/app/server/index.ts

@@ -1,125 +1,115 @@
-// User application entry point
-import { FluxStackFramework, vitePlugin, swaggerPlugin, staticPlugin, liveComponentsPlugin, staticFilesPlugin } from "@/core/server"
+/**
+ * 🚀 FluxStack Application Server Entry Point
+ * Main server configuration and initialization
+ */
+
+// ===== Core Framework =====
+import { FluxStackFramework } from "@/core/server"
 import { isDevelopment } from "@/core/utils/helpers"
 import { DEBUG } from "@/core/utils/logger"
-import { apiRoutes } from "./routes"
 import { helpers } from "@/core/utils/env"
-import { serverConfig } from "@/config/server.config"
+
+// ===== Configuration =====
 import { appConfig } from "@/config/app.config"
-import { loggerConfig } from "@/config/logger.config"
+import { serverConfig } from "@/config/server.config"
+
+// ===== Plugins =====
+import {
+  vitePlugin,
+  swaggerPlugin,
+  staticPlugin,
+  liveComponentsPlugin,
+  staticFilesPlugin
+} from "@/core/server"
 import cryptoAuthPlugin from "@/plugins/crypto-auth"
-import "./live/register-components"
 
-// Startup info moved to DEBUG level (set LOG_LEVEL=debug to see details)
+// ===== Application Routes =====
+import { appInstance } from "./app"
+
+// ===== Live Components Registration =====
+// Import auto-generated component registrations from core/ (for production build)
+// The generator creates this file in core/ to prevent accidental user modifications
+// This ensures components are registered before the plugin tries to use them
+import "@/core/server/live/auto-generated-components"
+
+// ===== Startup Logging =====
 DEBUG('🔧 Loading declarative configuration...')
 DEBUG(`📊 Environment: ${appConfig.env}`)
-DEBUG(`🚀 Port: ${serverConfig.port}`)
-DEBUG(`🌐 Host: ${serverConfig.host}`)
-
-// Criar aplicação com configuração declarativa
-const app = new FluxStackFramework({
-  server: {
-    port: serverConfig.port,
-    host: serverConfig.host,
-    apiPrefix: serverConfig.apiPrefix,
-    cors: {
-      origins: serverConfig.corsOrigins,
-      methods: serverConfig.corsMethods,
-      headers: serverConfig.corsHeaders,
-      credentials: serverConfig.corsCredentials
+DEBUG(`🚀 Port: ${serverConfig.server.port}`)
+DEBUG(`🌐 Host: ${serverConfig.server.host}`)
+
+// ===== Framework Configuration Helper =====
+/**
+ * Creates FluxStack framework configuration from declarative configs
+ */
+function createFrameworkConfig() {
+  return {
+    server: {
+      port: serverConfig.server.port,
+      host: serverConfig.server.host,
+      apiPrefix: serverConfig.server.apiPrefix,
+      cors: {
+        origins: serverConfig.cors.origins,
+        methods: serverConfig.cors.methods,
+        headers: serverConfig.cors.headers,
+        credentials: serverConfig.cors.credentials
+      },
+      middleware: []
     },
-    middleware: []
-  },
-  app: {
-    name: serverConfig.appName,
-    version: serverConfig.appVersion
-  },
-  client: {
-    port: serverConfig.clientPort,
-    proxy: {
-      target: helpers.getServerUrl()
+    app: {
+      name: appConfig.name,
+      version: appConfig.version
     },
-    build: {
-      sourceMaps: serverConfig.clientSourceMaps,
-      minify: false,
-      target: serverConfig.clientTarget as any,
-      outDir: serverConfig.clientOutDir
+    client: {
+      port: serverConfig.server.backendPort,
+      proxy: {
+        target: helpers.getServerUrl()
+      },
+      build: {
+        sourceMaps: false,
+        minify: false,
+        target: 'es2020' as any,
+        outDir: 'dist'
+      }
     }
   }
-})
+}
 
+// ===== Initialize Application =====
+const app = new FluxStackFramework(createFrameworkConfig())
 
-// Usar plugins de infraestrutura primeiro (Logger é core, não é plugin)
+// ===== Register Plugins =====
+// Note: Logger is part of core, not a plugin
 
-// Registrar plugin de autenticação ANTES dos outros plugins
+// 1. Authentication plugin (must be registered first)
 app.use(cryptoAuthPlugin)
 
-// Usar plugins condicionalmente baseado no ambiente
+// 2. Development/Production plugins (conditional)
 if (isDevelopment()) {
-  app.use(vitePlugin)
+  app.use(vitePlugin)  // Development: Vite dev server
 } else {
-  app.use(staticPlugin)
+  app.use(staticPlugin)  // Production: Static file serving
 }
 
-// Add static files AFTER Vite to avoid conflicts, but BEFORE Live Components
-app.use(staticFilesPlugin) // Add Static Files support 
-app.use(liveComponentsPlugin) // Add Live Components support
-  
+// 3. Static files (after Vite, before Live Components to avoid conflicts)
+app.use(staticFilesPlugin)
 
-// Adicionar rota de teste para mostrar config declarativo (antes das rotas)
-app.getApp().get('/api/env-test', () => {
-  return {
-    message: '⚡ Declarative Config System!',
-    timestamp: new Date().toISOString(),
-    serverConfig: {
-      port: serverConfig.port,
-      host: serverConfig.host,
-      apiPrefix: serverConfig.apiPrefix,
-      appName: serverConfig.appName,
-      appVersion: serverConfig.appVersion,
-      cors: {
-        origins: serverConfig.corsOrigins,
-        methods: serverConfig.corsMethods,
-        credentials: serverConfig.corsCredentials
-      },
-      client: {
-        port: serverConfig.clientPort,
-        target: serverConfig.clientTarget,
-        sourceMaps: serverConfig.clientSourceMaps
-      },
-      features: {
-        enableSwagger: serverConfig.enableSwagger,
-        enableMetrics: serverConfig.enableMetrics,
-        enableMonitoring: serverConfig.enableMonitoring
-      }
-    },
-    environment: {
-      NODE_ENV: appConfig.env,
-      DEBUG: appConfig.debug,
-      LOG_LEVEL: loggerConfig.level
-    },
-    urls: {
-      server: helpers.getServerUrl(),
-      client: helpers.getClientUrl(),
-      swagger: `${helpers.getServerUrl()}/swagger`
-    },
-    system: {
-      version: 'declarative-config',
-      features: ['type-safe', 'validated', 'declarative', 'runtime-reload']
-    }
-  }
-})
+// 4. Live Components (WebSocket support)
+app.use(liveComponentsPlugin)
 
-// Registrar rotas da aplicação DEPOIS da rota de teste
-app.routes(apiRoutes)
+// ===== Register Routes =====
+// Note: Routes are now registered in app.ts (including envTestRoute)
+app.routes(appInstance)
 
-// Swagger por último para descobrir todas as rotas
+// ===== Final Setup =====
+
+// Swagger documentation (must be last to discover all routes)
 app.use(swaggerPlugin)
 
-// Iniciar servidor (banner displayed by framework)
+// ===== Start Server =====
+// Banner will be displayed automatically by the framework
 app.listen()
 
-
-
-// Exportar tipo da aplicação para Eden Treaty (método correto)
+// ===== Eden Treaty Type Export =====
+// Export application type for type-safe client communication
 export type App = typeof app

package/app/server/live/register-components.ts

@@ -1,8 +1,19 @@
-// 🧪 Manual Registration REMOVED for Auto-Generation Testing
-// This file is intentionally left empty to test the auto-generation system
-// The build system should automatically generate all imports and registrations
+// ⚠️ DEPRECATION NOTICE
+// This file has been moved to: core/server/live/auto-generated-components.ts
+//
+// The auto-generated component registration is now located in the core/ directory
+// to prevent accidental user modifications and keep framework code separate from
+// application code.
+//
+// If you're looking for component registration logic:
+// - Generated file: core/server/live/auto-generated-components.ts (auto-generated during build)
+// - Generator: core/build/live-components-generator.ts
+// - Import location: app/server/index.ts
+//
+// To add new Live Components:
+// 1. Create your component class in this directory (app/server/live/)
+// 2. Extend LiveComponent class
+// 3. Run 'bun run build' to regenerate the registration file
 
-// NOTE: If you see this in production, auto-generation worked!
-// All Live Components should be discovered and registered automatically during build
-
-// Removed startup log to keep output clean - auto-generation handles everything
+// This file intentionally left empty - do not import
+export {}

package/app/server/routes/env-test.ts

@@ -0,0 +1,110 @@
+/**
+ * 🔧 Environment Test Route
+ * Displays current configuration for debugging purposes
+ */
+
+import { Elysia, t } from 'elysia'
+import { appConfig } from '@/config/app.config'
+import { serverConfig } from '@/config/server.config'
+import { loggerConfig } from '@/config/logger.config'
+import { appRuntimeConfig } from '@/config/runtime.config'
+import { helpers } from '@/core/utils/env'
+
+// Response schema for environment test
+const EnvTestResponseSchema = t.Object({
+  message: t.String(),
+  timestamp: t.String(),
+  serverConfig: t.Object({
+    port: t.Number(),
+    host: t.String(),
+    apiPrefix: t.String(),
+    appName: t.String(),
+    appVersion: t.String(),
+    cors: t.Object({
+      origins: t.Array(t.String()),
+      methods: t.Array(t.String()),
+      credentials: t.Boolean()
+    }),
+    client: t.Object({
+      port: t.Number(),
+      target: t.String(),
+      sourceMaps: t.Boolean()
+    }),
+    features: t.Object({
+      enableSwagger: t.Boolean(),
+      enableMetrics: t.Boolean(),
+      enableMonitoring: t.Boolean()
+    })
+  }),
+  environment: t.Object({
+    NODE_ENV: t.String(),
+    DEBUG: t.Boolean(),
+    LOG_LEVEL: t.String()
+  }),
+  urls: t.Object({
+    server: t.String(),
+    client: t.String(),
+    swagger: t.String()
+  }),
+  system: t.Object({
+    version: t.String(),
+    features: t.Array(t.String())
+  })
+}, {
+  description: 'Environment and configuration information for debugging'
+})
+
+/**
+ * Environment test endpoint
+ * Shows declarative config system information
+ */
+export const envTestRoute = new Elysia({ prefix: '/api', tags: ['Development'] })
+  .get('/env-test', () => {
+    return {
+      message: '⚡ Declarative Config System!',
+      timestamp: new Date().toISOString(),
+      serverConfig: {
+        port: serverConfig.server.port,
+        host: serverConfig.server.host,
+        apiPrefix: serverConfig.server.apiPrefix,
+        appName: appConfig.name,
+        appVersion: appConfig.version,
+        cors: {
+          origins: serverConfig.cors.origins,
+          methods: serverConfig.cors.methods,
+          credentials: serverConfig.cors.credentials
+        },
+        client: {
+          port: serverConfig.server.backendPort,
+          target: 'es2020',
+          sourceMaps: false
+        },
+        features: {
+          enableSwagger: appRuntimeConfig.values.enableSwagger,
+          enableMetrics: appRuntimeConfig.values.enableMetrics,
+          enableMonitoring: appRuntimeConfig.values.enableMonitoring
+        }
+      },
+      environment: {
+        NODE_ENV: appConfig.env,
+        DEBUG: appRuntimeConfig.values.enableDebugMode,
+        LOG_LEVEL: loggerConfig.level
+      },
+      urls: {
+        server: helpers.getServerUrl(),
+        client: helpers.getClientUrl(),
+        swagger: `${helpers.getServerUrl()}/swagger`
+      },
+      system: {
+        version: 'declarative-config',
+        features: ['type-safe', 'validated', 'declarative', 'runtime-reload']
+      }
+    }
+  }, {
+    detail: {
+      summary: 'Environment Configuration Test',
+      description: 'Returns current environment configuration, server settings, and runtime features for debugging and validation',
+      tags: ['Development', 'Configuration', 'Debug']
+    },
+    response: EnvTestResponseSchema
+  })

package/app/server/routes/index.ts

@@ -1,9 +1,5 @@
 import { Elysia, t } from "elysia"
 import { usersRoutes } from "./users.routes"
-import { uploadRoutes } from "./upload"
-import { configRoutes } from "./config"
-import { cryptoAuthDemoRoutes } from "./crypto-auth-demo.routes"
-import { exemploPostsRoutes } from "./exemplo-posts.routes"
 
 export const apiRoutes = new Elysia({ prefix: "/api" })
   .get("/", () => ({ message: "🔥 Hot Reload funcionando! FluxStack API v1.4.0 ⚡" }), {
@@ -36,8 +32,5 @@ export const apiRoutes = new Elysia({ prefix: "/api" })
       description: 'Returns the current health status of the API server'
     }
   })
+  // Register users routes
   .use(usersRoutes)
-  .use(uploadRoutes)
-  .use(configRoutes)
-  .use(cryptoAuthDemoRoutes)
-  .use(exemploPostsRoutes)  // ✅ Exemplo de rotas com crypto-auth

package/app/server/routes/users.routes.ts

@@ -1,114 +1,215 @@
-import { Elysia, t } from "elysia"
-import { UsersController } from "../controllers/users.controller"
-
-export const usersRoutes = new Elysia({ prefix: "/users" })
-  .get("/", () => UsersController.getUsers(), {
-    response: t.Object({
-      users: t.Array(t.Object({
-        id: t.Number(),
-        name: t.String(),
-        email: t.String(),
-        createdAt: t.Date()
-      }))
-    }),
+import { Elysia, t } from 'elysia'
+import { UsersController } from '@/app/server/controllers/users.controller'
+
+// ===== Request/Response Schemas =====
+
+const UserSchema = t.Object({
+  id: t.Number(),
+  name: t.String(),
+  email: t.String()
+}, {
+  description: 'User object'
+})
+
+const CreateUserRequestSchema = t.Object({
+  name: t.String({ minLength: 2, description: 'User name (minimum 2 characters)' }),
+  email: t.String({ format: 'email', description: 'Valid email address' })
+}, {
+  description: 'Request body for creating a new user'
+})
+
+const CreateUserResponseSchema = t.Union([
+  t.Object({
+    success: t.Literal(true),
+    user: UserSchema,
+    message: t.Optional(t.String())
+  }),
+  t.Object({
+    success: t.Literal(false),
+    error: t.String()
+  })
+], {
+  description: 'Response after attempting to create a user'
+})
+
+const GetUsersResponseSchema = t.Object({
+  success: t.Boolean(),
+  users: t.Array(UserSchema),
+  count: t.Number()
+}, {
+  description: 'List of all users'
+})
+
+const GetUserResponseSchema = t.Union([
+  t.Object({
+    success: t.Literal(true),
+    user: UserSchema
+  }),
+  t.Object({
+    success: t.Literal(false),
+    error: t.String()
+  })
+], {
+  description: 'Single user or error'
+})
+
+const DeleteUserResponseSchema = t.Union([
+  t.Object({
+    success: t.Literal(true),
+    message: t.String()
+  }),
+  t.Object({
+    success: t.Literal(false),
+    message: t.String()
+  })
+], {
+  description: 'Result of delete operation'
+})
+
+const ErrorResponseSchema = t.Object({
+  error: t.String()
+}, {
+  description: 'Error response'
+})
+
+/**
+ * Users API Routes
+ */
+export const usersRoutes = new Elysia({ prefix: '/users', tags: ['Users'] })
+  // GET /users - Get all users
+  .get('/', async () => {
+    return await UsersController.getUsers()
+  }, {
     detail: {
-      tags: ['Users'],
-      summary: 'List Users',
-      description: 'Retrieve a list of all users in the system'
-    }
+      summary: 'Get All Users',
+      description: 'Retrieves a list of all registered users',
+      tags: ['Users', 'CRUD']
+    },
+    response: GetUsersResponseSchema
   })
-  
-  .get("/:id", async ({ params: { id }, set }) => {
-    const userId = parseInt(id)
-    const result = await UsersController.getUserById(userId)
-    
+
+  // GET /users/:id - Get user by ID
+  .get('/:id', async ({ params, set }) => {
+    const id = parseInt(params.id)
+
+    // Handle invalid ID
+    if (isNaN(id)) {
+      set.status = 400
+      return { error: 'ID inválido' }
+    }
+
+    const result = await UsersController.getUserById(id)
+
     if (!result) {
       set.status = 404
-      return { error: "Usuário não encontrado" }
+      return { error: 'Usuário não encontrado' }
     }
-    
+
     return result
   }, {
-    params: t.Object({
-      id: t.String()
-    }),
     detail: {
-      tags: ['Users'],
       summary: 'Get User by ID',
-      description: 'Retrieve a specific user by their ID'
+      description: 'Retrieves a single user by their unique identifier',
+      tags: ['Users', 'CRUD']
+    },
+    params: t.Object({
+      id: t.String({ description: 'User ID' })
+    }),
+    response: {
+      200: GetUserResponseSchema,
+      400: ErrorResponseSchema,
+      404: ErrorResponseSchema
     }
   })
-  
-  .post("/", async ({ body, set }) => {
-    try {
-      return await UsersController.createUser(body as any)
-    } catch (error) {
+
+  // POST /users - Create new user
+  .post('/', async ({ body, set }) => {
+    // Validate required fields
+    if (!body.name || !body.email) {
+      set.status = 400
+      return {
+        success: false,
+        error: 'Nome e email são obrigatórios'
+      }
+    }
+
+    // Validate name length
+    if (body.name.length < 2) {
+      set.status = 400
+      return {
+        success: false,
+        error: 'Nome deve ter pelo menos 2 caracteres'
+      }
+    }
+
+    // Validate email format
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+    if (!emailRegex.test(body.email)) {
       set.status = 400
-      return { 
-        success: false, 
-        error: "Dados inválidos", 
-        details: error instanceof Error ? error.message : 'Unknown error'
+      return {
+        success: false,
+        error: 'Email inválido'
       }
     }
+
+    const result = await UsersController.createUser(body)
+
+    // If email is duplicate, still return 200 but with success: false
+    if (!result.success) {
+      return result
+    }
+
+    return result
   }, {
-    body: t.Object({
-      name: t.String({ minLength: 2 }),
-      email: t.String({ format: "email" })
-    }),
-    response: t.Object({
-      success: t.Boolean(),
-      user: t.Optional(t.Object({
-        id: t.Number(),
-        name: t.String(),
-        email: t.String(),
-        createdAt: t.Date()
-      })),
-      message: t.Optional(t.String())
-    }),
     detail: {
-      tags: ['Users'],
-      summary: 'Create User',
-      description: 'Create a new user with name and email'
+      summary: 'Create New User',
+      description: 'Creates a new user with name and email. Email must be unique.',
+      tags: ['Users', 'CRUD']
     },
-    error({ code, error, set }) {
-      switch (code) {
-        case 'VALIDATION':
-          set.status = 400
-          return {
-            success: false,
-            error: "Dados inválidos",
-            details: error.message
-          }
-        default:
-          set.status = 500
-          return {
-            success: false,
-            error: "Erro interno do servidor"
-          }
-      }
+    body: CreateUserRequestSchema,
+    response: {
+      200: CreateUserResponseSchema,
+      400: t.Object({
+        success: t.Literal(false),
+        error: t.String()
+      })
     }
   })
-  
-  .delete("/:id", ({ params: { id } }) => {
-    const userId = parseInt(id)
-    return UsersController.deleteUser(userId)
+
+  // DELETE /users/:id - Delete user
+  .delete('/:id', async ({ params, set }) => {
+    const id = parseInt(params.id)
+
+    if (isNaN(id)) {
+      set.status = 400
+      return {
+        success: false,
+        message: 'ID inválido'
+      }
+    }
+
+    const result = await UsersController.deleteUser(id)
+
+    if (!result.success) {
+      // Don't set 404 status, just return success: false
+      return result
+    }
+
+    return result
   }, {
-    params: t.Object({
-      id: t.String()
-    }),
-    response: t.Object({
-      success: t.Boolean(),
-      user: t.Optional(t.Object({
-        id: t.Number(),
-        name: t.String(),
-        email: t.String(),
-        createdAt: t.Date()
-      })),
-      message: t.Optional(t.String())
-    }),
     detail: {
-      tags: ['Users'],
       summary: 'Delete User',
-      description: 'Delete a user by their ID'
+      description: 'Deletes a user by their ID',
+      tags: ['Users', 'CRUD']
+    },
+    params: t.Object({
+      id: t.String({ description: 'User ID to delete' })
+    }),
+    response: {
+      200: DeleteUserResponseSchema,
+      400: t.Object({
+        success: t.Literal(false),
+        message: t.String()
+      })
     }
-  })
+  })