IMerge multiple resolvers – if you’re building a GraphQL API, you’ll quickly face this problem:

“How do I organize multiple resolvers without making one huge messy file?”

In this guide, you’ll learn:

• How to structure a GraphQL project
• How to merge multiple resolvers
• How to combine schemas
• Step-by-step setup (VS Code + Node.js)
• Best practices for scalable apps

Step 1: Setup Project in VS Code

1. Create Project Folder

Open VS Code → Open Terminal:

mkdir graphql-merge-resolvers
cd graphql-merge-resolvers
code .

2. Initialize Node Project

npm init -y

3. Install Dependencies

npm install @apollo/server express graphql graphql-tag cors @as-integrations/express5 @apollo/subgraph

4.Update package.json

{
  "type": "module",
  "scripts": {
    "start": "node src/index.js"
  }
}

Step 2: Create Folder Structure

Create this structure:

src/
  index.js
  /records
    schema.graphql
    resolvers.js
  /message
    schema.graphql
    resolvers.js

Step 3: Create Modular Resolvers

Message Resolver

const resolvers = {
  Query: {
    appMessage() {
      return "This response is coming from the message module.";
    },
  },
};
export default resolvers;

Record Resolver

const recordsData = [
  { id: "1", name: "Alice", position: "Frontend Developer", level: "Senior" },
];const resolvers = {
  Query: {
    records() {
      return recordsData;
    },
  },
};
export default resolvers;

Step 4: Create GraphQL Schemas

message/schema.graphql

type Query {
  appMessage: String
}

records/schema.graphql

type Record {
  id: ID
  name: String
  position: String
  level: String
}
type Query {
  records: [Record]
}

Step 5: Merge Schemas + Resolvers

Key Code (IMPORTANT)

const resolvers = {
  Query: {
    ...recordResolvers.Query,
    ...messageResolvers.Query,
  },
};

What is happening?

• ... = Spread operator
• Combines multiple Query objects
• Final result = One unified API

Step 6: Create Server (index.js)

import express from "express";
import cors from "cors";
import gql from "graphql-tag";
import { ApolloServer } from "@apollo/server";
import { buildSubgraphSchema } from "@apollo/subgraph";
import { expressMiddleware } from "@as-integrations/express5";
import recordResolvers from "./records/resolvers.js";
import messageResolvers from "./message/resolvers.js";
import { readFileSync } from "fs";const app = express();
const typeDefs = gql(`
  ${readFileSync("./src/records/schema.graphql")}
  ${readFileSync("./src/message/schema.graphql")}
`);
const resolvers = {
  Query: {
    ...recordResolvers.Query,
    ...messageResolvers.Query,
  },
};
const server = new ApolloServer({
  schema: buildSubgraphSchema({ typeDefs, resolvers }),
});
await server.start();

app.use("/graphql", 
cors(),
express.json(),
expressMiddleware(server)
);

app.listen(5050, () => {
  console.log("Server running at http://localhost:5050/graphql");
});

Step 7: Test Your API

Open browser:

http://localhost:5050/graphql

Run:

query {
  appMessage
}

query {
  records {
    name
  }
}

Common Mistakes

❌ Duplicate Query Names
❌ Not merging schemas properly
❌ Forgetting await server.start()
❌ Wrong file paths

Pro Tips

✔️ Keep modules separate
✔️ Use naming conventions
✔️ Use @graphql-tools/merge for large apps
✔️ Avoid large single resolver files

Conclusion

Now you know how to:

• ✔️ Structure a GraphQL project
• ✔️ Merge multiple resolvers
• ✔️ Build scalable APIs

This pattern is used in real production apps