Enhance plugin core utilities and type definitions

- Refactored plugin core with comprehensive template and validation utilities
- Updated MySQL plugin to leverage new core template generation methods
- Restructured type definitions for better type safety and modularity
- Added validation and template generation functions for database plugins
- Improved type definitions for plugin configurations and answers

Author: Eventyret

src/plugins/core/index.ts

@@ -0,0 +1,22 @@
+// Re-export all types from our core types
+export * from './types';
+
+// Export base plugin creator
+export { createDatabasePlugin } from '../databases/core/base-plugin';
+
+// Export template utilities
+export { 
+  createBaseTemplateVariables,
+  mergeTemplateVariables 
+} from './template-utils';
+
+// Export validation utilities
+export {
+  validatePort,
+  validateRequired
+} from './validation';
+
+// Export general utilities
+export {
+  createConnectionStringValidator
+} from './utils'; 

src/plugins/core/template-utils.ts

@@ -0,0 +1,40 @@
+import { DatabasePluginConfig, DatabaseAnswers, TemplateVariables } from '@types';
+
+export const createBaseTemplateVariables = (
+  config: DatabasePluginConfig,
+  answers: DatabaseAnswers
+): TemplateVariables => ({
+  database: {
+    type: config.name.toLowerCase(),
+    name: answers.database,
+    user: answers.username,
+    password: answers.password,
+    port: answers.port.toString(),
+    host: 'localhost'
+  },
+  environment: {
+    [`${config.envPrefix}_DATABASE`]: answers.database,
+    [`${config.envPrefix}_USER`]: answers.username,
+    [`${config.envPrefix}_PASSWORD`]: answers.password,
+    [`${config.envPrefix}_ROOT_PASSWORD`]: answers.rootPassword || answers.password,
+  },
+  volumes: {
+    data: config.volumePath
+  },
+  image: {
+    name: config.image.name,
+    tag: answers.version || config.defaultVersion
+  }
+});
+
+export const mergeTemplateVariables = (
+  base: TemplateVariables,
+  custom: Partial<TemplateVariables>
+): TemplateVariables => ({
+  ...base,
+  ...custom,
+  environment: {
+    ...base.environment,
+    ...custom.environment
+  }
+}); 

src/plugins/core/types.ts

@@ -1,61 +1,41 @@
-export interface DatabasePluginConfig {
-  name: 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;
-  };
-}
+import { 
+  DatabasePlugin as BaseDBPlugin, 
+  DatabasePluginConfig as BaseDBConfig, 
+  DatabaseTemplateVariables as BaseTemplateVars,
+  DatabaseAnswers
+} from '@/types/database';
 
