create-fluxstack 1.0.0 → 1.0.2

package/core/server/framework.ts

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

@@ -1,8 +0,0 @@
-// 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/core/server/plugins/database.ts

@@ -1,182 +0,0 @@
-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/core/server/plugins/logger.ts

@@ -1,47 +0,0 @@
-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/core/server/plugins/swagger.ts

@@ -1,34 +0,0 @@
-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/core/server/standalone.ts

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