[feat] Create resources for football: `format`, `state` and `event`

[majorbruteforce]

• Create independent entities FootballFormats, FootballStates and FootballEvents under base path /football
• The following additional endpoints are expected :
  • GET /:matchId/state : To fetch the latest match state
  • GET /:matchId/event?id=previousEventId : To fetch the most recent event next to the passed event (get most recent if nothing is passed)
  • GET /:matchId/event-series?id=previousEventId : To fetch all the events for the match sorted in descending order of time after the event with id previousEventId. (get all if nothing is passed)
  • POST /:matchId/event : To post a new event.
  • PATCH /event/:eventId : To patch a created event
  • DELETE /event/:eventId : To delete a created event

NOTE: Comment the schema for the three entities in the same thread.

[iamanishx]

event.schema.ts

import { Document } from 'mongoose';

// Common interfaces
interface Player {
  name: string;
  number: number;
}

interface Assist extends Player {}

// Event-specific detail interfaces
interface GoalDetails {
  team: string;
  scorer: Player & { assist?: Assist };
  minute: number;
  description: string;
}

interface SubstitutionDetails {
  team: string;
  outPlayer: Player;
  inPlayer: Player;
  minute: number;
}

interface FoulDetails {
  team: string;
  player: Player;
  type: string;
  card: 'yellow' | 'red' | 'none';
  minute: number;
}

interface InjuryDetails {
  team: string;
  player: Player;
  severity: 'minor' | 'moderate' | 'severe';
  minute: number;
}

interface PenaltyDetails {
  team: string;
  player: Player;
  success: boolean;
  minute: number;
}

interface VarDetails {
  incident: string;
  team: string;
  player: Player;
  decision: string;
  minute: number;
}

type EventDetails =
  | GoalDetails
  | SubstitutionDetails
  | FoulDetails
  | InjuryDetails
  | PenaltyDetails
  | VarDetails;

@Schema({ timestamps: true })
export class MatchEvent extends Document {
  @Prop({
    required: true,
    enum: ['goal', 'substitution', 'foul', 'injury', 'penalty', 'var_decision'],
  })
  type: string;

  @Prop({ type: Object, required: true })
  details: EventDetails;

  @Prop({ required: true })
  timestamp: Date;

  @Prop({ required: true })
  matchId: string;
}

export const MatchEventSchema = SchemaFactory.createForClass(MatchEvent);
`

[iamanishx]

match-format.schema.ts

import { Document } from 'mongoose';

interface PenaltyAction {
  type: string;
  penalty: string;
  description: string;
}

interface ExtraAction {
  type: string;
  opportunity: string;
  description: string;
}

interface ExtraTime {
  isDraw: boolean;
  description: string;
}

@Schema({ timestamps: true })
export class MatchFormat extends Document {
  @Prop({ required: true })
  totalDuration: number;

  @Prop({ required: true })
  halfTimeDuration: number;

  @Prop({ required: true })
  totalHalves: number;

  @Prop({ required: true })
  penaltyShootoutMaxAttempts: number;

  @Prop({ type: [Object], required: true })
  penaltyActions: PenaltyAction[];

  @Prop({ type: [Object], required: true })
  extraActions: ExtraAction[];

  @Prop({ type: Object, required: true })
  applyExtraTime: ExtraTime;
}

export const MatchFormatSchema = SchemaFactory.createForClass(MatchFormat);
`

[iamanishx]

states.schema.ts

import { Document } from 'mongoose';

// Interfaces for nested structures
interface Score {
  home: number;
  away: number;
}

interface Scorer {
  name: string;
  number: number;
  assist?: {
    name: string;
    number: number;
  };
}

interface Event {
  timestamp: string;
  type: string;
  team: string;
  scorer?: Scorer;
  minute: number;
  description: string;
}

interface Period {
  startTime: string;
  endTime: string;
  score: Score;
  possession: string;
  addedTime?: number;
  events: Event[];
  status: string;
}

interface ExtraTimePeriod {
  startTime: string;
  endTime: string;
  score: Score;
  possession: string;
  events: Event[];
  status: string;
}

interface PenaltyShot {
  player: string;
  success: boolean;
}

interface PlayerStats {
  saves?: number;
  cleanSheets?: number;
  passes?: number;
  passAccuracy?: number;
}

interface Player {
  name: string;
  number: number;
  position: string;
  status: string;
  stats?: PlayerStats;
  cards?: string[];
}

interface TeamCards {
  yellow: number;
  red: number;
}

interface TeamStats {
  possession: number;
  shots: {
    total: number;
    onTarget: number;
    blocked: number;
    woodwork: number;
  };
  corners: number;
  fouls: number;
  passes: {
    total: number;
    completed: number;
    accuracy: number;
  };
  offsides: number;
}

@Schema({ timestamps: true })
export class MatchState extends Document {
  @Prop({
    type: {
      first: {
        type: Object,
        required: true,
      },
      second: {
        type: Object,
        required: true,
      },
      extraTime: {
        firstHalf: { type: Object },
        secondHalf: { type: Object },
      },
      penalties: {
        home: [{ player: String, success: Boolean }],
        away: [{ player: String, success: Boolean }],
        outcome: String,
        score: { home: Number, away: Number },
      },
    },
    required: true,
  })
  periods: {
    first: Period;
    second: Period;
    extraTime?: {
      firstHalf: ExtraTimePeriod;
      secondHalf: ExtraTimePeriod;
    };
    penalties?: {
      home: PenaltyShot[];
      away: PenaltyShot[];
      outcome: string;
      score: Score;
    };
  };

