servcraft 0.1.7 → 0.3.1

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);
+    });
+  });
+});
+`;
+}

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

@@ -0,0 +1,100 @@
+export function serviceTestTemplate(name: string, pascalName: string, camelName: string): string {
+  return `import { describe, it, expect, beforeEach } from 'vitest';
+import { ${pascalName}Service } from '../${name}.service.js';
+
+describe('${pascalName}Service', () => {
+  let service: ${pascalName}Service;
+
+  beforeEach(() => {
+    service = new ${pascalName}Service();
+  });
+
+  describe('getAll', () => {
+    it('should return all ${name}', async () => {
+      const result = await service.getAll();
+
+      expect(result).toBeDefined();
+      expect(Array.isArray(result)).toBe(true);
+    });
+
+    it('should apply pagination', async () => {
+      const result = await service.getAll({ page: 1, limit: 10 });
+
+      expect(result).toBeDefined();
+      expect(result.length).toBeLessThanOrEqual(10);
+    });
+  });
+
+  describe('getById', () => {
+    it('should return a ${camelName} by id', async () => {
+      // TODO: Create test ${camelName} first
+      const id = '1';
+      const result = await service.getById(id);
+
+      expect(result).toBeDefined();
+      expect(result.id).toBe(id);
+    });
+
+    it('should return null for non-existent id', async () => {
+      const result = await service.getById('999999');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('create', () => {
+    it('should create a new ${camelName}', async () => {
+      const data = {
+        // TODO: Add required fields
+      };
+
+      const result = await service.create(data);
+
+      expect(result).toBeDefined();
+      expect(result.id).toBeDefined();
+    });
+
+    it('should throw error for invalid data', async () => {
+      await expect(service.create({} as any)).rejects.toThrow();
+    });
+  });
+
+  describe('update', () => {
+    it('should update a ${camelName}', async () => {
+      // TODO: Create test ${camelName} first
+      const id = '1';
+      const updates = {
+        // TODO: Add fields to update
+      };
+
+      const result = await service.update(id, updates);
+
+      expect(result).toBeDefined();
+      expect(result.id).toBe(id);
+    });
+
+    it('should return null for non-existent id', async () => {
+      const result = await service.update('999999', {});
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete a ${camelName}', async () => {
+      // TODO: Create test ${camelName} first
+      const id = '1';
+      const result = await service.delete(id);
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false for non-existent id', async () => {
+      const result = await service.delete('999999');
+
+      expect(result).toBe(false);
+    });
+  });
+});
+`;
+}

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`,
+    ]);
+  }
+}