jp.ms.common.modules 1.0.34 → 1.0.36

package/src/modules/simple-rooms/simple-rooms.controller.ts

@@ -1,54 +1,63 @@
-import { Body, Controller, Param, Post, Headers, HttpStatus, HttpCode } from '@nestjs/common';
+import {
+  Body,
+  Controller,
+  Param,
+  Post,
+  Headers,
+  HttpStatus,
+  HttpCode,
+} from '@nestjs/common';
 import { IAppHeaders, IBaseMoveData, IAppTableState } from 'jp.common.models';
 
 import { SimpleRoomsService } from './simple-rooms.service';
 
 @Controller('simple-rooms')
 export class SimpleRoomsController {
-    constructor (
-        private readonly roomsService: SimpleRoomsService,
-    ) {
-    }
-    @Post('table/watch/:tableId')
-    @HttpCode(HttpStatus.OK)
-    watchTheTable (
-        @Param('tableId') tableId: string,
-        @Headers() headers: IAppHeaders,
-    ): IAppTableState {
-        return this.roomsService.watchTheTable(tableId, headers.client_auth_token);
-    }
+  constructor(private readonly roomsService: SimpleRoomsService) {}
+  @Post('table/watch/:tableId')
+  @HttpCode(HttpStatus.OK)
+  watchTheTable(
+    @Param('tableId') tableId: string,
+    @Headers() headers: IAppHeaders,
+  ): IAppTableState {
+    return this.roomsService.watchTheTable(tableId, headers.client_auth_token);
+  }
 
-    @Post('table/enter/:tableId')
-    @HttpCode(HttpStatus.OK)
-    enterTheTable (
-        @Param('tableId') tableId: string,
-        @Headers() headers: IAppHeaders,
-    ): IAppTableState {
-        return this.roomsService.enterTheTable(tableId, headers.client_auth_token);
-    }
+  @Post('table/enter/:tableId')
+  @HttpCode(HttpStatus.OK)
+  enterTheTable(
+    @Param('tableId') tableId: string,
+    @Headers() headers: IAppHeaders,
+  ): IAppTableState {
+    return this.roomsService.enterTheTable(tableId, headers.client_auth_token);
+  }
 
-    @Post('table/exit/:tableId')
-    @HttpCode(HttpStatus.OK)
-    exitTheTable (
-        @Param('tableId') tableId: string,
-        @Headers() headers: IAppHeaders,
-    ): IAppTableState {
-        return this.roomsService.exitTheTable(tableId, headers.client_auth_token);
-    }
+  @Post('table/exit/:tableId')
+  @HttpCode(HttpStatus.OK)
+  exitTheTable(
+    @Param('tableId') tableId: string,
+    @Headers() headers: IAppHeaders,
+  ): IAppTableState {
+    return this.roomsService.exitTheTable(tableId, headers.client_auth_token);
+  }
 
-    @Post('table/move/:tableId')
-    @HttpCode(HttpStatus.OK)
-    moveOnTheTable (
-        @Param('tableId') tableId: string,
-        @Body() baseMoveData: IBaseMoveData,
-        @Headers() headers: IAppHeaders,
-    ): IAppTableState {
-        return this.roomsService.moveOnTheTable(tableId, headers.client_auth_token, baseMoveData);
-    }
+  @Post('table/move/:tableId')
+  @HttpCode(HttpStatus.OK)
+  moveOnTheTable(
+    @Param('tableId') tableId: string,
+    @Body() baseMoveData: IBaseMoveData,
+    @Headers() headers: IAppHeaders,
+  ): IAppTableState {
+    return this.roomsService.moveOnTheTable(
+      tableId,
+      headers.client_auth_token,
+      baseMoveData,
+    );
+  }
 
-    @Post('table/restart/:tableId')
-    @HttpCode(HttpStatus.OK)
-    restartTable (@Param('tableId') tableId: string): boolean {
-        return this.roomsService.restartTable(tableId);
-    }
+  @Post('table/restart/:tableId')
+  @HttpCode(HttpStatus.OK)
+  restartTable(@Param('tableId') tableId: string): boolean {
+    return this.roomsService.restartTable(tableId);
+  }
 }

