tRPC vs Next.js 15: The Performance Battle comparison in Real-World

// trpc/server.ts
// tRPC v11.0.0-beta.4 server setup for Next.js 15 App Router
// Imports
import { initTRPC, TRPCError } from '@trpc/server';
import { z } from 'zod'; // For input validation
import { getServerSession } from 'next-auth/next'; // Next.js 15 auth integration
import { authOptions } from '@/app/api/auth/[...nextauth]/route';
import type { Session } from 'next-auth';

// 1. Define context type: passed to all resolvers
interface CreateContextOptions {
  session: Session | null;
  req: Request;
}

// 2. Create context function: runs on every request
const createContext = async ({ req }: { req: Request }): Promise => {
  try {
    const session = await getServerSession(authOptions);
    return { session, req };
  } catch (error) {
    console.error('Failed to create tRPC context:', error);
    return { session: null, req };
  }
};

// 3. Initialize tRPC with error formatting and middleware
const t = initTRPC.context().create({
  errorFormatter: ({ shape, error }) => {
    return {
      ...shape,
      data: {
        ...shape.data,
        // Include stack trace only in development
        stack: process.env.NODE_ENV === 'development' ? error.stack : undefined,
        zodError: error.cause instanceof z.ZodError ? error.cause.flatten() : null,
      },
    };
  },
});

// 4. Define reusable middleware for authentication
const isAuthed = t.middleware(async ({ ctx, next }) => {
  if (!ctx.session?.user) {
    throw new TRPCError({
      code: 'UNAUTHORIZED',
      message: 'You must be logged in to access this resource',
    });
  }
  return next({
    ctx: {
      // Infers session type as non-null after auth check
      session: { ...ctx.session, user: ctx.session.user },
    },
  });
});

// 5. Export router and procedure helpers
export const router = t.router;
export const publicProcedure = t.procedure;
export const protectedProcedure = t.procedure.use(isAuthed);

// 6. Define user router with CRUD endpoints
const userRouter = router({
  // Get current user (protected)
  me: protectedProcedure.query(async ({ ctx }) => {
    try {
      // In production, fetch from database
      return ctx.session.user;
    } catch (error) {
      throw new TRPCError({
        code: 'INTERNAL_SERVER_ERROR',
        message: 'Failed to fetch current user',
        cause: error,
      });
    }
  }),
  // Update user profile (protected, with input validation)
  updateProfile: protectedProcedure
    .input(
      z.object({
        name: z.string().min(2).max(50).optional(),
        bio: z.string().max(500).optional(),
      })
    )
    .mutation(async ({ ctx, input }) => {
      try {
        // In production, update database
        const updatedUser = { ...ctx.session.user, ...input };
        return { success: true, user: updatedUser };
      } catch (error) {
        throw new TRPCError({
          code: 'INTERNAL_SERVER_ERROR',
          message: 'Failed to update user profile',
          cause: error,
        });
      }
    }),
});

// 7. Define post router for nested queries (simulates e-commerce catalog)
const postRouter = router({
  // Get nested product catalog (3 levels: category > subcategory > product)
  getCatalog: publicProcedure
    .input(
      z.object({
        categoryId: z.string().uuid(),
        includeOutOfStock: z.boolean().default(false),
      })
    )
    .query(async ({ ctx, input }) => {
      try {
        // Simulate 1MB nested payload (matches benchmark workload)
        const catalog = {
          category: { id: input.categoryId, name: 'Electronics' },
          subcategories: Array.from({ length: 50 }, (_, i) => ({
            id: `subcat-${i}`,
            name: `Subcategory ${i}`,
            products: Array.from({ length: 20 }, (_, j) => ({
              id: `prod-${i}-${j}`,
              name: `Product ${i}-${j}`,
              price: Math.random() * 1000,
              inStock: Math.random() > 0.2,
              // Include non-JSON types to test superjson
              createdAt: new Date(),
              metadata: new Map([['supplier', 'Acme Corp']]),
            })),
          })),
        };
        if (!input.includeOutOfStock) {
          catalog.subcategories.forEach(sub => {
            sub.products = sub.products.filter(p => p.inStock);
          });
        }
        return catalog;
      } catch (error) {
        throw new TRPCError({
          code: 'INTERNAL_SERVER_ERROR',
          message: 'Failed to fetch product catalog',
          cause: error,
        });
      }
    }),
});

