servcraft 0.2.0 → 0.4.2

package/src/cli/commands/templates.ts

@@ -0,0 +1,147 @@
+/* eslint-disable no-console */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import path from 'path';
+import { getProjectRoot } from '../utils/helpers.js';
+import { validateProject, displayError } from '../utils/error-handler.js';
+
+// Template types available for customization
+const TEMPLATE_TYPES = [
+  'controller',
+  'service',
+  'repository',
+  'types',
+  'schemas',
+  'routes',
+  'module-index',
+  'controller-test',
+  'service-test',
+  'integration-test',
+];
+
+async function initTemplates(): Promise<void> {
+  const projectError = validateProject();
+  if (projectError) {
+    displayError(projectError);
+    return;
+  }
+
+  const projectRoot = getProjectRoot();
+  const templatesDir = path.join(projectRoot, '.servcraft', 'templates');
+
+  try {
+    // Create .servcraft/templates directory
+    await fs.mkdir(templatesDir, { recursive: true });
+
+    console.log(chalk.cyan('\n📁 Creating custom template directory...\n'));
+
+    // Create example template files
+    const exampleController = `// Custom controller template
+// Available variables: name, pascalName, camelName, pluralName
+export function controllerTemplate(name: string, pascalName: string, camelName: string): string {
+  return \`import type { FastifyRequest, FastifyReply } from 'fastify';
+import type { \${pascalName}Service } from './\${name}.service.js';
+
+export class \${pascalName}Controller {
+  constructor(private \${camelName}Service: \${pascalName}Service) {}
+
+  // Add your custom controller methods here
+  async getAll(request: FastifyRequest, reply: FastifyReply) {
+    const data = await this.\${camelName}Service.getAll();
+    return reply.send({ data });
+  }
+}
+\`;
+}
+`;
+
+    await fs.writeFile(
+      path.join(templatesDir, 'controller.example.ts'),
+      exampleController,
+      'utf-8'
+    );
+
+    console.log(chalk.green('✔ Created template directory: .servcraft/templates/'));
+    console.log(chalk.green('✔ Created example template: controller.example.ts\n'));
+
+    console.log(chalk.bold('📋 Available template types:\n'));
+    TEMPLATE_TYPES.forEach((type) => {
+      console.log(chalk.gray(`  • ${type}.ts`));
+    });
+
+    console.log(chalk.yellow('\n💡 To customize a template:'));
+    console.log(chalk.gray('  1. Copy the example template'));
+    console.log(chalk.gray('  2. Rename it (remove .example)'));
+    console.log(chalk.gray('  3. Modify the template code'));
+    console.log(chalk.gray('  4. Use --template flag when generating\n'));
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk.red(`\n✗ Failed to initialize templates: ${error.message}\n`));
+    }
+  }
+}
+
+async function listTemplates(): Promise<void> {
+  const projectError = validateProject();
+  if (projectError) {
+    displayError(projectError);
+    return;
+  }
+
+  const projectRoot = getProjectRoot();
+  const projectTemplatesDir = path.join(projectRoot, '.servcraft', 'templates');
+  const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+  const userTemplatesDir = path.join(homeDir, '.servcraft', 'templates');
+
+  console.log(chalk.bold.cyan('\n📋 Available Templates\n'));
+
+  // Check project templates
+  console.log(chalk.bold('Project templates (.servcraft/templates/):'));
+  try {
+    const files = await fs.readdir(projectTemplatesDir);
+    const templates = files.filter((f) => f.endsWith('.ts') && !f.endsWith('.example.ts'));
+
+    if (templates.length > 0) {
+      templates.forEach((t) => {
+        console.log(chalk.green(`  ✓ ${t}`));
+      });
+    } else {
+      console.log(chalk.gray('  (none)'));
+    }
+  } catch {
+    console.log(chalk.gray('  (directory not found)'));
+  }
+
+  // Check user templates
+  console.log(chalk.bold('\nUser templates (~/.servcraft/templates/):'));
+  try {
+    const files = await fs.readdir(userTemplatesDir);
+    const templates = files.filter((f) => f.endsWith('.ts') && !f.endsWith('.example.ts'));
+
+    if (templates.length > 0) {
+      templates.forEach((t) => {
+        console.log(chalk.green(`  ✓ ${t}`));
+      });
+    } else {
+      console.log(chalk.gray('  (none)'));
+    }
+  } catch {
+    console.log(chalk.gray('  (directory not found)'));
+  }
+
+  // Show built-in templates
+  console.log(chalk.bold('\nBuilt-in templates:'));
+  TEMPLATE_TYPES.forEach((t) => {
+    console.log(chalk.cyan(`  • ${t}.ts`));
+  });
+
+  console.log(chalk.gray('\n💡 Run "servcraft templates init" to create custom templates\n'));
+}
+
+export const templatesCommand = new Command('templates')
+  .description('Manage code generation templates')
+  .addCommand(
+    new Command('init').description('Initialize custom templates directory').action(initTemplates)
+  )
+  .addCommand(new Command('list').description('List available templates').action(listTemplates));

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,10 @@ 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';
+import { scaffoldCommand } from './commands/scaffold.js';
+import { templatesCommand } from './commands/templates.js';
 
 const program = new Command();
 
