ballrush-core 0.5.3 → 0.5.4

package/dist/domain/index.d.ts

@@ -3,3 +3,4 @@ export * from "./group";
 export * from "./event";
 export * from "./event-template";
 export * from "./stat-group";
+export * from "./season";

package/dist/domain/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./group"), exports);
 __exportStar(require("./event"), exports);
 __exportStar(require("./event-template"), exports);
 __exportStar(require("./stat-group"), exports);
+__exportStar(require("./season"), exports);

package/dist/domain/season.d.ts

@@ -0,0 +1,81 @@
+export type SeasonStatus = 'upcoming' | 'in_progress' | 'ended';
+export declare class Season {
+    private seasonId;
+    private name;
+    private year;
+    private startDate;
+    private endDate;
+    private status;
+    private isPublic;
+    private description?;
+    private groupId?;
+    private createdBy?;
+    private createdAt?;
+    private updatedAt?;
+    constructor(seasonId: string, name: string, year: number, startDate: Date, endDate: Date, status: SeasonStatus, isPublic: boolean, description?: string | undefined, groupId?: number | undefined, createdBy?: number | undefined, createdAt?: Date | undefined, updatedAt?: Date | undefined);
+    static create(p: {
+        seasonId: string;
+        name: string;
+        year: number;
+        startDate: Date;
+        endDate: Date;
+        status?: SeasonStatus;
+        isPublic?: boolean;
+        description?: string;
+        groupId?: number;
+        createdBy?: number;
+        createdAt?: Date;
+        updatedAt?: Date;
+    }): Season;
+    /**
+     * Вычисляет статус сезона на основе дат
+     */
+    static calculateStatusFromDates(startDate: Date, endDate: Date, now?: Date): SeasonStatus;
+    /**
+     * Вычисляет текущий статус на основе дат
+     */
+    calculateStatus(now?: Date): SeasonStatus;
+    /**
+     * Обновляет статус в entity на основе текущих дат
+     */
+    updateStatus(now?: Date): void;
+    /**
+     * Проверяет, нужно ли обновить статус
+     */
+    needsStatusUpdate(now?: Date): boolean;
+    getSeasonId(): string;
+    getName(): string;
+    getYear(): number;
+    getStartDate(): Date;
+    getEndDate(): Date;
+    getStatus(): SeasonStatus;
+    getIsPublic(): boolean;
+    getDescription(): string | undefined;
+    getGroupId(): number | undefined;
+    getCreatedBy(): number | undefined;
+    getCreatedAt(): Date;
+    getUpdatedAt(): Date;
+    setName(name: string): void;
+    setYear(year: number): void;
+    setStartDate(startDate: Date): void;
+    setEndDate(endDate: Date): void;
+    setStatus(status: SeasonStatus): void;
+    setIsPublic(isPublic: boolean): void;
+    setDescription(description?: string): void;
+    setGroupId(groupId?: number): void;
+    setCreatedBy(createdBy?: number): void;
+    toObject(): {
+        seasonId: string;
+        name: string;
+        year: number;
+        startDate: Date;
+        endDate: Date;
+        status: SeasonStatus;
+        isPublic: boolean;
+        description: string | undefined;
+        groupId: number | undefined;
+        createdBy: number | undefined;
+        createdAt: Date | undefined;
+        updatedAt: Date | undefined;
+    };
+}