// 8. Combine routers into app router
export const appRouter = router({
  user: userRouter,
  post: postRouter,
});

// 9. Export router type for client-side type inference
export type AppRouter = typeof appRouter;

// 10. Create server-side caller for RSC usage
export const createCaller = t.createCallerFactory(appRouter);

// app/actions/catalog.ts
// Next.js 15 Server Actions equivalent to tRPC catalog endpoint
// Imports
import { z } from 'zod';
import { getServerSession } from 'next-auth/next';
import { authOptions } from '@/app/api/auth/[...nextauth]/route';
import { revalidatePath } from 'next/cache';
import { redirect } from 'next/navigation';

// 1. Define input validation schema (matches tRPC input)
const CatalogInputSchema = z.object({
  categoryId: z.string().uuid(),
  includeOutOfStock: z.boolean().default(false),
});

// 2. Define return type for type safety (manual, unlike tRPC's inferred types)
type CatalogProduct = {
  id: string;
  name: string;
  price: number;
  inStock: boolean;
  createdAt: Date;
  metadata: Map;
};

type CatalogSubcategory = {
  id: string;
  name: string;
  products: CatalogProduct[];
};

type Catalog = {
  category: { id: string; name: string };
  subcategories: CatalogSubcategory[];
};

// 3. Server Action: Get product catalog (equivalent to tRPC post.getCatalog)
export async function getCatalog(input: z.infer): Promise {
  try {
    // Validate input (Server Actions don't auto-validate like tRPC)
    const validatedInput = CatalogInputSchema.parse(input);

    // Simulate 1MB nested payload (matches benchmark workload)
    const catalog: Catalog = {
      category: { id: validatedInput.categoryId, name: 'Electronics' },
      subcategories: Array.from({ length: 50 }, (_, i) => ({
        id: `subcat-${i}`,
        name: `Subcategory ${i}`,
        products: Array.from({ length: 20 }, (_, j) => ({
          id: `prod-${i}-${j}`,
          name: `Product ${i}-${j}`,
          price: Math.random() * 1000,
          inStock: Math.random() > 0.2,
          createdAt: new Date(),
          metadata: new Map([['supplier', 'Acme Corp']]),
        })),
      })),
    };

    // Filter out of stock products if needed
    if (!validatedInput.includeOutOfStock) {
      catalog.subcategories.forEach(sub => {
        sub.products = sub.products.filter(p => p.inStock);
      });
    }

    // Revalidate cache for catalog page (Next.js 15 feature)
    revalidatePath(`/catalog/${validatedInput.categoryId}`);

    return catalog;
  } catch (error) {
    // Handle Zod validation errors
    if (error instanceof z.ZodError) {
      throw new Error(`Invalid input: ${JSON.stringify(error.flatten())}`);
    }
    // Handle other errors
    console.error('Failed to fetch catalog:', error);
    throw new Error('Failed to fetch product catalog. Please try again.');
  }
}

// 4. Server Action: Update user profile (equivalent to tRPC user.updateProfile)
export async function updateUserProfile(input: { name?: string; bio?: string }) {
  try {
    // Check auth (manual, unlike tRPC's middleware)
    const session = await getServerSession(authOptions);
    if (!session?.user) {
      redirect('/login');
    }

    // Validate input
    const validatedInput = z.object({
      name: z.string().min(2).max(50).optional(),
      bio: z.string().max(500).optional(),
    }).parse(input);

    // In production, update database
    const updatedUser = { ...session.user, ...validatedInput };

    // Revalidate user profile page
    revalidatePath('/profile');

    return { success: true, user: updatedUser };
  } catch (error) {
    if (error instanceof z.ZodError) {
      throw new Error(`Invalid input: ${JSON.stringify(error.flatten())}`);
    }
    console.error('Failed to update profile:', error);
    throw new Error('Failed to update profile. Please try again.');
  }
}

