create-fluxstack 1.0.2 → 1.0.3

package/meu-app-teste/core/types/build.ts

@@ -0,0 +1,174 @@
+/**
+ * Build system types
+ * Type definitions for build processes, bundling, and optimization
+ */
+
+export type BuildTarget = 'bun' | 'node' | 'docker' | 'static'
+export type BuildMode = 'development' | 'production' | 'test'
+export type BundleFormat = 'esm' | 'cjs' | 'iife' | 'umd'
+
+export interface BuildOptions {
+  target: BuildTarget
+  mode: BuildMode
+  outDir: string
+  sourceMaps: boolean
+  minify: boolean
+  treeshake: boolean
+  splitting: boolean
+  watch: boolean
+  clean: boolean
+}
+
+export interface BuildResult {
+  success: boolean
+  duration: number
+  outputFiles: BuildOutputFile[]
+  warnings: BuildWarning[]
+  errors: BuildError[]
+  stats: BuildStats
+}
+
+export interface BuildOutputFile {
+  path: string
+  size: number
+  type: 'js' | 'css' | 'html' | 'asset'
+  hash?: string
+  sourcemap?: string
+}
+
+export interface BuildWarning {
+  message: string
+  file?: string
+  line?: number
+  column?: number
+  code?: string
+}
+
+export interface BuildError {
+  message: string
+  file?: string
+  line?: number
+  column?: number
+  code?: string
+  stack?: string
+}
+
+export interface BuildStats {
+  totalSize: number
+  gzippedSize: number
+  chunkCount: number
+  assetCount: number
+  entryPoints: string[]
+  dependencies: string[]
+}
+
+export interface BundleOptions {
+  entry: string | string[]
+  format: BundleFormat
+  external?: string[]
+  globals?: Record<string, string>
+  banner?: string
+  footer?: string
+}
+
+export interface BundleResult {
+  code: string
+  map?: string
+  imports: string[]
+  exports: string[]
+  warnings: BuildWarning[]
+}
+
+export interface OptimizationOptions {
+  minify: boolean
+  treeshake: boolean
+  deadCodeElimination: boolean
+  constantFolding: boolean
+  inlining: boolean
+  compression: boolean
+}
+
+export interface OptimizationResult {
+  originalSize: number
+  optimizedSize: number
+  compressionRatio: number
+  optimizations: string[]
+  warnings: BuildWarning[]
+}
+
+export interface BuildManifest {
+  version: string
+  timestamp: string
+  target: BuildTarget
+  mode: BuildMode
+  client: ClientBuildManifest
+  server: ServerBuildManifest
+  assets: AssetManifest[]
+  optimization: OptimizationManifest
+  metrics: BuildMetrics
+}
+
+export interface ClientBuildManifest {
+  entryPoints: string[]
+  chunks: ChunkManifest[]
+  assets: AssetManifest[]
+  publicPath: string
+}
+
+export interface ServerBuildManifest {
+  entryPoint: string
+  dependencies: string[]
+  externals: string[]
+}
+
+export interface ChunkManifest {
+  name: string
+  file: string
+  size: number
+  hash: string
+  imports: string[]
+  dynamicImports: string[]
+}
+
+export interface AssetManifest {
+  name: string
+  file: string
+  size: number
+  hash: string
+  type: string
+}
+
+export interface OptimizationManifest {
+  minified: boolean
+  treeshaken: boolean
+  compressed: boolean
+  originalSize: number
+  optimizedSize: number
+  compressionRatio: number
+}
+
+export interface BuildMetrics {
+  buildTime: number
+  bundleTime: number
+  optimizationTime: number
+  totalSize: number
+  gzippedSize: number
+  chunkCount: number
+  assetCount: number
+}
+
+export interface BuildCache {
+  enabled: boolean
+  directory: string
+  strategy: 'filesystem' | 'memory' | 'hybrid'
+  maxSize: number
+  ttl: number
+}
+
+export interface BuildWatcher {
+  enabled: boolean
+  ignored: string[]
+  polling: boolean
+  interval: number
+  debounce: number
+}

