feat(scene): added wizard scene support

lib/decorators/core/index.ts

@@ -1,3 +1,4 @@
 export * from './update.decorator';
 export * from './scene.decorator';
+export * from './wizard.decorator';
 export * from './inject-bot.decorator';

lib/decorators/core/scene.decorator.ts

@@ -1,8 +1,14 @@
 import { SetMetadata } from '@nestjs/common';
+import { SceneOptions } from 'telegraf/typings/scenes/base';
+import { SceneMetadata } from '../../interfaces';
 import { SCENE_METADATA } from '../../telegraf.constants';
 
-/**
- * TODO
- */
-export const Scene = (id: string): ClassDecorator =>
-  SetMetadata(SCENE_METADATA, id);
+export const Scene = (
+  sceneId: string,
+  options?: SceneOptions<any>,
+): ClassDecorator =>
+  SetMetadata<string, SceneMetadata>(SCENE_METADATA, {
+    sceneId,
+    type: 'base',
+    options,
+  });

lib/decorators/core/wizard.decorator.ts

@@ -0,0 +1,14 @@
+import { SetMetadata } from '@nestjs/common';
+import { SceneOptions } from 'telegraf/typings/scenes/base';
+import { SceneMetadata } from '../../interfaces';
+import { SCENE_METADATA } from '../../telegraf.constants';
+
+export const Wizard = (
+  sceneId: string,
+  options?: SceneOptions<any>,
+): ClassDecorator =>
+  SetMetadata<string, SceneMetadata>(SCENE_METADATA, {
+    sceneId,
+    type: 'wizard',
+    options,
+  });

lib/decorators/scene/index.ts

@@ -1,2 +1,3 @@
 export * from './scene-enter.decorator';
 export * from './scene-leave.decorator';
+export * from './wizard-step.decorator';

lib/decorators/scene/wizard-step.decorator.ts

@@ -0,0 +1,6 @@
+import { SetMetadata } from '@nestjs/common';
+import { WizardStepMetadata } from '../../interfaces';
+import { WIZARD_STEP_METADATA } from '../../telegraf.constants';
+
+export const WizardStep = (step: number) =>
+  SetMetadata<string, WizardStepMetadata>(WIZARD_STEP_METADATA, { step });

lib/interfaces/index.ts

@@ -1,2 +1,4 @@
 export * from './telegraf-options.interface';
 export * from './listener-metadata.interface';
+export * from './scene-metadata.interface';
+export * from './telegraf-exception-filter.interface';

lib/interfaces/scene-metadata.interface.ts

@@ -0,0 +1,11 @@
+import { SceneOptions } from 'telegraf/typings/scenes/base';
+
+export interface SceneMetadata {
+  sceneId: string;
+  type: 'base' | 'wizard';
+  options?: SceneOptions<any>;
+}
+
+export interface WizardStepMetadata {
+  step: number;
+}

lib/services/listeners-explorer.service.ts

@@ -17,7 +17,7 @@ import {
 import { BaseExplorerService } from './base-explorer.service';
 import { TelegrafParamsFactory } from '../factories/telegraf-params-factory';
 import { TelegrafContextType } from '../execution-context';
-import { TelegrafModuleOptions } from '../interfaces';
+import { ListenerMetadata, TelegrafModuleOptions } from '../interfaces';
 
 @Injectable()
 export class ListenersExplorerService
@@ -75,13 +75,20 @@ export class ListenersExplorerService
       this.filterScenes(wrapper),
     );
     scenes.forEach((wrapper) => {
-      const sceneId = this.metadataAccessor.getSceneMetadata(
+      const { sceneId, type, options } = this.metadataAccessor.getSceneMetadata(
         wrapper.instance.constructor,
       );
-      const scene = new Scenes.BaseScene<any>(sceneId);
+      const scene =
+        type === 'base'
+          ? new Scenes.BaseScene<any>(sceneId, options || ({} as any))
+          : new Scenes.WizardScene<any>(sceneId, options || ({} as any));
       this.stage.register(scene);
 
-      this.registerListeners(scene, wrapper);
+      if (type === 'base') {
+        this.registerListeners(scene, wrapper);
+      } else {
+        this.registerWizardListeners(scene as Scenes.WizardScene<any>, wrapper);
+      }
     });
   }
 
