Merge pull request #739 from SprocketBot/cursor/issue-728-sprocket-authoritative-roster-426f

Make Sprocket authoritative for franchise roster/staff reads (GH-728)

Author: gankoji

core/src/franchise/franchise.module.ts

@@ -1,12 +1,29 @@
 import {forwardRef, Module} from "@nestjs/common";
 import {JwtModule} from "@nestjs/jwt";
+import {TypeOrmModule} from "@nestjs/typeorm";
 import {
     AnalyticsModule, config, EventsModule, NotificationModule,
 } from "@sprocketbot/common";
 
+import {FranchiseLeadershipRole} from "../database/authorization/franchise_leadership_role";
+import {FranchiseLeadershipSeat} from "../database/authorization/franchise_leadership_seat";
+import {FranchiseStaffRole} from "../database/authorization/franchise_staff_role";
+import {FranchiseStaffSeat} from "../database/authorization/franchise_staff_seat";
+import {FranchiseLeadershipAppointment} from "../database/franchise/franchise_leadership_appointment";
+import {FranchiseStaffAppointment} from "../database/franchise/franchise_staff_appointment";
+import {Player} from "../database/franchise/player/player.model";
+import {RosterRole} from "../database/franchise/roster_role";
+import {RosterSlot} from "../database/franchise/roster_slot";
+import {Team} from "../database/franchise/team/team.model";
 import {DatabaseModule} from "../database";
 import {EloConnectorModule} from "../elo/elo-connector";
 import {GameModule} from "../game";
+import {MLE_Player} from "../database/mledb/Player.model";
+import {MLE_Team} from "../database/mledb/Team.model";
+import {MLE_TeamToCaptain} from "../database/mledb/TeamToCaptain.model";
+import {LeagueToSkillGroup} from "../database/mledb-bridge/league_to_skill_group.model";
+import {PlayerToPlayer} from "../database/mledb-bridge/player_to_player.model";
+import {TeamToFranchise} from "../database/mledb-bridge/team_to_franchise.model";
 import {MledbInterfaceModule} from "../mledb";
 import {OrganizationModule} from "../organization/organization.module";
 import {SchedulingModule} from "../scheduling/scheduling.module";
