fix(): use bot token in di

lib/decorators/core/inject-bot.decorator.ts

@@ -1,5 +1,5 @@
 import { Inject } from '@nestjs/common';
 import { getBotToken } from '../../utils';
 
-export const InjectBot = (name?: string): ParameterDecorator =>
+export const InjectBot = (botName?: string): ParameterDecorator =>
-  Inject(getBotToken(name));
+  Inject(getBotToken(botName));

lib/interfaces/telegraf-options.interface.ts

@@ -8,7 +8,7 @@ import {
 
 export interface TelegrafModuleOptions<C extends Context = Context> {
   token: string;
-  name?: string;
+  botName?: string;
   options?: TelegrafOptions;
   launchOptions?: {
     polling?: LaunchPollingOptions;
@@ -24,7 +24,7 @@ export interface TelegrafOptionsFactory {
 
 export interface TelegrafModuleAsyncOptions
   extends Pick<ModuleMetadata, 'imports'> {
-  name?: string;
+  botName?: string;
   useExisting?: Type<TelegrafOptionsFactory>;
   useClass?: Type<TelegrafOptionsFactory>;
   useFactory?: (

lib/services/listeners-explorer.service.ts

@@ -6,10 +6,12 @@ import { Module } from '@nestjs/core/injector/module';
 import { BaseScene, Composer, Stage, Telegraf } from 'telegraf';
 
 import { MetadataAccessorService } from './metadata-accessor.service';
-import { TELEGRAF_MODULE_OPTIONS } from '../telegraf.constants';
+import {
+  TELEGRAF_BOT_NAME,
+  TELEGRAF_MODULE_OPTIONS,
+} from '../telegraf.constants';
 import { TelegrafModuleOptions } from '../interfaces';
 import { BaseExplorerService } from './base-explorer.service';
-import { getBotToken } from '../utils';
 
 @Injectable()
 export class ListenersExplorerService
@@ -19,6 +21,8 @@ export class ListenersExplorerService
   private bot: Telegraf<any>;
 
   constructor(
+    @Inject(TELEGRAF_BOT_NAME)
+    private readonly botName: string,
     @Inject(TELEGRAF_MODULE_OPTIONS)
     private readonly telegrafOptions: TelegrafModuleOptions,
     private readonly moduleRef: ModuleRef,
@@ -31,8 +35,9 @@ export class ListenersExplorerService
   }
 
   onModuleInit(): void {
-    const botToken = getBotToken(this.telegrafOptions.name);
+    this.bot = this.moduleRef.get<Telegraf<never>>(this.botName, {
-    this.bot = this.moduleRef.get<Telegraf<never>>(botToken);
+      strict: false,
+    });
     this.bot.use(this.stage.middleware());
 
     this.explore();

lib/telegraf-core.module.ts

@@ -1,21 +1,24 @@
 import { DiscoveryModule, ModuleRef } from '@nestjs/core';
 import {
-  Module,
   DynamicModule,
-  Provider,
-  Type,
   Global,
   Inject,
+  Module,
   OnApplicationShutdown,
+  Provider,
+  Type,
 } from '@nestjs/common';
 import {
-  TelegrafModuleOptions,
   TelegrafModuleAsyncOptions,
+  TelegrafModuleOptions,
   TelegrafOptionsFactory,
 } from './interfaces';
-import { TELEGRAF_MODULE_OPTIONS } from './telegraf.constants';
+import {
-import { MetadataAccessorService, ListenersExplorerService } from './services';
+  TELEGRAF_BOT_NAME,
-import { getBotToken, createBotFactory } from './utils';
+  TELEGRAF_MODULE_OPTIONS,
+} from './telegraf.constants';
+import { ListenersExplorerService, MetadataAccessorService } from './services';
+import { createBotFactory, getBotToken } from './utils';
 
 @Global()
 @Module({
@@ -24,14 +27,21 @@ import { getBotToken, createBotFactory } from './utils';
 })
 export class TelegrafCoreModule implements OnApplicationShutdown {
   constructor(
-    @Inject(TELEGRAF_MODULE_OPTIONS)
+    @Inject(TELEGRAF_BOT_NAME)
-    private readonly options: TelegrafModuleOptions,
+    private readonly botName: string,
     private readonly moduleRef: ModuleRef,
   ) {}
 
   public static forRoot(options: TelegrafModuleOptions): DynamicModule {
+    const telegrafBotName = getBotToken(options.botName);
+
+    const telegrafBotNameProvider = {
+      provide: TELEGRAF_BOT_NAME,
+      useValue: telegrafBotName,
+    };
+
     const telegrafBotProvider: Provider = {
-      provide: getBotToken(options.name),
+      provide: telegrafBotName,
       useFactory: async () => await createBotFactory(options),
     };
 
@@ -42,6 +52,7 @@ export class TelegrafCoreModule implements OnApplicationShutdown {
           provide: TELEGRAF_MODULE_OPTIONS,
           useValue: options,
         },
+        telegrafBotNameProvider,
         telegrafBotProvider,
       ],
       exports: [telegrafBotProvider],
@@ -51,7 +62,12 @@ export class TelegrafCoreModule implements OnApplicationShutdown {
   public static forRootAsync(
     options: TelegrafModuleAsyncOptions,
   ): DynamicModule {
-    const telegrafBotName = getBotToken(options.name);
+    const telegrafBotName = getBotToken(options.botName);
+
+    const telegrafBotNameProvider = {
+      provide: TELEGRAF_BOT_NAME,
+      useValue: telegrafBotName,
+    };
 
     const telegrafBotProvider: Provider = {
       provide: telegrafBotName,
@@ -64,14 +80,17 @@ export class TelegrafCoreModule implements OnApplicationShutdown {
     return {
       module: TelegrafCoreModule,
       imports: options.imports,
-      providers: [...asyncProviders, telegrafBotProvider],
+      providers: [
-      exports: [telegrafBotProvider],
+        ...asyncProviders,
+        telegrafBotNameProvider,
+        telegrafBotProvider,
+      ],
+      exports: [telegrafBotNameProvider, telegrafBotProvider],
     };
   }
 
   async onApplicationShutdown(): Promise<void> {
-    const botName = getBotToken(this.options.name);
+    const bot = this.moduleRef.get<any>(this.botName);
-    const bot = this.moduleRef.get<any>(botName);
     bot && (await bot.stop());
   }
 

lib/telegraf.constants.ts

@@ -1,4 +1,5 @@
 export const TELEGRAF_MODULE_OPTIONS = 'TELEGRAF_MODULE_OPTIONS';
+export const TELEGRAF_BOT_NAME = 'TELEGRAF_BOT_NAME';
 export const DEFAULT_BOT_NAME = 'DEFAULT_BOT_NAME';
 
 export const UPDATE_METADATA = 'UPDATE_METADATA';