create-fluxstack 1.0.13 → 1.0.15

package/core/utils/__tests__/helpers.test.ts

@@ -1,297 +0,0 @@
-/**
- * Tests for Helper Utilities
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import {
-  formatBytes,
-  createTimer,
-  delay,
-  retry,
-  debounce,
-  throttle,
-  isProduction,
-  isDevelopment,
-  isTest,
-  deepMerge,
-  pick,
-  omit,
-  generateId,
-  safeJsonParse,
-  safeJsonStringify
-} from '../helpers'
-
-describe('Helper Utilities', () => {
-  describe('formatBytes', () => {
-    it('should format bytes correctly', () => {
-      expect(formatBytes(0)).toBe('0 Bytes')
-      expect(formatBytes(1024)).toBe('1 KB')
-      expect(formatBytes(1048576)).toBe('1 MB')
-      expect(formatBytes(1073741824)).toBe('1 GB')
-    })
-
-    it('should handle decimal places', () => {
-      expect(formatBytes(1536, 1)).toBe('1.5 KB')
-      expect(formatBytes(1536, 0)).toBe('2 KB')
-    })
-  })
-
-  describe('createTimer', () => {
-    it('should measure time correctly', async () => {
-      const timer = createTimer('test')
-      await delay(10)
-      const duration = timer.end()
-
-      // Be more lenient in CI environments where timing can be variable
-      expect(duration).toBeGreaterThanOrEqual(5)
-      expect(timer.label).toBe('test')
-    })
-  })
-
-  describe('delay', () => {
-    it('should delay execution', async () => {
-      const start = Date.now()
-      await delay(50)
-      const end = Date.now()
-
-      // Be more lenient with timing in CI environments - allow for 10ms variance
-      expect(end - start).toBeGreaterThanOrEqual(40)
-      expect(end - start).toBeLessThan(200) // Ensure it's not too long
-    })
-  })
-
-  describe('retry', () => {
-    it('should succeed on first attempt', async () => {
-      const fn = vi.fn().mockResolvedValue('success')
-      const result = await retry(fn, 3, 10)
-
-      expect(result).toBe('success')
-      expect(fn).toHaveBeenCalledTimes(1)
-    })
-
-    it('should retry on failure and eventually succeed', async () => {
-      const fn = vi.fn()
-        .mockRejectedValueOnce(new Error('fail 1'))
-        .mockRejectedValueOnce(new Error('fail 2'))
-        .mockResolvedValue('success')
-
-      const result = await retry(fn, 3, 10)
-
-      expect(result).toBe('success')
-      expect(fn).toHaveBeenCalledTimes(3)
-    })
-
-    it('should throw after max attempts', async () => {
-      const fn = vi.fn().mockRejectedValue(new Error('always fails'))
-
-      await expect(retry(fn, 2, 10)).rejects.toThrow('always fails')
-      expect(fn).toHaveBeenCalledTimes(2)
-    })
-  })
-
-  describe('debounce', () => {
-    beforeEach(() => {
-      vi.useFakeTimers()
-    })
-
-    afterEach(() => {
-      vi.useRealTimers()
-    })
-
-    it('should debounce function calls', () => {
-      const fn = vi.fn()
-      const debouncedFn = debounce(fn, 100)
-
-      debouncedFn('arg1')
-      debouncedFn('arg2')
-      debouncedFn('arg3')
-
-      expect(fn).not.toHaveBeenCalled()
-
-      vi.advanceTimersByTime(100)
-
-      expect(fn).toHaveBeenCalledTimes(1)
-      expect(fn).toHaveBeenCalledWith('arg3')
-    })
-  })
-
-  describe('throttle', () => {
-    beforeEach(() => {
-      vi.useFakeTimers()
-    })
-
-    afterEach(() => {
-      vi.useRealTimers()
-    })
-
-    it('should throttle function calls', () => {
-      const fn = vi.fn()
-      const throttledFn = throttle(fn, 100)
-
-      throttledFn('arg1')
-      throttledFn('arg2')
-      throttledFn('arg3')
-
-      expect(fn).toHaveBeenCalledTimes(1)
-      expect(fn).toHaveBeenCalledWith('arg1')
-
-      vi.advanceTimersByTime(100)
-
-      throttledFn('arg4')
-      expect(fn).toHaveBeenCalledTimes(2)
-      expect(fn).toHaveBeenCalledWith('arg4')
-    })
-  })
-
-  describe('Environment Checks', () => {
-    const originalEnv = process.env.NODE_ENV
-
-    afterEach(() => {
-      process.env.NODE_ENV = originalEnv
-    })
-
-    it('should detect production environment', () => {
-      process.env.NODE_ENV = 'production'
-      expect(isProduction()).toBe(true)
-      expect(isDevelopment()).toBe(false)
-      expect(isTest()).toBe(false)
-    })
-
-    it('should detect development environment', () => {
-      process.env.NODE_ENV = 'development'
-      expect(isProduction()).toBe(false)
-      expect(isDevelopment()).toBe(true)
-      expect(isTest()).toBe(false)
-    })
-
-    it('should detect test environment', () => {
-      process.env.NODE_ENV = 'test'
-      expect(isProduction()).toBe(false)
-      expect(isDevelopment()).toBe(false)
-      expect(isTest()).toBe(true)
-    })
-
-    it('should default to development when NODE_ENV is not set', () => {
-      delete process.env.NODE_ENV
-      expect(isDevelopment()).toBe(true)
-    })
-  })
-
-  describe('Object Utilities', () => {
-    describe('deepMerge', () => {
-      it('should merge objects deeply', () => {
-        const target = {
-          a: 1,
-          b: {
-            c: 2,
-            d: 3
-          }
-        }
-
-        const source = {
-          b: {
-            c: 2, // Keep existing property
-            d: 4,
-            e: 5
-          },
-          f: 6
-        }
-
-        const result = deepMerge(target, source)
-
-        expect(result).toEqual({
-          a: 1,
-          b: {
-            c: 2,
-            d: 4,
-            e: 5
-          },
-          f: 6
-        })
-      })
-
-      it('should handle arrays correctly', () => {
-        const target = { arr: [1, 2, 3] }
-        const source = { arr: [4, 5, 6] }
-
-        const result = deepMerge(target, source)
-
-        expect(result.arr).toEqual([4, 5, 6])
-      })
-    })
-
-    describe('pick', () => {
-      it('should pick specified keys', () => {
-        const obj = { a: 1, b: 2, c: 3, d: 4 }
-        const result = pick(obj, ['a', 'c'])
-
-        expect(result).toEqual({ a: 1, c: 3 })
-      })
-
-      it('should handle non-existent keys', () => {
-        const obj = { a: 1, b: 2 }
-        const result = pick(obj, ['a', 'c'] as any)
-
-        expect(result).toEqual({ a: 1 })
-      })
-    })
-
-    describe('omit', () => {
-      it('should omit specified keys', () => {
-        const obj = { a: 1, b: 2, c: 3, d: 4 }
-        const result = omit(obj, ['b', 'd'])
-
-        expect(result).toEqual({ a: 1, c: 3 })
-      })
-    })
-  })
-
-  describe('String Utilities', () => {
-    describe('generateId', () => {
-      it('should generate id with default length', () => {
-        const id = generateId()
-        expect(id).toHaveLength(8)
-        expect(id).toMatch(/^[A-Za-z0-9]+$/)
-      })
-
-      it('should generate id with custom length', () => {
-        const id = generateId(16)
-        expect(id).toHaveLength(16)
-      })
-
-      it('should generate unique ids', () => {
-        const id1 = generateId()
-        const id2 = generateId()
-        expect(id1).not.toBe(id2)
-      })
-    })
-
-    describe('safeJsonParse', () => {
-      it('should parse valid JSON', () => {
-        const result = safeJsonParse('{"a": 1}', {})
-        expect(result).toEqual({ a: 1 })
-      })
-
-      it('should return fallback for invalid JSON', () => {
-        const fallback = { error: true }
-        const result = safeJsonParse('invalid json', fallback)
-        expect(result).toBe(fallback)
-      })
-    })
-
-    describe('safeJsonStringify', () => {
-      it('should stringify valid objects', () => {
-        const result = safeJsonStringify({ a: 1 })
-        expect(result).toBe('{"a":1}')
-      })
-
-      it('should return fallback for circular references', () => {
-        const circular: any = { a: 1 }
-        circular.self = circular
-
-        const result = safeJsonStringify(circular, '{"error": true}')
-        expect(result).toBe('{"error": true}')
-      })
-    })
-  })
-})

package/core/utils/__tests__/logger.test.ts

@@ -1,141 +0,0 @@
-/**
- * Tests for Logger Utility
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-
-// Set test environment
-process.env.NODE_ENV = 'test'
-
-// Import the logger
-import { logger as realLogger, log as realLog } from '../logger'
-
-describe('Logger', () => {
-  let consoleSpy: {
-    debug: any
-    info: any
-    warn: any
-    error: any
-  }
-  let logger: typeof realLogger
-  let log: typeof realLog
-
-  beforeEach(() => {
-    consoleSpy = {
-      debug: vi.spyOn(console, 'debug').mockImplementation(() => {}),
-      info: vi.spyOn(console, 'info').mockImplementation(() => {}),
-      warn: vi.spyOn(console, 'warn').mockImplementation(() => {}),
-      error: vi.spyOn(console, 'error').mockImplementation(() => {})
-    }
-    logger = realLogger
-    log = realLog
-  })
-
-  afterEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  describe('Log Levels', () => {
-    it('should log info messages', () => {
-      logger.info('Test info message')
-      expect(consoleSpy.info).toHaveBeenCalled()
-    })
-
-    it('should log warn messages', () => {
-      logger.warn('Test warn message')
-      expect(consoleSpy.warn).toHaveBeenCalled()
-    })
-
-    it('should log error messages', () => {
-      logger.error('Test error message')
-      expect(consoleSpy.error).toHaveBeenCalled()
-    })
-
-    it('should not log debug messages when log level is info', () => {
-      logger.debug('Test debug message')
-      expect(consoleSpy.debug).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('Message Formatting', () => {
-    it('should format messages with timestamp and level', () => {
-      logger.info('Test message')
-      
-      const call = consoleSpy.info.mock.calls[0][0]
-      expect(call).toMatch(/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\] INFO  Test message/)
-    })
-
-    it('should include metadata in log messages', () => {
-      const metadata = { userId: 123, action: 'login' }
-      logger.info('User action', metadata)
-      
-      const call = consoleSpy.info.mock.calls[0][0]
-      expect(call).toContain(JSON.stringify(metadata))
-    })
-  })
-
-  describe('Contextual Logging', () => {
-    it('should support contextual logging (basic test)', () => {
-      // Test that logger has basic functionality
-      expect(logger).toBeDefined()
-      expect(typeof logger.info).toBe('function')
-    })
-
-    it('should have log convenience object', () => {
-      // Test that log convenience object exists
-      expect(log).toBeDefined()
-      expect(typeof log.info).toBe('function')
-    })
-  })
-
-  describe('Performance Logging', () => {
-    it('should support basic logging functionality', () => {
-      // Test basic functionality without advanced features
-      expect(logger).toBeDefined()
-      expect(typeof logger.info).toBe('function')
-    })
-
-    it('should handle logging without errors', () => {
-      // Basic test without expecting specific console output
-      expect(() => {
-        logger.info('Test message')
-        log.info('Test message via convenience function')
-      }).not.toThrow()
-    })
-  })
-
-  describe('HTTP Request Logging', () => {
-    it('should log HTTP requests', () => {
-      logger.request('GET', '/api/users', 200, 150)
-      
-      expect(consoleSpy.info).toHaveBeenCalledWith(
-        expect.stringMatching(/GET \/api\/users 200 \(150ms\)/)
-      )
-    })
-
-    it('should log requests without status and duration', () => {
-      logger.request('POST', '/api/users')
-      
-      expect(consoleSpy.info).toHaveBeenCalledWith(
-        expect.stringMatching(/POST \/api\/users/)
-      )
-    })
-  })
-
-  describe('Convenience Functions', () => {
-    it('should provide log convenience functions', () => {
-      log.info('Test message')
-      expect(consoleSpy.info).toHaveBeenCalled()
-    })
-
-    it('should provide plugin logging', () => {
-      log.plugin('test-plugin', 'Plugin message')
-      expect(consoleSpy.debug).not.toHaveBeenCalled() // debug level, won't show with info level
-    })
-
-    it('should provide framework logging', () => {
-      log.framework('Framework message')
-      expect(consoleSpy.info).toHaveBeenCalled()
-    })
-  })
-})

package/create-test-app.ts

@@ -1,156 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * Script temporário para testar criação de aplicação FluxStack
- * Simula o comportamento do create-fluxstack CLI
- */
-
-import { promises as fs } from 'fs';
-import path from 'path';
-
-interface ProjectOptions {
-  name: string;
-  template: 'basic' | 'minimal' | 'full';
-  targetDir?: string;
-}
-
-async function createTestApp(options: ProjectOptions) {
-  const { name, template } = options;
-  const projectPath = path.resolve('test-apps', name);
-  
-  console.log(`🚀 Creating FluxStack app: ${name}`);
-  console.log(`📁 Location: ${projectPath}`);
-  console.log(`📋 Template: ${template}`);
-  console.log();
-  
-  // Check if directory already exists
-  try {
-    await fs.access(projectPath);
-    console.log(`❌ Directory ${name} already exists`);
-    return;
-  } catch (error: any) {
-    if (error.code !== 'ENOENT') {
-      throw error;
-    }
-  }
-  
-  // Create project directory
-  await fs.mkdir(projectPath, { recursive: true });
-  
-  // Get template path
-  const templatePath = path.resolve('framework-distribution', 'create-fluxstack', 'templates', template);
-  
-  // Copy template files
-  await copyDirectory(templatePath, projectPath);
-  
-  // Process template files (replace placeholders)
-  await processTemplateFiles(projectPath, {
-    PROJECT_NAME: name,
-    PROJECT_DESCRIPTION: `A FluxStack application named ${name}`,
-    PROJECT_NAME_KEBAB: name,
-    PROJECT_NAME_CAMEL: toCamelCase(name),
-    PROJECT_NAME_PASCAL: toPascalCase(name)
-  });
-  
-  console.log('✅ Project created successfully!');
-  console.log();
-  console.log('Next steps:');
-  console.log(`  cd test-apps/${name}`);
-  console.log('  bun install');
-  console.log('  bun run dev');
-  console.log();
-}
-
-async function copyDirectory(src: string, dest: string, exclude: string[] = []) {
-  await fs.mkdir(dest, { recursive: true });
-  
-  const entries = await fs.readdir(src, { withFileTypes: true });
-  
-  for (const entry of entries) {
-    if (exclude.includes(entry.name)) continue;
-    
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-    
-    if (entry.isDirectory()) {
-      await copyDirectory(srcPath, destPath, exclude);
-    } else {
-      const content = await fs.readFile(srcPath, 'utf-8');
-      await fs.writeFile(destPath, content, 'utf-8');
-    }
-  }
-}
-
-async function processTemplateFiles(
-  projectPath: string, 
-  replacements: Record<string, string>
-) {
-  const files = await getAllFiles(projectPath);
-  
-  for (const file of files) {
-    // Skip binary files
-    if (isBinaryFile(file)) continue;
-    
-    let content = await fs.readFile(file, 'utf-8');
-    
-    // Replace placeholders
-    for (const [key, value] of Object.entries(replacements)) {
-      const regex = new RegExp(`{{${key}}}`, 'g');
-      content = content.replace(regex, value);
-    }
-    
-    await fs.writeFile(file, content, 'utf-8');
-  }
-}
-
-async function getAllFiles(dirPath: string): Promise<string[]> {
-  const files: string[] = [];
-  
-  const items = await fs.readdir(dirPath, { withFileTypes: true });
-  
-  for (const item of items) {
-    const fullPath = path.join(dirPath, item.name);
-    
-    if (item.isDirectory()) {
-      files.push(...await getAllFiles(fullPath));
-    } else {
-      files.push(fullPath);
-    }
-  }
-  
-  return files;
-}
-
-function isBinaryFile(filePath: string): boolean {
-  const binaryExtensions = [
-    '.png', '.jpg', '.jpeg', '.gif', '.ico', '.svg',
-    '.woff', '.woff2', '.ttf', '.eot',
-    '.zip', '.tar', '.gz', '.rar'
-  ];
-  
-  const ext = path.extname(filePath).toLowerCase();
-  return binaryExtensions.includes(ext);
-}
-
-function toCamelCase(str: string): string {
-  return str
-    .replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : '')
-    .replace(/^[A-Z]/, char => char.toLowerCase());
-}
-
-function toPascalCase(str: string): string {
-  const camelCase = toCamelCase(str);
-  return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
-}
-
-// Run the script
-const projectName = process.argv[2] || 'test-todo-app';
-const template = (process.argv[3] as 'basic' | 'minimal' | 'full') || 'basic';
-
-createTestApp({
-  name: projectName,
-  template
-}).catch(error => {
-  console.error('❌ Error creating project:', error);
-  process.exit(1);
-});