// 5. Server Action: Get current user (equivalent to tRPC user.me)
export async function getCurrentUser() {
  try {
    const session = await getServerSession(authOptions);
    if (!session?.user) {
      redirect('/login');
    }
    return session.user;
  } catch (error) {
    console.error('Failed to get current user:', error);
    throw new Error('Failed to fetch user data.');
  }
}

// benchmark/run-benchmark.ts
// Benchmark script to compare tRPC vs Next.js 15 Server Actions
// Methodology:
// - Hardware: AWS c7g.2xlarge (8 vCPU, 16GB RAM, Graviton3)
// - Software: Node.js 22.6.0, Next.js 15.0.1, tRPC 11.0.0-beta.4, autocannon 7.14.0, wrk2 4.2.0
// - Workload: 30s duration, 500 concurrent connections, 3-level nested catalog query (1MB payload)
// - Environment: Isolated VPC, no external network calls, warm server (10s warmup)

import autocannon from 'autocannon';
import { run } from 'wrk2';
import fs from 'fs/promises';
import path from 'path';

// 1. Define benchmark configurations
const BENCHMARK_DURATION = 30; // seconds
const CONCURRENT_CONNECTIONS = 500;
const WARMUP_DURATION = 10; // seconds
const OUTPUT_DIR = path.join(__dirname, 'results');

// 2. tRPC endpoint URL (deployed locally on port 3000)
const TRPC_URL = 'http://localhost:3000/api/trpc/post.getCatalog';
// 3. Next.js Server Action URL (deployed locally on port 3000)
const SERVER_ACTION_URL = 'http://localhost:3000/api/actions/getCatalog';

// 4. Payload for both endpoints (matches CatalogInputSchema)
const PAYLOAD = JSON.stringify({
  categoryId: '123e4567-e89b-12d3-a456-426614174000',
  includeOutOfStock: false,
});

// 5. Function to run autocannon benchmark
async function runAutocannon(url: string, name: string) {
  console.log(`Running autocannon benchmark for ${name}...`);
  try {
    const result = await autocannon({
      url,
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: PAYLOAD,
      connections: CONCURRENT_CONNECTIONS,
      duration: BENCHMARK_DURATION,
      warmup: WARMUP_DURATION,
      pipelining: 1,
    });

    // Format results
    const formatted = {
      name,
      tool: name.includes('tRPC') ? 'tRPC v11' : 'Next.js 15 Server Actions',
      requestsPerSecond: result.requests.average,
      p50Latency: result.latency.p50,
      p99Latency: result.latency.p99,
      errors: result.errors,
      throughput: result.throughput,
    };

    // Save results to file
    await fs.mkdir(OUTPUT_DIR, { recursive: true });
    await fs.writeFile(
      path.join(OUTPUT_DIR, `${name}-autocannon.json`),
      JSON.stringify(formatted, null, 2)
    );

    console.log(`Autocannon results for ${name}:`, formatted);
    return formatted;
  } catch (error) {
    console.error(`Autocannon benchmark failed for ${name}:`, error);
    throw error;
  }
}

// 6. Function to run wrk2 benchmark (more accurate latency)
async function runWrk2(url: string, name: string) {
  console.log(`Running wrk2 benchmark for ${name}...`);
  try {
    const result = await run({
      url,
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: PAYLOAD,
      connections: CONCURRENT_CONNECTIONS,
      duration: BENCHMARK_DURATION,
      warmup: WARMUP_DURATION,
      threads: 8, // Match vCPU count
      script: undefined,
    });

    // Format wrk2 results
    const formatted = {
      name,
      tool: name.includes('tRPC') ? 'tRPC v11' : 'Next.js 15 Server Actions',
      requestsPerSecond: result.requestsPerSec,
      p50Latency: result.latency.p50,
      p99Latency: result.latency.p99,
      errors: result.errors,
    };

    // Save results
    await fs.writeFile(
      path.join(OUTPUT_DIR, `${name}-wrk2.json`),
      JSON.stringify(formatted, null, 2)
    );

    console.log(`wrk2 results for ${name}:`, formatted);
    return formatted;
  } catch (error) {
    console.error(`wrk2 benchmark failed for ${name}:`, error);
    throw error;
  }
}

