Service vs Filter Boundaries

Service vs Filter Boundaries Domain-specific exceptions, contextual translation, and keeping business meaning out of global infrastructure code

Phase 13 - Professional Error Handling Volume 04 - Professional Backend

Architecture milestone service understands use case

↓

exception carries meaning

↓

filter formats HTTP

Phase 13 creates one professional exception boundary and a correlation story that spans client response and server logs.

Create application-specific exceptions only when they add meaning NestJS already has NotFoundException and ConflictException. TaskFlow subclasses them only when a stable application code or reusable domain message earns its place.

import { ConflictException, NotFoundException, } from "@nestjs/common";

export class TaskNotFoundException extends NotFoundException { constructor(taskId: string) { super({ code: "TASK_NOT_FOUND", message: `Task ${taskId} was not found.`, }); } }

export class ProjectNotFoundException extends NotFoundException { constructor(projectId: string) { super({ code: "PROJECT_NOT_FOUND", message: `Project ${projectId} was not found.`, }); } }

export class ResourceConflictException extends ConflictException {
constructor(message: string, code = "RESOURCE_CONFLICT") {
super({ code, message });
}
}

TasksService now communicates domain meaning The service decides that a missing Task is a Task-domain event, not merely a Prisma event. That keeps the public API independent from which ORM we use.

import { Injectable } from "@nestjs/common";
import { Prisma } from "../generated/prisma/client";
import { PrismaService } from "../prisma/prisma.service";
import {
ProjectNotFoundException,
TaskNotFoundException,
} from "../common/errors/application.exceptions";
import {
CreateTaskDto,
UpdateTaskDto,
} from "./tasks.schemas";

@Injectable()
export class TasksService {
constructor(private readonly prisma: PrismaService) {}

findAll() { return this.prisma.task.findMany({ orderBy: { createdAt: "desc" }, }); }

async findOne(id: string) {
const task = await this.prisma.task.findUnique({
where: { id },
});

if (!task) { throw new TaskNotFoundException(id); }

return task; }

async create(input: CreateTaskDto) {
const project = await this.prisma.project.findUnique({
where: { id: input.projectId },
select: { id: true },
});

if (!project) { throw new ProjectNotFoundException(input.projectId);

}

return this.prisma.task.create({ data: input, }); }

async update(id: string, input: UpdateTaskDto) { try { return await this.prisma.task.update({ where: { id }, data: input, }); } catch (error) { this.rethrowMissingTask(error, id); } }

async remove(id: string) {
try {
await this.prisma.task.delete({
where: { id },
});
} catch (error) {
this.rethrowMissingTask(error, id);
}
}

private rethrowMissingTask(error: unknown, id: string): never { if ( error instanceof Prisma.PrismaClientKnownRequestError && error.code === "P2025" ) { throw new TaskNotFoundException(id); }

throw error;
}
}

Responsibility boundaries Layer Owns

Zod / pipe Request shape validity

TasksService Task/Project existence and business meaning

Prisma Persistence operations and database protocol

ApiExceptionFilter HTTP serialization, safe fallback, final logging

Anti-pattern: filter contains business rules // Avoid turning the global filter into this: if (exception.code === "P2025" && request.url.startsWith("/tasks")) { // infer Task business meaning from URL here... }

Architecture rule

The global filter should not reverse-engineer domain context from routes or database metadata. Services know the use case. Filters know HTTP error serialization.

Anti-pattern: swallowing unknown errors If a service catches unknown Error and turns it into BadRequestException, a programming bug can masquerade as a client mistake. Catch only failures you understand and can meaningfully translate. Re-throw the rest.