create-fluxstack 1.0.2 → 1.0.3

package/my-final-test/core/server/framework.ts

@@ -0,0 +1,123 @@
+import { Elysia } from "elysia"
+import type { FluxStackConfig, FluxStackContext, Plugin } from "../types"
+import type { PluginContext, PluginUtils } from "../plugins/types"
+import { getConfigSync, getEnvironmentInfo } from "../config"
+import { logger, type Logger } from "../utils/logger/index"
+import { createTimer, formatBytes, isProduction, isDevelopment } from "../utils/helpers"
+
+export class FluxStackFramework {
+  private app: Elysia
+  private context: FluxStackContext
+  private pluginContext: PluginContext
+  private plugins: Plugin[] = []
+
+  constructor(config?: Partial<FluxStackConfig>) {
+    // Load the full configuration
+    const fullConfig = config ? { ...getConfigSync(), ...config } : getConfigSync()
+    const envInfo = getEnvironmentInfo()
+
+    this.context = {
+      config: fullConfig,
+      isDevelopment: envInfo.isDevelopment,
+      isProduction: envInfo.isProduction,
+      isTest: envInfo.isTest,
+      environment: envInfo.name
+    }
+
+    this.app = new Elysia()
+
+    // Create plugin utilities
+    const pluginUtils: PluginUtils = {
+      createTimer,
+      formatBytes,
+      isProduction,
+      isDevelopment,
+      getEnvironment: () => envInfo.name,
+      createHash: (data: string) => {
+        const crypto = require('crypto')
+        return crypto.createHash('sha256').update(data).digest('hex')
+      },
+      deepMerge: (target: any, source: any) => {
+        const result = { ...target }
+        for (const key in source) {
+          if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+            result[key] = pluginUtils.deepMerge(result[key] || {}, source[key])
+          } else {
+            result[key] = source[key]
+          }
+        }
+        return result
+      },
+      validateSchema: (_data: any, _schema: any) => {
+        // Simple validation - in a real implementation you'd use a proper schema validator
+        try {
+          // Basic validation logic
+          return { valid: true, errors: [] }
+        } catch (error) {
+          return { valid: false, errors: [error instanceof Error ? error.message : 'Validation failed'] }
+        }
+      }
+    }
+
+    // Create plugin context
+    this.pluginContext = {
+      config: fullConfig,
+      logger: logger as Logger,
+      app: this.app,
+      utils: pluginUtils
+    }
+
+    this.setupCors()
+  }
+
+  private setupCors() {
+    const { cors } = this.context.config.server
+
+    this.app
+      .onRequest(({ set }) => {
+        set.headers["Access-Control-Allow-Origin"] = cors.origins.join(", ") || "*"
+        set.headers["Access-Control-Allow-Methods"] = cors.methods.join(", ") || "*"
+        set.headers["Access-Control-Allow-Headers"] = cors.headers.join(", ") || "*"
+        if (cors.credentials) {
+          set.headers["Access-Control-Allow-Credentials"] = "true"
+        }
+      })
+      .options("*", ({ set }) => {
+        set.status = 200
+        return ""
+      })
+  }
+
+  use(plugin: Plugin) {
+    this.plugins.push(plugin)
+    if (plugin.setup) {
+      plugin.setup(this.pluginContext)
+    }
+    return this
+  }
+
+  routes(routeModule: any) {
+    this.app.use(routeModule)
+    return this
+  }
+
+  getApp() {
+    return this.app
+  }
+
+  getContext() {
+    return this.context
+  }
+
+  listen(callback?: () => void) {
+    const port = this.context.config.server.port
+    const apiPrefix = this.context.config.server.apiPrefix
+
+    this.app.listen(port, () => {
+      console.log(`🚀 API ready at http://localhost:${port}${apiPrefix}`)
+      console.log(`📋 Health check: http://localhost:${port}${apiPrefix}/health`)
+      console.log()
+      callback?.()
+    })
+  }
+}

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

