NodeJS GraphQL

What is GraphQL, and how is it different from REST?

GraphQL is a query language for APIs and a runtime for executing queries against your data. It allows clients to request exactly the data they need, which minimizes over-fetching or under-fetching of data. Unlike REST, where each resource has a dedicated endpoint, GraphQL uses a single endpoint for all queries and mutations, and clients can request multiple resources in one request.

Key differences between GraphQL and REST:

Single endpoint: GraphQL APIs use a single endpoint, whereas REST APIs often use multiple endpoints for different resources.
Precise data fetching: Clients can specify exactly what data they need in GraphQL, reducing over-fetching and under-fetching, while REST responses may include unnecessary data.
Nested queries: GraphQL supports querying related data in a single request, whereas REST may require multiple requests to different endpoints.

How do you set up a basic GraphQL server in Node.js?

To set up a basic GraphQL server in Node.js, you can use the graphql and express-graphql packages. These allow you to define a schema, handle queries, and set up a GraphQL endpoint using Express.

Example of setting up a basic GraphQL server:

const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { buildSchema } = require('graphql');

// Define the GraphQL schema
const schema = buildSchema(\`
    type Query {
        hello: String
        user(id: Int!): User
    }

    type User {
        id: Int
        name: String
        age: Int
    }
\`);

// Define the root resolver
const root = {
    hello: () => {
        return 'Hello, GraphQL!';
    },
    user: ({ id }) => {
        const users = [
            { id: 1, name: 'John Doe', age: 28 },
            { id: 2, name: 'Jane Doe', age: 25 }
        ];
        return users.find(user => user.id === id);
    }
};

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

// Set up the GraphQL endpoint
app.use('/graphql', graphqlHTTP({
    schema: schema,
    rootValue: root,
    graphiql: true,  // Enable GraphiQL, the interactive GraphQL UI
}));

app.listen(4000, () => {
    console.log('GraphQL server running on http://localhost:4000/graphql');
});

In this example, the server defines a simple GraphQL schema with a hello query and a user query that returns user data based on the ID. The graphqlHTTP middleware is used to set up a GraphQL endpoint at /graphql, and GraphiQL is enabled for testing queries.

What is a GraphQL schema, and how do you define one?

A GraphQL schema defines the structure of the API, specifying the types of data that can be queried, the relationships between types, and the operations that can be performed. The schema includes object types, queries, mutations, and more.

Example of defining a GraphQL schema:

const { buildSchema } = require('graphql');

const schema = buildSchema(\`
    type Query {
        hello: String
        user(id: Int!): User
    }

    type User {
        id: Int
        name: String
        age: Int
    }
\`);

In this example, the schema defines a Query type with two fields: hello (a simple string) and user (which takes an ID as an argument and returns a User type). The User type is defined with three fields: id, name, and age.

What are queries and mutations in GraphQL?

In GraphQL, queries are used to retrieve data, while mutations are used to modify data (create, update, or delete).

Queries: Used to fetch data from the server. They are similar to the GET method in REST.
Mutations: Used to modify data on the server. They are similar to POST, PUT, and DELETE methods in REST.

Example of a query:

{
    user(id: 1) {
        name
        age
    }
}

Example of a mutation:

mutation {
    updateUser(id: 1, name: "John Doe", age: 30) {
        id
        name
        age
    }
}

How do you define a mutation in GraphQL?

To define a mutation in GraphQL, you include a Mutation type in the schema, similar to how you define a Query type. The mutation specifies the input arguments needed to modify data and the type of data that will be returned.

Example of defining a mutation:

const { buildSchema } = require('graphql');

const schema = buildSchema(\`
    type Mutation {
        updateUser(id: Int!, name: String!, age: Int!): User
    }

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

    type Query {
        user(id: Int!): User
    }
\`);

const root = {
    updateUser: ({ id, name, age }) => {
        const updatedUser = { id, name, age };
        return updatedUser;
    }
};

In this example, the mutation updateUser takes three arguments (ID, name, and age) and returns the updated user object. The root resolver defines the logic for updating the user.

What is GraphiQL, and how does it help with GraphQL development?

GraphiQL is an interactive in-browser tool that helps developers explore and test GraphQL APIs. It provides a user interface to write queries and mutations, view the schema, and see the results of requests in real-time. GraphiQL is particularly useful during development for testing and debugging GraphQL endpoints.

In the setup of a basic GraphQL server, you can enable GraphiQL by passing graphiql: true in the graphqlHTTP middleware configuration:

app.use('/graphql', graphqlHTTP({
    schema: schema,
    rootValue: root,
    graphiql: true,  // Enable GraphiQL
}));

What are resolvers in GraphQL?

Resolvers in GraphQL are functions that handle the logic for fetching and returning data for fields defined in the schema. When a client sends a query or mutation, the GraphQL server executes the appropriate resolver to fetch the required data.

Each field in the schema can have its own resolver, or the default resolver can be used to simply return the data as is. Resolvers receive four arguments: parent, args, context, and info.

Example of a resolver:

const root = {
    user: ({ id }) => {
        const users = [
            { id: 1, name: 'John Doe', age: 28 },
            { id: 2, name: 'Jane Doe', age: 25 }
        ];
        return users.find(user => user.id === id);
    }
};

In this example, the user resolver fetches user data based on the ID provided in the query.

What are arguments in GraphQL, and how do you pass them to queries and mutations?

Arguments in GraphQL allow clients to pass input data to queries and mutations. They are defined in the schema as part of the field definition, and they can be required (using !) or optional.

Example of defining and passing arguments in a query:

{
    user(id: 1) {
        name
        age
    }
}

In this example, the query takes an id argument to fetch a specific user. The id argument is defined in the schema:

type Query {
    user(id: Int!): User
}

What are fragments in GraphQL?

Fragments in GraphQL are reusable units of logic that allow you to share field selection sets between multiple queries or mutations. They help reduce repetition when querying the same fields in different parts of a query.

Example of using a fragment:

{
    user(id: 1) {
        ...userFields
    }
    anotherUser: user(id: 2) {
        ...userFields
    }
}

fragment userFields on User {
    id
    name
    age
}

In this example, the userFields fragment is used to fetch the id, name, and age fields for two different users, reducing the need to repeat the field selection.

How do you handle errors in GraphQL?

Errors in GraphQL can occur during query execution, and they are returned in the response as part of the errors field. If a resolver throws an error, the error message is sent to the client, while the valid parts of the query are still resolved and returned.

Example of handling an error:

const root = {
    user: ({ id }) => {
        if (id < 1) {
            throw new Error('Invalid user ID');
        }
        const users = [
            { id: 1, name: 'John Doe', age: 28 },
            { id: 2, name: 'Jane Doe', age: 25 }
        ];
        return users.find(user => user.id === id);
    }
};

In this example, an error is thrown if the user ID is less than 1, and the error message is returned to the client.

How do you connect a GraphQL API to a database in Node.js?

To connect a GraphQL API to a database in Node.js, you can use an ORM (Object-Relational Mapping) library like Sequelize (for SQL databases) or Mongoose (for MongoDB). The resolvers in your GraphQL server can interact with the database to fetch and modify data.

Example of connecting GraphQL to a MongoDB database using Mongoose:

const mongoose = require('mongoose');
const User = mongoose.model('User', new mongoose.Schema({
    name: String,
    age: Number
}));

const root = {
    user: async ({ id }) => {
        return await User.findById(id);
    },
    createUser: async ({ name, age }) => {
        const newUser = new User({ name, age });
        return await newUser.save();
    }
};

// Connect to MongoDB
mongoose.connect('mongodb://localhost:27017/mydatabase', { useNewUrlParser: true, useUnifiedTopology: true });

In this example, Mongoose is used to connect to a MongoDB database and perform queries inside the resolvers for fetching and creating user data.

Ads

ParikshaPatr

‹ NodeJS Interview