servcraft 0.1.7 → 0.2.0

package/src/cli/commands/remove.ts

@@ -0,0 +1,102 @@
+/* eslint-disable no-console */
+import { Command } from 'commander';
+import path from 'path';
+import ora from 'ora';
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import inquirer from 'inquirer';
+import { getModulesDir, success, error, info } from '../utils/helpers.js';
+import { ServCraftError, displayError, validateProject } from '../utils/error-handler.js';
+
+export const removeCommand = new Command('remove')
+  .alias('rm')
+  .description('Remove an installed module from your project')
+  .argument('<module>', 'Module to remove')
+  .option('-y, --yes', 'Skip confirmation prompt')
+  .option('--keep-env', 'Keep environment variables')
+  .action(async (moduleName: string, options?: { yes?: boolean; keepEnv?: boolean }) => {
+    // Validate project
+    const projectError = validateProject();
+    if (projectError) {
+      displayError(projectError);
+      return;
+    }
+
+    console.log(chalk.bold.cyan('\n🗑️  ServCraft Module Removal\n'));
+
+    const moduleDir = path.join(getModulesDir(), moduleName);
+
+    try {
+      // Check if module exists
+      const exists = await fs
+        .access(moduleDir)
+        .then(() => true)
+        .catch(() => false);
+
+      if (!exists) {
+        displayError(
+          new ServCraftError(`Module "${moduleName}" is not installed`, [
+            `Run ${chalk.cyan('servcraft list --installed')} to see installed modules`,
+            `Check the spelling of the module name`,
+          ])
+        );
+        return;
+      }
+
+      // Get list of files
+      const files = await fs.readdir(moduleDir);
+      const fileCount = files.length;
+
+      // Confirm removal
+      if (!options?.yes) {
+        console.log(chalk.yellow(`⚠  This will remove the "${moduleName}" module:`));
+        console.log(chalk.gray(`   Directory: ${moduleDir}`));
+        console.log(chalk.gray(`   Files: ${fileCount} file(s)`));
+        console.log();
+
+        const { confirm } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Are you sure you want to remove this module?',
+            default: false,
+          },
+        ]);
+
+        if (!confirm) {
+          console.log(chalk.yellow('\n✖ Removal cancelled\n'));
+          return;
+        }
+      }
+
+      const spinner = ora('Removing module...').start();
+
+      // Remove module directory
+      await fs.rm(moduleDir, { recursive: true, force: true });
+
+      spinner.succeed(`Module "${moduleName}" removed successfully!`);
+
+      // Show what was removed
+      console.log('\n' + chalk.bold('✓ Removed:'));
+      success(`  src/modules/${moduleName}/ (${fileCount} files)`);
+
+      // Instructions for cleanup
+      if (!options?.keepEnv) {
+        console.log('\n' + chalk.bold('📌 Manual cleanup needed:'));
+        info('  1. Remove environment variables related to this module from .env');
+        info('  2. Remove module imports from your main app file');
+        info('  3. Remove related database migrations if any');
+        info('  4. Update your routes if they reference this module');
+      } else {
+        console.log('\n' + chalk.bold('📌 Manual cleanup needed:'));
+        info('  1. Environment variables were kept (--keep-env flag)');
+        info('  2. Remove module imports from your main app file');
+        info('  3. Update your routes if they reference this module');
+      }
+
+      console.log();
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      console.log();
+    }
+  });

package/src/cli/index.ts

@@ -6,6 +6,9 @@ import { generateCommand } from './commands/generate.js';
 import { addModuleCommand } from './commands/add-module.js';
 import { dbCommand } from './commands/db.js';
 import { docsCommand } from './commands/docs.js';
+import { listCommand } from './commands/list.js';
+import { removeCommand } from './commands/remove.js';
+import { doctorCommand } from './commands/doctor.js';
 
 const program = new Command();
 
@@ -29,4 +32,13 @@ program.addCommand(dbCommand);
 // Documentation commands
 program.addCommand(docsCommand);
 
+// List modules
+program.addCommand(listCommand);
+
+// Remove module
+program.addCommand(removeCommand);
+
+// Diagnose project
+program.addCommand(doctorCommand);
+
 program.parse();

