API Design

const express = require('express');
const { body, query, param, validationResult } = require('express-validator');
const { v4: uuidv4 } = require('uuid');

const app = express();
app.use(express.json());

// ============================================
// Response Helpers
// ============================================

class ApiResponse {
  static success(data, meta = {}) {
    return {
      success: true,
      data,
      meta: {
        request_id: meta.requestId,
        timestamp: new Date().toISOString()
      }
    };
  }

  static paginated(data, pagination, meta = {}) {
    return {
      success: true,
      data,
      pagination,
      meta: {
        request_id: meta.requestId,
        timestamp: new Date().toISOString()
      }
    };
  }

  static error(code, message, details = [], meta = {}) {
    return {
      success: false,
      error: { code, message, details },
      meta: {
        request_id: meta.requestId,
        timestamp: new Date().toISOString()
      }
    };
  }
}

// ============================================
// Middleware
// ============================================

// Request ID
function requestIdMiddleware(req, res, next) {
  req.requestId = uuidv4();
  res.setHeader('X-Request-ID', req.requestId);
  next();
}

// Validation error handler
function validate(validations) {
  return async (req, res, next) => {
    await Promise.all(validations.map(v => v.run(req)));
    
    const errors = validationResult(req);
    if (errors.isEmpty()) {
      return next();
    }

    const details = errors.array().map(err => ({
      field: err.path,
      message: err.msg
    }));

    res.status(400).json(
      ApiResponse.error('VALIDATION_ERROR', 'Validation failed', details, { requestId: req.requestId })
    );
  };
}

// Async error wrapper
const asyncHandler = (fn) => (req, res, next) => {
  Promise.resolve(fn(req, res, next)).catch(next);
};

app.use(requestIdMiddleware);

// ============================================
// Routes
// ============================================

// List users with pagination
app.get('/users',
  validate([
    query('page').optional().isInt({ min: 1 }).toInt(),
    query('per_page').optional().isInt({ min: 1, max: 100 }).toInt(),
    query('sort').optional().matches(/^-?(name|email|created_at)$/)
  ]),
  asyncHandler(async (req, res) => {
    const page = req.query.page || 1;
    const perPage = req.query.per_page || 20;
    const sort = req.query.sort || 'created_at';
    const search = req.query.search;

    // Parse sort
    const sortDesc = sort.startsWith('-');
    const sortField = sort.replace('-', '');

    // Build query (pseudo-code with Prisma/Sequelize)
    const where = search ? { name: { contains: search } } : {};
    
    const [users, total] = await Promise.all([
      User.findMany({
        where,
        orderBy: { [sortField]: sortDesc ? 'desc' : 'asc' },
        skip: (page - 1) * perPage,
        take: perPage
      }),
      User.count({ where })
    ]);

    res.json(ApiResponse.paginated(
      users,
      {
        page,
        per_page: perPage,
        total,
        total_pages: Math.ceil(total / perPage)
      },
      { requestId: req.requestId }
    ));
  })
);

// Get single user
app.get('/users/:id',
  validate([
    param('id').isInt({ min: 1 }).toInt()
  ]),
  asyncHandler(async (req, res) => {
    const user = await User.findUnique({ where: { id: req.params.id } });

    if (!user) {
      return res.status(404).json(
        ApiResponse.error('USER_NOT_FOUND', `User with id ${req.params.id} not found`, [], { requestId: req.requestId })
      );
    }

    res.json(ApiResponse.success(user, { requestId: req.requestId }));
  })
);

// Create user
app.post('/users',
  validate([
    body('name').isString().trim().isLength({ min: 1, max: 100 }),
    body('email').isEmail().normalizeEmail(),
    body('password').isString().isLength({ min: 8 })
  ]),
  asyncHandler(async (req, res) => {
    const { name, email, password } = req.body;

    // Check existing email
    const existing = await User.findUnique({ where: { email } });
    if (existing) {
      return res.status(400).json(
        ApiResponse.error(
          'VALIDATION_ERROR',
          'Email already registered',
          [{ field: 'email', message: 'This email is already in use' }],
          { requestId: req.requestId }
        )
      );
    }

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

    res.status(201).json(ApiResponse.success(user, { requestId: req.requestId }));
  })
);