@@ -0,0 +1,8 @@
+// FluxStack framework exports
+export { FluxStackFramework } from "../framework/server"
+export { loggerPlugin } from "../plugins/built-in/logger"
+export { vitePlugin } from "../plugins/built-in/vite"
+export { staticPlugin } from "../plugins/built-in/static"
+export { swaggerPlugin } from "../plugins/built-in/swagger"
+export { PluginRegistry } from "../plugins/registry"
+export * from "../types"

package/my-final-test/core/server/plugins/database.ts

@@ -0,0 +1,182 @@
+import type { Plugin, PluginContext, CliCommand } from "../../plugins/types"
+
+// Database plugin with CLI commands
+export const databasePlugin: Plugin = {
+  name: "database",
+  version: "1.0.0",
+  description: "Database management plugin with CLI commands",
+  author: "FluxStack Team",
+  category: "data",
+
+  setup: (context: PluginContext) => {
+    context.logger.info("Database plugin initialized")
+  },
+
+  commands: [
+    {
+      name: "migrate",
+      description: "Run database migrations",
+      category: "Database",
+      usage: "flux database:migrate [options]",
+      examples: [
+        "flux database:migrate                # Run all pending migrations",
+        "flux database:migrate --rollback     # Rollback last migration",
+        "flux database:migrate --to 001       # Migrate to specific version"
+      ],
+      options: [
+        {
+          name: "rollback",
+          short: "r",
+          description: "Rollback the last migration",
+          type: "boolean"
+        },
+        {
+          name: "to",
+          description: "Migrate to specific version",
+          type: "string"
+        },
+        {
+          name: "dry-run",
+          description: "Show what would be migrated without executing",
+          type: "boolean"
+        }
+      ],
+      handler: async (args, options, context) => {
+        if (options["dry-run"]) {
+          console.log("🔍 Dry run mode - showing planned migrations:")
+        }
+
+        if (options.rollback) {
+          console.log("⬇️  Rolling back last migration...")
+          // Simulate rollback
+          await new Promise(resolve => setTimeout(resolve, 1000))
+          console.log("✅ Rollback completed")
+        } else if (options.to) {
+          console.log(`📈 Migrating to version: ${options.to}`)
+          // Simulate migration to version
+          await new Promise(resolve => setTimeout(resolve, 1500))
+          console.log(`✅ Migrated to version ${options.to}`)
+        } else {
+          console.log("📈 Running all pending migrations...")
+          // Simulate migration
+          await new Promise(resolve => setTimeout(resolve, 2000))
+          console.log("✅ All migrations completed")
+        }
+      }
+    },
+    {
+      name: "seed",
+      description: "Seed the database with initial data",
+      category: "Database", 
+      usage: "flux database:seed [seeder]",
+      examples: [
+        "flux database:seed                   # Run all seeders",
+        "flux database:seed users             # Run specific seeder"
+      ],
+      arguments: [
+        {
+          name: "seeder",
+          description: "Specific seeder to run",
+          required: false,
+          type: "string"
+        }
+      ],
+      options: [
+        {
+          name: "force",
+          short: "f",
+          description: "Force seeding even if data exists",
+          type: "boolean"
+        }
+      ],
+      handler: async (args, options, context) => {
+        const [seeder] = args
+        
+        if (seeder) {
+          console.log(`🌱 Running seeder: ${seeder}`)
+          console.log(`   Force mode: ${options.force ? 'ON' : 'OFF'}`)
+        } else {
+          console.log("🌱 Running all seeders...")
+        }
+        
+        // Simulate seeding
+        await new Promise(resolve => setTimeout(resolve, 1500))
+        console.log("✅ Database seeded successfully")
+      }
+    },
+    {
+      name: "reset",
+      description: "Reset the database (drop all tables and recreate)",
+      category: "Database",
+      usage: "flux database:reset [options]",
+      examples: [
+        "flux database:reset                  # Reset and migrate",
+        "flux database:reset --seed           # Reset, migrate and seed"
+      ],
+      options: [
+        {
+          name: "seed",
+          short: "s",
+          description: "Run seeders after reset",
+          type: "boolean"
+        },
+        {
+          name: "confirm",
+          description: "Skip confirmation prompt",
+          type: "boolean"
+        }
+      ],
+      handler: async (args, options, context) => {
+        if (!options.confirm) {
+          console.log("⚠️  WARNING: This will delete all data in the database!")
+          console.log("Use --confirm to skip this prompt.")
+          return
+        }
+
+        console.log("🗑️  Dropping all tables...")
+        await new Promise(resolve => setTimeout(resolve, 1000))
+        
+        console.log("📈 Running migrations...")
+        await new Promise(resolve => setTimeout(resolve, 1500))
+        
+        if (options.seed) {
+          console.log("🌱 Running seeders...")
+          await new Promise(resolve => setTimeout(resolve, 1000))
+        }
+        
+        console.log("✅ Database reset completed")
+      }
+    },
+    {
+      name: "status",
+      description: "Show database migration status",
+      category: "Database",
+      aliases: ["info"],
+      handler: async (args, options, context) => {
+        console.log("📊 Database Status:")
+        console.log("------------------")
+        console.log("Connected: ✅ Yes")
+        console.log("Tables: 15")
+        console.log("Last migration: 2024_01_15_create_users_table")
+        console.log("Pending migrations: 2")
+        console.log("Database size: 2.3 MB")
+      }
+    }
+  ]
+}
+
+// Utility functions that could be used by the plugin
+export async function runMigration(version?: string): Promise<void> {
+  // Actual migration logic would go here
+  console.log(`Running migration ${version || 'all'}`)
+}
+
+export async function rollbackMigration(): Promise<void> {
+  // Actual rollback logic would go here 
+  console.log("Rolling back migration")
+}
+
+export async function seedDatabase(seeder?: string): Promise<void> {
+  // Actual seeding logic would go here
+  console.log(`Seeding database ${seeder || 'all'}`)
+}

