feat(): accessing IoC container

Author: egocentryk

src/app.module.ts

@@ -3,13 +3,17 @@ import { AppController } from './app.controller'
 import { AppService } from './app.service'
 import { CoffeesModule } from './coffees/coffees.module'
 import { DevtoolsModule } from '@nestjs/devtools-integration'
+import { SchedulerModule } from './scheduler/scheduler.module';
+import { CronModule } from './cron/cron.module';
 
 @Module({
   imports: [
     CoffeesModule,
     DevtoolsModule.register({
       http: process.env.NODE_ENV !== 'production',
     }),
+    SchedulerModule,
+    CronModule,
   ],
   controllers: [AppController],
   providers: [AppService],

src/cron/cron.module.ts

@@ -0,0 +1,7 @@
+import { Module } from '@nestjs/common';
+import { CronService } from './cron.service';
+
+@Module({
+  providers: [CronService]
+})
+export class CronModule {}

src/cron/cron.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { CronService } from './cron.service';
+
+describe('CronService', () => {
+  let service: CronService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [CronService],
+    }).compile();
+
+    service = module.get<CronService>(CronService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/cron/cron.service.ts

@@ -0,0 +1,10 @@
+import { Interval } from 'src/scheduler/decorators/interval.decorator'
+import { IntervalHost } from '../scheduler/decorators/interval-host.decorator'
+
+@IntervalHost
+export class CronService {
+  @Interval(10000)
+  everySecond() {
+    console.log('This will be logged every 10 seconds!')
+  }
+}

src/scheduler/decorators/interval-host.decorator.ts

@@ -0,0 +1,4 @@
+import { SetMetadata } from '@nestjs/common'
+
+export const INTERVAL_HOST_KEY = 'INTERVAL_HOST_KEY'
+export const IntervalHost: ClassDecorator = SetMetadata(INTERVAL_HOST_KEY, true)

src/scheduler/decorators/interval.decorator.ts

@@ -0,0 +1,4 @@
+import { SetMetadata } from '@nestjs/common'
+
+export const INTERVAL_KEY = 'INTERVAL_KEY'
+export const Interval = (ms: number) => SetMetadata(INTERVAL_KEY, ms)

src/scheduler/interval.scheduler.spec.ts

@@ -0,0 +1,14 @@
+import { DiscoveryService, Reflector, MetadataScanner } from '@nestjs/core'
+import { IntervalScheduler } from './interval.scheduler'
+
+describe('IntervalScheduler', () => {
+  it('should be defined', () => {
+    const discoveryService = {} as DiscoveryService
+    const reflector = {} as Reflector
+    const metadataScanner = {} as MetadataScanner
+
+    expect(
+      new IntervalScheduler(discoveryService, reflector, metadataScanner),
+    ).toBeDefined()
+  })
+})

src/scheduler/interval.scheduler.ts

@@ -0,0 +1,57 @@
+import {
+  Injectable,
+  OnApplicationBootstrap,
+  OnApplicationShutdown,
+} from '@nestjs/common'
+import { DiscoveryService, MetadataScanner, Reflector } from '@nestjs/core'
+import { INTERVAL_HOST_KEY } from './decorators/interval-host.decorator'
+import { INTERVAL_KEY } from './decorators/interval.decorator'
+
+@Injectable()
+export class IntervalScheduler
+  implements OnApplicationBootstrap, OnApplicationShutdown
+{
+  private readonly intervals: NodeJS.Timeout[] = []
+
+  constructor(
+    private readonly discoveryService: DiscoveryService,
+    private readonly reflector: Reflector,
+    private readonly metadataScanner: MetadataScanner,
+  ) {}
+
+  onApplicationBootstrap() {
+    const providers = this.discoveryService.getProviders()
+    providers.forEach((wrapper) => {
+      const { instance } = wrapper
+
+      const prototype = instance && Object.getPrototypeOf(instance)
+      if (!instance || !prototype) {
+        return
+      }
+
+      const isIntervalHost =
+        this.reflector.get(INTERVAL_HOST_KEY, instance.constructor) ?? false
+
+      if (!isIntervalHost) {
+        return
+      }
+
+      const methodKeys = this.metadataScanner.getAllMethodNames(prototype)
+
+      methodKeys.forEach((methodKey) => {
+        const interval = this.reflector.get(INTERVAL_KEY, instance[methodKey])
+
+        if (interval === undefined) {
+          return
+        }
+
+        const intervalRef = setInterval(() => instance[methodKey](), interval)
+        this.intervals.push(intervalRef)
+      })
+    })
+  }
+
+  onApplicationShutdown(signal?: string) {
+    this.intervals.forEach((intervalRef) => clearInterval(intervalRef))
+  }
+}

src/scheduler/scheduler.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common'
+import { DiscoveryModule } from '@nestjs/core'
+import { IntervalScheduler } from './interval.scheduler'
+
+@Module({
+  imports: [DiscoveryModule],
+  providers: [IntervalScheduler],
+})
+export class SchedulerModule {}