Comprehensive comparison for Backend technology in applications

const { ApolloServer, gql, UserInputError, AuthenticationError } = require('apollo-server');
const { PrismaClient } = require('@prisma/client');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcrypt');

const prisma = new PrismaClient();
const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';

// GraphQL Schema Definition
const typeDefs = gql`
  type User {
    id: ID!
    email: String!
    name: String!
    orders: [Order!]!
    createdAt: String!
  }

  type Order {
    id: ID!
    userId: ID!
    user: User!
    items: [OrderItem!]!
    total: Float!
    status: OrderStatus!
    createdAt: String!
  }

  type OrderItem {
    id: ID!
    productId: ID!
    quantity: Int!
    price: Float!
  }

  enum OrderStatus {
    PENDING
    PROCESSING
    SHIPPED
    DELIVERED
    CANCELLED
  }

  type AuthPayload {
    token: String!
    user: User!
  }

  type Query {
    me: User
    order(id: ID!): Order
    orders(status: OrderStatus, limit: Int = 10, offset: Int = 0): [Order!]!
  }

  type Mutation {
    register(email: String!, password: String!, name: String!): AuthPayload!
    login(email: String!, password: String!): AuthPayload!
    createOrder(items: [OrderItemInput!]!): Order!
    updateOrderStatus(orderId: ID!, status: OrderStatus!): Order!
  }

  input OrderItemInput {
    productId: ID!
    quantity: Int!
    price: Float!
  }
`;

// Resolver Implementation
const resolvers = {
  Query: {
    // Get current authenticated user
    me: async (_, __, { user }) => {
      if (!user) throw new AuthenticationError('Not authenticated');
      return await prisma.user.findUnique({ where: { id: user.id } });
    },

    // Get specific order by ID
    order: async (_, { id }, { user }) => {
      if (!user) throw new AuthenticationError('Not authenticated');
      
      const order = await prisma.order.findUnique({
        where: { id },
        include: { items: true, user: true }
      });

      if (!order) throw new UserInputError('Order not found');
      if (order.userId !== user.id) throw new AuthenticationError('Unauthorized');

      return order;
    },

    // Get orders with filtering and pagination
    orders: async (_, { status, limit, offset }, { user }) => {
      if (!user) throw new AuthenticationError('Not authenticated');

      const where = { userId: user.id };
      if (status) where.status = status;

      return await prisma.order.findMany({
        where,
        include: { items: true, user: true },
        take: limit,
        skip: offset,
        orderBy: { createdAt: 'desc' }
      });
    }
  },

  Mutation: {
    // User registration
    register: async (_, { email, password, name }) => {
      const existingUser = await prisma.user.findUnique({ where: { email } });
      if (existingUser) throw new UserInputError('Email already in use');

      const hashedPassword = await bcrypt.hash(password, 10);
      const user = await prisma.user.create({
        data: { email, password: hashedPassword, name }
      });

      const token = jwt.sign({ id: user.id, email: user.email }, JWT_SECRET, { expiresIn: '7d' });
      return { token, user };
    },

    // User login
    login: async (_, { email, password }) => {
      const user = await prisma.user.findUnique({ where: { email } });
      if (!user) throw new UserInputError('Invalid credentials');

      const valid = await bcrypt.compare(password, user.password);
      if (!valid) throw new UserInputError('Invalid credentials');

      const token = jwt.sign({ id: user.id, email: user.email }, JWT_SECRET, { expiresIn: '7d' });
      return { token, user };
    },

    // Create new order
    createOrder: async (_, { items }, { user }) => {
      if (!user) throw new AuthenticationError('Not authenticated');
      if (!items || items.length === 0) throw new UserInputError('Order must have at least one item');

      const total = items.reduce((sum, item) => sum + (item.price * item.quantity), 0);

      const order = await prisma.order.create({
        data: {
          userId: user.id,
          total,
          status: 'PENDING',
          items: {
            create: items.map(item => ({
              productId: item.productId,
              quantity: item.quantity,
              price: item.price
            }))
          }
        },
        include: { items: true, user: true }
      });

      return order;
    },

    // Update order status
    updateOrderStatus: async (_, { orderId, status }, { user }) => {
      if (!user) throw new AuthenticationError('Not authenticated');

      const order = await prisma.order.findUnique({ where: { id: orderId } });
      if (!order) throw new UserInputError('Order not found');
      if (order.userId !== user.id) throw new AuthenticationError('Unauthorized');

      return await prisma.order.update({
        where: { id: orderId },
        data: { status },
        include: { items: true, user: true }
      });
    }
  },

  // Field resolvers
  User: {
    orders: async (parent) => {
      return await prisma.order.findMany({
        where: { userId: parent.id },
        include: { items: true }
      });
    }
  },

  Order: {
    user: async (parent) => {
      return await prisma.user.findUnique({ where: { id: parent.userId } });
    }
  }
};

// Context function to authenticate users
const context = async ({ req }) => {
  const token = req.headers.authorization?.replace('Bearer ', '');
  
  if (!token) return {};

  try {
    const decoded = jwt.verify(token, JWT_SECRET);
    const user = await prisma.user.findUnique({ where: { id: decoded.id } });
    return { user };
  } catch (error) {
    return {};
  }
};

// Initialize Apollo Server
const server = new ApolloServer({
  typeDefs,
  resolvers,
  context,
  formatError: (error) => {
    console.error(error);
    return error;
  }
});

// Start server
server.listen({ port: 4000 }).then(({ url }) => {
  console.log(`🚀 Server ready at ${url}`);
});