@@ -116,14 +123,71 @@ export class ListenersExplorerService
     );
   }
 
+  private registerWizardListeners(
+    wizard: Scenes.WizardScene<any>,
+    wrapper: InstanceWrapper<unknown>,
+  ): void {
+    const { instance } = wrapper;
+    const prototype = Object.getPrototypeOf(instance);
+
+    type WizardMetadata = { step: number; methodName: string };
+    const wizardSteps: WizardMetadata[] = [];
+    const basicListeners = [];
+
+    this.metadataScanner.scanFromPrototype(
+      instance,
+      prototype,
+      (methodName) => {
+        const methodRef = prototype[methodName];
+        const metadata = this.metadataAccessor.getWizardStepMetadata(methodRef);
+        if (!metadata) {
+          basicListeners.push(methodName);
+          return undefined;
+        }
+        wizardSteps.push({ step: metadata.step, methodName });
+      },
+    );
+
+    for (const methodName of basicListeners) {
+      this.registerIfListener(wizard, instance, prototype, methodName);
+    }
+
+    const group = wizardSteps
+      .sort((a, b) => a.step - b.step)
+      .reduce<{ [key: number]: WizardMetadata[] }>(
+        (prev, cur) => ({
+          ...prev,
+          [cur.step]: [...(prev[cur.step] || []), cur],
+        }),
+        {},
+      );
+
+    const steps = Object.values(group).map((stepsMetadata) => {
+      const composer = new Composer();
+      stepsMetadata.forEach((stepMethod) => {
+        this.registerIfListener(
+          composer,
+          instance,
+          prototype,
+          stepMethod.methodName,
+          [{ method: 'use', args: [] }],
+        );
+      });
+      return composer.middleware();
+    });
+
+    wizard.steps = steps;
+  }
+
   private registerIfListener(
     composer: Composer<any>,
     instance: any,
     prototype: any,
     methodName: string,
+    defaultMetadata?: ListenerMetadata[],
   ): void {
     const methodRef = prototype[methodName];
-    const metadata = this.metadataAccessor.getListenerMetadata(methodRef);
+    const metadata = this.metadataAccessor.getListenerMetadata(methodRef) || defaultMetadata;
     if (!metadata || metadata.length < 1) {
       return undefined;
     }

lib/services/metadata-accessor.service.ts

@@ -4,8 +4,13 @@ import {
   SCENE_METADATA,
   LISTENERS_METADATA,
   UPDATE_METADATA,
+  WIZARD_STEP_METADATA,
 } from '../telegraf.constants';
-import { ListenerMetadata } from '../interfaces';
+import {
+  ListenerMetadata,
+  SceneMetadata,
+  WizardStepMetadata,
+} from '../interfaces';
 
 @Injectable()
 export class MetadataAccessorService {
@@ -25,7 +30,11 @@ export class MetadataAccessorService {
     return this.reflector.get(LISTENERS_METADATA, target);
   }
 
-  getSceneMetadata(target: Function): string | undefined {
+  getSceneMetadata(target: Function): SceneMetadata | undefined {
     return this.reflector.get(SCENE_METADATA, target);
   }
+
+  getWizardStepMetadata(target: Function): WizardStepMetadata | undefined {
+    return this.reflector.get(WIZARD_STEP_METADATA, target);
+  }
 }

lib/telegraf.constants.ts

@@ -7,6 +7,7 @@ export const DEFAULT_BOT_NAME = 'DEFAULT_BOT_NAME';
 export const UPDATE_METADATA = 'UPDATE_METADATA';
 export const SCENE_METADATA = 'SCENE_METADATA';
 export const LISTENERS_METADATA = 'LISTENERS_METADATA';
+export const WIZARD_STEP_METADATA = 'WIZARD_STEP_METADATA';
 
 export const PARAM_ARGS_METADATA = ROUTE_ARGS_METADATA;