package/src/cli/utils/dry-run.ts

@@ -0,0 +1,155 @@
+/* eslint-disable no-console */
+import chalk from 'chalk';
+import path from 'path';
+
+export interface FileOperation {
+  type: 'create' | 'modify' | 'delete';
+  path: string;
+  content?: string;
+  size?: number;
+}
+
+export class DryRunManager {
+  private static instance: DryRunManager;
+  private enabled = false;
+  private operations: FileOperation[] = [];
+
+  private constructor() {}
+
+  static getInstance(): DryRunManager {
+    if (!DryRunManager.instance) {
+      DryRunManager.instance = new DryRunManager();
+    }
+    return DryRunManager.instance;
+  }
+
+  enable(): void {
+    this.enabled = true;
+    this.operations = [];
+  }
+
+  disable(): void {
+    this.enabled = false;
+    this.operations = [];
+  }
+
+  isEnabled(): boolean {
+    return this.enabled;
+  }
+
+  addOperation(operation: FileOperation): void {
+    if (this.enabled) {
+      this.operations.push(operation);
+    }
+  }
+
+  getOperations(): FileOperation[] {
+    return [...this.operations];
+  }
+
+  printSummary(): void {
+    if (!this.enabled || this.operations.length === 0) {
+      return;
+    }
+
+    console.log(chalk.bold.yellow('\n📋 Dry Run - Preview of changes:\n'));
+    console.log(chalk.gray('No files will be written. Remove --dry-run to apply changes.\n'));
+
+    const createOps = this.operations.filter((op) => op.type === 'create');
+    const modifyOps = this.operations.filter((op) => op.type === 'modify');
+    const deleteOps = this.operations.filter((op) => op.type === 'delete');
+
+    if (createOps.length > 0) {
+      console.log(chalk.green.bold(`\n✓ Files to be created (${createOps.length}):`));
+      createOps.forEach((op) => {
+        const size = op.content ? `${op.content.length} bytes` : 'unknown size';
+        console.log(`  ${chalk.green('+')} ${chalk.cyan(op.path)} ${chalk.gray(`(${size})`)}`);
+      });
+    }
+
+    if (modifyOps.length > 0) {
+      console.log(chalk.yellow.bold(`\n~ Files to be modified (${modifyOps.length}):`));
+      modifyOps.forEach((op) => {
+        console.log(`  ${chalk.yellow('~')} ${chalk.cyan(op.path)}`);
+      });
+    }
+
+    if (deleteOps.length > 0) {
+      console.log(chalk.red.bold(`\n- Files to be deleted (${deleteOps.length}):`));
+      deleteOps.forEach((op) => {
+        console.log(`  ${chalk.red('-')} ${chalk.cyan(op.path)}`);
+      });
+    }
+
+    console.log(chalk.gray('\n' + '─'.repeat(60)));
+    console.log(
+      chalk.bold(`  Total operations: ${this.operations.length}`) +
+        chalk.gray(
+          ` (${createOps.length} create, ${modifyOps.length} modify, ${deleteOps.length} delete)`
+        )
+    );
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.yellow('\n⚠ This was a dry run. No files were created or modified.'));
+    console.log(chalk.gray('  Remove --dry-run to apply these changes.\n'));
+  }
+
+  // Helper to format file path relative to cwd
+  relativePath(filePath: string): string {
+    return path.relative(process.cwd(), filePath);
+  }
+}
+
+// Wrapper functions for file operations
+export async function dryRunWriteFile(
+  filePath: string,
+  content: string,
+  actualWriteFn: (path: string, content: string) => Promise<void>
+): Promise<void> {
+  const dryRun = DryRunManager.getInstance();
+
+  if (dryRun.isEnabled()) {
+    dryRun.addOperation({
+      type: 'create',
+      path: dryRun.relativePath(filePath),
+      content,
+      size: content.length,
+    });
+    return;
+  }
+
+  await actualWriteFn(filePath, content);
+}
+
+export async function dryRunModifyFile(
+  filePath: string,
+  actualModifyFn: (path: string) => Promise<void>
+): Promise<void> {
+  const dryRun = DryRunManager.getInstance();
+
+  if (dryRun.isEnabled()) {
+    dryRun.addOperation({
+      type: 'modify',
+      path: dryRun.relativePath(filePath),
+    });
+    return;
+  }
+
+  await actualModifyFn(filePath);
+}
+
+export async function dryRunDeleteFile(
+  filePath: string,
+  actualDeleteFn: (path: string) => Promise<void>
+): Promise<void> {
+  const dryRun = DryRunManager.getInstance();
+
+  if (dryRun.isEnabled()) {
+    dryRun.addOperation({
+      type: 'delete',
+      path: dryRun.relativePath(filePath),
+    });
+    return;
+  }
+
+  await actualDeleteFn(filePath);
+}