package/dist/domain/season.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Season = void 0;
+class Season {
+    constructor(seasonId, name, year, startDate, endDate, status, isPublic, description, groupId, createdBy, createdAt, updatedAt) {
+        this.seasonId = seasonId;
+        this.name = name;
+        this.year = year;
+        this.startDate = startDate;
+        this.endDate = endDate;
+        this.status = status;
+        this.isPublic = isPublic;
+        this.description = description;
+        this.groupId = groupId;
+        this.createdBy = createdBy;
+        this.createdAt = createdAt;
+        this.updatedAt = updatedAt;
+    }
+    static create(p) {
+        if (!p.seasonId)
+            throw new Error("seasonId is required");
+        if (!p.name)
+            throw new Error("name is required");
+        if (!p.year || p.year < 2000)
+            throw new Error("year must be >= 2000");
+        if (!p.startDate)
+            throw new Error("startDate is required");
+        if (!p.endDate)
+            throw new Error("endDate is required");
+        if (p.startDate >= p.endDate)
+            throw new Error("startDate must be before endDate");
+        // Если статус не указан, вычисляем автоматически
+        const status = p.status ?? Season.calculateStatusFromDates(p.startDate, p.endDate);
+        return new Season(p.seasonId, p.name, p.year, p.startDate, p.endDate, status, p.isPublic ?? true, // По умолчанию публичный (системный)
+        p.description, p.groupId, p.createdBy, p.createdAt ?? new Date(), p.updatedAt ?? new Date());
+    }
+    /**
+     * Вычисляет статус сезона на основе дат
+     */
+    static calculateStatusFromDates(startDate, endDate, now = new Date()) {
+        if (now < startDate)
+            return 'upcoming';
+        if (now > endDate)
+            return 'ended';
+        return 'in_progress';
+    }
+    /**
+     * Вычисляет текущий статус на основе дат
+     */
+    calculateStatus(now = new Date()) {
+        return Season.calculateStatusFromDates(this.startDate, this.endDate, now);
+    }
+    /**
+     * Обновляет статус в entity на основе текущих дат
+     */
+    updateStatus(now = new Date()) {
+        this.status = this.calculateStatus(now);
+        this.updatedAt = now;
+    }
+    /**
+     * Проверяет, нужно ли обновить статус
+     */
+    needsStatusUpdate(now = new Date()) {
+        return this.status !== this.calculateStatus(now);
+    }
+    // ---- GETTERS
+    getSeasonId() { return this.seasonId; }
+    getName() { return this.name; }
+    getYear() { return this.year; }
+    getStartDate() { return this.startDate; }
+    getEndDate() { return this.endDate; }
+    getStatus() { return this.status; }
+    getIsPublic() { return this.isPublic; }
+    getDescription() { return this.description; }
+    getGroupId() { return this.groupId; }
+    getCreatedBy() { return this.createdBy; }
+    getCreatedAt() { return this.createdAt ?? new Date(); }
+    getUpdatedAt() { return this.updatedAt ?? new Date(); }
+    // ---- SETTERS
+    setName(name) {
+        if (!name)
+            throw new Error("name cannot be empty");
+        this.name = name;
+        this.updatedAt = new Date();
+    }
+    setYear(year) {
+        if (year < 2000)
+            throw new Error("year must be >= 2000");
+        this.year = year;
+        this.updatedAt = new Date();
+    }
+    setStartDate(startDate) {
+        if (startDate >= this.endDate)
+            throw new Error("startDate must be before endDate");
+        this.startDate = startDate;
+        this.updatedAt = new Date();
+    }
+    setEndDate(endDate) {
+        if (this.startDate >= endDate)
+            throw new Error("startDate must be before endDate");
+        this.endDate = endDate;
+        this.updatedAt = new Date();
+    }
+    setStatus(status) {
+        this.status = status;
+        this.updatedAt = new Date();
+    }
+    setIsPublic(isPublic) {
+        this.isPublic = isPublic;
+        this.updatedAt = new Date();
+    }
+    setDescription(description) {
+        this.description = description;
+        this.updatedAt = new Date();
+    }
+    setGroupId(groupId) {
+        this.groupId = groupId;
+        this.updatedAt = new Date();
+    }
+    setCreatedBy(createdBy) {
+        this.createdBy = createdBy;
+        this.updatedAt = new Date();
+    }
+    toObject() {
+        return {
+            seasonId: this.seasonId,
+            name: this.name,
+            year: this.year,
+            startDate: this.startDate,
+            endDate: this.endDate,
+            status: this.status,
+            isPublic: this.isPublic,
+            description: this.description,
+            groupId: this.groupId,
+            createdBy: this.createdBy,
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt,
+        };
+    }
+}
+exports.Season = Season;

