What is DIP?
Dependency Inversion Principle is one of the SOLID Principle.
It states that High Level Module shouldn't depend on low level modules, Both should depend on abstraction.
Means, the code that handles business-logic shouldn't depend directly on the implementation details. Instead they both should depend on interfaces/abstract Class.
Example
Suppose we have to 2 Modules,Car Module and Engine Module and Car Module uses Engine Module. Now if we are using DIP then we can swap Diesal Engine to Petrol Engine. Otherwise I have to make changes in the Car Module also.
HOW
We can do this using either interface injection or abstract class injection.
Interfaces doesn't exist at runtime, so in NestJS we attach a token to the Service we want to inject in the service.
Using Interface Injection
interface IPlanService {
canReview(): boolean;
}
export PlanService implements IPlanService {
canReview():boolean{
return true;
}
}
// Review.module.ts
const PLAN_SERVICE = Symbol('PLAN_SERVICE');
@Module({
providers: [
{
provide:PLAN_SERVICE
useClass:PlanService,
}
]
)
export class ReviewModule {}
// Now we can inject the `PlanService` in the `ReviewService` using `Inject` decorator.
@Injectable()
export class ReviewService {
constructor(@Inject(PLAN_SERVICE) private planService: IPlanService) {}
}
Using Abstract Class Injection
abstract class PlanServiceContract{
abstract canReview():Promise<boolean>;
}
export class PlanService implements PlanServiceContract{
async canReview():Promise<boolean>{
return true;
}
}
// Review.module.ts
@Module({
providers: [
{
provide:PlanServiceContract, // class itself as token
useClass:PlanService,
}
],
exports:[
PlanServiceContract,
]
)
export class ReviewModule {}
// Use it like this
@Injectable()
export class ReviewService {
constructor( private planService: PlanServiceContract) {}
}
We don't have to create a token if we are using abstract Class.
WHEN
You can use it everywhere, but it will be overkill and slows the development time.
When to use it :
- For Shared Providers
- Integration - External API's (Stripe, Github, etc.)
- For Repositories , to mock DB or replace DB
- Core Features that can scale in future / Business Logic.
The benefits of doing this is that it give us capability to mock things during test and change the behaviour without making changes in other modules. Its best to keep your Modules DeCoupled.
TIPS
- Create a Single Abstract File at the module lvl, that contains all the abstract classes.
- Use Base Interface / Abstract Class.
SOCIAL SHARE CARD GENERATOR