// Update user (partial)
app.patch('/users/:id',
  validate([
    param('id').isInt({ min: 1 }).toInt(),
    body('name').optional().isString().trim().isLength({ min: 1, max: 100 }),
    body('email').optional().isEmail().normalizeEmail()
  ]),
  asyncHandler(async (req, res) => {
    const user = await User.findUnique({ where: { id: req.params.id } });

    if (!user) {
      return res.status(404).json(
        ApiResponse.error('USER_NOT_FOUND', 'User not found', [], { requestId: req.requestId })
      );
    }

    const updatedUser = await User.update({
      where: { id: req.params.id },
      data: { ...req.body, updated_at: new Date() }
    });

    res.json(ApiResponse.success(updatedUser, { requestId: req.requestId }));
  })
);

// Delete user
app.delete('/users/:id',
  validate([param('id').isInt({ min: 1 }).toInt()]),
  asyncHandler(async (req, res) => {
    const user = await User.findUnique({ where: { id: req.params.id } });

    if (!user) {
      return res.status(404).json(
        ApiResponse.error('USER_NOT_FOUND', 'User not found', [], { requestId: req.requestId })
      );
    }

    await User.delete({ where: { id: req.params.id } });
    res.status(204).send();
  })
);

// Global error handler
app.use((err, req, res, next) => {
  console.error(err);
  res.status(500).json(
    ApiResponse.error('INTERNAL_ERROR', 'An unexpected error occurred', [], { requestId: req.requestId })
  );
});

app.listen(3000, () => console.log('API running on port 3000'));

const { ApolloServer, gql } = require('apollo-server-express');
const DataLoader = require('dataloader');

// ============================================
// Type Definitions
// ============================================

const typeDefs = gql`
  type User {
    id: ID!
    name: String!
    email: String!
    posts: [Post!]!
    followers(limit: Int, offset: Int): [User!]!
    followersCount: Int!
    createdAt: DateTime!
  }

  type Post {
    id: ID!
    title: String!
    content: String!
    author: User!
    comments(limit: Int): [Comment!]!
    likes: Int!
    createdAt: DateTime!
  }

  type Comment {
    id: ID!
    content: String!
    author: User!
    post: Post!
  }

  input CreateUserInput {
    name: String!
    email: String!
    password: String!
  }

  input UpdateUserInput {
    name: String
    email: String
  }

  input CreatePostInput {
    title: String!
    content: String!
  }

  type Query {
    user(id: ID!): User
    users(limit: Int, offset: Int, search: String): [User!]!
    post(id: ID!): Post
    feed(userId: ID!, limit: Int, cursor: String): [Post!]!
  }

  type Mutation {
    createUser(input: CreateUserInput!): User!
    updateUser(id: ID!, input: UpdateUserInput!): User!
    deleteUser(id: ID!): Boolean!
    createPost(input: CreatePostInput!): Post!
  }

  type Subscription {
    postCreated(userId: ID!): Post!
    commentAdded(postId: ID!): Comment!
  }
`;

// ============================================
// DataLoaders (Batch & Cache)
// ============================================

function createLoaders() {
  return {
    // Batch load users by IDs
    userLoader: new DataLoader(async (ids) => {
      const users = await User.findMany({
        where: { id: { in: ids.map(id => parseInt(id)) } }
      });
      const userMap = new Map(users.map(u => [u.id.toString(), u]));
      return ids.map(id => userMap.get(id) || null);
    }),

    // Batch load posts by author IDs
    postsByAuthorLoader: new DataLoader(async (authorIds) => {
      const posts = await Post.findMany({
        where: { authorId: { in: authorIds.map(id => parseInt(id)) } }
      });
      const postsByAuthor = new Map();
      posts.forEach(post => {
        const key = post.authorId.toString();
        if (!postsByAuthor.has(key)) {
          postsByAuthor.set(key, []);
        }
        postsByAuthor.get(key).push(post);
      });
      return authorIds.map(id => postsByAuthor.get(id) || []);
    }),

    // Batch load follower counts
    followersCountLoader: new DataLoader(async (userIds) => {
      const counts = await Follow.groupBy({
        by: ['followingId'],
        where: { followingId: { in: userIds.map(id => parseInt(id)) } },
        _count: { id: true }
      });
      const countMap = new Map(
        counts.map(c => [c.followingId.toString(), c._count.id])
      );
      return userIds.map(id => countMap.get(id) || 0);
    })
  };
}

// ============================================
// Resolvers
// ============================================

