2026 में Node.js और अपोलो सर्वर के साथ ग्राफक्यूएल एपीआई कैसे बनाएं

ग्राफक्यूएल ग्राहकों को एक ही अनुरोध में ठीक उसी डेटा का अनुरोध करने की सुविधा देता है जिसकी उन्हें आवश्यकता होती है – कोई अति-प्राप्ति नहीं, कोई कम-प्राप्ति नहीं।के साथ संयुक्त अपोलो सर्वर और टाइपस्क्रिप्ट, यह लचीली एपीआई बनाने का एक शक्तिशाली तरीका है। यह मार्गदर्शिका प्रारंभ से ही संपूर्ण ग्राफक्यूएल एपीआई बनाती है।

ग्राफक्यूएल बनाम आरईएसटी – त्वरित तुलना

स्कीमा को परिभाषित करें

mkdir graphql-api && cd graphql-api
npm init -y
npm install @apollo/server graphql
npm install -D typescript tsx @types/node
npx tsc --init

रिज़ॉल्वर लिखें

// src/schema.ts
export const typeDefs = `#graphql
  type User {
    id: ID!
    name: String!
    email: String!
    posts: [Post!]!
  }

  type Post {
    id: ID!
    title: String!
    content: String!
    author: User!
    published: Boolean!
  }

  type Query {
    users: [User!]!
    user(id: ID!): User
    posts: [Post!]!
  }

  type Mutation {
    createUser(name: String!, email: String!): User!
    createPost(title: String!, content: String!, authorId: ID!): Post!
    publishPost(id: ID!): Post!
  }
`;

सर्वर बनाएं

// src/resolvers.ts
import { db } from './db';

export const resolvers = {
  Query: {
    users: () => db.users.findAll(),
    user: (_: any, { id }: { id: string }) => db.users.findById(id),
    posts: () => db.posts.findAll(),
  },

  Mutation: {
    createUser: (_: any, { name, email }: { name: string; email: string }) => {
      return db.users.create({ name, email });
    },
    createPost: (_: any, args: { title: string; content: string; authorId: string }) => {
      return db.posts.create({ ...args, published: false });
    },
    publishPost: (_: any, { id }: { id: string }) => {
      return db.posts.update(id, { published: true });
    },
  },

  // Field resolvers for relationships
  User: {
    posts: (parent: { id: string }) => db.posts.findByAuthor(parent.id),
  },
  Post: {
    author: (parent: { authorId: string }) => db.users.findById(parent.authorId),
  },
};

रिज़ॉल्वर में प्रमाणीकरण

// src/index.ts
import { ApolloServer } from '@apollo/server';
import { startStandaloneServer } from '@apollo/server/standalone';
import { typeDefs } from './schema';
import { resolvers } from './resolvers';

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

const { url } = await startStandaloneServer(server, {
  listen: { port: 4000 },
  context: async ({ req }) => {
    // Extract auth token, attach user to context
    const token = req.headers.authorization?.replace('Bearer ', '');
    const user = token ? await verifyToken(token) : null;
    return { user };
  },
});

console.log("GraphQL ready at " + url);

DataLoader के साथ N+1 समस्या का समाधान

Mutation: {
  createPost: (_: any, args, context) => {
    // Require authentication
    if (!context.user) {
      throw new GraphQLError('Not authenticated', {
        extensions: { code: 'UNAUTHENTICATED' },
      });
    }
    return db.posts.create({ ...args, authorId: context.user.id });
  },
},

फ़ील्ड रिज़ॉल्वर N+1 क्वेरी (प्रति अभिभावक एक क्वेरी) ट्रिगर कर सकते हैं। डेटालोडर उन्हें बैच और कैश करता है:

उदाहरण क्वेरी

npm install dataloader

import DataLoader from 'dataloader';

// Create a loader that batches user lookups
const userLoader = new DataLoader(async (ids: readonly string[]) => {
  const users = await db.users.findByIds(ids);
  // Return in the same order as requested ids
  return ids.map(id => users.find(u => u.id === id));
});

// Use in resolver — batches all author lookups into one query
Post: {
  author: (parent, _, context) => context.userLoader.load(parent.authorId),
},

अक्सर पूछे जाने वाले प्रश्न

# Client requests exactly what it needs
query {
  user(id: "1") {
    name
    posts {
      title
      published
    }
  }
}