@@ -41,4 +45,16 @@ program.addCommand(removeCommand);
 // Diagnose project
 program.addCommand(doctorCommand);
 
+// Update modules
+program.addCommand(updateCommand);
+
+// Shell completion
+program.addCommand(completionCommand);
+
+// Scaffold resource
+program.addCommand(scaffoldCommand);
+
+// Template management
+program.addCommand(templatesCommand);
+
 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);
+    });
+  });
+});
+`;
+}

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

@@ -0,0 +1,139 @@
+export function integrationTestTemplate(
+  name: string,
+  pascalName: string,
+  camelName: string
+): string {
+  return `import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import { build } from '../../app.js';
+import { FastifyInstance } from 'fastify';
+import { prisma } from '../../lib/prisma.js';
+
+describe('${pascalName} Integration Tests', () => {
+  let app: FastifyInstance;
+
+  beforeAll(async () => {
+    app = await build();
+    await app.ready();
+  });
+
+  afterAll(async () => {
+    await app.close();
+    await prisma.$disconnect();
+  });
+
+  beforeEach(async () => {
+    // Clean up test data
+    // await prisma.${camelName}.deleteMany();
+  });
+
+  describe('Full CRUD workflow', () => {
+    it('should create, read, update, and delete a ${camelName}', async () => {
+      // Create
+      const createResponse = await app.inject({
+        method: 'POST',
+        url: '/${name}',
+        payload: {
+          // TODO: Add required fields
+        },
+      });
+
+      expect(createResponse.statusCode).toBe(201);
+      const created = createResponse.json().data;
+      expect(created.id).toBeDefined();
+
+      // Read
+      const readResponse = await app.inject({
+        method: 'GET',
+        url: \`/${name}/\${created.id}\`,
+      });
+
+      expect(readResponse.statusCode).toBe(200);
+      const read = readResponse.json().data;
+      expect(read.id).toBe(created.id);
+
+      // Update
+      const updateResponse = await app.inject({
+        method: 'PUT',
+        url: \`/${name}/\${created.id}\`,
+        payload: {
+          // TODO: Add fields to update
+        },
+      });
+
+      expect(updateResponse.statusCode).toBe(200);
+      const updated = updateResponse.json().data;
+      expect(updated.id).toBe(created.id);
+
+      // Delete
+      const deleteResponse = await app.inject({
+        method: 'DELETE',
+        url: \`/${name}/\${created.id}\`,
+      });
+
+      expect(deleteResponse.statusCode).toBe(204);
+
+      // Verify deletion
+      const verifyResponse = await app.inject({
+        method: 'GET',
+        url: \`/${name}/\${created.id}\`,
+      });
+
+      expect(verifyResponse.statusCode).toBe(404);
+    });
+  });
+
+  describe('List and pagination', () => {
+    it('should list ${name} with pagination', async () => {
+      // Create multiple ${name}
+      const count = 5;
+      for (let i = 0; i < count; i++) {
+        await app.inject({
+          method: 'POST',
+          url: '/${name}',
+          payload: {
+            // TODO: Add required fields
+          },
+        });
+      }
+
+      // Test pagination
+      const response = await app.inject({
+        method: 'GET',
+        url: '/${name}?page=1&limit=3',
+      });
+
+      expect(response.statusCode).toBe(200);
+      const result = response.json();
+      expect(result.data).toBeDefined();
+      expect(result.data.length).toBeLessThanOrEqual(3);
+      expect(result.total).toBeGreaterThanOrEqual(count);
+    });
+  });
+
+  describe('Validation', () => {
+    it('should validate required fields on create', async () => {
+      const response = await app.inject({
+        method: 'POST',
+        url: '/${name}',
+        payload: {},
+      });
+
+      expect(response.statusCode).toBe(400);
+      expect(response.json()).toHaveProperty('error');
+    });
+
+    it('should validate data types', async () => {
+      const response = await app.inject({
+        method: 'POST',
+        url: '/${name}',
+        payload: {
+          // TODO: Add invalid field types
+        },
+      });
+
+      expect(response.statusCode).toBe(400);
+    });
+  });
+});
+`;
+}