create-fluxstack 1.0.1 → 1.0.2

package/core/types/build.ts

@@ -1,174 +0,0 @@
-/**
- * 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/core/types/config.ts

@@ -1,68 +0,0 @@
-/**
- * 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/core/types/index.ts

@@ -1,127 +0,0 @@
-// 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/core/types/plugin.ts

@@ -1,94 +0,0 @@
-/**
- * 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/core/utils/__tests__/errors.test.ts

@@ -1,139 +0,0 @@
-/**
- * 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')
-    })
-  })
-})