# Response contains only requested fields:
# { "data": { "user": { "name": "Alice", "posts": [...] } } }

प्रश्न: मेरे प्रोजेक्ट के लिए ग्राफक्यूएल या आरईएसटी?

ए: जटिल, नेस्टेड, क्लाइंट-संचालित डेटा (मोबाइल ऐप्स, विभिन्न आवश्यकताओं वाले डैशबोर्ड) के लिए ग्राफक्यूएल। सरल CRUD के लिए REST और जब HTTP कैशिंग सबसे अधिक मायने रखती है। कई टीमें दोनों का उपयोग करती हैं।
प्रश्न: मैं ग्राफ़क्यूएल में फ़ाइल अपलोड कैसे प्रबंधित करूं?

उ: ग्राफ़क्यूएल-अपलोड पैकेज का उपयोग करें, या बेहतर होगा, एक अलग आरईएसटी एंडपॉइंट या निर्धारित यूआरएल के माध्यम से ऑब्जेक्ट स्टोरेज (एस 3) में फ़ाइलें अपलोड करें और यूआरएल को अपने ग्राफक्यूएल म्यूटेशन में पास करें।
प्रश्न: क्या GraphQL को REST की तुलना में कैश करना कठिन है?

उत्तर: हाँ HTTP स्तर पर (एकल समापन बिंदु, POST अनुरोध)। क्षतिपूर्ति के लिए क्लाइंट पर अपोलो क्लाइंट के सामान्यीकृत कैश और सर्वर पर लगातार क्वेरी या प्रतिक्रिया कैशिंग का उपयोग करें।
प्रश्न: मैं महँगी/दुर्भावनापूर्ण क्वेरीज़ को कैसे रोकूँ?

ए: क्वेरी गहराई सीमित करना, जटिलता विश्लेषण और दर सीमित करना जोड़ें। ग्राफ़कल-डेप्थ-लिमिट और ग्राफ़कल-क्वेरी-कॉम्प्लेक्सिटी जैसे पैकेज गहराई से निहित अपमानजनक प्रश्नों से रक्षा करते हैं।
प्रश्न: क्या मुझे कोड-प्रथम या स्कीमा-प्रथम का उपयोग करना चाहिए?

ए: स्कीमा-प्रथम (एसडीएल स्ट्रिंग्स, यहां दिखाया गया है) स्पष्ट और भाषा-अज्ञेयवादी है। कोड-प्रथम (नेक्सस, टाइपग्राफक्यूएल) बेहतर टाइपस्क्रिप्ट एकीकरण देता है। दोनों काम करते हैं; टीम की प्राथमिकता के आधार पर चयन करें।
निष्कर्ष

अपोलो सर्वर के साथ ग्राफक्यूएल ग्राहकों को उनके द्वारा लाए गए डेटा पर सटीक नियंत्रण देता है, जिससे अधिक और कम डेटा प्राप्त करना समाप्त हो जाता है। यहां सेटअप – टाइप की गई स्कीमा, रिश्तों के साथ रिज़ॉल्वर, संदर्भ-आधारित ऑथ, और एन + 1 समस्या के लिए डेटालोडर – एक उत्पादन ग्राफक्यूएल एपीआई की अनिवार्यताओं को शामिल करता है। लाइव होने से पहले गहराई सीमित करना और जटिलता विश्लेषण जोड़ें, और फ्रंटएंड पर सामान्यीकृत कैश के लिए अपोलो क्लाइंट के साथ जोड़ी बनाएं।

अपोलो सर्वर के साथ ग्राफक्यूएल ग्राहकों को उनके द्वारा लाए गए डेटा पर सटीक नियंत्रण देता है, जिससे अधिक और कम डेटा प्राप्त करना समाप्त हो जाता है। यहां सेटअप – टाइप की गई स्कीमा, रिश्तों के साथ रिज़ॉल्वर, संदर्भ-आधारित ऑथ, और एन + 1 समस्या के लिए डेटालोडर – एक उत्पादन ग्राफक्यूएल एपीआई की अनिवार्यताओं को शामिल करता है। लाइव होने से पहले गहराई सीमित करना और जटिलता विश्लेषण जोड़ें, और फ्रंटएंड पर सामान्यीकृत कैश के लिए अपोलो क्लाइंट के साथ जोड़ी बनाएं।