-export interface DatabaseAnswers {
-  database: string;
-  username: string;
-  password: string;
-  port: string;
-  version?: string;
-  charset?: string;
-  collation?: string;
-  rootPassword?: string;
+import {
+  Question,
+  ValidationRules,
+  PluginUtils,
+  PluginTemplateUtils
+} from '@/types/plugin';
+
+// Extend base plugin types with additional functionality
+export interface DatabasePlugin extends BaseDBPlugin {
+  getQuestions: () => Promise<Question[]>;
+  processAnswers: (answers: Record<string, any>) => DatabaseAnswers;
 }
 
-export interface ValidationResult {
-  isValid: boolean;
-  errors: string[];
+export interface DatabasePluginConfig extends BaseDBConfig {
+  validations?: Record<string, ValidationRules>;
+  additionalQuestions?: Question[];
 }
 
-export interface TemplateVariables {
-  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;
+// Template types
+export interface TemplateVariables extends BaseTemplateVars {
+  database: BaseTemplateVars['database'] & {
+    charset?: string;
+    collation?: string;
   };
 }
 
-export interface DatabasePlugin {
-  name: string;
-  defaultPort: number;
-  getTemplateVariables(answers: DatabaseAnswers): TemplateVariables;
-  validateConfig(answers: DatabaseAnswers): ValidationResult;
-  validateConnectionString(url: string): boolean;
-} 
+// Re-export plugin types
+export type {
+  Question,
+  ValidationRules,
+  PluginUtils,
+  PluginTemplateUtils,
+  DatabaseAnswers
+}; 

src/plugins/core/utils.ts

@@ -0,0 +1,28 @@
+import { DatabaseAnswers, ValidationResult } from '@types';
+
+export const createConnectionStringValidator = (databaseType: string) => 
+  (connectionString: string): boolean => {
+    const pattern = new RegExp(`^${databaseType}:\/\/[^:]+:[^@]+@[^:]+:\d+\/\w+$`);
+    return pattern.test(connectionString);
+  };
+
+export const validatePort = (port: string): ValidationResult => {
+  const errors: string[] = [];
+  const portNum = parseInt(port);
+  
+  if (isNaN(portNum) || portNum < 1024 || portNum > 65535) {
+    errors.push('Port must be a number between 1024 and 65535');
+  }
+
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+};
+
+export const validateRequired = (value: any, fieldName: string): ValidationResult => {
+  return {
+    isValid: !!value,
+    errors: value ? [] : [`${fieldName} is required`]
+  };
+}; 

src/plugins/core/validation.ts

@@ -0,0 +1,22 @@
+import { ValidationResult } from '@types';
+
+export const validatePort = (port: string): ValidationResult => {
+  const errors: string[] = [];
+  const portNum = parseInt(port);
+  
+  if (isNaN(portNum) || portNum < 1024 || portNum > 65535) {
+    errors.push('Port must be a number between 1024 and 65535');
+  }
+
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+};
+
+export const validateRequired = (value: any, fieldName: string): ValidationResult => {
+  return {
+    isValid: !!value,
+    errors: value ? [] : [`${fieldName} is required`]
+  };
+}; 

src/plugins/databases/core/base-plugin.ts

@@ -1,11 +1,5 @@
-import {
-  DatabaseAnswers,
-  DatabasePlugin,
-  DatabasePluginConfig,
-  Question,
-  TemplateVariables,
-  ValidationResult
-} from '@types';
+import { Question } from "@/types/cli";
+import { DatabasePlugin, DatabasePluginConfig } from "@/types/database";
 import { getDockerImageVersions } from '@utils/docker-versions';
 import { generateSecurePassword } from '@utils/passwords';
 
@@ -59,16 +53,16 @@ export function createDatabasePlugin(config: DatabasePluginConfig): DatabasePlug
         name: 'PASSWORD_TYPE',
         message: 'How would you like to set the database password?',
         choices: [
-          { label: 'Generate', value: 'generate', hint: 'Generate a secure password' },
-          { label: 'Custom', value: 'custom', hint: 'Use a custom password' }
+          { title: 'Generate', value: 'generate', description: 'Generate a secure password' },
+          { title: 'Custom', value: 'custom', description: 'Use a custom password' }
         ],
         default: 'generate'
       },
       {
         type: 'text',
         name: `${prefix}_PASSWORD`,
         message: 'Enter your database password:',
-        when: (answers) => answers.PASSWORD_TYPE === 'custom',
+        when: (answers: Record<string, any>) => answers.PASSWORD_TYPE === 'custom',
         validate: (value) => {
           if (!value) return 'Password is required';
           if (value.length < 8) return 'Password must be at least 8 characters long';
@@ -92,9 +86,9 @@ export function createDatabasePlugin(config: DatabasePluginConfig): DatabasePlug
         name: `${prefix}_VERSION`,
         message: `Which ${config.name} version would you like to use?`,
         choices: versions.map(version => ({
+          title: `${config.name} ${version}`,
           value: version,
-          label: `${config.name} ${version}`,
-          hint: version.includes('alpine') ? 'Recommended for production' : undefined
+          description: version.includes('alpine') ? 'Recommended for production' : undefined
         })),
         default: versions.find(v => v === config.defaultVersion) || versions[0]
       }
@@ -105,7 +99,7 @@ export function createDatabasePlugin(config: DatabasePluginConfig): DatabasePlug
 
   function validateConfig(answers: DatabaseAnswers): ValidationResult {
     const errors: string[] = [];
-    const requiredFields = ['database', 'username', 'password', 'port'];
+    const requiredFields = ['database', 'username', 'password', 'port'] as const;
 
     for (const field of requiredFields) {
       if (!answers[field]) {
@@ -115,7 +109,7 @@ export function createDatabasePlugin(config: DatabasePluginConfig): DatabasePlug
 
     if (config.validations) {
       Object.entries(config.validations).forEach(([field, rules]) => {
-        const value = answers[field];
+        const value = answers[field as keyof DatabaseAnswers];
         if (rules.required && !value) {
           errors.push(`${field} is required`);
         }
@@ -145,7 +139,7 @@ export function createDatabasePlugin(config: DatabasePluginConfig): DatabasePlug
     return pattern.test(connectionString);
   }
 
-  function getTemplateVariables(answers: DatabaseAnswers): TemplateVariables {
+  function getTemplateVariables(answers: DatabaseAnswers): DatabaseTemplateVariables {
     const prefix = config.envPrefix;
     return {
       database: {

src/plugins/databases/mysql/index.ts

@@ -1,8 +1,25 @@
-import { DatabasePlugin } from '@types';
-import { createDatabasePlugin } from '../core/base-plugin';
+import { DatabasePlugin, DatabaseAnswers } from '@types';
+import { 
+  createDatabasePlugin, 
+  createBaseTemplateVariables, 
+  mergeTemplateVariables 
+} from '../../core';
 import { mysqlConfig } from './config';
+import { validateConfig } from './validation';
 
 // Create the plugin instance using the base plugin creator
-const MySQLPlugin: DatabasePlugin = createDatabasePlugin(mysqlConfig);
+const MySQLPlugin: DatabasePlugin = {
+  ...createDatabasePlugin(mysqlConfig),
+  validateConfig,
+  getTemplateVariables: (answers: DatabaseAnswers) => {
+    const baseVariables = createBaseTemplateVariables(mysqlConfig, answers);
+    return mergeTemplateVariables(baseVariables, {
+      environment: {
+        MYSQL_CHARACTER_SET_SERVER: answers.charset || 'utf8mb4',
+        MYSQL_COLLATION_SERVER: answers.collation || 'utf8mb4_unicode_ci'
+      }
+    });
+  }
+};
 
 export default MySQLPlugin; 

src/plugins/databases/mysql/validation.ts

@@ -1,20 +1,22 @@
 import { DatabaseAnswers, ValidationResult } from '@types';
+import { validateRequired, validatePort } from '../../core/utils';
 
-export function validateConfig(config: DatabaseAnswers): ValidationResult {
+export function validateConfig(answers: DatabaseAnswers): ValidationResult {
   const errors: string[] = [];
 
-  const requiredFields = ['database', 'username', 'password', 'port'];
-  for (const field of requiredFields) {
-    if (!config[field]) {
-      errors.push(`${field} is required`);
-    }
+  // Base validation
+  const requiredValidation = validateRequired(answers.database, 'database');
+  const portValidation = validatePort(answers.port);
+
+  errors.push(...requiredValidation.errors, ...portValidation.errors);
+
+  // MySQL specific validation
+  if (answers.charset && !['utf8mb4', 'utf8', 'latin1'].includes(answers.charset)) {
+    errors.push('Invalid character set');
   }
 
-  if (config.port) {
-    const port = parseInt(config.port.toString());
-    if (isNaN(port) || port < 1024 || port > 65535) {
-      errors.push('Port must be a number between 1024 and 65535');
-    }
+  if (answers.collation && !answers.collation.startsWith(answers.charset || '')) {
+    errors.push('Collation must match character set');
   }
 
   return {

src/plugins/index.ts

@@ -0,0 +1,37 @@
+import { DatabasePlugin, PluginType } from '@types';
+import MySQLPlugin from './databases/mysql';
+import MariaDBPlugin from './databases/mariadb';
+import PostgreSQLPlugin from './databases/postgresql';
+
+// Plugin registry
+const plugins: Record<string, DatabasePlugin> = {
+  mysql: MySQLPlugin,
+  mariadb: MariaDBPlugin,
+  postgresql: PostgreSQLPlugin
+} as const;
+
+// Plugin type guard
+export const isDatabasePlugin = (plugin: unknown): plugin is DatabasePlugin => {
+  return plugin !== null && 
+    typeof plugin === 'object' && 
+    'type' in plugin && 
+    (plugin as DatabasePlugin).type === 'database';
+};
+
+// Plugin utilities with proper typing
+export const getPlugin = (name: string): DatabasePlugin | undefined => 
+  plugins[name];
+
+export const getPluginsByType = (type: PluginType): DatabasePlugin[] => 
+  Object.values(plugins).filter(plugin => 
+    isDatabasePlugin(plugin) && plugin.type === type
+  );
+
+export const getAllPlugins = (): DatabasePlugin[] => 
+  Object.values(plugins);
+
+// Export core functionality
+export * from './core';
+
+// Export plugin registry
+export default plugins;