servcraft 0.1.0 → 0.1.3

package/src/cli/commands/add-module.ts

@@ -1,21 +1,49 @@
 import { Command } from 'commander';
 import path from 'path';
-import fs from 'fs/promises';
 import ora from 'ora';
 import chalk from 'chalk';
-import { ensureDir, writeFile, fileExists, success, error, info, warn, getModulesDir, getSourceDir } from '../utils/helpers.js';
+import * as fs from 'fs/promises';
+import {
+  ensureDir,
+  writeFile,
+  fileExists,
+  success,
+  error,
+  info,
+  warn,
+  getModulesDir,
+} from '../utils/helpers.js';
+import { EnvManager } from '../utils/env-manager.js';
+import { TemplateManager } from '../utils/template-manager.js';
+import { InteractivePrompt } from '../utils/interactive-prompt.js';
 
 // Pre-built modules that can be added
 const AVAILABLE_MODULES = {
   auth: {
     name: 'Authentication',
     description: 'JWT authentication with access/refresh tokens',
-    files: ['auth.service', 'auth.controller', 'auth.routes', 'auth.middleware', 'auth.schemas', 'auth.types', 'index'],
+    files: [
+      'auth.service',
+      'auth.controller',
+      'auth.routes',
+      'auth.middleware',
+      'auth.schemas',
+      'auth.types',
+      'index',
+    ],
   },
   users: {
     name: 'User Management',
     description: 'User CRUD with RBAC (roles & permissions)',
-    files: ['user.service', 'user.controller', 'user.repository', 'user.routes', 'user.schemas', 'user.types', 'index'],
+    files: [
+      'user.service',
+      'user.controller',
+      'user.repository',
+      'user.routes',
+      'user.schemas',
+      'user.types',
+      'index',
+    ],
   },
   email: {
     name: 'Email Service',
@@ -27,109 +55,280 @@ const AVAILABLE_MODULES = {
     description: 'Activity logging and audit trail',
     files: ['audit.service', 'audit.types', 'index'],
   },
-  upload: {
-    name: 'File Upload',
-    description: 'File upload with local/S3 storage',
-    files: ['upload.service', 'upload.controller', 'upload.routes', 'upload.types', 'index'],
-  },
   cache: {
     name: 'Redis Cache',
-    description: 'Redis caching service',
+    description: 'Redis caching with TTL & invalidation',
     files: ['cache.service', 'cache.types', 'index'],
   },
-  notifications: {
+  upload: {
+    name: 'File Upload',
+    description: 'File upload with local/S3/Cloudinary storage',
+    files: ['upload.service', 'upload.routes', 'upload.types', 'index'],
+  },
+  mfa: {
+    name: 'MFA/TOTP',
+    description: 'Two-factor authentication with QR codes',
+    files: ['mfa.service', 'mfa.routes', 'totp.ts', 'types.ts', 'index'],
+  },
+  oauth: {
+    name: 'OAuth',
+    description: 'Social login (Google, GitHub, Facebook, Twitter, Apple)',
+    files: ['oauth.service', 'oauth.routes', 'providers', 'types.ts', 'index'],
+  },
+  payment: {
+    name: 'Payments',
+    description: 'Payment processing (Stripe, PayPal, Mobile Money)',
+    files: ['payment.service', 'payment.routes', 'providers', 'types.ts', 'index'],
+  },
+  notification: {
     name: 'Notifications',
-    description: 'In-app and push notifications',
-    files: ['notification.service', 'notification.types', 'index'],
+    description: 'Email, SMS, Push notifications',
+    files: ['notification.service', 'types.ts', 'index'],
+  },
+  'rate-limit': {
+    name: 'Rate Limiting',
+    description: 'Advanced rate limiting with multiple algorithms',
+    files: [
+      'rate-limit.service',
+      'rate-limit.middleware',
+      'rate-limit.routes',
+      'stores',
+      'types.ts',
+      'index',
+    ],
   },
-  settings: {
-    name: 'Settings',
-    description: 'Application settings management',
-    files: ['settings.service', 'settings.controller', 'settings.routes', 'settings.types', 'index'],
+  webhook: {
+    name: 'Webhooks',
+    description: 'Outgoing webhooks with HMAC signatures & retry',
+    files: ['webhook.service', 'webhook.routes', 'signature.ts', 'retry.ts', 'types.ts', 'index'],
+  },
+  queue: {
+    name: 'Queue/Jobs',
+    description: 'Background jobs with Bull/BullMQ & cron scheduling',
+    files: ['queue.service', 'cron.ts', 'workers.ts', 'routes.ts', 'types.ts', 'index'],
+  },
+  websocket: {
+    name: 'WebSockets',
+    description: 'Real-time communication with Socket.io',
+    files: ['websocket.service', 'features.ts', 'middlewares.ts', 'types.ts', 'index'],
+  },
+  search: {
+    name: 'Search',
+    description: 'Full-text search with Elasticsearch/Meilisearch',
+    files: ['search.service', 'adapters', 'types.ts', 'index'],
+  },
+  i18n: {
+    name: 'i18n/Localization',
+    description: 'Multi-language support with 7+ locales',
+    files: ['i18n.service', 'i18n.middleware', 'i18n.routes', 'types.ts', 'index'],
+  },
+  'feature-flag': {
+    name: 'Feature Flags',
+    description: 'A/B testing & progressive rollout',
+    files: ['feature-flag.service', 'feature-flag.routes', 'types.ts', 'index'],
+  },
+  analytics: {
+    name: 'Analytics/Metrics',
+    description: 'Prometheus metrics & event tracking',
+    files: ['analytics.service', 'analytics.routes', 'types.ts', 'index'],
+  },
+  'media-processing': {
+    name: 'Media Processing',
+    description: 'Image/video processing with FFmpeg',
+    files: ['media-processing.service', 'media-processing.routes', 'types.ts', 'index'],
+  },
+  'api-versioning': {
+    name: 'API Versioning',
+    description: 'Multiple API versions support',
+    files: [
+      'versioning.service',
+      'versioning.middleware',
+      'versioning.routes',
+      'types.ts',
+      'index',
+    ],
   },
 };
 
 export const addModuleCommand = new Command('add')
   .description('Add a pre-built module to your project')
-  .argument('[module]', 'Module to add (auth, users, email, audit, upload, cache, notifications, settings)')
+  .argument(
+    '[module]',
+    'Module to add (auth, users, email, audit, upload, cache, notifications, settings)'
+  )
   .option('-l, --list', 'List available modules')
-  .action(async (moduleName?: string, options?: { list?: boolean }) => {
-    if (options?.list || !moduleName) {
-      console.log(chalk.bold('\n📦 Available Modules:\n'));
-
-      for (const [key, mod] of Object.entries(AVAILABLE_MODULES)) {
-        console.log(`  ${chalk.cyan(key.padEnd(15))} ${mod.name}`);
-        console.log(`  ${' '.repeat(15)} ${chalk.gray(mod.description)}\n`);
+  .option('-f, --force', 'Force overwrite existing module')
+  .option('-u, --update', 'Update existing module (smart merge)')
+  .option('--skip-existing', 'Skip if module already exists')
+  .action(
+    async (
+      moduleName?: string,
+      options?: { list?: boolean; force?: boolean; update?: boolean; skipExisting?: boolean }
+    ) => {
+      if (options?.list || !moduleName) {
+        console.log(chalk.bold('\n📦 Available Modules:\n'));
+
+        for (const [key, mod] of Object.entries(AVAILABLE_MODULES)) {
+          console.log(`  ${chalk.cyan(key.padEnd(15))} ${mod.name}`);
+          console.log(`  ${' '.repeat(15)} ${chalk.gray(mod.description)}\n`);
+        }
+
+        console.log(chalk.bold('Usage:'));
+        console.log(`  ${chalk.yellow('servcraft add auth')}      Add authentication module`);
+        console.log(`  ${chalk.yellow('servcraft add users')}     Add user management module`);
+        console.log(`  ${chalk.yellow('servcraft add email')}     Add email service module\n`);
+        return;
       }
 
-      console.log(chalk.bold('Usage:'));
-      console.log(`  ${chalk.yellow('servcraft add auth')}      Add authentication module`);
-      console.log(`  ${chalk.yellow('servcraft add users')}     Add user management module`);
-      console.log(`  ${chalk.yellow('servcraft add email')}     Add email service module\n`);
-      return;
-    }
-
-    const module = AVAILABLE_MODULES[moduleName as keyof typeof AVAILABLE_MODULES];
-
-    if (!module) {
-      error(`Unknown module: ${moduleName}`);
-      info('Run "servcraft add --list" to see available modules');
-      return;
-    }
+      const module = AVAILABLE_MODULES[moduleName as keyof typeof AVAILABLE_MODULES];
 
-    const spinner = ora(`Adding ${module.name} module...`).start();
-
-    try {
-      const moduleDir = path.join(getModulesDir(), moduleName);
-
-      // Check if module already exists
-      if (await fileExists(moduleDir)) {
-        spinner.stop();
-        warn(`Module "${moduleName}" already exists`);
+      if (!module) {
+        error(`Unknown module: ${moduleName}`);
+        info('Run "servcraft add --list" to see available modules');
         return;
       }
 
-      await ensureDir(moduleDir);
-
-      // Generate module files based on type
-      switch (moduleName) {
-        case 'auth':
-          await generateAuthModule(moduleDir);
-          break;
-        case 'users':
-          await generateUsersModule(moduleDir);
-          break;
-        case 'email':
-          await generateEmailModule(moduleDir);
-          break;
-        case 'audit':
-          await generateAuditModule(moduleDir);
-          break;
-        case 'upload':
-          await generateUploadModule(moduleDir);
-          break;
-        case 'cache':
-          await generateCacheModule(moduleDir);
-          break;
-        default:
-          await generateGenericModule(moduleDir, moduleName);
+      const spinner = ora(`Adding ${module.name} module...`).start();
+
+      try {
+        const moduleDir = path.join(getModulesDir(), moduleName);
+        const templateManager = new TemplateManager(process.cwd());
+        const moduleExists = await fileExists(moduleDir);
+
+        // Handle existing module
+        if (moduleExists) {
+          spinner.stop();
+
+          // Check flags
+          if (options?.skipExisting) {
+            info(`Module "${moduleName}" already exists, skipping...`);
+            return;
+          }
+
+          // Check for modifications
+          const modifiedFiles = await templateManager.getModifiedFiles(moduleName, moduleDir);
+          const hasModifications = modifiedFiles.some((f) => f.isModified);
+
+          let action: string;
+
+          if (options?.force) {
+            action = 'overwrite';
+          } else if (options?.update) {
+            action = 'update';
+          } else {
+            // Interactive prompt
+            const choice = await InteractivePrompt.askModuleExists(moduleName, hasModifications);
+            action = choice.action;
+          }
+
+          // Handle action
+          if (action === 'skip') {
+            info('Keeping existing module');
+            return;
+          }
+
+          if (action === 'diff') {
+            // Show diff and ask again
+            await showDiffForModule(templateManager, moduleName, moduleDir);
+            return;
+          }
+
+          if (action === 'backup-overwrite' || action === 'overwrite') {
+            if (action === 'backup-overwrite') {
+              const backupPath = await templateManager.createBackup(moduleName, moduleDir);
+              InteractivePrompt.showBackupCreated(backupPath);
+            }
+
+            // Remove existing module
+            await fs.rm(moduleDir, { recursive: true, force: true });
+            await ensureDir(moduleDir);
+
+            // Generate fresh module
+            await generateModuleFiles(moduleName, moduleDir);
+
+            // Save templates and manifest
+            const files = await getModuleFiles(moduleName, moduleDir);
+            await templateManager.saveTemplate(moduleName, files);
+            await templateManager.saveManifest(moduleName, files);
+
+            spinner.succeed(
+              `${module.name} module ${action === 'backup-overwrite' ? 'backed up and ' : ''}overwritten!`
+            );
+          } else if (action === 'update') {
+            // Smart merge
+            await performSmartMerge(templateManager, moduleName, moduleDir, module.name);
+          }
+        } else {
+          // Fresh installation
+          await ensureDir(moduleDir);
+
+          // Generate module files
+          await generateModuleFiles(moduleName, moduleDir);
+
+          // Save templates and manifest for future updates
+          const files = await getModuleFiles(moduleName, moduleDir);
+          await templateManager.saveTemplate(moduleName, files);
+          await templateManager.saveManifest(moduleName, files);
+
+          spinner.succeed(`${module.name} module added successfully!`);
+        }
+
+        if (!moduleExists) {
+          console.log('\n📁 Files created:');
+          module.files.forEach((f) => success(`  src/modules/${moduleName}/${f}.ts`));
+        }
+
+        // Update .env file with module-specific variables
+        const envManager = new EnvManager(process.cwd());
+        const envSections = EnvManager.getModuleEnvVariables(moduleName);
+
+        if (envSections.length > 0) {
+          const envSpinner = ora('Updating environment variables...').start();
+          try {
+            const result = await envManager.addVariables(envSections);
+
+            envSpinner.succeed('Environment variables updated!');
+
+            if (result.created) {
+              info('\n📝 Created new .env file');
+            }
+
+            if (result.added.length > 0) {
+              console.log(chalk.bold('\n✅ Added to .env:'));
+              result.added.forEach((key) => success(`  ${key}`));
+            }
+
+            if (result.skipped.length > 0) {
+              console.log(chalk.bold('\n⏭️  Already in .env (skipped):'));
+              result.skipped.forEach((key) => info(`  ${key}`));
+            }
+
+            // Show which variables need configuration
+            const requiredVars = envSections
+              .flatMap((section) => section.variables)
+              .filter((v) => v.required && !v.value)
+              .map((v) => v.key);
+
+            if (requiredVars.length > 0) {
+              console.log(chalk.bold('\n⚠️  Required configuration:'));
+              requiredVars.forEach((key) => warn(`  ${key} - Please configure this variable`));
+            }
+          } catch (err) {
+            envSpinner.fail('Failed to update environment variables');
+            error(err instanceof Error ? err.message : String(err));
+          }
+        }
+
+        console.log('\n📌 Next steps:');
+        info('  1. Configure environment variables in .env (if needed)');
+        info('  2. Register the module in your main app file');
+        info('  3. Run database migrations if needed');
+      } catch (err) {
+        spinner.fail('Failed to add module');
+        error(err instanceof Error ? err.message : String(err));
       }
-
-      spinner.succeed(`${module.name} module added successfully!`);
-
-      console.log('\n📁 Files created:');
-      module.files.forEach((f) => success(`  src/modules/${moduleName}/${f}.ts`));
-
-      console.log('\n📌 Next steps:');
-      info('  1. Register the module in your main app file');
-      info('  2. Configure any required environment variables');
-      info('  3. Run database migrations if needed');
-
-    } catch (err) {
-      spinner.fail('Failed to add module');
-      error(err instanceof Error ? err.message : String(err));
     }
-  });
+  );
 
 async function generateAuthModule(dir: string): Promise<void> {
   // This would copy from templates or generate inline
@@ -420,3 +619,237 @@ export interface ${name.charAt(0).toUpperCase() + name.slice(1)}Data {
     await writeFile(path.join(dir, fileName), content);
   }
 }
+
+/**
+ * Helper: Generate module files - copies from existing src/modules if available
+ */
+async function generateModuleFiles(moduleName: string, moduleDir: string): Promise<void> {
+  // Check if module exists in src/modules (our new modules)
+  const sourceModuleDir = path.join(process.cwd(), 'src', 'modules', moduleName);
+
+  if (await fileExists(sourceModuleDir)) {
+    // Copy from existing module
+    await copyModuleFromSource(sourceModuleDir, moduleDir);
+    return;
+  }
+
+  // Fallback to old generation methods for basic modules
+  switch (moduleName) {
+    case 'auth':
+      await generateAuthModule(moduleDir);
+      break;
+    case 'users':
+      await generateUsersModule(moduleDir);
+      break;
+    case 'email':
+      await generateEmailModule(moduleDir);
+      break;
+    case 'audit':
+      await generateAuditModule(moduleDir);
+      break;
+    case 'upload':
+      await generateUploadModule(moduleDir);
+      break;
+    case 'cache':
+      await generateCacheModule(moduleDir);
+      break;
+    default:
+      await generateGenericModule(moduleDir, moduleName);
+  }
+}
+
+/**
+ * Helper: Copy module from source directory
+ */
+async function copyModuleFromSource(sourceDir: string, targetDir: string): Promise<void> {
+  const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const sourcePath = path.join(sourceDir, entry.name);
+    const targetPath = path.join(targetDir, entry.name);
+
+    if (entry.isDirectory()) {
+      await fs.mkdir(targetPath, { recursive: true });
+      await copyModuleFromSource(sourcePath, targetPath);
+    } else {
+      await fs.copyFile(sourcePath, targetPath);
+    }
+  }
+}
+
+/**
+ * Helper: Get all module files as Record<filename, content>
+ */
+async function getModuleFiles(
+  moduleName: string,
+  moduleDir: string
+): Promise<Record<string, string>> {
+  const files: Record<string, string> = {};
+  const entries = await fs.readdir(moduleDir);
+
+  for (const entry of entries) {
+    const filePath = path.join(moduleDir, entry);
+    const stat = await fs.stat(filePath);
+
+    if (stat.isFile() && entry.endsWith('.ts')) {
+      const content = await fs.readFile(filePath, 'utf-8');
+      files[entry] = content;
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Helper: Show diff for entire module
+ */
+async function showDiffForModule(
+  templateManager: TemplateManager,
+  moduleName: string,
+  moduleDir: string
+): Promise<void> {
+  const modifiedFiles = await templateManager.getModifiedFiles(moduleName, moduleDir);
+
+  console.log(chalk.cyan(`\n📊 Changes in module "${moduleName}":\n`));
+
+  for (const file of modifiedFiles) {
+    if (file.isModified) {
+      console.log(chalk.yellow(`\n📄 ${file.fileName}:`));
+
+      const currentPath = path.join(moduleDir, file.fileName);
+      const currentContent = await fs.readFile(currentPath, 'utf-8');
+      const originalContent = await templateManager.getTemplate(moduleName, file.fileName);
+
+      if (originalContent) {
+        const diff = templateManager.generateDiff(originalContent, currentContent);
+        console.log(diff);
+      }
+    }
+  }
+}
+
+/**
+ * Helper: Perform smart merge
+ */
+async function performSmartMerge(
+  templateManager: TemplateManager,
+  moduleName: string,
+  moduleDir: string,
+  _displayName: string
+): Promise<void> {
+  const spinner = ora('Analyzing files for merge...').start();
+
+  // Get new template files
+  const newFiles: Record<string, string> = {};
+  const templateDir = path.join(templateManager['templatesDir'], moduleName);
+
+  try {
+    const entries = await fs.readdir(templateDir);
+    for (const entry of entries) {
+      const content = await fs.readFile(path.join(templateDir, entry), 'utf-8');
+      newFiles[entry] = content;
+    }
+  } catch {
+    spinner.fail('Could not find template files');
+    return;
+  }
+
+  const modifiedFiles = await templateManager.getModifiedFiles(moduleName, moduleDir);
+  spinner.stop();
+
+  // Ask for batch action or individual
+  const batchAction = await InteractivePrompt.askBatchAction();
+
+  const stats = {
+    merged: 0,
+    kept: 0,
+    overwritten: 0,
+    conflicts: 0,
+  };
+
+  for (const fileInfo of modifiedFiles) {
+    const fileName = fileInfo.fileName;
+    const filePath = path.join(moduleDir, fileName);
+    const newContent = newFiles[fileName];
+
+    if (!newContent) {
+      // File doesn't exist in new template, keep existing
+      continue;
+    }
+
+    let fileAction: string;
+
+    if (batchAction === 'merge-all') {
+      fileAction = 'merge';
+    } else if (batchAction === 'keep-all') {
+      fileAction = 'keep';
+    } else if (batchAction === 'overwrite-all') {
+      fileAction = 'overwrite';
+    } else {
+      // Ask for each file
+      const currentContent = await fs.readFile(filePath, 'utf-8');
+      const yourLines = currentContent.split('\n').length;
+      const newLines = newContent.split('\n').length;
+
+      const choice = await InteractivePrompt.askFileAction(
+        fileName,
+        fileInfo.isModified,
+        yourLines,
+        newLines
+      );
+      fileAction = choice.action;
+
+      if (fileAction === 'diff') {
+        const originalContent = await templateManager.getTemplate(moduleName, fileName);
+        if (originalContent) {
+          const diff = templateManager.generateDiff(originalContent, currentContent);
+          const proceed = await InteractivePrompt.showDiffAndAsk(diff);
+          fileAction = proceed ? 'merge' : 'keep';
+        }
+      }
+    }
+
+    // Perform action
+    if (fileAction === 'keep' || fileAction === 'skip') {
+      stats.kept++;
+      continue;
+    }
+
+    if (fileAction === 'overwrite') {
+      await fs.writeFile(filePath, newContent, 'utf-8');
+      stats.overwritten++;
+      continue;
+    }
+
+    if (fileAction === 'merge') {
+      const originalContent = await templateManager.getTemplate(moduleName, fileName);
+      const currentContent = await fs.readFile(filePath, 'utf-8');
+
+      if (originalContent) {
+        const mergeResult = await templateManager.mergeFiles(
+          originalContent,
+          currentContent,
+          newContent
+        );
+
+        await fs.writeFile(filePath, mergeResult.merged, 'utf-8');
+
+        if (mergeResult.hasConflicts) {
+          stats.conflicts++;
+          InteractivePrompt.displayConflicts(mergeResult.conflicts);
+        } else {
+          stats.merged++;
+        }
+      } else {
+        await fs.writeFile(filePath, newContent, 'utf-8');
+        stats.overwritten++;
+      }
+    }
+  }
+
+  // Update manifest
+  const files = await getModuleFiles(moduleName, moduleDir);
+  await templateManager.updateManifest(moduleName, files);
+
+  InteractivePrompt.showMergeSummary(stats);
+}

package/src/cli/commands/db.ts

@@ -2,10 +2,9 @@ import { Command } from 'commander';
 import { execSync, spawn } from 'child_process';
 import ora from 'ora';
 import chalk from 'chalk';
-import { success, error, info } from '../utils/helpers.js';
+import { error, info } from '../utils/helpers.js';
 
-export const dbCommand = new Command('db')
-  .description('Database management commands');
+export const dbCommand = new Command('db').description('Database management commands');
 
 dbCommand
   .command('migrate')
@@ -131,7 +130,7 @@ dbCommand
   .action(async () => {
     try {
       execSync('npx prisma migrate status', { stdio: 'inherit' });
-    } catch (err) {
+    } catch {
       error('Failed to get migration status');
     }
   });