package/dist/mongo/index.d.ts

@@ -10,3 +10,4 @@ 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";
+export * from "./schemas/season.schema";

package/dist/mongo/index.js

@@ -26,3 +26,4 @@ __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);
+__exportStar(require("./schemas/season.schema"), exports);

package/dist/mongo/schemas/season.schema.d.ts

@@ -0,0 +1,21 @@
+import { Schema } from "mongoose";
+import { SeasonStatus } from "../../domain/season";
+export interface SeasonDoc {
+    seasonId: string;
+    name: string;
+    year: number;
+    startDate: Date;
+    endDate: Date;
+    status: SeasonStatus;
+    isPublic: boolean;
+    description?: string;
+    groupId?: number;
+    createdBy?: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function createSeasonSchema(): Schema<SeasonDoc, import("mongoose").Model<SeasonDoc, any, any, any, import("mongoose").Document<unknown, any, SeasonDoc> & SeasonDoc & {
+    _id: import("mongoose").Types.ObjectId;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, SeasonDoc, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<SeasonDoc>> & import("mongoose").FlatRecord<SeasonDoc> & {
+    _id: import("mongoose").Types.ObjectId;
+}>;

package/dist/mongo/schemas/season.schema.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSeasonSchema = createSeasonSchema;
+const mongoose_1 = require("mongoose");
+function createSeasonSchema() {
+    const schema = new mongoose_1.Schema({
+        seasonId: {
+            type: String,
+            required: true,
+            unique: true,
+            index: true
+        },
+        name: {
+            type: String,
+            required: true
+        },
+        year: {
+            type: Number,
+            required: true,
+            min: 2000,
+            index: true
+        },
+        startDate: {
+            type: Date,
+            required: true,
+            index: true
+        },
+        endDate: {
+            type: Date,
+            required: true,
+            index: true
+        },
+        status: {
+            type: String,
+            enum: ['upcoming', 'in_progress', 'ended'],
+            required: true,
+            default: 'upcoming',
+            index: true
+        },
+        isPublic: {
+            type: Boolean,
+            required: true,
+            default: true,
+            index: true
+        },
+        description: {
+            type: String,
+            required: false
+        },
+        groupId: {
+            type: Number,
+            required: false,
+            index: true
+        },
+        createdBy: {
+            type: Number,
+            required: false
+        },
+        createdAt: {
+            type: Date,
+            default: Date.now
+        },
+        updatedAt: {
+            type: Date,
+            default: Date.now
+        },
+    }, {
+        timestamps: true, // Автоматически обновляет createdAt и updatedAt
+    });
+    // Compound indexes для оптимизации запросов
+    schema.index({ isPublic: 1, status: 1 }); // Для поиска публичных активных сезонов
+    schema.index({ groupId: 1, status: 1 }); // Для поиска сезонов группы
+    schema.index({ year: 1, status: 1 }); // Для поиска по году и статусу
+    return schema;
+}

package/dist/ports/index.d.ts

@@ -10,3 +10,4 @@ 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";
+export * from "./seasons.repository";

package/dist/ports/index.js

@@ -26,3 +26,4 @@ __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);
+__exportStar(require("./seasons.repository"), exports);

package/dist/ports/seasons.repository.d.ts

@@ -0,0 +1,51 @@
+import { Season, SeasonStatus } from "../domain/season";
+export interface SeasonsRepository {
+    /**
+     * Получить сезон по ID
+     */
+    getById(seasonId: string): Promise<Season | null>;
+    /**
+     * Получить все публичные (системные) сезоны
+     */
+    getPublicSeasons(): Promise<Season[]>;
+    /**
+     * Получить все сезоны группы (включая публичные)
+     */
+    getByGroupId(groupId: number): Promise<Season[]>;
+    /**
+     * Получить сезоны по статусу
+     */
+    getByStatus(status: SeasonStatus, isPublic?: boolean): Promise<Season[]>;
+    /**
+     * Получить сезоны по году
+     */
+    getByYear(year: number, isPublic?: boolean): Promise<Season[]>;
+    /**
+     * Получить все сезоны
+     */
+    getAll(): Promise<Season[]>;
+    /**
+     * Создать новый сезон
+     */
+    createFromDomain(entity: Season): Promise<Season>;
+    /**
+     * Обновить сезон
+     */
+    updateFromDomain(entity: Season): Promise<Season | null>;
+    /**
+     * Удалить сезон
+     */
+    deleteById(seasonId: string): Promise<void>;
+    /**
+     * Обновить статусы всех сезонов на основе текущих дат
+     */
+    updateAllStatuses(now?: Date): Promise<number>;
+    /**
+     * Получить активные сезоны (in_progress)
+     */
+    getActiveSeasons(groupId?: number): Promise<Season[]>;
+    /**
+     * Получить будущие сезоны (upcoming)
+     */
+    getUpcomingSeasons(groupId?: number): Promise<Season[]>;
+}

package/dist/ports/seasons.repository.js

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

package/dist/repositories/index.d.ts

@@ -10,3 +10,4 @@ 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";
+export * from "./mongo/season.repository";

package/dist/repositories/index.js

@@ -26,3 +26,4 @@ __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);
+__exportStar(require("./mongo/season.repository"), exports);

