GraphQL APIs with Node.js: Build Flexible APIs with Apollo Server

import { ApolloServer } from '@apollo/server';
import { startStandaloneServer } from '@apollo/server/standalone';
import { GraphQLError } from 'graphql';

// Step 1: Create a small in-memory data store.
// A database can replace this array in a production application.
const users = [
  { id: '1', name: 'Ansh', email: 'ansh@example.com' },
  { id: '2', name: 'Priya', email: 'priya@example.com' },
];

// Generate unique identifiers for this demonstration.
let nextUserId = 3;

// Step 2: Define the GraphQL schema.
// Types describe available data; queries read and mutations change it.
const typeDefs = `#graphql
  type User {
    id: ID!
    name: String!
    email: String!
  }

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

  type Mutation {
    createUser(name: String!, email: String!): User!
    updateUser(id: ID!, name: String, email: String): User
  }
`;

// Step 3: Implement resolvers for schema operations.
const resolvers = {
  Query: {
    // Return a copy so callers cannot directly modify the array.
    users: () => {
      console.log('[Query] Fetching all users');
      return users.map((user) => ({ ...user }));
    },

    // Find one user by its GraphQL ID argument.
    user: (_, { id }) => {
      console.log(`[Query] Finding user with ID: ${id}`);
      const foundUser = users.find((user) => user.id === id);
      return foundUser ? { ...foundUser } : null;
    },
  },

  Mutation: {
    // Validate input before adding a user to the data store.
    createUser: (_, { name, email }) => {
      console.log('[Mutation] Creating a new user');

      if (!name.trim()) {
        throw new GraphQLError('Name cannot be empty.', {
          extensions: { code: 'BAD_USER_INPUT' },
        });
      }

      const normalizedEmail = email.trim().toLowerCase();
      const emailExists = users.some(
        (user) => user.email.toLowerCase() === normalizedEmail,
      );

      if (emailExists) {
        throw new GraphQLError('Email is already registered.', {
          extensions: { code: 'BAD_USER_INPUT' },
        });
      }

      const newUser = {
        id: String(nextUserId++),
        name: name.trim(),
        email: normalizedEmail,
      };

      users.push(newUser);
      console.log(`[Mutation] Created user with ID: ${newUser.id}`);
      return { ...newUser };
    },

    // Update only the fields supplied by the client.
    updateUser: (_, { id, name, email }) => {
      console.log(`[Mutation] Updating user with ID: ${id}`);
      const existingUser = users.find((user) => user.id === id);

      if (!existingUser) {
        return null;
      }

      if (name !== undefined) {
        if (!name.trim()) {
          throw new GraphQLError('Name cannot be empty.', {
            extensions: { code: 'BAD_USER_INPUT' },
          });
        }
        existingUser.name = name.trim();
      }

      if (email !== undefined) {
        const normalizedEmail = email.trim().toLowerCase();
        const emailExists = users.some(
          (user) => user.id !== id && user.email === normalizedEmail,
        );

        if (emailExists) {
          throw new GraphQLError('Email is already registered.', {
            extensions: { code: 'BAD_USER_INPUT' },
          });
        }

        existingUser.email = normalizedEmail;
      }

      console.log(`[Mutation] Updated user with ID: ${id}`);
      return { ...existingUser };
    },
  },
};

// Step 4: Create the Apollo GraphQL server.
const server = new ApolloServer({ typeDefs, resolvers });

// Step 5: Start the HTTP server and expose the GraphQL endpoint.
const { url } = await startStandaloneServer(server, {
  listen: { port: 4000 },
});

console.log('\nGraphQL API is ready!');
console.log(`Endpoint: ${url}`);
console.log('\nTry these operations in your GraphQL client:');

// Query example:
// query {
//   users { id name email }
//   user(id: "1") { name email }
// }

// Mutation example:
// mutation {
//   createUser(name: "Riya", email: "riya@example.com") {
//     id
//     name
//     email
//   }
// }

// Update example:
// mutation {
//   updateUser(id: "1", name: "Ansh Patel") {
//     id
//     name
//     email
//   }
// }

// The server remains active until its process is stopped.
// Press Ctrl+C in the terminal to shut it down.