create-fluxstack 1.8.1 → 1.8.3

package/core/framework/server.ts

@@ -1,14 +1,14 @@
 import { Elysia } from "elysia"
-import type { FluxStackConfig, FluxStackContext } from "../types"
-import type { FluxStack, PluginContext, PluginUtils } from "../plugins/types"
-import { PluginRegistry } from "../plugins/registry"
-import { PluginManager } from "../plugins/manager"
-import { getConfigSync, getEnvironmentInfo } from "../config"
-import { logger } from "../utils/logger"
-import { displayStartupBanner, type StartupInfo } from "../utils/logger/startup-banner"
-import { createErrorHandler } from "../utils/errors/handlers"
-import { createTimer, formatBytes, isProduction, isDevelopment } from "../utils/helpers"
-import type { Plugin } from "../plugins"
+import type { FluxStackConfig, FluxStackContext } from "@/core/types"
+import type { FluxStack, PluginContext, PluginUtils } from "@/core/plugins/types"
+import { PluginRegistry } from "@/core/plugins/registry"
+import { PluginManager } from "@/core/plugins/manager"
+import { getConfigSync, getEnvironmentInfo } from "@/core/config"
+import { logger } from "@/core/utils/logger"
+import { displayStartupBanner, type StartupInfo } from "@/core/utils/logger/startup-banner"
+import { createErrorHandler } from "@/core/utils/errors/handlers"
+import { createTimer, formatBytes, isProduction, isDevelopment } from "@/core/utils/helpers"
+import type { Plugin } from "@/core/plugins"
 
 export class FluxStackFramework {
   private app: Elysia
@@ -19,6 +19,21 @@ export class FluxStackFramework {
   private isStarted: boolean = false
   private requestTimings: Map<string, number> = new Map()
 
+  /**
+   * Helper to safely parse request.url which might be relative or absolute
+   */
+  private parseRequestURL(request: Request): URL {
+    try {
+      // Try parsing as absolute URL first
+      return new URL(request.url)
+    } catch {
+      // If relative, use host from headers or default to localhost
+      const host = request.headers.get('host') || 'localhost'
+      const protocol = request.headers.get('x-forwarded-proto') || 'http'
+      return new URL(request.url, `${protocol}://${host}`)
+    }
+  }
+
   constructor(config?: Partial<FluxStackConfig>) {
     // Load the full configuration
     const fullConfig = config ? { ...getConfigSync(), ...config } : getConfigSync()
@@ -160,7 +175,7 @@ export class FluxStackFramework {
   private setupHeadHandler() {
     // Global HEAD handler to prevent Elysia's automatic HEAD conversion bug
     this.app.head("*", ({ request, set }) => {
-      const url = new URL(request.url)
+      const url = this.parseRequestURL(request)
 
       // Handle API routes
       if (url.pathname.startsWith(this.context.config.server.apiPrefix)) {
@@ -234,7 +249,7 @@ export class FluxStackFramework {
     // Setup onRequest hook and onBeforeRoute hook
     this.app.onRequest(async ({ request, set }) => {
       const startTime = Date.now()
-      const url = new URL(request.url)
+      const url = this.parseRequestURL(request)
 
       // Store start time for duration calculation (using request URL as key)
       const requestKey = `${request.method}-${url.pathname}-${startTime}`
@@ -275,7 +290,7 @@ export class FluxStackFramework {
 
     // Setup onResponse hook
     this.app.onAfterHandle(async ({ request, response, set }) => {
-      const url = new URL(request.url)
+      const url = this.parseRequestURL(request)
 
       // Retrieve start time using the timing key
       const requestKey = set.headers['x-request-timing-key']
@@ -329,7 +344,7 @@ export class FluxStackFramework {
 
     this.app.onError(async ({ error, request, path, set }) => {
       const startTime = Date.now()
-      const url = new URL(request.url)
+      const url = this.parseRequestURL(request)
 
       const errorContext = {
         request,
@@ -448,7 +463,7 @@ export class FluxStackFramework {
 
   private async handleViteProxy(errorContext: any): Promise<Response> {
     const vitePort = this.context.config.client?.port || 5173
-    const url = new URL(errorContext.request.url)
+    const url = this.parseRequestURL(errorContext.request)
 
     try {
       const viteUrl = `http://localhost:${vitePort}${url.pathname}${url.search}`

package/core/framework/types.ts

@@ -3,8 +3,8 @@
  * Defines the main interfaces and types for the FluxStack framework
  */
 
-import type { FluxStackConfig } from "../types"
-import type { Logger } from "../utils/logger/index"
+import type { FluxStackConfig } from "@/core/types"
+import type { Logger } from "@/core/utils/logger/index"
 
 export interface FluxStackFrameworkOptions {
   config?: Partial<FluxStackConfig>

package/core/live/ComponentRegistry.ts

@@ -6,7 +6,7 @@ import type {
   BroadcastMessage, 
   ComponentDefinition,
   WebSocketData 
-} from '../types/types'
+} from '@/core/types/types'
 
 export class ComponentRegistry {
   private components = new Map<string, LiveComponent>()

package/core/plugins/built-in/live-components/commands/create-live-component.ts

@@ -1,4 +1,4 @@
-import type { CliCommand } from "../../../types";
+import type { CliCommand } from "@/core/plugins/types";
 import { promises as fs } from "fs";
 import path from "path";
 

package/core/plugins/built-in/live-components/index.ts

@@ -1,4 +1,4 @@
-import type { FluxStack, PluginContext } from '../../types'
+import type { FluxStack, PluginContext } from '@/core/plugins/types'
 import { createLiveComponentCommand } from './commands/create-live-component'
 
 type Plugin = FluxStack.Plugin

package/core/plugins/built-in/monitoring/index.ts

@@ -3,8 +3,10 @@
  * Provides performance monitoring, metrics collection, and system monitoring
  */
 
-import type { FluxStack, PluginContext, RequestContext, ResponseContext, ErrorContext } from "../../types"
-import { MetricsCollector } from "../../../utils/monitoring"
+import type { FluxStack, PluginContext, RequestContext, ResponseContext, ErrorContext } from "@/core/plugins/types"
+import { MetricsCollector } from "@/core/utils/monitoring"
+import { appConfig } from '@/config/app.config'
+import { monitoringConfig } from '@/config/monitoring.config'
 import * as os from 'os'
 import * as fs from 'fs'
 import * as path from 'path'
@@ -63,6 +65,36 @@ export interface AlertThreshold {
 
 type Plugin = FluxStack.Plugin
 
+// Default configuration values (uses monitoringConfig from /config)
+const DEFAULTS = {
+  enabled: monitoringConfig.monitoring.enabled,
+  httpMetrics: monitoringConfig.metrics.httpMetrics,
+  systemMetrics: monitoringConfig.metrics.systemMetrics,
+  customMetrics: monitoringConfig.metrics.customMetrics,
+  collectInterval: monitoringConfig.metrics.collectInterval,
+  retentionPeriod: monitoringConfig.metrics.retentionPeriod,
+  exporters: [
+    {
+      type: "console" as "console" | "prometheus" | "json" | "file",
+      interval: 30000,
+      enabled: monitoringConfig.metrics.exportToConsole
+    },
+    {
+      type: "prometheus" as "console" | "prometheus" | "json" | "file",
+      endpoint: "/metrics",
+      enabled: true,
+      format: "text" as const
+    }
+  ] as MetricsExporter[],
+  thresholds: {
+    responseTime: 1000, // ms
+    errorRate: 0.05, // 5%
+    memoryUsage: 0.8, // 80%
+    cpuUsage: 0.8 // 80%
+  },
+  alerts: [] as AlertThreshold[]
+}
+
 export const monitoringPlugin: Plugin = {
   name: "monitoring",
   version: "1.0.0",
@@ -71,137 +103,20 @@ export const monitoringPlugin: Plugin = {
   priority: 900, // Should run early to capture all metrics
   category: "monitoring",
   tags: ["monitoring", "metrics", "performance", "observability"],
-  dependencies: [], // No dependencies
-  
-  configSchema: {
-    type: "object",
-    properties: {
-      enabled: {
-        type: "boolean",
-        description: "Enable monitoring plugin"
-      },
-      httpMetrics: {
-        type: "boolean",
-        description: "Collect HTTP request/response metrics"
-      },
-      systemMetrics: {
-        type: "boolean",
-        description: "Collect system metrics (memory, CPU, etc.)"
-      },
-      customMetrics: {
-        type: "boolean",
-        description: "Enable custom metrics collection"
-      },
-      collectInterval: {
-        type: "number",
-        minimum: 1000,
-        description: "Interval for collecting system metrics (ms)"
-      },
-      retentionPeriod: {
-        type: "number",
-        minimum: 60000,
-        description: "How long to retain metrics in memory (ms)"
-      },
-      exporters: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            type: {
-              type: "string",
-              enum: ["prometheus", "json", "console", "file"]
-            },
-            endpoint: { type: "string" },
-            interval: { type: "number" },
-            enabled: { type: "boolean" },
-            format: { 
-              type: "string",
-              enum: ["text", "json"]
-            },
-            filePath: { type: "string" }
-          },
-          required: ["type"]
-        },
-        description: "Metrics exporters configuration"
-      },
-      thresholds: {
-        type: "object",
-        properties: {
-          responseTime: { type: "number" },
-          errorRate: { type: "number" },
-          memoryUsage: { type: "number" },
-          cpuUsage: { type: "number" }
-        },
-        description: "Alert thresholds"
-      },
-      alerts: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            metric: { type: "string" },
-            operator: { 
-              type: "string",
-              enum: [">", "<", ">=", "<=", "==", "!="]
-            },
-            value: { type: "number" },
-            severity: {
-              type: "string",
-              enum: ["info", "warning", "error", "critical"]
-            },
-            message: { type: "string" }
-          },
-          required: ["metric", "operator", "value", "severity"]
-        },
-        description: "Custom alert configurations"
-      }
-    },
-    additionalProperties: false
-  },
-  
-  defaultConfig: {
-    enabled: true,
-    httpMetrics: true,
-    systemMetrics: true,
-    customMetrics: true,
-    collectInterval: 5000,
-    retentionPeriod: 300000, // 5 minutes
-    exporters: [
-      {
-        type: "console",
-        interval: 30000,
-        enabled: false
-      },
-      {
-        type: "prometheus",
-        endpoint: "/metrics",
-        enabled: true,
-        format: "text"
-      }
-    ],
-    thresholds: {
-      responseTime: 1000, // ms
-      errorRate: 0.05, // 5%
-      memoryUsage: 0.8, // 80%
-      cpuUsage: 0.8 // 80%
-    },
-    alerts: []
-  },
+  dependencies: [],
 
   setup: async (context: PluginContext) => {
-    const config = getPluginConfig(context)
-    
-    if (!config.enabled) {
+    if (!DEFAULTS.enabled) {
       context.logger.info('Monitoring plugin disabled by configuration')
       return
     }
 
     context.logger.info('Initializing monitoring plugin', {
-      httpMetrics: config.httpMetrics,
-      systemMetrics: config.systemMetrics,
-      customMetrics: config.customMetrics,
-      exporters: config.exporters.length,
-      alerts: config.alerts.length
+      httpMetrics: DEFAULTS.httpMetrics,
+      systemMetrics: DEFAULTS.systemMetrics,
+      customMetrics: DEFAULTS.customMetrics,
+      exporters: DEFAULTS.exporters.length,
+      alerts: DEFAULTS.alerts.length
     })
 
     // Initialize enhanced metrics registry
@@ -219,36 +134,34 @@ export const monitoringPlugin: Plugin = {
     ;(context as any).metricsCollector = metricsCollector
 
     // Initialize HTTP metrics
-    if (config.httpMetrics) {
+    if (DEFAULTS.httpMetrics) {
       initializeHttpMetrics(metricsRegistry, metricsCollector)
     }
 
     // Start system metrics collection
-    if (config.systemMetrics) {
-      startSystemMetricsCollection(context, config, metricsCollector)
+    if (DEFAULTS.systemMetrics) {
+      startSystemMetricsCollection(context, metricsCollector)
     }
 
     // Setup metrics endpoint for Prometheus
-    setupMetricsEndpoint(context, config, metricsRegistry, metricsCollector)
+    setupMetricsEndpoint(context, metricsRegistry, metricsCollector)
 
     // Start metrics exporters
-    startMetricsExporters(context, config, metricsRegistry, metricsCollector)
+    startMetricsExporters(context, metricsRegistry, metricsCollector)
 
     // Setup metrics cleanup
-    setupMetricsCleanup(context, config, metricsRegistry)
+    setupMetricsCleanup(context, metricsRegistry)
 
     // Setup alert monitoring
-    if (config.alerts.length > 0) {
-      setupAlertMonitoring(context, config, metricsRegistry)
+    if (DEFAULTS.alerts.length > 0) {
+      setupAlertMonitoring(context, metricsRegistry)
     }
 
     context.logger.info('Monitoring plugin initialized successfully')
   },
 
   onServerStart: async (context: PluginContext) => {
-    const config = getPluginConfig(context)
-    
-    if (config.enabled) {
+    if (DEFAULTS.enabled) {
       context.logger.info('Monitoring plugin: Server monitoring started', {
         pid: process.pid,
         nodeVersion: process.version,
@@ -258,17 +171,15 @@ export const monitoringPlugin: Plugin = {
       // Record server start metric
       const metricsRegistry = (context as any).metricsRegistry as MetricsRegistry
       if (metricsRegistry) {
-        recordCounter(metricsRegistry, 'server_starts_total', 1, { 
-          version: context.config.app.version 
+        recordCounter(metricsRegistry, 'server_starts_total', 1, {
+          version: appConfig.version
         })
       }
     }
   },
 
   onServerStop: async (context: PluginContext) => {
-    const config = getPluginConfig(context)
-    
-    if (config.enabled) {
+    if (DEFAULTS.enabled) {
       context.logger.info('Monitoring plugin: Server monitoring stopped')
 
       // Record server stop metric
@@ -358,14 +269,13 @@ export const monitoringPlugin: Plugin = {
     )
 
     // Check thresholds and log warnings
-    const config = getPluginConfig(responseContext)
-    if (config.thresholds.responseTime && duration > config.thresholds.responseTime) {
+    if (DEFAULTS.thresholds.responseTime && duration > DEFAULTS.thresholds.responseTime) {
       const logger = (responseContext as any).logger || console
       logger.warn(`Slow request detected: ${responseContext.method} ${responseContext.path} took ${duration}ms`, {
         method: responseContext.method,
         path: responseContext.path,
         duration,
-        threshold: config.thresholds.responseTime
+        threshold: DEFAULTS.thresholds.responseTime
       })
     }
   },
@@ -410,12 +320,6 @@ export const monitoringPlugin: Plugin = {
 
 // Helper functions
 
-function getPluginConfig(context: any) {
-  // In a real implementation, this would get the config from the plugin context
-  const pluginConfig = context.config?.plugins?.config?.monitoring || {}
-  return { ...monitoringPlugin.defaultConfig, ...pluginConfig }
-}
-
 function getMetricsRegistry(context: any): MetricsRegistry | null {
   // In a real implementation, this would get the registry from the plugin context
   return (context as any).metricsRegistry || null
@@ -444,7 +348,7 @@ function initializeHttpMetrics(registry: MetricsRegistry, collector: MetricsColl
   collector.createHistogram('http_response_size_bytes', 'HTTP response size in bytes', [100, 1000, 10000, 100000, 1000000])
 }
 
-function startSystemMetricsCollection(context: PluginContext, config: any, collector: MetricsCollector) {
+function startSystemMetricsCollection(context: PluginContext, collector: MetricsCollector) {
   const intervals: NodeJS.Timeout[] = []
 
   // Initialize system metrics in collector
@@ -518,16 +422,16 @@ function startSystemMetricsCollection(context: PluginContext, config: any, colle
 
   // Collect metrics immediately and then at intervals
   collectSystemMetrics()
-  const interval = setInterval(collectSystemMetrics, config.collectInterval)
+  const interval = setInterval(collectSystemMetrics, DEFAULTS.collectInterval)
   intervals.push(interval)
 
   // Store intervals for cleanup
   ;(context as any).monitoringIntervals = intervals
 }
 
-function setupMetricsEndpoint(context: PluginContext, config: any, _registry: MetricsRegistry, collector: MetricsCollector) {
+function setupMetricsEndpoint(context: PluginContext, _registry: MetricsRegistry, collector: MetricsCollector) {
   // Find Prometheus exporter configuration
-  const prometheusExporter = config.exporters.find((e: any) => e.type === 'prometheus' && e.enabled)
+  const prometheusExporter = DEFAULTS.exporters.find((e: any) => e.type === 'prometheus' && e.enabled)
   if (!prometheusExporter) return
 
   const endpoint = prometheusExporter.endpoint || '/metrics'
@@ -547,10 +451,10 @@ function setupMetricsEndpoint(context: PluginContext, config: any, _registry: Me
   }
 }
 
-function startMetricsExporters(context: PluginContext, config: any, registry: MetricsRegistry, collector: MetricsCollector) {
+function startMetricsExporters(context: PluginContext, registry: MetricsRegistry, collector: MetricsCollector) {
   const intervals: NodeJS.Timeout[] = (context as any).monitoringIntervals || []
 
-  for (const exporterConfig of config.exporters) {
+  for (const exporterConfig of DEFAULTS.exporters) {
     if (!exporterConfig.enabled) continue
 
     const exportMetrics = () => {
@@ -588,11 +492,11 @@ function startMetricsExporters(context: PluginContext, config: any, registry: Me
   ;(context as any).monitoringIntervals = intervals
 }
 
-function setupAlertMonitoring(context: PluginContext, config: any, registry: MetricsRegistry) {
+function setupAlertMonitoring(context: PluginContext, registry: MetricsRegistry) {
   const intervals: NodeJS.Timeout[] = (context as any).monitoringIntervals || []
 
   const checkAlerts = () => {
-    for (const alert of config.alerts) {
+    for (const alert of DEFAULTS.alerts) {
       try {
         const metricValue = getMetricValue(registry, alert.metric)
         if (metricValue !== null && evaluateThreshold(metricValue, alert.operator, alert.value)) {
@@ -640,12 +544,12 @@ function setupAlertMonitoring(context: PluginContext, config: any, registry: Met
   ;(context as any).monitoringIntervals = intervals
 }
 
-function setupMetricsCleanup(context: PluginContext, config: any, registry: MetricsRegistry) {
+function setupMetricsCleanup(context: PluginContext, registry: MetricsRegistry) {
   const intervals: NodeJS.Timeout[] = (context as any).monitoringIntervals || []
 
   const cleanup = () => {
     const now = Date.now()
-    const cutoff = now - config.retentionPeriod
+    const cutoff = now - DEFAULTS.retentionPeriod
 
     // Clean up old metrics
     for (const [key, metric] of registry.counters.entries()) {

package/core/plugins/built-in/static/index.ts

@@ -1,6 +1,13 @@
 import { join } from "path"
 import { statSync, existsSync } from "fs"
-import type { Plugin, PluginContext } from "../.."
+import type { Plugin, PluginContext } from "@/core/plugins"
+
+// Default configuration values
+const DEFAULTS = {
+  enabled: true,
+  publicDir: "./dist/client",
+  indexFile: "index.html"
+}
 
 export const staticPlugin: Plugin = {
   name: "static",
@@ -12,41 +19,14 @@ export const staticPlugin: Plugin = {
   tags: ["static", "files", "spa"],
   dependencies: [],
 
-  configSchema: {
-    type: "object",
-    properties: {
-      enabled: {
-        type: "boolean",
-        description: "Enable static file serving"
-      },
-      publicDir: {
-        type: "string",
-        description: "Directory for static files"
-      },
-      indexFile: {
-        type: "string",
-        description: "Index file for SPA routing"
-      }
-    },
-    additionalProperties: false
-  },
-
-  defaultConfig: {
-    enabled: true,
-    publicDir: "./dist/client",
-    indexFile: "index.html"
-  },
-
   setup: async (context: PluginContext) => {
-    const config = getPluginConfig(context)
-
-    if (!config.enabled) {
+    if (!DEFAULTS.enabled) {
       context.logger.info('Static files plugin disabled')
       return
     }
 
     context.logger.info("Static files plugin activated", {
-      publicDir: config.publicDir
+      publicDir: DEFAULTS.publicDir
     })
 
     // Static fallback handler (runs last)
@@ -61,9 +41,9 @@ export const staticPlugin: Plugin = {
       const isDev = context.utils.isDevelopment()
       let baseDir: string
 
-      if (isDev && existsSync(config.publicDir)) {
+      if (isDev && existsSync(DEFAULTS.publicDir)) {
         // Development: use public directory
-        baseDir = config.publicDir
+        baseDir = DEFAULTS.publicDir
       } else {
         // Production: try paths in order of preference
         if (existsSync('client')) {
@@ -74,13 +54,13 @@ export const staticPlugin: Plugin = {
           baseDir = 'dist/client'
         } else {
           // Fallback to configured path
-          baseDir = config.publicDir
+          baseDir = DEFAULTS.publicDir
         }
       }
 
       // Root or empty path → index.html
       if (pathname === '/' || pathname === '') {
-        pathname = `/${config.indexFile}`
+        pathname = `/${DEFAULTS.indexFile}`
       }
 
       const filePath = join(baseDir, pathname)
@@ -97,7 +77,7 @@ export const staticPlugin: Plugin = {
       }
 
       // SPA fallback: serve index.html for non-file routes
-      const indexPath = join(baseDir, config.indexFile)
+      const indexPath = join(baseDir, DEFAULTS.indexFile)
       try {
         statSync(indexPath) // Ensure index exists
         return new Response(Bun.file(indexPath))
@@ -111,22 +91,13 @@ export const staticPlugin: Plugin = {
   },
 
   onServerStart: async (context: PluginContext) => {
-    const config = getPluginConfig(context)
-
-    if (config.enabled) {
+    if (DEFAULTS.enabled) {
       context.logger.info(`Static files plugin ready`, {
-        publicDir: config.publicDir,
-        indexFile: config.indexFile
+        publicDir: DEFAULTS.publicDir,
+        indexFile: DEFAULTS.indexFile
       })
     }
   }
 }
 
-// Helper function to get plugin config
-function getPluginConfig(context: PluginContext) {
-  const pluginConfig = context.config.plugins.config?.static || {}
-  return { ...staticPlugin.defaultConfig, ...pluginConfig }
-}
-
-
 export default staticPlugin