servcraft 0.2.0 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "servcraft",
-  "version": "0.2.0",
+  "version": "0.4.2",
   "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,10 @@ 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';
+import { getTemplate } from '../utils/template-loader.js';
 
 export const generateCommand = new Command('generate')
   .alias('g')
@@ -62,6 +66,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);
@@ -96,41 +101,50 @@ generateCommand
       // Use dynamic templates if fields are provided
       const hasFields = fields.length > 0;
 
+      // Load templates (custom or built-in)
+      const controllerTpl = await getTemplate('controller', controllerTemplate);
+      const serviceTpl = await getTemplate('service', serviceTemplate);
+      const repositoryTpl = await getTemplate('repository', repositoryTemplate);
+      const typesTpl = await getTemplate('types', typesTemplate);
+      const schemasTpl = await getTemplate('schemas', schemasTemplate);
+      const routesTpl = await getTemplate('routes', routesTemplate);
+      const moduleIndexTpl = await getTemplate('module-index', moduleIndexTemplate);
+
       const files = [
         {
           name: `${kebabName}.types.ts`,
           content: hasFields
             ? dynamicTypesTemplate(kebabName, pascalName, fields)
-            : typesTemplate(kebabName, pascalName),
+            : typesTpl(kebabName, pascalName),
         },
         {
           name: `${kebabName}.schemas.ts`,
           content: hasFields
             ? dynamicSchemasTemplate(kebabName, pascalName, camelName, fields, validatorType)
-            : schemasTemplate(kebabName, pascalName, camelName),
+            : schemasTpl(kebabName, pascalName, camelName),
         },
         {
           name: `${kebabName}.service.ts`,
-          content: serviceTemplate(kebabName, pascalName, camelName),
+          content: serviceTpl(kebabName, pascalName, camelName),
         },
         {
           name: `${kebabName}.controller.ts`,
-          content: controllerTemplate(kebabName, pascalName, camelName),
+          content: controllerTpl(kebabName, pascalName, camelName),
         },
-        { name: 'index.ts', content: moduleIndexTemplate(kebabName, pascalName, camelName) },
+        { name: 'index.ts', content: moduleIndexTpl(kebabName, pascalName, camelName) },
       ];
 
       if (options.repository !== false) {
         files.push({
           name: `${kebabName}.repository.ts`,
-          content: repositoryTemplate(kebabName, pascalName, camelName, pluralName),
+          content: repositoryTpl(kebabName, pascalName, camelName, pluralName),
         });
       }
 
       if (options.routes !== false) {
         files.push({
           name: `${kebabName}.routes.ts`,
-          content: routesTemplate(kebabName, pascalName, camelName, pluralName),
+          content: routesTpl(kebabName, pascalName, camelName, pluralName),
         });
       }
 
@@ -139,6 +153,31 @@ 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__');
+
+        // Load test templates (custom or built-in)
+        const controllerTestTpl = await getTemplate('controller-test', controllerTestTemplate);
+        const serviceTestTpl = await getTemplate('service-test', serviceTestTemplate);
+        const integrationTestTpl = await getTemplate('integration-test', integrationTestTemplate);
+
+        await writeFile(
+          path.join(testDir, `${kebabName}.controller.test.ts`),
+          controllerTestTpl(kebabName, pascalName, camelName)
+        );
+
+        await writeFile(
+          path.join(testDir, `${kebabName}.service.test.ts`),
+          serviceTestTpl(kebabName, pascalName, camelName)
+        );
+
+        await writeFile(
+          path.join(testDir, `${kebabName}.integration.test.ts`),
+          integrationTestTpl(kebabName, pascalName, camelName)
+        );
+      }
+
       spinner.succeed(`Module "${pascalName}" generated successfully!`);
 
       // Show Prisma model if requested or fields provided
@@ -169,6 +208,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/scaffold.ts