const resolvers = {
  Query: {
    user: async (_, { id }, { loaders }) => {
      return loaders.userLoader.load(id);
    },

    users: async (_, { limit = 20, offset = 0, search }) => {
      const where = search
        ? { name: { contains: search, mode: 'insensitive' } }
        : {};
      
      return User.findMany({
        where,
        skip: offset,
        take: limit,
        orderBy: { createdAt: 'desc' }
      });
    },

    feed: async (_, { userId, limit = 20, cursor }) => {
      const where = { authorId: parseInt(userId) };
      
      if (cursor) {
        // Decode cursor (base64 encoded post ID)
        const lastId = parseInt(Buffer.from(cursor, 'base64').toString());
        where.id = { lt: lastId };
      }

      return Post.findMany({
        where,
        take: limit,
        orderBy: { createdAt: 'desc' }
      });
    }
  },

  User: {
    posts: async (user, _, { loaders }) => {
      return loaders.postsByAuthorLoader.load(user.id.toString());
    },

    followersCount: async (user, _, { loaders }) => {
      return loaders.followersCountLoader.load(user.id.toString());
    },

    followers: async (user, { limit = 10, offset = 0 }, { loaders }) => {
      const follows = await Follow.findMany({
        where: { followingId: user.id },
        skip: offset,
        take: limit
      });
      
      return Promise.all(
        follows.map(f => loaders.userLoader.load(f.followerId.toString()))
      );
    }
  },

  Post: {
    author: async (post, _, { loaders }) => {
      return loaders.userLoader.load(post.authorId.toString());
    },

    comments: async (post, { limit = 20 }) => {
      return Comment.findMany({
        where: { postId: post.id },
        take: limit,
        orderBy: { createdAt: 'desc' }
      });
    }
  },

  Mutation: {
    createUser: async (_, { input }) => {
      // Check email uniqueness
      const existing = await User.findUnique({ where: { email: input.email } });
      if (existing) {
        throw new Error('Email already registered');
      }

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

    updateUser: async (_, { id, input }, { currentUser }) => {
      // Authorization
      if (currentUser.id !== parseInt(id)) {
        throw new Error('Not authorized');
      }

      const data = {};
      if (input.name) data.name = input.name;
      if (input.email) data.email = input.email;
      data.updatedAt = new Date();

      return User.update({
        where: { id: parseInt(id) },
        data
      });
    },

    createPost: async (_, { input }, { currentUser, pubsub }) => {
      const post = await Post.create({
        data: {
          title: input.title,
          content: input.content,
          authorId: currentUser.id
        }
      });

      // Publish to subscribers
      pubsub.publish(`POST_CREATED_${currentUser.id}`, {
        postCreated: post
      });

      return post;
    }
  },

  Subscription: {
    postCreated: {
      subscribe: (_, { userId }, { pubsub }) => {
        return pubsub.asyncIterator(`POST_CREATED_${userId}`);
      }
    },

    commentAdded: {
      subscribe: (_, { postId }, { pubsub }) => {
        return pubsub.asyncIterator(`COMMENT_ADDED_${postId}`);
      }
    }
  }
};

// ============================================
// Server Setup
// ============================================

const { PubSub } = require('graphql-subscriptions');
const pubsub = new PubSub();

const server = new ApolloServer({
  typeDefs,
  resolvers,
  context: ({ req }) => ({
    loaders: createLoaders(),
    currentUser: req.user, // From auth middleware
    pubsub
  }),
  plugins: [
    // Query complexity analysis
    {
      requestDidStart: () => ({
        didResolveOperation({ request, document }) {
          const complexity = getComplexity({
            schema: server.schema,
            query: document,
            variables: request.variables,
            estimators: [
              fieldExtensionsEstimator(),
              simpleEstimator({ defaultComplexity: 1 })
            ]
          });
          
          if (complexity > 1000) {
            throw new Error('Query too complex');
          }
        }
      })
    }
  ]
});

async function startServer() {
  await server.start();
  server.applyMiddleware({ app });
  
  // WebSocket for subscriptions
  const httpServer = createServer(app);
  server.installSubscriptionHandlers(httpServer);
  
  httpServer.listen(4000, () => {
    console.log(`🚀 Server ready at http://localhost:4000${server.graphqlPath}`);
    console.log(`🚀 Subscriptions at ws://localhost:4000${server.subscriptionsPath}`);
  });
}

startServer();