package/my-final-test/core/server/plugins/logger.ts

@@ -0,0 +1,47 @@
+import type { Plugin, PluginContext } from "../../types"
+import { log } from "../../utils/logger"
+
+export const loggerPlugin: Plugin = {
+  name: "logger",
+  setup: (context: PluginContext) => {
+    const logLevel = process.env.LOG_LEVEL || context.config.logging?.level || 'info'
+    const isDev = process.env.NODE_ENV === 'development'
+    
+    log.plugin("logger", "Logger plugin initialized", {
+      logLevel,
+      environment: process.env.NODE_ENV || 'development'
+    })
+    
+    // Only enable verbose request logging if explicitly requested
+    if (process.env.ENABLE_REQUEST_LOGS === 'true') {
+      // Setup logging hooks on the Elysia app
+      context.app.onRequest(({ request }: { request: Request }) => {
+        const startTime = Date.now()
+        const path = new URL(request.url).pathname
+        
+        // Store start time for duration calculation
+        ;(request as any).__startTime = startTime
+        
+        log.request(request.method, path)
+      })
+      
+      context.app.onResponse(({ request, set }: { request: Request, set: any }) => {
+        const duration = Date.now() - ((request as any).__startTime || Date.now())
+        const path = new URL(request.url).pathname
+        
+        log.request(request.method, path, set.status || 200, duration)
+      })
+    }
+    
+    // Always log errors
+    context.app.onError(({ error, request }: { error: Error, request: Request }) => {
+      const duration = Date.now() - ((request as any).__startTime || Date.now())
+      const path = new URL(request.url).pathname
+      
+      log.error(`${request.method} ${path} - ${error.message}`, {
+        duration,
+        stack: error.stack
+      })
+    })
+  }
+}

package/my-final-test/core/server/plugins/swagger.ts