// 7. Main benchmark runner
async function main() {
  try {
    // Warmup: Run a quick request to both endpoints
    console.log('Warming up servers...');
    await fetch(TRPC_URL, { method: 'POST', body: PAYLOAD, headers: { 'Content-Type': 'application/json' } });
    await fetch(SERVER_ACTION_URL, { method: 'POST', body: PAYLOAD, headers: { 'Content-Type': 'application/json' } });

    // Run benchmarks
    const trpcAutocannon = await runAutocannon(TRPC_URL, 'tRPC');
    const serverActionAutocannon = await runAutocannon(SERVER_ACTION_URL, 'Next.js-Server-Action');
    const trpcWrk2 = await runWrk2(TRPC_URL, 'tRPC');
    const serverActionWrk2 = await runWrk2(SERVER_ACTION_URL, 'Next.js-Server-Action');

    // Generate summary report
    const summary = {
      timestamp: new Date().toISOString(),
      methodology: {
        hardware: 'AWS c7g.2xlarge (8 vCPU, 16GB RAM)',
        software: 'Node.js 22.6.0, Next.js 15.0.1, tRPC 11.0.0-beta.4',
        workload: '3-level nested catalog query, 1MB payload, 500 concurrent connections, 30s duration',
      },
      results: {
        autocannon: [trpcAutocannon, serverActionAutocannon],
        wrk2: [trpcWrk2, serverActionWrk2],
      },
    };

    await fs.writeFile(
      path.join(OUTPUT_DIR, 'benchmark-summary.json'),
      JSON.stringify(summary, null, 2)
    );

    console.log('Benchmark complete. Results saved to', OUTPUT_DIR);
  } catch (error) {
    console.error('Benchmark failed:', error);
    process.exit(1);
  }
}

// Run if this is the main module
if (require.main === module) {
  main();
}

// Reusable auth middleware for tRPC
const isAuthed = t.middleware(async ({ ctx, next }) => {
  if (!ctx.session?.user) {
    throw new TRPCError({ code: 'UNAUTHORIZED' });
  }
  return next({ ctx: { session: { ...ctx.session, user: ctx.session.user } } });
});
export const protectedProcedure = t.procedure.use(isAuthed);

// Edge-optimized Server Action with payload limit
export const dynamic = 'force-dynamic';
export const runtime = 'edge';

export async function submitContactForm(input: { name: string; email: string; message: string }) {
  // Payload size limit (1MB max for edge)
  if (JSON.stringify(input).length > 1_000_000) {
    throw new Error('Payload too large (max 1MB)');
  }
  const validated = z.object({
    name: z.string().min(2),
    email: z.string().email(),
    message: z.string().min(10),
  }).parse(input);
  // Process form...
  revalidateTag('contact-submissions');
  return { success: true };
}

// Hybrid client setup (tRPC + Server Actions)
import { trpc } from '@/trpc/client'; // tRPC client
import { submitContactForm } from '@/app/actions/contact'; // Server Action

export function ContactForm() {
  const trpcUtils = trpc.useUtils();
  const { mutate: updateProfile } = trpc.user.updateProfile.useMutation();

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();
    // Use Server Action for simple form mutation
    await submitContactForm({ name: 'John', email: 'john@example.com', message: 'Hello' });
    // Use tRPC for complex profile update
    updateProfile({ name: 'John Doe' });
    trpcUtils.user.me.invalidate();
  };

  return ...;
}