create-fluxstack 1.7.4 → 1.8.1

package/core/plugins/config.ts

@@ -7,6 +7,8 @@ import type { FluxStack, PluginConfigSchema, PluginValidationResult } from "./ty
 import type { FluxStackConfig } from "../config/schema"
 import type { Logger } from "../utils/logger/index"
 
+type Plugin = FluxStack.Plugin
+
 export interface PluginConfigManager {
   validatePluginConfig(plugin: Plugin, config: any): PluginValidationResult
   mergePluginConfig(plugin: Plugin, userConfig: any): any

package/core/plugins/discovery.ts

@@ -9,6 +9,8 @@ import { readdir, readFile } from "fs/promises"
 import { join, resolve } from "path"
 import { existsSync } from "fs"
 
+type Plugin = FluxStack.Plugin
+
 export interface PluginDiscoveryConfig {
   logger?: Logger
   baseDir?: string

package/core/plugins/executor.ts

@@ -28,6 +28,8 @@ export interface PluginExecutionStep {
   canExecuteInParallel: boolean
 }
 
+type Plugin = FluxStack.Plugin
+
 export class PluginExecutor {
   private logger: Logger
 

package/core/plugins/index.ts

@@ -27,7 +27,6 @@ export type {
     BuildContext
 } from './types'
 
-export type { FluxStack }
 export type Plugin = FluxStack.Plugin
 
 // Plugin registry
@@ -200,5 +199,6 @@ import type {
     PluginPriority,
     RequestContext,
     ResponseContext,
-    ErrorContext
+    ErrorContext,
+    FluxStack
 } from './types'

package/core/plugins/registry.ts

@@ -291,7 +291,21 @@ export class PluginRegistry {
         }
       }
 
-      // Try to import the plugin
+      // Install dependencies BEFORE importing the plugin
+      if (manifest && manifest.dependencies && Object.keys(manifest.dependencies).length > 0) {
+        try {
+          const resolution = await this.dependencyManager.resolvePluginDependencies(pluginPath)
+          if (resolution.dependencies.length > 0) {
+            // Install dependencies directly in the plugin directory
+            await this.dependencyManager.installPluginDependenciesLocally(pluginPath, resolution.dependencies)
+            this.logger?.debug(`Dependencies installed for plugin at: ${pluginPath}`)
+          }
+        } catch (error) {
+          this.logger?.warn(`Failed to install dependencies for plugin at '${pluginPath}'`, { error })
+        }
+      }
+
+      // Try to import the plugin (after dependencies are installed)
       const pluginModule = await import(resolve(pluginPath))
       const plugin: FluxStackPlugin = pluginModule.default || pluginModule
 
@@ -434,38 +448,28 @@ export class PluginRegistry {
    * Resolver dependências de todos os plugins descobertos
    */
   private async resolveDependencies(results: PluginLoadResult[]): Promise<void> {
-    const resolutions = []
-    
-    // Resolver dependências para cada plugin carregado com sucesso
+    // Dependencies are now installed during plugin loading in loadPlugin()
+    // This method is kept for compatibility but no longer performs installation
+
+    // Only check for dependency conflicts on successfully loaded plugins
     for (const result of results) {
       if (result.success && result.plugin) {
         try {
-          // Tentar encontrar o diretório do plugin
           const pluginDir = this.findPluginDirectory(result.plugin.name)
           if (pluginDir) {
             const resolution = await this.dependencyManager.resolvePluginDependencies(pluginDir)
-            resolutions.push(resolution)
-            
+
             if (!resolution.resolved) {
-              this.logger?.warn(`Plugin '${result.plugin.name}' tem conflitos de dependências`, {
+              this.logger?.warn(`Plugin '${result.plugin.name}' has dependency conflicts`, {
                 conflicts: resolution.conflicts.length
               })
             }
           }
         } catch (error) {
-          this.logger?.warn(`Erro ao resolver dependências do plugin '${result.plugin.name}'`, { error })
+          this.logger?.warn(`Failed to check dependencies for plugin '${result.plugin.name}'`, { error })
         }
       }
     }
-
-    // Instalar dependências se houver resoluções
-    if (resolutions.length > 0) {
-      try {
-        await this.dependencyManager.installPluginDependencies(resolutions)
-      } catch (error) {
-        this.logger?.error('Erro ao instalar dependências de plugins', { error })
-      }
-    }
   }
 
   /**

package/core/server/backend-entry.ts

@@ -0,0 +1,51 @@
+/**
+ * Backend Entry Point - Core Framework
+ *
+ * This file contains the protected logic for running backend standalone mode.
+ * DO NOT modify this file directly - it's part of the FluxStack framework core.
+ *
+ * For customization, use app/server/backend-only.ts
+ */
+
+import type { Elysia } from "elysia"
+import { startBackendOnly } from "./standalone"
+
+export interface BackendEntryConfig {
+  port: number
+  apiPrefix?: string
+  host?: string
+}
+
+/**
+ * Start backend in standalone mode
+ *
+ * @param apiRoutes - Elysia routes from app/server/routes
+ * @param config - Backend configuration
+ */
+export function startBackend(
+  apiRoutes: Elysia,
+  config: BackendEntryConfig
+) {
+  const { port, apiPrefix = '/api', host = 'localhost' } = config
+
+  console.log(`🚀 Backend standalone: ${host}:${port}`)
+  console.log(`📡 API Prefix: ${apiPrefix}`)
+  console.log()
+
+  // Start backend using the standalone utility
+  startBackendOnly(apiRoutes, { port, apiPrefix })
+}
+
+/**
+ * Create backend entry config from declarative config
+ * Helper to make it easy to use with the config system
+ */
+export function createBackendConfig(
+  serverConfig: { server: { backendPort: number; apiPrefix: string; host: string } }
+): BackendEntryConfig {
+  return {
+    port: serverConfig.server.backendPort,
+    apiPrefix: serverConfig.server.apiPrefix,
+    host: serverConfig.server.host
+  }
+}

package/core/types/plugin.ts

@@ -3,6 +3,9 @@
  * Comprehensive type definitions for the plugin system
  */
 
+// Import namespace for type alias
+import type { FluxStack } from "../plugins/types"
+
 // Re-export plugin types
 export type {
   FluxStack,
@@ -13,6 +16,9 @@ export type {
   ErrorContext
 } from "../plugins/types"
 
+// Export Plugin as a standalone type for convenience
+export type Plugin = FluxStack.Plugin
+
 // Additional plugin-related types
 export interface PluginManifest {
   name: string

package/core/utils/build-logger.ts

@@ -0,0 +1,324 @@
+/**
+ * FluxStack Build Logger - Beautiful terminal output for build process
+ * Provides formatted tables, boxes, and colored output
+ */
+
+// ANSI Color codes
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+
+  // Text colors
+  cyan: '\x1b[36m',
+  blue: '\x1b[34m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  magenta: '\x1b[35m',
+  white: '\x1b[37m',
+  gray: '\x1b[90m',
+
+  // Background colors
+  bgCyan: '\x1b[46m',
+  bgBlue: '\x1b[44m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgRed: '\x1b[41m',
+}
+
+// Box drawing characters
+const box = {
+  topLeft: '╭',
+  topRight: '╮',
+  bottomLeft: '╰',
+  bottomRight: '╯',
+  horizontal: '─',
+  vertical: '│',
+  verticalRight: '├',
+  verticalLeft: '┤',
+  horizontalDown: '┬',
+  horizontalUp: '┴',
+  cross: '┼',
+}
+
+export interface TableColumn {
+  header: string
+  key: string
+  width?: number
+  align?: 'left' | 'right' | 'center'
+  color?: keyof typeof colors
+}
+
+export interface TableRow {
+  [key: string]: string | number
+}
+
+export class BuildLogger {
+  private indent = ''
+  private startTime = Date.now()
+
+  /**
+   * Print a beautiful header banner
+   */
+  header(title: string) {
+    const width = 60
+    const padding = Math.floor((width - title.length - 2) / 2)
+    const paddingRight = width - title.length - 2 - padding
+
+    console.log()
+    console.log(colors.cyan + colors.bright + box.topLeft + box.horizontal.repeat(width) + box.topRight + colors.reset)
+    console.log(colors.cyan + box.vertical + ' '.repeat(padding) + colors.bright + colors.white + title + colors.cyan + ' '.repeat(paddingRight) + box.vertical + colors.reset)
+    console.log(colors.cyan + box.bottomLeft + box.horizontal.repeat(width) + box.bottomRight + colors.reset)
+    console.log()
+  }
+
+  /**
+   * Print a section header
+   */
+  section(title: string, icon: string = '📦') {
+    console.log()
+    console.log(colors.bright + colors.blue + `${icon}  ${title}` + colors.reset)
+    console.log(colors.dim + colors.gray + box.horizontal.repeat(50) + colors.reset)
+  }
+
+  /**
+   * Print a success message
+   */
+  success(message: string) {
+    console.log(colors.green + '✓ ' + colors.reset + message)
+  }
+
+  /**
+   * Print an error message
+   */
+  error(message: string) {
+    console.log(colors.red + '✗ ' + colors.reset + message)
+  }
+
+  /**
+   * Print a warning message
+   */
+  warn(message: string) {
+    console.log(colors.yellow + '⚠ ' + colors.reset + message)
+  }
+
+  /**
+   * Print an info message
+   */
+  info(message: string, icon: string = '→') {
+    console.log(colors.cyan + icon + ' ' + colors.reset + message)
+  }
+
+  /**
+   * Print a step message
+   */
+  step(message: string, icon: string = '▸') {
+    console.log(colors.dim + colors.gray + icon + ' ' + colors.reset + message)
+  }
+
+  /**
+   * Print a table
+   */
+  table(columns: TableColumn[], rows: TableRow[]) {
+    if (rows.length === 0) {
+      this.warn('No data to display')
+      return
+    }
+
+    // Calculate column widths
+    const widths = columns.map(col => {
+      if (col.width) return col.width
+      const maxContentWidth = Math.max(
+        col.header.length,
+        ...rows.map(row => String(row[col.key] || '').length)
+      )
+      return Math.min(maxContentWidth, 40) // Max 40 chars per column
+    })
+
+    const totalWidth = widths.reduce((sum, w) => sum + w, 0) + (columns.length - 1) * 3 + 4
+
+    // Print top border
+    console.log(
+      colors.gray + box.topLeft +
+      widths.map((w, i) =>
+        box.horizontal.repeat(w + 2) + (i < widths.length - 1 ? box.horizontalDown : '')
+      ).join('') +
+      box.topRight + colors.reset
+    )
+
+    // Print header
+    const headerRow = columns.map((col, i) => {
+      const content = this.padContent(col.header, widths[i], 'center')
+      return colors.bright + colors.white + content + colors.reset
+    }).join(colors.gray + ' │ ' + colors.reset)
+
+    console.log(colors.gray + box.vertical + ' ' + colors.reset + headerRow + colors.gray + ' ' + box.vertical + colors.reset)
+
+    // Print header separator
+    console.log(
+      colors.gray + box.verticalRight +
+      widths.map((w, i) =>
+        box.horizontal.repeat(w + 2) + (i < widths.length - 1 ? box.cross : '')
+      ).join('') +
+      box.verticalLeft + colors.reset
+    )
+
+    // Print rows
+    rows.forEach((row, rowIndex) => {
+      const rowContent = columns.map((col, i) => {
+        const value = String(row[col.key] || '')
+        const content = this.padContent(value, widths[i], col.align || 'left')
+        const color = col.color ? colors[col.color] : ''
+        return color + content + colors.reset
+      }).join(colors.gray + ' │ ' + colors.reset)
+
+      console.log(colors.gray + box.vertical + ' ' + colors.reset + rowContent + colors.gray + ' ' + box.vertical + colors.reset)
+    })
+
+    // Print bottom border
+    console.log(
+      colors.gray + box.bottomLeft +
+      widths.map((w, i) =>
+        box.horizontal.repeat(w + 2) + (i < widths.length - 1 ? box.horizontalUp : '')
+      ).join('') +
+      box.bottomRight + colors.reset
+    )
+  }
+
+  /**
+   * Print a simple info box
+   */
+  box(title: string, items: Array<{ label: string; value: string | number; color?: keyof typeof colors }>) {
+    const maxLabelWidth = Math.max(...items.map(i => i.label.length))
+    const maxValueWidth = Math.max(...items.map(i => String(i.value).length))
+    const contentWidth = maxLabelWidth + maxValueWidth + 3
+    const boxWidth = Math.max(contentWidth, title.length) + 4
+
+    // Top border with title
+    console.log()
+    console.log(colors.cyan + box.topLeft + box.horizontal.repeat(2) + colors.bright + colors.white + title + colors.cyan + box.horizontal.repeat(boxWidth - title.length - 2) + box.topRight + colors.reset)
+
+    // Content
+    items.forEach(item => {
+      const label = item.label.padEnd(maxLabelWidth)
+      const value = String(item.value)
+      const valueColor = item.color ? colors[item.color] : colors.white
+      console.log(
+        colors.cyan + box.vertical + ' ' + colors.reset +
+        colors.gray + label + colors.reset +
+        colors.dim + ' : ' + colors.reset +
+        valueColor + colors.bright + value + colors.reset +
+        ' '.repeat(boxWidth - label.length - value.length - 3) +
+        colors.cyan + box.vertical + colors.reset
+      )
+    })
+
+    // Bottom border
+    console.log(colors.cyan + box.bottomLeft + box.horizontal.repeat(boxWidth) + box.bottomRight + colors.reset)
+    console.log()
+  }
+
+  /**
+   * Print a progress indicator
+   */
+  progress(current: number, total: number, label: string) {
+    const percentage = Math.round((current / total) * 100)
+    const barLength = 30
+    const filled = Math.round((percentage / 100) * barLength)
+    const empty = barLength - filled
+
+    const bar = colors.green + '█'.repeat(filled) + colors.gray + '░'.repeat(empty) + colors.reset
+    console.log(`${label} [${bar}] ${percentage}% (${current}/${total})`)
+  }
+
+  /**
+   * Start a timer
+   */
+  startTimer(label?: string) {
+    this.startTime = Date.now()
+    if (label) {
+      this.info(label, '⏱')
+    }
+  }
+
+  /**
+   * End timer and print elapsed time
+   */
+  endTimer(label: string = 'Completed') {
+    const elapsed = Date.now() - this.startTime
+    const seconds = (elapsed / 1000).toFixed(2)
+    this.success(`${label} in ${colors.bright}${seconds}s${colors.reset}`)
+  }
+
+  /**
+   * Print a summary box
+   */
+  summary(title: string, stats: Array<{ label: string; value: string | number; highlight?: boolean }>) {
+    console.log()
+    console.log(colors.bright + colors.green + '╔═══════════════════════════════════════════════════════════╗' + colors.reset)
+    console.log(colors.bright + colors.green + '║' + colors.reset + colors.bright + colors.white + ` ${title}`.padEnd(60) + colors.bright + colors.green + '║' + colors.reset)
+    console.log(colors.bright + colors.green + '╠═══════════════════════════════════════════════════════════╣' + colors.reset)
+
+    stats.forEach(stat => {
+      const label = `  ${stat.label}:`
+      const value = String(stat.value)
+      const valueColor = stat.highlight ? colors.yellow + colors.bright : colors.white
+      const padding = 60 - label.length - value.length - 1
+      console.log(
+        colors.bright + colors.green + '║' + colors.reset +
+        colors.cyan + label + colors.reset +
+        ' '.repeat(Math.max(padding, 1)) +
+        valueColor + value + colors.reset +
+        colors.bright + colors.green + ' ║' + colors.reset
+      )
+    })
+
+    console.log(colors.bright + colors.green + '╚═══════════════════════════════════════════════════════════╝' + colors.reset)
+    console.log()
+  }
+
+  /**
+   * Pad content based on alignment
+   */
+  private padContent(content: string, width: number, align: 'left' | 'right' | 'center' = 'left'): string {
+    if (content.length >= width) {
+      return content.slice(0, width)
+    }
+
+    const padding = width - content.length
+
+    switch (align) {
+      case 'right':
+        return ' '.repeat(padding) + content
+      case 'center':
+        const leftPad = Math.floor(padding / 2)
+        const rightPad = padding - leftPad
+        return ' '.repeat(leftPad) + content + ' '.repeat(rightPad)
+      default:
+        return content + ' '.repeat(padding)
+    }
+  }
+
+  /**
+   * Format file size
+   */
+  formatSize(bytes: number): string {
+    if (bytes === 0) return '0 B'
+    const k = 1024
+    const sizes = ['B', 'KB', 'MB', 'GB']
+    const i = Math.floor(Math.log(bytes) / Math.log(k))
+    return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`
+  }
+
+  /**
+   * Format duration
+   */
+  formatDuration(ms: number): string {
+    if (ms < 1000) return `${ms}ms`
+    return `${(ms / 1000).toFixed(2)}s`
+  }
+}
+
+// Export singleton instance
+export const buildLogger = new BuildLogger()

package/core/utils/config-schema.ts

@@ -23,17 +23,13 @@
  *     default: 3000,
  *     validate: (value) => value > 0 && value < 65536
  *   },
- *   debug: {
- *     type: 'boolean',
- *     env: 'DEBUG',
- *     default: false
- *   }
+ *   env: config.enum('NODE_ENV', ['development', 'production', 'test'] as const, 'development', true)
  * })
  *
  * // Access with full type safety
  * appConfig.name   // string
  * appConfig.port   // number
- * appConfig.debug  // boolean
+ * appConfig.env    // "development" | "production" | "test"
  * ```
  */
 

package/core/utils/helpers.ts

@@ -86,22 +86,27 @@ export const throttle = <T extends (...args: any[]) => any>(
   }
 }
 
+/**
+ * Environment detection utilities
+ * Uses declarative config system instead of legacy env
+ */
+
 export const isProduction = (): boolean => {
-  // Import here to avoid circular dependency
-  const { env } = require('./env')
-  return env.NODE_ENV === 'production'
+  // Lazy import to avoid circular dependency during module initialization
+  const { appConfig } = require('@/config/app.config')
+  return appConfig.env === 'production'
 }
 
 export const isDevelopment = (): boolean => {
-  // Import here to avoid circular dependency
-  const { env } = require('./env')
-  return env.NODE_ENV === 'development' || !env.NODE_ENV
+  // Lazy import to avoid circular dependency during module initialization
+  const { appConfig } = require('@/config/app.config')
+  return appConfig.env === 'development'
 }
 
 export const isTest = (): boolean => {
-  // Import here to avoid circular dependency
-  const { env } = require('./env')
-  return env.NODE_ENV === 'test'
+  // Lazy import to avoid circular dependency during module initialization
+  const { appConfig } = require('@/config/app.config')
+  return appConfig.env === 'test'
 }
 
 export const deepMerge = <T extends Record<string, any>>(target: T, source: Partial<T>): T => {

package/core/utils/regenerate-files.ts

@@ -0,0 +1,69 @@
+/**
+ * File Regeneration Utilities
+ *
+ * Provides functions to regenerate critical application files that might be
+ * accidentally deleted by developers.
+ */
+
+import { join } from "path"
+import { existsSync } from "fs"
+
+const BACKEND_ONLY_TEMPLATE = `/**
+ * 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.
+ */
+
+import { startBackend, createBackendConfig } from "@/core/server/backend-entry"
+import { apiRoutes } from "./routes"
+import { serverConfig } from "@/config/server.config"
+
+// Create backend configuration from declarative config
+const backendConfig = createBackendConfig(serverConfig)
+
+// Start backend in standalone mode
+startBackend(apiRoutes, backendConfig)
+`
+
+/**
+ * Check if backend-only.ts exists, regenerate if missing
+ */
+export async function ensureBackendEntry(projectRoot: string = process.cwd()): Promise<boolean> {
+  const backendOnlyPath = join(projectRoot, "app/server/backend-only.ts")
+
+  if (!existsSync(backendOnlyPath)) {
+    console.log("⚠️  backend-only.ts not found, regenerating...")
+
+    try {
+      await Bun.write(backendOnlyPath, BACKEND_ONLY_TEMPLATE)
+      console.log("✅ backend-only.ts regenerated successfully")
+      return true
+    } catch (error) {
+      console.error("❌ Failed to regenerate backend-only.ts:", error)
+      return false
+    }
+  }
+
+  return true
+}
+
+/**
+ * Regenerate backend-only.ts file
+ */
+export async function regenerateBackendEntry(projectRoot: string = process.cwd()): Promise<boolean> {
+  const backendOnlyPath = join(projectRoot, "app/server/backend-only.ts")
+
+  console.log("🔄 Regenerating backend-only.ts...")
+
+  try {
+    await Bun.write(backendOnlyPath, BACKEND_ONLY_TEMPLATE)
+    console.log("✅ backend-only.ts regenerated successfully")
+    return true
+  } catch (error) {
+    console.error("❌ Failed to regenerate backend-only.ts:", error)
+    return false
+  }
+}

package/core/utils/version.ts

@@ -3,4 +3,4 @@
  * Single source of truth for version number
  * Auto-synced with package.json
  */
-export const FLUXSTACK_VERSION = '1.7.4'
+export const FLUXSTACK_VERSION = '1.8.1'