package/dist/repositories/mongo/season.mapper.d.ts

@@ -0,0 +1,4 @@
+import { Season } from "../../domain/season";
+import { SeasonDoc } from "../../mongo";
+export declare function toDomain(doc: SeasonDoc): Season;
+export declare function toDoc(entity: Season): SeasonDoc;

package/dist/repositories/mongo/season.mapper.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDomain = toDomain;
+exports.toDoc = toDoc;
+const season_1 = require("../../domain/season");
+function toDomain(doc) {
+    return season_1.Season.create({
+        seasonId: doc.seasonId,
+        name: doc.name,
+        year: doc.year,
+        startDate: new Date(doc.startDate),
+        endDate: new Date(doc.endDate),
+        status: doc.status,
+        isPublic: doc.isPublic,
+        description: doc.description,
+        groupId: doc.groupId,
+        createdBy: doc.createdBy,
+        createdAt: new Date(doc.createdAt),
+        updatedAt: new Date(doc.updatedAt),
+    });
+}
+function toDoc(entity) {
+    return {
+        seasonId: entity.getSeasonId(),
+        name: entity.getName(),
+        year: entity.getYear(),
+        startDate: entity.getStartDate(),
+        endDate: entity.getEndDate(),
+        status: entity.getStatus(),
+        isPublic: entity.getIsPublic(),
+        description: entity.getDescription(),
+        groupId: entity.getGroupId(),
+        createdBy: entity.getCreatedBy(),
+        createdAt: entity.getCreatedAt(),
+        updatedAt: entity.getUpdatedAt(),
+    };
+}

package/dist/repositories/mongo/season.repository.d.ts

@@ -0,0 +1,20 @@
+import type { Model } from "mongoose";
+import type { SeasonDoc } from "../../mongo";
+import type { SeasonsRepository } from "../../ports/seasons.repository";
+import { Season, SeasonStatus } from "../../domain/season";
+export declare class MongoSeasonsRepository implements SeasonsRepository {
+    private readonly Model;
+    constructor(Model: Model<SeasonDoc>);
+    getById(seasonId: string): Promise<Season | null>;
+    getPublicSeasons(): Promise<Season[]>;
+    getByGroupId(groupId: number): Promise<Season[]>;
+    getByStatus(status: SeasonStatus, isPublic?: boolean): Promise<Season[]>;
+    getByYear(year: number, isPublic?: boolean): Promise<Season[]>;
+    getAll(): Promise<Season[]>;
+    createFromDomain(entity: Season): Promise<Season>;
+    updateFromDomain(entity: Season): Promise<Season | null>;
+    deleteById(seasonId: string): Promise<void>;
+    updateAllStatuses(now?: Date): Promise<number>;
+    getActiveSeasons(groupId?: number): Promise<Season[]>;
+    getUpcomingSeasons(groupId?: number): Promise<Season[]>;
+}

