jp.ms.common.modules 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jp.ms.common.modules",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,16 +10,18 @@
     "@nestjs/common": "11.1.0",
     "@nestjs/config": "4.0.2",
     "@nestjs/core": "11.1.0",
-    "@nestjs/mongoose": "11.0.3",
+    "@nestjs/mongoose": "11.0.4",
     "@nestjs/websockets": "11.1.9",
-    "jp.common.models": "file:../jp.common.models",
-    "jp.db.schemas": "1.0.37",
-    "jp.ms.common.engine": "file:../jp.ms.common.engine",
-    "mongoose": "8.14.1",
+    "jp.common.models": "1.0.7",
+    "jp.common.utils": "1.0.2",
+    "jp.db.schemas": "2.0.1",
+    "jp.ms.common.engine": "2.0.0",
+    "mongoose": "9.1.5",
     "nestjs-i18n": "10.5.1",
     "reflect-metadata": "0.2.2",
     "rxjs": "7.8.2",
-    "socket.io": "4.8.1"
+    "socket.io": "4.8.1",
+    "prom-client": "^15.1.0"
   },
   "devDependencies": {
     "@nestjs/swagger": "11.2.3",
@@ -27,7 +29,8 @@
     "class-transformer": "0.5.1",
     "class-validator": "0.14.3",
     "rimraf": "6.0.1",
-    "typescript": "5.8.3"
+    "typescript": "5.8.3",
+    "@types/express": "^5.0.6"
   },
   "scripts": {
     "build": "rimraf dist && tsc",

package/src/adapter/base-table-game-state-adapter.ts

@@ -0,0 +1,254 @@
+import {
+    IBaseTableGameStateExtraButtons,
+    IBaseTableGameStatePlayer,
+    IBaseTableGameStateSummary,
+    IBaseTableGameState,
+    IBaseTableGameStateMovesPanel,
+    IBaseTableGameStateYoursActionItem,
+    BaseTableGameStateYoursAction,
+    BaseTablePlayerActionsEnum,
+    BaseTableGameStateExtraButtons,
+    BaseTableGameStatePlayer,
+    BaseTableGameStateSummary,
+    BaseTableGameSummaryItem,
+    BaseTableGameStateMovesPanel,
+} from 'jp.common.models';
+import { GameMaster, GamePlayer } from 'jp.ms.common.engine';
+import { formatChips, getPropsFromObject } from 'jp.common.utils';
+
+export abstract class BaseTableGameStateAdapter {
+    private readonly _master: GameMaster;
+    private readonly _currentPlayer: GamePlayer;
+
+    constructor (master: GameMaster, currentPlayer: GamePlayer) {
+        this._master = master;
+        this._currentPlayer = currentPlayer;
+    }
+
+    getMaster<T extends GameMaster> () {
+        return this._master as T;
+    }
+
+    getCurrentPlayer<T extends GamePlayer> () {
+        return this._currentPlayer as T;
+    }
+
+    get lang (): string {
+        return this._currentPlayer.language.replace('language__', '');
+    }
+
+    t (key: string, options: object) {
+        const fullCommonKey = `common.${key}`;
+        const fullSpecificKey = `${this._master.getRoom().getGameType().replace('JUST_', '').toLowerCase()}.${key}`;
+
+        let resource = this._master.getRoom().getLocaleService().t(fullSpecificKey, { ...options, defaultValue: '' });
+        if (!resource) {
+            resource = this._master.getRoom().getLocaleService().t(fullCommonKey, { ...options, defaultValue: '' });
+        }
+
+        return resource || key;
+    }
+
+    getRoomId (): string {
+        return this._master.getRoom().getId();
+    }
+
+    getTableId (): string {
+        return this._master.getTable().getId();
+    }
+
+    getGameId (): string {
+        return this._master.getGameRound()?.getId() ?? '';
+    }
+
+    getTableSize (): number {
+        return this._master.getTable().getTableSize();
+    }
+
+    getPlayerTurnTimerRemain (): number | undefined {
+        return this._master.getPlayerTurnTimerRemain();
+    }
+
+    getRestartTimerRemain (): number | undefined {
+        return this._master.getRestartTimerRemain();
+    }
+
+    getYoursMessage (): string {
+        if (this._currentPlayer.isRoomQueuer()) {
+            if (this._master.getTable().isFull()) {
+                return this.t(`room.screen.info.message.title.WAITING_FREE_SEAT`, { lang: this.lang });
+            } else {
+                return this.t(`room.screen.info.message.title.WAITING_NEXT_GAME`, { lang: this.lang });
+            }
+        }
+
+        return '';
+    }
+
+    getPlayerComment (player: GamePlayer): string {
+        if (this._master.isInProgress()) {
+            if (this._master.isActivePlayer(player.id)) {
+                return this.getPlayerCommentInProgressActive(player);
+            } else {
+                return this.getPlayerCommentInProgressNotActive(player);
+            }
+        } else if (this._master.isFinish()) {
+            return this.getPlayerCommentFinish(player)
+        }
+
+        return ''
+    }
+
+    getPlayerCommentInProgressActive (player: GamePlayer): string {
+        return this.t('room.screen.player.turn.timeout', { lang: this.lang });
+    }
+
+    getPlayerCommentInProgressNotActive (player: GamePlayer): string {
+        return this.t(
+            `room.screen.last.action.title.${player.getLastMove()?.action}`,
+            { lang: this.lang, args: getPropsFromObject(player.getLastMove() ?? {}) },
+        );
+    }
+
+    getPlayerCommentFinish (player: GamePlayer): string {
+        const profit = formatChips(player.profit, this.lang, true);
+
+        return player.isWinner ? `+${profit}` : profit;
+    }
+
+    getPlayer (item: GamePlayer): IBaseTableGameStatePlayer {
+        return new BaseTableGameStatePlayer({
+            id: item.id,
+            fullName: item.fullName,
+            avatarUrl: item.avatarUrl,
+            stack: formatChips(item.stack, this.lang, true),
+            seatNumber: item.seatNumber,
+            active: item.isWinner || item.isActivePlayer(),
+            comment: this.getPlayerComment(item),
+        });
+    }
+
+    getPlayers (): Array<IBaseTableGameStatePlayer> {
+        return this._master.getTable().getPlayers<GamePlayer>().map((item) => this.getPlayer(item));
+    }
+
+    getPlayerActions (): Array<IBaseTableGameStateYoursActionItem> {
+        return this._master.getPossibleMoves(this._currentPlayer)
+            .map((action) => new BaseTableGameStateYoursAction(
+                action,
+                this.t(`room.screen.action.button.title.${action}`, { lang: this.lang }),
+            ));
+    }
+
+    getMovesPanelIsOpen (): boolean {
+        return true;
+    }
+
+    getMovesPanel (): IBaseTableGameStateMovesPanel {
+        return new BaseTableGameStateMovesPanel(this.getMovesPanelIsOpen(), this.getPlayerActions());
+    }
+
+    getExtraButtons (): IBaseTableGameStateExtraButtons | undefined {
+        const chat = this._master.hasPossibleMove(this._currentPlayer, BaseTablePlayerActionsEnum.ACTION_CHAT);
+        const react = this._master.hasPossibleMove(this._currentPlayer, BaseTablePlayerActionsEnum.ACTION_REACT);
+
+        return new BaseTableGameStateExtraButtons(
+            chat ?
+                new BaseTableGameStateYoursAction(
+                    BaseTablePlayerActionsEnum.ACTION_CHAT,
+                    this.t(`room.screen.action.button.title.${chat}`, { lang: this.lang }),
+                )
+                : undefined,
+            react ?
+                new BaseTableGameStateYoursAction(
+                    BaseTablePlayerActionsEnum.ACTION_REACT,
+                    this.t(`room.screen.action.button.title.${react}`, { lang: this.lang }),
+                )
+                : undefined,
+        );
+    }
+
+    getSummary (): IBaseTableGameStateSummary {
+        if (this._master.isInProgress()) {
+            return this.getSummaryPlaying();
+        } else if (this._master.isTechBreak()) {
+            return this.getSummaryTechBreak();
+        } else if (this._master.isWaiting()) {
+            return this.getSummaryWaiting();
+        } else if (this._master.isFinish()) {
+            return this.getSummaryEnd();
+        }
+
+        return new BaseTableGameStateSummary();
+    }
+
+    getSummaryTechBreak () {
+        const summary = new BaseTableGameStateSummary();
+
+        summary.list.push(BaseTableGameSummaryItem.newBodyMdItem(
+            'tech-break',
+            this.t('room.screen.tech.break.message', { lang: this.lang }),
+        ));
+
+        return summary;
+    }
+
+    getSummaryPlaying () {
+        const summary = new BaseTableGameStateSummary();
+
+        summary.list.push(BaseTableGameSummaryItem.newTitleMdItem(
+            'pot',
+            this.t('room.screen.summary.pot', {
+                    lang: this.lang,
+                    args: { POT: formatChips(this.getMaster()?.getGameRound()?.getPot() ?? 0, this.lang, true) },
+                },
+            ),
+        ));
+
+        return summary;
+    }
+
+    getSummaryWaiting () {
+        const summary = new BaseTableGameStateSummary();
+
+        summary.list.push(BaseTableGameSummaryItem.newBodyMdItem(
+            'waiting',
+            this.t('room.screen.waiting.for.the.players', { lang: this.lang }),
+        ));
+
+        return summary;
+    }
+
+    getSummaryEnd () {
+        const summary = new BaseTableGameStateSummary();
+
+        summary.list.push(BaseTableGameSummaryItem.newBodySmItem(
+            'WINNER',
+            this.t('room.screen.summary.winner', { lang: this.lang }),
+            this._master.getGameResultHelper()?.getWinnersName() ?? '',
+        ));
+
+        summary.list.push(BaseTableGameSummaryItem.newBodySmItem(
+            'NEW_GAME',
+            this.t('room.screen.summary.new.game', { lang: this.lang }),
+            this.t('room.screen.summary.new.game.value', { lang: this.lang }),
+        ));
+
+        return summary;
+    }
+
+    getState (): IBaseTableGameState {
+        return {
+            roomId: this.getRoomId(),
+            tableId: this.getTableId(),
+            gameId: this.getGameId(),
+            tableSize: this.getTableSize(),
+            checkPlayersTurnTimerRemain: this.getPlayerTurnTimerRemain(),
+            restartTimerRemain: this.getRestartTimerRemain(),
+            yoursMessage: this.getYoursMessage(),
+            summary: this.getSummary(),
+            movesPanel: this.getMovesPanel(),
+            extraButtons: this.getExtraButtons(),
+        }
+    }
+}

package/src/adapter/card-table-game-state-adapter.ts

@@ -0,0 +1,54 @@
+import {
+    ICardTableGameState,
+    ICardPlayerState,
+    CardsPanelState,
+    ICardsPanelState,
+} from 'jp.common.models';
+import { CardsGameMaster, CardsPlayer } from 'jp.ms.common.engine';
+
+import { BaseTableGameStateAdapter } from './base-table-game-state-adapter';
+
+export abstract class CardTableGameStateAdapter extends BaseTableGameStateAdapter {
+    override getPlayer (item: CardsPlayer): ICardPlayerState {
+        return {
+            ...super.getPlayer(item),
+            cards: item.getCards(),
+        };
+    }
+
+    override getPlayers (): Array<ICardPlayerState> {
+        return this.getMaster<CardsGameMaster>().getTable().getPlayers<CardsPlayer>().map((item) => this.getPlayer(item));
+    }
+
+    getPlayerCards () {
+        return this.getCurrentPlayer<CardsPlayer>().getCards();
+    }
+
+    getCardsPanelIsOpen (): boolean {
+        return false;
+    }
+
+    getCardsPanelBackdropVisible (): boolean {
+        return false;
+    }
+
+    getCardsPanel (): ICardsPanelState {
+        return new CardsPanelState(
+            this.getCardsPanelIsOpen(),
+            this.getPlayerActions(),
+            this.getPlayerCards(),
+            this.getCardsPanelBackdropVisible(),
+        );
+    }
+
+    getState (): ICardTableGameState {
+        return {
+            ...super.getState(),
+            players: this.getPlayers(),
+            baseCard: this.getMaster<CardsGameMaster>().getGameBaseCard(),
+            gameCards: this.getMaster<CardsGameMaster>().getGameCards(),
+            gameCardsPair: this.getMaster<CardsGameMaster>().getGameCardPairSlots().getSlots(),
+            cardsPanel: this.getCardsPanel(),
+        };
+    }
+}

package/src/adapter/index.ts

@@ -0,0 +1 @@
+export { CardTableGameStateAdapter } from './card-table-game-state-adapter';

package/src/config/database.ts

@@ -1,12 +1,11 @@
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { MongooseModuleAsyncOptions } from '@nestjs/mongoose';
 
-export function getDatabaseConfig (module: ConfigModule, service: object): MongooseModuleAsyncOptions {
+export function getDatabaseConfig (configService: object): MongooseModuleAsyncOptions {
     return {
-        imports: [module],
         useFactory: async (configService: ConfigService) => ({
             uri: configService.get<string>('MONGODB_URI'),
         }),
-        inject: [service],
+        inject: [configService],
     } as MongooseModuleAsyncOptions;
 }

package/src/config/locale.ts

@@ -2,15 +2,8 @@ import { join } from 'path';
 import { AcceptLanguageResolver, HeaderResolver, I18nAsyncOptions, QueryResolver } from 'nestjs-i18n';
 import { ConfigService } from '@nestjs/config';
 
-interface LocaleParams {
-    module: object,
-    service: object,
-    dirname: string,
-}
-
-export function getLocaleConfig (module: object, service: object, dirname: string) {
+export function getLocaleConfig (configService: object, dirname: string) {
     return {
-        imports: [module],
         useFactory: async (configService: ConfigService) => {
             return ({
                 fallbackLanguage: 'en',
@@ -25,6 +18,6 @@ export function getLocaleConfig (module: object, service: object, dirname: strin
             AcceptLanguageResolver,
             { use: HeaderResolver, options: ['x-lang'] },
         ],
-        inject: [service],
+        inject: [configService],
     } as I18nAsyncOptions;
 }

package/src/dto/app-screen/app-screen-section-button.dto.ts

@@ -40,6 +40,15 @@ export class AppScreenSectionButtonDto implements IAppScreenSectionButton {
   @IsString()
   url?: string;
 
+  @ApiProperty({
+    description: 'icon',
+    required: false,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  icon?: string;
+
   @ApiProperty({
     description: 'title',
     required: true,

package/src/dto/common/index.ts

@@ -0,0 +1 @@
+export { PlayerCheckStateDto } from './player-check-state.dto';

package/src/dto/common/player-connected.dto.ts

@@ -0,0 +1,58 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Expose } from 'class-transformer';
+import { IsArray, IsString, ValidateNested } from 'class-validator';
+import { GamePlayer } from 'jp.ms.common.engine';
+
+export class PlayerConnectedDto {
+    @ApiProperty({
+        description: 'Идентификатор пользователя',
+        required: true,
+        type: String,
+    })
+    @Expose()
+    @IsString()
+    id: string;
+
+    @ApiProperty({
+        description: 'Имя',
+        required: true,
+        type: String,
+    })
+    @Expose()
+    @IsString()
+    fullName: string;
+
+    @ApiProperty({
+        description: 'Дата последнего сообщения',
+        required: true,
+        type: String,
+    })
+    @Expose()
+    @IsString()
+    lastWSMessageDate: Date | null;
+
+    @ApiProperty({
+        description: 'Дата последнего сообщения',
+        required: true,
+        type: String,
+    })
+    @Expose()
+    @IsString()
+    isPlayer: boolean;
+
+    @IsArray()
+    @ValidateNested({ each: true })
+    @Expose()
+    connections: Array<string>;
+
+    static fromEntities(player: GamePlayer): PlayerConnectedDto {
+        const dto = new PlayerConnectedDto();
+        dto.id = player.id;
+        dto.fullName = player.fullName;
+        // dto.lastWSMessageDate = player.lastWSMessageDate;
+        dto.isPlayer = player.isPlayer();
+        dto.connections = player.connections.getAllConnectionsKeys();
+
+        return dto;
+    }
+}

package/src/dto/index.ts

@@ -1,2 +1,3 @@
-export * from './base'
+export * from './table-game'
 export * from './app-screen'
+export * from './common'

package/src/dto/table-game/base/base-table-game-state.dto.ts

@@ -0,0 +1,79 @@
+import { Expose, Type } from 'class-transformer';
+import { IsNumber, IsString, ValidateNested } from 'class-validator';
+import { IBaseTableGameState } from 'jp.common.models';
+import { ApiProperty } from '@nestjs/swagger';
+
+import { BaseTableSummaryDto } from './base-table-summary.dto';
+import { BaseTableMovesPanelDto } from './base-table-moves-panel.dto';
+
+export class BaseTableGameStateDto implements IBaseTableGameState {
+  @ApiProperty({
+    description: 'Room ID',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  roomId: string;
+
+  @ApiProperty({
+    description: 'Table ID',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  tableId: string;
+
+  @ApiProperty({
+    description: 'Game ID',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  gameId: string;
+
+  @ApiProperty({
+    description: 'Table Size',
+    type: Number,
+  })
+  @IsNumber()
+  @Expose()
+  tableSize: number;
+
+  @ApiProperty({
+    description: 'Your message',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  yoursMessage: string;
+
+  @ValidateNested()
+  @Type(() => BaseTableSummaryDto)
+  @Expose()
+  summary: BaseTableSummaryDto;
+
+  @ApiProperty({
+    description: 'Player Turn Timer Remain',
+    type: Number,
+  })
+  @IsNumber()
+  @Expose()
+  checkPlayersTurnTimerRemain?: number;
+
+  @ApiProperty({
+    description: 'Restart Timer Remain',
+    type: Number,
+  })
+  @IsNumber()
+  @Expose()
+  restartTimerRemain?: number;
+
+  @ValidateNested()
+  @Type(() => BaseTableMovesPanelDto)
+  @Expose()
+  movesPanel: BaseTableMovesPanelDto;
+}

package/src/dto/table-game/base/base-table-moves-panel.dto.ts

@@ -0,0 +1,23 @@
+import { Expose, Type } from 'class-transformer';
+import { IsArray, IsBoolean, ValidateNested } from 'class-validator';
+import { IBaseTableGameStateMovesPanel } from 'jp.common.models';
+import { ApiProperty } from '@nestjs/swagger';
+
+import { BaseTableYoursActionDto } from './base-table-yours-action.dto';
+
+export class BaseTableMovesPanelDto implements IBaseTableGameStateMovesPanel {
+  @ApiProperty({
+    description: 'isOpen',
+    required: true,
+    type: Boolean,
+  })
+  @Expose()
+  @IsBoolean()
+  isOpen: boolean;
+
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => BaseTableYoursActionDto)
+  @Expose()
+  moves: Array<BaseTableYoursActionDto>;
+}

package/src/dto/table-game/base/game-player.dto.ts

@@ -0,0 +1,69 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Expose } from 'class-transformer';
+import { IsString, IsNumber, IsBoolean } from 'class-validator';
+import { IBaseTableGameStatePlayer } from 'jp.common.models';
+
+export class GamePlayerDto implements IBaseTableGameStatePlayer {
+  @ApiProperty({
+    description: 'user ID',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  id: string;
+
+  @ApiProperty({
+    description: 'full name',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  fullName: string;
+
+  @ApiProperty({
+    description: 'avatar url',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  avatarUrl: string;
+
+  @ApiProperty({
+    description: 'stack',
+    required: true,
+    type: Number,
+  })
+  @Expose()
+  @IsNumber()
+  stack: string;
+
+  @ApiProperty({
+    description: 'seat number',
+    required: true,
+    type: Number,
+  })
+  @Expose()
+  @IsNumber()
+  seatNumber: number;
+
+  @ApiProperty({
+    description: 'active',
+    required: true,
+    type: Boolean,
+  })
+  @Expose()
+  @IsBoolean()
+  active: boolean;
+
+  @ApiProperty({
+    description: 'comment',
+    required: true,
+    type: String,
+  })
+  @Expose()
+  @IsString()
+  comment: string;
+}

package/src/dto/table-game/cards/card-pair-slot.dto.ts

@@ -0,0 +1,45 @@
+import { Expose, Type } from 'class-transformer';
+import { IsBoolean, IsNumber, ValidateNested } from 'class-validator';
+import { ICardPairSlotState } from 'jp.common.models';
+import { ApiProperty } from '@nestjs/swagger';
+
+import { CardDto } from './card.dto';
+
+export class CardPairSlotDto implements ICardPairSlotState {
+  @ApiProperty({
+    description: 'id',
+    required: true,
+    type: Number,
+  })
+  @Expose()
+  @IsNumber()
+  id: number;
+
+  @ValidateNested()
+  @Type(() => CardDto)
+  @Expose()
+  top: CardDto | null;
+
+  @ValidateNested()
+  @Type(() => CardDto)
+  @Expose()
+  bottom: CardDto | null;
+
+  @ApiProperty({
+    description: 'activated',
+    required: true,
+    type: Boolean,
+  })
+  @Expose()
+  @IsBoolean()
+  activated: boolean;
+
+  @ApiProperty({
+    description: 'activated',
+    required: true,
+    type: Boolean,
+  })
+  @Expose()
+  @IsBoolean()
+  disabled: boolean;
+}