Many things in the tech sound intimidating when you first learn of them than they actually are. ORMs (Object Relational Mappers) are just one of them; we also have quite a number of options for any Nodejs application but I'll share some incites into getting started with Prisma ORM.
What are ORMs?
Object-relational mapping conceptualizes the idea of being able to write queries like the one below, as well as much more complicated ones, using the object-oriented paradigm of your preferred programming language.
Essentially, ORMs help abstract the complexities of writing custom SQL queries to a database.
SELECT * FROM user where countryId = 2
Well, just like any other tool or library, we have pros and cons to using them. For the most part, I stumbled on Prisma, and it's arguably an excellent tool for low to medium-level complexity and enterprise apps.
- You easily scaffold a Nodejs server with a database quickly with the least amount of code.
- It's open-source, it's compatible with a number of SQL such as PostgreSQL, MySQL, and SQLite.
- Out of the box support for typescript.
- Many tools aren't properly documented and we have to rely on the community for help when stuck, but Prisma documentation is quite delightful and very detailed.
Next up we will look at some prerequisites for this tutorial, featuring Prisma, Express.js + typescript, and PostgreSQL.
Prerequisites
This tutorial assumes you've had some experience with Nodejs ;
- You have the Nodejs LTS installed
- Scaffold an Expressjs app
- Basic knowledge of Javascript/typescript
- Some idea of how ORMs interact with databases
Implementation
Lets set Up the Express.js app
- We’ll begin by setting up the Express.js app for a Movies listing API demo project.
Navigate into a new folder First, then run the following to create a new project:
we also assume you're using a Unix shell/terminal
mkdir movies-listing-api
cd movies-listing-api
npm init -y
- Next, install Express.js, our minimalistic framework for the Star Wars REST API:
npm install
- Next, setup typescript dev dependencies
npm install typescript
npm install @types/node
- Next, Create a tsconfig.json file
The tsconfig.json is where we define the TypeScript compiler options. We can create a tsconfig with several options sets. it should be at the root directory of the project.
npx tsc --init --rootDir src --outDir build \
--esModuleInterop --resolveJsonModule --lib es6 \
--module commonjs --allowJs true --noImplicitAny true
At this point, you should have a tsconfig.json that looks like this:
{
"compilerOptions": {
// "incremental": true,
"target": "es5",
"module": "commonjs",
"lib": ["es6"],
"allowJs": true,
// "checkJs": true,
// "jsx": "preserve",
// "declaration": true,
// "declarationMap": true,
// "sourceMap": true,
// "outFile": "./",
"outDir": "build",
"rootDir": "src",
// "composite": true,
// "tsBuildInfoFile": "./",
// "removeComments": true,
// "noEmit": true,
// "importHelpers": true,
// "downlevelIteration": true,
// "isolatedModules": true,
"strict": true,
"noImplicitAny": true,
// "strictNullChecks": true,
// "strictFunctionTypes": true,
// "strictBindCallApply": true,
// "strictPropertyInitialization": true,
// "noImplicitThis": true,
// "alwaysStrict": true,
// "noUnusedLocals": true,
// "noUnusedParameters": true,
// "noImplicitReturns": true,
// "noFallthroughCasesInSwitch": true,
// "moduleResolution": "node",
// "baseUrl": "./",
// "paths": {},
// "rootDirs": [],
// "typeRoots": [],
// "types": [],
// "allowSyntheticDefaultImports": true,
"esModuleInterop": true,
// "preserveSymlinks": true,
// "allowUmdGlobalAccess": true,
// "sourceRoot": "",
// "mapRoot": "",
// "inlineSourceMap": true,
// "inlineSources": true,
// "experimentalDecorators": true,
// "emitDecoratorMetadata": true,
"resolveJsonModule": true
}
}
- Next, set up the entry point of the application by checking out into the project/src directory and create two files app.ts and server.ts .
mkdir && cd src
touch server.ts
touch app.ts
the files should look like this :
This will contain the express routing and handle API requests.
#app.ts
import express, { Application } from 'express';
const app: Application = express();
export default app;
This Nodejs server, serves the express application and exposes it over process.env.PORT or 8000;
#server.ts
import app from './app';
const PORT = process.env.PORT || 8000;
app.listen(PORT, () => console.log(`⚡ on http://localhost:${PORT}/api`));
- Next up, we’ll set up a PostgreSQL database to create our tables for the star-wars movie API.
Set Up a Local PostgreSQL Database with docker
Create a Postgres image at the root of the project directory, build the image, and run it.
touch postgres.yaml
the docker-compose file should look this:
version: '3'
services:
postgres:
image: postgres:10.3-alpine
ports:
- '5432:5432'
network_mode: bridge
container_name: postgres_docker
environment:
POSTGRES_USER: 'postgres'
POSTGRES_PASSWORD: 'pgpass'
POSTGRES_DB: 'postgres'
volumes:
- ./initdb:/docker-entrypoint-initdb.d
If you want to run a PostgreSQL database with Docker, use the following command:
docker compose -f postgres.yaml up
The docker run command creates a new docker container named postgres_docker, exposing the container port 5432 to the local port 5432.
Our database is up and running. Next up, we will add Prisma to our Node.js project and create our schema.
Install Prisma ORM to Your Node.js Project
Run the following command, which installs Prisma as a dev dependency
npm install prisma
After that, initialize the Prisma schema with the following command:
npx prisma init
Next, add the database connection string to the env file,
it should look this:
DATABASE_URL="postgresql://postgres:pgpass@localhost:5432/movies_storage?schema=public"
Add Models and Run Prisma Migration
the Prisma folder at the root directory contains prisma.schema file, in it we define our database tables for Movies and Users with their relation.
datasource db {
provider = "postgresql"
url = env("DATABASE_URL")
}
generator client {
provider = "prisma-client-js"
}
model Movie {
id Int @id @default(autoincrement())
title String @unique
description String
createdAt DateTime @default(now())
}
We have added One table to the schema. The Movies table, which has an auto-increment ID, the title field that must be unique, description, and createdAt field that defaults to the current date.
To convert these models into PostgreSQL database tables, run the following command:
prisma migrate dev
This generates the migration file, that contains the SQL that creates the tables in the PostgreSQL database.
API to interact with movie listings
We will Update the app.ts file we created in a previous step and add the POST Movies and GET Movies API.
const app: Application = express();
import { PrismaClient } from '@prisma/client';
const prisma = new PrismaClient();
app.get('/', (req, res) => {
res.json({message: 'alive'});
});
app.post('/movies', async (req, res) => {
const {title, description} from 'req.body';
await prisma.movie.create({
data: {
title,
description,
}
});
res.json({
message: "movie created"
});
});
app.get('/movies:id', async (req, res) => {
const movie = await prisma.movie.findUnique({
where:{
id: req.params.id
},
});
res.json({
data: movie,
});
}
app.get('/movies', async (req, res) => {
const allMovies = await prisma.movie.findMany({});
res.json({
data: allMovies,
});
});
export default app;
Wrap-up
We built a Movie listing API with Express.js+typescript and Prisma ORM, using a PostgreSQL database running on Docker. I know we barely scratched the surface of what Prisma offers, nonetheless, I'm hoping this gives you some insights into adding Prisma ORM to your Nodejs apps.
To finish up, I suggest you further explore some great Prisma ORM features. For instance, query optimization, database transactions, and aggregate queries are good reads.
Thanks for the audience and I hope you found this article helpful 🤗. Feel free to reach out to me on Github, Twitter and LinkedIn.
Do drop a like, comment, and share 😌.
Happy coding!
