servcraft 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "servcraft",
-  "version": "0.2.0",
+  "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/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

@@ -1,8 +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('\nServCraft Doctor - Coming soon!\n'));
+    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

@@ -45,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')
@@ -62,6 +65,7 @@ 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);
@@ -139,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
@@ -169,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`);

package/src/cli/commands/list.ts

@@ -193,7 +193,7 @@ export const listCommand = new Command('list')
           byCategory[mod.category] = [];
         }
 
-        byCategory[mod.category].push({
+        byCategory[mod.category]?.push({
           id: key,
           name: mod.name,
           description: mod.description,

package/src/cli/commands/update.ts

@@ -0,0 +1,221 @@
+/* eslint-disable no-console */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import inquirer from 'inquirer';
+import { getProjectRoot, getModulesDir } from '../utils/helpers.js';
+import { validateProject, displayError } from '../utils/error-handler.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Get list of available modules (same as list.ts)
+const AVAILABLE_MODULES = [
+  'auth',
+  'users',
+  'email',
+  'mfa',
+  'oauth',
+  'rate-limit',
+  'cache',
+  'upload',
+  'search',
+  'notification',
+  'webhook',
+  'websocket',
+  'queue',
+  'payment',
+  'i18n',
+  'feature-flag',
+  'analytics',
+  'media-processing',
+  'api-versioning',
+  'audit',
+  'swagger',
+  'validation',
+];
+
+async function getInstalledModules(): Promise<string[]> {
+  try {
+    const modulesDir = getModulesDir();
+
+    const entries = await fs.readdir(modulesDir, { withFileTypes: true });
+    const installedModules = entries
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .filter((name) => AVAILABLE_MODULES.includes(name));
+
+    return installedModules;
+  } catch {
+    return [];
+  }
+}
+
+async function copyModuleFiles(moduleName: string, _projectRoot: string): Promise<void> {
+  const cliRoot = path.resolve(__dirname, '../../../');
+  const sourceModulePath = path.join(cliRoot, 'src', 'modules', moduleName);
+  const targetModulesDir = getModulesDir();
+  const targetModulePath = path.join(targetModulesDir, moduleName);
+
+  // Check if source module exists
+  try {
+    await fs.access(sourceModulePath);
+  } catch {
+    throw new Error(`Module source not found: ${moduleName}`);
+  }
+
+  // Copy module files
+  await fs.cp(sourceModulePath, targetModulePath, { recursive: true });
+}
+
+async function updateModule(moduleName: string, options: { check?: boolean }): Promise<void> {
+  const projectError = validateProject();
+  if (projectError) {
+    displayError(projectError);
+    return;
+  }
+
+  const projectRoot = getProjectRoot();
+  const installedModules = await getInstalledModules();
+
+  if (!installedModules.includes(moduleName)) {
+    console.log(chalk.yellow(`\n⚠ Module "${moduleName}" is not installed\n`));
+    console.log(
+      chalk.gray(`Run ${chalk.cyan(`servcraft add ${moduleName}`)} to install it first.\n`)
+    );
+    return;
+  }
+
+  if (options.check) {
+    console.log(chalk.cyan(`\n📦 Checking updates for "${moduleName}"...\n`));
+    console.log(chalk.gray('Note: Version tracking will be implemented in a future release.'));
+    console.log(chalk.gray('Currently, update will always reinstall the latest version.\n'));
+    return;
+  }
+
+  // Confirm update
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message: `Update "${moduleName}" module? This will overwrite existing files.`,
+      default: false,
+    },
+  ]);
+
+  if (!confirmed) {
+    console.log(chalk.yellow('\n⚠ Update cancelled\n'));
+    return;
+  }
+
+  console.log(chalk.cyan(`\n🔄 Updating "${moduleName}" module...\n`));
+
+  try {
+    await copyModuleFiles(moduleName, projectRoot);
+    console.log(chalk.green(`✔ Module "${moduleName}" updated successfully!\n`));
+    console.log(
+      chalk.gray('Note: Remember to review any breaking changes in the documentation.\n')
+    );
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk.red(`\n✗ Failed to update module: ${error.message}\n`));
+    }
+  }
+}
+
+async function updateAllModules(options: { check?: boolean }): Promise<void> {
+  const projectError = validateProject();
+  if (projectError) {
+    displayError(projectError);
+    return;
+  }
+
+  const installedModules = await getInstalledModules();
+
+  if (installedModules.length === 0) {
+    console.log(chalk.yellow('\n⚠ No modules installed\n'));
+    console.log(chalk.gray(`Run ${chalk.cyan('servcraft list')} to see available modules.\n`));
+    return;
+  }
+
+  if (options.check) {
+    console.log(chalk.cyan('\n📦 Checking updates for all modules...\n'));
+    console.log(chalk.bold('Installed modules:'));
+    installedModules.forEach((mod) => {
+      console.log(`  • ${chalk.cyan(mod)}`);
+    });
+    console.log();
+    console.log(chalk.gray('Note: Version tracking will be implemented in a future release.'));
+    console.log(chalk.gray('Currently, update will always reinstall the latest version.\n'));
+    return;
+  }
+
+  console.log(chalk.cyan(`\n📦 Found ${installedModules.length} installed module(s):\n`));
+  installedModules.forEach((mod) => {
+    console.log(`  • ${chalk.cyan(mod)}`);
+  });
+  console.log();
+
+  // Confirm update all
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message: 'Update all modules? This will overwrite existing files.',
+      default: false,
+    },
+  ]);
+
+  if (!confirmed) {
+    console.log(chalk.yellow('\n⚠ Update cancelled\n'));
+    return;
+  }
+
+  console.log(chalk.cyan('\n🔄 Updating all modules...\n'));
+
+  const projectRoot = getProjectRoot();
+  let successCount = 0;
+  let failCount = 0;
+
+  for (const moduleName of installedModules) {
+    try {
+      await copyModuleFiles(moduleName, projectRoot);
+      console.log(chalk.green(`✔ Updated: ${moduleName}`));
+      successCount++;
+    } catch {
+      console.error(chalk.red(`✗ Failed: ${moduleName}`));
+      failCount++;
+    }
+  }
+
+  console.log();
+  console.log(
+    chalk.bold(
+      `\n✔ Update complete: ${chalk.green(successCount)} succeeded, ${chalk.red(failCount)} failed\n`
+    )
+  );
+
+  if (successCount > 0) {
+    console.log(
+      chalk.gray('Note: Remember to review any breaking changes in the documentation.\n')
+    );
+  }
+}
+
+export const updateCommand = new Command('update')
+  .description('Update installed modules to latest version')
+  .argument('[module]', 'Specific module to update')
+  .option('--check', 'Check for updates without applying')
+  .option('-y, --yes', 'Skip confirmation prompt')
+  .action(async (moduleName?: string, options?: { check?: boolean; yes?: boolean }) => {
+    // If --yes flag is provided, we'll handle it by auto-confirming in the inquirer prompts
+    // For now, we'll just pass through to the update functions
+
+    if (moduleName) {
+      await updateModule(moduleName, { check: options?.check });
+    } else {
+      await updateAllModules({ check: options?.check });
+    }
+  });

package/src/cli/index.ts

@@ -9,6 +9,8 @@ import { docsCommand } from './commands/docs.js';
 import { listCommand } from './commands/list.js';
 import { removeCommand } from './commands/remove.js';
 import { doctorCommand } from './commands/doctor.js';
+import { updateCommand } from './commands/update.js';
+import { completionCommand } from './commands/completion.js';
 
 const program = new Command();
 
@@ -41,4 +43,10 @@ program.addCommand(removeCommand);
 // Diagnose project
 program.addCommand(doctorCommand);
 
+// Update modules
+program.addCommand(updateCommand);
+
+// Shell completion
+program.addCommand(completionCommand);
+
 program.parse();

package/src/cli/templates/controller-test.ts

@@ -0,0 +1,110 @@
+export function controllerTestTemplate(
+  name: string,
+  pascalName: string,
+  camelName: string
+): string {
+  return `import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { build } from '../../app.js';
+import { FastifyInstance } from 'fastify';
+
+describe('${pascalName}Controller', () => {
+  let app: FastifyInstance;
+
+  beforeAll(async () => {
+    app = await build();
+    await app.ready();
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  describe('GET /${name}', () => {
+    it('should return list of ${name}', async () => {
+      const response = await app.inject({
+        method: 'GET',
+        url: '/${name}',
+      });
+
+      expect(response.statusCode).toBe(200);
+      expect(response.json()).toHaveProperty('data');
+    });
+  });
+
+  describe('GET /${name}/:id', () => {
+    it('should return a single ${camelName}', async () => {
+      // TODO: Create test ${camelName} first
+      const response = await app.inject({
+        method: 'GET',
+        url: '/${name}/1',
+      });
+
+      expect(response.statusCode).toBe(200);
+      expect(response.json()).toHaveProperty('data');
+    });
+
+    it('should return 404 for non-existent ${camelName}', async () => {
+      const response = await app.inject({
+        method: 'GET',
+        url: '/${name}/999999',
+      });
+
+      expect(response.statusCode).toBe(404);
+    });
+  });
+
+  describe('POST /${name}', () => {
+    it('should create a new ${camelName}', async () => {
+      const response = await app.inject({
+        method: 'POST',
+        url: '/${name}',
+        payload: {
+          // TODO: Add required fields
+        },
+      });
+
+      expect(response.statusCode).toBe(201);
+      expect(response.json()).toHaveProperty('data');
+    });
+
+    it('should return 400 for invalid data', async () => {
+      const response = await app.inject({
+        method: 'POST',
+        url: '/${name}',
+        payload: {},
+      });
+
+      expect(response.statusCode).toBe(400);
+    });
+  });
+
+  describe('PUT /${name}/:id', () => {
+    it('should update a ${camelName}', async () => {
+      // TODO: Create test ${camelName} first
+      const response = await app.inject({
+        method: 'PUT',
+        url: '/${name}/1',
+        payload: {
+          // TODO: Add fields to update
+        },
+      });
+
+      expect(response.statusCode).toBe(200);
+      expect(response.json()).toHaveProperty('data');
+    });
+  });
+
+  describe('DELETE /${name}/:id', () => {
+    it('should delete a ${camelName}', async () => {
+      // TODO: Create test ${camelName} first
+      const response = await app.inject({
+        method: 'DELETE',
+        url: '/${name}/1',
+      });
+
+      expect(response.statusCode).toBe(204);
+    });
+  });
+});
+`;
+}