Graph Ql Course In Coimbatore - Idm Techpark Coimbatore

Graph QL Interview Questions and Answers

1. What is GraphQL?
GraphQL is a query language for APIs and a runtime for executing queries by leveraging a type system defined for data. It allows clients to request only the data they need.
2. How is GraphQL different from REST?

GraphQL: Fetches only required fields, single endpoint (/graphql), strong typing, client-driven.
REST: Fixed endpoints (/users, /posts), returns full payloads, server-driven.

3. What are the main components of GraphQL?

Schema (defines types and structure)
Query (fetches data)
Mutation (modifies data)
Subscription (real-time updates)

4. What is a GraphQL Schema?
A schema defines the structure of the data, specifying types, queries, mutations, and subscriptions.
5. What are Queries in GraphQL?
Queries are used to fetch data from the server. Example:
query { user(id: "1") { name email } }
6. What are Mutations in GraphQL?
Mutations modify or create data. Example:
mutation { addUser(name: "John", email: "john@example.com") { id name } }
7. What are Subscriptions in GraphQL?
Subscriptions allow real-time updates via WebSockets. Example:
subscription { newUser { id name } }
8. What is a Resolver in GraphQL?
A resolver is a function that resolves a query, mutation, or subscription by fetching the required data.
9. What is the purpose of Type System in GraphQL?
GraphQL uses a strong type system to define the shape of API responses and prevent invalid queries.
10. What are Scalar Types in GraphQL?
GraphQL provides built-in scalar types:

Int (integer)
Float (decimal)
String (text)
Boolean (true/false)
ID (unique identifier)

11. What are Custom Types in GraphQL?
Custom types allow defining structured objects in a schema. Example:
type User { id: ID! name: String! email: String! }
12. What are Input Types in GraphQL?
Input types allow passing structured data in mutations. Example:
input UserInput { name: String! email: String! }
13. What is the ! (exclamation mark) in GraphQL?
It denotes a required field, meaning it cannot be null.
14. How does GraphQL handle Errors?
Errors are returned in the errors field of the response JSON.
15. What is GraphiQL?
GraphiQL is an in-browser IDE for testing GraphQL queries.
16. Can GraphQL be used with SQL and NoSQL databases?
Yes, GraphQL can fetch data from SQL (PostgreSQL, MySQL) and NoSQL (MongoDB, Firebase).
17. How to implement authentication in GraphQL?
Authentication is typically handled via JWT or session tokens passed in the request headers.
18. What are Fragments in GraphQL?
Fragments allow reusing query parts. Example:
fragment UserFields on User { id name email } query { user(id: "1") { ...UserFields } }
19. What is Apollo Client?
Apollo Client is a GraphQL client for managing queries in frontend applications.
20. What is Apollo Server?
Apollo Server is a popular GraphQL server implementation.
21. What is Federation in GraphQL?
Federation allows composing multiple GraphQL services into a single API.
22. How does GraphQL handle Caching?
GraphQL clients (like Apollo) use in-memory caching, and server-side caching can be implemented with Redis or similar tools.
23. Can GraphQL be rate-limited?
Yes, rate limiting can be implemented using middleware.
24. How to secure GraphQL APIs?

Authentication (JWT, OAuth)
Authorization (role-based access control)
Rate limiting
Query complexity analysis

25. What are the benefits of GraphQL?

Fetch only required data
Strongly typed
Single endpoint
Supports real-time updates
Self-documenting API

1. How does GraphQL handle authorization at the resolver level?

Answer:
Authorization in GraphQL can be handled at the resolver level by checking user roles and permissions in context before executing queries or mutations.

Example:

const resolvers = { Query: { user: (parent, args, context) => { if (!context.user || !context.user.isAdmin) { throw new Error("Unauthorized"); } return getUserById(args.id); }, }, };

2. What are GraphQL field-level permissions?

Answer:
Field-level permissions restrict access to certain fields based on user roles.
Example using Apollo’s schema directives:

directive @auth(requires: Role = USER) on FIELD_DEFINITION type User { id: ID! email: String! @auth(requires: ADMIN) }

3. Explain GraphQL query complexity analysis.

