create-fluxstack 1.0.1 → 1.0.3

package/my-final-test/app/server/app.ts

@@ -0,0 +1,10 @@
+// Export the main app type for Eden Treaty
+import { apiRoutes } from "./routes"
+import { Elysia } from "elysia"
+
+// Create the full app structure that matches the server
+const appInstance = new Elysia()
+  .use(apiRoutes)
+
+// Export the type correctly for Eden Treaty
+export type App = typeof appInstance

package/my-final-test/app/server/backend-only.ts

@@ -0,0 +1,15 @@
+// Backend standalone entry point
+import { startBackendOnly } from "@/core/server/standalone"
+import { apiRoutes } from "./routes"
+import { env } from "@/core/utils/env-runtime"
+
+// Configuração para backend standalone com env dinâmico
+const backendConfig = {
+  port: env.get('BACKEND_PORT', 3001),  // Casting automático para number
+  apiPrefix: env.API_PREFIX             // Direto! (string)
+}
+
+console.log(`🚀 Backend standalone: ${env.HOST}:${backendConfig.port}`)
+
+// Iniciar apenas o backend
+startBackendOnly(apiRoutes, backendConfig)

package/my-final-test/app/server/controllers/users.controller.ts

@@ -0,0 +1,69 @@
+import type { User, CreateUserRequest, UserResponse } from '../types'
+
+let users: User[] = [
+  { id: 1, name: "João", email: "joao@example.com", createdAt: new Date() },
+  { id: 2, name: "Maria", email: "maria@example.com", createdAt: new Date() }
+]
+
+export class UsersController {
+  static async getUsers() {
+    return { users }
+  }
+
+  static resetForTesting() {
+    users.splice(0, users.length)
+    users.push(
+      { id: 1, name: "João", email: "joao@example.com", createdAt: new Date() },
+      { id: 2, name: "Maria", email: "maria@example.com", createdAt: new Date() }
+    )
+  }
+
+  static async createUser(userData: CreateUserRequest): Promise<UserResponse> {
+    const existingUser = users.find(u => u.email === userData.email)
+    
+    if (existingUser) {
+      return {
+        success: false,
+        message: "Email já está em uso"
+      }
+    }
+
+    const newUser: User = {
+      id: Date.now(),
+      name: userData.name,
+      email: userData.email,
+      createdAt: new Date()
+    }
+
+    users.push(newUser)
+
+    return {
+      success: true,
+      user: newUser
+    }
+  }
+
+  static async getUserById(id: number) {
+    const user = users.find(u => u.id === id)
+    return user ? { user } : null
+  }
+
+  static async deleteUser(id: number): Promise<UserResponse> {
+    const userIndex = users.findIndex(u => u.id === id)
+    
+    if (userIndex === -1) {
+      return {
+        success: false,
+        message: "Usuário não encontrado"
+      }
+    }
+
+    const deletedUser = users.splice(userIndex, 1)[0]
+    
+    return {
+      success: true,
+      user: deletedUser,
+      message: "Usuário deletado com sucesso"
+    }
+  }
+}

package/my-final-test/app/server/index.ts

