ballrush-core 0.6.1 → 0.6.2

package/dist/domain/achievement.d.ts

@@ -0,0 +1,64 @@
+import { AchievementType } from "../types";
+export type AchievementScope = "event" | "season" | "lifetime";
+export interface AchievementTranslation {
+    title: string;
+    description: string;
+}
+export interface AchievementTranslations {
+    [language: string]: AchievementTranslation;
+}
+export declare class Achievement {
+    private readonly achievementId;
+    private readonly type;
+    private readonly scope;
+    private title;
+    private description;
+    private translations;
+    private icon;
+    private algorithm;
+    private isActive;
+    private createdAt;
+    private updatedAt;
+    private constructor();
+    static create(params: {
+        achievementId: string;
+        type: AchievementType;
+        scope: AchievementScope;
+        title: string;
+        description: string;
+        translations?: AchievementTranslations;
+        icon: string;
+        algorithm: string;
+        isActive?: boolean;
+        createdAt?: Date;
+        updatedAt?: Date;
+    }): Achievement;
+    getAchievementId(): string;
+    getType(): AchievementType;
+    getScope(): AchievementScope;
+    getTitle(): string;
+    getDescription(): string;
+    getTranslations(): AchievementTranslations;
+    getTranslation(language: string): AchievementTranslation | undefined;
+    getIcon(): string;
+    getAlgorithm(): string;
+    getIsActive(): boolean;
+    getCreatedAt(): Date;
+    getUpdatedAt(): Date;
+    setTitle(title: string): void;
+    setDescription(description: string): void;
+    setTranslations(translations: AchievementTranslations): void;
+    addTranslation(language: string, translation: AchievementTranslation): void;
+    removeTranslation(language: string): void;
+    setIcon(icon: string): void;
+    setAlgorithm(algorithm: string): void;
+    setIsActive(isActive: boolean): void;
+    /**
+     * Получить локализованное название
+     */
+    getLocalizedTitle(language: string): string;
+    /**
+     * Получить локализованное описание
+     */
+    getLocalizedDescription(language: string): string;
+}

package/dist/domain/achievement.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Achievement = void 0;
+class Achievement {
+    constructor(achievementId, type, scope, title, description, translations, icon, algorithm, isActive, createdAt, updatedAt) {
+        this.achievementId = achievementId;
+        this.type = type;
+        this.scope = scope;
+        this.title = title;
+        this.description = description;
+        this.translations = translations;
+        this.icon = icon;
+        this.algorithm = algorithm;
+        this.isActive = isActive;
+        this.createdAt = createdAt;
+        this.updatedAt = updatedAt;
+    }
+    static create(params) {
+        if (!params.achievementId) {
+            throw new Error("Achievement creation failed: achievementId is required");
+        }
+        if (!params.type || (params.type !== "team" && params.type !== "personal")) {
+            throw new Error("Achievement creation failed: type must be 'team' or 'personal'");
+        }
+        if (!params.scope || !["event", "season", "lifetime"].includes(params.scope)) {
+            throw new Error("Achievement creation failed: scope must be 'event', 'season', or 'lifetime'");
+        }
+        if (!params.title) {
+            throw new Error("Achievement creation failed: title is required");
+        }
+        if (!params.description) {
+            throw new Error("Achievement creation failed: description is required");
+        }
+        if (!params.icon) {
+            throw new Error("Achievement creation failed: icon is required");
+        }
+        if (!params.algorithm) {
+            throw new Error("Achievement creation failed: algorithm is required");
+        }
+        const now = new Date();
+        return new Achievement(params.achievementId, params.type, params.scope, params.title, params.description, params.translations ?? {}, params.icon, params.algorithm, params.isActive ?? true, params.createdAt ?? now, params.updatedAt ?? now);
+    }
+    // ---- GETTERS
+    getAchievementId() {
+        return this.achievementId;
+    }
+    getType() {
+        return this.type;
+    }
+    getScope() {
+        return this.scope;
+    }
+    getTitle() {
+        return this.title;
+    }
+    getDescription() {
+        return this.description;
+    }
+    getTranslations() {
+        return { ...this.translations };
+    }
+    getTranslation(language) {
+        return this.translations[language];
+    }
+    getIcon() {
+        return this.icon;
+    }
+    getAlgorithm() {
+        return this.algorithm;
+    }
+    getIsActive() {
+        return this.isActive;
+    }
+    getCreatedAt() {
+        return this.createdAt;
+    }
+    getUpdatedAt() {
+        return this.updatedAt;
+    }
+    // ---- SETTERS
+    setTitle(title) {
+        if (!title) {
+            throw new Error("title cannot be empty");
+        }
+        this.title = title;
+        this.updatedAt = new Date();
+    }
+    setDescription(description) {
+        if (!description) {
+            throw new Error("description cannot be empty");
+        }
+        this.description = description;
+        this.updatedAt = new Date();
+    }
+    setTranslations(translations) {
+        this.translations = { ...translations };
+        this.updatedAt = new Date();
+    }
+    addTranslation(language, translation) {
+        if (!language) {
+            throw new Error("language cannot be empty");
+        }
+        if (!translation.title || !translation.description) {
+            throw new Error("translation must have both title and description");
+        }
+        this.translations[language] = { ...translation };
+        this.updatedAt = new Date();
+    }
+    removeTranslation(language) {
+        delete this.translations[language];
+        this.updatedAt = new Date();
+    }
+    setIcon(icon) {
+        if (!icon) {
+            throw new Error("icon cannot be empty");
+        }
+        this.icon = icon;
+        this.updatedAt = new Date();
+    }
+    setAlgorithm(algorithm) {
+        if (!algorithm) {
+            throw new Error("algorithm cannot be empty");
+        }
+        this.algorithm = algorithm;
+        this.updatedAt = new Date();
+    }
+    setIsActive(isActive) {
+        this.isActive = isActive;
+        this.updatedAt = new Date();
+    }
+    /**
+     * Получить локализованное название
+     */
+    getLocalizedTitle(language) {
+        const translation = this.getTranslation(language);
+        return translation?.title ?? this.title;
+    }
+    /**
+     * Получить локализованное описание
+     */
+    getLocalizedDescription(language) {
+        const translation = this.getTranslation(language);
+        return translation?.description ?? this.description;
+    }
+}
+exports.Achievement = Achievement;

