DEV Community: Tamim Ikbal

Finding the Peak Index in a Mountain Array

Tamim Ikbal — Tue, 04 Feb 2025 07:53:56 +0000

Hello, my friends! Hope you’re all doing great. Today, we’ll solve the problem of finding a Peak Element in a Mountain Array.

Here is my submission on LeetCode.

What is a Peak Element?

A peak element in an array is an element that is greater than both of its neighbors. Simply put, if array[i] is the peak, then:

array[i - 1] < array[i] && array[i] > array[i + 1]

To optimize the search, I use Binary Search to maintain efficient time complexity, moving left or right based on the mid value.

Edge Case: If the array length is 1 or less (array.length <= 1), we return the 0 index.
Edge Case: If the first element is greater than the next (array[0] > array[1]), we return 0, since the first index is the peak index.
Edge Case: If the last element is greater than the previous (array[array.length - 1] > array[array.length - 2]), we return array.length - 1, as the last element is the peak.
Now, if array[mid - 1] < array[mid] && array[mid] > array[mid + 1], we return mid, because it's the peak element, being greater than its neighbors.
Else If: array[mid] > array[mid - 1], we move right since array[mid] is greater than the left element, meaning the peak lies to the right.
Else: We move left, as mid is greater than the right element.

Let's Code

I will code in JavaScript to find the peak element and implement Binary Search for an optimized solution.

var findPeakElement = function (nums) {
  let length = nums.length;

  if (1 >= length) {
    return 0;
  }

  if (nums[0] > nums[1]) {
    return 0;
  }

  if (nums[length - 1] > nums[length - 2]) {
    return length - 1;
  }

  let left = 1;
  let right = length - 2;
  while (left <= right) {
    let mid = Math.floor((left + right) / 2);

    if (nums[mid - 1] < nums[mid] && nums[mid] > nums[mid + 1]) {
      return mid;
    } else if (nums[mid] > nums[mid - 1]) {
      left = mid + 1;
    } else {
      right = mid - 1;
    }
  }

  return -1;
};

Run Some Test:

console.log(findPeakElement([1, 2, 3, 1])); // Index: 2, Element: 3
console.log(findPeakElement([1, 2, 1, 3, 5, 6, 4])); // Index: 5, Element: 6
console.log(findPeakElement([1])); // Index: 0, Element: 1
console.log(findPeakElement([3, 4, 3, 2, 1])); // Index: 1, Element: 4

You can try this problem: Leetcode

Thanks for reading.

Setup Validation Pipes & Yup for NestJS Request Validation.

Tamim Ikbal — Mon, 03 Feb 2025 17:10:48 +0000

Hello my friends, Hope you are all doing well. Today we will set up a Validation Pipes to validate Requests based on the Yup Validation rule schema. Let’s Code.

1. Creating our NestJS Project

npm i -g @nestjs/cli
nest new project-name

2. Install YUP

Yup is a powerful schema builder for runtime value parsing and validation. So in this article, we will use Yup for validation.

npm i yup
yarn add yup

3. Create The Todo DTO And Validation Schema

Let's say we have an application where we require a Title and Description.

import { object, string, InferType } from 'yup';

export const createTodoSchema = object({
  title: string().min(3).required(),
  description: string().required(),
});

export type createTodoDto = InferType<typeof createTodoSchema>;

Here we created a Yup object with a set of validation rules and export then we generated and export the todo DTO createTodoDto from createTodoSchema;

4. Create A Validator Pipes

Now, We have to create a Validation Pipes with will validate the Request based on our giver YUP Object.

validator.pipes.ts

import {
    ArgumentMetadata,
    HttpException,
    HttpStatus,
    Injectable,
    PipeTransform,
  } from '@nestjs/common';
  import { Schema, ValidationError } from 'yup';

  @Injectable()
  export class Validator implements PipeTransform {
    constructor(private schema: Schema) {}

    transform(value: any, metadata: ArgumentMetadata) {
      try {
        //Validate the request input data based on the Validation rule..
        return this.schema.validateSync(value, { abortEarly: false });
      } catch (error) {

        //When got error from YUP catch it and process the errors.
        if (error instanceof ValidationError) {
          const errors = {};

          //Formate the errors
          error.inner.forEach((err: ValidationError) => {
            const path = err.path || '';
            const messages = errors[path] || [];
            errors[path] = [err.message, ...messages];
          });

          //Throw the Exceptoom with The errors and Status code 422.
          throw new HttpException(
            {
              message: 'Validation failed',
              errors: errors,
            },
            HttpStatus.UNPROCESSABLE_ENTITY,
          );
        }

        //Cache rest of the errors and throw it with 500 server error.
        throw new HttpException(
          {
            message: 'Something went wrong',
          },
          HttpStatus.INTERNAL_SERVER_ERROR,
        );
      }
    }
  }

Here, we create a class Validator which is a custom Nestjs pipes (read more about pipes).
In the constructor function we initiated the YUP schema.
Now, As we implement the PipeTransform interface, we have to use transform method and which will be called By Nestjs automatically.

On validation failed

Given system will throw the error with this formate.

{
  "message": "Validation failed",
  "errors": {
    "title": [
      "title is a required field",
      "title must be at least 3 characters"
    ],
    "description": [
      "description is a required field"
    ]
  }
}

5. Use the Validator Pipe

Let’s validate the request of store method.

todo.controller.ts

