jp.ms.common.modules 1.0.41 → 1.0.43

package/src/modules/confirmation-message-manager/confirmation-message-manager.interfaces.ts

@@ -0,0 +1,20 @@
+import { ModuleMetadata } from '@nestjs/common';
+import { Type } from '@nestjs/common/interfaces/type.interface';
+import { DynamicModule } from '@nestjs/common/interfaces/modules/dynamic-module.interface';
+import { ForwardReference } from '@nestjs/common/interfaces/modules/forward-reference.interface';
+
+export interface ConfirmationMessageManagerOptions extends Pick<
+  ModuleMetadata,
+  'imports'
+> {
+  imports?: Array<
+    Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
+  >;
+  inject?: any[];
+  useFactory?: (...args: any[]) => ConfirmationMessageManagerFactoryOptions;
+}
+
+export interface ConfirmationMessageManagerFactoryOptions {
+  confirmationMessageManagerTime: string;
+  confirmationMessageManagerAttemptCount: number;
+}

package/src/modules/confirmation-message-manager/confirmation-message-manager.module.ts

@@ -0,0 +1,77 @@
+import {
+  DynamicModule,
+  Global,
+  Inject,
+  Module,
+  Provider,
+} from '@nestjs/common';
+import schedule, { Job } from 'node-schedule';
+import { BaseWsEvent } from 'jp.ms.common.engine';
+
+import { JpLoggerService } from '../logger';
+import { EventsBusPlayerWsMessageSubscribeService } from '../event-bus';
+
+import { ConfirmationMessageManagerService } from './confirmation-message-manager.service';
+import {
+  ConfirmationMessageManagerFactoryOptions,
+  ConfirmationMessageManagerOptions,
+} from './confirmation-message-manager.interfaces';
+import { CONFIRMATION_MESSAGE_MANAGER_OPTIONS } from './confirmation-message-manager.constants';
+
+@Global()
+@Module({
+  providers: [ConfirmationMessageManagerService],
+  exports: [ConfirmationMessageManagerService],
+})
+export class ConfirmationMessageManagerModule {
+  private confirmationMessageManagerJob: Job;
+
+  constructor(
+    private readonly confirmationMessageManagerService: ConfirmationMessageManagerService,
+    private readonly eventsBusPlayerWsMessageSubscribeService: EventsBusPlayerWsMessageSubscribeService,
+    @Inject(CONFIRMATION_MESSAGE_MANAGER_OPTIONS)
+    private readonly options: ConfirmationMessageManagerFactoryOptions,
+    @Inject() private readonly logger: JpLoggerService,
+  ) {}
+
+  static forRootAsync(
+    options: ConfirmationMessageManagerOptions,
+  ): DynamicModule {
+    return {
+      module: ConfirmationMessageManagerModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: CONFIRMATION_MESSAGE_MANAGER_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        } as Provider,
+      ],
+    };
+  }
+
+  onModuleInit() {
+    this.eventsBusPlayerWsMessageSubscribeService.subscribeOnSendMessage(
+      (wsEvent: BaseWsEvent) => {
+        this.confirmationMessageManagerService.addToQueue(wsEvent);
+      },
+    );
+
+    this.eventsBusPlayerWsMessageSubscribeService.subscribeOnGotMessageFromClient(
+      (wsEvent: BaseWsEvent) => {
+        this.confirmationMessageManagerService.removeFromQueue(wsEvent.key);
+      },
+    );
+
+    const confirmationMessageManagerTime =
+      this.options.confirmationMessageManagerTime;
+
+    if (confirmationMessageManagerTime) {
+      this.logger.log(`${ConfirmationMessageManagerModule.name}: scheduleJob`);
+      this.confirmationMessageManagerJob = schedule.scheduleJob(
+        confirmationMessageManagerTime,
+        () => this.confirmationMessageManagerService.process(),
+      );
+    }
+  }
+}

package/src/modules/confirmation-message-manager/confirmation-message-manager.service.ts

