How to Use MongoDB and GraphQL Together

In today's modern web development world, storing and managing data effectively is crucial for any application. Two popular technologies, MongoDB and GraphQL, have emerged as powerful tools for tackling these challenges. MongoDB is a popular NoSQL database that stores data in a flexible, JSON-like format called BSON. GraphQL, on the other hand, is a query language for APIs that enables you to request only the data you need from your server, reducing the amount of data transferred over the network. In this blog post, we'll explore how to use MongoDB and GraphQL together, allowing you to harness the power of both technologies to build scalable and efficient web applications.

Getting Started with MongoDB and GraphQL

Before diving into the integration of MongoDB and GraphQL, let's briefly touch upon the basics of each technology.

MongoDB

MongoDB is a cross-platform, document-oriented NoSQL database that stores data in BSON (Binary JSON) format. It's known for its high performance, scalability, and flexibility in handling data. MongoDB uses collections to store documents, and these documents can have different fields and structures.

GraphQL

GraphQL is a query language for APIs and a runtime for executing those queries against your data. Developed by Facebook, GraphQL provides a more efficient, powerful, and flexible alternative to the traditional REST API. With GraphQL, clients can request only the data they need, avoiding over-fetching or under-fetching of data.

Setting Up the Project

To get started, make sure you have the following software installed on your machine:

• Node.js (version 14 or later)
• npm (version 7 or later)
• MongoDB (version 4 or later)

Once you've installed the required software, create a new directory for your project and navigate to it in your terminal. Then, run the following command to initialize a new Node.js project:

npm init -y

This command will create a package.json file with default settings.

Next, install the necessary dependencies for our project:

npm install express graphql graphql-tools apollo-server-express mongodb mongoose

These packages include:

• express: A lightweight web application framework for Node.js
• graphql: The JavaScript implementation of GraphQL
• graphql-tools: A set of utilities for building and working with GraphQL schemas
• apollo-server-express: An integration between Apollo Server and Express, allowing you to run a GraphQL server alongside an Express app
• mongodb: The official MongoDB driver for Node.js
• mongoose: An Object Data Modeling (ODM) library for MongoDB and Node.js

Connecting to MongoDB

To connect to MongoDB, first create a new file named database.js in your project directory. Then, add the following code to establish a connection to your MongoDB instance:

const mongoose = require('mongoose');

async function connectToDatabase() {
  try {
    await mongoose.connect('mongodb://localhost:27017/graphql-mongo', {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    });

    console.log('Successfully connected to MongoDB');
  } catch (error) {
    console.error('Error connecting to MongoDB:', error);
  }
}

module.exports = connectToDatabase;

Replace 'mongodb://localhost:27017/graphql-mongo' with the connection string for your MongoDB instance if needed. In this example, we're connecting to a local MongoDB instance with a database named graphql-mongo.

Now, let's create an Express application to serve our GraphQL API. Create a new file named app.js in your project directory and add the following code:

const express = require('express');
const { ApolloServer } = require('apollo-server-express');

const connectToDatabase = require('./database');

async function startServer() {
  //  // Connect to the database
  await connectToDatabase();

  // Create an Express app
  const app = express();

  // Create an Apollo server
  const server = new ApolloServer({
    typeDefs: /* GraphQL schema */,
    resolvers: /* GraphQL resolvers */,
  });

  // Apply the Apollo middleware to the Express app
  server.applyMiddleware({ app });

  // Start the Express server
  app.listen({ port: 4000 }, () => {
    console.log(`Server ready at http://localhost:4000${server.graphqlPath}`);
  });
}

startServer();

In this code, we first connect to our MongoDB database using the connectToDatabase function from database.js. Then, we create an Express app and an Apollo Server instance, which we'll configure with our GraphQL schema and resolvers later. Finally, we start the Express server on port 4000.

Defining the GraphQL Schema and Resolvers

Before we can use our GraphQL API, we need to define the schema and resolvers. The schema describes the types and operations available in our API, while the resolvers specify how to fetch the data for each operation.

Create a new file named schema.js in your project directory and add the following code:

const { gql } = require('apollo-server-express');

const typeDefs = gql`
  type Query {
    getAllUsers: [User!]!
  }

  type User {
    id: ID!
    name: String!
    age: Int!
  }

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

module.exports = typeDefs;

In this schema, we define a User type with three fields: id, name, and age. We also define two operations: getAllUsers, which returns a list of all users, and createUser, which creates a new user.

Now, let's create a Mongoose model for our User type. Create a new file named user.model.js in your project directory and add the following code:

const mongoose = require('mongoose');

const UserSchema = new mongoose.Schema({
  name: String,
  age: Number,
});

const UserModel = mongoose.model('User', UserSchema);

module.exports = UserModel;

Next, create a new file named resolvers.js in your project directory and add the following code:

const UserModel = require('./user.model');

const resolvers = {
  Query: {
    getAllUsers: async () => {
      return await UserModel.find();
    },
  },
  Mutation: {
    createUser: async (_, { name, age }) => {
      const newUser = new UserModel({ name, age });
      return await newUser.save();
    },
  },
};

module.exports = resolvers;

In our resolvers, we define two functions: getAllUsers, which fetches all users from the MongoDB database using the UserModel.find() method, and createUser, which creates a new user using the UserModel and saves it to the database.

Finally, update the app.js file to include our schema and resolvers:

const typeDefs = require('./schema');
const resolvers = require('./resolvers');

// ...

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

Now, our GraphQL server is ready to use. Start the server by running the following command:

node app.js

You should see the message "Server ready at http://localhost:4000/graphql" in your terminal. Navigate to that URL in your browser to access the GraphQL Playground, where you can interact with yourGraphQL API and test queries and mutations.

For example, to create a new user, execute the following mutation in the GraphQL Playground:

mutation {
  createUser(name: "Alice", age: 30) {
    id
    name
    age
  }
}

This will create a new user in the MongoDB database and return the created user's id, name, and age.

To fetch all users, execute the following query:

query {
  getAllUsers {
    id
    name
    age
  }
}

This will return a list of all users in the MongoDB database, including the user we just created.

FAQ

Q: Can I use other databases with GraphQL?

A: Yes, you can use any database with GraphQL. The resolvers in your GraphQL server are responsible for fetching data from your database, so you can use any database that has a compatible driver or library for your programming language.

Q: How do I handle authentication and authorization in my GraphQL server?

A: You can handle authentication and authorization in your GraphQL server using middleware or by adding custom logic to your resolvers. For example, you can use the context argument in your resolvers to pass authentication information and check permissions before executing the resolver's main logic.

Q: What are some best practices for structuring my GraphQL server code?

A: Here are some best practices for structuring your GraphQL server code:

1. Separate your code into modules (e.g., schema, resolvers, models, etc.) to keep it organized and maintainable.
2. Use a consistent naming convention for your types, fields, and operations.
3. Keep your resolvers simple and focused on fetching data. Move complex business logic to separate functions or services.
4. Use DataLoader or a similar library to batch and cache requests to your database, reducing the number of queries and improving performance.

Q: How do I handle errors in my GraphQL server?

A: You can handle errors in your GraphQL server by throwing custom errors in your resolvers or by using custom error handling middleware. GraphQL servers typically return errors as part of the response, allowing clients to handle them as needed.

Q: Can I use real-time features like subscriptions with MongoDB and GraphQL?

A: Yes, you can use real-time features like subscriptions with MongoDB and GraphQL. You'll need to configure your GraphQL server to support subscriptions and use a library like graphql-subscriptions to manage your subscription events. Additionally, you can use MongoDB change streams to listen for changes in your database and publish events to your subscribers.