package/dist/domain/index.d.ts

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

package/dist/domain/index.js

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

package/dist/index.d.ts

@@ -1,6 +1,12 @@
 export * from "./types";
 export * from "./utils";
-export * from "./domain";
+export { Achievement, AchievementScope, AchievementTranslation, AchievementTranslations } from "./domain/achievement";
+export * from "./domain/user";
+export * from "./domain/group";
+export * from "./domain/event";
+export * from "./domain/event-template";
+export * from "./domain/stat-group";
+export * from "./domain/season";
 export * from "./ports";
 export * from "./mongo";
 export * from "./repositories";

package/dist/index.js

@@ -14,9 +14,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Achievement = void 0;
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils"), exports);
-__exportStar(require("./domain"), exports);
+var achievement_1 = require("./domain/achievement");
+Object.defineProperty(exports, "Achievement", { enumerable: true, get: function () { return achievement_1.Achievement; } });
+__exportStar(require("./domain/user"), exports);
+__exportStar(require("./domain/group"), exports);
+__exportStar(require("./domain/event"), exports);
+__exportStar(require("./domain/event-template"), exports);
+__exportStar(require("./domain/stat-group"), exports);
+__exportStar(require("./domain/season"), exports);
 __exportStar(require("./ports"), exports);
 __exportStar(require("./mongo"), exports);
 __exportStar(require("./repositories"), exports);

package/dist/mongo/index.d.ts

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

package/dist/mongo/index.js

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

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

