create-fluxstack 1.0.13 → 1.0.14

package/app/server/middleware/validation.ts

@@ -0,0 +1,270 @@
+/**
+ * Validation Middleware
+ * Provides request validation using schemas
+ */
+
+import type { Context } from 'elysia'
+
+export interface ValidationSchema {
+  body?: Record<string, any>
+  query?: Record<string, any>
+  params?: Record<string, any>
+}
+
+export interface ValidationError {
+  field: string
+  message: string
+  value?: any
+}
+
+/**
+ * Create validation middleware for a specific schema
+ */
+export const validationMiddleware = (schema: ValidationSchema) => ({
+  name: 'validation',
+  
+  beforeHandle: async (context: Context) => {
+    const errors: ValidationError[] = []
+
+    // Validate body
+    if (schema.body && context.body) {
+      const bodyErrors = validateObject(context.body, schema.body, 'body')
+      errors.push(...bodyErrors)
+    }
+
+    // Validate query parameters
+    if (schema.query && context.query) {
+      const queryErrors = validateObject(context.query, schema.query, 'query')
+      errors.push(...queryErrors)
+    }
+
+    // Validate path parameters
+    if (schema.params && context.params) {
+      const paramErrors = validateObject(context.params, schema.params, 'params')
+      errors.push(...paramErrors)
+    }
+
+    if (errors.length > 0) {
+      return new Response(
+        JSON.stringify({
+          error: 'Validation failed',
+          details: errors
+        }),
+        { 
+          status: 400, 
+          headers: { 'Content-Type': 'application/json' } 
+        }
+      )
+    }
+  }
+})
+
+/**
+ * Validate an object against a schema
+ */
+function validateObject(
+  obj: any, 
+  schema: Record<string, any>, 
+  prefix: string
+): ValidationError[] {
+  const errors: ValidationError[] = []
+
+  for (const [field, rules] of Object.entries(schema)) {
+    const value = obj[field]
+    const fieldPath = `${prefix}.${field}`
+
+    // Check required fields
+    if (rules.required && (value === undefined || value === null || value === '')) {
+      errors.push({
+        field: fieldPath,
+        message: `${field} is required`,
+        value
+      })
+      continue
+    }
+
+    // Skip validation if field is not required and not present
+    if (!rules.required && (value === undefined || value === null)) {
+      continue
+    }
+
+    // Type validation
+    if (rules.type) {
+      const typeError = validateType(value, rules.type, fieldPath)
+      if (typeError) {
+        errors.push(typeError)
+        continue
+      }
+    }
+
+    // String validations
+    if (rules.type === 'string' && typeof value === 'string') {
+      if (rules.minLength && value.length < rules.minLength) {
+        errors.push({
+          field: fieldPath,
+          message: `${field} must be at least ${rules.minLength} characters`,
+          value
+        })
+      }
+
+      if (rules.maxLength && value.length > rules.maxLength) {
+        errors.push({
+          field: fieldPath,
+          message: `${field} must be no more than ${rules.maxLength} characters`,
+          value
+        })
+      }
+
+      if (rules.pattern && !new RegExp(rules.pattern).test(value)) {
+        errors.push({
+          field: fieldPath,
+          message: `${field} format is invalid`,
+          value
+        })
+      }
+
+      if (rules.email && !isValidEmail(value)) {
+        errors.push({
+          field: fieldPath,
+          message: `${field} must be a valid email address`,
+          value
+        })
+      }
+    }
+
+    // Number validations
+    if (rules.type === 'number' && typeof value === 'number') {
+      if (rules.min !== undefined && value < rules.min) {
+        errors.push({
+          field: fieldPath,
+          message: `${field} must be at least ${rules.min}`,
+          value
+        })
+      }
+
+      if (rules.max !== undefined && value > rules.max) {
+        errors.push({
+          field: fieldPath,
+          message: `${field} must be no more than ${rules.max}`,
+          value
+        })
+      }
+    }
+
+    // Array validations
+    if (rules.type === 'array' && Array.isArray(value)) {
+      if (rules.minItems && value.length < rules.minItems) {
+        errors.push({
+          field: fieldPath,
+          message: `${field} must have at least ${rules.minItems} items`,
+          value
+        })
+      }
+
+      if (rules.maxItems && value.length > rules.maxItems) {
+        errors.push({
+          field: fieldPath,
+          message: `${field} must have no more than ${rules.maxItems} items`,
+          value
+        })
+      }
+    }
+
+    // Enum validation
+    if (rules.enum && !rules.enum.includes(value)) {
+      errors.push({
+        field: fieldPath,
+        message: `${field} must be one of: ${rules.enum.join(', ')}`,
+        value
+      })
+    }
+  }
+
+  return errors
+}
+
+/**
+ * Validate value type
+ */
+function validateType(value: any, expectedType: string, fieldPath: string): ValidationError | null {
+  const actualType = Array.isArray(value) ? 'array' : typeof value
+
+  if (actualType !== expectedType) {
+    return {
+      field: fieldPath,
+      message: `Expected ${expectedType}, got ${actualType}`,
+      value
+    }
+  }
+
+  return null
+}
+
+/**
+ * Validate email format
+ */
+function isValidEmail(email: string): boolean {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+  return emailRegex.test(email)
+}
+
+/**
+ * Common validation schemas
+ */
+export const commonSchemas = {
+  createUser: {
+    body: {
+      name: {
+        type: 'string',
+        required: true,
+        minLength: 2,
+        maxLength: 100
+      },
+      email: {
+        type: 'string',
+        required: true,
+        email: true,
+        maxLength: 255
+      }
+    }
+  },
+
+  updateUser: {
+    params: {
+      id: {
+        type: 'string',
+        required: true,
+        pattern: '^\\d+$'
+      }
+    },
+    body: {
+      name: {
+        type: 'string',
+        required: false,
+        minLength: 2,
+        maxLength: 100
+      },
+      email: {
+        type: 'string',
+        required: false,
+        email: true,
+        maxLength: 255
+      }
+    }
+  },
+
+  pagination: {
+    query: {
+      page: {
+        type: 'string',
+        required: false,
+        pattern: '^\\d+$'
+      },
+      limit: {
+        type: 'string',
+        required: false,
+        pattern: '^\\d+$'
+      }
+    }
+  }
+}