@@ -0,0 +1,211 @@
+/* eslint-disable no-console */
+import { Command } from 'commander';
+import path from 'path';
+import ora from 'ora';
+import chalk from 'chalk';
+import {
+  toPascalCase,
+  toCamelCase,
+  toKebabCase,
+  pluralize,
+  writeFile,
+  success,
+  info,
+  getModulesDir,
+} from '../utils/helpers.js';
+import { DryRunManager } from '../utils/dry-run.js';
+import { parseFields } from '../utils/field-parser.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 { controllerTemplate } from '../templates/controller.js';
+import { serviceTemplate } from '../templates/service.js';
+import { repositoryTemplate } from '../templates/repository.js';
+import { routesTemplate } from '../templates/routes.js';
+import { moduleIndexTemplate } from '../templates/module-index.js';
+import { controllerTestTemplate } from '../templates/controller-test.js';
+import { serviceTestTemplate } from '../templates/service-test.js';
+import { integrationTestTemplate } from '../templates/integration-test.js';
+import { getTemplate } from '../utils/template-loader.js';
+
+export const scaffoldCommand = new Command('scaffold')
+  .description('Generate complete CRUD with Prisma model')
+  .argument('<name>', 'Resource name (e.g., product, user)')
+  .option(
+    '--fields <fields>',
+    'Field definitions: "name:string email:string? age:number category:relation"'
+  )
+  .option('--validator <type>', 'Validator type: zod, joi, yup', 'zod')
+  .option('--dry-run', 'Preview changes without writing files')
+  .action(
+    async (
+      name: string,
+      options: { fields?: string; validator?: ValidatorType; dryRun?: boolean }
+    ) => {
+      const dryRun = DryRunManager.getInstance();
+      if (options.dryRun) {
+        dryRun.enable();
+        console.log(chalk.yellow('\n⚠ DRY RUN MODE - No files will be written\n'));
+      }
+
+      if (!options.fields) {
+        console.log(chalk.red('\n✗ Error: --fields option is required\n'));
+        console.log(chalk.gray('Example:'));
+        console.log(
+          chalk.cyan(
+            '  servcraft scaffold product --fields "name:string price:number category:relation"'
+          )
+        );
+        process.exit(1);
+      }
+
+      const spinner = ora('Scaffolding resource...').start();
+
+      try {
+        // Parse fields
+        const fields = parseFields(options.fields || '');
+
+        if (!fields || fields.length === 0) {
+          spinner.fail('No valid fields provided');
+          console.log(chalk.gray(`\nReceived: ${options.fields}`));
+          console.log(chalk.gray(`Parsed: ${JSON.stringify(fields)}`));
+          process.exit(1);
+        }
+
+        // Generate names
+        const kebabName = toKebabCase(name);
+        const pascalName = toPascalCase(name);
+        const camelName = toCamelCase(name);
+        const pluralName = pluralize(camelName);
+        const tableName = pluralize(kebabName);
+
+        // Create module directory
+        const modulesDir = getModulesDir();
+        const moduleDir = path.join(modulesDir, kebabName);
+
+        // Load templates (custom or built-in)
+        const controllerTpl = await getTemplate('controller', controllerTemplate);
+        const serviceTpl = await getTemplate('service', serviceTemplate);
+        const repositoryTpl = await getTemplate('repository', repositoryTemplate);
+        const routesTpl = await getTemplate('routes', routesTemplate);
+        const moduleIndexTpl = await getTemplate('module-index', moduleIndexTemplate);
+
+        // Generate all files
+        const files = [
+          {
+            name: `${kebabName}.types.ts`,
+            content: dynamicTypesTemplate(kebabName, pascalName, fields),
+          },
+          {
+            name: `${kebabName}.schemas.ts`,
+            content: dynamicSchemasTemplate(
+              kebabName,
+              pascalName,
+              camelName,
+              fields,
+              options.validator || 'zod'
+            ),
+          },
+          {
+            name: `${kebabName}.service.ts`,
+            content: serviceTpl(kebabName, pascalName, camelName),
+          },
+          {
+            name: `${kebabName}.controller.ts`,
+            content: controllerTpl(kebabName, pascalName, camelName),
+          },
+          {
+            name: 'index.ts',
+            content: moduleIndexTpl(kebabName, pascalName, camelName),
+          },
+          {
+            name: `${kebabName}.repository.ts`,
+            content: repositoryTpl(kebabName, pascalName, camelName, pluralName),
+          },
+          {
+            name: `${kebabName}.routes.ts`,
+            content: routesTpl(kebabName, pascalName, camelName, pluralName),
+          },
+        ];
+
+        // Write all files
+        for (const file of files) {
+          await writeFile(path.join(moduleDir, file.name), file.content);
+        }
+
+        // Generate test files
+        const testDir = path.join(moduleDir, '__tests__');
+
+        // Load test templates (custom or built-in)
+        const controllerTestTpl = await getTemplate('controller-test', controllerTestTemplate);
+        const serviceTestTpl = await getTemplate('service-test', serviceTestTemplate);
+        const integrationTestTpl = await getTemplate('integration-test', integrationTestTemplate);
+
+        await writeFile(
+          path.join(testDir, `${kebabName}.controller.test.ts`),
+          controllerTestTpl(kebabName, pascalName, camelName)
+        );
+
+        await writeFile(
+          path.join(testDir, `${kebabName}.service.test.ts`),
+          serviceTestTpl(kebabName, pascalName, camelName)
+        );
+
+        await writeFile(
+          path.join(testDir, `${kebabName}.integration.test.ts`),
+          integrationTestTpl(kebabName, pascalName, camelName)
+        );
+
+        spinner.succeed(`Resource "${pascalName}" scaffolded successfully!`);
+
+        // Show Prisma model
+        console.log('\n' + '─'.repeat(70));
+        info('📋 Prisma model to add to schema.prisma:');
+        console.log(chalk.gray('\n// Copy this to your schema.prisma file:\n'));
+        console.log(dynamicPrismaTemplate(pascalName, tableName, fields));
+        console.log('─'.repeat(70));
+
+        // Show fields summary
+        console.log('\n📋 Fields scaffolded:');
+        fields.forEach((f) => {
+          const opts = [];
+          if (f.isOptional) opts.push('optional');
+          if (f.isArray) opts.push('array');
+          if (f.isUnique) opts.push('unique');
+          if (f.relation) opts.push(`relation: ${f.relation.model}`);
+          const optsStr = opts.length > 0 ? ` (${opts.join(', ')})` : '';
+          success(`  ${f.name}: ${f.type}${optsStr}`);
+        });
+
+        // Show files created
+        console.log('\n📁 Files created:');
+        files.forEach((f) => success(`  src/modules/${kebabName}/${f.name}`));
+        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`);
+
+        // Show next steps
+        console.log('\n📌 Next steps:');
+        info('  1. Add the Prisma model to your schema.prisma file');
+        info('  2. Run: npx prisma db push (or prisma migrate dev)');
+        info('  3. Run: npx prisma generate');
+        info('  4. Register the module routes in your app');
+        info('  5. Update the test files with actual test data');
+
+        console.log(
+          chalk.gray('\n💡 Tip: Use --dry-run to preview changes before applying them\n')
+        );
+
+        if (options.dryRun) {
+          dryRun.printSummary();
+        }
+      } catch (error) {
+        spinner.fail('Failed to scaffold resource');
+        if (error instanceof Error) {
+          console.error(chalk.red(`\n✗ ${error.message}\n`));
+          console.error(chalk.gray(error.stack));
+        }
+        process.exit(1);
+      }
+    }
+  );