package/meu-app-teste/core/types/config.ts

@@ -0,0 +1,68 @@
+/**
+ * Configuration-related types
+ * Centralized type definitions for all configuration interfaces
+ */
+
+// Re-export all configuration types from schema
+export type {
+  FluxStackConfig,
+  AppConfig,
+  ServerConfig,
+  ClientConfig,
+  BuildConfig,
+  LoggingConfig,
+  MonitoringConfig,
+  PluginConfig,
+  DatabaseConfig,
+  AuthConfig,
+  EmailConfig,
+  StorageConfig,
+  LogLevel,
+  BuildTarget,
+  LogFormat,
+  CorsConfig,
+  MiddlewareConfig,
+  ProxyConfig,
+  ClientBuildConfig,
+  OptimizationConfig,
+  LogTransportConfig,
+  MetricsConfig,
+  ProfilingConfig
+} from "../config/schema"
+
+// Re-export configuration loading types
+export type {
+  // EnvironmentInfo,
+  ConfigLoadOptions,
+  ConfigLoadResult,
+  ValidationResult,
+  ValidationError as ConfigValidationError,
+  ValidationWarning
+} from "../config/loader"
+
+// Additional configuration utility types
+export interface ConfigOverride {
+  path: string
+  value: any
+  source: 'env' | 'file' | 'runtime'
+}
+
+export interface ConfigMergeOptions {
+  deep?: boolean
+  arrays?: 'replace' | 'merge' | 'concat'
+  overrideArrays?: boolean
+}
+
+export interface ConfigValidationOptions {
+  strict?: boolean
+  allowUnknown?: boolean
+  stripUnknown?: boolean
+  warnings?: boolean
+}
+
+export interface ConfigSource {
+  type: 'file' | 'env' | 'default' | 'override'
+  path?: string
+  priority: number
+  data: any
+}

package/meu-app-teste/core/types/index.ts

@@ -0,0 +1,127 @@
+// Re-export all configuration types
+export * from "./config"
+
+// Ensure critical types are explicitly exported
+export type { 
+  FluxStackConfig,
+  AppConfig,
+  ServerConfig,
+  ClientConfig,
+  BuildConfig,
+  LoggingConfig,
+  MonitoringConfig,
+  PluginConfig
+} from "../config/schema"
+
+// Re-export plugin types (explicitly handling conflicts)
+export type {
+  Plugin,
+  PluginContext,
+  PluginUtils,
+  PluginManifest,
+  PluginLoadResult,
+  PluginDiscoveryOptions,
+  // PluginHooks,
+  // PluginConfig as PluginConfigOptions,
+  PluginHook,
+  PluginPriority,
+  RequestContext,
+  ResponseContext,
+  ErrorContext
+} from "./plugin"
+
+// Re-export additional plugin types from core plugins
+export type {
+  Plugin as CorePlugin,
+  PluginContext as CorePluginContext,
+  PluginUtils as CorePluginUtils,
+  RequestContext as CoreRequestContext,
+  ResponseContext as CoreResponseContext,
+  ErrorContext as CoreErrorContext
+} from "../plugins/types"
+
+// Re-export API types
+export type {
+  HttpMethod,
+  ApiEndpoint,
+  ApiSchema,
+  ApiResponse,
+  ApiError,
+  ApiMeta,
+  PaginationMeta,
+  TimingMeta
+} from "./api"
+
+// Re-export build types (explicitly handle BuildTarget conflict)
+export type {
+  BuildTarget,
+  BuildMode,
+  BundleFormat,
+  BuildOptions,
+  BuildResult,
+  BuildOutputFile,
+  BuildWarning,
+  BuildError,
+  BuildStats
+} from "./build"
+
+// Re-export framework types
+export type {
+  FluxStackFrameworkOptions,
+  FrameworkContext,
+  FrameworkStats,
+  FrameworkHooks,
+  RouteDefinition,
+  MiddlewareDefinition,
+  ServiceDefinition
+} from "../framework/types"
+
+// Re-export utility types
+export type {
+  Logger
+} from "../utils/logger/index"
+
+export type {
+  FluxStackError,
+  ValidationError,
+  NotFoundError,
+  UnauthorizedError,
+  ForbiddenError,
+  ConflictError,
+  InternalServerError,
+  ServiceUnavailableError
+} from "../utils/errors"
+
+export type {
+  Metric,
+  Counter,
+  Gauge,
+  Histogram,
+  SystemMetrics,
+  HttpMetrics
+} from "../utils/monitoring"
+
+// Legacy configuration interface for backward compatibility
+export interface LegacyFluxStackConfig {
+  port?: number
+  vitePort?: number
+  clientPath?: string
+  apiPrefix?: string
+  cors?: {
+    origins?: string[]
+    methods?: string[]
+    headers?: string[]
+  }
+  build?: {
+    outDir?: string
+    target?: string
+  }
+}
+
+export interface FluxStackContext {
+  config: any // Use any to avoid circular dependency
+  isDevelopment: boolean
+  isProduction: boolean
+  isTest: boolean
+  environment: string
+}