package/src/modules/simple-rooms/simple-rooms.interfaces.ts

@@ -4,12 +4,15 @@ 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 SimpleRoomsModuleOptions extends Pick<ModuleMetadata, 'imports'> {
-    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
-    inject?: any[];
-    useFactory?: (...args: any[]) => Promise<any> | any;
+export interface SimpleRoomsModuleOptions
+  extends Pick<ModuleMetadata, 'imports'> {
+  imports?: Array<
+    Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
+  >;
+  inject?: any[];
+  useFactory?: (...args: any[]) => Promise<any> | any;
 }
 
 export interface SimpleRoomsFactoryOptions {
-    i18n: I18nService
+  i18n: I18nService;
 }

package/src/modules/simple-rooms/simple-rooms.module.ts

@@ -1,6 +1,10 @@
 import { DynamicModule, Module, Provider } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
-import { SimpleRoom, SimpleRoomSchema, SimpleRoomsRepository } from 'jp.db.schemas';
+import {
+  SimpleRoom,
+  SimpleRoomSchema,
+  SimpleRoomsRepository,
+} from 'jp.db.schemas';
 
 import { SimpleRoomsController } from './simple-rooms.controller';
 import { SimpleRoomsService } from './simple-rooms.service';
@@ -8,29 +12,28 @@ import { SIMPLE_ROOMS_OPTIONS } from './simple-rooms.constants';
 import { SimpleRoomsModuleOptions } from './simple-rooms.interfaces';
 
 @Module({
-    imports: [
-        MongooseModule.forFeature([{ name: SimpleRoom.name, schema: SimpleRoomSchema }]),
-    ],
-    controllers: [SimpleRoomsController],
-    providers: [SimpleRoomsService, SimpleRoomsRepository],
+  imports: [
+    MongooseModule.forFeature([
+      { name: SimpleRoom.name, schema: SimpleRoomSchema },
+    ]),
+  ],
+  controllers: [SimpleRoomsController],
+  providers: [SimpleRoomsService, SimpleRoomsRepository],
 })
 export class SimpleRoomsModule {
-    constructor () {
+  constructor() {}
 
-    }
-
-    static forRootAsync (options: SimpleRoomsModuleOptions): DynamicModule {
-        return {
-            module: SimpleRoomsModule,
-            imports: options.imports ?? [],
-            providers: [
-                {
-                    provide: SIMPLE_ROOMS_OPTIONS,
-                    useFactory: options.useFactory,
-                    inject: options.inject || [],
-                } as Provider,
-            ],
-        };
-    }
+  static forRootAsync(options: SimpleRoomsModuleOptions): DynamicModule {
+    return {
+      module: SimpleRoomsModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: SIMPLE_ROOMS_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        } as Provider,
+      ],
+    };
+  }
 }
-

package/src/modules/simple-rooms/simple-rooms.service.ts

@@ -1,8 +1,9 @@
-import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
 import {
-    IBaseMoveData,
-    IAppTableState,
-} from 'jp.common.models';
+  Inject,
+  Injectable,
+  InternalServerErrorException,
+} from '@nestjs/common';
+import { IBaseMoveData, IAppTableState } from 'jp.common.models';
 
 import { SimpleRoomsManagerService } from '../simple-rooms-manager';
 import { PlayersManagerService } from '../players-manager';
