create-fluxstack 1.0.13 → 1.0.14

package/core/cli/generators/utils.ts

@@ -0,0 +1,192 @@
+import { existsSync } from "fs"
+import { join } from "path"
+
+export class GeneratorUtils {
+  static validateName(name: string): { valid: boolean; error?: string } {
+    if (!name || typeof name !== 'string') {
+      return { valid: false, error: 'Name is required' }
+    }
+    
+    const trimmed = name.trim()
+    if (trimmed.length === 0) {
+      return { valid: false, error: 'Name cannot be empty' }
+    }
+    
+    if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(trimmed)) {
+      return { valid: false, error: 'Name must start with a letter and contain only letters, numbers, hyphens, and underscores' }
+    }
+    
+    if (trimmed.length > 100) {
+      return { valid: false, error: 'Name must be less than 100 characters' }
+    }
+    
+    return { valid: true }
+  }
+
+  static validatePath(path: string): { valid: boolean; error?: string } {
+    if (!path || typeof path !== 'string') {
+      return { valid: true } // Path is optional
+    }
+    
+    const trimmed = path.trim()
+    if (trimmed.length === 0) {
+      return { valid: true }
+    }
+    
+    // Check for invalid characters
+    if (/[<>:"|?*]/.test(trimmed)) {
+      return { valid: false, error: 'Path contains invalid characters' }
+    }
+    
+    // Check for absolute paths (should be relative)
+    if (trimmed.startsWith('/') || /^[a-zA-Z]:/.test(trimmed)) {
+      return { valid: false, error: 'Path should be relative to project root' }
+    }
+    
+    return { valid: true }
+  }
+
+  static checkFileExists(workingDir: string, filePath: string): boolean {
+    const fullPath = join(workingDir, filePath)
+    return existsSync(fullPath)
+  }
+
+  static getDefaultPath(type: string, name: string): string {
+    const kebabName = this.toKebabCase(name)
+    const pascalName = this.toPascalCase(name)
+    
+    switch (type) {
+      case 'controller':
+        return `app/server/controllers/${kebabName}.controller.ts`
+      case 'service':
+        return `app/server/services/${kebabName}.service.ts`
+      case 'route':
+        return `app/server/routes/${kebabName}.routes.ts`
+      case 'component':
+        return `app/client/src/components/${pascalName}/${pascalName}.tsx`
+      default:
+        return `${kebabName}.ts`
+    }
+  }
+
+  static getRelatedFiles(type: string, name: string): string[] {
+    const kebabName = this.toKebabCase(name)
+    const pascalName = this.toPascalCase(name)
+    
+    switch (type) {
+      case 'controller':
+        return [
+          `app/server/services/${kebabName}.service.ts`,
+          `app/server/schemas/${kebabName}.schema.ts`,
+          `app/server/routes/${kebabName}.routes.ts`
+        ]
+      case 'service':
+        return [
+          `app/server/repositories/${kebabName}.repository.ts`,
+          `app/server/controllers/${kebabName}.controller.ts`
+        ]
+      case 'component':
+        return [
+          `app/client/src/components/${pascalName}/${pascalName}.css`,
+          `app/client/src/components/${pascalName}/index.ts`,
+          `app/client/src/components/${pascalName}/${pascalName}.test.tsx`,
+          `app/client/src/components/${pascalName}/${pascalName}.stories.tsx`
+        ]
+      case 'route':
+        return [
+          `app/server/controllers/${kebabName}.controller.ts`,
+          `app/server/middleware/${kebabName}.middleware.ts`
+        ]
+      default:
+        return []
+    }
+  }
+
+  static formatFileSize(bytes: number): string {
+    const units = ['B', 'KB', 'MB', 'GB']
+    let size = bytes
+    let unitIndex = 0
+    
+    while (size >= 1024 && unitIndex < units.length - 1) {
+      size /= 1024
+      unitIndex++
+    }
+    
+    return `${size.toFixed(1)} ${units[unitIndex]}`
+  }
+
+  static getTemplateVariables(name: string, additionalVars: Record<string, any> = {}): Record<string, any> {
+    return {
+      name,
+      Name: this.capitalize(name),
+      NAME: name.toUpperCase(),
+      kebabName: this.toKebabCase(name),
+      camelName: this.toCamelCase(name),
+      pascalName: this.toPascalCase(name),
+      snakeName: this.toSnakeCase(name),
+      timestamp: new Date().toISOString(),
+      date: new Date().toLocaleDateString(),
+      time: new Date().toLocaleTimeString(),
+      year: new Date().getFullYear(),
+      month: new Date().getMonth() + 1,
+      day: new Date().getDate(),
+      ...additionalVars
+    }
+  }
+
+  // String transformation utilities
+  static capitalize(str: string): string {
+    return str.charAt(0).toUpperCase() + str.slice(1)
+  }
+
+  static toCamelCase(str: string): string {
+    return str
+      .replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : '')
+      .replace(/^[A-Z]/, char => char.toLowerCase())
+  }
+
+  static toPascalCase(str: string): string {
+    return this.capitalize(this.toCamelCase(str))
+  }
+
+  static toKebabCase(str: string): string {
+    return str
+      .replace(/([a-z])([A-Z])/g, '$1-$2')
+      .replace(/[\s_]+/g, '-')
+      .toLowerCase()
+  }
+
+  static toSnakeCase(str: string): string {
+    return str
+      .replace(/([a-z])([A-Z])/g, '$1_$2')
+      .replace(/[\s-]+/g, '_')
+      .toLowerCase()
+  }
+
+  static pluralize(str: string): string {
+    // Simple pluralization - in a real implementation you'd use a proper library
+    if (str.endsWith('y')) {
+      return str.slice(0, -1) + 'ies'
+    }
+    if (str.endsWith('s') || str.endsWith('sh') || str.endsWith('ch') || str.endsWith('x') || str.endsWith('z')) {
+      return str + 'es'
+    }
+    return str + 's'
+  }
+
+  static singularize(str: string): string {
+    // Simple singularization - in a real implementation you'd use a proper library
+    if (str.endsWith('ies')) {
+      return str.slice(0, -3) + 'y'
+    }
+    if (str.endsWith('es')) {
+      return str.slice(0, -2)
+    }
+    if (str.endsWith('s') && !str.endsWith('ss')) {
+      return str.slice(0, -1)
+    }
+    return str
+  }
+}
+
+export const generatorUtils = GeneratorUtils