package/meu-app-teste/core/types/plugin.ts

@@ -0,0 +1,94 @@
+/**
+ * Plugin system types
+ * Comprehensive type definitions for the plugin system
+ */
+
+// Re-export plugin types
+export type {
+  Plugin,
+  PluginContext,
+  PluginUtils,
+  RequestContext,
+  ResponseContext,
+  ErrorContext
+} from "../plugins/types"
+
+// Additional plugin-related types
+export interface PluginManifest {
+  name: string
+  version: string
+  description: string
+  author: string
+  license: string
+  homepage?: string
+  repository?: string
+  keywords: string[]
+  dependencies: Record<string, string>
+  peerDependencies?: Record<string, string>
+  fluxstack: {
+    version: string
+    hooks: string[]
+    config?: any
+  }
+}
+
+export interface PluginLoadResult {
+  success: boolean
+  plugin?: Plugin
+  error?: string
+  warnings?: string[]
+}
+
+export interface PluginRegistryState {
+  plugins: Map<string, Plugin>
+  loadOrder: string[]
+  dependencies: Map<string, string[]>
+  conflicts: string[]
+}
+
+export interface PluginHookResult {
+  success: boolean
+  error?: Error
+  duration: number
+  plugin: string
+  hook: string
+}
+
+export interface PluginMetrics {
+  loadTime: number
+  setupTime: number
+  hookExecutions: Map<string, number>
+  errors: number
+  warnings: number
+}
+
+export type PluginHook = 
+  | 'setup'
+  | 'onServerStart'
+  | 'onServerStop'
+  | 'onRequest'
+  | 'onResponse'
+  | 'onError'
+
+export type PluginPriority = 'highest' | 'high' | 'normal' | 'low' | 'lowest' | number
+
+export interface PluginConfigSchema {
+  type: 'object'
+  properties: Record<string, any>
+  required?: string[]
+  additionalProperties?: boolean
+}
+
+export interface PluginDiscoveryOptions {
+  directories?: string[]
+  patterns?: string[]
+  includeBuiltIn?: boolean
+  includeExternal?: boolean
+}
+
+export interface PluginInstallOptions {
+  version?: string
+  registry?: string
+  force?: boolean
+  dev?: boolean
+}

package/meu-app-teste/core/utils/__tests__/errors.test.ts