package/app/server/routes/index.ts

@@ -1,8 +1,12 @@
-import { Elysia } from "elysia"
+import { Elysia, t } from "elysia"
 import { usersRoutes } from "./users.routes"
+import { uploadRoutes } from "./upload"
 
 export const apiRoutes = new Elysia({ prefix: "/api" })
   .get("/", () => ({ message: "🔥 Hot Reload funcionando! FluxStack API v1.4.0 ⚡" }), {
+    response: t.Object({
+      message: t.String()
+    }),
     detail: {
       tags: ['Health'],
       summary: 'API Root',
@@ -16,10 +20,18 @@ export const apiRoutes = new Elysia({ prefix: "/api" })
     version: "1.4.0",
     environment: "development"
   }), {
+    response: t.Object({
+      status: t.String(),
+      timestamp: t.String(),
+      uptime: t.String(),
+      version: t.String(),
+      environment: t.String()
+    }),
     detail: {
       tags: ['Health'],
       summary: 'Health Check',
       description: 'Returns the current health status of the API server'
     }
   })
-  .use(usersRoutes)
+  .use(usersRoutes)
+  .use(uploadRoutes)

package/app/server/routes/upload.ts

@@ -0,0 +1,92 @@
+import { Elysia, t } from 'elysia'
+import { writeFile, mkdir } from 'fs/promises'
+import { existsSync } from 'fs'
+import { join, extname } from 'path'
+
+export const uploadRoutes = new Elysia({ prefix: '/upload' })
+  .post('/avatar', async ({ body }: { body: { file: File } }) => {
+    try {
+      const { file } = body
+      
+      if (!file) {
+        throw new Error('No file provided')
+      }
+
+      // Validate file type
+      const allowedTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/webp', 'image/gif']
+      if (!allowedTypes.includes(file.type)) {
+        throw new Error('Invalid file type. Only JPEG, PNG, WebP and GIF are allowed.')
+      }
+
+      // Validate file size (5MB max)
+      const maxSize = 5 * 1024 * 1024 // 5MB
+      if (file.size > maxSize) {
+        throw new Error('File too large. Maximum size is 5MB.')
+      }
+
+      // Create uploads directory if it doesn't exist
+      const uploadsDir = join(process.cwd(), 'uploads', 'avatars')
+      if (!existsSync(uploadsDir)) {
+        await mkdir(uploadsDir, { recursive: true })
+      }
+
+      // Generate unique filename
+      const timestamp = Date.now()
+      const randomId = Math.random().toString(36).substring(2, 8)
+      const extension = extname(file.name) || '.jpg'
+      const filename = `avatar-${timestamp}-${randomId}${extension}`
+      const filepath = join(uploadsDir, filename)
+
+      // Convert file to buffer and save
+      const buffer = await file.arrayBuffer()
+      await writeFile(filepath, new Uint8Array(buffer))
+
+      // Return the URL path for the uploaded file
+      const imageUrl = `/uploads/avatars/${filename}`
+      
+      console.log('📸 Avatar uploaded successfully:', {
+        filename,
+        size: file.size,
+        type: file.type,
+        url: imageUrl
+      })
+
+      return {
+        success: true,
+        message: 'Avatar uploaded successfully',
+        imageUrl,
+        filename,
+        size: file.size,
+        type: file.type
+      }
+
+    } catch (error: any) {
+      console.error('❌ Avatar upload failed:', error.message)
+      
+      return {
+        success: false,
+        error: error.message || 'Upload failed',
+        imageUrl: null
+      }
+    }
+  }, {
+    body: t.Object({
+      file: t.File({
+        type: ['image/jpeg', 'image/jpg', 'image/png', 'image/webp', 'image/gif'],
+        maxSize: 5 * 1024 * 1024 // 5MB
+      })
+    }),
+    response: {
+      200: t.Object({
+        success: t.Boolean(),
+        message: t.Optional(t.String()),
+        error: t.Optional(t.String()),
+        imageUrl: t.Union([t.String(), t.Null()]),
+        filename: t.Optional(t.String()),
+        size: t.Optional(t.Number()),
+        type: t.Optional(t.String())
+      })
+    }
+  })
+
+  // Note: File serving is now handled by the static-files plugin at /uploads/*

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

@@ -18,11 +18,12 @@ export const usersRoutes = new Elysia({ prefix: "/users" })
     }
   })
   
-  .get("/:id", async ({ params: { id } }) => {
+  .get("/:id", async ({ params: { id }, set }) => {
     const userId = parseInt(id)
     const result = await UsersController.getUserById(userId)
     
     if (!result) {
+      set.status = 404
       return { error: "Usuário não encontrado" }
     }
     
@@ -31,14 +32,6 @@ export const usersRoutes = new Elysia({ prefix: "/users" })
     params: t.Object({
       id: t.String()
     }),
-    response: t.Object({
-      user: t.Object({
-        id: t.Number(),
-        name: t.String(),
-        email: t.String(),
-        createdAt: t.Date()
-      })
-    }),
     detail: {
       tags: ['Users'],
       summary: 'Get User by ID',