  @Prop({
    type: {
      home: {
        name: String,
        formation: String,
        captain: String,
        lineup: [Object],
        substitutes: [Object],
        substitutionsLeft: Number,
        cards: Object,
        injuries: [String],
      },
      away: {
        name: String,
        formation: String,
        captain: String,
        lineup: [Object],
        substitutes: [Object],
        substitutionsLeft: Number,
        cards: Object,
        injuries: [String],
      },
    },
    required: true,
  })
  teams: {
    home: {
      name: string;
      formation: string;
      captain: string;
      lineup: Player[];
      substitutes: Player[];
      substitutionsLeft: number;
      cards: TeamCards;
      injuries: string[];
    };
    away: {
      name: string;
      formation: string;
      captain: string;
      lineup: Player[];
      substitutes: Player[];
      substitutionsLeft: number;
      cards: TeamCards;
      injuries: string[];
    };
  };

  @Prop({
    type: {
      id: String,
      competition: String,
      venue: {
        name: String,
        city: String,
      },
      officials: {
        referee: String,
        assistants: [String],
        fourthOfficial: String,
        var: {
          referee: String,
          assistant: String,
        },
      },
      weather: {
        condition: String,
        temperature: Number,
      },
      status: String,
      minute: Number,
    },
    required: true,
  })
  match: {
    id: string;
    competition: string;
    venue: {
      name: string;
      city: string;
    };
    officials: {
      referee: string;
      assistants: string[];
      fourthOfficial: string;
      var: {
        referee: string;
        assistant: string;
      };
    };
    weather: {
      condition: string;
      temperature: number;
    };
    status: string;
    minute: number;
  };

  @Prop({
    type: {
      home: Object,
      away: Object,
    },
    required: true,
  })
  stats: {
    home: TeamStats;
    away: TeamStats;
  };

  @Prop({
    type: {
      winner: String,
      type: String,
      score: {
        home: Number,
        away: Number,
      },
    },
    required: true,
  })
  matchOutcome: {
    winner: string;
    type: string;
    score: Score;
  };
}

export const MatchStateSchema = SchemaFactory.createForClass(MatchState);

// match-state.dto.ts
import { z } from 'zod';

const ScoreSchema = z.object({
  home: z.number(),
  away: z.number(),
});

const AssistSchema = z.object({
  name: z.string(),
  number: z.number(),
});

const ScorerSchema = z.object({
  name: z.string(),
  number: z.number(),
  assist: AssistSchema.optional(),
});

const EventSchema = z.object({
  timestamp: z.string(),
  type: z.string(),
  team: z.string(),
  scorer: ScorerSchema.optional(),
  minute: z.number(),
  description: z.string(),
});

const PeriodSchema = z.object({
  startTime: z.string(),
  endTime: z.string(),
  score: ScoreSchema,
  possession: z.string(),
  addedTime: z.number().optional(),
  events: z.array(EventSchema),
  status: z.string(),
});

const PenaltyShotSchema = z.object({
  player: z.string(),
  success: z.boolean(),
});

const PlayerStatsSchema = z.object({
  saves: z.number().optional(),
  cleanSheets: z.number().optional(),
  passes: z.number().optional(),
  passAccuracy: z.number().optional(),
});

const PlayerSchema = z.object({
  name: z.string(),
  number: z.number(),
  position: z.string(),
  status: z.string(),
  stats: PlayerStatsSchema.optional(),
  cards: z.array(z.string()).optional(),
});

const TeamCardsSchema = z.object({
  yellow: z.number(),
  red: z.number(),
});

const TeamStatsSchema = z.object({
  possession: z.number(),
  shots: z.object({
    total: z.number(),
    onTarget: z.number(),
    blocked: z.number(),
    woodwork: z.number(),
  }),
  corners: z.number(),
  fouls: z.number(),
  passes: z.object({
    total: z.number(),
    completed: z.number(),
    accuracy: z.number(),
  }),
  offsides: z.number(),
});

export const CreateMatchStateDto = z.object({
  periods: z.object({
    first: PeriodSchema,
    second: PeriodSchema,
    extraTime: z
      .object({
        firstHalf: PeriodSchema,
        secondHalf: PeriodSchema,
      })
      .optional(),
    penalties: z
      .object({
        home: z.array(PenaltyShotSchema),
        away: z.array(PenaltyShotSchema),
        outcome: z.string(),
        score: ScoreSchema,
      })
      .optional(),
  }),
  teams: z.object({
    home: z.object({
      name: z.string(),
      formation: z.string(),
      captain: z.string(),
      lineup: z.array(PlayerSchema),
      substitutes: z.array(PlayerSchema),
      substitutionsLeft: z.number(),
      cards: TeamCardsSchema,
      injuries: z.array(z.string()),
    }),
    away: z.object({
      name: z.string(),
      formation: z.string(),
      captain: z.string(),
      lineup: z.array(PlayerSchema),
      substitutes: z.array(PlayerSchema),
      substitutionsLeft: z.number(),
      cards: TeamCardsSchema,
      injuries: z.array(z.string()),
    }),
  }),
  match: z.object({
    id: z.string(),
    competition: z.string(),
    venue: z.object({
      name: z.string(),
      city: z.string(),
    }),
    officials: z.object({
      referee: z.string(),
      assistants: z.array(z.string()),
      fourthOfficial: z.string(),
      var: z.object({
        referee: z.string(),
        assistant: z.string(),
      }),
    }),
    weather: z.object({
      condition: z.string(),
      temperature: z.number(),
    }),
    status: z.string(),
    minute: z.number(),
  }),
  stats: z.object({
    home: TeamStatsSchema,
    away: TeamStatsSchema,
  }),
  matchOutcome: z.object({
    winner: z.string(),
    type: z.string(),
    score: ScoreSchema,
  }),
});

export type CreateMatchStateDtoType = z.infer<typeof CreateMatchStateDto>;
`