create-fluxstack 1.1.0 → 1.4.1

package/core/cli/generators/plugin.ts

@@ -0,0 +1,290 @@
+import type { Generator } from "./index.js"
+import type { GeneratorContext, GeneratorOptions, Template } from "./types.js"
+import { templateEngine } from "./template-engine.js"
+import { join } from "path"
+
+export class PluginGenerator implements Generator {
+    name = 'plugin'
+    description = 'Generate a new FluxStack plugin'
+
+    async generate(context: GeneratorContext, options: GeneratorOptions): Promise<void> {
+        const template = this.getTemplate(options.template)
+
+        if (template.hooks?.beforeGenerate) {
+            await template.hooks.beforeGenerate(context, options)
+        }
+
+        const files = await templateEngine.processTemplate(template, context, options)
+
+        if (options.dryRun) {
+            console.log(`\n📋 Would generate plugin '${options.name}':\n`)
+            for (const file of files) {
+                console.log(`${file.action === 'create' ? '📄' : '✏️'} ${file.path}`)
+            }
+            return
+        }
+
+        await templateEngine.generateFiles(files, options.dryRun)
+
+        if (template.hooks?.afterGenerate) {
+            const filePaths = files.map(f => f.path)
+            await template.hooks.afterGenerate(context, options, filePaths)
+        }
+
+        console.log(`\n✅ Generated plugin '${options.name}' with ${files.length} files`)
+        console.log(`\n📦 Next steps:`)
+        console.log(`   1. Edit plugins/${options.name}/plugin.json with your plugin metadata`)
+        console.log(`   2. Implement your plugin logic in plugins/${options.name}/index.ts`)
+        console.log(`   3. Add server-side code in plugins/${options.name}/server/ (optional)`)
+        console.log(`   4. Add client-side code in plugins/${options.name}/client/ (optional)`)
+        console.log(`   5. Run: bun run cli plugin:deps install`)
+    }
+
+    private getTemplate(templateName?: string): Template {
+        switch (templateName) {
+            case 'full':
+                return this.getFullTemplate()
+            case 'server':
+                return this.getServerOnlyTemplate()
+            case 'client':
+                return this.getClientOnlyTemplate()
+            default:
+                return this.getBasicTemplate()
+        }
+    }
+
+    private getBasicTemplate(): Template {
+        return {
+            name: 'basic-plugin',
+            description: 'Basic plugin template with essential files',
+            files: [
+                {
+                    path: 'plugins/{{name}}/plugin.json',
+                    content: `{
+  "name": "{{name}}",
+  "version": "1.0.0",
+  "description": "{{description}}",
+  "author": "Your Name",
+  "type": "fluxstack-plugin",
+  "main": "index.ts",
+  "dependencies": {},
+  "fluxstack": {
+    "minVersion": "1.4.0"
+  },
+  "hooks": {
+    "setup": true,
+    "onServerStart": false,
+    "onRequest": false,
+    "onResponse": false,
+    "onError": false
+  }
+}
+`
+                },
+                {
+                    path: 'plugins/{{name}}/index.ts',
+                    content: `import type { FluxStackPlugin, PluginContext } from '@/core/types/plugin'
+
+/**
+ * {{pascalName}} Plugin
+ * {{description}}
+ */
+export class {{pascalName}}Plugin implements FluxStackPlugin {
+  name = '{{name}}'
+  version = '1.0.0'
+
+  /**
+   * Setup hook - called when plugin is loaded
+   */
+  async setup(context: PluginContext): Promise<void> {
+    console.log(\`[{{name}}] Plugin initialized\`)
+
+    // Add your initialization logic here
+    // Example: Register middleware, setup database connections, etc.
+  }
+
+  /**
+   * Server start hook - called when server starts
+   */
+  async onServerStart?(context: PluginContext): Promise<void> {
+    console.log(\`[{{name}}] Server started\`)
+
+    // Add logic to run when server starts
+  }
+
+  /**
+   * Request hook - called on each request
+   */
+  async onRequest?(context: PluginContext, request: Request): Promise<void> {
+    // Add request processing logic
+  }
+
+  /**
+   * Response hook - called on each response
+   */
+  async onResponse?(context: PluginContext, response: Response): Promise<void> {
+    // Add response processing logic
+  }
+
+  /**
+   * Error hook - called when errors occur
+   */
+  async onError?(context: PluginContext, error: Error): Promise<void> {
+    console.error(\`[{{name}}] Error:\`, error)
+
+    // Add error handling logic
+  }
+}
+
+// Export plugin instance
+export default new {{pascalName}}Plugin()
+`
+                },
+                {
+                    path: 'plugins/{{name}}/README.md',
+                    content: `# {{pascalName}} Plugin
+
+{{description}}
+
+## Installation
+
+This plugin is already in your FluxStack project. To use it:
+
+1. Make sure the plugin is enabled in your configuration
+2. Install any additional dependencies (if needed):
+   \`\`\`bash
+   bun run cli plugin:deps install
+   \`\`\`
+
+## Usage
+
+\`\`\`typescript
+// The plugin is automatically loaded by FluxStack
+// Configure it in your app/server/index.ts if needed
+\`\`\`
+
+## Configuration
+
+Add configuration options here.
+
+## API
+
+Document your plugin's API here.
+
+## Hooks
+
+This plugin uses the following hooks:
+- \`setup\`: Initialize plugin resources
+- \`onServerStart\`: Run when server starts (optional)
+- \`onRequest\`: Process incoming requests (optional)
+- \`onResponse\`: Process outgoing responses (optional)
+- \`onError\`: Handle errors (optional)
+
+## Development
+
+To modify this plugin:
+
+1. Edit \`index.ts\` with your logic
+2. Update \`plugin.json\` with metadata
+3. Test with: \`bun run dev\`
+
+## License
+
+MIT
+`
+                }
+            ]
+        }
+    }
+
+    private getServerOnlyTemplate(): Template {
+        const basic = this.getBasicTemplate()
+        return {
+            ...basic,
+            name: 'server-plugin',
+            description: 'Plugin with server-side code',
+            files: [
+                ...basic.files,
+                {
+                    path: 'plugins/{{name}}/server/index.ts',
+                    content: `/**
+ * Server-side logic for {{pascalName}} plugin
+ */
+
+export class {{pascalName}}Service {
+  async initialize() {
+    console.log(\`[{{name}}] Server service initialized\`)
+  }
+
+  // Add your server-side methods here
+}
+
+export const {{camelName}}Service = new {{pascalName}}Service()
+`
+                }
+            ]
+        }
+    }
+
+    private getClientOnlyTemplate(): Template {
+        const basic = this.getBasicTemplate()
+        return {
+            ...basic,
+            name: 'client-plugin',
+            description: 'Plugin with client-side code',
+            files: [
+                ...basic.files,
+                {
+                    path: 'plugins/{{name}}/client/index.ts',
+                    content: `/**
+ * Client-side logic for {{pascalName}} plugin
+ */
+
+export class {{pascalName}}Client {
+  initialize() {
+    console.log(\`[{{name}}] Client initialized\`)
+  }
+
+  // Add your client-side methods here
+}
+
+export const {{camelName}}Client = new {{pascalName}}Client()
+`
+                }
+            ]
+        }
+    }
+
+    private getFullTemplate(): Template {
+        const basic = this.getBasicTemplate()
+        const server = this.getServerOnlyTemplate()
+        const client = this.getClientOnlyTemplate()
+
+        return {
+            ...basic,
+            name: 'full-plugin',
+            description: 'Complete plugin with server and client code',
+            files: [
+                ...basic.files,
+                ...server.files.slice(basic.files.length), // Add server files
+                ...client.files.slice(basic.files.length), // Add client files
+                {
+                    path: 'plugins/{{name}}/types.ts',
+                    content: `/**
+ * Type definitions for {{pascalName}} plugin
+ */
+
+export interface {{pascalName}}Config {
+  // Add your configuration types here
+  enabled: boolean
+}
+
+export interface {{pascalName}}Options {
+  // Add your options types here
+}
+`
+                }
+            ]
+        }
+    }
+}

