create-fluxstack 1.8.1 → 1.9.1

package/app/client/src/lib/eden-api.ts

@@ -2,245 +2,78 @@
 import { treaty } from '@elysiajs/eden'
 import type { App } from '../../../server/app'
 
-// Get base URL dynamically
-const getBaseUrl = () => {
+/**
+ * Get base URL dynamically
+ */
+export const getBaseUrl = () => {
   if (typeof window === 'undefined') return 'http://localhost:3000'
-  
-  // In production, use current origin
+
+  // Production: use current origin
   if (window.location.hostname !== 'localhost') {
     return window.location.origin
   }
-  
-  // In development, use backend server (port 3000 for integrated mode)
-  return 'http://localhost:3000'
-}
-
-// Create Eden Treaty client with proper typing
-const client = treaty<App>(getBaseUrl())
-
-// Export the client's API directly to get proper type inference
-export const api = client.api
 
-// Enhanced error handling with retry and recovery strategies
-import { 
-  ClientAPIError, 
-  NetworkError, 
-  TimeoutError, 
-  withRetry, 
-  withFallback, 
-  CircuitBreaker,
-  getDefaultUserMessage,
-  type RetryOptions,
-  type FallbackOptions
-} from './errors'
-
-// Legacy interface for backward compatibility
-export interface APIError {
-  message: string
-  status: number
-  code?: string
-  details?: any
+  // Development: use backend server
+  return 'http://localhost:3000'
 }
 
-// Legacy class for backward compatibility
-export class APIException extends Error {
-  status: number
-  code?: string
-  details?: any
-
-  constructor(error: APIError) {
-    super(error.message)
-    this.name = 'APIException'
-    this.status = error.status
-    this.code = error.code
-    this.details = error.details
-  }
+/**
+ * Get auth token from localStorage (optional)
+ */
+const getAuthToken = (): string | null => {
+  if (typeof window === 'undefined') return null
+  return localStorage.getItem('accessToken')
 }
 
-// Global circuit breaker for API calls
-const apiCircuitBreaker = new CircuitBreaker(5, 60000, 60000)
-
-// Enhanced API call wrapper with retry and recovery
-export async function apiCall<T>(
-  apiPromise: Promise<any>,
-  options: {
-    retry?: Partial<RetryOptions>
-    fallback?: FallbackOptions<T>
-    timeout?: number
-    useCircuitBreaker?: boolean
-  } = {}
-): Promise<T> {
-  const { retry, fallback, timeout = 30000, useCircuitBreaker = true } = options
-
-  const executeCall = async (): Promise<T> => {
-    // Add timeout to the API call
-    const timeoutPromise = new Promise<never>((_, reject) => {
-      setTimeout(() => {
-        reject(new TimeoutError(timeout))
-      }, timeout)
-    })
-
-    try {
-      const result = await Promise.race([apiPromise, timeoutPromise])
-      const { data, error } = result
-      
-      if (error) {
-        const correlationId = error.value?.correlationId
-        
-        throw new ClientAPIError(
-          error.value?.message || 'API Error',
-          error.value?.code || 'API_ERROR',
-          error.status,
-          error.value?.details || error.value,
-          correlationId,
-          error.value?.userMessage
-        )
-      }
-      
-      return data
-    } catch (error) {
-      // Handle different types of errors
-      if (error instanceof ClientAPIError || error instanceof TimeoutError) {
-        throw error
-      }
-      
-      if (error instanceof Error) {
-        // Check if it's a network error
-        if (error.message.includes('fetch') || error.message.includes('network')) {
-          throw new NetworkError(error.message)
-        }
-        
-        throw new ClientAPIError(
-          error.message,
-          'NETWORK_ERROR',
-          0,
-          undefined,
-          undefined,
-          'Unable to connect to the server. Please check your connection.'
-        )
-      }
-      
-      throw new ClientAPIError(
-        'Unknown error occurred',
-        'UNKNOWN_ERROR',
-        500,
-        error
-      )
+/**
+ * Create Eden Treaty client with authentication and logging
+ * Based on official ElysiaJS Chan example
+ */
+export const api = treaty<App>(getBaseUrl(), {
+  // Dynamic headers for every request
+  headers(_path, _options) {
+    const token = getAuthToken()
+    return token ? { Authorization: `Bearer ${token}` } : undefined
+  },
+
+  // Custom fetcher with logging and error handling
+  // Use 'as any' to bypass Bun's strict fetch type (includes preconnect property)
+  fetcher: (async (url, init) => {
+    if (import.meta.env.DEV) {
+      console.log(`🌐 ${init?.method ?? 'GET'} ${url}`)
     }
-  }
-
-  // Wrap with circuit breaker if enabled
-  const callWithCircuitBreaker = useCircuitBreaker 
-    ? () => apiCircuitBreaker.execute(executeCall)
-    : executeCall
-
-  // Apply retry logic if specified
-  const callWithRetry = retry 
-    ? () => withRetry(callWithCircuitBreaker, retry)
-    : callWithCircuitBreaker
-
-  // Apply fallback if specified
-  if (fallback) {
-    return withFallback(callWithRetry, fallback)
-  }
-
-  return callWithRetry()
-}
 
-// Simplified API call for basic usage (backward compatibility)
-export async function simpleApiCall(apiPromise: Promise<any>) {
-  return apiCall(apiPromise)
-}
+    const res = await fetch(url, init)
 
-// Specialized API calls for different scenarios
-export async function criticalApiCall<T>(apiPromise: Promise<any>): Promise<T> {
-  return apiCall(apiPromise, {
-    retry: {
-      maxRetries: 5,
-      baseDelay: 2000,
-      maxDelay: 30000
-    },
-    timeout: 60000,
-    useCircuitBreaker: true
-  })
-}
+    if (import.meta.env.DEV) {
+      console.log(`📡 ${url} → ${res.status}`)
+    }
 
-export async function backgroundApiCall<T>(
-  apiPromise: Promise<any>, 
-  fallbackValue: T
-): Promise<T> {
-  return apiCall(apiPromise, {
-    retry: {
-      maxRetries: 2,
-      baseDelay: 1000
-    },
-    fallback: {
-      fallbackValue,
-      showFallbackMessage: false
-    },
-    timeout: 15000,
-    useCircuitBreaker: false
-  })
-}
+    // Auto-logout on 401
+    if (res.status === 401) {
+      console.warn('🔒 Token expired')
+      localStorage.removeItem('accessToken')
+      // window.location.href = '/login' // Uncomment if you have auth
+    }
 
-export async function userActionApiCall<T>(apiPromise: Promise<any>): Promise<T> {
-  return apiCall(apiPromise, {
-    retry: {
-      maxRetries: 3,
-      baseDelay: 1000,
-      retryableStatusCodes: [408, 429, 500, 502, 503, 504]
-    },
-    timeout: 30000,
-    useCircuitBreaker: true
-  })
-}
+    return res
+  }) as typeof fetch
+}).api // ← expose the generated API object
 
-// User-friendly error messages (enhanced)
+/**
+ * Get user-friendly error message
+ */
 export function getErrorMessage(error: unknown): string {
-  if (error instanceof ClientAPIError) {
-    return error.getUserFriendlyMessage()
-  }
-  
-  if (error instanceof APIException) {
-    return getDefaultUserMessage(error.code || 'UNKNOWN_ERROR', error.status)
+  // Eden Treaty error format
+  if (error && typeof error === 'object' && 'value' in error) {
+    const edenError = error as { value?: { message?: string; userMessage?: string } }
+    return edenError.value?.userMessage || edenError.value?.message || 'An error occurred'
   }
-  
+
+  // Standard Error
   if (error instanceof Error) {
     return error.message
   }
-  
-  return 'An unexpected error occurred'
-}
 
-// Error recovery utilities
-export function isRetryableError(error: unknown): boolean {
-  if (error instanceof ClientAPIError) {
-    return error.isRetryable
-  }
-  
-  if (error instanceof APIException) {
-    const retryableStatusCodes = [408, 429, 500, 502, 503, 504]
-    return retryableStatusCodes.includes(error.status)
-  }
-  
-  return false
-}
-
-export function shouldShowErrorToUser(error: unknown): boolean {
-  if (error instanceof ClientAPIError) {
-    // Don't show technical errors to users
-    const technicalCodes = ['DATABASE_ERROR', 'EXTERNAL_SERVICE_ERROR', 'INTERNAL_SERVER_ERROR']
-    return !technicalCodes.includes(error.code)
-  }
-  
-  return true
-}
-
-// Circuit breaker utilities
-export function getCircuitBreakerState(): string {
-  return apiCircuitBreaker.getState()
+  return 'An unexpected error occurred'
 }
-
-export function resetCircuitBreaker(): void {
-  apiCircuitBreaker.reset()
-}

package/app/client/src/main.tsx

@@ -1,11 +1,10 @@
 import { StrictMode } from 'react'
 import { createRoot } from 'react-dom/client'
-import { BrowserRouter } from 'react-router-dom'
 import './index.css'
 import App from './App.tsx'
 
 createRoot(document.getElementById('root')!).render(
-  <BrowserRouter>
+  <StrictMode>
     <App />
-  </BrowserRouter>,
+  </StrictMode>,
 )

package/app/server/controllers/users.controller.ts

@@ -1,37 +1,56 @@
-import type { User, CreateUserRequest, UserResponse } from '../types'
+import type { CreateUserRequest } from '@/app/shared/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() }
-]
+// User type
+export interface User {
+  id: number
+  name: string
+  email: string
+  createdAt: Date
+}
+
+// In-memory storage for users (for testing purposes)
+let users: User[] = []
+let nextId = 1
 
 export class UsersController {
+  /**
+   * Get all users
+   */
   static async getUsers() {
-    return { users }
+    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() }
-    )
+  /**
+   * Get user by ID
+   */
+  static async getUserById(id: number) {
+    const user = users.find(u => u.id === id)
+    if (!user) {
+      return null
+    }
+    return { user }
   }
 
-  static async createUser(userData: CreateUserRequest): Promise<UserResponse> {
-    const existingUser = users.find(u => u.email === userData.email)
-    
+  /**
+   * Create a new user
+   */
+  static async createUser(data: CreateUserRequest) {
+    // Check for duplicate email
+    const existingUser = users.find(u => u.email === data.email)
     if (existingUser) {
       return {
         success: false,
-        message: "Email já está em uso"
+        message: 'Email já está em uso'
       }
     }
 
+    // Create new user
     const newUser: User = {
-      id: Date.now(),
-      name: userData.name,
-      email: userData.email,
+      id: nextId++,
+      name: data.name,
+      email: data.email,
       createdAt: new Date()
     }
 
@@ -43,27 +62,34 @@ export class UsersController {
     }
   }
 
-  static async getUserById(id: number) {
-    const user = users.find(u => u.id === id)
-    return user ? { user } : null
-  }
-
-  static async deleteUser(id: number): Promise<UserResponse> {
+  /**
+   * Delete user by ID
+   */
+  static async deleteUser(id: number) {
     const userIndex = users.findIndex(u => u.id === id)
-    
+
     if (userIndex === -1) {
       return {
         success: false,
-        message: "Usuário não encontrado"
+        message: 'Usuário não encontrado'
       }
     }
 
-    const deletedUser = users.splice(userIndex, 1)[0]
-    
+    const deletedUser = users[userIndex]
+    users.splice(userIndex, 1)
+
     return {
       success: true,
       user: deletedUser,
-      message: "Usuário deletado com sucesso"
+      message: 'Usuário deletado com sucesso'
     }
   }
-}
+
+  /**
+   * Reset users array for testing purposes
+   */
+  static resetForTesting() {
+    users = []
+    nextId = 1
+  }
+}

package/app/server/index.ts

@@ -26,8 +26,11 @@ import cryptoAuthPlugin from "@/plugins/crypto-auth"
 // ===== Application Routes =====
 import { appInstance } from "./app"
 
-// NOTE: Live Components auto-discovery is handled by liveComponentsPlugin
-// No need to import "./live/register-components" anymore
+// ===== 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...')

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

@@ -3,18 +3,62 @@
  * Displays current configuration for debugging purposes
  */
 
-import { Elysia } from 'elysia'
+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' })
+export const envTestRoute = new Elysia({ prefix: '/api', tags: ['Development'] })
   .get('/env-test', () => {
     return {
       message: '⚡ Declarative Config System!',
@@ -56,4 +100,11 @@ export const envTestRoute = new Elysia({ prefix: '/api' })
         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