ballrush-core 0.4.2 → 0.4.3

package/dist/domain/group.d.ts

@@ -6,6 +6,7 @@ export declare class Group {
     private timezone;
     private isMessageLast;
     private language;
+    private isPublic;
     private constructor();
     static create(params: {
         groupId: number;
@@ -14,6 +15,7 @@ export declare class Group {
         timezone?: string;
         isMessageLast?: boolean;
         language?: LanguageType;
+        isPublic?: boolean;
     }): Group;
     getGroupId(): number;
     getGroupName(): string;
@@ -21,11 +23,13 @@ export declare class Group {
     getIsMessageLast(): boolean;
     getLanguage(): LanguageType;
     getParticipants(): ParticipantGroup[];
+    getIsPublic(): boolean;
     getAdmins(): ParticipantGroup[];
     getAdminIds(): number[];
     setTimezone(tz: string): void;
     setIsMessageLast(v: boolean): void;
     setLanguage(language: LanguageType): void;
+    setIsPublic(value: boolean): void;
     addAdmin(userId: number): void;
     removeAdmin(userId: number): void;
     addNewParticipant(userId: number, isAdmin?: boolean, initialRating?: number): boolean;

package/dist/domain/group.js

@@ -4,18 +4,19 @@ exports.Group = void 0;
 const types_1 = require("../types");
 const utils_1 = require("../utils");
 class Group {
-    constructor(groupId, groupName, participants, timezone = "UTC+0", isMessageLast = false, language = "en") {
+    constructor(groupId, groupName, participants, timezone = "UTC+0", isMessageLast = false, language = "en", isPublic = false) {
         this.groupId = groupId;
         this.groupName = groupName;
         this.participants = participants;
         this.timezone = timezone;
         this.isMessageLast = isMessageLast;
         this.language = language;
+        this.isPublic = isPublic;
     }
     static create(params) {
         if (!params.groupName)
             throw new Error("Group name is required");
-        return new Group(params.groupId, params.groupName, (params.participants ?? []).map(p => ({ ...p, ratingHistory: [...p.ratingHistory] })), params.timezone ?? "UTC+0", params.isMessageLast ?? false, params.language ?? "en");
+        return new Group(params.groupId, params.groupName, (params.participants ?? []).map(p => ({ ...p, ratingHistory: [...p.ratingHistory] })), params.timezone ?? "UTC+0", params.isMessageLast ?? false, params.language ?? "en", params.isPublic ?? false);
     }
     getGroupId() { return this.groupId; }
     getGroupName() { return this.groupName; }
@@ -23,6 +24,7 @@ class Group {
     getIsMessageLast() { return this.isMessageLast; }
     getLanguage() { return this.language; }
     getParticipants() { return this.participants; }
+    getIsPublic() { return this.isPublic; }
     getAdmins() {
         return this.participants.filter(p => p.isAdmin);
     }
@@ -38,6 +40,9 @@ class Group {
     setLanguage(language) {
         this.language = language;
     }
+    setIsPublic(value) {
+        this.isPublic = value;
+    }
     addAdmin(userId) {
         const p = this.participants.find(x => x.userId === userId);
         if (p) {

package/dist/domain/index.d.ts

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

package/dist/domain/index.js

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

package/dist/domain/stat-group.d.ts

@@ -0,0 +1,26 @@
+export declare class StatGroup {
+    private readonly groupId;
+    private readonly groupName;
+    private readonly seasonsCount;
+    private readonly eventsCount;
+    private readonly matchesCount;
+    private readonly participantsCount;
+    private readonly updatedAt;
+    private constructor();
+    static create(params: {
+        groupId: number;
+        groupName: string;
+        seasonsCount: number;
+        eventsCount: number;
+        matchesCount: number;
+        participantsCount: number;
+        updatedAt?: Date;
+    }): StatGroup;
+    getGroupId(): number;
+    getGroupName(): string;
+    getSeasonsCount(): number;
+    getEventsCount(): number;
+    getMatchesCount(): number;
+    getParticipantsCount(): number;
+    getUpdatedAt(): Date;
+}

package/dist/domain/stat-group.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatGroup = void 0;
+class StatGroup {
+    constructor(groupId, groupName, seasonsCount, eventsCount, matchesCount, participantsCount, updatedAt) {
+        this.groupId = groupId;
+        this.groupName = groupName;
+        this.seasonsCount = seasonsCount;
+        this.eventsCount = eventsCount;
+        this.matchesCount = matchesCount;
+        this.participantsCount = participantsCount;
+        this.updatedAt = updatedAt;
+    }
+    static create(params) {
+        if (!params.groupName)
+            throw new Error("Group name is required");
+        if (params.seasonsCount < 0)
+            throw new Error("Seasons count cannot be negative");
+        if (params.eventsCount < 0)
+            throw new Error("Events count cannot be negative");
+        if (params.matchesCount < 0)
+            throw new Error("Matches count cannot be negative");
+        if (params.participantsCount < 0)
+            throw new Error("Participants count cannot be negative");
+        return new StatGroup(params.groupId, params.groupName, params.seasonsCount, params.eventsCount, params.matchesCount, params.participantsCount, params.updatedAt ?? new Date());
+    }
+    getGroupId() { return this.groupId; }
+    getGroupName() { return this.groupName; }
+    getSeasonsCount() { return this.seasonsCount; }
+    getEventsCount() { return this.eventsCount; }
+    getMatchesCount() { return this.matchesCount; }
+    getParticipantsCount() { return this.participantsCount; }
+    getUpdatedAt() { return this.updatedAt; }
+}
+exports.StatGroup = StatGroup;

package/dist/mongo/index.d.ts

@@ -2,3 +2,4 @@ export * from "./schemas/user.schema";
 export * from "./schemas/event-template.schema";
 export * from "./schemas/event.schema";
 export * from "./schemas/group.schema";
+export * from "./schemas/stat-group.schema";

package/dist/mongo/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./schemas/user.schema"), exports);
 __exportStar(require("./schemas/event-template.schema"), exports);
 __exportStar(require("./schemas/event.schema"), exports);
 __exportStar(require("./schemas/group.schema"), exports);
+__exportStar(require("./schemas/stat-group.schema"), exports);

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

@@ -7,6 +7,9 @@ export interface GroupDoc {
     timezone: string;
     isMessageLast: boolean;
     language: LanguageType;
+    isPublic?: boolean;
+    createdAt?: Date;
+    updatedAt?: Date;
 }
 export declare function createRatingPointSchema(): Schema<RatingPoint, import("mongoose").Model<RatingPoint, any, any, any, import("mongoose").Document<unknown, any, RatingPoint> & RatingPoint & {
     _id: import("mongoose").Types.ObjectId;

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

@@ -30,6 +30,9 @@ function createGroupSchema() {
         timezone: { type: String, default: "UTC+0" },
         isMessageLast: { type: Boolean, default: false },
         language: { type: String, enum: ['en', 'ru', 'ua'], default: 'en' },
+        isPublic: { type: Boolean, default: false, index: true },
+    }, {
+        timestamps: true, // Adds createdAt and updatedAt automatically
     });
     return GroupSchema;
 }

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

@@ -0,0 +1,15 @@
+import { Schema } from "mongoose";
+export interface StatGroupDoc {
+    groupId: number;
+    groupName: string;
+    seasonsCount: number;
+    eventsCount: number;
+    matchesCount: number;
+    participantsCount: number;
+    updatedAt: Date;
+}
+export declare function createStatGroupSchema(): Schema<StatGroupDoc, import("mongoose").Model<StatGroupDoc, any, any, any, import("mongoose").Document<unknown, any, StatGroupDoc> & StatGroupDoc & {
+    _id: import("mongoose").Types.ObjectId;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, StatGroupDoc, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<StatGroupDoc>> & import("mongoose").FlatRecord<StatGroupDoc> & {
+    _id: import("mongoose").Types.ObjectId;
+}>;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStatGroupSchema = createStatGroupSchema;
+const mongoose_1 = require("mongoose");
+function createStatGroupSchema() {
+    const StatGroupSchema = new mongoose_1.Schema({
+        groupId: { type: Number, required: true, unique: true, index: true },
+        groupName: { type: String, required: true },
+        seasonsCount: { type: Number, required: true, min: 0 },
+        eventsCount: { type: Number, required: true, min: 0 },
+        matchesCount: { type: Number, required: true, min: 0 },
+        participantsCount: { type: Number, required: true, min: 0 },
+        updatedAt: { type: Date, default: Date.now },
+    }, {
+        collection: 'stat_group',
+        versionKey: false, // убирает поле __v
+    });
+    return StatGroupSchema;
+}

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

@@ -12,6 +12,7 @@ export type GroupWrite = {
     timezone: string;
     isMessageLast: boolean;
     language: LanguageType;
+    isPublic: boolean;
 };
 export interface GroupsRepository {
     create(groupData: Group): Promise<Group>;

package/dist/ports/index.d.ts

@@ -2,3 +2,4 @@ export * from "./users.repository";
 export * from "./groups.repository";
 export * from "./events.repository";
 export * from "./event-templates.repository";
+export * from "./stat-group.repository";

package/dist/ports/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./users.repository"), exports);
 __exportStar(require("./groups.repository"), exports);
 __exportStar(require("./events.repository"), exports);
 __exportStar(require("./event-templates.repository"), exports);
+__exportStar(require("./stat-group.repository"), exports);

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

@@ -0,0 +1,41 @@
+import { StatGroup } from "../domain/stat-group";
+export interface FindPublicGroupsOptions {
+    page: number;
+    limit: number;
+    search?: string;
+    sort: 'lastActivity' | 'name' | 'members' | 'games';
+}
+export interface PublicGroupsWithStatsResult {
+    groups: Array<{
+        groupId: number;
+        groupName: string;
+        updatedAt: Date;
+        statistics: {
+            seasonsCount: number;
+            eventsCount: number;
+            matchesCount: number;
+            participantsCount: number;
+        };
+    }>;
+    totalCount: number;
+}
+export interface StatGroupRepository {
+    /**
+     * Find statistics for a specific group
+     * @param groupId The group ID
+     * @returns Group statistics or null if not found
+     */
+    findByGroupId(groupId: number): Promise<StatGroup | null>;
+    /**
+     * Find public groups with their statistics using aggregation
+     * @param options Query options for filtering, pagination, and sorting
+     * @returns Paginated list of public groups with statistics
+     */
+    findPublicGroupsWithStats(options: FindPublicGroupsOptions): Promise<PublicGroupsWithStatsResult>;
+    /**
+     * Create or update group statistics
+     * @param stats The statistics to save
+     * @returns The saved statistics
+     */
+    upsert(stats: StatGroup): Promise<StatGroup>;
+}

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

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

package/dist/repositories/index.d.ts

@@ -2,3 +2,4 @@ export * from "./mongo/user.repository";
 export * from "./mongo/group.repository";
 export * from "./mongo/event.repository";
 export * from "./mongo/event-template.repository";
+export * from "./mongo/stat-group.repository";

package/dist/repositories/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./mongo/user.repository"), exports);
 __exportStar(require("./mongo/group.repository"), exports);
 __exportStar(require("./mongo/event.repository"), exports);
 __exportStar(require("./mongo/event-template.repository"), exports);
+__exportStar(require("./mongo/stat-group.repository"), exports);

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

@@ -11,6 +11,7 @@ function toDomain(doc) {
         timezone: doc.timezone,
         isMessageLast: doc.isMessageLast,
         language: doc.language,
+        isPublic: doc.isPublic ?? false,
     });
 }
 function toDoc(group) {
@@ -21,5 +22,6 @@ function toDoc(group) {
         timezone: group.getTimezone(),
         isMessageLast: group.getIsMessageLast(),
         language: group.getLanguage(),
+        isPublic: group.getIsPublic(),
     };
 }

package/dist/repositories/mongo/stat-group.mapper.d.ts

@@ -0,0 +1,4 @@
+import { StatGroup } from "../../domain/stat-group";
+import { StatGroupDoc } from "../../mongo";
+export declare function toStatGroupDomain(doc: StatGroupDoc): StatGroup;
+export declare function toStatGroupDoc(statGroup: StatGroup): StatGroupDoc;

package/dist/repositories/mongo/stat-group.mapper.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toStatGroupDomain = toStatGroupDomain;
+exports.toStatGroupDoc = toStatGroupDoc;
+const stat_group_1 = require("../../domain/stat-group");
+function toStatGroupDomain(doc) {
+    return stat_group_1.StatGroup.create({
+        groupId: doc.groupId,
+        groupName: doc.groupName,
+        seasonsCount: doc.seasonsCount,
+        eventsCount: doc.eventsCount,
+        matchesCount: doc.matchesCount,
+        participantsCount: doc.participantsCount,
+        updatedAt: doc.updatedAt,
+    });
+}
+function toStatGroupDoc(statGroup) {
+    return {
+        groupId: statGroup.getGroupId(),
+        groupName: statGroup.getGroupName(),
+        seasonsCount: statGroup.getSeasonsCount(),
+        eventsCount: statGroup.getEventsCount(),
+        matchesCount: statGroup.getMatchesCount(),
+        participantsCount: statGroup.getParticipantsCount(),
+        updatedAt: statGroup.getUpdatedAt(),
+    };
+}

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

@@ -0,0 +1,13 @@
+import type { Model } from "mongoose";
+import type { StatGroupRepository, FindPublicGroupsOptions, PublicGroupsWithStatsResult } from "../../ports/stat-group.repository";
+import type { StatGroupDoc } from "../../mongo";
+import type { GroupDoc } from "../../mongo";
+import { StatGroup } from "../../domain/stat-group";
+export declare class MongoStatGroupRepository implements StatGroupRepository {
+    private readonly StatGroupModel;
+    private readonly GroupModel;
+    constructor(StatGroupModel: Model<StatGroupDoc>, GroupModel: Model<GroupDoc>);
+    findByGroupId(groupId: number): Promise<StatGroup | null>;
+    findPublicGroupsWithStats(options: FindPublicGroupsOptions): Promise<PublicGroupsWithStatsResult>;
+    upsert(stats: StatGroup): Promise<StatGroup>;
+}

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

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoStatGroupRepository = void 0;
+const stat_group_mapper_1 = require("./stat-group.mapper");
+const errors_1 = require("../../errors");
+class MongoStatGroupRepository {
+    constructor(StatGroupModel, GroupModel) {
+        this.StatGroupModel = StatGroupModel;
+        this.GroupModel = GroupModel;
+    }
+    async findByGroupId(groupId) {
+        try {
+            // Validate input
+            if (!groupId || groupId === 0) {
+                throw new errors_1.ValidationError('StatGroup', 'groupId', groupId, 'must be a non-zero number');
+            }
+            const doc = await this.StatGroupModel.findOne({ groupId }).lean();
+            return doc ? (0, stat_group_mapper_1.toStatGroupDomain)(doc) : null;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('findByGroupId', 'StatGroup', groupId, error);
+        }
+    }
+    async findPublicGroupsWithStats(options) {
+        try {
+            const { page, limit, search, sort } = options;
+            const skip = (page - 1) * limit;
+            // Build match stage for public groups
+            const matchStage = { isPublic: true };
+            if (search) {
+                matchStage.groupName = { $regex: search, $options: 'i' };
+            }
+            // Build sort stage
+            let sortStage = {};
+            switch (sort) {
+                case 'lastActivity':
+                    sortStage = { 'statistics.updatedAt': -1 };
+                    break;
+                case 'name':
+                    sortStage = { groupName: 1 };
+                    break;
+                case 'members':
+                    sortStage = { 'statistics.participantsCount': -1 };
+                    break;
+                case 'games':
+                    sortStage = { 'statistics.matchesCount': -1 };
+                    break;
+            }
+            // Aggregation pipeline to join groups with statistics
+            const pipeline = [
+                // Match public groups
+                { $match: matchStage },
+                // Lookup statistics
+                {
+                    $lookup: {
+                        from: 'stat_group',
+                        localField: 'groupId',
+                        foreignField: 'groupId',
+                        as: 'statistics'
+                    }
+                },
+                // Unwind statistics (handle case where no stats exist)
+                {
+                    $unwind: {
+                        path: '$statistics',
+                        preserveNullAndEmptyArrays: true
+                    }
+                },
+                // Add default statistics if none exist
+                {
+                    $addFields: {
+                        statistics: {
+                            $cond: {
+                                if: { $eq: ['$statistics', null] },
+                                then: {
+                                    seasonsCount: 0,
+                                    eventsCount: 0,
+                                    matchesCount: 0,
+                                    participantsCount: { $size: '$participants' },
+                                    updatedAt: '$updatedAt'
+                                },
+                                else: {
+                                    seasonsCount: '$statistics.seasonsCount',
+                                    eventsCount: '$statistics.eventsCount',
+                                    matchesCount: '$statistics.matchesCount',
+                                    participantsCount: '$statistics.participantsCount',
+                                    updatedAt: '$statistics.updatedAt'
+                                }
+                            }
+                        }
+                    }
+                },
+                // Sort
+                { $sort: sortStage },
+                // Pagination
+                { $skip: skip },
+                { $limit: limit },
+                // Project final result
+                {
+                    $project: {
+                        groupId: 1,
+                        groupName: 1,
+                        updatedAt: 1,
+                        statistics: 1
+                    }
+                }
+            ];
+            // Execute aggregation
+            const groups = await this.GroupModel.aggregate(pipeline).exec();
+            // Get total count for pagination
+            const totalCountPipeline = [
+                { $match: matchStage },
+                { $count: 'total' }
+            ];
+            const totalResult = await this.GroupModel.aggregate(totalCountPipeline).exec();
+            const totalCount = totalResult[0]?.total || 0;
+            return {
+                groups: groups.map(g => ({
+                    groupId: g.groupId,
+                    groupName: g.groupName,
+                    updatedAt: g.updatedAt,
+                    statistics: g.statistics,
+                })),
+                totalCount,
+            };
+        }
+        catch (error) {
+            throw new errors_1.QueryError('findPublicGroupsWithStats', 'StatGroup', 'public', error);
+        }
+    }
+    async upsert(stats) {
+        try {
+            // Validate input
+            if (!stats) {
+                throw new errors_1.ValidationError('StatGroup', 'stats', stats, 'stats object is required');
+            }
+            const groupId = stats.getGroupId();
+            if (!groupId || groupId === 0) {
+                throw new errors_1.ValidationError('StatGroup', 'groupId', groupId, 'must be a non-zero number');
+            }
+            const doc = (0, stat_group_mapper_1.toStatGroupDoc)(stats);
+            const result = await this.StatGroupModel.findOneAndUpdate({ groupId }, {
+                $set: {
+                    ...doc,
+                    updatedAt: new Date(),
+                }
+            }, {
+                upsert: true,
+                new: true,
+                setDefaultsOnInsert: true,
+            }).lean();
+            return (0, stat_group_mapper_1.toStatGroupDomain)(result);
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('upsert', 'StatGroup', stats.getGroupId(), error);
+        }
+    }
+}
+exports.MongoStatGroupRepository = MongoStatGroupRepository;

package/package.json

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