Updated plugins

Author: Eventyret

PROJECT.md

@@ -169,16 +169,17 @@ This document outlines the planned features, improvements, and tasks for V2 of t
    - Existing database config
    - Existing Docker files
    - Environment files
+   - Node.js version detection
 
-2. **Environment Selection**
+2. **Environment Selection** ✅
    ```
    ? Select environment setup:
    ❯ Development (Optimized for local development with hot-reload)
    ❯ Production (Optimized for deployment)
    ❯ Both (Development + Production setup)
    ```
 
-3. **Production Setup** (Only if Production/Both selected)
+3. **Production Setup** ✅
    - If Production was selected:
      ```
      ? Choose deployment setup:
@@ -191,7 +192,7 @@ This document outlines the planned features, improvements, and tasks for V2 of t
      - Development: docker-compose.yml
      - Production: Both Dockerfile and docker-compose.prod.yml
 
-4. **Database Configuration**
+4. **Database Configuration** ✅
    ```
    ? Select database setup:
    ❯ PostgreSQL (Recommended for production)
@@ -203,41 +204,53 @@ This document outlines the planned features, improvements, and tasks for V2 of t
    - Show warning if SQLite selected for production
    - Additional configuration based on database type
 
-5. **Node.js Configuration**
+5. **Node.js Configuration** ✅
    ```
    ? Select Node.js version:
-   ❯ LTS (Recommended, currently Node.js 20)
-   ❯ Current (Latest stable)
+   ❯ Project Version (if detected)
+   ❯ Node 20 LTS (v20.11.1) - Latest minor version
+   ❯ Node 18 LTS (v18.19.1) - Latest minor version
+   ❯ Latest (v21.x) - Not LTS
    ❯ Custom Version
    ```
-
-#### Smart Defaults & Validation
+   - Auto-detects project version from:
+     - .nvmrc
+     - .node-version
+     - local node_modules
+     - system Node.js
+   - Shows latest minor version for each LTS major
+   - Validates custom version input
+
+#### Smart Defaults & Validation ✅
 - [x] Use detected values when available
 - [x] Skip questions if valid configuration exists
 - [x] Validate database credentials
 - [x] Ensure password strength
 - [x] Verify port availability
+- [x] Validate Node.js versions
+- [x] Smart version selection based on project
 
 ### Current Progress
 - [x] Basic project structure
 - [x] TypeScript migration
 - [x] Project detection
 - [x] Interactive UI with Ink
 - [x] Basic flow implementation
+- [x] Node.js version management
 - [ ] Database configuration
 - [ ] Docker file generation
 - [ ] Environment handling
 - [ ] Plugin system
 
 ### Next Steps
-1. Implement database configuration handlers
-2. Create Docker template system
-3. Add environment variable management
+1. Implement Docker file generation based on selected options
+2. Add environment variable management
+3. Create database configuration handlers
 4. Implement plugin system for extensibility
 
 ### 5. Project Detection & Configuration 🔍
-- [ ] Improve Strapi version detection
-- [ ] Add Node.js version compatibility check
+- [x] Improve Strapi version detection
+- [x] Add Node.js version compatibility check
 - [ ] Implement project structure validation
 - [ ] Add support for custom Strapi configurations
 - [ ] Implement configuration file support
@@ -328,4 +341,31 @@ This document outlines the planned features, improvements, and tasks for V2 of t
    - Cloud platform integrations
    - Additional template support
    - Performance optimizations
-   - Community-requested features 
+   - Community-requested features 
+
+## Example Usage
+
+```typescript
+// Initialize the generator
+const generator = new DockerGenerator('/path/to/plugins');
+await generator.initialize();
+
+// Get available databases
+const databases = generator.getAvailableDatabases();
+
+// Generate Docker files
+await generator.generate({
+  environment: 'development',
+  database: {
+    type: 'postgresql',
+    config: {
+      host: 'localhost',
+      port: 5432,
+      // ... other config
+    }
+  },
+  node: {
+    version: '20.11.1'
+  }
+}, './output');
+``` 

src/plugins/core/docker-generator.ts