import { Body, Controller, Get, Post, UsePipes } from '@nestjs/common';
import { TodoService } from './todo.service';
import { Todo } from './todo.interface';
import { createTodoDto, createTodoSchema } from './dto/create.dto';
import { Validator } from '../../Pipes/validator.pipe';

@Controller('todos')
export class TodoController {
  constructor(private readonly todoService: TodoService) {}

  @Get()
  async index(): Promise<Todo[]> {
    return await this.todoService.findAll();
  }

  @Post()
  //We can use our Custom Validator Pipes with Nestjs @UsePipes decorator. 

  @UsePipes(new Validator(createTodoSchema))
  async store(@Body() todoDto: createTodoDto): Promise<ApiResponse<Todo>> {
    console.log(todoDto);
    const todo = await this.todoService.create(todoDto);
    return {
      message: 'Todo Created Updated!',
      payload: todo,
    };
  }
}

Explanation: In the @UsePipes decorator we passed our Validator class instance with the createTodoSchema schema and the Validator class will validate the request with defines rull on createTodoSchema.

todo.service.ts

import { Injectable } from '@nestjs/common';
import { Repository } from 'typeorm';
import { Todo } from './todo.entity';
import { InjectRepository } from '@nestjs/typeorm';
import { createTodoDto } from './dto/create.dto';
import { ConfigService } from '@nestjs/config';

@Injectable()
export class TodoService {
  constructor(
    @InjectRepository(Todo)
    private todoRepository: Repository<Todo>,
    private config: ConfigService,
  ) {}

  findAll(): Promise<Todo[]> {
    console.log(this.config.get('app.name'));
    return this.todoRepository.find();
  }

  create(todoDto: createTodoDto): Promise<Todo> {
    const todo = new Todo();
    todo.title = todoDto.title;
    return this.todoRepository.save(todo);
  }
}

Thanks for reading. If you want to read more about Custom Pipes please read the Nestjs official docs here.

How to Set Up Custom Configuration Files in NestJS

Tamim Ikbal — Sun, 02 Feb 2025 04:54:18 +0000

Hello my friends, I Hope you are all doing well. Today we will learn how to set up the custom config file in nestjs.

NestJS is a powerful JavaScript framework that provides all the essential functionalities needed for building scalable applications. However, it's not fully structured, you need to organize it yourself. While NestJS provides recommendations, it's up to us to implement a clean and maintainable configuration setup.

In this guide, we will set up a custom configuration file to keep our application settings structured and easy to manage. Let’s get started!

Let's say you have an env file with some different type of variable, for example:

APP_NAME=Laravel
APP_ENV=local
APP_TIMEZONE=UTC

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=root
DB_PASSWORD=

Now, We can get and use them by process.env in our js code which is not ideal for production because of performance, security, and caching.

So, let’s create a config file for them but here also we shouldn't tie them into one file then we will break SRP and this will be harder to manage. So, let's do this step by step.

1. Creating our NestJS Project

To create a NestJs project, we need to run the following commands in our terminal.

npm i -g @nestjs/cli
nest new project-name

2. Install Nestjs Config

npm i --save @nestjs/config

3. Make the configuration file

Create the respective configuration files in the src/config folder. In this case, app.config.js and database.config.js.

4. Write the Config File

app.config.js

import * as process from 'node:process';
import { registerAs } from '@nestjs/config';

const config = () => ({
  name: process.env.APP_NAME || 'NestApp',
  env: process.env.APP_ENV || 'production',
  debug: process.env.APP_DEBUG === 'true',
  timezone: process.env.APP_TIMEZONE || 'UTC',
  locale: process.env.APP_LOCALE || 'en',
});

export default registerAs('app', config);

database.config.js

import * as process from 'node:process';
import { registerAs } from '@nestjs/config';

const config = () => ({
  database: process.env.DB_CONNECTION || 'mysql',
  connection: {
    mysql: {
      type: 'mysql',
      host: process.env.DB_HOST || 'localhost',
      port: parseInt(process.env.DB_PORT, 10) || 3306,
      username: process.env.DB_USERNAME || 'root',
      password: process.env.DB_PASSWORD || '',
      database: process.env.DB_NAME || '',
      entities: ['./../Models/*.entity{.ts,.js}'],
      migrations: ['./../database/migrations/*{.ts,.js}'],
      synchronize: false,
      migrationsRun: false,
      logging: process.env.DB_LOGGING === 'true',
    },
  },
});

export default registerAs('database', config);

Explanation

We define a configuration object and export it using nestjs registerAs(), which provides a namespace (prefix) for the configuration to avoid conflict between config key.

5. Import and Setup the ConfigModule

app.module.ts

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import appConfig from './config/app.config';
import databaseConfig from './config/database.config';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true, // Makes config accessible throughout the application
      load: [appConfig, databaseConfig],
    }),
  ],
  controllers: [],
  providers: [],
})
export class AppModule {}

6. Using Config Values in the Application

app.service.ts

import { Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';

@Injectable()
export class AppService {
  constructor(private config: ConfigService) {}

  getHello(): string {
    console.log(this.config.get('app.name')); // Fetching APP_NAME from config
    return 'Hello World!';
  }
}

That’s it! Now you have a powerful and organized configuration setup in NestJS. 🚀

Thanks for reading! 🙌

To Read more about Nest COnfig Please Visit: https://docs.nestjs.com/techniques/configuration