Benchmark: GraphQL 17 vs. REST vs. tRPC 11 API Payload Size for 100k User Apps

// GraphQL 17 Server Implementation
// Dependencies: graphql@17.0.0, express@4.18.2, express-graphql@0.12.0, faker@5.5.3
const { GraphQLSchema, GraphQLObjectType, GraphQLList, GraphQLString, GraphQLInt, GraphQLBoolean, GraphQLNonNull } = require('graphql');
const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { faker } = require('faker');

// Generate 100k user test dataset
const generateUsers = (count) => {
  const users = [];
  for (let i = 0; i < count; i++) {
    users.push({
      id: i + 1,
      name: faker.person.fullName(),
      email: faker.internet.email(),
      isActive: faker.datatype.boolean(),
      profile: {
        bio: faker.lorem.paragraph(),
        avatar: faker.image.avatar(),
        location: faker.location.city(),
        website: faker.internet.url(),
        social: {
          twitter: faker.internet.userName(),
          github: faker.internet.userName(),
        }
      },
      settings: {
        theme: faker.helpers.arrayElement(['light', 'dark']),
        notifications: faker.datatype.boolean(),
        language: faker.helpers.arrayElement(['en', 'es', 'fr']),
      },
      lastActive: faker.date.recent().toISOString(),
    });
  }
  return users;
};

// Initialize 100k user dataset (cached for benchmarks)
const USERS = generateUsers(100000);

// Define GraphQL User Type
const UserType = new GraphQLObjectType({
  name: 'User',
  fields: () => ({
    id: { type: new GraphQLNonNull(GraphQLInt) },
    name: { type: new GraphQLNonNull(GraphQLString) },
    email: { type: GraphQLString },
    isActive: { type: GraphQLBoolean },
    profile: {
      type: new GraphQLObjectType({
        name: 'UserProfile',
        fields: () => ({
          bio: { type: GraphQLString },
          avatar: { type: GraphQLString },
          location: { type: GraphQLString },
          website: { type: GraphQLString },
          social: {
            type: new GraphQLObjectType({
              name: 'UserSocial',
              fields: () => ({
                twitter: { type: GraphQLString },
                github: { type: GraphQLString },
              })
            })
          }
        })
      })
    },
    settings: {
      type: new GraphQLObjectType({
        name: 'UserSettings',
        fields: () => ({
          theme: { type: GraphQLString },
          notifications: { type: GraphQLBoolean },
          language: { type: GraphQLString },
        })
      })
    },
    lastActive: { type: GraphQLString },
  })
});

// Root Query
const RootQuery = new GraphQLObjectType({
  name: 'RootQueryType',
  fields: () => ({
    users: {
      type: new GraphQLList(UserType),
      args: {
        limit: { type: GraphQLInt, defaultValue: 100000 },
        offset: { type: GraphQLInt, defaultValue: 0 },
        activeOnly: { type: GraphQLBoolean, defaultValue: false },
      },
      resolve: (parent, args) => {
        try {
          let filtered = args.activeOnly ? USERS.filter(u => u.isActive) : USERS;
          return filtered.slice(args.offset, args.offset + args.limit);
        } catch (err) {
          console.error('User resolver error:', err);
          throw new Error('Failed to fetch users');
        }
      }
    }
  })
});

// Schema
const schema = new GraphQLSchema({
  query: RootQuery,
});

// Express Server
const app = express();
app.use('/graphql', graphqlHTTP({
  schema,
  graphiql: false, // Disable GUI for benchmarks
  customFormatErrorFn: (err) => {
    console.error('GraphQL Error:', err);
    return { message: err.message, status: 500 };
  }
}));

// Error handling middleware
app.use((err, req, res, next) => {
  console.error('Server error:', err);
  res.status(500).json({ error: 'Internal server error' });
});

const PORT = 4000;
app.listen(PORT, () => {
  console.log(`GraphQL 17 server running on port ${PORT}`);
});

// REST (Express 4.18.2) Server Implementation
// Dependencies: express@4.18.2, faker@5.5.3, zod@3.22.4
const express = require('express');
const { z } = require('zod');
const { faker } = require('faker');

// Generate 100k user test dataset (identical to GraphQL benchmark)
const generateUsers = (count) => {
  const users = [];
  for (let i = 0; i < count; i++) {
    users.push({
      id: i + 1,
      name: faker.person.fullName(),
      email: faker.internet.email(),
      isActive: faker.datatype.boolean(),
      profile: {
        bio: faker.lorem.paragraph(),
        avatar: faker.image.avatar(),
        location: faker.location.city(),
        website: faker.internet.url(),
        social: {
          twitter: faker.internet.userName(),
          github: faker.internet.userName(),
        }
      },
      settings: {
        theme: faker.helpers.arrayElement(['light', 'dark']),
        notifications: faker.datatype.boolean(),
        language: faker.helpers.arrayElement(['en', 'es', 'fr']),
      },
      lastActive: faker.date.recent().toISOString(),
    });
  }
  return users;
};