Answer:
Query complexity analysis assigns a cost to each query and blocks expensive ones to prevent abuse.

Example using Apollo Server:

const { createComplexityLimitRule } = require("graphql-validation-complexity"); const complexityRule = createComplexityLimitRule(1000);

4. What is GraphQL federation?

Answer:
GraphQL federation allows multiple GraphQL services to act as a single API using Apollo Federation.

Example:

extend type User @key(fields: "id") { id: ID! @external reviews: [Review] }

5. How does GraphQL handle caching at different levels?

Answer:

Client-side caching: Apollo Client, Relay, or Urql.
Server-side caching: DataLoader or Redis.
Edge caching: CDN-level caching (e.g., Cloudflare, Fastly).

6. How do you design an efficient GraphQL pagination system?

Answer:
Use cursor-based pagination instead of offset-based pagination.

Example:

type PageInfo { hasNextPage: Boolean! endCursor: String } type UserEdge { node: User cursor: String! } type UserConnection { edges: [UserEdge] pageInfo: PageInfo }

7. Explain GraphQL stitching and its use cases.

Answer:
Schema stitching merges multiple GraphQL schemas into a unified API. Useful for microservices-based GraphQL architecture.

8. How do you prevent GraphQL query depth attacks?

Answer:
Use depth limiting to prevent deeply nested queries that overload the server.

Example:

const depthLimit = require("graphql-depth-limit"); app.use( "/graphql", graphqlHTTP({ schema, validationRules: [depthLimit(5)], }) );

9. How do you secure GraphQL subscriptions?

Answer:

Authenticate WebSocket connections before allowing a subscription.
Use context to validate user access before returning data.

Example:

const onConnect = (connectionParams, webSocket, context) => { if (connectionParams.authToken) { return validateToken(connectionParams.authToken); } throw new Error("Missing auth token!"); };

10. Explain how to use GraphQL with microservices.

Answer:
GraphQL can be used in a microservices architecture using:

Apollo Federation: Federates multiple GraphQL services.
Schema Stitching: Merges multiple schemas into a single API.

11. How do you implement rate limiting in GraphQL?

Answer:
Use middleware or Apollo plugins to limit API calls per user.

Example:

const rateLimit = require("graphql-rate-limit"); const rateLimitedField = rateLimit({ max: 5, window: "1m" });

12. What is a GraphQL custom directive?

Answer:
A directive modifies query behavior at runtime.

Example:

directive @deprecated(reason: String) on FIELD_DEFINITION

13. How do you implement GraphQL transactions?

Answer:
Use database transactions in mutations.

Example using Sequelize:

const transaction = await sequelize.transaction(); try { await User.create({ name: "Alice" }, { transaction }); await transaction.commit(); } catch (error) { await transaction.rollback(); }

14. What are GraphQL persisted queries?

Answer:
Persisted queries store queries server-side to reduce request payload size and improve security.

15. How do you integrate GraphQL with gRPC?

Answer:
Use a resolver that calls a gRPC service.

Example:

16. What is schema delegation in GraphQL?

Answer:
Schema delegation allows one schema to forward requests to another schema.

Example:

const delegateToSchema = require("@graphql-tools/delegate"); const resolvers = { Query: { user: (_, args, context, info) => delegateToSchema({ schema: remoteSchema, operation: "query", fieldName: "user", args, context, info }), }, };

17. How do you prevent GraphQL batch attacks?

Answer:

Batch size limits: Restrict the number of queries in a batch.
Rate limiting: Prevent excessive batching.

18. What is a GraphQL transport layer?

Answer:
GraphQL can be transported over HTTP, WebSockets, gRPC, or even MQTT.

19. What is GraphQL SDL-first vs. Code-first development?

Answer:

SDL-first: Define schema first, then implement resolvers.
Code-first: Define types in code, then generate schema.

Example using TypeGraphQL (code-first):

@ObjectType() class User { @Field() id: string; @Field() name: string; }

20. How do you implement GraphQL in a CQRS architecture?

Answer:
GraphQL queries for reading and mutations for commands (create/update/delete) fit well in CQRS.

21. What are GraphQL global object identifiers?

Answer:
A common ID format across types using Relay conventions.

Example:

interface Node { id: ID! } type User implements Node { id: ID! }