package/core/cli/index.ts

@@ -5,12 +5,81 @@ import { ProjectCreator } from "../templates/create-project"
 import { getConfigSync } from "../config"
 import { cliRegistry } from "./command-registry"
 import { pluginDiscovery } from "./plugin-discovery"
+import { generateCommand, interactiveGenerateCommand } from "./generators/index.js"
 
 const command = process.argv[2]
 const args = process.argv.slice(3)
 
 // Register built-in commands
 async function registerBuiltInCommands() {
+  // Register generate commands
+  cliRegistry.register(generateCommand)
+  cliRegistry.register(interactiveGenerateCommand)
+  
+  // Register plugin dependency commands
+  cliRegistry.register({
+    name: 'plugin:deps',
+    description: 'Gerenciar dependências de plugins',
+    category: 'Plugins',
+    handler: async (args, options, context) => {
+      if (args.length === 0) {
+        console.log(`
+⚡ FluxStack Plugin Dependencies Manager
+
+Usage:
+  flux plugin:deps install     Install plugin dependencies
+  flux plugin:deps list        List plugin dependencies  
+  flux plugin:deps check       Check for dependency conflicts
+  flux plugin:deps clean       Clean unused dependencies
+
+Examples:
+  flux plugin:deps install --dry-run    # Show what would be installed
+  flux plugin:deps list --plugin crypto-auth  # Show specific plugin deps
+  flux plugin:deps check                # Check for conflicts
+        `)
+        return
+      }
+      
+      // Handle subcommands
+      const subcommand = args[0]
+      const subArgs = args.slice(1)
+      
+      // Import dinamicamente para evitar problemas de inicialização
+      const { createPluginDepsCommand } = await import('./commands/plugin-deps')
+      const cmd = createPluginDepsCommand()
+      
+      switch (subcommand) {
+        case 'install':
+          const installCmd = cmd.commands.find(c => c.name() === 'install')
+          if (installCmd) {
+            await installCmd.parseAsync(['node', 'cli', ...subArgs], { from: 'user' })
+          }
+          break
+        case 'list':
+          const listCmd = cmd.commands.find(c => c.name() === 'list')
+          if (listCmd) {
+            await listCmd.parseAsync(['node', 'cli', ...subArgs], { from: 'user' })
+          }
+          break
+        case 'check':
+          const checkCmd = cmd.commands.find(c => c.name() === 'check')
+          if (checkCmd) {
+            await checkCmd.parseAsync(['node', 'cli', ...subArgs], { from: 'user' })
+          }
+          break
+        case 'clean':
+          const cleanCmd = cmd.commands.find(c => c.name() === 'clean')
+          if (cleanCmd) {
+            await cleanCmd.parseAsync(['node', 'cli', ...subArgs], { from: 'user' })
+          }
+          break
+        default:
+          console.error(`❌ Unknown subcommand: ${subcommand}`)
+          console.error('Available subcommands: install, list, check, clean')
+      }
+    }
+  })
+  
   // Help command
   cliRegistry.register({
     name: 'help',

package/core/cli/plugin-discovery.ts

@@ -11,39 +11,35 @@ export class CliPluginDiscovery {
     // 1. Load built-in plugins with CLI commands
     await this.loadBuiltInPlugins()
     
-    // 2. Load external plugins from node_modules
-    await this.loadExternalPlugins()
-    
-    // 3. Load local plugins from project
+    // 2. Load local plugins from project
     await this.loadLocalPlugins()
   }
 
   private async loadBuiltInPlugins(): Promise<void> {
-    const builtInPluginsDir = join(__dirname, '../server/plugins')
+    const builtInPluginsDir = join(__dirname, '../plugins/built-in')
     
     if (!existsSync(builtInPluginsDir)) {
       return
     }
 
     try {
-      // For now, we'll manually list built-in plugins that might have CLI commands
-      const potentialPlugins = [
-        'logger',
-        'vite', 
-        'swagger',
-        'static',
-        'database'
-      ]
+      const fs = await import('fs')
+      const potentialPlugins = fs.readdirSync(builtInPluginsDir, { withFileTypes: true })
+        .filter(entry => entry.isDirectory())
+        .map(entry => entry.name)
 
       for (const pluginName of potentialPlugins) {
         try {
-          const pluginPath = join(builtInPluginsDir, `${pluginName}.ts`)
+          const pluginPath = join(builtInPluginsDir, pluginName, 'index.ts')
           if (existsSync(pluginPath)) {
             const pluginModule = await import(pluginPath)
-            const plugin = pluginModule[`${pluginName}Plugin`] as Plugin
             
-            if (plugin && plugin.commands) {
-              this.registerPluginCommands(plugin)
+            if (pluginModule.commands) {
+              for (const command of pluginModule.commands) {
+                cliRegistry.register(command)
+              }
+              this.loadedPlugins.add(pluginName)
+              logger.debug(`Registered ${pluginModule.commands.length} CLI commands from built-in plugin: ${pluginName}`)
             }
           }
         } catch (error) {
@@ -55,74 +51,9 @@ export class CliPluginDiscovery {
     }
   }
 
-  private async loadExternalPlugins(): Promise<void> {
-    const nodeModulesDir = join(process.cwd(), 'node_modules')
-    
-    if (!existsSync(nodeModulesDir)) {
-      return
-    }
-
-    try {
-      const fs = await import('fs')
-      const entries = fs.readdirSync(nodeModulesDir, { withFileTypes: true })
-      
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue
-        
-        // Check for FluxStack plugins (convention: fluxstack-plugin-*)
-        if (entry.name.startsWith('fluxstack-plugin-')) {
-          await this.loadExternalPlugin(entry.name)
-        }
-        
-        // Check for scoped packages (@fluxstack/plugin-*)
-        if (entry.name.startsWith('@fluxstack')) {
-          const scopedDir = join(nodeModulesDir, entry.name)
-          if (existsSync(scopedDir)) {
-            const scopedEntries = fs.readdirSync(scopedDir, { withFileTypes: true })
-            for (const scopedEntry of scopedEntries) {
-              if (scopedEntry.isDirectory() && scopedEntry.name.startsWith('plugin-')) {
-                await this.loadExternalPlugin(`${entry.name}/${scopedEntry.name}`)
-              }
-            }
-          }
-        }
-      }
-    } catch (error) {
-      logger.debug('Failed to scan external plugins:', error)
-    }
-  }
-
-  private async loadExternalPlugin(packageName: string): Promise<void> {
-    try {
-      const packagePath = join(process.cwd(), 'node_modules', packageName)
-      const packageJsonPath = join(packagePath, 'package.json')
-      
-      if (!existsSync(packageJsonPath)) {
-        return
-      }
-
-      const packageJson = JSON.parse(await import('fs').then(fs => 
-        fs.readFileSync(packageJsonPath, 'utf-8')
-      ))
-
-      // Check if this is a FluxStack plugin
-      if (packageJson.fluxstack?.plugin) {
-        const entryPoint = packageJson.main || 'index.js'
-        const pluginPath = join(packagePath, entryPoint)
-        
-        if (existsSync(pluginPath)) {
-          const pluginModule = await import(pluginPath)
-          const plugin = pluginModule.default || pluginModule[packageJson.fluxstack.plugin] as Plugin
-          
-          if (plugin && plugin.commands) {
-            this.registerPluginCommands(plugin)
-          }
-        }
-      }
-    } catch (error) {
-      logger.debug(`Failed to load external plugin ${packageName}:`, error)
-    }
-  }
+  // Métodos removidos - não carregamos mais plugins do node_modules
+  // private async loadExternalPlugins(): Promise<void> { ... }
+  // private async loadExternalPlugin(packageName: string): Promise<void> { ... }
 
   private async loadLocalPlugins(): Promise<void> {
     const localPluginsDir = join(process.cwd(), 'plugins')

package/core/client/fluxstack.ts

@@ -0,0 +1,17 @@
+// 🔥 FluxStack Client Library - Main Entry Point
+// This is the primary interface for all FluxStack client functionality
+
+// Re-export everything from the main index
+export * from './index'
+
+// Convenience aliases for common hooks and utilities
+export { 
+  useHybridLiveComponent as useLive,
+  useWebSocket as useWS,
+  useChunkedUpload as useUpload,
+  StateValidator as Validator
+} from './index'
+
+// Default export for easy importing
+import * as FluxStack from './index'
+export default FluxStack

package/core/client/hooks/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Core Client Hooks
+ * FluxStack hook utilities exports
+ */
+
+export { createAuthHook } from './useAuth.js'
+export type { AuthHook } from './useAuth.js'

package/core/client/hooks/state-validator.ts

@@ -0,0 +1,130 @@
+// 🔥 State Validation Utilities
+
+import type { StateValidation, StateConflict, HybridState } from '../../types/types'
+
+export class StateValidator {
+  /**
+   * Generate checksum for state object
+   */
+  static generateChecksum(state: any): string {
+    const json = JSON.stringify(state, Object.keys(state).sort())
+    let hash = 0
+    for (let i = 0; i < json.length; i++) {
+      const char = json.charCodeAt(i)
+      hash = ((hash << 5) - hash) + char
+      hash = hash & hash // Convert to 32-bit integer
+    }
+    return Math.abs(hash).toString(16)
+  }
+
+  /**
+   * Create validation metadata
+   */
+  static createValidation(
+    state: any, 
+    source: 'client' | 'server' | 'mount' = 'client'
+  ): StateValidation {
+    return {
+      checksum: this.generateChecksum(state),
+      version: Date.now(),
+      timestamp: Date.now(),
+      source
+    }
+  }
+
+  /**
+   * Compare two states and detect conflicts
+   */
+  static detectConflicts<T>(
+    clientState: T, 
+    serverState: T,
+    excludeFields: string[] = ['lastUpdated', 'version']
+  ): StateConflict[] {
+    const conflicts: StateConflict[] = []
+    
+    const clientKeys = Object.keys(clientState as any)
+    const serverKeys = Object.keys(serverState as any)
+    const allKeys = Array.from(new Set([...clientKeys, ...serverKeys]))
+
+    for (const key of allKeys) {
+      if (excludeFields.includes(key)) continue
+
+      const clientValue = (clientState as any)?.[key]
+      const serverValue = (serverState as any)?.[key]
+
+      if (JSON.stringify(clientValue) !== JSON.stringify(serverValue)) {
+        conflicts.push({
+          property: key as string,
+          clientValue,
+          serverValue,
+          timestamp: Date.now(),
+          resolved: false
+        })
+      }
+    }
+
+    return conflicts
+  }
+
+  /**
+   * Merge states with conflict resolution
+   */
+  static mergeStates<T>(
+    clientState: T,
+    serverState: T,
+    conflicts: StateConflict[],
+    strategy: 'client' | 'server' | 'smart' = 'smart'
+  ): T {
+    const merged = { ...clientState }
+
+    for (const conflict of conflicts) {
+      switch (strategy) {
+        case 'client':
+          // Keep client value
+          break
+        
+        case 'server':
+          (merged as any)[conflict.property] = conflict.serverValue
+          break
+          
+        case 'smart':
+          // Smart resolution based on field type and context
+          if (conflict.property === 'lastUpdated') {
+            // Server timestamp wins
+            (merged as any)[conflict.property] = conflict.serverValue
+          } else if (typeof conflict.serverValue === 'number' && typeof conflict.clientValue === 'number') {
+            // For numbers, use the higher value (e.g., counters)
+            (merged as any)[conflict.property] = Math.max(conflict.serverValue, conflict.clientValue)
+          } else {
+            // Default to server for other types
+            (merged as any)[conflict.property] = conflict.serverValue
+          }
+          break
+      }
+    }
+
+    return merged
+  }
+
+  /**
+   * Validate state integrity
+   */
+  static validateState<T>(hybridState: HybridState<T>): boolean {
+    const currentChecksum = this.generateChecksum(hybridState.data)
+    return currentChecksum === hybridState.validation.checksum
+  }
+
+  /**
+   * Update validation after state change
+   */
+  static updateValidation<T>(
+    hybridState: HybridState<T>,
+    source: 'client' | 'server' | 'mount' = 'client'
+  ): HybridState<T> {
+    return {
+      ...hybridState,
+      validation: this.createValidation(hybridState.data, source),
+      status: 'synced'
+    }
+  }
+}

package/core/client/hooks/useAuth.ts

@@ -0,0 +1,49 @@
+/**
+ * Authentication Hook
+ * Core FluxStack authentication utilities
+ */
+
+import type { BaseUser, BaseUserStore } from '../state/index.js'
+
+/**
+ * Create authentication hook for a user store
+ */
+export function createAuthHook(useUserStore: () => BaseUserStore) {
+  return function useAuth() {
+    const store = useUserStore()
+    
+    return {
+      // State
+      currentUser: store.currentUser,
+      isAuthenticated: store.isAuthenticated,
+      isLoading: store.isLoading,
+      error: store.error,
+      
+      // Computed
+      isAdmin: store.currentUser?.role === 'admin',
+      
+      // Actions
+      login: store.login,
+      register: store.register,
+      logout: store.logout,
+      updateProfile: store.updateProfile,
+      clearError: store.clearError
+    }
+  }
+}
+
+/**
+ * Base auth hook interface
+ */
+export interface AuthHook {
+  currentUser: BaseUser | null
+  isAuthenticated: boolean
+  isLoading: boolean
+  error: string | null
+  isAdmin: boolean
+  login: (credentials: { email: string; password: string }) => Promise<void>
+  register: (data: { email: string; password: string; name: string }) => Promise<void>
+  logout: () => void
+  updateProfile: (data: Partial<BaseUser>) => Promise<void>
+  clearError: () => void
+}