package/src/cli/utils/error-handler.ts

@@ -0,0 +1,184 @@
+/* eslint-disable no-console */
+import chalk from 'chalk';
+
+export interface ErrorSuggestion {
+  message: string;
+  suggestions: string[];
+  docsLink?: string;
+}
+
+export class ServCraftError extends Error {
+  suggestions: string[];
+  docsLink?: string;
+
+  constructor(message: string, suggestions: string[] = [], docsLink?: string) {
+    super(message);
+    this.name = 'ServCraftError';
+    this.suggestions = suggestions;
+    this.docsLink = docsLink;
+  }
+}
+
+// Common error types with suggestions
+export const ErrorTypes = {
+  MODULE_NOT_FOUND: (moduleName: string): ServCraftError =>
+    new ServCraftError(
+      `Module "${moduleName}" not found`,
+      [
+        `Run ${chalk.cyan('servcraft list')} to see available modules`,
+        `Check the spelling of the module name`,
+        `Visit ${chalk.blue('https://github.com/Le-Sourcier/servcraft#modules')} for module list`,
+      ],
+      'https://github.com/Le-Sourcier/servcraft#add-pre-built-modules'
+    ),
+
+  MODULE_ALREADY_EXISTS: (moduleName: string): ServCraftError =>
+    new ServCraftError(`Module "${moduleName}" already exists`, [
+      `Use ${chalk.cyan('servcraft add ' + moduleName + ' --force')} to overwrite`,
+      `Use ${chalk.cyan('servcraft add ' + moduleName + ' --update')} to update`,
+      `Use ${chalk.cyan('servcraft add ' + moduleName + ' --skip-existing')} to skip`,
+    ]),
+
+  NOT_IN_PROJECT: (): ServCraftError =>
+    new ServCraftError(
+      'Not in a ServCraft project directory',
+      [
+        `Run ${chalk.cyan('servcraft init')} to create a new project`,
+        `Navigate to your ServCraft project directory`,
+        `Check if ${chalk.yellow('package.json')} exists`,
+      ],
+      'https://github.com/Le-Sourcier/servcraft#initialize-project'
+    ),
+
+  FILE_ALREADY_EXISTS: (fileName: string): ServCraftError =>
+    new ServCraftError(`File "${fileName}" already exists`, [
+      `Use ${chalk.cyan('--force')} flag to overwrite`,
+      `Choose a different name`,
+      `Delete the existing file first`,
+    ]),
+
+  INVALID_DATABASE: (database: string): ServCraftError =>
+    new ServCraftError(`Invalid database type: "${database}"`, [
+      `Valid options: ${chalk.cyan('postgresql, mysql, sqlite, mongodb, none')}`,
+      `Use ${chalk.cyan('servcraft init --db postgresql')} for PostgreSQL`,
+    ]),
+
+  INVALID_VALIDATOR: (validator: string): ServCraftError =>
+    new ServCraftError(`Invalid validator type: "${validator}"`, [
+      `Valid options: ${chalk.cyan('zod, joi, yup')}`,
+      `Default is ${chalk.cyan('zod')}`,
+    ]),
+
+  MISSING_DEPENDENCY: (dependency: string, command: string): ServCraftError =>
+    new ServCraftError(`Missing dependency: "${dependency}"`, [
+      `Run ${chalk.cyan(command)} to install`,
+      `Check your ${chalk.yellow('package.json')}`,
+    ]),
+
+  INVALID_FIELD_FORMAT: (field: string): ServCraftError =>
+    new ServCraftError(`Invalid field format: "${field}"`, [
+      `Expected format: ${chalk.cyan('name:type')}`,
+      `Example: ${chalk.cyan('name:string age:number isActive:boolean')}`,
+      `Supported types: string, number, boolean, date`,
+    ]),
+
+  GIT_NOT_INITIALIZED: (): ServCraftError =>
+    new ServCraftError('Git repository not initialized', [
+      `Run ${chalk.cyan('git init')} to initialize git`,
+      `This is required for some ServCraft features`,
+    ]),
+};
+
+// Display error with suggestions
+export function displayError(error: Error | ServCraftError): void {
+  console.error('\n' + chalk.red.bold('✗ Error: ') + chalk.red(error.message));
+
+  if (error instanceof ServCraftError) {
+    if (error.suggestions.length > 0) {
+      console.log('\n' + chalk.yellow.bold('💡 Suggestions:'));
+      error.suggestions.forEach((suggestion) => {
+        console.log(chalk.yellow('  • ') + suggestion);
+      });
+    }
+
+    if (error.docsLink) {
+      console.log(
+        '\n' + chalk.blue.bold('📚 Documentation: ') + chalk.blue.underline(error.docsLink)
+      );
+    }
+  }
+
+  console.log(); // Empty line for spacing
+}
+
+// Handle common Node.js errors
+export function handleSystemError(err: NodeJS.ErrnoException): ServCraftError {
+  switch (err.code) {
+    case 'ENOENT':
+      return new ServCraftError(`File or directory not found: ${err.path}`, [
+        `Check if the path exists`,
+        `Create the directory first`,
+      ]);
+
+    case 'EACCES':
+    case 'EPERM':
+      return new ServCraftError(`Permission denied: ${err.path}`, [
+        `Check file permissions`,
+        `Try running with elevated privileges (not recommended)`,
+        `Change ownership of the directory`,
+      ]);
+
+    case 'EEXIST':
+      return new ServCraftError(`File or directory already exists: ${err.path}`, [
+        `Use a different name`,
+        `Remove the existing file first`,
+        `Use ${chalk.cyan('--force')} to overwrite`,
+      ]);
+
+    case 'ENOTDIR':
+      return new ServCraftError(`Not a directory: ${err.path}`, [
+        `Check the path`,
+        `A file exists where a directory is expected`,
+      ]);
+
+    case 'EISDIR':
+      return new ServCraftError(`Is a directory: ${err.path}`, [
+        `Cannot perform this operation on a directory`,
+        `Did you mean to target a file?`,
+      ]);
+
+    default:
+      return new ServCraftError(err.message, [
+        `Check system error code: ${err.code}`,
+        `Review the error details above`,
+      ]);
+  }
+}
+
+// Validate project structure
+export function validateProject(): ServCraftError | null {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const fs = require('fs');
+
+    if (!fs.existsSync('package.json')) {
+      return ErrorTypes.NOT_IN_PROJECT();
+    }
+
+    const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf-8'));
+
+    if (!packageJson.dependencies?.fastify) {
+      return new ServCraftError('This does not appear to be a ServCraft project', [
+        `ServCraft projects require Fastify`,
+        `Run ${chalk.cyan('servcraft init')} to create a new project`,
+      ]);
+    }
+
+    return null;
+  } catch {
+    return new ServCraftError('Failed to validate project', [
+      `Ensure you are in the project root directory`,
+      `Check if ${chalk.yellow('package.json')} is valid`,
+    ]);
+  }
+}

package/src/cli/utils/helpers.ts

@@ -1,6 +1,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import chalk from 'chalk';
+import { DryRunManager } from './dry-run.js';
 
 export function toPascalCase(str: string): string {
   return str
@@ -52,6 +53,18 @@ export async function ensureDir(dirPath: string): Promise<void> {
 }
 
 export async function writeFile(filePath: string, content: string): Promise<void> {
+  const dryRun = DryRunManager.getInstance();
+
+  if (dryRun.isEnabled()) {
+    dryRun.addOperation({
+      type: 'create',
+      path: dryRun.relativePath(filePath),
+      content,
+      size: content.length,
+    });
+    return;
+  }
+
   await ensureDir(path.dirname(filePath));
   await fs.writeFile(filePath, content, 'utf-8');
 }