@@ -0,0 +1,107 @@
+import { PluginManager } from './plugin-manager';
+import { TemplateRenderer } from './template-renderer';
+import path from 'path';
+
+export interface DockerConfig {
+  environment: 'development' | 'production' | 'both';
+  database: {
+    type: string;
+    config: Record<string, any>;
+  };
+  node: {
+    version: string;
+  };
+}
+
+export class DockerGenerator {
+  private pluginManager: PluginManager;
+  private templateRenderer: TemplateRenderer;
+
+  constructor(pluginsPath: string) {
+    this.pluginManager = new PluginManager(pluginsPath);
+    this.templateRenderer = new TemplateRenderer();
+  }
+
+  // Initialize the generator
+  async initialize(): Promise<void> {
+    await this.pluginManager.loadPlugins();
+  }
+
+  // Get available database types
+  getAvailableDatabases(): string[] {
+    return this.pluginManager.getAllDatabasePlugins().map(plugin => plugin.name);
+  }
+
+  // Generate Docker configuration files
+  async generate(config: DockerConfig, targetDir: string): Promise<void> {
+    // Load database plugin and templates
+    const { templates, variables } = await this.pluginManager.generateDockerConfig(
+      config.database.type,
+      config.database.config
+    );
+
+    // Add environment-specific variables
+    const templateVars = {
+      ...variables,
+      environment: config.environment,
+      node: {
+        version: config.node.version
+      }
+    };
+
+    // Generate docker-compose.yml
+    if (config.environment !== 'production' || config.database.type === 'sqlite') {
+      const composePath = path.join(targetDir, 
+        config.environment === 'both' ? 'docker-compose.dev.yml' : 'docker-compose.yml'
+      );
+      await this.templateRenderer.renderToFile(
+        templates['compose'],
+        templateVars,
+        composePath
+      );
+    }
+
+    // Generate production docker-compose if needed
+    if (config.environment === 'production' || config.environment === 'both') {
+      const prodComposePath = path.join(targetDir, 'docker-compose.prod.yml');
+      await this.templateRenderer.renderToFile(
+        templates['compose'],
+        { ...templateVars, environment: 'production' },
+        prodComposePath
+      );
+    }
+
+    // Generate Dockerfile
+    const dockerfilePath = path.join(targetDir, 
+      config.environment === 'both' ? 'Dockerfile.prod' : 'Dockerfile'
+    );
+    
+    if (templates['dockerfile']) {
+      await this.templateRenderer.renderToFile(
+        templates['dockerfile'],
+        templateVars,
+        dockerfilePath
+      );
+    }
+
+    // Generate development Dockerfile if needed
+    if (config.environment === 'both') {
+      await this.templateRenderer.renderToFile(
+        templates['dockerfile'],
+        { ...templateVars, environment: 'development' },
+        path.join(targetDir, 'Dockerfile.dev')
+      );
+    }
+  }
+
+  // Validate configuration
+  async validateConfig(config: DockerConfig): Promise<boolean> {
+    const plugin = this.pluginManager.getDatabasePlugin(config.database.type);
+    if (!plugin) {
+      throw new Error(`Unsupported database type: ${config.database.type}`);
+    }
+
+    const validation = plugin.validateAnswers(config.database.config);
+    return validation.isValid;
+  }
+} 

src/plugins/core/load-plugins.ts

@@ -0,0 +1,53 @@
+import fs from 'fs';
+import path from 'path';
+import { DatabasePlugin } from './types';
+
+export async function loadDatabasePlugins(pluginsPath: string): Promise<Map<string, DatabasePlugin>> {
+  const plugins = new Map<string, DatabasePlugin>();
+  const databasesPath = path.join(pluginsPath, 'databases');
+
+  try {
+    const entries = fs.readdirSync(databasesPath, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const plugin = await loadDatabasePlugin(path.join(databasesPath, entry.name));
+        if (plugin) {
+          plugins.set(plugin.name, plugin);
+        }
+      }
+    }
+  } catch (error) {
+    console.error('Error loading plugins:', error);
+  }
+
+  return plugins;
+}
+
+async function loadDatabasePlugin(pluginPath: string): Promise<DatabasePlugin | null> {
+  try {
+    const [questions, config, validation] = await Promise.all([
+      import(path.join(pluginPath, 'questions')),
+      import(path.join(pluginPath, 'config')),
+      import(path.join(pluginPath, 'validation'))
+    ]);
+
+    return {
+      name: path.basename(pluginPath),
+      getQuestions: questions.getQuestions,
+      validateConfig: validation.validateConfig,
+      getTemplateVariables: config.getTemplateVariables
+    };
+  } catch (error) {
+    console.error(`Error loading plugin from ${pluginPath}:`, error);
+    return null;
+  }
+}
+
+export function getDatabasePlugin(plugins: Map<string, DatabasePlugin>, name: string): DatabasePlugin | undefined {
+  return plugins.get(name);
+}
+
+export function getAllDatabasePlugins(plugins: Map<string, DatabasePlugin>): DatabasePlugin[] {
+  return Array.from(plugins.values());
+}