@@ -0,0 +1,34 @@
+import { swagger } from '@elysiajs/swagger'
+import type { Plugin, PluginContext } from '../../types'
+
+export const swaggerPlugin: Plugin = {
+  name: 'swagger',
+  setup(context: PluginContext) {
+    context.app.use(swagger({
+      path: '/swagger',
+      documentation: {
+        info: {
+          title: 'FluxStack API',
+          version: '1.0.0',
+          description: 'Modern full-stack TypeScript framework with type-safe API endpoints'
+        },
+        tags: [
+          { 
+            name: 'Health', 
+            description: 'Health check endpoints' 
+          },
+          { 
+            name: 'Users', 
+            description: 'User management endpoints' 
+          }
+        ],
+        servers: [
+          {
+            url: `http://localhost:${context.config.server?.port || 3000}`,
+            description: 'Development server'
+          }
+        ]
+      }
+    }))
+  }
+}

package/my-final-test/core/server/standalone.ts

@@ -0,0 +1,91 @@
+// Standalone backend server (sem frontend integrado)
+import { FluxStackFramework } from "./index"
+import type { Plugin, PluginContext } from "../types"
+
+export const createStandaloneServer = (userConfig: any = {}) => {
+  const app = new FluxStackFramework({
+    server: {
+      port: userConfig.port || parseInt(process.env.BACKEND_PORT || '3000'),
+      host: 'localhost',
+      apiPrefix: userConfig.apiPrefix || "/api",
+      cors: {
+        origins: ['*'],
+        methods: ['GET', 'POST', 'PUT', 'DELETE'],
+        headers: ['Content-Type', 'Authorization'],
+        credentials: false,
+        maxAge: 86400
+      },
+      middleware: []
+    },
+    app: { name: 'FluxStack Backend', version: '1.0.0' },
+    client: { port: 5173, proxy: { target: 'http://localhost:3000' }, build: { sourceMaps: true, minify: false, target: 'es2020', outDir: 'dist' } },
+    ...userConfig
+  })
+
+  // Plugin de logging silencioso para standalone
+  const silentLogger: Plugin = {
+    name: "silent-logger",
+    setup: (context: PluginContext) => {
+      context.app.onRequest(({ request }: { request: Request }) => {
+        // Log mais limpo para backend standalone
+        const timestamp = new Date().toLocaleTimeString()
+        const path = new URL(request.url).pathname
+        console.log(`[${timestamp}] ${request.method} ${path}`)
+      })
+    }
+  }
+
+  app.use(silentLogger)
+  return app
+}
+
+export const startBackendOnly = async (userRoutes?: any, config: any = {}) => {
+  const port = config.port || process.env.BACKEND_PORT || 3000
+  const host = process.env.HOST || 'localhost'
+  
+  console.log(`🦊 FluxStack Backend`)
+  console.log(`🚀 http://${host}:${port}`)
+  console.log(`📋 Health: http://${host}:${port}/health`)
+  console.log()
+
+  const app = createStandaloneServer(config)
+  
+  if (userRoutes) {
+    app.routes(userRoutes)
+  }
+
+  // Adicionar rotas básicas para backend standalone
+  const framework = app.getApp()
+  
+  // Health check
+  framework.get("/health", () => ({ 
+    status: "ok", 
+    mode: "backend-only",
+    timestamp: new Date().toISOString(),
+    port
+  }))
+  
+  // Rota raiz informativa para backend standalone
+  framework.get("/", () => ({
+    message: "🦊 FluxStack Backend Server",
+    mode: "backend-only",
+    endpoints: {
+      health: "/health",
+      api: "/api/*",
+      docs: "/swagger"
+    },
+    frontend: {
+      note: "Frontend não está rodando neste servidor",
+      recommendation: "Use 'bun run dev' para modo integrado ou 'bun run dev:frontend' para frontend standalone"
+    },
+    timestamp: new Date().toISOString()
+  }))
+
+  // Override do listen para não mostrar mensagens do framework
+  const context = app.getContext()
+  framework.listen(context.config.port!, () => {
+    // Mensagem já foi mostrada acima, não repetir
+  })
+
+  return app
+}