Route parameters in NestJS - Performance & Optimization

Performance: Route parameters

MEDIUM IMPACT

Route parameters affect server-side routing speed and how quickly the server can match and process incoming requests.

Handling dynamic URL segments in NestJS routes

NestJS

import { Controller, Get, Param } from '@nestjs/common';

@Controller('users')
export class UserController {
  @Get(':id')
  getUser(@Param('id') id: string) {
    return `User ID is ${id}`;
  }
}

Using NestJS route parameters lets the framework efficiently parse and match routes internally.

📈 Performance GainReduces CPU overhead by avoiding manual parsing, improving routing speed.

Handling dynamic URL segments in NestJS routes

NestJS

import { Controller, Get, Req } from '@nestjs/common';

@Controller('users')
export class UserController {
  @Get('*')
  getUser(@Req() req) {
    const userId = req.url.split('/')[2];
    // process userId manually
    return `User ID is ${userId}`;
  }
}

Manually parsing URL strings bypasses NestJS routing optimizations and adds unnecessary processing.

📉 Performance CostAdds extra string operations per request, increasing CPU usage and slowing routing.

Performance Comparison

Pattern	CPU Usage	Routing Speed	Code Complexity	Verdict
Manual URL parsing	High (extra string ops)	Slower (extra processing)	High (manual code)	[X] Bad
NestJS @Param decorator	Low (optimized parsing)	Faster (native routing)	Low (clean code)	[OK] Good

Rendering Pipeline

Route parameters are processed during the server's routing phase before controller logic executes. Efficient parameter parsing reduces server CPU time and speeds response generation.

→Routing

→Controller Execution

⚠️ BottleneckRouting stage CPU usage due to manual string parsing

Optimization Tips

1Always use NestJS @Param decorator for route parameters to leverage optimized parsing.

2Avoid manual string operations on URLs to reduce CPU overhead during routing.

3Keep route handlers simple to improve server response times.

Performance Quiz - 3 Questions

What is the main performance benefit of using NestJS route parameters instead of manual URL parsing?

A Reduced CPU usage during routing

B Improved client-side rendering speed

C Lower network bandwidth usage

D Faster database queries

DevTools: Network and Performance panels

How to check: Use Network panel to measure request response times; use Performance panel to profile server CPU usage during routing.

What to look for: Look for lower CPU time and faster response times when using route parameters correctly.

Practice

1. What does the : symbol represent in a NestJS route path like @Get('users/:id')?

easy

A. It is used to comment out the route path.

B. It defines a query parameter to be passed in the URL.

C. It indicates a static part of the URL path.

D. It marks id as a dynamic route parameter to capture from the URL.

Solution

1. Step 1: Understand route path syntax

   The colon : before id in @Get('users/:id') means id is a variable part of the URL.

2. Step 2: Identify the role of dynamic parameters

   This dynamic parameter allows the route to accept different id values from the URL, making the route flexible.

3. Final Answer:

   It marks id as a dynamic route parameter to capture from the URL. -> Option D

4. Quick Check:

   Colon means dynamic parameter = A [OK]

Hint: Colon before name means dynamic URL part [OK]

Common Mistakes:

• Thinking colon means query parameter
• Confusing static and dynamic parts
• Assuming colon is for comments

2. Which of the following is the correct way to access a route parameter named userId inside a NestJS controller method?

easy

A. @Body('userId') userId: string

B. @Query('userId') userId: string

C. @Param('userId') userId: string

D. @Headers('userId') userId: string

Solution

1. Step 1: Identify decorator for route parameters

   In NestJS, @Param() decorator is used to extract route parameters from the URL.

2. Step 2: Match parameter name

   Using @Param('userId') correctly accesses the userId parameter from the route.

3. Final Answer:

   @Param('userId') userId: string -> Option C

4. Quick Check:

   @Param for route params = C [OK]

Hint: Use @Param('name') to get route parameters [OK]

Common Mistakes:

• Using @Query instead of @Param for route params
• Trying to get route params from @Body or @Headers
• Forgetting to specify parameter name in @Param

3. Given this NestJS controller method:

@Get('products/:id')
getProduct(@Param('id') id: string) {
  return `Product ID is ${id}`;
}

What will be the response when a client requests /products/42?

medium

A. "Product ID is 42"

B. "Product ID is id"

C. "Product ID is undefined"

D. 404 Not Found error

Solution

1. Step 1: Understand route parameter extraction

   The @Param('id') decorator extracts the value 42 from the URL /products/42.

2. Step 2: Check returned string

   The method returns the string with the extracted id interpolated: "Product ID is 42".

3. Final Answer:

   "Product ID is 42" -> Option A

4. Quick Check:

   Route param 'id' = 42 in output [OK]

Hint: Route param value replaces :id in URL [OK]

Common Mistakes:

• Expecting literal 'id' instead of value
• Not using @Param to get the value
• Assuming undefined if param missing

4. What is wrong with this NestJS controller method?

@Get('orders/:orderId')
getOrder(@Param() orderId: string) {
  return `Order: ${orderId}`;
}

medium

A. Missing parameter name inside @Param() decorator.

B. Route path should not have colon before orderId.

C. Method should use @Query instead of @Param.

D. Return statement syntax is invalid.

Solution

1. Step 1: Check @Param usage

   The @Param() decorator without an argument returns an object of all params, not a single string.

2. Step 2: Identify mismatch in parameter type

   The method expects orderId as a string, but @Param() without argument returns an object, causing a type mismatch.

3. Final Answer:

   Missing parameter name inside @Param() decorator. -> Option A

4. Quick Check:

   @Param needs name for single param = B [OK]

Hint: Use @Param('name') for single param, else get object [OK]

Common Mistakes:

• Omitting parameter name in @Param() when expecting string
• Confusing @Param with @Query
• Thinking colon is wrong in route path

5. You want to create a NestJS route that accepts two parameters: category and itemId. Which of the following route paths and method signatures correctly captures both parameters?

hard

A. @Get('shop/:category/:itemId')getItem(@Body('category') category: string, @Body('itemId') itemId: string)

B. @Get('shop/:category/:itemId')getItem(@Param('category') category: string, @Param('itemId') itemId: string)

C. @Get('shop/:category/:itemId')getItem(@Query('category') category: string, @Query('itemId') itemId: string)

D. @Get('shop/:category/:itemId')getItem(@Param() params: string)

Solution

1. Step 1: Verify route path with two parameters

   The path 'shop/:category/:itemId' correctly defines two dynamic route parameters.

2. Step 2: Check method parameters for correct decorators

   Using @Param('category') and @Param('itemId') extracts each parameter individually as strings.

3. Final Answer:

   @Get('shop/:category/:itemId') with getItem(@Param('category') category: string, @Param('itemId') itemId: string) -> Option B

4. Quick Check:

   Use @Param('name') for each route param = D [OK]

Hint: Use @Param('name') for each route parameter [OK]

Common Mistakes:

• Using @Param() with string instead of object
• Using @Query or @Body instead of @Param for route params
• Not matching parameter names exactly