Prisma ORM with GraphQL

Introduction

Prisma ORM helps you easily work with databases using simple code. GraphQL lets you ask for exactly the data you want. Together, they make fetching and changing data smooth and clear.

When building a web app that needs to get or save data from a database.

When you want to ask for only specific data fields to reduce loading time.

When you want to keep your database code clean and easy to understand.

When you want to connect your database with a frontend app using a flexible API.

When you want to avoid writing complex SQL queries by hand.

Syntax

GraphQL

type Query {
  allUsers: [User!]!
}

type Mutation {
  createUser(name: String!, email: String!): User!
}

type User {
  id: ID!
  name: String!
  email: String!
}

// In your resolver file (JavaScript/TypeScript):
const { PrismaClient } = require('@prisma/client');
const prisma = new PrismaClient();

const resolvers = {
  Query: {
    allUsers: async () => {
      return await prisma.user.findMany();
    },
  },
  Mutation: {
    createUser: async (_, args) => {
      return await prisma.user.create({ data: args });
    },
  },
};

The GraphQL schema defines what data you can ask for or change.

Resolvers connect GraphQL queries and mutations to Prisma database commands.

Examples

This query fetches all users from the database.

GraphQL

type Query {
  allUsers: [User!]!
}

// Resolver example
allUsers: async () => {
  return await prisma.user.findMany();
}

This mutation adds a new user with a name and email.

GraphQL

type Mutation {
  createUser(name: String!, email: String!): User!
}

// Resolver example
createUser: async (_, args) => {
  return await prisma.user.create({ data: args });
}

This query fetches one user by their unique ID.

GraphQL

type Query {
  userById(id: ID!): User
}

// Resolver example
userById: async (_, args) => {
  return await prisma.user.findUnique({ where: { id: Number(args.id) } });
}

This mutation deletes a user by ID and returns the deleted user data.

GraphQL

type Mutation {
  deleteUser(id: ID!): User
}

// Resolver example
deleteUser: async (_, args) => {
  return await prisma.user.delete({ where: { id: Number(args.id) } });
}

Sample Program

This program defines a simple GraphQL schema and resolvers using Prisma ORM. It shows fetching all users, adding a new user, and fetching all users again to see the change.

GraphQL

// GraphQL schema
const { gql } = require('apollo-server');

const typeDefs = gql`
  type User {
    id: ID!
    name: String!
    email: String!
  }

  type Query {
    allUsers: [User!]!
  }

  type Mutation {
    createUser(name: String!, email: String!): User!
  }
`;

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

const resolvers = {
  Query: {
    allUsers: async () => {
      return await prisma.user.findMany();
    },
  },
  Mutation: {
    createUser: async (_, args) => {
      return await prisma.user.create({ data: args });
    },
  },
};

// Example usage (simulate calling resolvers)
async function runExample() {
  console.log('Users before:');
  let usersBefore = await resolvers.Query.allUsers();
  console.log(usersBefore);

  console.log('\nCreating a new user...');
  let newUser = await resolvers.Mutation.createUser(null, { name: 'Alice', email: '[e-mail]' });
  console.log(newUser);

  console.log('\nUsers after:');
  let usersAfter = await resolvers.Query.allUsers();
  console.log(usersAfter);
}

runExample();

Important Notes

Prisma ORM automatically generates database queries, so you don't write SQL directly.

GraphQL lets clients ask for only the data they need, which can improve app speed.

Remember to handle errors in real apps, like when a user already exists or input is invalid.

Summary

Prisma ORM and GraphQL work together to make database access easy and flexible.

Define your data types and operations in GraphQL schema, then connect them to Prisma in resolvers.

This setup helps build clean, efficient APIs for apps that need database data.

Practice

1. What is the main role of Prisma ORM when used with GraphQL?

easy

A. To define GraphQL schema types

B. To style the frontend user interface

C. To handle HTTP requests from clients

D. To manage database access and queries easily

Solution

1. Step 1: Understand Prisma ORM's purpose

   Prisma ORM acts as a tool to simplify database operations by providing an easy way to query and manage data.

2. Step 2: Differentiate Prisma from GraphQL schema and frontend roles

   GraphQL schema defines data types and operations, while frontend styling is unrelated to Prisma's role.

3. Final Answer:

   To manage database access and queries easily -> Option D

4. Quick Check:

   Prisma ORM = database access tool [OK]

