ballrush-core 0.6.0 → 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/domain/season.d.ts

@@ -1,4 +1,5 @@
 export type SeasonStatus = 'upcoming' | 'in_progress' | 'ended';
+export type SeasonType = 'system' | 'group';
 export declare class Season {
     private seasonId;
     private name;
@@ -7,12 +8,13 @@ export declare class Season {
     private endDate;
     private status;
     private isPublic;
+    private seasonType;
     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);
+    constructor(seasonId: string, name: string, year: number, startDate: Date, endDate: Date, status: SeasonStatus, isPublic: boolean, seasonType: SeasonType, description?: string | undefined, groupId?: number | undefined, createdBy?: number | undefined, createdAt?: Date | undefined, updatedAt?: Date | undefined);
     static create(p: {
         seasonId: string;
         name: string;
@@ -20,7 +22,8 @@ export declare class Season {
         startDate: Date;
         endDate: Date;
         status?: SeasonStatus;
-        isPublic?: boolean;
+        isPublic: boolean;
+        seasonType: SeasonType;
         description?: string;
         groupId?: number;
         createdBy?: number;
@@ -50,6 +53,7 @@ export declare class Season {
     getEndDate(): Date;
     getStatus(): SeasonStatus;
     getIsPublic(): boolean;
+    getSeasonType(): SeasonType;
     getDescription(): string | undefined;
     getGroupId(): number | undefined;
     getCreatedBy(): number | undefined;
@@ -61,6 +65,7 @@ export declare class Season {
     setEndDate(endDate: Date): void;
     setStatus(status: SeasonStatus): void;
     setIsPublic(isPublic: boolean): void;
+    setSeasonType(seasonType: SeasonType): void;
     setDescription(description?: string): void;
     setGroupId(groupId?: number): void;
     setCreatedBy(createdBy?: number): void;
@@ -72,6 +77,7 @@ export declare class Season {
         endDate: Date;
         status: SeasonStatus;
         isPublic: boolean;
+        seasonType: SeasonType;
         description: string | undefined;
         groupId: number | undefined;
         createdBy: number | undefined;

package/dist/domain/season.js

@@ -2,7 +2,7 @@
 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) {
+    constructor(seasonId, name, year, startDate, endDate, status, isPublic, seasonType, description, groupId, createdBy, createdAt, updatedAt) {
         this.seasonId = seasonId;
         this.name = name;
         this.year = year;
@@ -10,6 +10,7 @@ class Season {
         this.endDate = endDate;
         this.status = status;
         this.isPublic = isPublic;
+        this.seasonType = seasonType;
         this.description = description;
         this.groupId = groupId;
         this.createdBy = createdBy;
@@ -29,10 +30,13 @@ class Season {
             throw new Error("endDate is required");
         if (p.startDate >= p.endDate)
             throw new Error("startDate must be before endDate");
+        if (p.isPublic === undefined)
+            throw new Error("isPublic is required");
+        if (!p.seasonType)
+            throw new Error("seasonType is required");
         // Если статус не указан, вычисляем автоматически
         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());
+        return new Season(p.seasonId, p.name, p.year, p.startDate, p.endDate, status, p.isPublic, p.seasonType, p.description, p.groupId, p.createdBy, p.createdAt ?? new Date(), p.updatedAt ?? new Date());
     }
     /**
      * Вычисляет статус сезона на основе дат
@@ -71,6 +75,7 @@ class Season {
     getEndDate() { return this.endDate; }
     getStatus() { return this.status; }
     getIsPublic() { return this.isPublic; }
+    getSeasonType() { return this.seasonType; }
     getDescription() { return this.description; }
     getGroupId() { return this.groupId; }
     getCreatedBy() { return this.createdBy; }
@@ -109,6 +114,10 @@ class Season {
         this.isPublic = isPublic;
         this.updatedAt = new Date();
     }
+    setSeasonType(seasonType) {
+        this.seasonType = seasonType;
+        this.updatedAt = new Date();
+    }
     setDescription(description) {
         this.description = description;
         this.updatedAt = new Date();
@@ -130,6 +139,7 @@ class Season {
             endDate: this.endDate,
             status: this.status,
             isPublic: this.isPublic,
+            seasonType: this.seasonType,
             description: this.description,
             groupId: this.groupId,
             createdBy: this.createdBy,

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/mongo/schemas/season.schema.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "mongoose";
-import { SeasonStatus } from "../../domain/season";
+import { SeasonStatus, SeasonType } from "../../domain/season";
 export interface SeasonDoc {
     seasonId: string;
     name: string;
@@ -8,6 +8,7 @@ export interface SeasonDoc {
     endDate: Date;
     status: SeasonStatus;
     isPublic: boolean;
+    seasonType: SeasonType;
     description?: string;
     groupId?: number;
     createdBy?: number;

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

@@ -43,6 +43,13 @@ function createSeasonSchema() {
             default: true,
             index: true
         },
+        seasonType: {
+            type: String,
+            enum: ['system', 'group'],
+            required: true,
+            default: 'system',
+            index: true
+        },
         description: {
             type: String,
             required: false
@@ -68,6 +75,7 @@ function createSeasonSchema() {
         timestamps: true, // Автоматически обновляет createdAt и updatedAt
     });
     // Compound indexes для оптимизации запросов
+    schema.index({ seasonType: 1, status: 1 }); // Для поиска системных/групповых сезонов
     schema.index({ isPublic: 1, status: 1 }); // Для поиска публичных активных сезонов
     schema.index({ groupId: 1, status: 1 }); // Для поиска сезонов группы
     schema.index({ year: 1, status: 1 }); // Для поиска по году и статусу

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.mapper.js

@@ -12,6 +12,7 @@ function toDomain(doc) {
         endDate: new Date(doc.endDate),
         status: doc.status,
         isPublic: doc.isPublic,
+        seasonType: doc.seasonType,
         description: doc.description,
         groupId: doc.groupId,
         createdBy: doc.createdBy,
@@ -28,6 +29,7 @@ function toDoc(entity) {
         endDate: entity.getEndDate(),
         status: entity.getStatus(),
         isPublic: entity.getIsPublic(),
+        seasonType: entity.getSeasonType(),
         description: entity.getDescription(),
         groupId: entity.getGroupId(),
         createdBy: entity.getCreatedBy(),

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

@@ -23,7 +23,7 @@ class MongoSeasonsRepository {
     }
     async getPublicSeasons() {
         try {
-            const docs = await this.Model.find({ isPublic: true }).sort({ year: -1, startDate: -1 }).lean();
+            const docs = await this.Model.find({ seasonType: 'system' }).sort({ year: -1, startDate: -1 }).lean();
             return docs.map(d => (0, season_mapper_1.toDomain)(d));
         }
         catch (error) {
@@ -35,12 +35,8 @@ class MongoSeasonsRepository {
             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 }
-                ]
+                groupId: groupId
             }).sort({ year: -1, startDate: -1 }).lean();
             return docs.map(d => (0, season_mapper_1.toDomain)(d));
         }
@@ -178,7 +174,7 @@ class MongoSeasonsRepository {
                     throw new errors_1.ValidationError('Season', 'groupId', groupId, 'must be a non-zero number');
                 }
                 filter.$or = [
-                    { isPublic: true },
+                    { seasonType: 'system' },
                     { groupId: groupId }
                 ];
             }
@@ -199,7 +195,7 @@ class MongoSeasonsRepository {
                     throw new errors_1.ValidationError('Season', 'groupId', groupId, 'must be a non-zero number');
                 }
                 filter.$or = [
-                    { isPublic: true },
+                    { seasonType: 'system' },
                     { groupId: groupId }
                 ];
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ballrush-core",
-    "version": "0.6.0",
+    "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",