const USERS = generateUsers(100000);

// Validation Schemas
const GetUsersSchema = z.object({
  limit: z.number().int().positive().max(100000).optional().default(100000),
  offset: z.number().int().nonnegative().optional().default(0),
  activeOnly: z.boolean().optional().default(false),
  fields: z.array(z.string()).optional(), // For partial responses
});

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

// GET /users endpoint
app.get('/users', async (req, res, next) => {
  try {
    // Validate query params
    const { limit, offset, activeOnly, fields } = GetUsersSchema.parse({
      limit: req.query.limit ? parseInt(req.query.limit) : undefined,
      offset: req.query.offset ? parseInt(req.query.offset) : undefined,
      activeOnly: req.query.activeOnly === 'true',
      fields: req.query.fields ? req.query.fields.split(',') : undefined,
    });

    // Filter and paginate users
    let filtered = activeOnly ? USERS.filter(u => u.isActive) : USERS;
    const paginated = filtered.slice(offset, offset + limit);

    // Handle partial responses (field selection)
    let response = paginated;
    if (fields && fields.length > 0) {
      response = paginated.map(user => {
        const subset = {};
        fields.forEach(field => {
          if (user.hasOwnProperty(field)) subset[field] = user[field];
          // Handle nested fields (e.g., profile.bio)
          else if (field.includes('.')) {
            const [parent, child] = field.split('.');
            if (user[parent] && user[parent][child]) {
              subset[field] = user[parent][child];
            }
          }
        });
        return subset;
      });
    }

    res.status(200).json({
      total: filtered.length,
      limit,
      offset,
      data: response,
    });
  } catch (err) {
    console.error('GET /users error:', err);
    if (err instanceof z.ZodError) {
      return res.status(400).json({ error: 'Invalid query parameters', details: err.errors });
    }
    next(err);
  }
});

// POST /users/query for complex filters
app.post('/users/query', async (req, res, next) => {
  try {
    const { limit, offset, activeOnly, fields } = GetUsersSchema.parse(req.body);

    let filtered = activeOnly ? USERS.filter(u => u.isActive) : USERS;
    const paginated = filtered.slice(offset, offset + limit);

    let response = paginated;
    if (fields && fields.length > 0) {
      response = paginated.map(user => {
        const subset = {};
        fields.forEach(field => {
          if (user.hasOwnProperty(field)) subset[field] = user[field];
          else if (field.includes('.')) {
            const [parent, child] = field.split('.');
            if (user[parent] && user[parent][child]) {
              subset[field] = user[parent][child];
            }
          }
        });
        return subset;
      });
    }

    res.status(200).json({
      total: filtered.length,
      limit,
      offset,
      data: response,
    });
  } catch (err) {
    console.error('POST /users/query error:', err);
    if (err instanceof z.ZodError) {
      return res.status(400).json({ error: 'Invalid request body', details: err.errors });
    }
    next(err);
  }
});

// Error handling middleware
app.use((err, req, res, next) => {
  console.error('Unhandled server error:', err);
  res.status(500).json({ error: 'Internal server error' });
});

const PORT = 4001;
app.listen(PORT, () => {
  console.log(`REST server running on port ${PORT}`);
});

// tRPC 11 Server Implementation
// Dependencies: @trpc/server@11.0.0-rc.312, @trpc/client@11.0.0-rc.312, zod@3.22.4, faker@5.5.3, express@4.18.2, @trpc/server/adapters/express
const { initTRPC } = require('@trpc/server');
const { z } = require('zod');
const { faker } = require('faker');
const express = require('express');
const { createExpressMiddleware } = require('@trpc/server/adapters/express');

// Generate identical 100k user dataset
const generateUsers = (count) => {
  const users = [];
  for (let i = 0; i < count; i++) {
    users.push({
      id: i + 1,
      name: faker.person.fullName(),
      email: faker.internet.email(),
      isActive: faker.datatype.boolean(),
      profile: {
        bio: faker.lorem.paragraph(),
        avatar: faker.image.avatar(),
        location: faker.location.city(),
        website: faker.internet.url(),
        social: {
          twitter: faker.internet.userName(),
          github: faker.internet.userName(),
        }
      },
      settings: {
        theme: faker.helpers.arrayElement(['light', 'dark']),
        notifications: faker.datatype.boolean(),
        language: faker.helpers.arrayElement(['en', 'es', 'fr']),
      },
      lastActive: faker.date.recent().toISOString(),
    });
  }
  return users;
};

const USERS = generateUsers(100000);

// Initialize tRPC
const t = initTRPC.create({
  errorFormatter: ({ shape, error }) => {
    console.error('tRPC Error:', error);
    return {
      ...shape,
      data: {
        ...shape.data,
        zodError: error.cause instanceof z.ZodError ? error.cause.flatten() : null,
      },
    };
  },
});

// Define public procedure
const publicProcedure = t.procedure;
const router = t.router;