Hint: Prisma handles database, GraphQL defines schema [OK]

Common Mistakes:

• Confusing Prisma with GraphQL schema definition
• Thinking Prisma manages frontend UI
• Assuming Prisma handles HTTP requests

2. Which of the following is the correct way to import Prisma Client in a Node.js GraphQL resolver file?

easy

A. import Prisma from 'prisma';

B. const PrismaClient = require('prisma-client');

C. import { PrismaClient } from '@prisma/client';

D. const { Prisma } = require('@prisma/client');

Solution

1. Step 1: Recall Prisma Client import syntax

   The official Prisma Client is imported using ES module syntax: import { PrismaClient } from '@prisma/client';

2. Step 2: Identify incorrect import forms

   Options B, C, and D use wrong package names or destructuring that Prisma does not support.

3. Final Answer:

   import { PrismaClient } from '@prisma/client'; -> Option C

4. Quick Check:

   Correct Prisma import = import { PrismaClient } from '@prisma/client'; [OK]

Hint: Use exact package '@prisma/client' with named import [OK]

Common Mistakes:

• Using wrong package name like 'prisma-client'
• Incorrect destructuring of PrismaClient
• Mixing CommonJS require with ES import incorrectly

3. Given this GraphQL resolver using Prisma:

const users = await prisma.user.findMany({ where: { active: true } });
return users;

What does this resolver return?

medium

A. All users including inactive ones

B. Only users with active set to true

C. An error because 'active' is not a valid field

D. An empty list always

Solution

1. Step 1: Analyze the Prisma query filter

   The query uses findMany with a where clause filtering users where active equals true.

2. Step 2: Understand the result of the query

   It returns only users whose active field is true, excluding inactive users.

3. Final Answer:

   Only users with active set to true -> Option B

4. Quick Check:

   findMany with where active:true = filtered users [OK]

Hint: Where filters results; active:true returns only active users [OK]

Common Mistakes:

• Assuming it returns all users ignoring filter
• Thinking it causes an error without schema check
• Believing it always returns empty list

4. You wrote this resolver code but get an error:

const newUser = prisma.user.create({
  data: {
    name: 'Alice'
  }
});
return newUser;

What is the likely cause of the error?

medium

A. Missing await before prisma.user.create call

B. Incorrect field name 'name' in data

C. Using create instead of findMany

D. Returning newUser before defining it

Solution

1. Step 1: Check asynchronous Prisma call

   prisma.user.create returns a Promise, so it needs await to resolve before returning.

2. Step 2: Identify missing await causing error

   Without await, newUser is a Promise, not the created user object, causing issues in return.

3. Final Answer:

   Missing await before prisma.user.create call -> Option A

4. Quick Check:

   Async Prisma calls need await [OK]

Hint: Always await Prisma async calls in resolvers [OK]

Common Mistakes:

• Forgetting to await async Prisma methods
• Assuming create returns data synchronously
• Confusing create with findMany usage

5. You want to fetch a user and their posts in one GraphQL query using Prisma. Which resolver code correctly fetches the user with their posts included?

hard

A. const user = await prisma.user.findUnique({ where: { id }, include: { posts: true } });

B. const user = await prisma.user.findMany({ where: { id }, select: { posts: false } });

C. const user = await prisma.post.findMany({ where: { userId: id } });

D. const user = await prisma.user.findUnique({ where: { id } }); const posts = await prisma.post.findMany({ where: { userId: id } });

Solution

1. Step 1: Understand Prisma's include option

   Using include: { posts: true } fetches related posts along with the user in one query.

2. Step 2: Compare options for fetching user with posts

   const user = await prisma.user.findUnique({ where: { id }, include: { posts: true } }); uses findUnique with include correctly; const user = await prisma.user.findMany({ where: { id }, select: { posts: false } }); excludes posts; const user = await prisma.post.findMany({ where: { userId: id } }); fetches posts only; const user = await prisma.user.findUnique({ where: { id } }); const posts = await prisma.post.findMany({ where: { userId: id } }); fetches separately, not in one query.

3. Final Answer:

   const user = await prisma.user.findUnique({ where: { id }, include: { posts: true } }); -> Option A

4. Quick Check:

   Include fetches relations in one query [OK]

Hint: Use include to fetch related data in one Prisma query [OK]

Common Mistakes:

• Using findMany instead of findUnique for single user
• Not using include to fetch related posts
• Fetching posts separately causing extra queries