package/docker-compose.microservices.yml

@@ -1,75 +0,0 @@
-version: '3.8'
-
-services:
-  # Frontend-Only Service
-  frontend:
-    build:
-      context: .
-      dockerfile: Dockerfile.frontend
-    ports:
-      - "8080:80"
-    environment:
-      - API_URL=http://backend:3001
-    depends_on:
-      - backend
-    networks:
-      - fluxstack-network
-    restart: unless-stopped
-
-  # Backend-Only Service
-  backend:
-    build:
-      context: .
-      dockerfile: Dockerfile.backend
-    ports:
-      - "3001:3001"
-    environment:
-      - NODE_ENV=production
-      - BACKEND_PORT=3001
-      - DATABASE_URL=postgresql://fluxstack:password@postgres:5432/fluxstack
-      - CORS_ORIGINS=http://frontend:80,http://localhost:3000
-    depends_on:
-      postgres:
-        condition: service_healthy
-    networks:
-      - fluxstack-network
-    restart: unless-stopped
-
-  # Database
-  postgres:
-    image: postgres:15-alpine
-    environment:
-      - POSTGRES_DB=fluxstack
-      - POSTGRES_USER=fluxstack
-      - POSTGRES_PASSWORD=password
-    volumes:
-      - postgres_data:/var/lib/postgresql/data
-    networks:
-      - fluxstack-network
-    restart: unless-stopped
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U fluxstack -d fluxstack"]
-      interval: 10s
-      timeout: 5s
-      retries: 5
-
-  # Load Balancer (opcional)
-  nginx-lb:
-    image: nginx:alpine
-    ports:
-      - "0.0.0.0:3000:80"
-    volumes:
-      - ./nginx-lb.conf:/etc/nginx/conf.d/default.conf
-    depends_on:
-      - frontend
-      - backend
-    networks:
-      - fluxstack-network
-    restart: unless-stopped
-
-volumes:
-  postgres_data:
-
-networks:
-  fluxstack-network:
-    driver: bridge