@@ -0,0 +1,139 @@
+/**
+ * Tests for Error Handling System
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  FluxStackError,
+  ValidationError,
+  NotFoundError,
+  UnauthorizedError,
+  ForbiddenError,
+  ConflictError,
+  InternalServerError,
+  ServiceUnavailableError
+} from '../errors'
+
+describe('Error Classes', () => {
+  describe('FluxStackError', () => {
+    it('should create error with all properties', () => {
+      const context = { field: 'email', value: 'invalid' }
+      const error = new FluxStackError('Test error', 'TEST_ERROR', 400, context)
+
+      expect(error.message).toBe('Test error')
+      expect(error.code).toBe('TEST_ERROR')
+      expect(error.statusCode).toBe(400)
+      expect(error.context).toBe(context)
+      expect(error.timestamp).toBeInstanceOf(Date)
+      expect(error.name).toBe('FluxStackError')
+    })
+
+    it('should default to status code 500', () => {
+      const error = new FluxStackError('Test error', 'TEST_ERROR')
+      expect(error.statusCode).toBe(500)
+    })
+
+    it('should serialize to JSON correctly', () => {
+      const error = new FluxStackError('Test error', 'TEST_ERROR', 400, { test: true })
+      const json = error.toJSON()
+
+      expect(json.name).toBe('FluxStackError')
+      expect(json.message).toBe('Test error')
+      expect(json.code).toBe('TEST_ERROR')
+      expect(json.statusCode).toBe(400)
+      expect(json.context).toEqual({ test: true })
+      expect(json.timestamp).toBeInstanceOf(Date)
+      expect(json.stack).toBeDefined()
+    })
+  })
+
+  describe('ValidationError', () => {
+    it('should create validation error with correct defaults', () => {
+      const error = new ValidationError('Invalid input')
+
+      expect(error.message).toBe('Invalid input')
+      expect(error.code).toBe('VALIDATION_ERROR')
+      expect(error.statusCode).toBe(400)
+      expect(error.name).toBe('ValidationError')
+    })
+
+    it('should include context', () => {
+      const context = { field: 'email', rule: 'required' }
+      const error = new ValidationError('Email is required', context)
+
+      expect(error.context).toBe(context)
+    })
+  })
+
+  describe('NotFoundError', () => {
+    it('should create not found error', () => {
+      const error = new NotFoundError('User')
+
+      expect(error.message).toBe('User not found')
+      expect(error.code).toBe('NOT_FOUND')
+      expect(error.statusCode).toBe(404)
+      expect(error.name).toBe('NotFoundError')
+    })
+  })
+
+  describe('UnauthorizedError', () => {
+    it('should create unauthorized error with default message', () => {
+      const error = new UnauthorizedError()
+
+      expect(error.message).toBe('Unauthorized')
+      expect(error.code).toBe('UNAUTHORIZED')
+      expect(error.statusCode).toBe(401)
+      expect(error.name).toBe('UnauthorizedError')
+    })
+
+    it('should create unauthorized error with custom message', () => {
+      const error = new UnauthorizedError('Invalid token')
+
+      expect(error.message).toBe('Invalid token')
+    })
+  })
+
+  describe('ForbiddenError', () => {
+    it('should create forbidden error', () => {
+      const error = new ForbiddenError('Access denied')
+
+      expect(error.message).toBe('Access denied')
+      expect(error.code).toBe('FORBIDDEN')
+      expect(error.statusCode).toBe(403)
+      expect(error.name).toBe('ForbiddenError')
+    })
+  })
+
+  describe('ConflictError', () => {
+    it('should create conflict error', () => {
+      const error = new ConflictError('Resource already exists')
+
+      expect(error.message).toBe('Resource already exists')
+      expect(error.code).toBe('CONFLICT')
+      expect(error.statusCode).toBe(409)
+      expect(error.name).toBe('ConflictError')
+    })
+  })
+
+  describe('InternalServerError', () => {
+    it('should create internal server error with default message', () => {
+      const error = new InternalServerError()
+
+      expect(error.message).toBe('Internal server error')
+      expect(error.code).toBe('INTERNAL_SERVER_ERROR')
+      expect(error.statusCode).toBe(500)
+      expect(error.name).toBe('InternalServerError')
+    })
+  })
+
+  describe('ServiceUnavailableError', () => {
+    it('should create service unavailable error', () => {
+      const error = new ServiceUnavailableError('Database is down')
+
+      expect(error.message).toBe('Database is down')
+      expect(error.code).toBe('SERVICE_UNAVAILABLE')
+      expect(error.statusCode).toBe(503)
+      expect(error.name).toBe('ServiceUnavailableError')
+    })
+  })
+})