DEV Community: Sanjai Sakthivel

RouterInput in Angular v16

Sanjai Sakthivel — Tue, 02 Jul 2024 06:52:41 +0000

Introduction:

Angular v16 has recently been released, bringing along a range of new features aimed at enhancing the developer experience. One of these exciting features is RouterInput, which allows developers to retrieve route information through inputs. In this blog post, we will explore how RouterInput can be utilized and discuss its benefits.

What is RouterInput?

RouterInput is a new API introduced in Angular v16 that enables developers to listen to route parameters through input bindings in their components. This means that when a route parameter changes, the component is notified through an observable stream, allowing for dynamic updates.

Getting Started with RouterInput:

To start using RouterInput, you need to update your route provider in the main.ts file. This can be done by importing the necessary modules and adding the "withComponentInputBinding()" method to your route provider configuration. Here's an example:

import { provideRouter, withComponentInputBinding } from '@angular/router';

bootstrapApplication(AppComponent, {
  providers: [
    provideRouter(appRoutes, withComponentInputBinding())
  ]
});

Once the route provider is updated, you can start utilizing RouterInput in your components. Simply add the "@Input()" decorator to the properties that you want to bind to route parameters. Here's an example:

`@Input() testId!: string;
@Input() permission!: string;
@Input() user!: string;`

With these input bindings, your component will be notified whenever the corresponding route parameters change.

Additional Notes on RouterInput:

Router Inputs are only accessible within the routed component. If you need to access these parameters within a child component, you can either pass the input through input binding between the parent and child components or use other methods mentioned earlier.
If you prefer a more descriptive decorator name for RouterInput, you can remap it in its definition using the "import {Input as RouterInput} from '@angular/core'" statement. This allows you to use the new decorator name in your component.

Conclusion:

RouterInput is a valuable addition to Angular v16, providing developers with a convenient way to retrieve and react to route parameters through input bindings. By incorporating RouterInput into your Angular projects, you can enhance the flexibility and responsiveness of your components. So, go ahead and explore this new feature to further improve your Angular development experience.

Happy coding!

Understanding Commit Types: A Developer's Guide

Sanjai Sakthivel — Fri, 15 Sep 2023 05:17:11 +0000

Introduction

When it comes to version control, clear and consistent commit messages are crucial. They help team members understand the changes made and why they were made. In this blog post, we'll explore ten common commit types and provide examples for each, along with explanations of when and why to use them.

1. build

Example:

build: upgrade webpack to version 5.3.0

Explanation:

The build type is used for making changes to the build system or external dependencies. This includes things like package updates, configuration changes, or adjustments to the build process.

2. chore

Example:

chore: update eslint configuration

Explanation:

chore commits are for routine tasks, maintenance, or general housekeeping. This could include tasks like code clean-up, reorganizing files, or updating development tools.

3. ci

Example:

ci: integrate automated testing with CircleCI

Explanation:

ci commits involve changes to the Continuous Integration (CI) configuration. This includes setup, optimizations, or integrations with various CI/CD tools.

4. docs

Example:

docs: add usage instructions to README.md

Explanation:

docs commits are reserved for documentation-related changes. This could involve creating or updating documentation files, comments, or inline code documentation.

5. feat

Example:

feat: implement user authentication with JWT

Explanation:

feat commits signify the addition of a new feature or functionality. This type is used when introducing something entirely new to the codebase.

6. fix

Example:

fix: resolve null pointer exception in user profile

Explanation:

fix commits are used when addressing a specific bug or issue in the code. They are crucial for maintaining a stable and reliable application.

7. perf

Example:

perf: optimize database queries for faster response times

Explanation:

perf commits focus on performance improvements. This includes changes that make the code run more efficiently or reduce resource consumption.

8. refactor

Example:

refactor: extract common utility functions from user service

Explanation:

refactor commits involve making changes to the codebase that don't affect its external behavior. This could include code restructuring, optimization, or enhancing maintainability.

9. revert

Example:

revert: undo changes from commit a2b8c3d

Explanation:

revert commits are used to undo the changes introduced by a previous commit. This is especially useful when a change causes unexpected issues or conflicts.

10. style

Example:

style: format code according to Prettier standards

Explanation:

style commits focus on code style and formatting. This includes changes like indentation, spacing, and code styling to maintain a consistent codebase.

Conclusion

Using clear commit types and messages is essential for effective collaboration in any development project. By following these conventions, teams can maintain a clean, well-documented codebase that's easy to understand and work with. So, start incorporating these commit types into your workflow and watch your development process become more efficient and organized. Happy coding!

NestJS Pipes and Essential Packages

Sanjai Sakthivel — Mon, 21 Aug 2023 08:02:42 +0000

