[93] feat: New command to generate crud api

actions/add-utils/file-utils.ts

@@ -0,0 +1,29 @@
+import { existsSync } from 'fs';
+import { join, basename } from 'path';
+
+export function getControllerFilePath(modelName: string): string | null {
+  const controllerFilePath = join(process.cwd(), modelName, `${basename(modelName)}.controller.ts`);
+  if (existsSync(controllerFilePath)) {
+    return controllerFilePath;
+  }
+  return null;
+}
+
+export function getDtoFilePath(modelName: string): string | null {
+  const dtoFilePath = join(process.cwd(), modelName, 'dto',`${basename(modelName)}.dto.ts`);
+  if (existsSync(dtoFilePath)) {
+    return dtoFilePath;
+  }
+  return null;
+}
+
+export function findProjectRoot(): string {
+  let dir = process.cwd();
+  while (dir !== '/') {
+    if (existsSync(join(dir, 'package.json'))) {
+      return dir;
+    }
+    dir = join(dir, '..');
+  }
+  throw new Error('Project root not found');
+}

actions/add-utils/import-manager.ts

@@ -0,0 +1,32 @@
+export function addImports(content: string, fileType: 'controller' | 'dto'): string {
+  const existingSwaggerImports = content.match(/import\s+{\s*([^}]+)\s*}\s+from\s+'@nestjs\/swagger';/);
+
+  let swaggerDecorators: string[];
+
+  switch (fileType) {
+    case 'controller':
+      swaggerDecorators = ['ApiOperation', 'ApiResponse', 'ApiParam', 'ApiBody', 'ApiTags'];
+      break;
+    case 'dto':
+      swaggerDecorators = ['ApiProperty', 'ApiPropertyOptional'];
+      break;
+    default:
+      throw new Error('Unsupported file type');
+  }
+
+  const existingDecorators = existingSwaggerImports ? existingSwaggerImports[1].split(',').map((d) => d.trim()) : [];
+  const newDecorators = swaggerDecorators.filter((d) => !existingDecorators.includes(d));
+
+  if (newDecorators.length > 0) {
+    const newImportStatement = `import { ${[...existingDecorators, ...newDecorators].join(', ')} } from '@nestjs/swagger';`;
+    if (existingSwaggerImports) {
+      content = content.replace(existingSwaggerImports[0], newImportStatement);
+    } else {
+      const lastImportIndex = content.lastIndexOf('import ');
+      const insertPosition = content.indexOf(';', lastImportIndex) + 1;
+      content = `${content.slice(0, insertPosition)}\n${newImportStatement}${content.slice(insertPosition)}`;
+    }
+  }
+
+  return content;
+}

actions/add-utils/swagger-controller.ts

