Refactor project structure and enhance type definitions for database plugins

- Updated tsconfig with improved path aliases
- Restructured database plugin types and configurations
- Added comprehensive type definitions for database plugins
- Implemented core plugin management and template generation utilities
- Introduced project detection and configuration generation functions

Author: Eventyret

.vscode/settings.json

@@ -1,6 +1,6 @@
 {
 	"editor.codeActionsOnSave": {
-		"source.fixAll.eslint": true
+		"source.fixAll.eslint": "explicit"
 	},
 	"eslint.validate": ["javascript"]
 }

src/commands/dockerize.ts

@@ -0,0 +1,49 @@
+import { generateDockerCompose } from '../templates';
+import { getAvailablePlugins, processPluginAnswers } from '../core/plugin-manager';
+
+export async function dockerize(answers: any) {
+  const options = {
+    nodeVersion: answers.nodeVersion,
+    environment: answers.environment,
+    customModifications: [
+      // Example: Add Redis service
+      {
+        service: 'redis',
+        config: {
+          image: 'redis:alpine',
+          ports: ['6379:6379'],
+          volumes: ['redis_data:/data']
+        }
+      },
+      // Example: Modify Strapi service
+      {
+        service: 'strapi',
+        config: {
+          environment: {
+            REDIS_HOST: 'redis'
+          },
+          depends_on: ['redis']
+        }
+      }
+    ]
+  };
+
+  if (answers.database) {
+    const plugin = getAvailablePlugins().find(p => p.name === answers.database);
+    if (plugin) {
+      options.database = {
+        plugin,
+        config: await processPluginAnswers(plugin.name, answers)
+      };
+    }
+  }
+
+  const composeFile = await generateDockerCompose(options);
+  
+  // Write to appropriate docker-compose file
+  const filename = options.environment === 'production' 
+    ? 'docker-compose.prod.yml' 
+    : 'docker-compose.yml';
+  
+  await writeFile(filename, composeFile);
+} 

src/core/plugin-manager.ts

@@ -0,0 +1,85 @@
+import { DatabasePlugin } from '@types';
+
+const plugins = new Map<string, DatabasePlugin>();
+
+export async function loadPlugins() {
+  const plugins = new Map<string, DatabasePlugin>();
+
+  // Dynamic imports to get the actual plugin instances
+  const postgresql = (await import('@plugins/databases/postgresql')).default;
+  const mysql = (await import('@plugins/databases/mysql')).default;
+  const mariadb = (await import('@plugins/databases/mariadb')).default;
+  const sqlite = (await import('@plugins/databases/sqlite')).default;
+
+  plugins.set('postgresql', postgresql);
+  plugins.set('mysql', mysql);
+  plugins.set('mariadb', mariadb);
+  plugins.set('sqlite', sqlite);
+
+  return plugins;
+}
+
+export function registerPlugin(plugin: DatabasePlugin) {
+  plugins.set(plugin.name, plugin);
+}
+
+export function getPlugin(name: string): DatabasePlugin | undefined {
+  return plugins.get(name);
+}
+
+export function getPluginQuestions(pluginName: string) {
+  const plugin = plugins.get(pluginName);
+  if (!plugin) {
+    throw new Error(`Plugin ${pluginName} not found`);
+  }
+
+  return [
+    {
+      type: 'text',
+      name: 'database',
+      message: 'Database name?',
+      default: 'strapi'
+    },
+    {
+      type: 'text',
+      name: 'username',
+      message: 'Database username?',
+      default: 'strapi'
+    },
+    {
+      type: 'password',
+      name: 'password',
+      message: 'Database password?',
+      validate: (input: string) => input.length >= 8
+    },
+    {
+      type: 'text',
+      name: 'port',
+      message: 'Database port?',
+      default: plugin.defaultPort.toString()
+    },
+    // Add additional questions if they exist
+    ...(plugin.additionalQuestions || [])
+  ];
+}
+
+export function processPluginAnswers(pluginName: string, answers: any) {
+  const plugin = plugins.get(pluginName);
+  if (!plugin) {
+    throw new Error(`Plugin ${pluginName} not found`);
+  }
+
+  if (!plugin.validateConfig(answers)) {
+    throw new Error('Invalid configuration');
+  }
+
+  return {
+    templateVariables: plugin.getTemplateVariables(answers),
+    containerName: plugin.containerName,
+    volumePath: plugin.volumePath
+  };
+}
+
+export function getAvailablePlugins(): DatabasePlugin[] {
+  return Array.from(plugins.values());
+} 

