create-fluxstack 1.7.5 → 1.8.3

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/app.ts

@@ -1,10 +1,25 @@
-// Export the main app type for Eden Treaty
-import { apiRoutes } from "./routes"
+/**
+ * 🎯 Application Instance - Single Source of Truth
+ *
+ * This instance is used by:
+ * - index.ts (full-stack mode)
+ * - backend-only.ts (backend standalone mode)
+ * - Eden Treaty client (type inference)
+ *
+ * This ensures that the type exported for Eden Treaty is exactly
+ * the same as what the server uses.
+ */
+
 import { Elysia } from "elysia"
+import { apiRoutes } from "./routes"
+import { envTestRoute } from "./routes/env-test"
 
-// Create the full app structure that matches the server
-const appInstance = new Elysia()
-  .use(apiRoutes)
+/**
+ * Main application instance with all routes registered
+ */
+export const appInstance = new Elysia()
+  .use(envTestRoute)  // Environment test/debug endpoint
+  .use(apiRoutes)     // Main application routes
 
 // Export the type correctly for Eden Treaty
 export type App = typeof appInstance

package/app/server/backend-only.ts

@@ -1,15 +1,18 @@
-// Backend standalone entry point
-import { startBackendOnly } from "@/core/server/standalone"
-import { apiRoutes } from "./routes"
-import { serverConfig } from "@/config/server.config"
+/**
+ * Backend Standalone Entry Point
+ *
+ * This is a minimal wrapper for starting the backend in standalone mode.
+ * The core logic is protected in @/core/server/backend-entry.ts
+ *
+ * You can customize the configuration here if needed.
+ */
 
-// Configuração para backend standalone usando config declarativo
-const backendConfig = {
-  port: serverConfig.backendPort,
-  apiPrefix: serverConfig.apiPrefix
-}
+import { startBackend, createBackendConfig } from "@/core/server/backend-entry"
+import { appInstance } from "./app"
+import { serverConfig } from "@/config/server.config"
 
-console.log(`🚀 Backend standalone: ${serverConfig.host}:${backendConfig.port}`)
+// Create backend configuration from declarative config
+const backendConfig = createBackendConfig(serverConfig)
 
-// Iniciar apenas o backend
-startBackendOnly(apiRoutes, backendConfig)
+// Start backend in standalone mode
+startBackend(appInstance, backendConfig)

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
+  }
+}