@@ -0,0 +1,91 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { BaseWsEvent } from 'jp.ms.common.engine';
+
+import { PlayersManagerService } from '../players-manager';
+import { JpLoggerService } from '../logger';
+
+import { CONFIRMATION_MESSAGE_MANAGER_OPTIONS } from './confirmation-message-manager.constants';
+import { ConfirmationMessageManagerFactoryOptions } from './confirmation-message-manager.interfaces';
+
+interface IGameMessageConfirmationManagerMessage {
+  event: BaseWsEvent;
+  repeatCount: number;
+}
+
+@Injectable()
+export class ConfirmationMessageManagerService {
+  private queue: Map<string, IGameMessageConfirmationManagerMessage>;
+  private jobId: NodeJS.Timeout | null = null;
+
+  constructor(
+    private readonly playersManagerService: PlayersManagerService,
+    @Inject(CONFIRMATION_MESSAGE_MANAGER_OPTIONS)
+    private readonly options: ConfirmationMessageManagerFactoryOptions,
+    @Inject() private readonly logger: JpLoggerService,
+  ) {
+    this.queue = new Map<string, IGameMessageConfirmationManagerMessage>();
+  }
+
+  getByKey(key: string) {
+    this.queue.get(key);
+  }
+
+  addToQueue(message: BaseWsEvent): void {
+    this.logger.log(
+      `${ConfirmationMessageManagerService.name}: add to queue ws message key: ${message.key}, type: ${message.type}`,
+    );
+
+    const foundMessage = this.queue.get(message.key);
+
+    if (foundMessage) {
+      foundMessage.repeatCount += 1;
+    } else {
+      this.queue.set(message.key, {
+        event: message,
+        repeatCount: 0,
+      });
+    }
+  }
+
+  removeFromQueue(key: string): void {
+    this.logger.log(
+      `${ConfirmationMessageManagerService.name}: remove from queue ws message key: ${key}`,
+    );
+
+    this.queue.delete(key);
+  }
+
+  process() {
+    this.clearQueue();
+    this.repeatSendingMessages();
+  }
+
+  private isExpired(message: IGameMessageConfirmationManagerMessage): boolean {
+    return (
+      message.repeatCount >= this.options.confirmationMessageManagerAttemptCount
+    );
+  }
+
+  private clearQueue(): void {
+    for (const [key, message] of this.queue) {
+      if (this.isExpired(message)) {
+        this.logger.log(
+          `${ConfirmationMessageManagerService.name}: clear expired ws message key: ${message.event.key}, type: ${message.event.type}`,
+        );
+        this.queue.delete(key);
+      }
+    }
+  }
+
+  private repeatSendingMessages(): void {
+    for (const [, message] of this.queue) {
+      const foundPlayer = this.playersManagerService.getPlayerById(
+        message.event.playerId,
+      );
+      this.logger.log(
+        `${ConfirmationMessageManagerService.name}: repeat ws message key: ${message.event.key}, type: ${message.event.type}, repeatCount: ${message.repeatCount}`,
+      );
+      foundPlayer?.sendMessage(message.event);
+    }
+  }
+}

package/src/modules/event-bus/events-bus.app.subscribe.service.ts