src/index.ts

@@ -0,0 +1,29 @@
+import { getProjectInfo } from './utils/project-detection';
+import { loadPlugins } from './core/plugin-manager';
+import { promptQuestions } from './prompts';
+import { generateConfiguration } from './templates';
+
+export async function main() {
+  // 1. Auto-Detection Phase
+  const projectInfo = await getProjectInfo();
+  // - Project type (TS/JS)
+  // - Existing database config
+  // - Node.js version
+  // - Environment files
+
+  // 2. Load Available Plugins
+  const plugins = await loadPlugins();
+
+  // 3. Interactive Questions
+  const answers = await promptQuestions({
+    projectInfo,
+    availablePlugins: plugins
+  });
+
+  // 4. Generate Configuration
+  await generateConfiguration({
+    projectInfo,
+    answers,
+    selectedPlugin: plugins[answers.database]
+  });
+} 

src/plugins/core/types.ts

@@ -1,66 +1,61 @@
-export type Environment = 'development' | 'production' | 'both';
-
-export interface DatabaseConfig {
-  type: string;
-  config: Record<string, any>;
-}
-
-export interface NodeConfig {
-  version: string;
-}
-
-export interface DockerConfig {
-  environment: Environment;
-  database: DatabaseConfig;
-  node: NodeConfig;
-}
-
-export interface Question {
-  type: string;
+export interface DatabasePluginConfig {
   name: string;
-  message: string;
-  default?: any;
-  choices?: string[];
-  validate?: (value: any) => boolean | string;
+  defaultPort: number;
+  containerName: string;
+  volumePath: string;
+  envPrefix: string;
+  defaultVersion: string;
+  image: {
+    name: string;
+    tag: string;
+  };
+  healthcheck?: {
+    test: string[] | string;
+    interval: string;
+    timeout: string;
+    retries: number;
+  };
+}
+
+export interface DatabaseAnswers {
+  database: string;
+  username: string;
+  password: string;
+  port: string;
+  version?: string;
+  charset?: string;
+  collation?: string;
+  rootPassword?: string;
 }
 
 export interface ValidationResult {
   isValid: boolean;
-  errors?: string[];
-}
-
-export interface Template {
-  name: string;
-  content: string;
-  variables: Record<string, any>;
-}
-
-export interface DatabasePlugin {
-  name: string;
-  getQuestions: () => Question[];
-  validateConfig: (config: Record<string, any>) => ValidationResult;
-  getTemplateVariables: (config: Record<string, any>) => Record<string, any>;
+  errors: string[];
 }
 
 export interface TemplateVariables {
-  [key: string]: string | number | boolean | object;
+  database: {
+    type: string;
+    name: string;
+    user: string;
+    password: string;
+    port: string;
+    host: string;
+  };
+  environment: Record<string, string>;
+  volumes: {
+    data: string;
+  };
+  image: {
+    name: string;
+    tag: string;
+  };
 }
 
-export interface Plugin {
-  type: string;
+export interface DatabasePlugin {
   name: string;
-  version: string;
-  description: string;
-
-  // Get questions to ask user
-  getQuestions(): Question[];
-
-  // Validate user's answers
-  validateAnswers(answers: Record<string, any>): ValidationResult;
-
-  // Get templates with variables
-  getTemplates(answers: Record<string, any>): Template[];
-
-  // Get environment variables
-  getEnvironmentVariables(answers: Record<string, any>): Record<string, string>;
+  defaultPort: number;
+  getTemplateVariables(answers: DatabaseAnswers): TemplateVariables;
+  validateConfig(answers: DatabaseAnswers): ValidationResult;
+  validateConnectionString(url: string): boolean;
 }