1---
2title: Throw HTTP Exceptions from Services
3impact: HIGH
4impactDescription: Keeps controllers thin and simplifies error handling
5tags: error-handling, exceptions, services
6---
7 
8## Throw HTTP Exceptions from Services
9 
10It's acceptable (and often preferable) to throw `HttpException` subclasses from services in HTTP applications. This keeps controllers thin and allows services to communicate appropriate error states. For truly layer-agnostic services, use domain exceptions that map to HTTP status codes.
11 
12**Incorrect (return error objects instead of throwing):**
13 
14```typescript
15// Return error objects instead of throwing
16@Injectable()
17export class UsersService {
18  async findById(id: string): Promise<{ user?: User; error?: string }> {
19    const user = await this.repo.findOne({ where: { id } });
20    if (!user) {
21      return { error: 'User not found' }; // Controller must check this
22    }
23    return { user };
24  }
25}
26 
27@Controller('users')
28export class UsersController {
29  @Get(':id')
30  async findOne(@Param('id') id: string) {
31    const result = await this.usersService.findById(id);
32    if (result.error) {
33      throw new NotFoundException(result.error);
34    }
35    return result.user;
36  }
37}
38```
39 
40**Correct (throw exceptions directly from service):**
41 
42```typescript
43// Throw exceptions directly from service
44@Injectable()
45export class UsersService {
46  constructor(private readonly repo: UserRepository) {}
47 
48  async findById(id: string): Promise<User> {
49    const user = await this.repo.findOne({ where: { id } });
50    if (!user) {
51      throw new NotFoundException(`User #${id} not found`);
52    }
53    return user;
54  }
55 
56  async create(dto: CreateUserDto): Promise<User> {
57    const existing = await this.repo.findOne({
58      where: { email: dto.email },
59    });
60    if (existing) {
61      throw new ConflictException('Email already registered');
62    }
63    return this.repo.save(dto);
64  }
65 
66  async update(id: string, dto: UpdateUserDto): Promise<User> {
67    const user = await this.findById(id); // Throws if not found
68    Object.assign(user, dto);
69    return this.repo.save(user);
70  }
71}
72 
73// Controller stays thin
74@Controller('users')
75export class UsersController {
76  @Get(':id')
77  findOne(@Param('id') id: string): Promise<User> {
78    return this.usersService.findById(id);
79  }
80 
81  @Post()
82  create(@Body() dto: CreateUserDto): Promise<User> {
83    return this.usersService.create(dto);
84  }
85}
86 
87// For layer-agnostic services, use domain exceptions
88export class EntityNotFoundException extends Error {
89  constructor(
90    public readonly entity: string,
91    public readonly id: string,
92  ) {
93    super(`${entity} with ID "${id}" not found`);
94  }
95}
96 
97// Map to HTTP in exception filter
98@Catch(EntityNotFoundException)
99export class EntityNotFoundFilter implements ExceptionFilter {
100  catch(exception: EntityNotFoundException, host: ArgumentsHost) {
101    const ctx = host.switchToHttp();
102    const response = ctx.getResponse<Response>();
103 
104    response.status(404).json({
105      statusCode: 404,
106      message: exception.message,
107      entity: exception.entity,
108      id: exception.id,
109    });
110  }
111}
112```
113 
114Reference: [NestJS Exception Filters](https://docs.nestjs.com/exception-filters)
115