# Initialize project
mkdir graphql-server && cd graphql-server
npm init -y

# Install dependencies
npm install @apollo/server express graphql cors body-parser

// schema.js
export const typeDefs = `#graphql
  type Book {
    title: String
    author: String
  }

  type Query {
    books: [Book]
  }
`;

// resolvers.js
const books = [
  { title: 'The Awakening', author: 'Kate Chopin' },
  { title: 'City of Glass', author: 'Paul Auster' },
];

export const resolvers = {
  Query: {
    books: () => books,
  },
};

// index.js
import { ApolloServer } from '@apollo/server';
import { expressMiddleware } from '@apollo/server/express4';
import { ApolloServerPluginDrainHttpServer } from '@apollo/server/plugin/drainHttpServer';
import express from 'express';
import http from 'http';
import cors from 'cors';
import { typeDefs } from './schema.js';
import { resolvers } from './resolvers.js';

const app = express();
const httpServer = http.createServer(app);

const server = new ApolloServer({
  typeDefs,
  resolvers,
  plugins: [ApolloServerPluginDrainHttpServer({ httpServer })],
});

await server.start();

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

await new Promise((resolve) => httpServer.listen({ port: 4000 }, resolve));
console.log(`🚀 Server ready at http://localhost:4000/graphql`);

type Character {
  id: ID!
  name: String!
  appearsIn: [Episode!]!
}

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

user: (parent, args, context, info) => {
  return users.find(u => u.id === args.id);
}

type Mutation {
  createUser(name: String!, email: String!): User
}

Mutation: {
  createUser: (_, { name, email }) => {
    const newUser = { id: Date.now().toString(), name, email };
    users.push(newUser);
    return newUser;
  }
}

input UserInput {
  name: String!
  email: String!
  age: Int
}

type Mutation {
  createUser(input: UserInput!): User
}

type Subscription {
  postAdded: Post
}

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

fragment UserDetails on User {
  id
  name
  email
}

query GetUser {
  user(id: "1") {
    ...UserDetails
  }
}

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

interface Character {
  id: ID!
  name: String!
}

type Human implements Character {
  id: ID!
  name: String!
  totalCredits: Int
}

type Droid implements Character {
  id: ID!
  name: String!
  primaryFunction: String
}

union SearchResult = Human | Droid | Starship

query Search($text: String!) {
  search(text: $text) {
    ... on Human { name }
    ... on Starship { name, length }
  }
}

scalar Date

const authLink = setContext((_, { headers }) => {
  return {
    headers: { ...headers, authorization: token }
  }
});

npm install @apollo/client graphql

// lib/apollo-client.js
import { ApolloClient, InMemoryCache } from '@apollo/client';

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

export default client;

// app/providers.js
'use client';
import { ApolloProvider } from '@apollo/client';
import client from '@/lib/apollo-client';

export function Providers({ children }) {
  return {children};
}

import { useQuery, gql } from '@apollo/client';

const GET_BOOKS = gql`
  query GetBooks {
    books {
      title
      author
    }
  }
`;

function BookList() {
  const { loading, error, data } = useQuery(GET_BOOKS);

  if (loading) return 
Loading...
;
  if (error) return 
Error: {error.message}
;

  return data.books.map(({ title, author }) => (
    

      
{title}
      
{author}
    
  ));
}

const ADD_BOOK = gql`
  mutation AddBook($title: String!, $author: String!) {
    addBook(title: $title, author: $author) {
      title
      author
    }
  }
`;

function AddBookForm() {
  let inputTitle, inputAuthor;
  const [addBook, { data, loading, error }] = useMutation(ADD_BOOK);

  return (
    
 {
      e.preventDefault();
      addBook({ variables: { title: inputTitle.value, author: inputAuthor.value } });
    }}>
       inputTitle = node} />
       inputAuthor = node} />
      Add Book
    
  );
}

BookList.fragments = {
  book: gql`
    fragment BookDetails on Book {
      title
      author
    }
  `,
};

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

app.use(
  '/graphql',
  expressMiddleware(server, {
    context: async ({ req }) => ({
      user: await getUserFromToken(req.headers.authorization),
    }),
  }),
);

const authorLoader = new DataLoader(async (ids) => {
  const authors = await getAuthorsByIds(ids);
  return ids.map(id => authors.find(a => a.id === id));
});

import { GraphQLError } from 'graphql';

if (!user) {
  throw new GraphQLError('Not authenticated', {
    extensions: { code: 'UNAUTHENTICATED' },
  });
}