@@ -23,11 +40,32 @@ import {
 import {PlayerService} from "./player";
 import {PlayerController} from "./player/player.controller";
 import {PlayerResolver} from "./player/player.resolver";
+import {RosterAuthorityService} from "./roster-authority.service";
 import {TeamService} from "./team/team.service";
 
+const rosterAuthorityOrm = TypeOrmModule.forFeature([
+    MLE_Player,
+    MLE_Team,
+    MLE_TeamToCaptain,
+    TeamToFranchise,
+    LeagueToSkillGroup,
+    PlayerToPlayer,
+    Player,
+    RosterRole,
+    RosterSlot,
+    Team,
+    FranchiseStaffAppointment,
+    FranchiseLeadershipAppointment,
+    FranchiseStaffRole,
+    FranchiseStaffSeat,
+    FranchiseLeadershipRole,
+    FranchiseLeadershipSeat,
+]);
+
 @Module({
     imports: [
         DatabaseModule,
+        rosterAuthorityOrm,
         UtilModule,
         NotificationModule,
         EventsModule,
@@ -43,6 +81,7 @@ import {TeamService} from "./team/team.service";
     ],
     providers: [
         PlayerService,
+        RosterAuthorityService,
         GameSkillGroupService,
         GameSkillGroupResolver,
         FranchiseService,
@@ -51,7 +90,7 @@ import {TeamService} from "./team/team.service";
         PlayerResolver,
         TeamService,
     ],
-    exports: [PlayerService, FranchiseService, GameSkillGroupService, TeamService],
+    exports: [PlayerService, FranchiseService, GameSkillGroupService, TeamService, RosterAuthorityService],
     controllers: [FranchiseController, GameSkillGroupController, PlayerController],
 })
 export class FranchiseModule {}

core/src/franchise/franchise/franchise.service.ts

@@ -12,6 +12,7 @@ import {FranchiseProfile} from "$db/franchise/franchise_profile/franchise_profil
 import {MledbPlayerService} from "../../mledb";
 import {MemberService} from "../../organization";
 import {PlayerService} from "../player";
+import {RosterAuthorityService} from "../roster-authority.service";
 
 @Injectable()
 export class FranchiseService {
@@ -23,6 +24,7 @@ export class FranchiseService {
     private readonly sprocketMemberService: MemberService,
     @InjectRepository(FranchiseProfile)
     private readonly franchiseProfileRepository: Repository<FranchiseProfile>,
+    private readonly rosterAuthorityService: RosterAuthorityService,
     ) {}
 
     async getFranchiseProfile(franchiseId: number): Promise<FranchiseProfile> {
@@ -62,6 +64,26 @@ export class FranchiseService {
     }
 
     async getPlayerFranchisesByUserId(userId: number): Promise<CoreOutput<CoreEndpoint.GetPlayerFranchises>> {
+        const fromSprocket = await this.rosterAuthorityService.getPlayerFranchisesFromSprocket(userId);
+
+        let fromMle: CoreOutput<CoreEndpoint.GetPlayerFranchises> = [];
+        try {
+            fromMle = await this.getPlayerFranchisesFromMle(userId);
+        } catch {
+            // No linked MLE player (or other read failure): Sprocket-only is fine.
+        }
+
+        if (fromMle.length === 0) {
+            return fromSprocket;
+        }
+
+        return this.mergePlayerFranchiseRows(fromSprocket, fromMle);
+    }
+
+    /**
+     * Legacy MLE read path (dual-read with Sprocket until projection/backfill is complete everywhere).
+     */
+    private async getPlayerFranchisesFromMle(userId: number): Promise<CoreOutput<CoreEndpoint.GetPlayerFranchises>> {
         const mlePlayer = await this.mledbPlayerService.getMlePlayerBySprocketUser(userId);
 
         const playerId = mlePlayer.id;
@@ -112,6 +134,46 @@ export class FranchiseService {
         }
     }
 
+    private mergePlayerFranchiseRows(
+        sprocket: CoreOutput<CoreEndpoint.GetPlayerFranchises>,
+        mle: CoreOutput<CoreEndpoint.GetPlayerFranchises>,
+    ): CoreOutput<CoreEndpoint.GetPlayerFranchises> {
+        type Acc = {id: number; name: string; staffByCode: Map<string, {id: number; name: string;}>;};
+        const byFranchiseId = new Map<number, Acc>();
+
+        const mergeRow = (row: {id: number; name: string; staffPositions: Array<{id: number; name: string;}>;}) => {
+            let acc = byFranchiseId.get(row.id);
+            if (!acc) {
+                acc = {
+                    id: row.id,
+                    name: row.name,
+                    staffByCode: new Map(),
+                };
+                byFranchiseId.set(row.id, acc);
+            } else if (!acc.name && row.name) {
+                acc.name = row.name;
+            }
+            for (const sp of row.staffPositions) {
+                if (!acc.staffByCode.has(sp.name)) {
+                    acc.staffByCode.set(sp.name, sp);
+                }
+            }
+        };
+
+        for (const row of sprocket) {
+            mergeRow(row);
+        }
+        for (const row of mle) {
+            mergeRow(row);
+        }
+
+        return [...byFranchiseId.values()].map(acc => ({
+            id: acc.id,
+            name: acc.name,
+            staffPositions: [...acc.staffByCode.values()],
+        }));
+    }
+
     /**
      * Helper method to get franchises based on staff assignments
      * Used for FP/FA players and as a fallback when team franchise lookup fails

core/src/franchise/player/player.service.ts

@@ -52,6 +52,7 @@ import {MemberPlatformAccountService} from "../../organization/member-platform-a
 import {OrganizationService} from "../../organization";
 import {MemberService} from "../../organization/member/member.service";
 import {GameSkillGroupService} from "../game-skill-group";
+import {RosterAuthorityService} from "../roster-authority.service";
 import type {RankdownJwtPayload} from "./player.types";
 import type {CreatePlayerTuple} from "./player.types";
 
@@ -87,12 +88,23 @@ export class PlayerService {
     private readonly eloConnectorService: EloConnectorService,
     private readonly platformService: PlatformService,
     private readonly analyticsService: AnalyticsService,
+    private readonly rosterAuthorityService: RosterAuthorityService,
     @Inject(forwardRef(() => MemberPlatformAccountService))
     private readonly memberPlatformAccountService: MemberPlatformAccountService,
     @Inject(forwardRef(() => MledbPlayerAccountService))
     private readonly mledbPlayerAccountService: MledbPlayerAccountService,
     ) {}
 
+    private async syncRosterAuthorityAfterMleSave(mlePlayerId: number): Promise<void> {
+        try {
+            await this.rosterAuthorityService.syncFromMlePlayerId(mlePlayerId);
+        } catch (err) {
+            this.logger.warn(
+                `Roster authority sync failed for MLE player ${mlePlayerId}: ${err instanceof Error ? err.message : String(err)}`,
+            );
+        }
+    }
+
     async getPlayer(query: FindOneOptions<Player>): Promise<Player> {
         this.logger.debug(`getPlayer: ${JSON.stringify(query)}`);
         return this.playerRepository.findOneOrFail(query);
@@ -405,6 +417,11 @@ export class PlayerService {
                 throw new Error(`Tried updating player with MLEID: ${mleid}, but that MLEID does not yet exist.`);
             }
             await runner.commitTransaction();
+
+            const mleAfter = await this.mle_playerRepository.findOne({where: {mleid} });
+            if (mleAfter) {
+                await this.syncRosterAuthorityAfterMleSave(mleAfter.id);
+            }
         } catch (e) {
             await runner.rollbackTransaction();
             this.logger.error(e);
@@ -441,9 +458,10 @@ export class PlayerService {
         });
 
         if (runner) {
-            await runner.manager.save(player);
+            await runner.manager.save(MLE_Player, updatedPlayer);
         } else {
-            await this.mle_playerRepository.save(player);
+            await this.mle_playerRepository.save(updatedPlayer);
+            await this.syncRosterAuthorityAfterMleSave(updatedPlayer.id);
         }
 
         return updatedPlayer;
@@ -500,6 +518,7 @@ export class PlayerService {
             await runner.manager.save(ptpBridge);
         } else {
             await this.ptpRepo.save(ptpBridge);
+            await this.syncRosterAuthorityAfterMleSave(player.id);
         }
 
         return player;
@@ -854,6 +873,7 @@ export class PlayerService {
                 });
 
                 await this.mle_playerRepository.save(newMlePlayer);
+                await this.syncRosterAuthorityAfterMleSave(newMlePlayer.id);
 
                 this.logger.debug(`Player ${playerDelta.playerId}: Salary update complete`);
             }
@@ -908,6 +928,7 @@ export class PlayerService {
             const mlePlayer = await this.getMlePlayerBySprocketPlayer(sprocPlayerId);
             mlePlayer.salary = salary;
             await this.mle_playerRepository.save(mlePlayer);
+            await this.syncRosterAuthorityAfterMleSave(mlePlayer.id);
             return mlePlayer;
         }
 
@@ -938,6 +959,7 @@ export class PlayerService {
         }
 
         await this.mle_playerRepository.save(player);
+        await this.syncRosterAuthorityAfterMleSave(player.id);
 
         return player;
     }
@@ -973,6 +995,7 @@ export class PlayerService {
         });
 
         await this.mle_playerRepository.save(player);
+        await this.syncRosterAuthorityAfterMleSave(player.id);
 
         // Move player to Waiver Wire
         // TODO fix later when we abstract away from MLE
@@ -1020,6 +1043,7 @@ export class PlayerService {
         });
 
         await this.mle_playerRepository.save(player);
+        await this.syncRosterAuthorityAfterMleSave(player.id);
         return player;
     }
 
@@ -1342,6 +1366,19 @@ export class PlayerService {
             await runner.commitTransaction();
             this.logger.log(`Transaction committed successfully`);
 
+            const rlPlayers = await this.playerRepository.find({
+                where: {
+                    member: {user: {id: user.id} },
+                    skillGroup: {game: {id: 7} },
+                },
+            });
+            for (const pl of rlPlayers) {
+                const bridge = await this.ptpRepo.findOne({where: {sprocketPlayerId: pl.id} });
+                if (bridge) {
+                    await this.syncRosterAuthorityAfterMleSave(bridge.mledPlayerId);
+                }
+            }
+
             const result = `Successfully created/updated user with ID ${user.id}.`;
             this.logger.log(`=== INTAKE USER COMPLETED ===`);
             this.logger.log(`Result: ${result}`);
@@ -1406,6 +1443,7 @@ export class PlayerService {
         });
         mlePlayer.discordId = newAcct;
         await this.mle_playerRepository.save(mlePlayer);
+        await this.syncRosterAuthorityAfterMleSave(mlePlayer.id);
 
         // Then, follow up with Sprocket.
         const uaa = await this.userAuthRepository.findOneOrFail({
@@ -1425,6 +1463,7 @@ export class PlayerService {
         });
         mlePlayer.teamName = newTeam;
         await this.mle_playerRepository.save(mlePlayer);
+        await this.syncRosterAuthorityAfterMleSave(mlePlayer.id);
     }
 
     async changePlayerName(mleid: number, newName: string): Promise<void> {