Resolvers & Execution Model

// Every resolver receives 4 arguments:
// resolver(parent, args, context, info)

const resolvers = {
  Query: {
    // parent = root value (null for top-level queries)
    // args   = query arguments { id: "42" }
    // context= shared data (auth user, DB connections, dataloaders)
    // info   = query AST, field selection info
    user: async (parent, args, context, info) => {
      if (!context.currentUser) throw new Error("Not authenticated");
      return context.db.User.findById(args.id);
    },

    users: async (_, { role, limit = 20, offset = 0 }, { db }) => {
      const filter = role ? { role } : {};
      return db.User.find(filter).skip(offset).limit(limit);
    }
  },

  // Field-level resolvers on User type
  User: {
    // parent = the User object returned from the Query resolver
    posts: async (user, _, { db }) => {
      return db.Post.find({ authorId: user.id });
    },
    // Computed field — not stored in DB
    fullName: (user) => user.firstName + " " + user.lastName
  },

  Mutation: {
    createUser: async (_, { input }, { db, bcrypt }) => {
      const hash = await bcrypt.hash(input.password, 12);
      return db.User.create({ ...input, passwordHash: hash });
    }
  }
};

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

await startStandaloneServer(server, {
  context: async ({ req }) => {
    // Build context for EVERY request
    const token = req.headers.authorization?.split(" ")[1];
    let currentUser = null;
    if (token) {
      try {
        const decoded = jwt.verify(token, process.env.JWT_SECRET);
        currentUser = await User.findById(decoded.userId);
      } catch {}
    }
    return {
      currentUser,           // attached user
      db: { User, Post },   // database models
      dataloaders            // batch loaders (Lesson 11)
    };
  }
});