Introduction

Data validation is a crucial aspect of building robust API applications. Whether you're receiving data from users or external sources, ensuring its accuracy and integrity is paramount. NestJS, a powerful framework for building scalable and maintainable server-side applications, provides a built-in mechanism called pipes for handling data validation, transformation, and processing.

Basics of NestJS Pipes

NestJS pipes are essentially middlewares that can intercept and modify incoming data before it reaches the handler. They're versatile tools that can be used for a variety of tasks, including data validation and transformation.

// Basic usage of a pipe in a controller method
@Post('create')
@UsePipes(new ValidationPipe())
async create(@Body() createDto: CreateDto) {
  // Process the validated createDto
}

Using the `class-validator` and `class-transformer` Packages

The class-validator package provides decorators to validate class properties, while the class-transformer package is used to transform incoming data into class instances.

import { IsString, IsInt } from 'class-validator';
import { Transform } from 'class-transformer';

export class CreateUserDto {
  @IsString()
  username: string;

  @IsInt()
  @Transform(({ value }) => parseInt(value))
  age: number;
}

Enhancing API Documentation with `@nestjs/swagger`

The @nestjs/swagger package can be used to generate Swagger documentation for your API. You can also integrate validation rules into the documentation using decorators.

import { ApiProperty } from '@nestjs/swagger';

export class CreateUserDto {
  @ApiProperty()
  username: string;

  @ApiProperty()
  age: number;
}

Working with Query Parameters using `@nestjs/parseint`

Parsing query parameters, especially integers, is simplified using the @nestjs/parseint package.

// In a controller
@Get('user')
async getUserById(@Query('id', ParseIntPipe) userId: number) {
  // userId is now a parsed integer
}

Leveraging `nestjs-query` Packages for GraphQL APIs

nestjs-query offers packages for building GraphQL APIs with integrated query validation and parsing.

// In a resolver
@Query(() => [User])
async getUsers(@QueryArgs() query: QueryOptions<User>) {
  return this.userService.query(query);
}

Logging with `winston` for Enhanced Debugging

Using the winston package allows for comprehensive logging to aid in debugging and monitoring.

import * as winston from 'winston';

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.Console({ format: winston.format.simple() }),
  ],
});

logger.info('Informational log message', { additionalInfo: 'some data' });

Conclusion

NestJS pipes, along with essential packages like class-validator, class-transformer, @nestjs/parseint, and winston, significantly enhance the data validation and transformation capabilities of your applications. By integrating these tools into your NestJS projects, you can ensure the reliability and security of your API endpoints while simplifying the development process.

Remember to explore the official documentation of each package for more in-depth information and customization options. Additionally, by leveraging these tools creatively, you can streamline your codebase and build more resilient applications.

Additional Resources

ValidationPipe in NestJS

Sanjai Sakthivel — Thu, 17 Aug 2023 19:57:14 +0000

Title: Mastering Data Validation in NestJS with Class Validator Package and Global Pipes

In the realm of backend development, data validation is a cornerstone of ensuring data accuracy, consistency, and security. NestJS, a powerful Node.js framework, takes data validation to the next level by seamlessly integrating the class-validator package and the global application of the ValidationPipe. In this comprehensive guide, we'll delve into the world of data validation in NestJS, exploring its importance, the versatile capabilities of the class-validator package, and the convenience of configuring the ValidationPipe as a global import.

Understanding Data Validation in NestJS

Data validation, at its core, is the process of verifying that incoming data adheres to specific rules or constraints before it is processed further. This pivotal step prevents erroneous or malicious data from triggering unexpected behavior or security vulnerabilities within your application.

Introducing the Class Validator Package

The class-validator package is a pivotal addition to NestJS, simplifying the data validation process by allowing you to define validation rules directly within your Data Transfer Objects (DTOs). This package operates on decorators, offering an elegant mechanism to express validation criteria using familiar annotations.

Using the ValidationPipe with Class Validator

In the context of NestJS, the ValidationPipe and the class-validator package create a dynamic duo for seamless data validation. Let's explore the process through a step-by-step guide:

Step 1: Install Required Packages

Start by installing the necessary packages:

npm install class-validator class-transformer

Step 2: Define Your DTO

Begin by crafting a Data Transfer Object (DTO) class that mirrors the structure of the incoming data. Employ the class-validator decorators to stipulate validation rules:

import { IsString, IsEmail, IsNotEmpty } from 'class-validator';

export class CreateUserDto {
  @IsNotEmpty()
  @IsString()
  name: string;

  @IsNotEmpty()
  @IsEmail()
  email: string;

  @IsNotEmpty()
  @IsString()
  password: string;
}