package/core/cli/index.ts

@@ -6,6 +6,7 @@ import { getConfigSync } from "../config"
 import { cliRegistry } from "./command-registry"
 import { pluginDiscovery } from "./plugin-discovery"
 import { generateCommand, interactiveGenerateCommand } from "./generators/index.js"
+import { startGroup, endGroup, logBox, logInGroup } from "../utils/logger/group-logger"
 
 const command = process.argv[2]
 const args = process.argv.slice(3)
@@ -134,12 +135,20 @@ Examples:
       }
     ],
     handler: async (args, options, context) => {
-      console.log("⚡ FluxStack Full-Stack Development")
-      console.log(`🌐 Frontend: http://localhost:${options['frontend-port']}`)  
-      console.log(`🚀 Backend: http://localhost:${options.port}`)
-      console.log("🔄 Backend inicia Vite programaticamente - Zero órfãos!")
-      console.log("📦 Starting backend server...")
-      console.log()
+      // Grouped startup messages
+      startGroup({
+        title: 'FluxStack Development Server',
+        icon: '⚡',
+        color: 'cyan'
+      })
+
+      logInGroup(`Frontend: http://localhost:${options['frontend-port']}`, '🌐')
+      logInGroup(`Backend: http://localhost:${options.port}`, '🚀')
+      logInGroup('Backend inicia Vite programaticamente', '🔄')
+      logInGroup('Starting backend server...', '📦')
+
+      endGroup()
+      console.log('') // Separator line
       
       const { spawn } = await import("child_process")
       const devProcess = spawn("bun", ["--watch", "app/server/index.ts"], {
@@ -215,7 +224,7 @@ Examples:
     }
   })
 