@@ -0,0 +1,117 @@
+import * as fs from 'fs';
+import * as chalk from 'chalk';
+import { addImports } from './import-manager';
+
+export function addSwaggerControllers(controllerPath: string) {
+  try {
+    const content = fs.readFileSync(controllerPath, 'utf-8');
+    let updatedContent = content;
+
+    const httpMethods = {
+      Get: /@Get\(['"]?[^'"]*['"]?\)?\s*\n\s*async\s+(\w+)\(([\w\s,@(){}:'"=]*)\)\s*:\s*Promise<([\w\[\]]+)>/g,
+      Post: /@Post\(['"]?[^'"]*['"]?\)?\s*\n\s*async\s+(\w+)\(([\w\s,@(){}:'"=]*)\)\s*:\s*Promise<([\w\[\]]+)>/g,
+      Put: /@Put\(['"]?[^'"]*['"]?\)?\s*\n\s*async\s+(\w+)\(([\w\s,@(){}:'"=]*)\)\s*:\s*Promise<([\w\[\]]+)>/g,
+      Delete: /@Delete\(['"]?[^'"]*['"]?\)?\s*\n\s*async\s+(\w+)\(([\w\s,@(){}:'"=]*)\)\s*:\s*Promise<([\w\[\]]+)>/g
+    };
+
+    let processedMethods: Set<string> = new Set();
+
+    for (const [method, regex] of Object.entries(httpMethods)) {
+      let match;
+      while ((match = regex.exec(updatedContent)) !== null) {
+        const methodSignature = match[0];
+        if (!processedMethods.has(methodSignature)) {
+          processedMethods.add(methodSignature);
+          const updatedMethod = replaceMethod(methodSignature, method);
+          updatedContent = updatedContent.replace(methodSignature, updatedMethod);
+        }
+      }
+    }
+
+    if (!/@ApiTags\(/.test(updatedContent)) {
+      const classRegex = /@Controller\(['"]([\w-]+)['"]\)/;
+      updatedContent = updatedContent.replace(classRegex, (match, p1) => {
+        return `${match}\n@ApiTags('${p1}')`;
+      });
+    }
+
+    updatedContent = addImports(updatedContent,"controller");
+
+    fs.writeFileSync(controllerPath, updatedContent, 'utf-8');
+    console.info(chalk.green(`Swagger decorators added to ${controllerPath}`));
+  } catch (error) {
+    console.error(chalk.red(`Error adding Swagger decorators to ${controllerPath}`), error);
+  }
+}
+
+function replaceMethod(methodSignature: string, method: string): string {
+  const decorators = generateSwaggerDecorators(methodSignature, method);
+  return decorators + methodSignature;
+}
+
+function generateSwaggerDecorators(methodSignature: string, method: string): string {
+  let decorators = '';
+  if (!/@ApiOperation\(/.test(methodSignature)) {
+    decorators += `@ApiOperation({ summary: '${getOperationSummary(method)}' })\n`;
+  }
+
+  if (!/@ApiResponse\(/.test(methodSignature)) {
+    decorators += `@ApiResponse({ status: 200, description: 'Successful response', type: '${getReturnType(methodSignature)}' })\n`;
+  }
+
+  if (/@Body\(/.test(methodSignature) && !/@ApiBody\(/.test(methodSignature)) {
+    decorators += `@ApiBody({ type: ${getBodyType(methodSignature)}, description: 'Item data' })\n`;
+  }
+
+  if (/@Param\(['"]\w+['"]\)/.test(methodSignature) && !/@ApiParam\({ name: /.test(methodSignature)) {
+    const paramName = getParamName(methodSignature);
+    const paramType = getParamType(methodSignature);
+    decorators += `@ApiParam({ name: '${paramName}', description: 'ID of the item', type: '${paramType}' })\n`;
+  }
+
+  if (method === 'Delete') {
+    if (!/@ApiResponse\({ status: 204/.test(methodSignature)) {
+      decorators += `@ApiResponse({ status: 204, description: 'Item deleted' })\n`;
+    }
+    if (!/@ApiResponse\({ status: 404/.test(methodSignature)) {
+      decorators += `@ApiResponse({ status: 404, description: 'Item not found' })\n`;
+    }
+  }
+
+  return decorators;
+}
+
+function getOperationSummary(method: string): string {
+  switch (method) {
+    case 'Get':
+      return 'Retrieve items';
+    case 'Post':
+      return 'Create an item';
+    case 'Put':
+      return 'Update an item';
+    case 'Delete':
+      return 'Delete an item';
+    default:
+      return '';
+  }
+}
+
+function getReturnType(methodSignature: string): string {
+  const match = methodSignature.match(/:\s*Promise<([\w\s@(){}]+)>/);
+  return match ? match[1].trim() : 'any';
+}
+
+function getBodyType(methodSignature: string): string {
+  const match = methodSignature.match(/@Body\(\)\s*([\w<>,]+):\s*([\w<>,]+)/);
+  return match ? match[2].trim() : 'any';
+}
+
+function getParamType(methodSignature: string): string {
+  const match = methodSignature.match(/@Param\(\s*['"]\w+['"]\s*\)\s*\w+:\s*(\w+)/);
+  return match ? match[1] : 'string';
+}
+
+function getParamName(methodSignature: string): string {
+  const match = methodSignature.match(/@Param\(\s*['"](\w+)['"]\s*\)/);
+  return match ? match[1] : 'id';
+}

actions/add-utils/swagger-dto.ts

@@ -0,0 +1,36 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { addImports } from './import-manager';
+import * as chalk from 'chalk';
+
+export function addSwaggerDto(dtoFilePath: string) {
+
+  const dtoContent = fs.readFileSync(dtoFilePath, 'utf-8');
+
+  let updatedContent = addSwaggerDecorators(dtoContent);
+  updatedContent = addImports(updatedContent, 'dto');
+
+  fs.writeFileSync(dtoFilePath, updatedContent, 'utf-8');
+  console.info(chalk.green(`Swagger decorators added to ${dtoFilePath}`));
+}
+
+const addSwaggerDecorators = (content: string): string => {
+  const lines = content.split('\n');
+
+  const updatedLines = lines.map(line => {
+    if (line.includes('export class Create') || line.includes('export class Update')) {
+      return line;
+    }
+
+    if (line.includes(':')) {
+      const [name, type] = line.split(':');
+      const isOptional = name.includes('?');
+      const decorator = isOptional ? '@ApiPropertyOptional' : '@ApiProperty';
+      return `  ${decorator}({ description: '${name.trim()}' })\n  ${line}`;
+    }
+
+    return line;
+  });
+
+  return updatedLines.join('\n');
+};

actions/add-utils/swagger-init.ts

@@ -0,0 +1,44 @@
+import * as fs from 'fs';
+import * as chalk from 'chalk';
+import { join } from 'path';
+import { findProjectRoot } from './file-utils';
+
+export function addSwaggerInitialization() {
+  const projectRoot = findProjectRoot();
+  const mainPath = join(projectRoot, 'src', 'main.ts');
+
+  try {
+    let mainContent = fs.readFileSync(mainPath, 'utf-8');
+
+    if (!/import\s+{\s*SwaggerModule\s*,\s*DocumentBuilder\s*}\s+from\s+'@nestjs\/swagger';/.test(mainContent)) {
+      mainContent = mainContent.replace(
+        'import { NestFactory } from \'@nestjs/core\';',
+        `import { NestFactory } from '@nestjs/core';
+import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';`
+      );
+    }
+
+    if (!/const\s+config\s+=\s+new\s+DocumentBuilder\(\)/.test(mainContent)) {
+      mainContent = mainContent.replace(
+        /await\s+app\.listen\(\d+\);/,
+        `const config = new DocumentBuilder()
+  .setTitle('API Documentation')
+  .setDescription('The API description')
+  .setVersion('1.0')
+  .addTag('api')
+  .build();
+
+ const document = SwaggerModule.createDocument(app, config);
+ SwaggerModule.setup('api', app, document);
+
+ await app.listen(3000);`
+      );
+    }
+
+    fs.writeFileSync(mainPath, mainContent, 'utf-8');
+    console.info(chalk.green('Swagger initialized in main.ts'));
+
+  } catch (error) {
+    console.error(chalk.red(`Error adding Swagger initialization to ${mainPath}`), error);
+  }
+}