@@ -12,79 +13,83 @@ import { SimpleRoomsFactoryOptions } from './simple-rooms.interfaces';
 
 @Injectable()
 export class SimpleRoomsService {
-    constructor (
-        private readonly simpleRoomsManager: SimpleRoomsManagerService,
-        private readonly playersManager: PlayersManagerService,
-        @Inject(SIMPLE_ROOMS_OPTIONS) private readonly options: SimpleRoomsFactoryOptions,
-    ) {
+  constructor(
+    private readonly simpleRoomsManager: SimpleRoomsManagerService,
+    private readonly playersManager: PlayersManagerService,
+    @Inject(SIMPLE_ROOMS_OPTIONS)
+    private readonly options: SimpleRoomsFactoryOptions,
+  ) {}
+
+  watchTheTable(tableId: string, clientAuthToken: string): IAppTableState {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+    const master = room?.getMasterById(tableId);
+
+    if (player && room && master) {
+      room.handleWatchTheTable(player, tableId);
+
+      return master.createGameStateDto(player);
     }
 
-    watchTheTable (tableId: string, clientAuthToken: string): IAppTableState {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
-        const master = room?.getMasterById(tableId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && room && master) {
-            room.handleWatchTheTable(player, tableId);
+  enterTheTable(tableId: string, clientAuthToken: string): IAppTableState {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+    const master = room?.getMasterById(tableId);
 
-            return master.createGameStateDto(player);
-        }
+    if (player && room && master) {
+      room.handleEnterTheTable(player, tableId);
 
-        throw new InternalServerErrorException();
+      return master.createGameStateDto(player);
     }
 
-    enterTheTable (tableId: string, clientAuthToken: string): IAppTableState {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
-        const master = room?.getMasterById(tableId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && room && master) {
-            room.handleEnterTheTable(player, tableId);
+  exitTheTable(tableId: string, clientAuthToken: string): IAppTableState {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+    const master = room?.getMasterById(tableId);
 
-            return master.createGameStateDto(player);
-        }
+    if (player && room && master) {
+      room.handleExitTheTable(player, tableId);
 
-        throw new InternalServerErrorException();
+      return master.createGameStateDto(player);
     }
 
-    exitTheTable (tableId: string, clientAuthToken: string): IAppTableState {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
-        const master = room?.getMasterById(tableId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && room && master) {
-            room.handleExitTheTable(player, tableId);
+  moveOnTheTable(
+    tableId: string,
+    clientAuthToken: string,
+    moveDto: IBaseMoveData,
+  ): IAppTableState {
+    const player = this.playersManager.getPlayerById(clientAuthToken);
+    const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+    const master = room?.getMasterById(tableId);
 
-            return master.createGameStateDto(player);
-        }
+    if (player && room && master) {
+      room.handleMoveOnTheTable(player, tableId, moveDto);
 
-        throw new InternalServerErrorException();
+      return master.createGameStateDto(player);
     }
 
-    moveOnTheTable (tableId: string, clientAuthToken: string, moveDto: IBaseMoveData): IAppTableState {
-        const player = this.playersManager.getPlayerById(clientAuthToken);
-        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
-        const master = room?.getMasterById(tableId);
+    throw new InternalServerErrorException();
+  }
 
-        if (player && room && master) {
-            room.handleMoveOnTheTable(player, tableId, moveDto);
+  restartTable(tableId: string): boolean {
+    const room = this.simpleRoomsManager.getRoomByTableId(tableId);
+    const master = room?.getMasterById(tableId);
 
-            return master.createGameStateDto(player);
-        }
+    if (room && master) {
+      room.handleRestartTable(tableId);
 
-        throw new InternalServerErrorException();
+      return true;
     }
 
-    restartTable (tableId: string): boolean {
-        const room = this.simpleRoomsManager.getRoomByTableId(tableId);
-        const master = room?.getMasterById(tableId);
-
-        if (room && master) {
-            room.handleRestartTable(tableId);
-
-            return true;
-        }
-
-        throw new InternalServerErrorException();
-    }
+    throw new InternalServerErrorException();
+  }
 }

package/src/modules/simple-rooms-manager/simple-rooms-manager.constants.ts

@@ -1 +1,3 @@
-export const SIMPLE_ROOMS_MANAGER_OPTIONS = Symbol('SIMPLE_ROOMS_MANAGER_OPTIONS');
+export const SIMPLE_ROOMS_MANAGER_OPTIONS = Symbol(
+  'SIMPLE_ROOMS_MANAGER_OPTIONS',
+);

package/src/modules/simple-rooms-manager/simple-rooms-manager.interfaces.ts

@@ -4,16 +4,21 @@ 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';
 import { GameRoomConfig, SimpleRoom } from 'jp.ms.common.engine';
-import { ConfigService } from '@nestjs/config';
 
-export interface SimpleRoomsManagerOptions extends Pick<ModuleMetadata, 'imports'> {
-    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
-    inject?: any[];
-    useFactory?: (...args: any[]) => Promise<any> | any;
+export interface SimpleRoomsManagerOptions
+  extends Pick<ModuleMetadata, 'imports'> {
+  imports?: Array<
+    Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
+  >;
+  inject?: any[];
+  useFactory?: (...args: any[]) => SimpleRoomsFactoryOptions;
 }
 
 export interface SimpleRoomsFactoryOptions {
-    i18n: I18nService;
-    configService: ConfigService;
-    createRoom (room: GameRoomConfig): SimpleRoom;
+  i18n: I18nService | any;
+  createRoom(room: GameRoomConfig): SimpleRoom;
+  gameType: string;
+  restartGameTimeout: number;
+  playersTurnTimeout: number;
+  instantFinishMode: boolean;
 }

package/src/modules/simple-rooms-manager/simple-rooms-manager.module.ts

@@ -1,15 +1,15 @@
 import { DynamicModule, Global, Module, Provider } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
 import {
-    SimpleRoom,
-    SimpleRoomSchema,
-    SimpleRoomsRepository,
-    User,
-    UserSchema,
-    UsersRepository,
-    GameResult,
-    GameResultSchema,
-    GameResultRepository,
+  SimpleRoom,
+  SimpleRoomSchema,
+  SimpleRoomsRepository,
+  User,
+  UserSchema,
+  UsersRepository,
+  GameResult,
+  GameResultSchema,
+  GameResultRepository,
 } from 'jp.db.schemas';
 
 import { SimpleRoomsManagerService } from './simple-rooms-manager.service';
@@ -18,41 +18,43 @@ import { SIMPLE_ROOMS_MANAGER_OPTIONS } from './simple-rooms-manager.constants';
 
 @Global()
 @Module({
-    imports: [
-        MongooseModule.forFeature([{name: SimpleRoom.name, schema: SimpleRoomSchema}]),
-        MongooseModule.forFeature([{name: User.name, schema: UserSchema}]),
-        MongooseModule.forFeature([{name: GameResult.name, schema: GameResultSchema}]),
-    ],
-    providers: [
-        SimpleRoomsRepository,
-        UsersRepository,
-        GameResultRepository,
-        SimpleRoomsManagerService,
-    ],
-    exports: [SimpleRoomsManagerService],
+  imports: [
+    MongooseModule.forFeature([
+      { name: SimpleRoom.name, schema: SimpleRoomSchema },
+    ]),
+    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+    MongooseModule.forFeature([
+      { name: GameResult.name, schema: GameResultSchema },
+    ]),
+  ],
+  providers: [
+    SimpleRoomsRepository,
+    UsersRepository,
+    GameResultRepository,
+    SimpleRoomsManagerService,
+  ],
+  exports: [SimpleRoomsManagerService],
 })
 export class SimpleRoomsManagerModule {
-    constructor (
-        private readonly simpleRoomsManagerService: SimpleRoomsManagerService,
-    ) {
-    }
+  constructor(
+    private readonly simpleRoomsManagerService: SimpleRoomsManagerService,
+  ) {}
 
-    static forRootAsync (options: SimpleRoomsManagerOptions): DynamicModule {
-        return {
-            module: SimpleRoomsManagerModule,
-            imports: options.imports ?? [],
-            providers: [
-                {
-                    provide: SIMPLE_ROOMS_MANAGER_OPTIONS,
-                    useFactory: options.useFactory,
-                    inject: options.inject || [],
-                } as Provider,
-            ],
-        };
-    }
+  static forRootAsync(options: SimpleRoomsManagerOptions): DynamicModule {
+    return {
+      module: SimpleRoomsManagerModule,
+      imports: options.imports ?? [],
+      providers: [
+        {
+          provide: SIMPLE_ROOMS_MANAGER_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        } as Provider,
+      ],
+    };
+  }
 
-    async onModuleInit () {
-        await this.simpleRoomsManagerService.hydrateRoomsFromDB();
-    }
+  async onModuleInit() {
+    await this.simpleRoomsManagerService.hydrateRoomsFromDB();
+  }
 }
-