majiayu000 Backend Patterns
Apply production-ready backend architecture patterns.
Stack Detection
Check for: package.json (Node/Express/Fastify/Hono), pom.xml (Spring Boot), pyproject.toml (FastAPI/Django), go.mod (Go/Gin/Fiber)
Universal Patterns (all stacks)
Repository Pattern
Separate data access from business logic:
// TypeScript
interface UserRepository {
findById(id: string): Promise<User | null>;
findAll(options: PaginationOptions): Promise<Page<User>>;
create(data: CreateUserDto): Promise<User>;
update(id: string, data: UpdateUserDto): Promise<User>;
delete(id: string): Promise<void>;
}
# Python
class UserRepository:
async def find_by_id(self, id: str) -> User | None: ...
async def find_all(self, options: PaginationOptions) -> Page[User]: ...
async def create(self, data: CreateUserDto) -> User: ...
Service Layer
Business logic lives in services, not controllers:
// TypeScript
class UserService {
constructor(private readonly userRepo: UserRepository) {}
async createUser(dto: CreateUserDto): Promise<User> {
// Business logic: validation, hashing, etc.
const existing = await this.userRepo.findByEmail(dto.email);
if (existing) throw new ConflictError("Email already exists");
const hashed = await bcrypt.hash(dto.password, 12);
return this.userRepo.create({ ...dto, password: hashed });
}
}
Error Handling Middleware
// TypeScript / Express
app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
if (err instanceof ValidationError) {
return res.status(400).json({ error: { code: "VALIDATION_ERROR", message: err.message } });
}
if (err instanceof NotFoundError) {
return res.status(404).json({ error: { code: "NOT_FOUND", message: err.message } });
}
logger.error("Unhandled error", { error: err.message, stack: err.stack });
res.status(500).json({ error: { code: "INTERNAL_ERROR", message: "Internal server error" } });
});
Input Validation
// TypeScript with Zod
const CreateUserSchema = z.object({
email: z.string().email(),
password: z.string().min(8).max(72),
name: z.string().min(1).max(100),
});
// Python with Pydantic
class CreateUserDto(BaseModel):
email: EmailStr
password: str = Field(min_length=8, max_length=72)
name: str = Field(min_length=1, max_length=100)
N+1 Query Prevention
// ❌ N+1 problem
const users = await userRepo.findAll();
for (const user of users) {
user.posts = await postRepo.findByUserId(user.id); // N queries!
}
// ✅ Join or batch
const users = await userRepo.findAllWithPosts(); // 1 query with JOIN
// or use DataLoader pattern for GraphQL
Pagination Pattern
interface PaginationOptions {
page: number; // 1-based
limit: number; // max 100
}
interface Page<T> {
data: T[];
meta: { total: number; page: number; limit: number; totalPages: number };
}
Usage
/backend-patterns # review and improve current backend
/backend-patterns repository # add repository pattern
/backend-patterns service # add service layer
/backend-patterns error # add error handling
/backend-patterns validation # add input validation