@@ -0,0 +1,21 @@
+import { Schema } from "mongoose";
+import { AchievementType } from "../../types";
+import { AchievementScope, AchievementTranslations } from "../../domain/achievement";
+export interface AchievementDoc {
+    _id: string;
+    type: AchievementType;
+    scope: AchievementScope;
+    title: string;
+    description: string;
+    translations: AchievementTranslations;
+    icon: string;
+    algorithm: string;
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function createAchievementSchema(): Schema<AchievementDoc, import("mongoose").Model<AchievementDoc, any, any, any, import("mongoose").Document<unknown, any, AchievementDoc> & AchievementDoc & Required<{
+    _id: string;
+}>, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, AchievementDoc, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<AchievementDoc>> & import("mongoose").FlatRecord<AchievementDoc> & Required<{
+    _id: string;
+}>>;

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAchievementSchema = createAchievementSchema;
+const mongoose_1 = require("mongoose");
+function createAchievementSchema() {
+    const schema = new mongoose_1.Schema({
+        _id: {
+            type: String,
+            required: true,
+        },
+        type: {
+            type: String,
+            enum: ["team", "personal"],
+            required: true,
+            index: true,
+        },
+        scope: {
+            type: String,
+            enum: ["event", "season", "lifetime"],
+            required: true,
+            index: true,
+        },
+        title: {
+            type: String,
+            required: true,
+        },
+        description: {
+            type: String,
+            required: true,
+        },
+        translations: {
+            type: mongoose_1.Schema.Types.Mixed,
+            required: false,
+            default: {},
+        },
+        icon: {
+            type: String,
+            required: true,
+        },
+        algorithm: {
+            type: String,
+            required: true,
+        },
+        isActive: {
+            type: Boolean,
+            required: true,
+            default: true,
+            index: true,
+        },
+        createdAt: {
+            type: Date,
+            default: Date.now,
+        },
+        updatedAt: {
+            type: Date,
+            default: Date.now,
+        },
+    }, {
+        collection: "achievements",
+        timestamps: true,
+    });
+    // Compound indexes для оптимизации запросов
+    schema.index({ type: 1, isActive: 1 }); // Для поиска активных достижений по типу
+    schema.index({ scope: 1, isActive: 1 }); // Для поиска активных достижений по scope
+    schema.index({ type: 1, scope: 1, isActive: 1 }); // Комбинированный индекс
+    return schema;
+}

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

@@ -0,0 +1,45 @@
+import { Achievement } from "../domain/achievement";
+import { AchievementType } from "../types";
+import { AchievementScope } from "../domain/achievement";
+export interface AchievementsRepository {
+    /**
+     * Получить достижение по ID
+     */
+    findById(achievementId: string): Promise<Achievement | null>;
+    /**
+     * Получить все достижения
+     */
+    findAll(): Promise<Achievement[]>;
+    /**
+     * Получить активные достижения
+     */
+    findActive(): Promise<Achievement[]>;
+    /**
+     * Получить достижения по типу
+     */
+    findByType(type: AchievementType, activeOnly?: boolean): Promise<Achievement[]>;
+    /**
+     * Получить достижения по scope
+     */
+    findByScope(scope: AchievementScope, activeOnly?: boolean): Promise<Achievement[]>;
+    /**
+     * Получить достижения по типу и scope
+     */
+    findByTypeAndScope(type: AchievementType, scope: AchievementScope, activeOnly?: boolean): Promise<Achievement[]>;
+    /**
+     * Создать новое достижение
+     */
+    create(achievement: Achievement): Promise<Achievement>;
+    /**
+     * Обновить достижение
+     */
+    update(achievement: Achievement): Promise<Achievement | null>;
+    /**
+     * Удалить достижение
+     */
+    delete(achievementId: string): Promise<void>;
+    /**
+     * Проверить существование достижения
+     */
+    exists(achievementId: string): Promise<boolean>;
+}

package/dist/ports/achievements.repository.js

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

package/dist/ports/index.d.ts

@@ -11,3 +11,4 @@ export * from "./stat-user-profile.repository";
 export * from "./stat-user-match-history.repository";
 export * from "./stat-event.repository";
 export * from "./seasons.repository";
+export * from "./achievements.repository";

package/dist/ports/index.js

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

package/dist/repositories/index.d.ts

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

package/dist/repositories/index.js

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

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

@@ -0,0 +1,4 @@
+import { Achievement } from "../../domain/achievement";
+import { AchievementDoc } from "../../mongo";
+export declare function toDomain(doc: AchievementDoc): Achievement;
+export declare function toDoc(achievement: Achievement): AchievementDoc;

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDomain = toDomain;
+exports.toDoc = toDoc;
+const achievement_1 = require("../../domain/achievement");
+function toDomain(doc) {
+    return achievement_1.Achievement.create({
+        achievementId: doc._id,
+        type: doc.type,
+        scope: doc.scope,
+        title: doc.title,
+        description: doc.description,
+        translations: doc.translations,
+        icon: doc.icon,
+        algorithm: doc.algorithm,
+        isActive: doc.isActive,
+        createdAt: doc.createdAt,
+        updatedAt: doc.updatedAt,
+    });
+}
+function toDoc(achievement) {
+    return {
+        _id: achievement.getAchievementId(),
+        type: achievement.getType(),
+        scope: achievement.getScope(),
+        title: achievement.getTitle(),
+        description: achievement.getDescription(),
+        translations: achievement.getTranslations(),
+        icon: achievement.getIcon(),
+        algorithm: achievement.getAlgorithm(),
+        isActive: achievement.getIsActive(),
+        createdAt: achievement.getCreatedAt(),
+        updatedAt: achievement.getUpdatedAt(),
+    };
+}

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

@@ -0,0 +1,20 @@
+import type { Model } from "mongoose";
+import type { AchievementsRepository } from "../../ports/achievements.repository";
+import type { AchievementDoc } from "../../mongo";
+import { Achievement } from "../../domain/achievement";
+import { AchievementType } from "../../types";
+import { AchievementScope } from "../../domain/achievement";
+export declare class MongoAchievementsRepository implements AchievementsRepository {
+    private readonly AchievementModel;
+    constructor(AchievementModel: Model<AchievementDoc>);
+    findById(achievementId: string): Promise<Achievement | null>;
+    findAll(): Promise<Achievement[]>;
+    findActive(): Promise<Achievement[]>;
+    findByType(type: AchievementType, activeOnly?: boolean): Promise<Achievement[]>;
+    findByScope(scope: AchievementScope, activeOnly?: boolean): Promise<Achievement[]>;
+    findByTypeAndScope(type: AchievementType, scope: AchievementScope, activeOnly?: boolean): Promise<Achievement[]>;
+    create(achievement: Achievement): Promise<Achievement>;
+    update(achievement: Achievement): Promise<Achievement | null>;
+    delete(achievementId: string): Promise<void>;
+    exists(achievementId: string): Promise<boolean>;
+}

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

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoAchievementsRepository = void 0;
+const achievement_mapper_1 = require("./achievement.mapper");
+const errors_1 = require("../../errors");
+class MongoAchievementsRepository {
+    constructor(AchievementModel) {
+        this.AchievementModel = AchievementModel;
+    }
+    async findById(achievementId) {
+        try {
+            if (!achievementId) {
+                throw new errors_1.ValidationError("Achievement", "achievementId", achievementId, "achievementId is required");
+            }
+            const doc = await this.AchievementModel.findById(achievementId).lean();
+            return doc ? (0, achievement_mapper_1.toDomain)(doc) : null;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError("findById", "Achievement", achievementId, error);
+        }
+    }
+    async findAll() {
+        try {
+            const docs = await this.AchievementModel.find().lean();
+            return docs.map((doc) => (0, achievement_mapper_1.toDomain)(doc));
+        }
+        catch (error) {
+            throw new errors_1.QueryError("findAll", "Achievement", "all", error);
+        }
+    }
+    async findActive() {
+        try {
+            const docs = await this.AchievementModel.find({ isActive: true }).lean();
+            return docs.map((doc) => (0, achievement_mapper_1.toDomain)(doc));
+        }
+        catch (error) {
+            throw new errors_1.QueryError("findActive", "Achievement", "active", error);
+        }
+    }
+    async findByType(type, activeOnly = false) {
+        try {
+            if (!type || (type !== "team" && type !== "personal")) {
+                throw new errors_1.ValidationError("Achievement", "type", type, "type must be 'team' or 'personal'");
+            }
+            const query = { type };
+            if (activeOnly) {
+                query.isActive = true;
+            }
+            const docs = await this.AchievementModel.find(query).lean();
+            return docs.map((doc) => (0, achievement_mapper_1.toDomain)(doc));
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError("findByType", "Achievement", type, error);
+        }
+    }
+    async findByScope(scope, activeOnly = false) {
+        try {
+            if (!scope || !["event", "season", "lifetime"].includes(scope)) {
+                throw new errors_1.ValidationError("Achievement", "scope", scope, "scope must be 'event', 'season', or 'lifetime'");
+            }
+            const query = { scope };
+            if (activeOnly) {
+                query.isActive = true;
+            }
+            const docs = await this.AchievementModel.find(query).lean();
+            return docs.map((doc) => (0, achievement_mapper_1.toDomain)(doc));
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError("findByScope", "Achievement", scope, error);
+        }
+    }
+    async findByTypeAndScope(type, scope, activeOnly = false) {
+        try {
+            if (!type || (type !== "team" && type !== "personal")) {
+                throw new errors_1.ValidationError("Achievement", "type", type, "type must be 'team' or 'personal'");
+            }
+            if (!scope || !["event", "season", "lifetime"].includes(scope)) {
+                throw new errors_1.ValidationError("Achievement", "scope", scope, "scope must be 'event', 'season', or 'lifetime'");
+            }
+            const query = { type, scope };
+            if (activeOnly) {
+                query.isActive = true;
+            }
+            const docs = await this.AchievementModel.find(query).lean();
+            return docs.map((doc) => (0, achievement_mapper_1.toDomain)(doc));
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError("findByTypeAndScope", "Achievement", `${type}-${scope}`, error);
+        }
+    }
+    async create(achievement) {
+        try {
+            if (!achievement) {
+                throw new errors_1.ValidationError("Achievement", "achievement", achievement, "achievement object is required");
+            }
+            const achievementId = achievement.getAchievementId();
+            if (!achievementId) {
+                throw new errors_1.ValidationError("Achievement", "achievementId", achievementId, "achievementId is required");
+            }
+            const write = (0, achievement_mapper_1.toDoc)(achievement);
+            const saved = await new this.AchievementModel(write).save();
+            return (0, achievement_mapper_1.toDomain)(saved.toObject());
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            // Check for duplicate key error
+            if (error?.code === 11000) {
+                throw new errors_1.DuplicateEntityError("Achievement", achievement.getAchievementId(), error);
+            }
+            throw new errors_1.QueryError("create", "Achievement", achievement.getAchievementId(), error);
+        }
+    }
+    async update(achievement) {
+        try {
+            if (!achievement) {
+                throw new errors_1.ValidationError("Achievement", "achievement", achievement, "achievement object is required");
+            }
+            const achievementId = achievement.getAchievementId();
+            if (!achievementId) {
+                throw new errors_1.ValidationError("Achievement", "achievementId", achievementId, "achievementId is required");
+            }
+            const write = (0, achievement_mapper_1.toDoc)(achievement);
+            const doc = await this.AchievementModel.findByIdAndUpdate(achievementId, { $set: write }, { new: true }).lean();
+            return doc ? (0, achievement_mapper_1.toDomain)(doc) : null;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError("update", "Achievement", achievement.getAchievementId(), error);
+        }
+    }
+    async delete(achievementId) {
+        try {
+            if (!achievementId) {
+                throw new errors_1.ValidationError("Achievement", "achievementId", achievementId, "achievementId is required");
+            }
+            const result = await this.AchievementModel.findByIdAndDelete(achievementId);
+            if (!result) {
+                throw new errors_1.EntityNotFoundError("Achievement", achievementId, "delete");
+            }
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError || error instanceof errors_1.EntityNotFoundError) {
+                throw error;
+            }
+            throw new errors_1.QueryError("delete", "Achievement", achievementId, error);
+        }
+    }
+    async exists(achievementId) {
+        try {
+            if (!achievementId) {
+                throw new errors_1.ValidationError("Achievement", "achievementId", achievementId, "achievementId is required");
+            }
+            const count = await this.AchievementModel.countDocuments({ _id: achievementId });
+            return count > 0;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError("exists", "Achievement", achievementId, error);
+        }
+    }
+}
+exports.MongoAchievementsRepository = MongoAchievementsRepository;

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

@@ -36,9 +36,7 @@ class MongoSeasonsRepository {
                 throw new errors_1.ValidationError('Season', 'groupId', groupId, 'must be a non-zero number');
             }
             const docs = await this.Model.find({
-                $or: [
-                    { groupId: groupId }
-                ]
+                groupId: groupId
             }).sort({ year: -1, startDate: -1 }).lean();
             return docs.map(d => (0, season_mapper_1.toDomain)(d));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ballrush-core",
-    "version": "0.6.1",
+    "version": "0.6.2",
     "private": false,
     "license": "MIT",
     "main": "./dist/index.js",
@@ -28,6 +28,7 @@
     },
     "devDependencies": {
         "@types/jest": "^30.0.0",
+        "baseline-browser-mapping": "^2.8.30",
         "jest": "^30.1.3",
         "mongoose": "^7.8.7",
         "rimraf": "^5.0.0",