@@ -0,0 +1,104 @@
+// User application entry point
+import { FluxStackFramework, loggerPlugin, vitePlugin, swaggerPlugin, staticPlugin } from "@/core/server"
+import { isDevelopment } from "@/core/utils/helpers"
+import { apiRoutes } from "./routes"
+// Import sistema de env dinâmico simplificado
+import { env, helpers } from "@/core/utils/env-runtime-v2"
+
+console.log('🔧 Loading dynamic environment configuration...')
+console.log(`📊 Environment: ${env.NODE_ENV}`)           // Direto!
+console.log(`🚀 Port: ${env.PORT}`)                      // Direto!
+console.log(`🌐 Host: ${env.HOST}`)                      // Direto!
+
+// Criar aplicação com configuração dinâmica simplificada
+const app = new FluxStackFramework({
+  server: {
+    port: env.PORT,                      // Direto! (number)
+    host: env.HOST,                      // Direto! (string)
+    apiPrefix: env.API_PREFIX,           // Direto! (string)
+    cors: {
+      origins: env.CORS_ORIGINS,         // Direto! (string[])
+      methods: env.get('CORS_METHODS', ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS']),
+      headers: env.get('CORS_HEADERS', ['*']),
+      credentials: env.get('CORS_CREDENTIALS', false)
+    },
+    middleware: []
+  },
+  app: {
+    name: env.FLUXSTACK_APP_NAME,        // Direto! (string)
+    version: env.FLUXSTACK_APP_VERSION   // Direto! (string)
+  },
+  client: {
+    port: env.VITE_PORT,                 // Direto! (number)
+    proxy: {
+      target: helpers.getServerUrl()     // Helper inteligente
+    },
+    build: {
+      sourceMaps: env.get('CLIENT_SOURCEMAPS', env.NODE_ENV !== 'production'),
+      minify: env.get('CLIENT_MINIFY', env.NODE_ENV === 'production'),
+      target: env.get('CLIENT_TARGET', 'es2020'),
+      outDir: env.get('CLIENT_OUTDIR', 'dist')
+    }
+  }
+})
+
+
+// Usar plugins de infraestrutura primeiro (mas NÃO o Swagger ainda)
+app.use(loggerPlugin)
+
+// Usar plugins condicionalmente baseado no ambiente
+if (isDevelopment()) {
+  app.use(vitePlugin)
+} else {
+  app.use(staticPlugin)
+}
+  
+
+// Adicionar rota de teste para mostrar env dinâmico (antes das rotas)
+app.getApp().get('/api/env-test', () => {
+  return {
+    message: '🔥 Environment Variables Simplificado!',
+    timestamp: new Date().toISOString(),
+    environment: {
+      NODE_ENV: env.NODE_ENV,             // Direto!
+      PORT: env.PORT,                     // Direto!
+      HOST: env.HOST,                     // Direto!
+      DEBUG: env.DEBUG,                   // Direto!
+      CORS_ORIGINS: env.CORS_ORIGINS,     // Direto!
+      ENABLE_SWAGGER: env.ENABLE_SWAGGER, // Direto!
+      
+      // Vars customizadas com casting automático
+      CUSTOM_VAR: env.get('CUSTOM_VAR', 'not-set'),
+      MAX_RETRIES: env.get('MAX_RETRIES', 3),        // number
+      ENABLE_CACHE: env.get('ENABLE_CACHE', false),  // boolean
+      ALLOWED_IPS: env.get('ALLOWED_IPS', [])        // string[]
+    },
+    urls: {
+      server: helpers.getServerUrl(),     // Helper!
+      swagger: `${helpers.getServerUrl()}/swagger`
+    },
+    note: 'API simplificada com casting automático! 🚀'
+  }
+})
+
+// Registrar rotas da aplicação DEPOIS da rota de teste
+app.routes(apiRoutes)
+
+// Swagger por último para descobrir todas as rotas
+app.use(swaggerPlugin)
+
+// Iniciar servidor
+app.listen(() => {
+  console.log('\n✅ FluxStack com Environment Variables Simplificado!')
+  console.log(`🔗 Server: ${helpers.getServerUrl()}`)
+  console.log(`🔗 Teste dinâmico: ${helpers.getServerUrl()}/api/env-test`)
+  
+  if (env.ENABLE_SWAGGER) {
+    console.log(`📋 Swagger: ${helpers.getServerUrl()}/swagger`)
+  }
+  
+  console.log('💡 Mude as env vars e reinicie para ver a diferença!')
+})
+
+// Exportar tipo da aplicação para Eden Treaty (método correto)
+export type App = typeof app

package/my-final-test/app/server/routes/index.ts

@@ -0,0 +1,25 @@
+import { Elysia } from "elysia"
+import { usersRoutes } from "./users.routes"
+
+export const apiRoutes = new Elysia({ prefix: "/api" })
+  .get("/", () => ({ message: "🔥 Hot Reload funcionando! FluxStack API v1.4.0 ⚡" }), {
+    detail: {
+      tags: ['Health'],
+      summary: 'API Root',
+      description: 'Returns a welcome message from the FluxStack API'
+    }
+  })
+  .get("/health", () => ({ 
+    status: "🚀 Hot Reload ativo!", 
+    timestamp: new Date().toISOString(),
+    uptime: `${Math.floor(process.uptime())}s`,
+    version: "1.4.0",
+    environment: "development"
+  }), {
+    detail: {
+      tags: ['Health'],
+      summary: 'Health Check',
+      description: 'Returns the current health status of the API server'
+    }
+  })
+  .use(usersRoutes)

package/my-final-test/app/server/routes/users.routes.ts

@@ -0,0 +1,121 @@
+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()
+      }))
+    }),
+    detail: {
+      tags: ['Users'],
+      summary: 'List Users',
+      description: 'Retrieve a list of all users in the system'
+    }
+  })
+  
+  .get("/:id", async ({ params: { id } }) => {
+    const userId = parseInt(id)
+    const result = await UsersController.getUserById(userId)
+    
+    if (!result) {
+      return { error: "Usuário não encontrado" }
+    }
+    
+    return result
+  }, {
+    params: t.Object({
+      id: t.String()
+    }),
+    response: t.Object({
+      user: t.Object({
+        id: t.Number(),
+        name: t.String(),
+        email: t.String(),
+        createdAt: t.Date()
+      })
+    }),
+    detail: {
+      tags: ['Users'],
+      summary: 'Get User by ID',
+      description: 'Retrieve a specific user by their ID'
+    }
+  })
+  
+  .post("/", async ({ body, set }) => {
+    try {
+      return await UsersController.createUser(body as any)
+    } catch (error) {
+      set.status = 400
+      return { 
+        success: false, 
+        error: "Dados inválidos", 
+        details: error instanceof Error ? error.message : 'Unknown error'
+      }
+    }
+  }, {
+    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'
+    },
+    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"
+          }
+      }
+    }
+  })
+  
+  .delete("/:id", ({ params: { id } }) => {
+    const userId = parseInt(id)
+    return UsersController.deleteUser(userId)
+  }, {
+    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'
+    }
+  })

package/my-final-test/app/server/types/index.ts

@@ -0,0 +1 @@
+export * from '../../shared/types'

package/my-final-test/app/shared/types/index.ts

@@ -0,0 +1,18 @@
+// Shared types between server and client
+export interface User {
+  id: number
+  name: string
+  email: string
+  createdAt: Date
+}
+
+export interface CreateUserRequest {
+  name: string
+  email: string
+}
+
+export interface UserResponse {
+  success: boolean
+  user?: User
+  message?: string
+}