DEV Community: Mirza Saikat Ahmmed

"Mastering Prisma ORM with NestJS: A Step-by-Step Guide to Installation and Connection Troubleshooting (Version 7.0.1)"

Mirza Saikat Ahmmed — Sun, 30 Nov 2025 15:10:16 +0000

# Mastering Prisma ORM with NestJS: A Step-by-Step Guide to Installation and Connection Troubleshooting (Version 7.0.1)

In the rapidly evolving landscape of web development, effective database management is pivotal to any application's success. As developers, we strive to choose tools that simplify our workflows while enhancing performance. Prisma ORM combined with NestJS offers a robust solution for modern application needs. In this blog post, we'll explore the seamless integration of Prisma ORM into a NestJS application, guiding you through installation, setup, and connection troubleshooting specifically for version 7.0.1.

## Table of Contents
1. [What is Prisma ORM?](#what-is-prisma-orm)
2. [Prerequisites](#prerequisites)
3. [Installing Prisma and NestJS](#installing-prisma-and-nestjs)
4. [Setting Up Prisma](#setting-up-prisma)
5. [Creating a Database Connection](#creating-a-database-connection)
6. [Connection Troubleshooting](#connection-troubleshooting)
7. [Testing the Connection](#testing-the-connection)
8. [Conclusion](#conclusion)

## What is Prisma ORM?
Prisma is an open-source database toolkit that streamlines interaction with your databases, making it easier to manage schemas, perform migrations, and execute queries. It abstracts much of the boilerplate code associated with traditional ORMs, allowing developers to focus on building their applications more efficiently.

## Prerequisites
Before diving into the installation process, ensure you have the following:

- **Node.js** (version 14 or above)
- **NestJS CLI** installed:

bash
npm install -g @nestjs/cli

- A **database** of your choice (PostgreSQL, MySQL, SQLite, etc.)
- A **basic understanding** of TypeScript and NestJS

## Installing Prisma and NestJS

1. **Create a New NestJS Project:**

bash
nest new my-nest-project


2. **Navigate to the Project Directory:**

bash
cd my-nest-project


3. **Install Prisma and Required Packages:**

bash
npm install @prisma/client prisma


4. **Initialize Prisma:**

bash
npx prisma init


   This command creates a new `prisma` directory with a `schema.prisma` file, where you will define your data models.

## Setting Up Prisma
With Prisma initialized, it's time to define your data models:

1. Open the `prisma/schema.prisma` file and specify your database connection. Here’s an example configuration for a PostgreSQL database:

prisma
datasource db {
provider = "postgresql"
url = env("DATABASE_URL")
}

generator client {
provider = "prisma-client-js"
}

model User {
id Int @id @default(autoincrement())
name String
email String @unique
}


2. Set your `DATABASE_URL` in the `.env` file:

DATABASE_URL="postgresql://USER:PASSWORD@localhost:5432/mydb"


3. **Run Migrations:**
   After defining your model, create the database tables with:

bash
npx prisma migrate dev --name init


## Creating a Database Connection

1. **Create a Prisma Service:**
   Generate a service to interact with your Prisma client.

bash
nest generate service prisma


2. **Implement the Prisma Client inside the Service:**
   Update `prisma.service.ts` to create a connection to your database.

typescript
import { Injectable } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';

@Injectable()
export class PrismaService extends PrismaClient {
constructor() {
super();
}
}


3. **Utilize the Prisma Service in Your Modules:**
   Import the Prisma service into any module needing database access.

## Connection Troubleshooting
If you encounter issues while connecting to the database, consider checking the following:

1. **Database URL:** Confirm that the `DATABASE_URL` is correctly formatted and the credentials are valid.
2. **Database Availability:** Ensure your database server is running. You can test connections using a database client like pgAdmin for PostgreSQL.
3. **Database Permissions:** Make sure the user specified in the `DATABASE_URL` has necessary permissions on the database.

## Testing the Connection
You can test the connection by creating a simple controller to interact with the Prisma service:

1. **Generate a User Controller:**

bash
nest generate controller user


2. **Update the User Controller:**

typescript
import { Controller, Get } from '@nestjs/common';
import { PrismaService } from './prisma.service';

@Controller('user')
export class UserController {
constructor(private readonly prisma: PrismaService) {}

 @Get()
 async getUsers() {
   return this.prisma.user.findMany();
 }

}


3. **Start Your NestJS Application:**

bash
npm run start


Visit `http://localhost:3000/user` in your browser to verify if data retrieval is successful.

## Conclusion
Utilizing Prisma ORM in a NestJS application can significantly simplify your data management and streamline the development process. By following the steps outlined in this guide, you are well on your way to effectively integrating these powerful tools. Equipped with knowledge of connection troubleshooting and testing, you can confidently build scalable applications featuring robust database interactions.

Stay tuned for future posts where we will delve into advanced features of Prisma ORM, such as advanced querying capabilities, relational data modeling, and more.

---

For more insights and updates on web development, don’t forget to subscribe to our blog!

Unlocking VS Code: The Ultimate Cheatsheet for Developers

Mirza Saikat Ahmmed — Sat, 12 Oct 2024 21:08:50 +0000

Visual Studio Code (VS Code) has become one of the most popular code editors among developers for its flexibility, vast extension marketplace, and robust features. Whether you’re a beginner or an experienced developer, mastering VS Code can significantly enhance your productivity. Here’s a handy cheatsheet that covers essential shortcuts, tips, and tricks to elevate your coding experience in VS Code.

1. Keyboard Shortcuts

Familiarizing yourself with keyboard shortcuts is key to navigating VS Code efficiently. Here are some essential shortcuts:

General Shortcuts

Open Command Palette: Ctrl + Shift + P (Windows/Linux) or Cmd + Shift + P (Mac)
Open File: Ctrl + O (Windows/Linux) or Cmd + O (Mac)
New File: Ctrl + N (Windows/Linux) or Cmd + N (Mac)
Open Settings: Ctrl + , (Windows/Linux) or Cmd + , (Mac)

Navigation

Quick Open: Ctrl + P (Windows/Linux) or Cmd + P (Mac) — Quickly open files by name.
Go to Line: Ctrl + G (Windows/Linux) or Cmd + G (Mac) — Jump to a specific line number.
Switch Between Editor Tabs: Ctrl + Tab (Windows/Linux) or Cmd + Option + → (Mac)

Editor Management

Split Editor: Ctrl + \ (Windows/Linux) or Cmd + \ (Mac)
Close Editor: Ctrl + W (Windows/Linux) or Cmd + W (Mac)
Format Document: Shift + Alt + F (Windows/Linux) or Shift + Option + F (Mac)

2. Extensions to Boost Productivity

VS Code has a vast marketplace filled with extensions to enhance your development workflow. Here are a few must-have extensions:

Prettier: A code formatter that ensures your code is consistent and clean.
Live Server: Launch a local development server with live reload for static and dynamic pages.
GitLens: Supercharge your Git capabilities with detailed insights into code changes and history.
Bracket Pair Colorizer: Colorizes matching brackets to improve code readability.

3. Integrated Terminal

The integrated terminal in VS Code allows you to run commands directly within the editor. Here are some useful commands:

Open Terminal: Ctrl + ` (Windows/Linux) or Cmd + ` (Mac)
Create New Terminal: Ctrl + Shift + (Windows/Linux) or Cmd + Shift + (Mac)
Kill Terminal: Ctrl + Shift + X (Windows/Linux) or Cmd + Shift + X (Mac)

4. Version Control with Git

VS Code provides built-in support for Git. Here are some Git-related shortcuts:

Open Source Control Panel: Ctrl + Shift + G (Windows/Linux) or Cmd + Shift + G (Mac)
Stage Changes: Ctrl + Shift + U (Windows/Linux) or Cmd + Shift + U (Mac)
Commit Changes: Type a commit message and press Ctrl + Enter (Windows/Linux) or Cmd + Enter (Mac)

5. Customizing Your Setup

Customizing VS Code to fit your workflow can make a significant difference. Here are some tips:

Themes: Change the look and feel of your editor with various themes available in the marketplace. Explore themes under Preferences: Color Theme.
Settings Sync: Enable settings sync to keep your preferences across multiple devices.
Keyboard Shortcuts: Customize shortcuts by navigating to File > Preferences > Keyboard Shortcuts.

Conclusion

Mastering VS Code involves knowing the right shortcuts, utilizing extensions, and customizing your setup. With the tips in this cheatsheet, you’re well on your way to becoming a VS Code pro!

You can connect with me on Linkedin: https://www.linkedin.com/in/mirzasaikatahmmed/
Follow me on GitHub: https://github.com/mirzasaikatahmmed

Git Cheatsheet that will make you a master in Git

Mirza Saikat Ahmmed — Sun, 29 Sep 2024 11:14:31 +0000

Introduction to Git

Git is a widely used version control system that allows developers to track changes and collaborate on projects. It has become an essential tool for managing code changes, whether working solo or in a team. However, mastering Git can be a challenge, especially for beginners who are not familiar with its commands and features. In this Git cheatsheet, we will cover both the basic and advanced Git commands that every developer should know. From creating a repository to branching, merging, and beyond, this cheatsheet will serve as a handy reference guide for anyone looking to improve their Git skills and become a more proficient developer. Whether you are just starting with Git or looking to enhance your existing knowledge, this cheatsheet will help you make the most out of Git and optimize your workflow.

Basic Git commands

Initialization

To initialize a new Git repository in the current directory, run the following command:

git init

This creates a hidden .git directory in the current directory that tracks changes to your code.

Cloning

To clone an existing Git repository to your local machine, run the following command:

git clone <repository URL>

This creates a new directory on your computer with a copy of the repository.

Staging changes

Before you commit changes to your code, you need to stage them using the git add command. This tells Git which changes you want to include in your commit.
To stage a file or directory, run the following command:

git add <file/directory>

You can also stage all changes in the current directory by running:

git add .

Committing changes

To commit the changes in the staging area with a commit message, run the following command:

git commit -m "<commit message>"

The commit message should briefly describe the changes you made in the commit.

Checking status

To check the current status of your repository, run the following command:

git status

This will show you which files have been modified, which files are staged for commit, and which files are untracked.

Viewing changes

To view the changes between the working directory and the staging area, run the following command:

git diff

To view the changes between the staging area and the last commit, run the following command:

git diff --cached

Branching

Git allows you to create multiple branches of your code so that you can work on different features or fixes without affecting the main codebase. The default branch in Git is called master.

To create a new branch with the specified name, run the following command:

git branch <branch name>

To switch to the specified branch, run the following command:

git checkout <branch name>

You can also create and switch to a new branch in one command by running:

git checkout -b <branch name>

To merge the specified branch into the current branch, run the following command:

git merge <branch name>

Pushing changes

To push changes to a remote repository, run the following command:

git push <remote> <branch>

is the name of the remote repository, and is the name of the branch you want to push.

Pulling changes

To pull changes from a remote repository, run the following command:

git pull <remote> <branch>

<remote> is the name of the remote repository, and <branch> is the name of the branch you want to pull.

Viewing history

To view the commit history, run the following command:

git log

This will show you a list of all the commits in the repository, along with the commit message, author, and date.

Advanced Git commands

Reverting changes

If you need to undo a commit, you can use the git revert command. This creates a new commit that undoes the changes made in the specified commit.

Resetting changes

If you want to undo a commit and remove it from the commit history, you can use the git reset command. This removes the specified commit and all subsequent commits from the commit history. There are three options for git reset: --soft, --mixed, and --hard.

--soft
only resets the commit history and leaves the changes in the staging area.
--mixed resets the commit history and unstages the changes.
--hard resets the commit history, unstages the changes, and discards all changes made after the specified commit.

To reset the last commit using --soft, run the following command:

git reset --soft HEAD~1

To reset the last commit using --mixed, run the following command:

git reset --mixed HEAD~1

To reset the last commit using --hard, run the following command:

git reset --hard HEAD~1

Rebasing

If you want to apply your changes to a different branch, you can use the git rebase command. This command applies your changes on top of the specified branch.
To rebase the current branch onto the specified branch, run the following command:

git rebase <branch name>

Stashing

If you want to save changes without committing them, you can use the git stash command. This saves the changes in a stack of temporary commits, allowing you to switch to a different branch or work on something else.
To stash your changes, run the following command:

git stash

To apply your changes again, run the following command:

git stash apply

Cherry-picking

If you want to apply a specific commit from one branch to another, you can use the git cherry-pick command. This command applies the specified commit on top of the current branch.
To cherry-pick the specified commit, run the following command:

git cherry-pick <commit hash>

Git hooks

Git hooks are scripts that run automatically before or after specific Git commands, allowing you to customize the behavior of Git. Git comes with a set of built-in hooks, but you can also create your own custom hooks.
To create a custom Git hook, navigate to the .git/hooks directory in your Git repository and create a new file with the name of the hook you want to create (e.g., pre-commit, post-merge). The file should be executable and contain the script you want to run.

Git aliases

Git aliases are shortcuts for Git commands, allowing you to save time and type less. You can create your own custom aliases using the git config command.
To create a new alias, run the following command:

git config --global alias.<alias name> '<command>'

<alias name> is the name of the alias you want to create, and <command> is the Git command you want to alias.

Git workflows

Git workflows are strategies for using Git to manage code changes in a team. There are several popular Git workflows, including the centralized workflow, the feature branch workflow, and the Gitflow workflow.
The centralized workflow is a simple workflow that involves a single main branch, with all changes made directly to that branch.
The feature branch workflow involves creating a new branch for each feature or bug fix, and merging those branches back into the main branch when the changes are complete.
The Gitflow workflow is a more complex workflow that involves multiple branches, including a develop branch for ongoing development, a release branch for preparing releases, and feature branches for individual features.

Conclusion

In conclusion, Git is a powerful tool for version control and managing code changes. It allows developers to collaborate on projects, track changes, and revert to previous versions when necessary. While the basic Git commands are essential to know, the advanced Git commands discussed in this cheat sheet can help you be more efficient and effective when working with Git.

You can connect with me on Linkedin: https://www.linkedin.com/in/mirzasaikatahmmed/
Follow me on GitHub: https://github.com/mirzasaikatahmmed

Create Personal Portfolio Using Github Api with Blog

Mirza Saikat Ahmmed — Tue, 02 Aug 2022 12:48:43 +0000

For a developer, a personal portfolio plays an important role to showcase his/her works, reach to potential clients or land a job. But making it requires a tremendous amount of works and time. Also maintaining it manually with the latest project is a pain.

What if you could create your portfolio in 5 minutes just by providing your Github username and even host it without any cost? Do you want to display your skills, job history, education history, or even dev.to posts to your website? Then you are in right place.

Introducing GitProfile to kickstart your personal portfolio with Github Api and blog.