-  // Create command  
+  // Create command
   cliRegistry.register({
     name: 'create',
     description: 'Create a new FluxStack project',
@@ -243,7 +252,7 @@ Examples:
     ],
     handler: async (args, options, context) => {
       const [projectName, template] = args
-      
+
       if (!/^[a-zA-Z0-9-_]+$/.test(projectName)) {
         console.error("❌ Project name can only contain letters, numbers, hyphens, and underscores")
         return
@@ -254,7 +263,7 @@ Examples:
           name: projectName,
           template: template as 'basic' | 'full' || 'basic'
         })
-        
+
         await creator.create()
       } catch (error) {
         console.error("❌ Failed to create project:", error instanceof Error ? error.message : String(error))
@@ -262,6 +271,91 @@ Examples:
       }
     }
   })
+
+  // Make:plugin command (shortcut for generate plugin)
+  cliRegistry.register({
+    name: 'make:plugin',
+    description: 'Create a new FluxStack plugin',
+    category: 'Plugins',
+    usage: 'flux make:plugin <name> [options]',
+    aliases: ['create:plugin'],
+    examples: [
+      'flux make:plugin my-plugin              # Create basic plugin',
+      'flux make:plugin my-plugin --template full    # Create full plugin with server/client',
+      'flux make:plugin auth --template server       # Create server-only plugin'
+    ],
+    arguments: [
+      {
+        name: 'name',
+        description: 'Name of the plugin to create',
+        required: true,
+        type: 'string'
+      }
+    ],
+    options: [
+      {
+        name: 'template',
+        short: 't',
+        description: 'Plugin template to use',
+        type: 'string',
+        choices: ['basic', 'full', 'server', 'client'],
+        default: 'basic'
+      },
+      {
+        name: 'description',
+        short: 'd',
+        description: 'Plugin description',
+        type: 'string',
+        default: 'A FluxStack plugin'
+      },
+      {
+        name: 'force',
+        short: 'f',
+        description: 'Overwrite existing plugin',
+        type: 'boolean',
+        default: false
+      }
+    ],
+    handler: async (args, options, context) => {
+      const [name] = args
+
+      if (!/^[a-zA-Z0-9-_]+$/.test(name)) {
+        console.error("❌ Plugin name can only contain letters, numbers, hyphens, and underscores")
+        return
+      }
+
+      // Use the plugin generator
+      const { generatorRegistry } = await import('./generators/index.js')
+      const pluginGenerator = generatorRegistry.get('plugin')
+
+      if (!pluginGenerator) {
+        console.error("❌ Plugin generator not found")
+        return
+      }
+
+      const generatorContext = {
+        workingDir: context.workingDir,
+        config: context.config,
+        logger: context.logger,
+        utils: context.utils
+      }
+
+      const generatorOptions = {
+        name,
+        template: options.template,
+        force: options.force,
+        dryRun: false,
+        description: options.description
+      }
+
+      try {
+        await pluginGenerator.generate(generatorContext, generatorOptions)
+      } catch (error) {
+        console.error("❌ Failed to create plugin:", error instanceof Error ? error.message : String(error))
+        throw error
+      }
+    }
+  })
 }
 
 // Main CLI logic