In this example, each field in the DTO has been adorned with the @IsNotEmpty() decorator to ensure that they are not devoid of content.

Step 3: Apply ValidationPipe

Within your controller method, introduce the ValidationPipe to the pertinent parameter (typically the @Body() decorator for POST requests):

import { Controller, Post, Body, UsePipes } from '@nestjs/common';
import { ValidationPipe } from '@nestjs/common';
import { CreateUserDto } from './dto/create-user.dto';

@Controller('users')
export class UsersController {
  @Post()
  @UsePipes(new ValidationPipe())
  createUser(@Body() createUserDto: CreateUserDto) {
    // Access validated 'createUserDto' here
    // Logic to create a user
  }
}

The inclusion of the @UsePipes(new ValidationPipe()) decorator in your controller method ensures that incoming data is automatically validated against the rules specified within the class-validator decorators within your DTO.

Configuring Global ValidationPipe

Elevating your data validation game, you can configure the ValidationPipe as a global import within your application's main file (typically main.ts):

import { ValidationPipe } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  // Configure ValidationPipe as a global pipe
  app.useGlobalPipes(new ValidationPipe());

  await app.listen(3000);
}
bootstrap();

By employing app.useGlobalPipes(new ValidationPipe()), you effectively mandate NestJS to implement the ValidationPipe for every incoming request across your application.

Benefits of Global ValidationPipe

Uniformity: Every incoming datum undergoes automated validation, ensuring consistent data quality throughout your application.
Reduced Boilerplate: The need to manually add the ValidationPipe decorator to each controller method is eliminated.
Error Management: In instances where validation fails, the ValidationPipe triggers a validation exception, delivering uniform error responses.

Conclusion

Data validation is a pivotal aspect of application development, and NestJS, coupled with the class-validator package, streamlines this process. By harnessing decorators and the elegance of DTOs, you can confidently assert that the data coursing through your application is dependable, safeguarded, and dependable. The powerful synergy between the ValidationPipe and the class-validator package revolutionizes your validation workflow, bolstering the integrity of your NestJS applications. Furthermore, the global application of the ValidationPipe streamlines your codebase, significantly enhancing the uniformity and robustness of your data validation mechanisms.

NestJS Pipes

Sanjai Sakthivel — Thu, 17 Aug 2023 19:49:06 +0000

Title: Mastering NestJS Pipes: Types, Implementation, and Useful Packages

NestJS, a robust Node.js framework, empowers developers with a multitude of features to streamline backend development. Among these, pipes stand out as a fundamental tool for transforming and validating data within your application. In this comprehensive guide, we'll dive deep into the realm of NestJS pipes, exploring their various types, implementation strategies, and even shine a spotlight on a selection of packages that can elevate your pipe-handling experience.

Understanding NestJS Pipes

Pipes in NestJS are the Swiss Army knife of data processing. They facilitate seamless transformation, sanitization, and validation of incoming data as it traverses various parts of your application. This ensures that the data conforms to specific requirements before it's used in controllers or sent back as responses.

Types of Pipes

Built-in Pipes: NestJS comes equipped with an arsenal of built-in pipes tailored for common use cases. These pipes significantly expedite your development process. Some noteworthy built-in pipes include:

ParseIntPipe: Converts a string to an integer.
ParseFloatPipe: Converts a string to a floating-point number.
ValidationPipe: Performs automatic data validation based on decorators such as @Body(), @Query(), and more.
DefaultValuePipe: Provides default values when a value is missing.

Custom Pipes: For specialized requirements, crafting custom pipes is the way to go. By implementing the PipeTransform interface, you gain the ability to handle intricate transformations and validations tailored precisely to your application's needs.

Applying Pipes

NestJS empowers you to apply pipes at different levels within your application:

Parameter Level:

Apply a pipe to a specific parameter within a route handler. For instance:

   @Get(':id')
   getOne(@Param('id', ParseIntPipe) id: number) {
     // Controller logic
   }

Route Level:

Apply a pipe to an entire route handler within a controller:

   @UsePipes(MyCustomPipe)
   @Controller('items')
   export class ItemsController {
     // Controller methods
   }

Global Level:

Apply a pipe globally to the entire application:

   // main.ts
   async function bootstrap() {
     const app = await NestFactory.create(AppModule);
     app.useGlobalPipes(new MyCustomPipe());
     // ...
   }
   bootstrap();

Useful Packages for NestJS Pipes

