Code Review

How It Works

Whenever a team member opens a pull request, Kody performs a Code Review directly in your code management tool, such as GitHub or GitLab. Kody analyzes the code, provides detailed feedback, and highlights potential issues, just as a human reviewer would. This ensures code quality and speeds up the review process.

Additionally, you can use the command @kody start-review directly in Git to have Kody initiate a code review on any pull request. This command bypasses branch and naming configurations, so Kody will review any PR where the command is used.

Code Review Settings

Customize Kody’s Code Review to align with your team’s specific needs.

Code Style Guide

Set up your style guide to ensure consistent standards across the codebase.

You are a senior TypeScript programmer with experience in the NestJS framework and a preference for clean programming and design patterns.Generate code, corrections, and refactorings that comply with the basic principles and nomenclature.
## TypeScript General Guidelines

### Basic Principles- Use English for all code and documentation.
- Always declare the type of each variable and function (parameters and return value). 
- Avoid using any. - Create necessary types.
- Use JSDoc to document public classes and methods.
- Don't leave blank lines within a function.- One export per file.

### Nomenclature- Use PascalCase for classes.
- Use camelCase for variables, functions, and methods.
- Use kebab-case for file and directory names.
- Use UPPERCASE for environment variables. 
- Avoid magic numbers and define constants.
- Start each function with a verb.
- Use verbs for boolean variables. Example: isLoading, hasError, canDelete, etc.
- Use complete words instead of abbreviations and correct spelling. 
- Except for standard abbreviations like API, URL, etc. 
- Except for well-known abbreviations:  
    - i, j for loops  
    - err for errors  
    - ctx for contexts  
    - req, res, next for middleware function parameters

### Functions
- In this context, what is understood as a function will also apply to a method.
- Write short functions with a single purpose. Less than 20 instructions.
- Name functions with a verb and something else. 
- If it returns a boolean, use isX or hasX, canX, etc. 
- If it doesn't return anything, use executeX or saveX, etc.
- Avoid nesting blocks by: 
- Early checks and returns. 
- Extraction to utility functions.
- Use higher-order functions (map, filter, reduce, etc.) to avoid function nesting.
 - Use arrow functions for simple functions (less than 3 instructions). 
- Use named functions for non-simple functions.
- Use default parameter values instead of checking for null or undefined.
- Reduce function parameters using RO-RO
- Use an object to pass multiple parameters. 
- Use an object to return results. 
- Declare necessary types for input arguments and output.
- Use a single level of abstraction.

### Data- Don't abuse primitive types and encapsulate data in composite types.
- Avoid data validations in functions and use classes with internal validation.
- Prefer immutability for data. 
- Use readonly for data that doesn't change. 
- Use as const for literals that don't change.

### Classes
- Follow SOLID principles.
- Prefer composition over inheritance.
- Declare interfaces to define contracts.
- Write small classes with a single purpose. 
- Less than 200 instructions. 
- Less than 10 public methods. 
- Less than 10 properties.

### Exceptions
- Use exceptions to handle errors you don't expect.
- If you catch an exception, it should be to: 
- Fix an expected problem. 
- Add context. 
- Otherwise, use a global handler.

### Testing
- Follow the Arrange-Act-Assert convention for tests.
- Name test variables clearly. 
- Follow the convention: inputX, mockX, actualX, expectedX, etc.
- Write unit tests for each public function. 
- Use test doubles to simulate dependencies.  
- Except for third-party dependencies that are not expensive to execute.
- Write acceptance tests for each module. 
- Follow the Given-When-Then convention.

## Specific to NestJS

### Basic Principles
- Use modular architecture
- Encapsulate the API in modules. 
- One module per main domain/route. 
- One controller for its route.  
- And other controllers for secondary routes. 
- A models folder with data types.  
- DTOs validated with class-validator for inputs.  
- Declare simple types for outputs. 
- A services module with business logic and persistence.  
- Entities with MikroORM for data persistence.  
- One service per entity.
- A core module for nest artifacts 
- Global filters for exception handling. 
- Global middlewares for request management. 
- Guards for permission management. 
- Interceptors for request management.
- A shared module for services shared between modules. 
- Utilities 
- Shared business logic

### Testing
- Use the standard Jest framework for testing.
- Write tests for each controller and service.
- Write end to end tests for each api module.
- Add a admin/test method to each controller as a smoke test.

Style Guide per Path

Path-specific instructions allow you to set additional, file-specific code review conditions based on file paths. These guide Kody’s code review automation to apply specific guidelines only where they’re most relevant.

Examples:

Special Rules for Certain Files or Directories:
- Projects often contain files or folders that require particular attention due to sensitivity or complexity, such as configuration files, deployment scripts, or security-related code.
- Example: For files in config/, ensure they follow strict security checks to prevent hardcoded sensitive information.
Code Review Customization:
- Tailor review practices for different code areas, ensuring specific guidelines are followed in relevant sections.
- Example: In the api/ directory, emphasize input validation and error handling.
Enhancing Code Quality:
- Example: In UI-related files, focus on accessibility and responsiveness best practices.

Automatic Review

Choose whether you want reviews to trigger automatically or only when you issue the command @kody start-review in a pull request.

Types of Analysis

Select the types of analysis you’d like Kody to perform. Options include:

Performance Optimization: Identifies improvements for code efficiency, performance, and resource usage.

// Original code
let result = [];
for (let i = 0; i < items.length; i++) {
  result.push(items[i] * 2);
}

// Optimized code using map (more efficient and readable)
const result = items.map((item) => item * 2);

Security: Detects vulnerabilities and improves code security.

// Original code
function getUserData(username) {
  return db.query(`SELECT * FROM users WHERE username = '${username}'`);
}

// Improved code with enhanced security (using prepared statements)
function getUserData(username) {
  return db.query("SELECT * FROM users WHERE username = ?", [username]);
}

Error Handling: Enhances how errors and exceptions are managed.

// Original code
const data = JSON.parse(input);

// Improved code with error handling
try {
  const data = JSON.parse(input);
} catch (error) {
  console.error("Error parsing JSON:", error);
}

Refactoring: Restructures code to improve readability, maintainability, or modularity.

// Original code
function calculateDiscount(price, discount) {
  if (discount) {
    return price - (price * discount) / 100;
  } else {
    return price;
  }
}

// Refactored code to reduce duplicated logic
function calculateDiscount(price, discount = 0) {
  return price - (price * discount) / 100;
}

Maintainability: Enhances code to simplify future maintenance and extension.
```
// Original code
function processOrder(order) {
  // order proce
```

Getting Started

Interacting with Kody

AI Workflows

Cockpit

Security

Configs

How It Works

Code Review Settings

Code Style Guide

Style Guide per Path

Automatic Review

Types of Analysis

Getting Started

Interacting with Kody

AI Workflows

Cockpit

Security

Configs

​How It Works

​Code Review Settings

​Code Style Guide

​Style Guide per Path

​Automatic Review

​Types of Analysis

How It Works

Code Review Settings

Code Style Guide

Style Guide per Path

Automatic Review

Types of Analysis