@@ -293,12 +387,20 @@ async function main() {
 async function handleLegacyCommands() {
   switch (command) {
   case "dev":
-    console.log("⚡ FluxStack Full-Stack Development")
-    console.log("🌐 Frontend: http://localhost:5173")  
-    console.log("🚀 Backend: http://localhost:3000")
-    console.log("🔄 Backend inicia Vite programaticamente - Zero órfãos!")
-    console.log("📦 Starting backend server...")
-    console.log()
+    // Grouped startup messages
+    startGroup({
+      title: 'FluxStack Development Server',
+      icon: '⚡',
+      color: 'cyan'
+    })
+
+    logInGroup('Frontend: http://localhost:5173', '🌐')
+    logInGroup('Backend: http://localhost:3000', '🚀')
+    logInGroup('Backend inicia Vite programaticamente', '🔄')
+    logInGroup('Starting backend server...', '📦')
+
+    endGroup()
+    console.log('') // Separator line
     
     // Start only backend - it will start Vite programmatically
     const { spawn } = await import("child_process")

package/core/config/env.ts

@@ -3,6 +3,7 @@
  * Handles environment variable processing and precedence
  */
 
+import { env, helpers } from '../utils/env'
 import type { FluxStackConfig, LogLevel, BuildTarget, LogFormat } from './schema'
 
 export interface EnvironmentInfo {
@@ -24,8 +25,6 @@ export interface ConfigPrecedence {
  * Get current environment information
  */
 export function getEnvironmentInfo(): EnvironmentInfo {
-  // Import here to avoid circular dependency
-  const { env } = require('../utils/env-runtime-v2')
   const nodeEnv = env.NODE_ENV
 
   return {
@@ -99,117 +98,60 @@ export class EnvironmentProcessor {
     const config: any = {}
 
     // App configuration
-    this.setConfigValue(config, 'app.name',
-      process.env.FLUXSTACK_APP_NAME || process.env.APP_NAME, 'string')
-    this.setConfigValue(config, 'app.version',
-      process.env.FLUXSTACK_APP_VERSION || process.env.APP_VERSION, 'string')
-    this.setConfigValue(config, 'app.description',
-      process.env.FLUXSTACK_APP_DESCRIPTION || process.env.APP_DESCRIPTION, 'string')
+    this.setConfigValue(config, 'app.name', env.FLUXSTACK_APP_NAME, 'string')
+    this.setConfigValue(config, 'app.version', env.FLUXSTACK_APP_VERSION, 'string')
 
     // Server configuration
-    this.setConfigValue(config, 'server.port',
-      process.env.PORT || process.env.FLUXSTACK_PORT, 'number')
-    this.setConfigValue(config, 'server.host',
-      process.env.HOST || process.env.FLUXSTACK_HOST, 'string')
-    this.setConfigValue(config, 'server.apiPrefix',
-      process.env.FLUXSTACK_API_PREFIX || process.env.API_PREFIX, 'string')
+    this.setConfigValue(config, 'server.port', env.PORT?.toString(), 'number')
+    this.setConfigValue(config, 'server.host', env.HOST, 'string')
+    this.setConfigValue(config, 'server.apiPrefix', env.API_PREFIX, 'string')
 
     // CORS configuration
-    this.setConfigValue(config, 'server.cors.origins',
-      process.env.CORS_ORIGINS || process.env.FLUXSTACK_CORS_ORIGINS, 'array')
-    this.setConfigValue(config, 'server.cors.methods',
-      process.env.CORS_METHODS || process.env.FLUXSTACK_CORS_METHODS, 'array')
-    this.setConfigValue(config, 'server.cors.headers',
-      process.env.CORS_HEADERS || process.env.FLUXSTACK_CORS_HEADERS, 'array')
-    this.setConfigValue(config, 'server.cors.credentials',
-      process.env.CORS_CREDENTIALS || process.env.FLUXSTACK_CORS_CREDENTIALS, 'boolean')
-    this.setConfigValue(config, 'server.cors.maxAge',
-      process.env.CORS_MAX_AGE || process.env.FLUXSTACK_CORS_MAX_AGE, 'number')
+    const corsOriginsStr = env.has('CORS_ORIGINS') ? env.all().CORS_ORIGINS : undefined
+    const corsMethodsStr = env.has('CORS_METHODS') ? env.all().CORS_METHODS : undefined
+    const corsHeadersStr = env.has('CORS_HEADERS') ? env.all().CORS_HEADERS : undefined
+
+    this.setConfigValue(config, 'server.cors.origins', corsOriginsStr, 'array')
+    this.setConfigValue(config, 'server.cors.methods', corsMethodsStr, 'array')
+    this.setConfigValue(config, 'server.cors.headers', corsHeadersStr, 'array')
+    this.setConfigValue(config, 'server.cors.credentials', env.CORS_CREDENTIALS?.toString(), 'boolean')
+    this.setConfigValue(config, 'server.cors.maxAge', env.CORS_MAX_AGE?.toString(), 'number')
 
     // Client configuration
-    this.setConfigValue(config, 'client.port',
-      process.env.VITE_PORT || process.env.CLIENT_PORT || process.env.FLUXSTACK_CLIENT_PORT, 'number')
-    this.setConfigValue(config, 'client.proxy.target',
-      process.env.VITE_API_URL || process.env.API_URL || process.env.FLUXSTACK_PROXY_TARGET, 'string')
-    this.setConfigValue(config, 'client.build.sourceMaps',
-      process.env.FLUXSTACK_CLIENT_SOURCEMAPS, 'boolean')
-    this.setConfigValue(config, 'client.build.minify',
-      process.env.FLUXSTACK_CLIENT_MINIFY, 'boolean')
+    this.setConfigValue(config, 'client.port', env.VITE_PORT?.toString(), 'number')
 
     // Build configuration
-    this.setConfigValue(config, 'build.target',
-      process.env.BUILD_TARGET || process.env.FLUXSTACK_BUILD_TARGET, 'buildTarget')
-    this.setConfigValue(config, 'build.outDir',
-      process.env.BUILD_OUTDIR || process.env.FLUXSTACK_BUILD_OUTDIR, 'string')
-    this.setConfigValue(config, 'build.sourceMaps',
-      process.env.BUILD_SOURCEMAPS || process.env.FLUXSTACK_BUILD_SOURCEMAPS, 'boolean')
-    this.setConfigValue(config, 'build.clean',
-      process.env.BUILD_CLEAN || process.env.FLUXSTACK_BUILD_CLEAN, 'boolean')
-
-    // Build optimization
-    this.setConfigValue(config, 'build.optimization.minify',
-      process.env.BUILD_MINIFY || process.env.FLUXSTACK_BUILD_MINIFY, 'boolean')
-    this.setConfigValue(config, 'build.optimization.treeshake',
-      process.env.BUILD_TREESHAKE || process.env.FLUXSTACK_BUILD_TREESHAKE, 'boolean')
-    this.setConfigValue(config, 'build.optimization.compress',
-      process.env.BUILD_COMPRESS || process.env.FLUXSTACK_BUILD_COMPRESS, 'boolean')
-    this.setConfigValue(config, 'build.optimization.splitChunks',
-      process.env.BUILD_SPLIT_CHUNKS || process.env.FLUXSTACK_BUILD_SPLIT_CHUNKS, 'boolean')
-    this.setConfigValue(config, 'build.optimization.bundleAnalyzer',
-      process.env.BUILD_ANALYZER || process.env.FLUXSTACK_BUILD_ANALYZER, 'boolean')
+    const buildMinify = env.has('BUILD_MINIFY') ? env.all().BUILD_MINIFY : undefined
+    this.setConfigValue(config, 'build.optimization.minify', buildMinify, 'boolean')
 
     // Logging configuration
-    this.setConfigValue(config, 'logging.level',
-      process.env.LOG_LEVEL || process.env.FLUXSTACK_LOG_LEVEL, 'logLevel')
-    this.setConfigValue(config, 'logging.format',
-      process.env.LOG_FORMAT || process.env.FLUXSTACK_LOG_FORMAT, 'logFormat')
+    this.setConfigValue(config, 'logging.level', env.LOG_LEVEL, 'logLevel')
+    this.setConfigValue(config, 'logging.format', env.LOG_FORMAT, 'logFormat')
 
     // Monitoring configuration
-    this.setConfigValue(config, 'monitoring.enabled',
-      process.env.MONITORING_ENABLED || process.env.FLUXSTACK_MONITORING_ENABLED, 'boolean')
-    this.setConfigValue(config, 'monitoring.metrics.enabled',
-      process.env.METRICS_ENABLED || process.env.FLUXSTACK_METRICS_ENABLED, 'boolean')
-    this.setConfigValue(config, 'monitoring.metrics.collectInterval',
-      process.env.METRICS_INTERVAL || process.env.FLUXSTACK_METRICS_INTERVAL, 'number')
-    this.setConfigValue(config, 'monitoring.profiling.enabled',
-      process.env.PROFILING_ENABLED || process.env.FLUXSTACK_PROFILING_ENABLED, 'boolean')
-    this.setConfigValue(config, 'monitoring.profiling.sampleRate',
-      process.env.PROFILING_SAMPLE_RATE || process.env.FLUXSTACK_PROFILING_SAMPLE_RATE, 'number')
+    this.setConfigValue(config, 'monitoring.enabled', env.ENABLE_MONITORING?.toString(), 'boolean')
+    this.setConfigValue(config, 'monitoring.metrics.enabled', env.ENABLE_METRICS?.toString(), 'boolean')
 
     // Database configuration
-    this.setConfigValue(config, 'database.url', process.env.DATABASE_URL, 'string')
-    this.setConfigValue(config, 'database.host', process.env.DATABASE_HOST, 'string')
-    this.setConfigValue(config, 'database.port', process.env.DATABASE_PORT, 'number')
-    this.setConfigValue(config, 'database.database', process.env.DATABASE_NAME, 'string')
-    this.setConfigValue(config, 'database.user', process.env.DATABASE_USER, 'string')
-    this.setConfigValue(config, 'database.password', process.env.DATABASE_PASSWORD, 'string')
-    this.setConfigValue(config, 'database.ssl', process.env.DATABASE_SSL, 'boolean')
-    this.setConfigValue(config, 'database.poolSize', process.env.DATABASE_POOL_SIZE, 'number')
+    this.setConfigValue(config, 'database.url', env.DATABASE_URL, 'string')
+    this.setConfigValue(config, 'database.host', env.DB_HOST, 'string')
+    this.setConfigValue(config, 'database.port', env.DB_PORT?.toString(), 'number')
+    this.setConfigValue(config, 'database.database', env.DB_NAME, 'string')
+    this.setConfigValue(config, 'database.user', env.DB_USER, 'string')
+    this.setConfigValue(config, 'database.password', env.DB_PASSWORD, 'string')
+    this.setConfigValue(config, 'database.ssl', env.DB_SSL?.toString(), 'boolean')
 
     // Auth configuration
-    this.setConfigValue(config, 'auth.secret', process.env.JWT_SECRET, 'string')
-    this.setConfigValue(config, 'auth.expiresIn', process.env.JWT_EXPIRES_IN, 'string')
-    this.setConfigValue(config, 'auth.algorithm', process.env.JWT_ALGORITHM, 'string')
-    this.setConfigValue(config, 'auth.issuer', process.env.JWT_ISSUER, 'string')
+    this.setConfigValue(config, 'auth.secret', env.JWT_SECRET, 'string')
+    this.setConfigValue(config, 'auth.expiresIn', env.JWT_EXPIRES_IN, 'string')
+    this.setConfigValue(config, 'auth.algorithm', env.JWT_ALGORITHM, 'string')
 
     // Email configuration
-    this.setConfigValue(config, 'email.host', process.env.SMTP_HOST, 'string')
-    this.setConfigValue(config, 'email.port', process.env.SMTP_PORT, 'number')
-    this.setConfigValue(config, 'email.user', process.env.SMTP_USER, 'string')
-    this.setConfigValue(config, 'email.password', process.env.SMTP_PASSWORD, 'string')
-    this.setConfigValue(config, 'email.secure', process.env.SMTP_SECURE, 'boolean')
-    this.setConfigValue(config, 'email.from', process.env.SMTP_FROM, 'string')
-
-    // Storage configuration
-    this.setConfigValue(config, 'storage.uploadPath', process.env.UPLOAD_PATH, 'string')
-    this.setConfigValue(config, 'storage.maxFileSize', process.env.MAX_FILE_SIZE, 'number')
-    this.setConfigValue(config, 'storage.provider', process.env.STORAGE_PROVIDER, 'string')
-
-    // Plugin configuration
-    this.setConfigValue(config, 'plugins.enabled',
-      process.env.FLUXSTACK_PLUGINS_ENABLED, 'array')
-    this.setConfigValue(config, 'plugins.disabled',
-      process.env.FLUXSTACK_PLUGINS_DISABLED, 'array')
+    this.setConfigValue(config, 'email.host', env.SMTP_HOST, 'string')
+    this.setConfigValue(config, 'email.port', env.SMTP_PORT?.toString(), 'number')
+    this.setConfigValue(config, 'email.user', env.SMTP_USER, 'string')
+    this.setConfigValue(config, 'email.password', env.SMTP_PASSWORD, 'string')
+    this.setConfigValue(config, 'email.secure', env.SMTP_SECURE?.toString(), 'boolean')
 
     return this.cleanEmptyObjects(config)
   }