class-validator: This package complements NestJS's built-in ValidationPipe. It utilizes decorators to effortlessly add validation rules to your DTOs (Data Transfer Objects) and executes automatic validation based on these rules.
class-transformer: In conjunction with class-validator, this package is a game-changer for transforming and normalizing incoming data to the desired format. It shines when handling intricate data transformations.
@nestjs/mapped-types: This package introduces utility functions for generating mapped types. It's invaluable for crafting new DTOs derived from existing ones, complete with additional validation rules or transformed properties.
nestjs-query/packages/query-graphql: If you're in the realm of GraphQL and aspire to seamlessly handle query validation and filtering, the nestjs-query library furnishes potent tools for defining and validating queries.

Examples of Types of Pipes

1. Built-in Pipes

`ParseIntPipe` and `ParseFloatPipe`

Imagine an API endpoint that anticipates an ID as a parameter in the URL. The ID requires conversion into a numeric format for processing.

@Get(':id')
getOne(@Param('id', ParseIntPipe) id: number) {
  // Now 'id' is a number
  // Controller logic
}

`ValidationPipe`

Consider a scenario where user input validation is imperative for creating a new item. Employ the ValidationPipe to automatically validate incoming data based on a DTO class furnished with validation decorators.

@Post()
createItem(@Body(ValidationPipe) createItemDto: CreateItemDto) {
  // 'createItemDto' is validated as per DTO rules
  // Controller logic
}

`DefaultValuePipe`

In situations where a query parameter is optional and absent from the request, DefaultValuePipe steps in to assign a default value.

@Get()
getItems(@Query('page', DefaultValuePipe) page: number = 1) {
  // If 'page' query parameter is omitted, 'page' defaults to 1
  // Controller logic
}

2. Custom Pipe

Custom Validation Pipe

Suppose you're tasked with validating whether an email adheres to a valid format. Crafting a custom pipe is the optimal route for executing this validation.

import { PipeTransform, Injectable, BadRequestException } from '@nestjs/common';

@Injectable()
export class EmailValidationPipe implements PipeTransform {
  transform(value: any) {
    const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
    if (!emailRegex.test(value)) {
      throw new BadRequestException('Invalid email format');
    }
    return value;
  }
}

Subsequently, apply this custom pipe to your route:

@Post('register')
registerUser(@Body('email', EmailValidationPipe) email: string) {
  // Email is validated by the custom pipe
  // Controller logic
}

Conclusion

Navigating NestJS pipes, whether they're baked into the framework or custom-crafted, ushers in an era of data processing prowess. By immersing yourself in the world of these pipes and leveraging packages like class-validator and class-transformer, you unlock the potential to ensure data consistency, amplify validation processes, and keep your codebase modular and primed for growth. Be discerning in your choice of pipe type for every situation, and explore the remarkable utilities bestowed upon you by NestJS and its associated packages, all in the pursuit of refining your backend development journey.

DEV Community: Sanjai Sakthivel

RouterInput in Angular v16

Introduction:

What is RouterInput?

Getting Started with RouterInput:

Additional Notes on RouterInput:

Conclusion:

Understanding Commit Types: A Developer's Guide

Introduction

1. build

Example:

Explanation:

2. chore

Example:

Explanation:

3. ci

Example:

Explanation:

4. docs

Example:

Explanation:

5. feat

Example:

Explanation:

6. fix

Example:

Explanation:

7. perf

Example:

Explanation:

8. refactor

Example:

Explanation:

9. revert

Example:

Explanation:

10. style

Example:

Explanation:

Conclusion

NestJS Pipes and Essential Packages

Introduction

Basics of NestJS Pipes

Using the class-validator and class-transformer Packages

Enhancing API Documentation with @nestjs/swagger

Working with Query Parameters using @nestjs/parseint

Leveraging nestjs-query Packages for GraphQL APIs

Logging with winston for Enhanced Debugging

Conclusion

Additional Resources

ValidationPipe in NestJS

Understanding Data Validation in NestJS

Introducing the Class Validator Package

Using the ValidationPipe with Class Validator

Step 1: Install Required Packages

Step 2: Define Your DTO

Step 3: Apply ValidationPipe

Configuring Global ValidationPipe

Benefits of Global ValidationPipe

Conclusion

NestJS Pipes

Understanding NestJS Pipes

Types of Pipes

Applying Pipes

Useful Packages for NestJS Pipes

Examples of Types of Pipes

1. Built-in Pipes

ParseIntPipe and ParseFloatPipe

ValidationPipe

DefaultValuePipe

2. Custom Pipe

Custom Validation Pipe

Conclusion

Using the `class-validator` and `class-transformer` Packages

Enhancing API Documentation with `@nestjs/swagger`

Working with Query Parameters using `@nestjs/parseint`

Leveraging `nestjs-query` Packages for GraphQL APIs

Logging with `winston` for Enhanced Debugging

`ParseIntPipe` and `ParseFloatPipe`

`ValidationPipe`

`DefaultValuePipe`