service-layer-extractor

Service Layer Extractor Extract business logic from controllers into a testable service layer. Architecture Layers routes/ → Define endpoints, parse requests controllers/ → Validate input, call services, format responses services/ → Business logic, orchestration repositories/ → Database queries models/ → Data structures Before: Fat Controller // ❌ Business logic mixed with HTTP concerns router . post ( "/users" , async ( req , res ) => { try { // Validation if ( ! req . body . email ) { return res . status ( 400 ) . json ( { error : "Email required" } ) ; } // Check duplicate const existing = await db . query ( "SELECT * FROM users WHERE email = $1" , [ req . body . email , ] ) ; if ( existing . rows . length

0 ) { return res . status ( 409 ) . json ( { error : "Email already exists" } ) ; } // Hash password const hashedPassword = await bcrypt . hash ( req . body . password , 10 ) ; // Create user const result = await db . query ( "INSERT INTO users (email, password, name) VALUES ($1, $2, $3) RETURNING *" , [ req . body . email , hashedPassword , req . body . name ] ) ; // Send welcome email await sendEmail ( req . body . email , "Welcome!" , "Thanks for joining" ) ; res . status ( 201 ) . json ( result . rows [ 0 ] ) ; } catch ( err ) { res . status ( 500 ) . json ( { error : err . message } ) ; } } ) ; After: Service Layer // ✅ Separated concerns // services/user.service.ts export class UserService { constructor ( private userRepository : UserRepository , private emailService : EmailService ) { } async createUser ( dto : CreateUserDto ) : Promise < User

{ // Business logic only const existing = await this . userRepository . findByEmail ( dto . email ) ; if ( existing ) { throw new ConflictError ( "Email already exists" ) ; } const hashedPassword = await bcrypt . hash ( dto . password , 10 ) ; const user = await this . userRepository . create ( { ... dto , password : hashedPassword , } ) ; await this . emailService . sendWelcome ( user . email ) ; return user ; } } // controllers/user.controller.ts export class UserController { constructor ( private userService : UserService ) { } create = asyncHandler ( async ( req , res ) => { const user = await this . userService . createUser ( req . body ) ; res . status ( 201 ) . json ( { success : true , data : user } ) ; } ) ; } // repositories/user.repository.ts export class UserRepository { async create ( data : CreateUserData ) : Promise < User

{ const result = await db . query ( "INSERT INTO users (email, password, name) VALUES ($1, $2, $3) RETURNING *" , [ data . email , data . password , data . name ] ) ; return result . rows [ 0 ] ; } async findByEmail ( email : string ) : Promise < User | null

{ const result = await db . query ( "SELECT * FROM users WHERE email = $1" , [ email , ] ) ; return result . rows [ 0 ] || null ; } } Dependency Injection // container.ts (using tsyringe or manual) import { UserService } from "./services/user.service" ; import { UserRepository } from "./repositories/user.repository" ; import { EmailService } from "./services/email.service" ; export class Container { private static instances = new Map ( ) ; static get < T

( constructor : new ( ... args : any [ ] ) => T ) : T { if ( ! this . instances . has ( constructor ) ) { // Create dependencies const deps = this . resolveDependencies ( constructor ) ; this . instances . set ( constructor , new constructor ( ... deps ) ) ; } return this . instances . get ( constructor ) ; } private static resolveDependencies ( constructor : any ) : any [ ] { // Resolve constructor dependencies return [ ] ; } } // Usage const userService = Container . get ( UserService ) ; Testing Services // user.service.test.ts describe ( "UserService" , ( ) => { let service : UserService ; let mockRepository : jest . Mocked < UserRepository

; let mockEmailService : jest . Mocked < EmailService

; beforeEach ( ( ) => { mockRepository = { create : jest . fn ( ) , findByEmail : jest . fn ( ) , } as any ; mockEmailService = { sendWelcome : jest . fn ( ) , } as any ; service = new UserService ( mockRepository , mockEmailService ) ; } ) ; it ( "creates user successfully" , async ( ) => { mockRepository . findByEmail . mockResolvedValue ( null ) ; mockRepository . create . mockResolvedValue ( { id : "1" , email : "test@example.com" , } ) ; const user = await service . createUser ( { email : "test@example.com" , password : "password123" , name : "Test User" , } ) ; expect ( user . id ) . toBe ( "1" ) ; expect ( mockEmailService . sendWelcome ) . toHaveBeenCalled ( ) ; } ) ; it ( "throws error if email exists" , async ( ) => { mockRepository . findByEmail . mockResolvedValue ( { id : "1" } as User ) ; await expect ( service . createUser ( { email : "existing@example.com" , password : "pass" , name : "Test" , } ) ) . rejects . toThrow ( ConflictError ) ; } ) ; } ) ; Folder Structure src/ ├── routes/ │ └── users.routes.ts ├── controllers/ │ └── user.controller.ts ├── services/ │ ├── user.service.ts │ ├── email.service.ts │ └── payment.service.ts ├── repositories/ │ └── user.repository.ts ├── models/ │ └── user.model.ts ├── types/ │ └── user.types.ts └── middleware/ └── validate.ts Migration Strategy

Phase 1: Create Service Layer (Week 1-2)

[ ] Create service classes

[ ] Move business logic to services

[ ] Keep controllers thin

[ ] No breaking changes

Phase 2: Add Tests (Week 3-4)

[ ] Write service unit tests

[ ] Mock dependencies

[ ] Achieve 80%+ coverage

Phase 3: Extract Repositories (Week 5-6)

[ ] Create repository layer

[ ] Move DB queries from services

[ ] Services depend on repositories

Phase 4: Dependency Injection (Week 7-8)

[ ] Set up DI container

[ ] Remove manual instantiation

[ ] Wire up dependencies

Benefits

Testability

Services testable without HTTP

Reusability

Logic reused across endpoints

Separation

Clear boundaries between layers

Maintainability

Easier to locate and modify logic Output Checklist Service classes created Business logic extracted from controllers Repository layer for data access Dependency injection setup Unit tests for services Folder structure reorganized Migration plan documented Team trained on new patterns