brackt/app/routes/leagues/$leagueId.server.ts

import { getAuth } from "@clerk/react-router/server";
import {
  findLeagueById,
  findCurrentSeason,
  findTeamsBySeasonId,
  findCommissionersByLeagueId,
  isUserLeagueMember,
  isCommissioner,
  findUserByClerkId,
  findDraftSlotsBySeasonId,
} from "~/models";
import { findCurrentSeasonWithSports } from "~/models/season";
import type { Route } from "./+types/$leagueId";

export async function loader(args: Route.LoaderArgs) {
  const { userId } = await getAuth(args);
  const { params } = args;
  const { leagueId } = params;

  // Fetch league
  const league = await findLeagueById(leagueId);

  if (!league) {
    throw new Response("League not found", { status: 404 });
  }

  // Fetch current season with sports
  const seasonWithSports = await findCurrentSeasonWithSports(leagueId);
  const season = seasonWithSports || null;

  // Fetch commissioners
  const commissioners = await findCommissionersByLeagueId(leagueId);

  // Check if current user is a commissioner
  const isUserCommissioner = userId
    ? await isCommissioner(leagueId, userId)
    : false;

  // Check if user is a member (has a team in current season)
  const isUserMember = userId
    ? await isUserLeagueMember(leagueId, userId)
    : false;

  // Check access: user must be a commissioner, a member, or an admin
  // If not logged in or not authorized, throw 403
  if (!userId) {
    throw new Response("You must be logged in to view this league", {
      status: 401,
    });
  }

  if (!isUserCommissioner && !isUserMember) {
    throw new Response("You do not have access to this league", {
      status: 403,
    });
  }

  // Fetch teams for current season
  const teams = season ? await findTeamsBySeasonId(season.id) : [];

  // Fetch draft slots if season is in pre_draft or draft status
  const draftSlots =
    season && (season.status === "pre_draft" || season.status === "draft")
      ? await findDraftSlotsBySeasonId(season.id)
      : [];

  // Fetch user data for team owners
  const ownerIds = teams
    .map((t) => t.ownerId)
    .filter((id): id is string => id !== null);
  const uniqueOwnerIds = [...new Set(ownerIds)];
  const owners = await Promise.all(
    uniqueOwnerIds.map(async (ownerId) => {
      const user = await findUserByClerkId(ownerId);
      return user
        ? { clerkId: ownerId, name: user.username || user.displayName }
        : null;
    })
  );
  const ownerMap = new Map(
    owners
      .filter((o): o is NonNullable<typeof o> => o !== null)
      .map((o) => [o.clerkId, o.name])
  );

  // Fetch user data for commissioners
  const commissionerIds = commissioners.map((c) => c.userId);
  const commissionerUsers = await Promise.all(
    commissionerIds.map(async (commissionerId) => {
      const user = await findUserByClerkId(commissionerId);
      return user
        ? { clerkId: commissionerId, name: user.username || user.displayName }
        : null;
    })
  );
  const commissionerMap = new Map(
    commissionerUsers
      .filter((c): c is NonNullable<typeof c> => c !== null)
      .map((c) => [c.clerkId, c.name])
  );

  // Count available teams
  const availableTeamCount = teams.filter((t) => !t.ownerId).length;

  // Count teams with owners
  const teamsWithOwners = teams.filter((t) => t.ownerId !== null).length;

  // Get sports seasons data
  const sportsSeasons = seasonWithSports?.seasonSports?.map((ss) => ({
    id: ss.sportsSeason.id,
    name: ss.sportsSeason.name,
    status: ss.sportsSeason.status,
    scoringPattern: ss.sportsSeason.scoringPattern,
    sport: ss.sportsSeason.sport,
  })) || [];
  const sportsCount = sportsSeasons.length;

  // Check if draft order is set
  const isDraftOrderSet = draftSlots.length > 0;

  return {
    league,
    season,
    teams,
    commissioners,
    currentUserId: userId,
    isUserCommissioner,
    ownerMap: Object.fromEntries(ownerMap),
    commissionerMap: Object.fromEntries(commissionerMap),
    availableTeamCount,
    draftSlots,
    sportsCount,
    teamsWithOwners,
    isDraftOrderSet,
    sportsSeasons,
  };
}