MongoDB with GraphQL

Introduction

MongoDB stores data as flexible documents. GraphQL lets you ask for exactly the data you want. Using them together helps you get data easily and quickly.

You want to build a website that shows user profiles stored in MongoDB.

You need to fetch only some fields from a large MongoDB collection to save bandwidth.

You want to update MongoDB data through a simple API without writing many endpoints.

You want to combine data from MongoDB with other data sources in one query.

You want to let frontend developers ask for data without backend changes.

Syntax

GraphQL

type Query {
  getItems: [Item]
}

type Item {
  id: ID!
  name: String
  description: String
}

type Mutation {
  addItem(name: String!, description: String): Item
}

# Resolver example in JavaScript
const resolvers = {
  Query: {
    getItems: async () => {
      const items = await mongoCollection.find().toArray();
      return items.map(item => ({
        id: item._id.toString(),
        name: item.name,
        description: item.description
      }));
    }
  },
  Mutation: {
    addItem: async (_, { name, description }) => {
      const result = await mongoCollection.insertOne({ name, description });
      return {
        id: result.insertedId.toString(),
        name,
        description
      };
    }
  }
};

GraphQL schema defines what data you can ask for.

Resolvers connect GraphQL queries to MongoDB operations.

Examples

Fetch only id and name fields from MongoDB documents.

GraphQL

query {
  getItems {
    id
    name
  }
}

Fetch id and description fields instead.

GraphQL

query {
  getItems {
    id
    description
  }
}

Add a new item to MongoDB and get back its id and name.

GraphQL

mutation {
  addItem(name: "Book", description: "A nice book") {
    id
    name
  }
}

Sample Program

This program sets up a GraphQL server connected to MongoDB. It defines a query to get all items and a mutation to add a new item. It converts MongoDB's _id to string for GraphQL.

GraphQL

# GraphQL schema definition
const { ApolloServer, gql } = require('apollo-server');
const { MongoClient, ObjectId } = require('mongodb');

const uri = 'mongodb://localhost:27017';
const client = new MongoClient(uri);

const typeDefs = gql`
  type Item {
    id: ID!
    name: String
    description: String
  }

  type Query {
    getItems: [Item]
  }

  type Mutation {
    addItem(name: String!, description: String): Item
  }
`;

async function startServer() {
  await client.connect();
  const db = client.db('testdb');
  const itemsCollection = db.collection('items');

  const resolvers = {
    Query: {
      getItems: async () => {
        const items = await itemsCollection.find().toArray();
        return items.map(item => ({
          id: item._id.toString(),
          name: item.name,
          description: item.description
        }));
      }
    },
    Mutation: {
      addItem: async (_, { name, description }) => {
        const result = await itemsCollection.insertOne({ name, description });
        return {
          id: result.insertedId.toString(),
          name,
          description
        };
      }
    }
  };

  const server = new ApolloServer({ typeDefs, resolvers });

  server.listen().then(({ url }) => {
    console.log(`Server ready at ${url}`);
  });
}

startServer();

Important Notes

GraphQL queries let you ask for only the data you need, reducing data transfer.

Resolvers must convert MongoDB ObjectId to string for GraphQL ID type.

Use async/await to handle MongoDB calls inside resolvers.

Summary

MongoDB stores flexible documents; GraphQL queries them precisely.

Define GraphQL schema and resolvers to connect to MongoDB.

Use queries to fetch data and mutations to change data in MongoDB.

Practice

1. What is the main purpose of using GraphQL with MongoDB?

easy

A. To store data in tables instead of documents

B. To replace MongoDB with a SQL database

C. To automatically backup MongoDB data

D. To query only the specific data fields needed from MongoDB

Solution

1. Step 1: Understand GraphQL's role

   GraphQL allows clients to request exactly the data they want, no more, no less.

2. Step 2: Connect to MongoDB data

   MongoDB stores flexible documents, and GraphQL queries these documents precisely.

3. Final Answer:

   To query only the specific data fields needed from MongoDB -> Option D

4. Quick Check:

   GraphQL queries = precise data retrieval [OK]

Hint: GraphQL fetches only requested fields from MongoDB [OK]

Common Mistakes:

• Thinking GraphQL replaces MongoDB
• Confusing document storage with tables
• Assuming GraphQL handles backups

2. Which of the following is the correct way to define a GraphQL query to fetch a list of users from MongoDB?

easy

A. query { users { id name email } }

B. mutation { users { id name email } }

C. query users { id name email }

D. fetch users from MongoDB

Solution

1. Step 1: Identify GraphQL query syntax

   GraphQL queries start with the keyword query followed by the selection set.

2. Step 2: Check the options

   query { users { id name email } } correctly uses query { users { id name email } } to fetch user fields.

3. Final Answer:

   query { users { id name email } } -> Option A

4. Quick Check:

   GraphQL query syntax = query + selection set [OK]

Hint: Queries start with 'query' keyword, mutations with 'mutation' [OK]

Common Mistakes:

• Using mutation instead of query for fetching data
• Omitting braces or keywords
• Writing invalid syntax like 'fetch users from MongoDB'

3. Given this GraphQL query to fetch a user by ID:
query { user(id: "123") { name age } }
And MongoDB has a user document { _id: "123", name: "Alice", age: 30, city: "NY" }, what will be the query result?

medium

A. { "data": { "user": { "name": "Alice", "age": 30 } } }

B. { "data": { "user": { "name": "Alice", "city": "NY" } } }

C. { "data": { "user": { "id": "123", "name": "Alice" } } }

D. { "error": "User not found" }

Solution

1. Step 1: Understand the query fields

   The query requests only name and age fields for user with id "123".

2. Step 2: Match MongoDB document fields

   The document has those fields: name "Alice" and age 30, so those are returned.

3. Final Answer:

   { "data": { "user": { "name": "Alice", "age": 30 } } } -> Option A

4. Quick Check:

   Requested fields returned exactly [OK]

Hint: GraphQL returns only requested fields, ignoring others [OK]

Common Mistakes:

• Expecting all document fields returned
• Confusing id with _id field
• Assuming error when user exists

4. You wrote this GraphQL mutation to add a new user:
mutation { addUser(name: "Bob", age: "25") { id name } }
But you get an error: "Field 'addUser' argument 'age' of type 'Int!' was provided invalid value." What is the likely cause?

medium

A. The mutation syntax is incorrect; should use query instead

B. The age argument is missing in the schema definition

C. The age argument was provided as a string, not an integer

D. The age value 25 is invalid because it is too low

Solution

1. Step 1: Analyze the error message

   The error says the 'age' argument type is 'Int!' but the value is invalid.

2. Step 2: Analyze the query literal

   The query provides age: "25" as a string literal, but the schema expects an integer literal for Int!, causing the invalid value error.

3. Final Answer:

   The age argument was provided as a string, not an integer -> Option C

4. Quick Check:

   Type mismatch in argument causes invalid value error [OK]

Hint: Match argument types exactly as schema defines [OK]

Common Mistakes:

• Using query instead of mutation for data change
• Ignoring schema argument types
• Assuming numeric values are always valid

5. You want to update a user's city in MongoDB using GraphQL. The schema defines a mutation:
updateUser(id: ID!, city: String!): User
Which resolver code snippet correctly updates the city field in MongoDB?

hard

A. return UserModel.updateOne({ id }, { city });

B. return UserModel.findByIdAndUpdate(id, { city }, { new: true });

C. return UserModel.findOneAndDelete({ _id: id });

D. return UserModel.insertOne({ id, city });

Solution

1. Step 1: Identify correct MongoDB update method

   findByIdAndUpdate updates a document by its _id and returns the updated document.

2. Step 2: Check options for update and return

   return UserModel.findByIdAndUpdate(id, { city }, { new: true }); uses findByIdAndUpdate with { new: true } to return updated user, matching schema.

3. Final Answer:

   return UserModel.findByIdAndUpdate(id, { city }, { new: true }); -> Option B

4. Quick Check:

   Use findByIdAndUpdate to update and return new doc [OK]

Hint: Use findByIdAndUpdate with { new: true } to get updated doc [OK]

Common Mistakes:

• Using updateOne without returning updated document
• Deleting instead of updating
• Inserting new document instead of updating existing