servcraft 0.1.7 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "servcraft",
-  "version": "0.1.7",
+  "version": "0.3.1",
   "description": "A modular, production-ready Node.js backend framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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

@@ -16,6 +16,8 @@ import {
 import { EnvManager } from '../utils/env-manager.js';
 import { TemplateManager } from '../utils/template-manager.js';
 import { InteractivePrompt } from '../utils/interactive-prompt.js';
+import { DryRunManager } from '../utils/dry-run.js';
+import { ErrorTypes, displayError, validateProject } from '../utils/error-handler.js';
 
 // Pre-built modules that can be added
 const AVAILABLE_MODULES = {
@@ -160,10 +162,17 @@ export const addModuleCommand = new Command('add')
   .option('-f, --force', 'Force overwrite existing module')
   .option('-u, --update', 'Update existing module (smart merge)')
   .option('--skip-existing', 'Skip if module already exists')
+  .option('--dry-run', 'Preview changes without writing files')
   .action(
     async (
       moduleName?: string,
-      options?: { list?: boolean; force?: boolean; update?: boolean; skipExisting?: boolean }
+      options?: {
+        list?: boolean;
+        force?: boolean;
+        update?: boolean;
+        skipExisting?: boolean;
+        dryRun?: boolean;
+      }
     ) => {
       if (options?.list || !moduleName) {
         console.log(chalk.bold('\n📦 Available Modules:\n'));
@@ -180,11 +189,24 @@ export const addModuleCommand = new Command('add')
         return;
       }
 
+      // Enable dry-run mode if specified
+      const dryRun = DryRunManager.getInstance();
+      if (options?.dryRun) {
+        dryRun.enable();
+        console.log(chalk.yellow('\n⚠ DRY RUN MODE - No files will be written\n'));
+      }
+
       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');
+        displayError(ErrorTypes.MODULE_NOT_FOUND(moduleName));
+        return;
+      }
+
+      // Validate project structure
+      const projectError = validateProject();
+      if (projectError) {
+        displayError(projectError);
         return;
       }
 
@@ -319,10 +341,17 @@ export const addModuleCommand = new Command('add')
           }
         }
 
-        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');
+        if (!options?.dryRun) {
+          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');
+        }
+
+        // Show dry-run summary if enabled
+        if (options?.dryRun) {
+          dryRun.printSummary();
+        }
       } catch (err) {
         spinner.fail('Failed to add module');
         error(err instanceof Error ? err.message : String(err));

package/src/cli/commands/completion.ts

@@ -0,0 +1,146 @@
+/* eslint-disable no-console */
+/* eslint-disable no-useless-escape */
+import { Command } from 'commander';
+
+const bashScript = `
+# servcraft bash completion script
+_servcraft_completions() {
+  local cur prev words cword
+  _init_completion || return
+
+  # Main commands
+  local commands="init add generate list remove doctor update completion docs --version --help"
+
+  # Generate subcommands
+  local generate_subcommands="module controller service repository types schema routes m c s r t"
+
+  case "\${words[1]}" in
+    generate|g)
+      if [[ \${cword} -eq 2 ]]; then
+        COMPREPLY=( \$(compgen -W "\${generate_subcommands}" -- "\${cur}") )
+      fi
+      ;;
+    add|remove|rm|update)
+      if [[ \${cword} -eq 2 ]]; then
+        # Get available modules
+        local modules="auth cache rate-limit notification payment oauth mfa queue websocket upload"
+        COMPREPLY=( \$(compgen -W "\${modules}" -- "\${cur}") )
+      fi
+      ;;
+    completion)
+      if [[ \${cword} -eq 2 ]]; then
+        COMPREPLY=( \$(compgen -W "bash zsh" -- "\${cur}") )
+      fi
+      ;;
+    *)
+      if [[ \${cword} -eq 1 ]]; then
+        COMPREPLY=( \$(compgen -W "\${commands}" -- "\${cur}") )
+      fi
+      ;;
+  esac
+}
+
+complete -F _servcraft_completions servcraft
+`;
+
+const zshScript = `
+#compdef servcraft
+
+_servcraft() {
+  local context state state_descr line
+  typeset -A opt_args
+
+  _arguments -C \\
+    '1: :_servcraft_commands' \\
+    '*::arg:->args'
+
+  case $state in
+    args)
+      case $line[1] in
+        generate|g)
+          _servcraft_generate
+          ;;
+        add|remove|rm|update)
+          _servcraft_modules
+          ;;
+        completion)
+          _arguments '1: :(bash zsh)'
+          ;;
+      esac
+      ;;
+  esac
+}
+
+_servcraft_commands() {
+  local commands
+  commands=(
+    'init:Initialize a new ServCraft project'
+    'add:Add a pre-built module to your project'
+    'generate:Generate code files (controller, service, etc.)'
+    'list:List available and installed modules'
+    'remove:Remove an installed module'
+    'doctor:Diagnose project configuration'
+    'update:Update installed modules'
+    'completion:Generate shell completion scripts'
+    'docs:Open documentation'
+    '--version:Show version'
+    '--help:Show help'
+  )
+  _describe 'command' commands
+}
+
+_servcraft_generate() {
+  local subcommands
+  subcommands=(
+    'module:Generate a complete module (controller + service + routes)'
+    'controller:Generate a controller'
+    'service:Generate a service'
+    'repository:Generate a repository'
+    'types:Generate TypeScript types'
+    'schema:Generate validation schema'
+    'routes:Generate routes file'
+    'm:Alias for module'
+    'c:Alias for controller'
+    's:Alias for service'
+    'r:Alias for repository'
+    't:Alias for types'
+  )
+  _describe 'subcommand' subcommands
+}
+
+_servcraft_modules() {
+  local modules
+  modules=(
+    'auth:Authentication & Authorization'
+    'cache:Redis caching'
+    'rate-limit:Rate limiting'
+    'notification:Email/SMS notifications'
+    'payment:Payment integration'
+    'oauth:OAuth providers'
+    'mfa:Multi-factor authentication'
+    'queue:Background jobs'
+    'websocket:WebSocket support'
+    'upload:File upload handling'
+  )
+  _describe 'module' modules
+}
+
+_servcraft "$@"
+`;
+
+export const completionCommand = new Command('completion')
+  .description('Generate shell completion scripts')
+  .argument('<shell>', 'Shell type (bash or zsh)')
+  .action((shell: string) => {
+    const shellLower = shell.toLowerCase();
+
+    if (shellLower === 'bash') {
+      console.log(bashScript);
+    } else if (shellLower === 'zsh') {
+      console.log(zshScript);
+    } else {
+      console.error(`Unsupported shell: ${shell}`);
+      console.error('Supported shells: bash, zsh');
+      process.exit(1);
+    }
+  });

package/src/cli/commands/doctor.ts

@@ -0,0 +1,123 @@
+/* eslint-disable no-console */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs/promises';
+
+interface Check {
+  name: string;
+  status: 'pass' | 'warn' | 'fail';
+  message: string;
+  suggestion?: string;
+}
+
+async function checkNodeVersion(): Promise<Check> {
+  const version = process.version;
+  const major = parseInt(version.slice(1).split('.')[0] || '0', 10);
+
+  if (major >= 18) {
+    return { name: 'Node.js', status: 'pass', message: `${version} ✓` };
+  }
+  return {
+    name: 'Node.js',
+    status: 'fail',
+    message: `${version} (< 18)`,
+    suggestion: 'Upgrade to Node.js 18+',
+  };
+}
+
+async function checkPackageJson(): Promise<Check[]> {
+  const checks: Check[] = [];
+  try {
+    const content = await fs.readFile('package.json', 'utf-8');
+    const pkg = JSON.parse(content);
+
+    checks.push({ name: 'package.json', status: 'pass', message: 'Found' });
+
+    if (pkg.dependencies?.fastify) {
+      checks.push({ name: 'Fastify', status: 'pass', message: 'Installed' });
+    } else {
+      checks.push({
+        name: 'Fastify',
+        status: 'fail',
+        message: 'Missing',
+        suggestion: 'npm install fastify',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'package.json',
+      status: 'fail',
+      message: 'Not found',
+      suggestion: 'Run servcraft init',
+    });
+  }
+  return checks;
+}
+
+async function checkDirectories(): Promise<Check[]> {
+  const checks: Check[] = [];
+  const dirs = ['src', 'node_modules', '.git', '.env'];
+
+  for (const dir of dirs) {
+    try {
+      await fs.access(dir);
+      checks.push({ name: dir, status: 'pass', message: 'Exists' });
+    } catch {
+      const isCritical = dir === 'src' || dir === 'node_modules';
+      checks.push({
+        name: dir,
+        status: isCritical ? 'fail' : 'warn',
+        message: 'Not found',
+        suggestion:
+          dir === 'node_modules' ? 'npm install' : dir === '.env' ? 'Create .env file' : undefined,
+      });
+    }
+  }
+  return checks;
+}
+
+export const doctorCommand = new Command('doctor')
+  .description('Diagnose project configuration and dependencies')
+  .action(async () => {
+    console.log(chalk.bold.cyan('\n🔍 ServCraft Doctor\n'));
+
+    const allChecks: Check[] = [];
+
+    allChecks.push(await checkNodeVersion());
+    allChecks.push(...(await checkPackageJson()));
+    allChecks.push(...(await checkDirectories()));
+
+    // Display results
+    allChecks.forEach((check) => {
+      const icon =
+        check.status === 'pass'
+          ? chalk.green('✓')
+          : check.status === 'warn'
+            ? chalk.yellow('⚠')
+            : chalk.red('✗');
+      const color =
+        check.status === 'pass' ? chalk.green : check.status === 'warn' ? chalk.yellow : chalk.red;
+
+      console.log(`${icon} ${check.name.padEnd(20)} ${color(check.message)}`);
+      if (check.suggestion) {
+        console.log(chalk.gray(`   → ${check.suggestion}`));
+      }
+    });
+
+    const pass = allChecks.filter((c) => c.status === 'pass').length;
+    const warn = allChecks.filter((c) => c.status === 'warn').length;
+    const fail = allChecks.filter((c) => c.status === 'fail').length;
+
+    console.log(chalk.gray('\n' + '─'.repeat(60)));
+    console.log(
+      `\n${chalk.green(pass + ' passed')} | ${chalk.yellow(warn + ' warnings')} | ${chalk.red(fail + ' failed')}\n`
+    );
+
+    if (fail === 0 && warn === 0) {
+      console.log(chalk.green.bold('✨ Everything looks good!\n'));
+    } else if (fail > 0) {
+      console.log(chalk.red.bold('✗ Fix critical issues before using ServCraft.\n'));
+    } else {
+      console.log(chalk.yellow.bold('⚠ Some warnings, but should work.\n'));
+    }
+  });

package/src/cli/commands/generate.ts

@@ -14,7 +14,26 @@ import {
   info,
   getModulesDir,
 } from '../utils/helpers.js';
+import { DryRunManager } from '../utils/dry-run.js';
+import chalk from 'chalk';
 import { parseFields, type FieldDefinition } from '../utils/field-parser.js';
+import { ErrorTypes, displayError } from '../utils/error-handler.js';
+
+// Helper to enable dry-run mode
+function enableDryRunIfNeeded(options: { dryRun?: boolean }): void {
+  const dryRun = DryRunManager.getInstance();
+  if (options.dryRun) {
+    dryRun.enable();
+    console.log(chalk.yellow('\n⚠ DRY RUN MODE - No files will be written\n'));
+  }
+}
+
+// Helper to show dry-run summary
+function showDryRunSummary(options: { dryRun?: boolean }): void {
+  if (options.dryRun) {
+    DryRunManager.getInstance().printSummary();
+  }
+}
 import { controllerTemplate } from '../templates/controller.js';
 import { serviceTemplate } from '../templates/service.js';
 import { repositoryTemplate } from '../templates/repository.js';
@@ -26,6 +45,9 @@ import { prismaModelTemplate } from '../templates/prisma-model.js';
 import { dynamicTypesTemplate } from '../templates/dynamic-types.js';
 import { dynamicSchemasTemplate, type ValidatorType } from '../templates/dynamic-schemas.js';
 import { dynamicPrismaTemplate } from '../templates/dynamic-prisma.js';
+import { controllerTestTemplate } from '../templates/controller-test.js';
+import { serviceTestTemplate } from '../templates/service-test.js';
+import { integrationTestTemplate } from '../templates/integration-test.js';
 
 export const generateCommand = new Command('generate')
   .alias('g')
@@ -43,7 +65,10 @@ generateCommand
   .option('--prisma', 'Generate Prisma model suggestion')
   .option('--validator <type>', 'Validator type: zod, joi, yup', 'zod')
   .option('-i, --interactive', 'Interactive mode to define fields')
+  .option('--with-tests', 'Generate test files (__tests__ directory)')
+  .option('--dry-run', 'Preview changes without writing files')
   .action(async (name: string, fieldsArgs: string[], options) => {
+    enableDryRunIfNeeded(options);
     let fields: FieldDefinition[] = [];
 
     // Parse fields from command line or interactive mode
@@ -118,6 +143,26 @@ generateCommand
         await writeFile(path.join(moduleDir, file.name), file.content);
       }
 
+      // Generate test files if --with-tests flag is provided
+      if (options.withTests) {
+        const testDir = path.join(moduleDir, '__tests__');
+
+        await writeFile(
+          path.join(testDir, `${kebabName}.controller.test.ts`),
+          controllerTestTemplate(kebabName, pascalName, camelName)
+        );
+
+        await writeFile(
+          path.join(testDir, `${kebabName}.service.test.ts`),
+          serviceTestTemplate(kebabName, pascalName, camelName)
+        );
+
+        await writeFile(
+          path.join(testDir, `${kebabName}.integration.test.ts`),
+          integrationTestTemplate(kebabName, pascalName, camelName)
+        );
+      }
+
       spinner.succeed(`Module "${pascalName}" generated successfully!`);
 
       // Show Prisma model if requested or fields provided
@@ -148,6 +193,12 @@ generateCommand
       console.log('\n📁 Files created:');
       files.forEach((f) => success(`  src/modules/${kebabName}/${f.name}`));
 
+      if (options.withTests) {
+        success(`  src/modules/${kebabName}/__tests__/${kebabName}.controller.test.ts`);
+        success(`  src/modules/${kebabName}/__tests__/${kebabName}.service.test.ts`);
+        success(`  src/modules/${kebabName}/__tests__/${kebabName}.integration.test.ts`);
+      }
+
       console.log('\n📌 Next steps:');
       if (!hasFields) {
         info('  1. Update the types in ' + `${kebabName}.types.ts`);
@@ -161,6 +212,9 @@ generateCommand
         info(`  ${hasFields ? '3' : '4'}. Add the Prisma model to schema.prisma`);
         info(`  ${hasFields ? '4' : '5'}. Run: npm run db:migrate`);
       }
+
+      // Show dry-run summary if enabled
+      showDryRunSummary(options);
     } catch (err) {
       spinner.fail('Failed to generate module');
       error(err instanceof Error ? err.message : String(err));
@@ -173,7 +227,9 @@ generateCommand
   .alias('c')
   .description('Generate a controller')
   .option('-m, --module <module>', 'Target module name')
+  .option('--dry-run', 'Preview changes without writing files')
   .action(async (name: string, options) => {
+    enableDryRunIfNeeded(options);
     const spinner = ora('Generating controller...').start();
 
     try {
@@ -187,7 +243,7 @@ generateCommand
 
       if (await fileExists(filePath)) {
         spinner.stop();
-        error(`Controller "${kebabName}" already exists`);
+        displayError(ErrorTypes.FILE_ALREADY_EXISTS(`${kebabName}.controller.ts`));
         return;
       }
 
@@ -195,6 +251,7 @@ generateCommand
 
       spinner.succeed(`Controller "${pascalName}Controller" generated!`);
       success(`  src/modules/${moduleName}/${kebabName}.controller.ts`);
+      showDryRunSummary(options);
     } catch (err) {
       spinner.fail('Failed to generate controller');
       error(err instanceof Error ? err.message : String(err));
@@ -207,7 +264,9 @@ generateCommand
   .alias('s')
   .description('Generate a service')
   .option('-m, --module <module>', 'Target module name')
+  .option('--dry-run', 'Preview changes without writing files')
   .action(async (name: string, options) => {
+    enableDryRunIfNeeded(options);
     const spinner = ora('Generating service...').start();
 
     try {
@@ -229,6 +288,7 @@ generateCommand
 
       spinner.succeed(`Service "${pascalName}Service" generated!`);
       success(`  src/modules/${moduleName}/${kebabName}.service.ts`);
+      showDryRunSummary(options);
     } catch (err) {
       spinner.fail('Failed to generate service');
       error(err instanceof Error ? err.message : String(err));
@@ -241,7 +301,9 @@ generateCommand
   .alias('r')
   .description('Generate a repository')
   .option('-m, --module <module>', 'Target module name')
+  .option('--dry-run', 'Preview changes without writing files')
   .action(async (name: string, options) => {
+    enableDryRunIfNeeded(options);
     const spinner = ora('Generating repository...').start();
 
     try {
@@ -264,6 +326,7 @@ generateCommand
 
       spinner.succeed(`Repository "${pascalName}Repository" generated!`);
       success(`  src/modules/${moduleName}/${kebabName}.repository.ts`);
+      showDryRunSummary(options);
     } catch (err) {
       spinner.fail('Failed to generate repository');
       error(err instanceof Error ? err.message : String(err));
@@ -276,7 +339,9 @@ generateCommand
   .alias('t')
   .description('Generate types/interfaces')
   .option('-m, --module <module>', 'Target module name')
+  .option('--dry-run', 'Preview changes without writing files')
   .action(async (name: string, options) => {
+    enableDryRunIfNeeded(options);
     const spinner = ora('Generating types...').start();
 
     try {
@@ -297,6 +362,7 @@ generateCommand
 
       spinner.succeed(`Types for "${pascalName}" generated!`);
       success(`  src/modules/${moduleName}/${kebabName}.types.ts`);
+      showDryRunSummary(options);
     } catch (err) {
       spinner.fail('Failed to generate types');
       error(err instanceof Error ? err.message : String(err));
@@ -309,7 +375,9 @@ generateCommand
   .alias('v')
   .description('Generate validation schemas')
   .option('-m, --module <module>', 'Target module name')
+  .option('--dry-run', 'Preview changes without writing files')
   .action(async (name: string, options) => {
+    enableDryRunIfNeeded(options);
     const spinner = ora('Generating schemas...').start();
 
     try {
@@ -331,6 +399,7 @@ generateCommand
 
       spinner.succeed(`Schemas for "${pascalName}" generated!`);
       success(`  src/modules/${moduleName}/${kebabName}.schemas.ts`);
+      showDryRunSummary(options);
     } catch (err) {
       spinner.fail('Failed to generate schemas');
       error(err instanceof Error ? err.message : String(err));
@@ -342,7 +411,9 @@ generateCommand
   .command('routes <name>')
   .description('Generate routes')
   .option('-m, --module <module>', 'Target module name')
+  .option('--dry-run', 'Preview changes without writing files')
   .action(async (name: string, options) => {
+    enableDryRunIfNeeded(options);
     const spinner = ora('Generating routes...').start();
 
     try {
@@ -365,6 +436,7 @@ generateCommand
 
       spinner.succeed(`Routes for "${pascalName}" generated!`);
       success(`  src/modules/${moduleName}/${kebabName}.routes.ts`);
+      showDryRunSummary(options);
     } catch (err) {
       spinner.fail('Failed to generate routes');
       error(err instanceof Error ? err.message : String(err));

package/src/cli/commands/init.ts

@@ -6,6 +6,7 @@ import inquirer from 'inquirer';
 import chalk from 'chalk';
 import { execSync } from 'child_process';
 import { ensureDir, writeFile, error, warn } from '../utils/helpers.js';
+import { DryRunManager } from '../utils/dry-run.js';
 
 interface InitOptions {
   name: string;
@@ -27,6 +28,7 @@ export const initCommand = new Command('init')
   .option('--esm', 'Use ES Modules (import/export) - default')
   .option('--cjs, --commonjs', 'Use CommonJS (require/module.exports)')
   .option('--db <database>', 'Database type (postgresql, mysql, sqlite, mongodb, none)')
+  .option('--dry-run', 'Preview changes without writing files')
   .action(
     async (
       name?: string,
@@ -37,8 +39,16 @@ export const initCommand = new Command('init')
         esm?: boolean;
         commonjs?: boolean;
         db?: string;
+        dryRun?: boolean;
       }
     ) => {
+      // Enable dry-run mode if specified
+      const dryRun = DryRunManager.getInstance();
+      if (cmdOptions?.dryRun) {
+        dryRun.enable();
+        console.log(chalk.yellow('\n⚠ DRY RUN MODE - No files will be written\n'));
+      }
+
       console.log(
         chalk.blue(`
 ╔═══════════════════════════════════════════╗
@@ -274,19 +284,23 @@ export const initCommand = new Command('init')
 
         spinner.succeed('Project files generated!');
 
-        // Install dependencies
-        const installSpinner = ora('Installing dependencies...').start();
-
-        try {
-          execSync('npm install', { cwd: projectDir, stdio: 'pipe' });
-          installSpinner.succeed('Dependencies installed!');
-        } catch {
-          installSpinner.warn('Failed to install dependencies automatically');
-          warn('  Run "npm install" manually in the project directory');
+        // Install dependencies (skip in dry-run mode)
+        if (!cmdOptions?.dryRun) {
+          const installSpinner = ora('Installing dependencies...').start();
+
+          try {
+            execSync('npm install', { cwd: projectDir, stdio: 'pipe' });
+            installSpinner.succeed('Dependencies installed!');
+          } catch {
+            installSpinner.warn('Failed to install dependencies automatically');
+            warn('  Run "npm install" manually in the project directory');
+          }
         }
 
         // Print success message
-        console.log('\n' + chalk.green('✨ Project created successfully!'));
+        if (!cmdOptions?.dryRun) {
+          console.log('\n' + chalk.green('✨ Project created successfully!'));
+        }
         console.log('\n' + chalk.bold('📁 Project structure:'));
         console.log(`
   ${options.name}/
@@ -317,6 +331,11 @@ export const initCommand = new Command('init')
   ${chalk.yellow('servcraft generate service <name>')}    Generate a service
   ${chalk.yellow('servcraft add auth')}                   Add authentication module
 `);
+
+        // Show dry-run summary if enabled
+        if (cmdOptions?.dryRun) {
+          dryRun.printSummary();
+        }
       } catch (err) {
         spinner.fail('Failed to create project');
         error(err instanceof Error ? err.message : String(err));