@@ -1,20 +1,20 @@
-import { Injectable } from '@nestjs/common';
-import { BaseAppEvent } from 'jp.ms.common.engine';
-import { Subject } from 'rxjs';
-
-@Injectable()
-export class EventsBusAppSubscribeService {
-  private readonly appEventSubject: Subject<BaseAppEvent>;
-
-  constructor() {
-    this.appEventSubject = new Subject<BaseAppEvent>();
-  }
-
-  pushNewEvent(event: BaseAppEvent) {
-    this.appEventSubject.next(event);
-  }
-
-  subscribe(onHandleAppEvent: (event: BaseAppEvent) => void) {
-    this.appEventSubject.subscribe(onHandleAppEvent);
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { BaseAppEvent } from 'jp.ms.common.engine';
+import { Subject } from 'rxjs';
+
+@Injectable()
+export class EventsBusAppSubscribeService {
+  private readonly appEventSubject: Subject<BaseAppEvent>;
+
+  constructor() {
+    this.appEventSubject = new Subject<BaseAppEvent>();
+  }
+
+  pushNewEvent(event: BaseAppEvent) {
+    this.appEventSubject.next(event);
+  }
+
+  subscribe(onHandleAppEvent: (event: BaseAppEvent) => void) {
+    this.appEventSubject.subscribe(onHandleAppEvent);
+  }
+}

package/src/modules/event-bus/events-bus.main-tables.subscribe.service.ts

@@ -1,34 +1,34 @@
-import { Injectable } from '@nestjs/common';
-import { GamePlayer, RoomUpdateStateEvent } from 'jp.ms.common.engine';
-import { Subject } from 'rxjs';
-
-@Injectable()
-export class EventsBusMainTablesSubscribeService {
-  private readonly roomStatesSubject: Subject<RoomUpdateStateEvent>;
-  private readonly tablesSubscribers: Map<string, GamePlayer>;
-
-  constructor() {
-    this.roomStatesSubject = new Subject<RoomUpdateStateEvent>();
-    this.tablesSubscribers = new Map();
-  }
-
-  getTablesSubscribers() {
-    return Array.from(this.tablesSubscribers.values());
-  }
-
-  addTablesSubscriber(player: GamePlayer) {
-    this.tablesSubscribers.set(player.id, player);
-  }
-
-  removeTablesSubbcriber(player: GamePlayer) {
-    this.tablesSubscribers.delete(player.id);
-  }
-
-  pushNewRoomState(event: RoomUpdateStateEvent) {
-    this.roomStatesSubject.next(event);
-  }
-
-  subscribe(onHandleStatusRoomChange: (event: RoomUpdateStateEvent) => void) {
-    this.roomStatesSubject.subscribe(onHandleStatusRoomChange);
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { GamePlayer, RoomUpdateStateEvent } from 'jp.ms.common.engine';
+import { Subject } from 'rxjs';
+
+@Injectable()
+export class EventsBusMainTablesSubscribeService {
+  private readonly roomStatesSubject: Subject<RoomUpdateStateEvent>;
+  private readonly tablesSubscribers: Map<string, GamePlayer>;
+
+  constructor() {
+    this.roomStatesSubject = new Subject<RoomUpdateStateEvent>();
+    this.tablesSubscribers = new Map();
+  }
+
+  getTablesSubscribers() {
+    return Array.from(this.tablesSubscribers.values());
+  }
+
+  addTablesSubscriber(player: GamePlayer) {
+    this.tablesSubscribers.set(player.id, player);
+  }
+
+  removeTablesSubbcriber(player: GamePlayer) {
+    this.tablesSubscribers.delete(player.id);
+  }
+
+  pushNewRoomState(event: RoomUpdateStateEvent) {
+    this.roomStatesSubject.next(event);
+  }
+
+  subscribe(onHandleStatusRoomChange: (event: RoomUpdateStateEvent) => void) {
+    this.roomStatesSubject.subscribe(onHandleStatusRoomChange);
+  }
+}

package/src/modules/event-bus/events-bus.many-tables-tournament.subscribe.service.ts

@@ -1,6 +1,6 @@
-import { Injectable } from '@nestjs/common';
-
-import { EventsBusTournamentSubscribeService } from './events-bus.tournament.subscribe.service';
-
-@Injectable()
-export class EventsBusManyTablesTournamentSubscribeService extends EventsBusTournamentSubscribeService {}
+import { Injectable } from '@nestjs/common';
+
+import { EventsBusTournamentSubscribeService } from './events-bus.tournament.subscribe.service';
+
+@Injectable()
+export class EventsBusManyTablesTournamentSubscribeService extends EventsBusTournamentSubscribeService {}

package/src/modules/event-bus/events-bus.module.ts

@@ -1,23 +1,26 @@
-import { Global, Module } from '@nestjs/common';
-
-import { EventsBusMainTablesSubscribeService } from './events-bus.main-tables.subscribe.service';
-import { EventsBusOneTableTournamentSubscribeService } from './events-bus.one-table-tournament.subscribe.service';
-import { EventsBusManyTablesTournamentSubscribeService } from './events-bus.many-tables-tournament.subscribe.service';
-import { EventsBusAppSubscribeService } from './events-bus.app.subscribe.service';
-
-@Global()
-@Module({
-  providers: [
-    EventsBusMainTablesSubscribeService,
-    EventsBusOneTableTournamentSubscribeService,
-    EventsBusManyTablesTournamentSubscribeService,
-    EventsBusAppSubscribeService,
-  ],
-  exports: [
-    EventsBusMainTablesSubscribeService,
-    EventsBusOneTableTournamentSubscribeService,
-    EventsBusManyTablesTournamentSubscribeService,
-    EventsBusAppSubscribeService,
-  ],
-})
-export class EventsBusModule {}
+import { Global, Module } from '@nestjs/common';
+
+import { EventsBusMainTablesSubscribeService } from './events-bus.main-tables.subscribe.service';
+import { EventsBusOneTableTournamentSubscribeService } from './events-bus.one-table-tournament.subscribe.service';
+import { EventsBusManyTablesTournamentSubscribeService } from './events-bus.many-tables-tournament.subscribe.service';
+import { EventsBusAppSubscribeService } from './events-bus.app.subscribe.service';
+import { EventsBusPlayerWsMessageSubscribeService } from './events-bus.player-ws-message.subscribe.service';
+
+@Global()
+@Module({
+  providers: [
+    EventsBusMainTablesSubscribeService,
+    EventsBusOneTableTournamentSubscribeService,
+    EventsBusManyTablesTournamentSubscribeService,
+    EventsBusAppSubscribeService,
+    EventsBusPlayerWsMessageSubscribeService,
+  ],
+  exports: [
+    EventsBusMainTablesSubscribeService,
+    EventsBusOneTableTournamentSubscribeService,
+    EventsBusManyTablesTournamentSubscribeService,
+    EventsBusAppSubscribeService,
+    EventsBusPlayerWsMessageSubscribeService,
+  ],
+})
+export class EventsBusModule {}

package/src/modules/event-bus/events-bus.one-table-tournament.subscribe.service.ts

@@ -1,6 +1,6 @@
-import { Injectable } from '@nestjs/common';
-
-import { EventsBusTournamentSubscribeService } from './events-bus.tournament.subscribe.service';
-
-@Injectable()
-export class EventsBusOneTableTournamentSubscribeService extends EventsBusTournamentSubscribeService {}
+import { Injectable } from '@nestjs/common';
+
+import { EventsBusTournamentSubscribeService } from './events-bus.tournament.subscribe.service';
+
+@Injectable()
+export class EventsBusOneTableTournamentSubscribeService extends EventsBusTournamentSubscribeService {}

package/src/modules/event-bus/events-bus.player-ws-message.subscribe.service.ts

@@ -0,0 +1,30 @@
+import { BaseWsEvent } from 'jp.ms.common.engine';
+import { Subject } from 'rxjs';
+
+export class EventsBusPlayerWsMessageSubscribeService {
+  private readonly subjectSendMessage: Subject<BaseWsEvent>;
+  private readonly subjectGotMessage: Subject<BaseWsEvent>;
+
+  constructor() {
+    this.subjectSendMessage = new Subject<BaseWsEvent>();
+    this.subjectGotMessage = new Subject<BaseWsEvent>();
+  }
+
+  pushSendMessage(event: BaseWsEvent) {
+    this.subjectSendMessage.next(event);
+  }
+
+  pushGotMessage(event: BaseWsEvent) {
+    this.subjectGotMessage.next(event);
+  }
+
+  subscribeOnSendMessage(onHandleWsEvent: (event: BaseWsEvent) => void) {
+    this.subjectSendMessage.subscribe(onHandleWsEvent);
+  }
+
+  subscribeOnGotMessageFromClient(
+    onHandleWsEvent: (event: BaseWsEvent) => void,
+  ) {
+    this.subjectGotMessage.subscribe(onHandleWsEvent);
+  }
+}

package/src/modules/event-bus/events-bus.tournament.subscribe.service.ts

@@ -1,18 +1,18 @@
-import { RoomUpdateStateEvent } from 'jp.ms.common.engine';
-import { Subject } from 'rxjs';
-
-export abstract class EventsBusTournamentSubscribeService {
-  private readonly roomStatesSubject: Subject<RoomUpdateStateEvent>;
-
-  constructor() {
-    this.roomStatesSubject = new Subject<RoomUpdateStateEvent>();
-  }
-
-  pushNewRoomState(event: RoomUpdateStateEvent) {
-    this.roomStatesSubject.next(event);
-  }
-
-  subscribe(onHandleStatusRoomChange: (event: RoomUpdateStateEvent) => void) {
-    this.roomStatesSubject.subscribe(onHandleStatusRoomChange);
-  }
-}
+import { RoomUpdateStateEvent } from 'jp.ms.common.engine';
+import { Subject } from 'rxjs';
+
+export abstract class EventsBusTournamentSubscribeService {
+  private readonly roomStatesSubject: Subject<RoomUpdateStateEvent>;
+
+  constructor() {
+    this.roomStatesSubject = new Subject<RoomUpdateStateEvent>();
+  }
+
+  pushNewRoomState(event: RoomUpdateStateEvent) {
+    this.roomStatesSubject.next(event);
+  }
+
+  subscribe(onHandleStatusRoomChange: (event: RoomUpdateStateEvent) => void) {
+    this.roomStatesSubject.subscribe(onHandleStatusRoomChange);
+  }
+}

package/src/modules/event-bus/index.ts

@@ -1,5 +1,6 @@
-export { EventsBusModule } from './events-bus.module';
-export { EventsBusMainTablesSubscribeService } from './events-bus.main-tables.subscribe.service';
-export { EventsBusOneTableTournamentSubscribeService } from './events-bus.one-table-tournament.subscribe.service';
-export { EventsBusManyTablesTournamentSubscribeService } from './events-bus.many-tables-tournament.subscribe.service';
-export { EventsBusAppSubscribeService } from './events-bus.app.subscribe.service';
+export { EventsBusModule } from './events-bus.module';
+export { EventsBusMainTablesSubscribeService } from './events-bus.main-tables.subscribe.service';
+export { EventsBusOneTableTournamentSubscribeService } from './events-bus.one-table-tournament.subscribe.service';
+export { EventsBusManyTablesTournamentSubscribeService } from './events-bus.many-tables-tournament.subscribe.service';
+export { EventsBusAppSubscribeService } from './events-bus.app.subscribe.service';
+export { EventsBusPlayerWsMessageSubscribeService } from './events-bus.player-ws-message.subscribe.service';

package/src/modules/events/events.constants.ts

@@ -1 +1 @@
-export const EVENTS_OPTIONS = Symbol('EVENTS_OPTIONS');
+export const EVENTS_OPTIONS = Symbol('EVENTS_OPTIONS');

package/src/modules/events/events.gateway.ts

@@ -1,70 +1,84 @@
-import {
-  WebSocketServer,
-  OnGatewayConnection,
-  OnGatewayDisconnect,
-  WebSocketGateway,
-} from '@nestjs/websockets';
-import { Server, Socket } from 'socket.io';
-import { UsersRepository } from 'jp.db.schemas';
-import { Inject } from '@nestjs/common';
-
-import { PlayersManagerService } from '../players-manager/players-manager.service';
-
-import { EVENTS_OPTIONS } from './events.constants';
-import { EventsFactoryOptions } from './events.interfaces';
-
-@WebSocketGateway({ cors: { origin: '*' } })
-export class EventsGateway
-  implements OnGatewayConnection<Socket>, OnGatewayDisconnect<Socket>
-{
-  @WebSocketServer()
-  server: Server;
-
-  constructor(
-    private readonly playersManager: PlayersManagerService,
-    private readonly usersRepository: UsersRepository,
-    @Inject(EVENTS_OPTIONS) private readonly options: EventsFactoryOptions,
-  ) {}
-
-  async handleConnection(client: Socket) {
-    const playerId = client.handshake.auth.token as string | undefined;
-
-    const player = this.playersManager.getPlayerById(playerId ?? '');
-    if (player) {
-      player.connections.addConnection(client);
-    } else {
-      const user = await this.usersRepository.findById(playerId ?? '');
-      if (user) {
-        const player = this.options.createPlayer({
-          id: user.userId,
-          fullName: user.fullName,
-          avatarUrl: user.avatarUrl,
-          balance: user.balance,
-          experience: user.experience,
-          level: user.level,
-          language: user.normalizedLang,
-        });
-        this.playersManager.addPlayer(player);
-        player.connections.addConnection(client);
-      }
-    }
-  }
-
-  handleDisconnect(client: Socket): void {
-    const playerId = client.handshake.auth.token as string | undefined;
-    const connectedPlayer = this.playersManager.getPlayerById(playerId ?? '');
-
-    if (connectedPlayer) {
-      connectedPlayer.disconnect();
-
-      if (
-        !connectedPlayer.isPlayer() &&
-        !connectedPlayer.isTableQueuer() &&
-        !connectedPlayer.isRoomQueuer() &&
-        !connectedPlayer.hasOpenConnection()
-      ) {
-        this.playersManager.removePlayer(playerId ?? '');
-      }
-    }
-  }
-}
+import {
+  WebSocketServer,
+  OnGatewayConnection,
+  OnGatewayDisconnect,
+  WebSocketGateway,
+} from '@nestjs/websockets';
+import { Server, Socket } from 'socket.io';
+import { UsersRepository } from 'jp.db.schemas';
+import { Inject } from '@nestjs/common';
+import { BaseWsEvent } from 'jp.ms.common.engine';
+
+import { PlayersManagerService } from '../players-manager/players-manager.service';
+import { EventsBusPlayerWsMessageSubscribeService } from '../event-bus';
+
+import { EVENTS_OPTIONS } from './events.constants';
+import { EventsFactoryOptions } from './events.interfaces';
+
+@WebSocketGateway({ cors: { origin: '*' } })
+export class EventsGateway
+  implements OnGatewayConnection<Socket>, OnGatewayDisconnect<Socket>
+{
+  @WebSocketServer()
+  server: Server;
+
+  constructor(
+    private readonly playersManager: PlayersManagerService,
+    private readonly usersRepository: UsersRepository,
+    private readonly eventsBusPlayerWsMessageSubscribeService: EventsBusPlayerWsMessageSubscribeService,
+    @Inject(EVENTS_OPTIONS) private readonly options: EventsFactoryOptions,
+  ) {}
+
+  async handleConnection(client: Socket) {
+    const playerId = client.handshake.auth.token as string | undefined;
+
+    const player = this.playersManager.getPlayerById(playerId ?? '');
+    if (player) {
+      player.connections.addConnection(client);
+    } else {
+      const user = await this.usersRepository.findById(playerId ?? '');
+      if (user) {
+        const player = this.options.createPlayer({
+          id: user.userId,
+          fullName: user.publicFullName,
+          avatarUrl: user.publicAvatarUrl,
+          avatarFrame: user.avatarFrame,
+          balance: user.balance,
+          experience: user.experience,
+          level: user.level,
+          language: user.normalizedLang,
+          cardsSkin: user.cardSkin,
+          onSendWsMessage: this.handleSendWsMessage,
+          onGotWsMessageClientResponse: this.handleGotWsMessageClientResponse,
+        });
+        this.playersManager.addPlayer(player);
+        player.connections.addConnection(client);
+      }
+    }
+  }
+
+  handleDisconnect(client: Socket): void {
+    const playerId = client.handshake.auth.token as string | undefined;
+    const connectedPlayer = this.playersManager.getPlayerById(playerId ?? '');
+
+    if (connectedPlayer) {
+      connectedPlayer.disconnect();
+      if (
+        !connectedPlayer.isPlayer() &&
+        !connectedPlayer.isTableQueuer() &&
+        !connectedPlayer.isRoomQueuer() &&
+        !connectedPlayer.hasOpenConnection()
+      ) {
+        this.playersManager.removePlayer(playerId ?? '');
+      }
+    }
+  }
+
+  handleSendWsMessage = (wsEvent: BaseWsEvent) => {
+    this.eventsBusPlayerWsMessageSubscribeService.pushSendMessage(wsEvent);
+  };
+
+  handleGotWsMessageClientResponse = (wsEvent: BaseWsEvent) => {
+    this.eventsBusPlayerWsMessageSubscribeService.pushGotMessage(wsEvent);
+  };
+}

package/src/modules/events/events.interfaces.ts

@@ -1,17 +1,17 @@
-import { GamePlayer, IGamePlayerConfig } from 'jp.ms.common.engine';
-import { ModuleMetadata } from '@nestjs/common';
-import { Type } from '@nestjs/common/interfaces/type.interface';
-import { DynamicModule } from '@nestjs/common/interfaces/modules/dynamic-module.interface';
-import { ForwardReference } from '@nestjs/common/interfaces/modules/forward-reference.interface';
-
-export interface EventsModuleOptions extends Pick<ModuleMetadata, 'imports'> {
-  imports?: Array<
-    Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
-  >;
-  inject?: any[];
-  useFactory?: (...args: any[]) => Promise<any> | any;
-}
-
-export interface EventsFactoryOptions {
-  createPlayer: (config: IGamePlayerConfig) => GamePlayer;
-}
+import { GamePlayer, IGamePlayerConfig } from 'jp.ms.common.engine';
+import { ModuleMetadata } from '@nestjs/common';
+import { Type } from '@nestjs/common/interfaces/type.interface';
+import { DynamicModule } from '@nestjs/common/interfaces/modules/dynamic-module.interface';
+import { ForwardReference } from '@nestjs/common/interfaces/modules/forward-reference.interface';
+
+export interface EventsModuleOptions extends Pick<ModuleMetadata, 'imports'> {
+  imports?: Array<
+    Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
+  >;
+  inject?: any[];
+  useFactory?: (...args: any[]) => Promise<any> | any;
+}
+
+export interface EventsFactoryOptions {
+  createPlayer: (config: IGamePlayerConfig) => GamePlayer;
+}