22. How does Apollo Gateway work in GraphQL Federation?

Answer:
Apollo Gateway aggregates multiple federated services into a single GraphQL endpoint.

23. What are GraphQL query variables?

Answer:
Query variables allow dynamic input.

Example:

query getUser($id: ID!) { user(id: $id) { name } }

24. What are GraphQL source types?

Answer:
Source types define how GraphQL maps to a backend (SQL, NoSQL, REST).

25. How do you handle file uploads in GraphQL?

Answer:
Use graphql-upload middleware.

Example:

mutation uploadFile($file: Upload!) { uploadFile(file: $file) { filename, url } }

1. What is GraphQL and how is it different from REST?

Answer:
GraphQL is a query language for APIs that allows clients to request exactly the data they need.

Key Differences from REST:

GraphQL has one endpoint; REST has multiple.
GraphQL returns only requested fields; REST may over-fetch.
GraphQL uses typed schemas, while REST relies on different endpoints.

2. What are GraphQL Queries, Mutations, and Subscriptions?

Answer:

Query: Reads/fetches data (like GET in REST).
Mutation: Modifies data (like POST, PUT, DELETE in REST).
Subscription: Handles real-time updates using WebSockets.

Example Query:

query { user(id: "1") { name, email } }

Example Mutation:

mutation { createUser(name: "John") { id, name } }

3. What is a GraphQL Schema?

Answer:
A GraphQL schema defines the API’s data structure and operations.

Example:

type User { id: ID! name: String! } type Query { user(id: ID!): User }

4. What are Resolvers in GraphQL?

Answer:
Resolvers fetch the actual data for GraphQL fields.

Example:

const resolvers = { Query: { user: (_, { id }) => getUserById(id), }, };

5. How does GraphQL handle errors?

Answer:
Errors are returned in the errors field instead of using HTTP status codes.

Example response:

{ "data": null, "errors": [ { "message": "User not found", "path": ["user"], "extensions": { "code": "NOT_FOUND" } } ] }

6. What is a GraphQL Fragment?

Answer:
A fragment allows reusing query parts.

Example:

fragment UserFields on User { id name email } query getUser { user(id: "1") { ...UserFields } }

7. What is GraphQL Introspection?

Answer:
Introspection allows querying a GraphQL API for its schema.

Example:

{ __schema { types { name } } }

8. What is a GraphQL Directive?

Answer:
Directives modify query execution.

Example (@include directive):

query getUser($showEmail: Boolean!) { user(id: "1") { name email @include(if: $showEmail) } }

9. What is the difference between Interfaces and Unions in GraphQL?

Answer:

Interface: Defines common fields for multiple types.
Union: Groups multiple types without common fields.

Example Interface:

interface Character { name: String! } type Hero implements Character { name: String! power: String! }

Example Union:

union SearchResult = User | Post

10. How does GraphQL handle authentication?

Answer:
Authentication is usually handled using JWT or API keys in the request headers.

Example in Apollo Server:

const context = ({ req }) => { const token = req.headers.authorization; return { user: verifyToken(token) }; };

11. How does GraphQL handle real-time updates?

Answer:
GraphQL subscriptions use WebSockets for real-time data.

Example:

subscription { newMessage { id content } }

12. What is DataLoader and how does it help GraphQL?

Answer:
DataLoader batches multiple database requests into a single query to avoid the N+1 problem.

Example:

const userLoader = new DataLoader(keys => batchUsers(keys)); const resolvers = { Query: { user: (_, { id }) => userLoader.load(id), }, };

13. How do you handle pagination in GraphQL?

Answer:
GraphQL supports offset-based and cursor-based pagination.

Example Cursor-Based Pagination:

query { users(first: 10, after: "cursor123") { edges { node { id, name } cursor } pageInfo { hasNextPage } } }

14. What are the best practices for designing a GraphQL schema?

Answer:

Use meaningful field names.
Avoid deeply nested fields.
Use nullable fields carefully.
Implement proper error handling.

15. What is GraphQL Query Batching?

Answer:
Query batching allows multiple queries in a single request, reducing network calls.

16. How do you handle file uploads in GraphQL?