// User router
const userRouter = router({
  // Query to get users, with strict input validation
  getUsers: publicProcedure
    .input(
      z.object({
        limit: z.number().int().positive().max(100000).optional().default(100000),
        offset: z.number().int().nonnegative().optional().default(0),
        activeOnly: z.boolean().optional().default(false),
        // Fields to return, with automatic pruning via tRPC transformer
        fields: z.array(z.string()).optional(),
      })
    )
    .query(async ({ input }) => {
      try {
        const { limit, offset, activeOnly, fields } = input;
        // Filter users
        let filtered = activeOnly ? USERS.filter(u => u.isActive) : USERS;
        const paginated = filtered.slice(offset, offset + limit);

        // Automatic field pruning
        let response = paginated;
        if (fields && fields.length > 0) {
          response = paginated.map(user => {
            const subset = {};
            fields.forEach(field => {
              if (user.hasOwnProperty(field)) subset[field] = user[field];
              else if (field.includes('.')) {
                const [parent, child] = field.split('.');
                if (user[parent] && user[parent][child]) {
                  subset[field] = user[parent][child];
                }
              }
            });
            return subset;
          });
        }

        return {
          total: filtered.length,
          limit,
          offset,
          data: response,
        };
      } catch (err) {
        console.error('getUsers query error:', err);
        throw new Error('Failed to fetch users');
      }
    }),

  // Mutation example
  updateUser: publicProcedure
    .input(
      z.object({
        id: z.number().int().positive(),
        name: z.string().optional(),
        isActive: z.boolean().optional(),
      })
    )
    .mutation(async ({ input }) => {
      try {
        const userIndex = USERS.findIndex(u => u.id === input.id);
        if (userIndex === -1) {
          throw new Error('User not found');
        }
        USERS[userIndex] = { ...USERS[userIndex], ...input };
        return USERS[userIndex];
      } catch (err) {
        console.error('updateUser mutation error:', err);
        throw new Error('Failed to update user');
      }
    }),
});

// Root router
const appRouter = router({
  user: userRouter,
});

// Export router type for client (TypeScript)
// export type AppRouter = typeof appRouter;

const app = express();
app.use('/trpc', createExpressMiddleware({
  router: appRouter,
  createContext: ({ req, res }) => {
    return { req, res };
  },
}));

// Error handling middleware
app.use((err, req, res, next) => {
  console.error('Server error:', err);
  res.status(500).json({ error: 'Internal server error' });
});

const PORT = 4002;
app.listen(PORT, () => {
  console.log(`tRPC 11 server running on port ${PORT}`);
});

// Custom tRPC transformer for field pruning
const fieldPruningTransformer = {
  input: (input) => input,
  output: (output, ctx) => {
    const { fields } = ctx.input;
    if (!fields || fields.length === 0) return output;
    // Prune output data to only requested fields
    if (output.data && Array.isArray(output.data)) {
      output.data = output.data.map(item => {
        const pruned = {};
        fields.forEach(field => {
          if (item.hasOwnProperty(field)) pruned[field] = item[field];
          else if (field.includes('.')) {
            const [parent, child] = field.split('.');
            if (item[parent]) pruned[field] = item[parent][child];
          }
        });
        return pruned;
      });
    }
    return output;
  },
};

// Add to tRPC init
const t = initTRPC.create({
  transformer: fieldPruningTransformer,
});

// GraphQL 17 resolver with lookahead
const UserType = new GraphQLObjectType({
  name: 'User',
  fields: () => ({
    id: { type: GraphQLInt },
    name: { type: GraphQLString },
    profile: { type: UserProfileType },
    settings: { type: UserSettingsType },
  })
});

const resolvers = {
  Query: {
    users: {
      resolve: (parent, args, context, info) => {
        // Use lookahead to check requested fields
        const requestedFields = info.fieldNodes[0].selectionSet.selections.map(s => s.name.value);
        const needsProfile = requestedFields.includes('profile');
        const needsSettings = requestedFields.includes('settings');

        // Only fetch requested nested data
        let users = USERS.slice(args.offset, args.offset + args.limit);
        if (needsProfile || needsSettings) {
          users = users.map(user => {
            const subset = { ...user };
            if (!needsProfile) delete subset.profile;
            if (!needsSettings) delete subset.settings;
            return subset;
          });
        }
        return users;
      }
    }
  }
};

// REST partial response with Zod validation
const GetUsersSchema = z.object({
  limit: z.number().optional(),
  fields: z.array(z.string()).optional(),
});

app.get('/users', (req, res) => {
  const { limit, fields } = GetUsersSchema.parse({
    limit: req.query.limit,
    fields: req.query.fields?.split(','),
  });
  let users = USERS.slice(0, limit || 100000);
  if (fields) {
    users = users.map(user => {
      const subset = {};
      fields.forEach(field => {
        if (user.hasOwnProperty(field)) subset[field] = user[field];
      });
      return subset;
    });
  }
  res.json(users);
});