create-fluxstack 1.8.1 → 1.9.1

package/app/server/routes/users.routes.ts

@@ -1,114 +1,215 @@
-import { Elysia, t } from "elysia"
-import { UsersController } from "../controllers/users.controller"
-
-export const usersRoutes = new Elysia({ prefix: "/users" })
-  .get("/", () => UsersController.getUsers(), {
-    response: t.Object({
-      users: t.Array(t.Object({
-        id: t.Number(),
-        name: t.String(),
-        email: t.String(),
-        createdAt: t.Date()
-      }))
-    }),
+import { Elysia, t } from 'elysia'
+import { UsersController } from '@/app/server/controllers/users.controller'
+
+// ===== Request/Response Schemas =====
+
+const UserSchema = t.Object({
+  id: t.Number(),
+  name: t.String(),
+  email: t.String()
+}, {
+  description: 'User object'
+})
+
+const CreateUserRequestSchema = t.Object({
+  name: t.String({ minLength: 2, description: 'User name (minimum 2 characters)' }),
+  email: t.String({ format: 'email', description: 'Valid email address' })
+}, {
+  description: 'Request body for creating a new user'
+})
+
+const CreateUserResponseSchema = t.Union([
+  t.Object({
+    success: t.Literal(true),
+    user: UserSchema,
+    message: t.Optional(t.String())
+  }),
+  t.Object({
+    success: t.Literal(false),
+    error: t.String()
+  })
+], {
+  description: 'Response after attempting to create a user'
+})
+
+const GetUsersResponseSchema = t.Object({
+  success: t.Boolean(),
+  users: t.Array(UserSchema),
+  count: t.Number()
+}, {
+  description: 'List of all users'
+})
+
+const GetUserResponseSchema = t.Union([
+  t.Object({
+    success: t.Literal(true),
+    user: UserSchema
+  }),
+  t.Object({
+    success: t.Literal(false),
+    error: t.String()
+  })
+], {
+  description: 'Single user or error'
+})
+
+const DeleteUserResponseSchema = t.Union([
+  t.Object({
+    success: t.Literal(true),
+    message: t.String()
+  }),
+  t.Object({
+    success: t.Literal(false),
+    message: t.String()
+  })
+], {
+  description: 'Result of delete operation'
+})
+
+const ErrorResponseSchema = t.Object({
+  error: t.String()
+}, {
+  description: 'Error response'
+})
+
+/**
+ * Users API Routes
+ */
+export const usersRoutes = new Elysia({ prefix: '/users', tags: ['Users'] })
+  // GET /users - Get all users
+  .get('/', async () => {
+    return await UsersController.getUsers()
+  }, {
     detail: {
-      tags: ['Users'],
-      summary: 'List Users',
-      description: 'Retrieve a list of all users in the system'
-    }
+      summary: 'Get All Users',
+      description: 'Retrieves a list of all registered users',
+      tags: ['Users', 'CRUD']
+    },
+    response: GetUsersResponseSchema
   })
-  
-  .get("/:id", async ({ params: { id }, set }) => {
-    const userId = parseInt(id)
-    const result = await UsersController.getUserById(userId)
-    
+
+  // GET /users/:id - Get user by ID
+  .get('/:id', async ({ params, set }) => {
+    const id = parseInt(params.id)
+
+    // Handle invalid ID
+    if (isNaN(id)) {
+      set.status = 400
+      return { error: 'ID inválido' }
+    }
+
+    const result = await UsersController.getUserById(id)
+
     if (!result) {
       set.status = 404
-      return { error: "Usuário não encontrado" }
+      return { error: 'Usuário não encontrado' }
     }
-    
+
     return result
   }, {
-    params: t.Object({
-      id: t.String()
-    }),
     detail: {
-      tags: ['Users'],
       summary: 'Get User by ID',
-      description: 'Retrieve a specific user by their ID'
+      description: 'Retrieves a single user by their unique identifier',
+      tags: ['Users', 'CRUD']
+    },
+    params: t.Object({
+      id: t.String({ description: 'User ID' })
+    }),
+    response: {
+      200: GetUserResponseSchema,
+      400: ErrorResponseSchema,
+      404: ErrorResponseSchema
     }
   })
-  
-  .post("/", async ({ body, set }) => {
-    try {
-      return await UsersController.createUser(body as any)
-    } catch (error) {
+
+  // POST /users - Create new user
+  .post('/', async ({ body, set }) => {
+    // Validate required fields
+    if (!body.name || !body.email) {
+      set.status = 400
+      return {
+        success: false,
+        error: 'Nome e email são obrigatórios'
+      }
+    }
+
+    // Validate name length
+    if (body.name.length < 2) {
+      set.status = 400
+      return {
+        success: false,
+        error: 'Nome deve ter pelo menos 2 caracteres'
+      }
+    }
+
+    // Validate email format
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+    if (!emailRegex.test(body.email)) {
       set.status = 400
-      return { 
-        success: false, 
-        error: "Dados inválidos", 
-        details: error instanceof Error ? error.message : 'Unknown error'
+      return {
+        success: false,
+        error: 'Email inválido'
       }
     }
+
+    const result = await UsersController.createUser(body)
+
+    // If email is duplicate, still return 200 but with success: false
+    if (!result.success) {
+      return result
+    }
+
+    return result
   }, {
-    body: t.Object({
-      name: t.String({ minLength: 2 }),
-      email: t.String({ format: "email" })
-    }),
-    response: t.Object({
-      success: t.Boolean(),
-      user: t.Optional(t.Object({
-        id: t.Number(),
-        name: t.String(),
-        email: t.String(),
-        createdAt: t.Date()
-      })),
-      message: t.Optional(t.String())
-    }),
     detail: {
-      tags: ['Users'],
-      summary: 'Create User',
-      description: 'Create a new user with name and email'
+      summary: 'Create New User',
+      description: 'Creates a new user with name and email. Email must be unique.',
+      tags: ['Users', 'CRUD']
     },
-    error({ code, error, set }) {
-      switch (code) {
-        case 'VALIDATION':
-          set.status = 400
-          return {
-            success: false,
-            error: "Dados inválidos",
-            details: error.message
-          }
-        default:
-          set.status = 500
-          return {
-            success: false,
-            error: "Erro interno do servidor"
-          }
-      }
+    body: CreateUserRequestSchema,
+    response: {
+      200: CreateUserResponseSchema,
+      400: t.Object({
+        success: t.Literal(false),
+        error: t.String()
+      })
     }
   })
-  
-  .delete("/:id", ({ params: { id } }) => {
-    const userId = parseInt(id)
-    return UsersController.deleteUser(userId)
+
+  // DELETE /users/:id - Delete user
+  .delete('/:id', async ({ params, set }) => {
+    const id = parseInt(params.id)
+
+    if (isNaN(id)) {
+      set.status = 400
+      return {
+        success: false,
+        message: 'ID inválido'
+      }
+    }
+
+    const result = await UsersController.deleteUser(id)
+
+    if (!result.success) {
+      // Don't set 404 status, just return success: false
+      return result
+    }
+
+    return result
   }, {
-    params: t.Object({
-      id: t.String()
-    }),
-    response: t.Object({
-      success: t.Boolean(),
-      user: t.Optional(t.Object({
-        id: t.Number(),
-        name: t.String(),
-        email: t.String(),
-        createdAt: t.Date()
-      })),
-      message: t.Optional(t.String())
-    }),
     detail: {
-      tags: ['Users'],
       summary: 'Delete User',
-      description: 'Delete a user by their ID'
+      description: 'Deletes a user by their ID',
+      tags: ['Users', 'CRUD']
+    },
+    params: t.Object({
+      id: t.String({ description: 'User ID to delete' })
+    }),
+    response: {
+      200: DeleteUserResponseSchema,
+      400: t.Object({
+        success: t.Literal(false),
+        message: t.String()
+      })
     }
-  })
+  })

package/config/fluxstack.config.ts

@@ -4,8 +4,8 @@
  * @deprecated Use the configuration from the root fluxstack.config.ts instead
  */
 
-import { getConfigSync, createLegacyConfig } from '../core/config'
-import type { FluxStackConfig } from '../core/config'
+import { getConfigSync, createLegacyConfig } from '@/core/config'
+import type { FluxStackConfig } from '@/core/config'
 
 // Load the new configuration
 const newConfig = getConfigSync()

package/config/plugins.config.ts

@@ -28,7 +28,8 @@ const pluginsConfigSchema = {
   // Logger plugin (handled by logger.config.ts)
   loggerEnabled: config.boolean('LOGGER_PLUGIN_ENABLED', true),
 
-  // Swagger plugin (enable/disable via runtime.config.ts)
+  // Swagger plugin
+  swaggerEnabled: config.boolean('SWAGGER_ENABLED', true),
   swaggerTitle: config.string('SWAGGER_TITLE', 'FluxStack API'),
   swaggerVersion: config.string('SWAGGER_VERSION', FLUXSTACK_VERSION),
   swaggerDescription: config.string(
@@ -37,6 +38,26 @@ const pluginsConfigSchema = {
   ),
   swaggerPath: config.string('SWAGGER_PATH', '/swagger'),
 
+  // Swagger advanced options
+  swaggerExcludePaths: config.array('SWAGGER_EXCLUDE_PATHS', []),
+
+  // Swagger servers (comma-separated list of URLs)
+  // Format: "url1|description1,url2|description2"
+  // Example: "https://api.prod.com|Production,https://api.staging.com|Staging"
+  swaggerServers: config.string('SWAGGER_SERVERS', ''),
+
+  // Swagger UI options
+  swaggerPersistAuthorization: config.boolean('SWAGGER_PERSIST_AUTH', true),
+  swaggerDisplayRequestDuration: config.boolean('SWAGGER_DISPLAY_DURATION', true),
+  swaggerEnableFilter: config.boolean('SWAGGER_ENABLE_FILTER', true),
+  swaggerShowExtensions: config.boolean('SWAGGER_SHOW_EXTENSIONS', true),
+  swaggerTryItOutEnabled: config.boolean('SWAGGER_TRY_IT_OUT', true),
+
+  // Swagger authentication (Basic Auth)
+  swaggerAuthEnabled: config.boolean('SWAGGER_AUTH_ENABLED', false),
+  swaggerAuthUsername: config.string('SWAGGER_AUTH_USERNAME', 'admin'),
+  swaggerAuthPassword: config.string('SWAGGER_AUTH_PASSWORD', ''),
+
   // Static files plugin
   staticFilesEnabled: config.boolean('STATIC_FILES_ENABLED', true),
   staticPublicDir: config.string('STATIC_PUBLIC_DIR', 'public'),

package/core/build/bundler.ts

@@ -79,34 +79,18 @@ export class Bundler {
     let liveComponentsGenerator: any = null
 
     try {
-      // 🚀 PRE-BUILD: Auto-generate Live Components registration
-      const generatorModule = await import('./live-components-generator')
-      liveComponentsGenerator = generatorModule.liveComponentsGenerator
-      const discoveredComponents = await liveComponentsGenerator.preBuild()
-
-      // 🔌 PRE-BUILD: Auto-generate FluxStack Plugins registration
-      const pluginsGeneratorModule = await import('./flux-plugins-generator')
-      const fluxPluginsGenerator = pluginsGeneratorModule.fluxPluginsGenerator
-      const discoveredPlugins = await fluxPluginsGenerator.preBuild()
-      
+      // Run pre-build steps
+      liveComponentsGenerator = await this.runPreBuildSteps()
+
       // Ensure output directory exists
-      if (!existsSync(this.config.outDir)) {
-        mkdirSync(this.config.outDir, { recursive: true })
-      }
+      this.ensureOutputDirectory()
 
-      const external = [
-        "@tailwindcss/vite",
-        "tailwindcss", 
-        "lightningcss",
-        "vite",
-        "@vitejs/plugin-react",
-        ...(this.config.external || []),
-        ...(options.external || [])
-      ]
+      // Get external dependencies
+      const external = this.getExternalDependencies(options)
 
       const buildArgs = [
-        "bun", "build", 
-        entryPoint, 
+        "bun", "build",
+        entryPoint,
         "--outdir", this.config.outDir,
         "--target", this.config.target,
         ...external.flatMap(ext => ["--external", ext])
@@ -132,20 +116,12 @@ export class Bundler {
       const exitCode = await buildProcess.exited
       const duration = Date.now() - startTime
 
-      // 🧹 POST-BUILD: Handle auto-generated registration file
-      // (liveComponentsGenerator already available from above)
-
       if (exitCode === 0) {
         buildLogger.success(`Server bundle completed in ${buildLogger.formatDuration(duration)}`)
-        
-        // Keep generated files for production (they're now baked into bundle)
-        await liveComponentsGenerator.postBuild(false)
-        
-        // Cleanup plugins registry
-        const pluginsGeneratorModule = await import('./flux-plugins-generator')
-        const fluxPluginsGenerator = pluginsGeneratorModule.fluxPluginsGenerator
-        await fluxPluginsGenerator.postBuild(false)
-        
+
+        // Run post-build cleanup
+        await this.runPostBuildCleanup(liveComponentsGenerator)
+
         return {
           success: true,
           duration,
@@ -154,15 +130,10 @@ export class Bundler {
         }
       } else {
         buildLogger.error("Server bundle failed")
-        
-        // Restore original files since build failed
-        await liveComponentsGenerator.postBuild(false)
-        
-        // Restore plugins registry
-        const pluginsGeneratorModule = await import('./flux-plugins-generator')
-        const fluxPluginsGenerator = pluginsGeneratorModule.fluxPluginsGenerator
-        await fluxPluginsGenerator.postBuild(false)
-        
+
+        // Run post-build cleanup
+        await this.runPostBuildCleanup(liveComponentsGenerator)
+
         const stderr = await new Response(buildProcess.stderr).text()
         return {
           success: false,
@@ -172,21 +143,139 @@ export class Bundler {
       }
     } catch (error) {
       const duration = Date.now() - startTime
-      
+
+      // 🧹 CLEANUP: Restore original files on error
+      try {
+        await this.runPostBuildCleanup(liveComponentsGenerator)
+      } catch (cleanupError) {
+        buildLogger.warn(`Failed to cleanup generated files: ${cleanupError}`)
+      }
+
+      return {
+        success: false,
+        duration,
+        error: error instanceof Error ? error.message : "Unknown error"
+      }
+    }
+  }
+
+  async compileToExecutable(entryPoint: string, outputName: string = "app", options: BundleOptions = {}): Promise<BundleResult> {
+    buildLogger.section('Executable Build', '📦')
+
+    const startTime = Date.now()
+    let liveComponentsGenerator: any = null
+
+    try {
+      // Run pre-build steps
+      liveComponentsGenerator = await this.runPreBuildSteps()
+
+      // Ensure output directory exists
+      this.ensureOutputDirectory()
+
+      const outputPath = join(this.config.outDir, outputName)
+
+      // Get external dependencies
+      const external = this.getExternalDependencies(options)
+
+      const buildArgs = [
+        "bun", "build",
+        entryPoint,
+        "--compile",
+        "--outfile", outputPath,
+        "--target", this.config.target,
+        ...external.flatMap(ext => ["--external", ext])
+      ]
+
+      if (this.config.sourceMaps) {
+        buildArgs.push("--sourcemap")
+      }
+
+      if (this.config.minify) {
+        buildArgs.push("--minify")
+      }
+
+      // Add Windows-specific options if provided
+      if (options.executable?.windows) {
+        const winOpts = options.executable.windows
+        if (winOpts.hideConsole) {
+          buildArgs.push("--windows-hide-console")
+        }
+        if (winOpts.icon) {
+          buildArgs.push("--windows-icon", winOpts.icon)
+        }
+        if (winOpts.title) {
+          buildArgs.push("--windows-title", winOpts.title)
+        }
+        if (winOpts.publisher) {
+          buildArgs.push("--windows-publisher", winOpts.publisher)
+        }
+        if (winOpts.version) {
+          buildArgs.push("--windows-version", winOpts.version)
+        }
+        if (winOpts.description) {
+          buildArgs.push("--windows-description", winOpts.description)
+        }
+        if (winOpts.copyright) {
+          buildArgs.push("--windows-copyright", winOpts.copyright)
+        }
+      }
+
+      // Add custom build arguments if provided
+      if (options.executable?.customArgs) {
+        buildArgs.push(...options.executable.customArgs)
+      }
+
+      buildLogger.step(`Compiling ${entryPoint} to ${outputPath}...`)
+
+      const buildProcess = spawn({
+        cmd: buildArgs,
+        stdout: "pipe",
+        stderr: "pipe",
+        env: {
+          ...process.env,
+          NODE_ENV: 'production',
+          ...options.env
+        }
+      })
+
+      const exitCode = await buildProcess.exited
+      const duration = Date.now() - startTime
+
+      if (exitCode === 0) {
+        buildLogger.success(`Executable compiled in ${buildLogger.formatDuration(duration)}`)
+
+        // Run post-build cleanup
+        await this.runPostBuildCleanup(liveComponentsGenerator)
+
+        return {
+          success: true,
+          duration,
+          outputPath,
+          entryPoint: outputPath
+        }
+      } else {
+        buildLogger.error("Executable compilation failed")
+
+        // Run post-build cleanup
+        await this.runPostBuildCleanup(liveComponentsGenerator)
+
+        const stderr = await new Response(buildProcess.stderr).text()
+        return {
+          success: false,
+          duration,
+          error: stderr || "Executable compilation failed"
+        }
+      }
+    } catch (error) {
+      const duration = Date.now() - startTime
+
       // 🧹 CLEANUP: Restore original files on error
       try {
-        if (liveComponentsGenerator) {
-          await liveComponentsGenerator.postBuild(false)
-        }
-        
-        // Cleanup plugins registry
-        const pluginsGeneratorModule = await import('./flux-plugins-generator')
-        const fluxPluginsGenerator = pluginsGeneratorModule.fluxPluginsGenerator
-        await fluxPluginsGenerator.postBuild(false)
+        await this.runPostBuildCleanup(liveComponentsGenerator)
       } catch (cleanupError) {
         buildLogger.warn(`Failed to cleanup generated files: ${cleanupError}`)
       }
-      
+
       return {
         success: false,
         duration,
@@ -195,6 +284,61 @@ export class Bundler {
     }
   }
 
+  /**
+   * Get list of external dependencies that should not be bundled
+   */
+  private getExternalDependencies(options: BundleOptions = {}): string[] {
+    return [
+      "@tailwindcss/vite",
+      "tailwindcss",
+      "lightningcss",
+      "vite",
+      "@vitejs/plugin-react",
+      "rollup",
+      ...(this.config.external || []),
+      ...(options.external || [])
+    ]
+  }
+
+  /**
+   * Ensure output directory exists
+   */
+  private ensureOutputDirectory(): void {
+    if (!existsSync(this.config.outDir)) {
+      mkdirSync(this.config.outDir, { recursive: true })
+    }
+  }
+
+  /**
+   * Run pre-build steps (Live Components and Plugins generation)
+   */
+  private async runPreBuildSteps(): Promise<any> {
+    // 🚀 PRE-BUILD: Auto-generate Live Components registration
+    const generatorModule = await import('./live-components-generator')
+    const liveComponentsGenerator = generatorModule.liveComponentsGenerator
+    await liveComponentsGenerator.preBuild()
+
+    // 🔌 PRE-BUILD: Auto-generate FluxStack Plugins registration
+    const pluginsGeneratorModule = await import('./flux-plugins-generator')
+    const fluxPluginsGenerator = pluginsGeneratorModule.fluxPluginsGenerator
+    await fluxPluginsGenerator.preBuild()
+
+    return liveComponentsGenerator
+  }
+
+  /**
+   * Run post-build cleanup
+   */
+  private async runPostBuildCleanup(liveComponentsGenerator: any): Promise<void> {
+    if (liveComponentsGenerator) {
+      await liveComponentsGenerator.postBuild(false)
+    }
+
+    const pluginsGeneratorModule = await import('./flux-plugins-generator')
+    const fluxPluginsGenerator = pluginsGeneratorModule.fluxPluginsGenerator
+    await fluxPluginsGenerator.postBuild(false)
+  }
+
   private async getClientAssets(): Promise<string[]> {
     // This would analyze the build output to get asset information
     // For now, return empty array - can be enhanced later

package/core/build/flux-plugins-generator.ts

@@ -95,12 +95,12 @@ export class FluxPluginsGenerator {
   private findPluginEntryFile(pluginDir: string): string | null {
     const possibleFiles = [
       'index.ts',
-      'index.js',
+      'index',
       'plugin.ts',
-      'plugin.js',
+      'plugin',
       'src/index.ts',
-      'src/index.js',
-      'dist/index.js'
+      'src/index',
+      'dist/index'
     ]
 
     for (const file of possibleFiles) {
@@ -130,7 +130,7 @@ export class FluxPluginsGenerator {
     const imports = plugins
       .map(plugin => {
         const importName = this.getImportName(plugin.pluginName)
-        const importPath = plugin.entryFile === 'index.ts' || plugin.entryFile === 'index.js'
+        const importPath = plugin.entryFile === 'index.ts' || plugin.entryFile === 'index'
           ? plugin.relativePath
           : `${plugin.relativePath}/${plugin.entryFile.replace(/\.(ts|js)$/, '')}`
         return `import ${importName} from "${importPath}"`

package/core/build/index.ts

@@ -47,6 +47,10 @@ export class FluxStackBuilder {
     return await this.bundler.bundleServer("app/server/index.ts")
   }
 
+  async buildExecutable(outputName: string = "CLauncher", options?: import("../types/build").BundleOptions) {
+    return await this.bundler.compileToExecutable("app/server/index.ts", outputName, options)
+  }
+
   async createDockerFiles() {
     buildLogger.section('Docker Configuration', '🐳')