Answer:
Use graphql-upload middleware.

Example Mutation:

mutation uploadFile($file: Upload!) { uploadFile(file: $file) { filename, url } }

17. How can you call a REST API from a GraphQL resolver?

Answer:
Use fetch or axios inside the resolver.

Example:

const resolvers = { Query: { user: async (_, { id }) => { const response = await fetch(`https://api.example.com/users/${id}`); return response.json(); }, }, };

18. What are GraphQL Scalars?

Answer:
Scalars are primitive types: Int, Float, String, Boolean, and ID.

19. How does caching work in GraphQL?

Answer:

Client-side: Apollo Client
Server-side: Redis, CDN

20. What are persisted queries in GraphQL?

Answer:
Persisted queries store queries server-side to improve performance.

21. How do you prevent malicious GraphQL queries?

Answer:

Query depth limiting.
Complexity analysis.
Rate limiting.

Example:

const depthLimit = require("graphql-depth-limit"); app.use(graphqlHTTP({ schema, validationRules: [depthLimit(5)] }));

22. What is Apollo Client?

Answer:
Apollo Client is a GraphQL state management library for front-end applications.

23. What is Relay in GraphQL?

Answer:
Relay is a GraphQL client by Facebook, optimized for React.

24. What is a GraphQL connection?

Answer:
A connection is a pattern used for implementing pagination.

Example:

type UserConnection { edges: [UserEdge] pageInfo: PageInfo }

25. What are the limitations of GraphQL?

Answer:

Complex queries can cause performance issues.
Caching is harder compared to REST.
Overhead in large-scale applications.

1. What are the key components of a GraphQL schema?

Answer:
A GraphQL schema consists of:

Types: Defines the shape of data.
Queries: Read operations.
Mutations: Write operations.
Subscriptions: Real-time operations.

Example:

type User { id: ID! name: String! } type Query { user(id: ID!): User }

2. What are resolvers in GraphQL?

Answer:
Resolvers map GraphQL queries to functions that return data.

Example in Node.js (Apollo Server):

const resolvers = { Query: { user: (_, { id }) => database.getUser(id), }, };

3. What is the difference between Queries, Mutations, and Subscriptions?

Answer:

Query: Fetches data.
Mutation: Modifies data.
Subscription: Listens for real-time updates.

Example Subscription:

subscription { newMessage { id content } }

4. What is a GraphQL fragment?

Answer:
A fragment allows reusing query parts.

Example:

fragment UserFields on User { id name } query getUser { user(id: "1") { ...UserFields } }

5. How does GraphQL handle errors?

Answer:
Errors are returned inside the errors array in the response.

Example Response:

{ "errors": [ { "message": "User not found", "extensions": { "code": "NOT_FOUND" } } ] }

6. How does GraphQL handle authentication?

Answer:
Typically using JWT in request headers.

Example:

const context = ({ req }) => { const token = req.headers.authorization; return { user: verifyToken(token) }; };

7. What is GraphQL introspection?

Answer:
It allows clients to query the schema itself.

Example Query:

{ __schema { types { name } } }

8. How does GraphQL handle pagination?

Answer:
Using cursor-based or offset-based pagination.

Cursor-based Example:

query { users(first: 10, after: "cursor123") { edges { node { id, name } cursor } pageInfo { hasNextPage } } }

9. What is the N+1 problem in GraphQL?

Answer:
Occurs when separate queries are made for each related item, leading to excessive DB calls.

Solution using DataLoader:

const userLoader = new DataLoader(keys => batchUsers(keys));

10. How can you optimize GraphQL queries?

Answer:

Use batching (DataLoader).
Implement caching (Redis, Apollo).
Use query depth limiting.

11. How does GraphQL handle caching?

Answer:

Client-side: Apollo Client stores cache locally.
Server-side: Redis or in-memory cache.

Example (Apollo Client Cache):

const client = new ApolloClient({ cache: new InMemoryCache(), });

12. What is a GraphQL Directive?

Answer:
A directive modifies query behavior.

Example (@include directive):

query getUser($showEmail: Boolean!) { user(id: "1") { name email @include(if: $showEmail) } }

13. How do you implement real-time data updates in GraphQL?

