Dynamic Service Invokation - IOC - nestjs

Question

how can I invoke a service's method dynamically (looked up from a hash-map) from a controller:
registration.service.ts
import { Injectable } from '#nestjs/common';
import { CacheService } from '../cache/cache.service';
import { LoggerService } from '../../config/logger/logger.service';
#Injectable()
export class RegistrationService {
constructor(private readonly cache: CacheService,
private readonly logger: LoggerService) {
}
async process() {
this.logger.info(`RegistrationService - testThis - hit!`);
}
}
app.controller.ts
import { Controller, Get, Res } from '#nestjs/common';
import { RegistrationService } from './modules/campaignOne/registration.service';
const SCREENS = {
'start': 'this.registration.process'
};
#Controller()
export class AppController {
constructor(private readonly registration: RegistrationService) {}
#Get('test')
async test(#Res() res: any): any {
await eval(SCREENS['start'])();
return Promise.resolve('ok');
}
}
When await eval(SCREENS['start'])(); is executed, the method is called but an error is thrown at this.logger.. because it can't resolve the logger.
The idea is to have multiple providers and logic in the controller will determine which provider to invoke dynamically.
I know the problem and solution lies in dependency injection and IOC - but I don't know how to resolve.
Help please?

Answer 1

I would use the factory approach with this.
First create an interface to define the shape of the "dynamic" service you want
//IService.ts
export interface IService {
invoke(): Promise<void>;
}
Now all of your services that you want dynamic can implement this interface.
NOTE: This service is not using the nest #Injectable annotation because this class is not what will be actually injected as you'll see below.
//registration.service.ts
import { CacheService } from '../cache/cache.service';
import { LoggerService } from '../../config/logger/logger.service';
export class RegistrationService implements IService {
private readonly cache: CacheService;
private readonly logger: LoggerService;
constructor(cache: CacheService, logger: LoggerService) {
this.cache = cache;
this.logger = logger;
}
async invoke() : Promise<void> {
this.logger.info(`RegistrationService - testThis - hit!`);
return Promise.resolve();
}
}
Now create your factory class that WILL be the thing that gets injected by the IOC
//ScreenFactory.ts
import { Injectable } from '#nestjs/common';
import { RegistrationService } from './modules/campaignOne/registration.service';
#Injectable()
export class ScreenFactory {
private readonly cache: CacheService;
private readonly logger: LoggerService;
constructor(cache: CacheService, logger: LoggerService) {
this.cache = cache;
this.logger = logger;
}
public getService(screenName: string) : IService {
switch(screenName) {
case 'start': return new RegistrationService(this.cache, this.logger);
default: throw new Error('No service defined for the given screen');
}
}
}
Now in your module, inject the factory instead
import { Controller, Get, Res } from '#nestjs/common';
import { ScreenFactory } from './modules/ScreenFactory';
#Controller()
export class AppController {
constructor(private readonly screenFactory: ScreenFactory) {}
#Get('test')
async test(#Res() res: any): any {
//await eval(SCREENS['start'])();
const service: IService = this.screenFactory.getService('start');
await service.invoke();
return Promise.resolve('ok');
}
}
That's a lot of pseudo code but this is how I generally handle the "I need a different thing per request" type of scenario.