create-fluxstack 1.0.0 → 1.0.2

package/app/server/app.ts

@@ -1,10 +0,0 @@
-// 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/app/server/backend-only.ts

@@ -1,15 +0,0 @@
-// 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/app/server/controllers/users.controller.ts

@@ -1,69 +0,0 @@
-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/app/server/index.ts

@@ -1,104 +0,0 @@
-// 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/app/server/routes/index.ts

@@ -1,25 +0,0 @@
-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/app/server/routes/users.routes.ts

@@ -1,121 +0,0 @@
-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/app/server/types/index.ts

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

package/app/shared/types/index.ts

@@ -1,18 +0,0 @@
-// 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
-}