Answer:
Using subscriptions with WebSockets.

Example Subscription:

subscription { newUser { id name } }

14. How can you rate-limit a GraphQL API?

Answer:
Using middleware like express-rate-limit.

Example:

const rateLimit = require("express-rate-limit"); app.use(rateLimit({ windowMs: 60000, max: 100 }));

15. What are custom scalars in GraphQL?

Answer:
Custom scalars define special types like DateTime.

Example:

scalar DateTime

16. How can you call REST APIs from a GraphQL resolver?

Answer:
Using fetch or axios.

Example:

const resolvers = { Query: { user: async (_, { id }) => { const response = await fetch(`https://api.example.com/users/${id}`); return response.json(); }, }, };

17. What is GraphQL federation?

Answer:
Federation enables multiple services to form a single GraphQL API.

Example (Apollo Federation):

const { ApolloGateway } = require("@apollo/gateway"); const gateway = new ApolloGateway({ serviceList: [{ name: "users", url: "http://users.api" }] });

18. What is persisted queries in GraphQL?

Answer:
Stores frequent queries on the server to reduce bandwidth.

19. How does GraphQL handle access control (authorization)?

Answer:

Use middleware for role-based access.
Implement field-level access control.

Example:

const resolvers = { Query: { user: (_, { id }, { user }) => { if (!user.isAdmin) throw new Error("Not Authorized"); return getUser(id); }, }, };

20. How do you prevent deep query recursion?

Answer:
Set a query depth limit using graphql-depth-limit.

Example:

app.use(graphqlHTTP({ schema, validationRules: [depthLimit(5)] }));

21. What is Relay in GraphQL?

Answer:
Relay is a GraphQL client optimized for React apps.

22. What is Apollo Client?

Answer:
A state management library for GraphQL queries in front-end apps.

Example:

const client = new ApolloClient({ uri: "http://localhost:4000/graphql", cache: new InMemoryCache(), });

23. What are GraphQL unions?

Answer:
Unions allow a field to return multiple types.

Example:

union SearchResult = User | Post

24. How can you handle file uploads in GraphQL?

Answer:
Using graphql-upload middleware.

Example:

mutation uploadFile($file: Upload!) { uploadFile(file: $file) { filename, url } }

25. What are the disadvantages of GraphQL?

Answer:

Complexity in large-scale apps.
Performance issues in deep queries.
Harder caching compared to REST.

Coimbatore Software Training Institute -n Idm Techpark Coimbatore

"Deep Concepts to Elevate Your Career"

This guide provides 100+ Graph QL interview questions along with in-depth concepts to strengthen your expertise.

Download

Graph QL Interview Questions and Answers

Top 100 GraphQL Interview Questions for Freshers

​1. What is GraphQL? GraphQL is a query language for APIs and a runtime for executing queries by leveraging a type system defined for data. It allows clients to request only the data they need. 2. How is GraphQL different from REST?

GraphQL: Fetches only required fields, single endpoint (/graphql), strong typing, client-driven.

REST: Fixed endpoints (/users, /posts), returns full payloads, server-driven.

3. What are the main components of GraphQL?

Schema (defines types and structure)

Query (fetches data)

Mutation (modifies data)

Subscription (real-time updates)

Int (integer)

Float (decimal)

String (text)

Boolean (true/false)

ID (unique identifier)

Authentication (JWT, OAuth)

Authorization (role-based access control)

Rate limiting

Query complexity analysis

25. What are the benefits of GraphQL?

Fetch only required data

Strongly typed

Single endpoint

Supports real-time updates

Self-documenting API

"Deep Concepts to Elevate Your Career"

This guide provides 100+ Graph QL interview questions along with in-depth concepts to strengthen your expertise.

Contact Us

2nd floor, 162/B, Sarojini St, Ram Nagar, Coimbatore, Tamil Nadu 641009

+91-95853-05700

idmtechparkcoimbatore@gmail.com

Software Courses

Designing Courses

Full Stack Developer

Db Courses

AI Courses

Non Coding Courses

1. What is GraphQL?
GraphQL is a query language for APIs and a runtime for executing queries by leveraging a type system defined for data. It allows clients to request only the data they need.
2. How is GraphQL different from REST?