package/dist/repositories/mongo/season.repository.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoSeasonsRepository = void 0;
+const season_mapper_1 = require("./season.mapper");
+const errors_1 = require("../../errors");
+class MongoSeasonsRepository {
+    constructor(Model) {
+        this.Model = Model;
+    }
+    async getById(seasonId) {
+        try {
+            if (!seasonId) {
+                throw new errors_1.ValidationError('Season', 'seasonId', seasonId, 'must be a non-empty string');
+            }
+            const doc = await this.Model.findOne({ seasonId }).lean();
+            return doc ? (0, season_mapper_1.toDomain)(doc) : null;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError)
+                throw error;
+            throw new errors_1.QueryError('getById', 'Season', seasonId, error);
+        }
+    }
+    async getPublicSeasons() {
+        try {
+            const docs = await this.Model.find({ isPublic: true }).sort({ year: -1, startDate: -1 }).lean();
+            return docs.map(d => (0, season_mapper_1.toDomain)(d));
+        }
+        catch (error) {
+            throw new errors_1.QueryError('getPublicSeasons', 'Season', 'public', error);
+        }
+    }
+    async getByGroupId(groupId) {
+        try {
+            if (!groupId || groupId === 0) {
+                throw new errors_1.ValidationError('Season', 'groupId', groupId, 'must be a non-zero number');
+            }
+            // Возвращаем публичные сезоны + сезоны конкретной группы
+            const docs = await this.Model.find({
+                $or: [
+                    { isPublic: true },
+                    { groupId: groupId }
+                ]
+            }).sort({ year: -1, startDate: -1 }).lean();
+            return docs.map(d => (0, season_mapper_1.toDomain)(d));
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError)
+                throw error;
+            throw new errors_1.QueryError('getByGroupId', 'Season', groupId, error);
+        }
+    }
+    async getByStatus(status, isPublic) {
+        try {
+            const filter = { status };
+            if (isPublic !== undefined) {
+                filter.isPublic = isPublic;
+            }
+            const docs = await this.Model.find(filter).sort({ year: -1, startDate: -1 }).lean();
+            return docs.map(d => (0, season_mapper_1.toDomain)(d));
+        }
+        catch (error) {
+            throw new errors_1.QueryError('getByStatus', 'Season', status, error);
+        }
+    }
+    async getByYear(year, isPublic) {
+        try {
+            if (!year || year < 2000) {
+                throw new errors_1.ValidationError('Season', 'year', year, 'must be >= 2000');
+            }
+            const filter = { year };
+            if (isPublic !== undefined) {
+                filter.isPublic = isPublic;
+            }
+            const docs = await this.Model.find(filter).sort({ startDate: 1 }).lean();
+            return docs.map(d => (0, season_mapper_1.toDomain)(d));
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError)
+                throw error;
+            throw new errors_1.QueryError('getByYear', 'Season', year, error);
+        }
+    }
+    async getAll() {
+        try {
+            const docs = await this.Model.find().sort({ year: -1, startDate: -1 }).lean();
+            return docs.map(d => (0, season_mapper_1.toDomain)(d));
+        }
+        catch (error) {
+            throw new errors_1.QueryError('getAll', 'Season', 'all', error);
+        }
+    }
+    async createFromDomain(entity) {
+        try {
+            if (!entity) {
+                throw new errors_1.ValidationError('Season', 'entity', entity, 'entity object is required');
+            }
+            const seasonId = entity.getSeasonId();
+            if (!seasonId) {
+                throw new errors_1.ValidationError('Season', 'seasonId', seasonId, 'must be a non-empty string');
+            }
+            const write = (0, season_mapper_1.toDoc)(entity);
+            const saved = await new this.Model(write).save();
+            return (0, season_mapper_1.toDomain)(saved.toObject());
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError)
+                throw error;
+            if (error?.code === 11000) {
+                throw new errors_1.DuplicateEntityError('Season', entity.getSeasonId(), error);
+            }
+            throw new errors_1.QueryError('createFromDomain', 'Season', entity.getSeasonId(), error);
+        }
+    }
+    async updateFromDomain(entity) {
+        try {
+            if (!entity) {
+                throw new errors_1.ValidationError('Season', 'entity', entity, 'entity object is required');
+            }
+            const seasonId = entity.getSeasonId();
+            if (!seasonId) {
+                throw new errors_1.ValidationError('Season', 'seasonId', seasonId, 'must be a non-empty string');
+            }
+            const write = (0, season_mapper_1.toDoc)(entity);
+            const updated = await this.Model.findOneAndUpdate({ seasonId }, write, { new: true }).lean();
+            return updated ? (0, season_mapper_1.toDomain)(updated) : null;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError)
+                throw error;
+            throw new errors_1.QueryError('updateFromDomain', 'Season', entity.getSeasonId(), error);
+        }
+    }
+    async deleteById(seasonId) {
+        try {
+            if (!seasonId) {
+                throw new errors_1.ValidationError('Season', 'seasonId', seasonId, 'must be a non-empty string');
+            }
+            const result = await this.Model.deleteOne({ seasonId });
+            if (result.deletedCount === 0) {
+                throw new errors_1.EntityNotFoundError('Season', seasonId, 'delete');
+            }
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError || error instanceof errors_1.EntityNotFoundError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('deleteById', 'Season', seasonId, error);
+        }
+    }
+    async updateAllStatuses(now = new Date()) {
+        try {
+            let updatedCount = 0;
+            // Получаем все сезоны
+            const docs = await this.Model.find().lean();
+            // Обновляем каждый сезон, если статус изменился
+            for (const doc of docs) {
+                const entity = (0, season_mapper_1.toDomain)(doc);
+                const oldStatus = entity.getStatus();
+                const newStatus = entity.calculateStatus(now);
+                if (oldStatus !== newStatus) {
+                    entity.setStatus(newStatus);
+                    await this.updateFromDomain(entity);
+                    updatedCount++;
+                }
+            }
+            return updatedCount;
+        }
+        catch (error) {
+            throw new errors_1.QueryError('updateAllStatuses', 'Season', 'all', error);
+        }
+    }
+    async getActiveSeasons(groupId) {
+        try {
+            const filter = { status: 'in_progress' };
+            if (groupId !== undefined) {
+                if (groupId === 0) {
+                    throw new errors_1.ValidationError('Season', 'groupId', groupId, 'must be a non-zero number');
+                }
+                filter.$or = [
+                    { isPublic: true },
+                    { groupId: groupId }
+                ];
+            }
+            const docs = await this.Model.find(filter).sort({ year: -1, startDate: -1 }).lean();
+            return docs.map(d => (0, season_mapper_1.toDomain)(d));
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError)
+                throw error;
+            throw new errors_1.QueryError('getActiveSeasons', 'Season', groupId || 'all', error);
+        }
+    }
+    async getUpcomingSeasons(groupId) {
+        try {
+            const filter = { status: 'upcoming' };
+            if (groupId !== undefined) {
+                if (groupId === 0) {
+                    throw new errors_1.ValidationError('Season', 'groupId', groupId, 'must be a non-zero number');
+                }
+                filter.$or = [
+                    { isPublic: true },
+                    { groupId: groupId }
+                ];
+            }
+            const docs = await this.Model.find(filter).sort({ startDate: 1 }).lean();
+            return docs.map(d => (0, season_mapper_1.toDomain)(d));
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError)
+                throw error;
+            throw new errors_1.QueryError('getUpcomingSeasons', 'Season', groupId || 'all', error);
+        }
+    }
+}
+exports.MongoSeasonsRepository = MongoSeasonsRepository;

package/package.json

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