create-fluxstack 1.8.1 → 1.8.3

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/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/live-components-generator.ts

@@ -18,9 +18,12 @@ export class LiveComponentsGenerator {
   private backupFilePath: string
 
   constructor() {
+    // Scan components from app/ directory (user code)
     this.componentsPath = join(process.cwd(), 'app', 'server', 'live')
-    this.registrationFilePath = join(process.cwd(), 'app', 'server', 'live', 'register-components.ts')
-    this.backupFilePath = join(process.cwd(), 'app', 'server', 'live', 'register-components.backup.ts')
+
+    // Generate registration file in core/ directory (framework code - protected from user modifications)
+    this.registrationFilePath = join(process.cwd(), 'core', 'server', 'live', 'auto-generated-components.ts')
+    this.backupFilePath = join(process.cwd(), 'core', 'server', 'live', 'auto-generated-components.backup.ts')
   }
 
   /**
@@ -64,7 +67,8 @@ export class LiveComponentsGenerator {
                 fileName,
                 className,
                 componentName,
-                filePath: `./${fileName}`
+                // Path relative to core/server/live/ where the generated file will be
+                filePath: `@/app/server/live/${fileName}`
               })
 
               buildLogger.step(`Discovered component: ${className} → ${componentName}`)
@@ -190,18 +194,17 @@ ${components.map(comp => `  ${comp.className}`).join(',\n')}
   }
 
   /**
-   * Post-build hook: Clean up generated file (optional)
+   * Post-build hook: Clean up backup file
+   * Note: Since the generated file is now in core/, we always keep it (it's bundled into production)
    */
-  async postBuild(keepGenerated: boolean = false): Promise<void> {
+  async postBuild(keepGenerated: boolean = true): Promise<void> {
     buildLogger.step('Cleaning up Live Components registration...')
 
-    if (keepGenerated) {
-      // Remove backup since we're keeping the generated version
-      if (existsSync(this.backupFilePath)) {
-        unlinkSync(this.backupFilePath)
-      }
-    } else {
-      this.restoreOriginalFile()
+    // Always keep the generated file in core/ (it gets bundled)
+    // Just remove the backup
+    if (existsSync(this.backupFilePath)) {
+      unlinkSync(this.backupFilePath)
+      buildLogger.step('Removed backup file')
     }
   }
 

package/core/cli/command-registry.ts

@@ -1,6 +1,6 @@
 import type { CliCommand, CliContext, CliArgument, CliOption } from "../plugins/types"
-import { getConfigSync } from "../config"
-import { logger } from "../utils/logger"
+import { getConfigSync } from "@/core/config"
+import { logger } from "@/core/utils/logger"
 import { createTimer, formatBytes, isProduction, isDevelopment } from "../utils/helpers"
 
 export class CliCommandRegistry {
@@ -10,20 +10,10 @@ export class CliCommandRegistry {
 
   constructor() {
     const config = getConfigSync()
-    
+
     this.context = {
       config,
-      logger: {
-        debug: (message: string, meta?: unknown) => logger.debug(message, meta),
-        info: (message: string, meta?: unknown) => logger.info(message, meta),
-        warn: (message: string, meta?: unknown) => logger.warn(message, meta),
-        error: (message: string, meta?: unknown) => logger.error(message, meta),
-        child: (context: Record<string, unknown>) => logger,
-        time: (label: string) => logger.time(label),
-        timeEnd: (label: string) => logger.timeEnd(label),
-        request: (method: string, path: string, status?: number, duration?: number) =>
-          logger.request(method, path, status, duration)
-      },
+      logger: logger as any,
       utils: {
         createTimer,
         formatBytes,

package/core/cli/commands/plugin-deps.ts

@@ -4,8 +4,8 @@
 
 import { Command } from 'commander'
 import chalk from 'chalk'
-import { PluginDependencyManager } from '../../plugins/dependency-manager'
-import { PluginRegistry } from '../../plugins/registry'
+import { PluginDependencyManager } from '@/core/plugins/dependency-manager'
+import { PluginRegistry } from '@/core/plugins/registry'
 import { existsSync, readFileSync } from 'fs'
 import { join } from 'path'
 
@@ -32,11 +32,11 @@ function createInstallCommand(): Command {
         const dependencyManager = new PluginDependencyManager({
           autoInstall: !options.dryRun,
           packageManager: options.packageManager,
-          logger: createConsoleLogger()
+          logger: createConsoleLogger() as any as any
         })
 
         const registry = new PluginRegistry({
-          logger: createConsoleLogger()
+          logger: createConsoleLogger() as any as any
         })
 
         // Descobrir plugins
@@ -104,7 +104,7 @@ function createListCommand(): Command {
 
       try {
         const registry = new PluginRegistry({
-          logger: createConsoleLogger()
+          logger: createConsoleLogger() as any
         })
 
         const results = await registry.discoverPlugins({
@@ -113,7 +113,7 @@ function createListCommand(): Command {
 
         const dependencyManager = new PluginDependencyManager({
           autoInstall: false,
-          logger: createConsoleLogger()
+          logger: createConsoleLogger() as any
         })
 
         for (const result of results) {
@@ -162,7 +162,7 @@ function createCheckCommand(): Command {
 
       try {
         const registry = new PluginRegistry({
-          logger: createConsoleLogger()
+          logger: createConsoleLogger() as any
         })
 
         const results = await registry.discoverPlugins({
@@ -171,7 +171,7 @@ function createCheckCommand(): Command {
 
         const dependencyManager = new PluginDependencyManager({
           autoInstall: false,
-          logger: createConsoleLogger()
+          logger: createConsoleLogger() as any
         })
 
         const resolutions = []

package/core/cli/generators/component.ts

@@ -1,6 +1,6 @@
-import type { Generator } from "./index.js"
-import type { GeneratorContext, GeneratorOptions, Template } from "./types.js"
-import { templateEngine } from "./template-engine.js"
+import type { Generator } from "./index"
+import type { GeneratorContext, GeneratorOptions, Template } from "./types"
+import { templateEngine } from "./template-engine"
 
 export class ComponentGenerator implements Generator {
     name = 'component'

package/core/cli/generators/controller.ts

@@ -1,6 +1,6 @@
-import type { Generator } from "./index.js"
-import type { GeneratorContext, GeneratorOptions, Template } from "./types.js"
-import { templateEngine } from "./template-engine.js"
+import type { Generator } from "./index"
+import type { GeneratorContext, GeneratorOptions, Template } from "./types"
+import { templateEngine } from "./template-engine"
 
 export class ControllerGenerator implements Generator {
   name = 'controller'
@@ -55,7 +55,7 @@ export class ControllerGenerator implements Generator {
           content: `import { Elysia, t } from 'elysia'
 import { {{pascalName}}Service } from '../services/{{kebabName}}.service'
 import { {{pascalName}}Schema, Create{{pascalName}}Schema, Update{{pascalName}}Schema } from '../schemas/{{kebabName}}.schema'
-import { NotFoundError, ValidationError } from '../../../core/utils/errors'
+import { NotFoundError, ValidationError } from '@/core/utils/errors'
 
 export class {{pascalName}}Controller {
   private service: {{pascalName}}Service

package/core/cli/generators/index.ts

@@ -1,10 +1,10 @@
-import type { CliCommand } from "../../plugins/types.js"
-import { ControllerGenerator } from "./controller.js"
-import { RouteGenerator } from "./route.js"
-import { ComponentGenerator } from "./component.js"
-import { ServiceGenerator } from "./service.js"
-import { PluginGenerator } from "./plugin.js"
-import type { GeneratorContext, GeneratorOptions } from "./types.js"
+import type { CliCommand } from "../../plugins/types"
+import { ControllerGenerator } from "./controller"
+import { RouteGenerator } from "./route"
+import { ComponentGenerator } from "./component"
+import { ServiceGenerator } from "./service"
+import { PluginGenerator } from "./plugin"
+import type { GeneratorContext, GeneratorOptions } from "./types"
 
 export interface Generator {
   name: string
@@ -47,7 +47,7 @@ export class GeneratorRegistry {
 export const generatorRegistry = new GeneratorRegistry()
 
 // Export additional commands
-export { interactiveGenerateCommand } from "./interactive.js"
+export { interactiveGenerateCommand } from "./interactive"
 
 // CLI command for code generation
 export const generateCommand: CliCommand = {

package/core/cli/generators/interactive.ts

@@ -1,7 +1,7 @@
-import type { CliCommand } from "../../plugins/types.js"
-import { generatorRegistry } from "./index.js"
-import type { GeneratorContext, GeneratorOptions } from "./types.js"
-import { promptSystem } from "./prompts.js"
+import type { CliCommand } from "../../plugins/types"
+import { generatorRegistry } from "./index"
+import type { GeneratorContext, GeneratorOptions } from "./types"
+import { promptSystem } from "./prompts"
 
 export const interactiveGenerateCommand: CliCommand = {
   name: 'generate:interactive',

package/core/cli/generators/plugin.ts

@@ -1,6 +1,6 @@
-import type { Generator } from "./index.js"
-import type { GeneratorContext, GeneratorOptions, Template } from "./types.js"
-import { templateEngine } from "./template-engine.js"
+import type { Generator } from "./index"
+import type { GeneratorContext, GeneratorOptions, Template } from "./types"
+import { templateEngine } from "./template-engine"
 import { join } from "path"
 
 export class PluginGenerator implements Generator {

package/core/cli/generators/prompts.ts

@@ -1,4 +1,4 @@
-import type { PromptConfig } from "./types.js"
+import type { PromptConfig } from "./types"
 
 export class PromptSystem {
   async prompt(config: PromptConfig): Promise<any> {