How To Use Prisma With Express? A Step-by-Step Guide

How To Use Prisma With Express?

Lavesh Katariya
November 2, 2023

13 mins read

Last updated November 2, 2023

Express stands out as a robust Node.js framework, allowing you to develop API servers and backend applications. The framework significantly streamlines the entire process by offering a rich library of pre-built tools tailored for developing varying functionalities. Not only does the framework reduce the volume of code required, but it also reduces the required effort.

However, when it comes to establishing a connection with a database, it can become somewhat challenging for those who avoid writing database queries for any reason. You want a tool that can simplify this process so you can focus on writing application logic. In such situations, you can use an ORM (Object-Relational Mapper). ORMs work as intermediaries that simplify data manipulation and can be integrated with frameworks.

In addition, they offer several advantages such as:

They can save you a lot of time and effort, and without learning the database languages and the underlying technologies, you can work with databases.
They can automate much of this work, so you can focus on building your application.
They also offer features such as autocompletion for database queries, type safety, data modeling, migrations, integration with GraphQL, etc.

Coming back to Express, it supports major popular ORMs such as Sequelize, Prisma, and TypeORM to work with databases. This article will show you how to use Prisma to create a RESTful API with Express.js.

Before we get into that topic, let's first familiarize ourselves with Prisma and its essential features that can significantly enhance your database workflow.

What is Prisma?

Prisma is a popular open-source ORM that provides an abstraction over database connections and operations, making it easier for developers to interact with various databases using a unified API. Also, it can automate the several processes of generating database models, querying, and data manipulation, reducing the need for manual SQL queries and minimizing the likelihood of errors.

It is well known for various features that greatly simplify database communication, which are as follows:

1. Prisma Client

Prisma Client is an auto-generated query builder that acts as a bridge between your application code and the database. It generates type-safe queries and functions to ensure type safety. In addition, it offers autocompletion which can help you to write queries more quickly and accurately.

While talking about the databases it supports, it supports multiple database providers, including MySQL, PostgreSQL, and SQLite. This empowers developers to seamlessly switch databases without extensive code changes.

2. Effortless Database Connections

Prisma simplifies the process of establishing database connections. Instead of configuring connections manually, Prisma leverages the concept of "Datasources" defined in the schema.prisma file. By specifying the provider and connection URL, developers can seamlessly switch between development, staging, and production environments. This abstraction streamlines the deployment process and improves scalability.

3. Prisma Migration

Migrating database schemas is a critical aspect of application development. Prisma introduces a powerful migration system that, a migration tool that tracks changes in the schema generates migration scripts, and applies them to the database. This ensures that your database schema is always in sync with your application's codebase.

Contact us now to access our skilled Node.js developers and take your development to the next level.

Using Prisma with Express

Now that we have explored its key features, let's delve into how to work with Prisma with Express by creating a simple application.

Step 1: Set Up Your Project

Create a new directory for your project and navigate into it.
Initialize your project by running `npm init` and following the prompts.
Install the required dependencies:

npm install express @prisma/client

Step 2: Define Prisma Schema

Create a directory named `prisma` in your project root.
Inside the `prisma` directory, create a file named `schema.prisma` and define your database schema and connection details. For instance:

datasource db {

provider = "mysql" // or your preferred database provider

url = env("DATABASE_URL")

}

generator client {

provider = "prisma-client-js"

}

Step 3: Generate Prisma Client

Run the following command to generate the Prisma Client based on your schema:

npx prisma generate

Step 4: Set Up Express Server

Create a file named `index.js` (or `app.js`) in your project root.
Set up your Express server and import the necessary modules:

const express = require('express');

const { PrismaClient } = require('@prisma/client');

const app = express();

const prisma = new PrismaClient();

const PORT = process.env.PORT || 3000;

app.listen(PORT, () => {

console.log(`Server is running on port ${PORT}`);

});

Step 5: Create Routes

Create a `routes` directory in your project.
Inside the `routes` directory, create a file named `users.js` (for example).
Define your Express routes in the `users.js` file to interact with the Prisma Client:

const express = require('express');

const router = express.Router();

const { PrismaClient } = require('@prisma/client');

const prisma = new PrismaClient();

// GET /users

router.get('/users', async (req, res) => {

try {

const users = await prisma.user.findMany();

res.json(users);

} catch (error) {

res.status(500).json({ error: 'An error occurred' });

}

});

// POST /users

router.post('/users', async (req, res) => {

const { name, email } = req.body;

try {

const user = await prisma.user.create({

data: {

name,

email,

});

res.json(user);

} catch (error) {

res.status(500).json({ error: 'An error occurred' });

}

});

module.exports = router;

Step 6: Use Routes in Express Server

In your `index.js` (or `app.js`), use the routes you've defined:

const usersRouter = require('./routes/users');

app.use(express.json()); // Parse JSON request bodies

app.use('/api', usersRouter); // Use the /api prefix for your routes

// Other middleware and routes can be added here

Step 7: Run Your Server

Start your Express server by running:

node index.js

Your REST API with Express and Prisma is now up and running.

You can use tools like Postman or your browser to test the API endpoints (`GET /api/users` and `POST /api/users` in this example).

Final Words

This article explores the synergy between Prisma and Express for seamless database communication. Prisma is a cutting-edge Object Relational Mapper (ORM) tool that can significantly improve the efficiency of backend development.

Unlock the potential of modern, secure, and efficient web applications by leveraging the synergy of Prisma and Express.

Whether you're looking to upgrade your existing app or start from scratch, our team of skilled Node.js developers can help you turn your vision into reality. Don't wait—contact us today to learn more about our services.

Lavesh Katariya

With over 8 years of experience in the MERN stack, I specialize in building robust and scalable web applications. Proficient in MongoDB, Express.js, React.js, and Node.js, my passion for clean code and innovative problem-solving ensures high-quality solutions.

Get In Touch

get in touch

READY TO DEVELOP YOUR SUCCESS STORY WITH US?

Get in Touch