How To Use Prisma With Express?

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 Express 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:

1. 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.
2. They can automate much of this work, so you can focus on building your application.
3. 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 Express Prisma and its essential features that can significantly enhance your database workflow.

What is Prisma Express?

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. Prisma Express seamlessly bridges the gap between native and cross-platform development, offering robust database integration and consistent performance across diverse environments.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.

Using Prisma with Express

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

Step 1: Set Up Your Project

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

npm install express @prisma/client

Step 2: Define Prisma Schema

1. Create a directory named `prisma` in your project root.
2. 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

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

npx prisma generate

Step 4: Set Up Express Server

1. Create a file named `index.js` (or `app.js`) in your project root.
2. 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

1. Create a `routes` directory in your project.
2. Inside the `routes` directory, create a file named `users.js` (for example).
3. 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

1. 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

1. 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).

Conclusion

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.