ballrush-core 0.5.0 → 0.5.2

package/dist/mongo/index.d.ts

@@ -7,3 +7,6 @@ export * from "./schemas/stat-group-profile.schema";
 export * from "./schemas/stat-group-season.schema";
 export * from "./schemas/stat-group-last-100-games.schema";
 export * from "./schemas/stat-group-activity-chart.schema";
+export * from "./schemas/stat-user-profile.schema";
+export * from "./schemas/stat-user-match-history.schema";
+export * from "./schemas/stat-event.schema";

package/dist/mongo/index.js

@@ -23,3 +23,6 @@ __exportStar(require("./schemas/stat-group-profile.schema"), exports);
 __exportStar(require("./schemas/stat-group-season.schema"), exports);
 __exportStar(require("./schemas/stat-group-last-100-games.schema"), exports);
 __exportStar(require("./schemas/stat-group-activity-chart.schema"), exports);
+__exportStar(require("./schemas/stat-user-profile.schema"), exports);
+__exportStar(require("./schemas/stat-user-match-history.schema"), exports);
+__exportStar(require("./schemas/stat-event.schema"), exports);

package/dist/mongo/schemas/stat-event.schema.d.ts

@@ -0,0 +1,96 @@
+import { Schema } from "mongoose";
+/**
+ * Mongoose document interface for StatEventPlayer
+ */
+export interface StatEventPlayerDoc {
+    userId: number;
+    playerName: string;
+    avatarUrl: string;
+    position: string;
+}
+/**
+ * Mongoose document interface for StatEventTeam
+ */
+export interface StatEventTeamDoc {
+    teamId: number;
+    teamName: string;
+    totalPoints: number;
+    avgTeamRating: number;
+    players: StatEventPlayerDoc[];
+}
+/**
+ * Mongoose document interface for StatEventStandingsRow
+ */
+export interface StatEventStandingsRowDoc {
+    rank: number;
+    teamName: string;
+    played: number;
+    wins: number;
+    draws: number;
+    losses: number;
+    goalsFor: number;
+    goalsAgainst: number;
+    goalDifference: number;
+    points: number;
+}
+/**
+ * Mongoose document interface for StatEventMatch
+ */
+export interface StatEventMatchDoc {
+    matchId: number;
+    matchNumber: number;
+    time: string;
+    status: string;
+    team1Name: string;
+    team1Score: number;
+    team2Name: string;
+    team2Score: number;
+}
+/**
+ * Mongoose document interface for StatEventHeader
+ */
+export interface StatEventHeaderDoc {
+    status: 'Finished' | 'In Progress' | 'Upcoming';
+    seasonName: string;
+    groupName: string;
+    eventName: string;
+    date: Date;
+    timeRange: string;
+    location: string;
+    winnerName: string | null;
+}
+/**
+ * Mongoose document interface for StatEventOverviewStats
+ */
+export interface StatEventOverviewStatsDoc {
+    totalGoals: number;
+    goalsPerMatch: number;
+}
+/**
+ * Mongoose document interface for StatEventOverview
+ */
+export interface StatEventOverviewDoc {
+    stats: StatEventOverviewStatsDoc;
+    standings: StatEventStandingsRowDoc[];
+    teams: StatEventTeamDoc[];
+}
+/**
+ * Mongoose document interface for StatEvent
+ */
+export interface StatEventDoc {
+    eventId: number;
+    header: StatEventHeaderDoc;
+    overview: StatEventOverviewDoc;
+    matches: StatEventMatchDoc[];
+    calculatedAt: Date;
+    version: number;
+}
+/**
+ * Factory function to create StatEvent schema
+ * Collection: stat_events
+ */
+export declare function createStatEventSchema(): Schema<StatEventDoc, import("mongoose").Model<StatEventDoc, any, any, any, import("mongoose").Document<unknown, any, StatEventDoc> & StatEventDoc & {
+    _id: import("mongoose").Types.ObjectId;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, StatEventDoc, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<StatEventDoc>> & import("mongoose").FlatRecord<StatEventDoc> & {
+    _id: import("mongoose").Types.ObjectId;
+}>;

package/dist/mongo/schemas/stat-event.schema.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStatEventSchema = createStatEventSchema;
+const mongoose_1 = require("mongoose");
+/**
+ * Factory function to create StatEvent schema
+ * Collection: stat_events
+ */
+function createStatEventSchema() {
+    const PlayerSchema = new mongoose_1.Schema({
+        userId: { type: Number, required: true },
+        playerName: { type: String, required: true },
+        avatarUrl: { type: String, required: true },
+        position: { type: String, required: true },
+    }, { _id: false });
+    const TeamSchema = new mongoose_1.Schema({
+        teamId: { type: Number, required: true },
+        teamName: { type: String, required: true },
+        totalPoints: { type: Number, required: true, min: 0, default: 0 },
+        avgTeamRating: { type: Number, required: true, min: 0, default: 0 },
+        players: { type: [PlayerSchema], default: [] },
+    }, { _id: false });
+    const StandingsRowSchema = new mongoose_1.Schema({
+        rank: { type: Number, required: true, min: 1 },
+        teamName: { type: String, required: true },
+        played: { type: Number, required: true, min: 0, default: 0 },
+        wins: { type: Number, required: true, min: 0, default: 0 },
+        draws: { type: Number, required: true, min: 0, default: 0 },
+        losses: { type: Number, required: true, min: 0, default: 0 },
+        goalsFor: { type: Number, required: true, min: 0, default: 0 },
+        goalsAgainst: { type: Number, required: true, min: 0, default: 0 },
+        goalDifference: { type: Number, required: true, default: 0 },
+        points: { type: Number, required: true, min: 0, default: 0 },
+    }, { _id: false });
+    const MatchSchema = new mongoose_1.Schema({
+        matchId: { type: Number, required: true },
+        matchNumber: { type: Number, required: true, min: 1 },
+        time: { type: String, required: true },
+        status: { type: String, required: true },
+        team1Name: { type: String, required: true },
+        team1Score: { type: Number, required: true, min: 0, default: 0 },
+        team2Name: { type: String, required: true },
+        team2Score: { type: Number, required: true, min: 0, default: 0 },
+    }, { _id: false });
+    const HeaderSchema = new mongoose_1.Schema({
+        status: { type: String, enum: ['Finished', 'In Progress', 'Upcoming'], required: true },
+        seasonName: { type: String, required: true },
+        groupName: { type: String, required: true },
+        eventName: { type: String, required: true },
+        date: { type: Date, required: true },
+        timeRange: { type: String, required: true },
+        location: { type: String, required: true },
+        winnerName: { type: String, default: null },
+    }, { _id: false });
+    const OverviewStatsSchema = new mongoose_1.Schema({
+        totalGoals: { type: Number, required: true, min: 0, default: 0 },
+        goalsPerMatch: { type: Number, required: true, min: 0, default: 0 },
+    }, { _id: false });
+    const OverviewSchema = new mongoose_1.Schema({
+        stats: { type: OverviewStatsSchema, required: true },
+        standings: { type: [StandingsRowSchema], default: [] },
+        teams: { type: [TeamSchema], default: [] },
+    }, { _id: false });
+    const StatEventSchema = new mongoose_1.Schema({
+        eventId: { type: Number, required: true, unique: true, index: true },
+        header: { type: HeaderSchema, required: true },
+        overview: { type: OverviewSchema, required: true },
+        matches: { type: [MatchSchema], default: [] },
+        calculatedAt: { type: Date, default: Date.now },
+        version: { type: Number, required: true, default: 1, min: 1 },
+    }, {
+        collection: 'stat_events',
+        versionKey: false,
+    });
+    // Index for fast lookup by eventId
+    StatEventSchema.index({ eventId: 1 }, { unique: true });
+    // Index for cache invalidation by calculatedAt
+    StatEventSchema.index({ calculatedAt: -1 });
+    return StatEventSchema;
+}

package/dist/mongo/schemas/stat-user-match-history.schema.d.ts

@@ -0,0 +1,24 @@
+import { Schema } from "mongoose";
+/**
+ * Mongoose document interface for StatUserMatchHistory
+ */
+export interface StatUserMatchHistoryDoc {
+    userId: number;
+    groupId: number;
+    eventId: number;
+    result: 'Win' | 'Loss' | 'Draw';
+    matchup: string;
+    score: string;
+    date: Date;
+    seasonName: string;
+    createdAt: Date;
+}
+/**
+ * Factory function to create StatUserMatchHistory schema
+ * Collection: stat_user_match_history
+ */
+export declare function createStatUserMatchHistorySchema(): Schema<StatUserMatchHistoryDoc, import("mongoose").Model<StatUserMatchHistoryDoc, any, any, any, import("mongoose").Document<unknown, any, StatUserMatchHistoryDoc> & StatUserMatchHistoryDoc & {
+    _id: import("mongoose").Types.ObjectId;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, StatUserMatchHistoryDoc, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<StatUserMatchHistoryDoc>> & import("mongoose").FlatRecord<StatUserMatchHistoryDoc> & {
+    _id: import("mongoose").Types.ObjectId;
+}>;

package/dist/mongo/schemas/stat-user-match-history.schema.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStatUserMatchHistorySchema = createStatUserMatchHistorySchema;
+const mongoose_1 = require("mongoose");
+/**
+ * Factory function to create StatUserMatchHistory schema
+ * Collection: stat_user_match_history
+ */
+function createStatUserMatchHistorySchema() {
+    const StatUserMatchHistorySchema = new mongoose_1.Schema({
+        userId: { type: Number, required: true, index: true },
+        groupId: { type: Number, required: true, index: true },
+        eventId: { type: Number, required: true },
+        result: { type: String, enum: ['Win', 'Loss', 'Draw'], required: true },
+        matchup: { type: String, required: true },
+        score: { type: String, required: true },
+        date: { type: Date, required: true },
+        seasonName: { type: String, required: true },
+        createdAt: { type: Date, default: Date.now },
+    }, {
+        collection: 'stat_user_match_history',
+        versionKey: false,
+    });
+    // Compound index for efficient queries (userId + groupId + date DESC)
+    StatUserMatchHistorySchema.index({ userId: 1, groupId: 1, date: -1 });
+    // Compound index for season filtering (userId + groupId + seasonName + date DESC)
+    StatUserMatchHistorySchema.index({ userId: 1, groupId: 1, seasonName: 1, date: -1 });
+    return StatUserMatchHistorySchema;
+}

package/dist/mongo/schemas/stat-user-profile.schema.d.ts

@@ -0,0 +1,51 @@
+import { Schema } from "mongoose";
+/**
+ * Mongoose sub-schema for SkillHistoryPoint
+ */
+export interface SkillHistoryPointDoc {
+    date: Date;
+    earnedRating: number | null;
+    manualAdjustment: number | null;
+}
+/**
+ * Mongoose sub-schema for ProfileAchievement
+ */
+export interface ProfileAchievementDoc {
+    icon: string;
+    name: string;
+    description: string;
+    count: number;
+}
+/**
+ * Mongoose document interface for StatUserProfile
+ */
+export interface StatUserProfileDoc {
+    userId: number;
+    groupId: number;
+    username: string;
+    fullName: string;
+    avatarUrl: string;
+    position: string;
+    currentSkillRating: number;
+    groupName: string;
+    gamesCount: number;
+    wins: number;
+    losses: number;
+    draws: number;
+    winPercentage: number;
+    goalsFor: number;
+    goalsAgainst: number;
+    eventsCount: number;
+    skillHistory: SkillHistoryPointDoc[];
+    achievements: ProfileAchievementDoc[];
+    lastUpdated: Date;
+}
+/**
+ * Factory function to create StatUserProfile schema
+ * Collection: stat_user_profile
+ */
+export declare function createStatUserProfileSchema(): Schema<StatUserProfileDoc, import("mongoose").Model<StatUserProfileDoc, any, any, any, import("mongoose").Document<unknown, any, StatUserProfileDoc> & StatUserProfileDoc & {
+    _id: import("mongoose").Types.ObjectId;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, StatUserProfileDoc, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<StatUserProfileDoc>> & import("mongoose").FlatRecord<StatUserProfileDoc> & {
+    _id: import("mongoose").Types.ObjectId;
+}>;

package/dist/mongo/schemas/stat-user-profile.schema.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStatUserProfileSchema = createStatUserProfileSchema;
+const mongoose_1 = require("mongoose");
+/**
+ * Factory function to create StatUserProfile schema
+ * Collection: stat_user_profile
+ */
+function createStatUserProfileSchema() {
+    const SkillHistoryPointSchema = new mongoose_1.Schema({
+        date: { type: Date, required: true },
+        earnedRating: { type: Number, default: null },
+        manualAdjustment: { type: Number, default: null },
+    }, { _id: false });
+    const ProfileAchievementSchema = new mongoose_1.Schema({
+        icon: { type: String, required: true },
+        name: { type: String, required: true },
+        description: { type: String, required: true },
+        count: { type: Number, required: true, min: 0, default: 0 },
+    }, { _id: false });
+    const StatUserProfileSchema = new mongoose_1.Schema({
+        userId: { type: Number, required: true, index: true },
+        groupId: { type: Number, required: true, index: true },
+        username: { type: String, required: true },
+        fullName: { type: String, required: true },
+        avatarUrl: { type: String, default: '' },
+        position: { type: String, default: '' },
+        currentSkillRating: { type: Number, required: true, default: 0 },
+        groupName: { type: String, required: true },
+        gamesCount: { type: Number, required: true, min: 0, default: 0 },
+        wins: { type: Number, required: true, min: 0, default: 0 },
+        losses: { type: Number, required: true, min: 0, default: 0 },
+        draws: { type: Number, required: true, min: 0, default: 0 },
+        winPercentage: { type: Number, required: true, min: 0, max: 100, default: 0 },
+        goalsFor: { type: Number, required: true, min: 0, default: 0 },
+        goalsAgainst: { type: Number, required: true, min: 0, default: 0 },
+        eventsCount: { type: Number, required: true, min: 0, default: 0 },
+        skillHistory: { type: [SkillHistoryPointSchema], default: [] },
+        achievements: { type: [ProfileAchievementSchema], default: [] },
+        lastUpdated: { type: Date, default: Date.now },
+    }, {
+        collection: 'stat_user_profile',
+        versionKey: false,
+    });
+    // Create compound unique index for userId + groupId
+    StatUserProfileSchema.index({ userId: 1, groupId: 1 }, { unique: true });
+    return StatUserProfileSchema;
+}

package/dist/ports/index.d.ts

@@ -7,3 +7,6 @@ export * from "./stat-group-profile.repository";
 export * from "./stat-group-season.repository";
 export * from "./stat-group-last-100-games.repository";
 export * from "./stat-group-activity-chart.repository";
+export * from "./stat-user-profile.repository";
+export * from "./stat-user-match-history.repository";
+export * from "./stat-event.repository";

package/dist/ports/index.js

@@ -23,3 +23,6 @@ __exportStar(require("./stat-group-profile.repository"), exports);
 __exportStar(require("./stat-group-season.repository"), exports);
 __exportStar(require("./stat-group-last-100-games.repository"), exports);
 __exportStar(require("./stat-group-activity-chart.repository"), exports);
+__exportStar(require("./stat-user-profile.repository"), exports);
+__exportStar(require("./stat-user-match-history.repository"), exports);
+__exportStar(require("./stat-event.repository"), exports);

package/dist/ports/stat-event.repository.d.ts

@@ -0,0 +1,14 @@
+import { StatEvent } from "../types/stat-event.types";
+/**
+ * Repository interface for StatEvent
+ * Provides pre-aggregated event data including standings, statistics,
+ * and enriched rosters/matches for the Event Page
+ */
+export interface StatEventRepository {
+    /**
+     * Finds complete event data by event ID
+     * @param eventId - The event ID
+     * @returns Complete event data or null if not found
+     */
+    findEventById(eventId: number): Promise<StatEvent | null>;
+}

package/dist/ports/stat-event.repository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ports/stat-user-match-history.repository.d.ts

@@ -0,0 +1,19 @@
+import { StatUserMatchHistory, MatchHistoryFilter, MatchHistoryOptions, MatchHistoryResult } from "../types/stat-user-match-history.types";
+/**
+ * Repository interface for StatUserMatchHistory
+ * Provides paginated and filterable match history data
+ */
+export interface StatUserMatchHistoryRepository {
+    /**
+     * Find paginated match history for a user in a group
+     * @param filter - User ID, group ID, and optional season filter
+     * @param options - Pagination options
+     * @returns Paginated match history with metadata
+     */
+    find(filter: MatchHistoryFilter, options: MatchHistoryOptions): Promise<MatchHistoryResult>;
+    /**
+     * Create a new match history item
+     * @param item - Match history item to save
+     */
+    create(item: StatUserMatchHistory): Promise<void>;
+}

package/dist/ports/stat-user-match-history.repository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ports/stat-user-profile.repository.d.ts

@@ -0,0 +1,20 @@
+import { StatUserProfile } from "../types/stat-user-profile.types";
+/**
+ * Repository interface for StatUserProfile
+ * Provides pre-aggregated user profile data including basic info,
+ * statistics, skill history, and achievements
+ */
+export interface StatUserProfileRepository {
+    /**
+     * Find user profile data for a specific user in a specific group
+     * @param userId - User ID
+     * @param groupId - Group ID
+     * @returns User profile data or null if not found
+     */
+    findByUserAndGroup(userId: number, groupId: number): Promise<StatUserProfile | null>;
+    /**
+     * Create or update user profile data
+     * @param profile - User profile data to save
+     */
+    save(profile: StatUserProfile): Promise<void>;
+}

package/dist/ports/stat-user-profile.repository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/repositories/index.d.ts

@@ -7,3 +7,6 @@ export * from "./mongo/stat-group-profile.repository";
 export * from "./mongo/stat-group-season.repository";
 export * from "./mongo/stat-group-last-100-games.repository";
 export * from "./mongo/stat-group-activity-chart.repository";
+export * from "./mongo/stat-user-profile.repository";
+export * from "./mongo/stat-user-match-history.repository";
+export * from "./mongo/stat-event.repository";

package/dist/repositories/index.js

@@ -23,3 +23,6 @@ __exportStar(require("./mongo/stat-group-profile.repository"), exports);
 __exportStar(require("./mongo/stat-group-season.repository"), exports);
 __exportStar(require("./mongo/stat-group-last-100-games.repository"), exports);
 __exportStar(require("./mongo/stat-group-activity-chart.repository"), exports);
+__exportStar(require("./mongo/stat-user-profile.repository"), exports);
+__exportStar(require("./mongo/stat-user-match-history.repository"), exports);
+__exportStar(require("./mongo/stat-event.repository"), exports);

package/dist/repositories/mongo/stat-event.repository.d.ts

@@ -0,0 +1,13 @@
+import type { Model } from "mongoose";
+import type { StatEventRepository } from "../../ports/stat-event.repository";
+import type { StatEventDoc } from "../../mongo/schemas/stat-event.schema";
+import type { StatEvent } from "../../types/stat-event.types";
+/**
+ * MongoDB implementation of StatEventRepository
+ * Provides read-only access to pre-aggregated event data
+ */
+export declare class MongoStatEventRepository implements StatEventRepository {
+    private readonly model;
+    constructor(model: Model<StatEventDoc>);
+    findEventById(eventId: number): Promise<StatEvent | null>;
+}

package/dist/repositories/mongo/stat-event.repository.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoStatEventRepository = void 0;
+const errors_1 = require("../../errors");
+/**
+ * MongoDB implementation of StatEventRepository
+ * Provides read-only access to pre-aggregated event data
+ */
+class MongoStatEventRepository {
+    constructor(model) {
+        this.model = model;
+    }
+    async findEventById(eventId) {
+        try {
+            // Validate input
+            if (!eventId || eventId === 0) {
+                throw new errors_1.ValidationError('StatEvent', 'eventId', eventId, 'must be a non-zero number');
+            }
+            // Find event by ID
+            const doc = await this.model
+                .findOne({ eventId })
+                .lean();
+            if (!doc) {
+                return null;
+            }
+            // Map document to domain type
+            return {
+                eventId: doc.eventId,
+                header: {
+                    status: doc.header.status,
+                    seasonName: doc.header.seasonName,
+                    groupName: doc.header.groupName,
+                    eventName: doc.header.eventName,
+                    date: doc.header.date,
+                    timeRange: doc.header.timeRange,
+                    location: doc.header.location,
+                    winnerName: doc.header.winnerName,
+                },
+                overview: {
+                    stats: {
+                        totalGoals: doc.overview.stats.totalGoals,
+                        goalsPerMatch: doc.overview.stats.goalsPerMatch,
+                    },
+                    standings: doc.overview.standings.map(s => ({
+                        rank: s.rank,
+                        teamName: s.teamName,
+                        played: s.played,
+                        wins: s.wins,
+                        draws: s.draws,
+                        losses: s.losses,
+                        goalsFor: s.goalsFor,
+                        goalsAgainst: s.goalsAgainst,
+                        goalDifference: s.goalDifference,
+                        points: s.points,
+                    })),
+                    teams: doc.overview.teams.map(t => ({
+                        teamId: t.teamId,
+                        teamName: t.teamName,
+                        totalPoints: t.totalPoints,
+                        avgTeamRating: t.avgTeamRating,
+                        players: t.players.map(p => ({
+                            userId: p.userId,
+                            playerName: p.playerName,
+                            avatarUrl: p.avatarUrl,
+                            position: p.position,
+                        })),
+                    })),
+                },
+                matches: doc.matches.map(m => ({
+                    matchId: m.matchId,
+                    matchNumber: m.matchNumber,
+                    time: m.time,
+                    status: m.status,
+                    team1Name: m.team1Name,
+                    team1Score: m.team1Score,
+                    team2Name: m.team2Name,
+                    team2Score: m.team2Score,
+                })),
+                calculatedAt: doc.calculatedAt,
+                version: doc.version,
+            };
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('findEventById', 'StatEvent', eventId, error);
+        }
+    }
+}
+exports.MongoStatEventRepository = MongoStatEventRepository;

package/dist/repositories/mongo/stat-user-match-history.repository.d.ts

@@ -0,0 +1,14 @@
+import type { Model } from "mongoose";
+import type { StatUserMatchHistoryRepository } from "../../ports/stat-user-match-history.repository";
+import type { StatUserMatchHistoryDoc } from "../../mongo/schemas/stat-user-match-history.schema";
+import type { StatUserMatchHistory, MatchHistoryFilter, MatchHistoryOptions, MatchHistoryResult } from "../../types/stat-user-match-history.types";
+/**
+ * MongoDB implementation of StatUserMatchHistoryRepository
+ * Provides paginated and filterable match history data
+ */
+export declare class MongoStatUserMatchHistoryRepository implements StatUserMatchHistoryRepository {
+    private readonly model;
+    constructor(model: Model<StatUserMatchHistoryDoc>);
+    find(filter: MatchHistoryFilter, options: MatchHistoryOptions): Promise<MatchHistoryResult>;
+    create(item: StatUserMatchHistory): Promise<void>;
+}

package/dist/repositories/mongo/stat-user-match-history.repository.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoStatUserMatchHistoryRepository = void 0;
+const errors_1 = require("../../errors");
+/**
+ * MongoDB implementation of StatUserMatchHistoryRepository
+ * Provides paginated and filterable match history data
+ */
+class MongoStatUserMatchHistoryRepository {
+    constructor(model) {
+        this.model = model;
+    }
+    async find(filter, options) {
+        try {
+            // Validate input
+            if (!filter.userId || filter.userId === 0) {
+                throw new errors_1.ValidationError('StatUserMatchHistory', 'userId', filter.userId, 'must be a non-zero number');
+            }
+            if (!filter.groupId || filter.groupId === 0) {
+                throw new errors_1.ValidationError('StatUserMatchHistory', 'groupId', filter.groupId, 'must be a non-zero number');
+            }
+            if (!options.page || options.page < 1) {
+                throw new errors_1.ValidationError('StatUserMatchHistory', 'page', options.page, 'must be at least 1');
+            }
+            if (!options.limit || options.limit < 1) {
+                throw new errors_1.ValidationError('StatUserMatchHistory', 'limit', options.limit, 'must be at least 1');
+            }
+            // Build query
+            const query = {
+                userId: filter.userId,
+                groupId: filter.groupId,
+            };
+            // Add season filter if not "All Seasons"
+            if (filter.season && filter.season !== 'All Seasons') {
+                query.seasonName = filter.season;
+            }
+            // Count total matches
+            const totalMatches = await this.model.countDocuments(query);
+            // Calculate pagination
+            const totalPages = Math.ceil(totalMatches / options.limit);
+            const skip = (options.page - 1) * options.limit;
+            // Fetch paginated results (sorted by date DESC)
+            const docs = await this.model
+                .find(query)
+                .sort({ date: -1 })
+                .skip(skip)
+                .limit(options.limit)
+                .lean();
+            // Map documents to domain types
+            const matches = docs.map(doc => ({
+                userId: doc.userId,
+                groupId: doc.groupId,
+                eventId: doc.eventId,
+                result: doc.result,
+                matchup: doc.matchup,
+                score: doc.score,
+                date: doc.date,
+                seasonName: doc.seasonName,
+                createdAt: doc.createdAt,
+            }));
+            return {
+                matches,
+                totalMatches,
+                totalPages,
+                currentPage: options.page,
+            };
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('find', 'StatUserMatchHistory', `${filter.userId}:${filter.groupId}`, error);
+        }
+    }
+    async create(item) {
+        try {
+            // Validate input
+            if (!item.userId || item.userId === 0) {
+                throw new errors_1.ValidationError('StatUserMatchHistory', 'userId', item.userId, 'must be a non-zero number');
+            }
+            if (!item.groupId || item.groupId === 0) {
+                throw new errors_1.ValidationError('StatUserMatchHistory', 'groupId', item.groupId, 'must be a non-zero number');
+            }
+            if (!item.eventId || item.eventId === 0) {
+                throw new errors_1.ValidationError('StatUserMatchHistory', 'eventId', item.eventId, 'must be a non-zero number');
+            }
+            // Create new match history item
+            await this.model.create({
+                userId: item.userId,
+                groupId: item.groupId,
+                eventId: item.eventId,
+                result: item.result,
+                matchup: item.matchup,
+                score: item.score,
+                date: item.date,
+                seasonName: item.seasonName,
+                createdAt: item.createdAt,
+            });
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('create', 'StatUserMatchHistory', `${item.userId}:${item.groupId}:${item.eventId}`, error);
+        }
+    }
+}
+exports.MongoStatUserMatchHistoryRepository = MongoStatUserMatchHistoryRepository;

package/dist/repositories/mongo/stat-user-profile.repository.d.ts

@@ -0,0 +1,14 @@
+import type { Model } from "mongoose";
+import type { StatUserProfileRepository } from "../../ports/stat-user-profile.repository";
+import type { StatUserProfileDoc } from "../../mongo/schemas/stat-user-profile.schema";
+import type { StatUserProfile } from "../../types/stat-user-profile.types";
+/**
+ * MongoDB implementation of StatUserProfileRepository
+ * Provides read and write access to pre-aggregated user profile data
+ */
+export declare class MongoStatUserProfileRepository implements StatUserProfileRepository {
+    private readonly model;
+    constructor(model: Model<StatUserProfileDoc>);
+    findByUserAndGroup(userId: number, groupId: number): Promise<StatUserProfile | null>;
+    save(profile: StatUserProfile): Promise<void>;
+}

package/dist/repositories/mongo/stat-user-profile.repository.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoStatUserProfileRepository = void 0;
+const errors_1 = require("../../errors");
+/**
+ * MongoDB implementation of StatUserProfileRepository
+ * Provides read and write access to pre-aggregated user profile data
+ */
+class MongoStatUserProfileRepository {
+    constructor(model) {
+        this.model = model;
+    }
+    async findByUserAndGroup(userId, groupId) {
+        try {
+            // Validate input
+            if (!userId || userId === 0) {
+                throw new errors_1.ValidationError('StatUserProfile', 'userId', userId, 'must be a non-zero number');
+            }
+            if (!groupId || groupId === 0) {
+                throw new errors_1.ValidationError('StatUserProfile', 'groupId', groupId, 'must be a non-zero number');
+            }
+            const doc = await this.model.findOne({ userId, groupId }).lean();
+            if (!doc) {
+                return null;
+            }
+            // Map document to domain type
+            return {
+                userId: doc.userId,
+                groupId: doc.groupId,
+                username: doc.username,
+                fullName: doc.fullName,
+                avatarUrl: doc.avatarUrl,
+                position: doc.position,
+                currentSkillRating: doc.currentSkillRating,
+                groupName: doc.groupName,
+                gamesCount: doc.gamesCount,
+                wins: doc.wins,
+                losses: doc.losses,
+                draws: doc.draws,
+                winPercentage: doc.winPercentage,
+                goalsFor: doc.goalsFor,
+                goalsAgainst: doc.goalsAgainst,
+                eventsCount: doc.eventsCount,
+                skillHistory: doc.skillHistory.map(point => ({
+                    date: point.date,
+                    earnedRating: point.earnedRating,
+                    manualAdjustment: point.manualAdjustment,
+                })),
+                achievements: doc.achievements.map(achievement => ({
+                    icon: achievement.icon,
+                    name: achievement.name,
+                    description: achievement.description,
+                    count: achievement.count,
+                })),
+                lastUpdated: doc.lastUpdated,
+            };
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('findByUserAndGroup', 'StatUserProfile', `${userId}:${groupId}`, error);
+        }
+    }
+    async save(profile) {
+        try {
+            // Validate input
+            if (!profile.userId || profile.userId === 0) {
+                throw new errors_1.ValidationError('StatUserProfile', 'userId', profile.userId, 'must be a non-zero number');
+            }
+            if (!profile.groupId || profile.groupId === 0) {
+                throw new errors_1.ValidationError('StatUserProfile', 'groupId', profile.groupId, 'must be a non-zero number');
+            }
+            // Upsert the profile (create or update)
+            await this.model.updateOne({ userId: profile.userId, groupId: profile.groupId }, {
+                $set: {
+                    username: profile.username,
+                    fullName: profile.fullName,
+                    avatarUrl: profile.avatarUrl,
+                    position: profile.position,
+                    currentSkillRating: profile.currentSkillRating,
+                    groupName: profile.groupName,
+                    gamesCount: profile.gamesCount,
+                    wins: profile.wins,
+                    losses: profile.losses,
+                    draws: profile.draws,
+                    winPercentage: profile.winPercentage,
+                    goalsFor: profile.goalsFor,
+                    goalsAgainst: profile.goalsAgainst,
+                    eventsCount: profile.eventsCount,
+                    skillHistory: profile.skillHistory,
+                    achievements: profile.achievements,
+                    lastUpdated: profile.lastUpdated,
+                },
+            }, { upsert: true });
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('save', 'StatUserProfile', `${profile.userId}:${profile.groupId}`, error);
+        }
+    }
+}
+exports.MongoStatUserProfileRepository = MongoStatUserProfileRepository;

package/dist/types/index.d.ts

@@ -3,3 +3,6 @@ export * from "./stat-group-profile.types";
 export * from "./stat-group-season.types";
 export * from "./stat-group-last-100-games.types";
 export * from "./stat-group-activity-chart.types";
+export * from "./stat-user-profile.types";
+export * from "./stat-user-match-history.types";
+export * from "./stat-event.types";

package/dist/types/index.js

@@ -19,3 +19,6 @@ __exportStar(require("./stat-group-profile.types"), exports);
 __exportStar(require("./stat-group-season.types"), exports);
 __exportStar(require("./stat-group-last-100-games.types"), exports);
 __exportStar(require("./stat-group-activity-chart.types"), exports);
+__exportStar(require("./stat-user-profile.types"), exports);
+__exportStar(require("./stat-user-match-history.types"), exports);
+__exportStar(require("./stat-event.types"), exports);

package/dist/types/stat-event.types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Statistics: Event Page Types
+ * Pre-aggregated event data with standings, statistics, and enriched rosters/matches
+ */
+export interface StatEventPlayer {
+    userId: number;
+    playerName: string;
+    avatarUrl: string;
+    position: string;
+}
+export interface StatEventTeam {
+    teamId: number;
+    teamName: string;
+    totalPoints: number;
+    avgTeamRating: number;
+    players: StatEventPlayer[];
+}
+export interface StatEventStandingsRow {
+    rank: number;
+    teamName: string;
+    played: number;
+    wins: number;
+    draws: number;
+    losses: number;
+    goalsFor: number;
+    goalsAgainst: number;
+    goalDifference: number;
+    points: number;
+}
+export interface StatEventMatch {
+    matchId: number;
+    matchNumber: number;
+    time: string;
+    status: string;
+    team1Name: string;
+    team1Score: number;
+    team2Name: string;
+    team2Score: number;
+}
+export interface StatEventHeader {
+    status: 'Finished' | 'In Progress' | 'Upcoming';
+    seasonName: string;
+    groupName: string;
+    eventName: string;
+    date: Date;
+    timeRange: string;
+    location: string;
+    winnerName: string | null;
+}
+export interface StatEventOverviewStats {
+    totalGoals: number;
+    goalsPerMatch: number;
+}
+export interface StatEventOverview {
+    stats: StatEventOverviewStats;
+    standings: StatEventStandingsRow[];
+    teams: StatEventTeam[];
+}
+export interface StatEvent {
+    eventId: number;
+    header: StatEventHeader;
+    overview: StatEventOverview;
+    matches: StatEventMatch[];
+    calculatedAt: Date;
+    version: number;
+}

package/dist/types/stat-event.types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Statistics: Event Page Types
+ * Pre-aggregated event data with standings, statistics, and enriched rosters/matches
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/stat-user-match-history.types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Statistics: User Match History Types
+ * Pre-aggregated user match history data for ballrush-api
+ */
+export interface StatUserMatchHistory {
+    userId: number;
+    groupId: number;
+    eventId: number;
+    result: 'Win' | 'Loss' | 'Draw';
+    matchup: string;
+    score: string;
+    date: Date;
+    seasonName: string;
+    createdAt: Date;
+}
+/**
+ * Filter options for match history queries
+ */
+export interface MatchHistoryFilter {
+    userId: number;
+    groupId: number;
+    season?: string;
+}
+/**
+ * Pagination options for match history queries
+ */
+export interface MatchHistoryOptions {
+    page: number;
+    limit: number;
+}
+/**
+ * Result type for paginated match history queries
+ */
+export interface MatchHistoryResult {
+    matches: StatUserMatchHistory[];
+    totalMatches: number;
+    totalPages: number;
+    currentPage: number;
+}

package/dist/types/stat-user-match-history.types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Statistics: User Match History Types
+ * Pre-aggregated user match history data for ballrush-api
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/stat-user-profile.types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Statistics: User Profile Types
+ * Pre-aggregated user profile data for ballrush-api
+ */
+export interface SkillHistoryPoint {
+    date: Date;
+    earnedRating: number | null;
+    manualAdjustment: number | null;
+}
+export interface ProfileAchievement {
+    icon: string;
+    name: string;
+    description: string;
+    count: number;
+}
+export interface StatUserProfile {
+    userId: number;
+    groupId: number;
+    username: string;
+    fullName: string;
+    avatarUrl: string;
+    position: string;
+    currentSkillRating: number;
+    groupName: string;
+    gamesCount: number;
+    wins: number;
+    losses: number;
+    draws: number;
+    winPercentage: number;
+    goalsFor: number;
+    goalsAgainst: number;
+    eventsCount: number;
+    skillHistory: SkillHistoryPoint[];
+    achievements: ProfileAchievement[];
+    lastUpdated: Date;
+}

package/dist/types/stat-user-profile.types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Statistics: User Profile Types
+ * Pre-aggregated user profile data for ballrush-api
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ballrush-core",
-    "version": "0.5.0",
+    "version": "0.5.2",
     "private": false,
     "license": "MIT",
     "main": "./dist/index.js",