ballrush-core 0.1.1 → 0.2.0

package/README.md

@@ -1,21 +1,70 @@
 # ballrush-core
 
-Shared core library for **Ballrush** project.  
-Contains TypeScript types and Mongoose schema factories (without models).
+⚠️ **Note:** This library is for **personal use** in the Ballrush project.  
 
-## Features
-
-- 🗂 Shared **TypeScript types**
-- 🏗 Mongoose **schema factories** (`createXSchema`) without `model()`
-- 🎯 Designed for **DDD** (domain-driven design) architecture
-- 🔌 Reusable in bot (`ballrush-bot`) and API (`ballrush-api`)
+Shared core library for **Ballrush**.  
+Includes **TypeScript types**, **domain entities**, **repository ports & Mongo implementations**, **Mongoose schema factories** (no models), and **utils**.
 
-## Installation
+## Features
+- 🧠 **Domain**: `User`, `Group`, `Event`, `EventTemplate`
+- 🔌 **Ports**: repository interfaces (DDD)
+- 🗄️ **Mongo adapters**: ready-to-use repository implementations (accept Mongoose Models)
+- 🏗 **Schema factories**: `createXSchema()` (without `model()`)
+- 🧰 **Utils**: small reusable helpers (e.g., rating utils)
 
+## Install
 ```bash
 npm install ballrush-core
+````
+
+## Exports (subpaths)
+
+* `ballrush-core/types`
+* `ballrush-core/domain`
+* `ballrush-core/ports`
+* `ballrush-core/mongo`
+* `ballrush-core/repositories`
+* `ballrush-core/utils`
+
+## Quick start
+
+### 1) Create Mongoose models in your app
+
+```ts
+import { connection } from "mongoose";
+import { createUserSchema, UserDoc } from "ballrush-core/mongo";
+
+export const UserModel = connection.model<UserDoc>("User", createUserSchema());
 ```
 
-License
+### 2) Use Mongo repositories (bot or API)
 
-MIT © 2025 Serhii Zghama
+```ts
+import { MongoUsersRepository } from "ballrush-core/repositories";
+import type { UsersRepository } from "ballrush-core/ports";
+
+const usersRepo: UsersRepository = new MongoUsersRepository(UserModel);
+```
+
+### 3) Work with domain entities
+
+```ts
+import { User } from "ballrush-core/domain";
+
+const user = User.create({
+  userId: 1,
+  firstName: "Alex",
+  username: "alex"
+});
+```
+
+### 4) Utils
+
+```ts
+import { addRating, getCurrentRating } from "ballrush-core/utils";
+```
+
+## License
+```
+MIT © 2025 Serhii Zghama
+```

package/dist/domain/event-template.d.ts

@@ -0,0 +1,84 @@
+import { ParticipantEvent } from "../types";
+export declare class EventTemplate {
+    private templateId;
+    private groupId;
+    private adminId;
+    private description;
+    private title;
+    private preViewImg;
+    private options;
+    private autoPost;
+    private defaultTime;
+    private defaultDayOfWeek;
+    private defaultLocation;
+    private defaultDuration;
+    private defaultParticipants;
+    private maxPlayers;
+    private createdAt;
+    constructor(templateId: number, groupId: number, adminId: number, description: string, title: string, preViewImg: string, options: string[], autoPost: boolean, defaultTime: string, defaultDayOfWeek: number, // 0..6
+    defaultLocation: string, defaultDuration: string, defaultParticipants: ParticipantEvent[], maxPlayers: number, createdAt: Date);
+    static create(p: {
+        templateId: number;
+        groupId: number;
+        adminId: number;
+        description: string;
+        title: string;
+        previewImg: string;
+        options: string[];
+        autoPost?: boolean;
+        defaultTime: string;
+        defaultDayOfWeek: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+        defaultLocation: string;
+        defaultDuration: string;
+        defaultParticipants?: ParticipantEvent[];
+        maxPlayers: number;
+        createdAt?: Date;
+    }): EventTemplate;
+    getTemplateId(): number;
+    getGroupId(): number;
+    getAdminId(): number;
+    getDescription(): string;
+    getTitle(): string;
+    getPreViewImg(): string;
+    getOptions(): string[];
+    getAutoPost(): boolean;
+    getDefaultTime(): string;
+    getDefaultDayOfWeek(): number;
+    getDefaultLocation(): string;
+    getDefaultDuration(): string;
+    getDefaultParticipants(): ParticipantEvent[];
+    getMaxPlayers(): number;
+    getCreatedAt(): Date;
+    setGroupId(groupId: number): void;
+    setAdminId(adminId: number): void;
+    setDescription(description: string): void;
+    setTitle(title: string): void;
+    setPreViewImg(url: string): void;
+    setOptions(options: string[]): void;
+    setAutoPost(flag: boolean): void;
+    setDefaultTime(time: string): void;
+    setDefaultDayOfWeek(day: number): void;
+    setDefaultLocation(loc: string): void;
+    setDefaultDuration(duration: string): void;
+    setDefaultParticipants(participants: ParticipantEvent[]): void;
+    setMaxPlayers(n: number): void;
+    addDefaultParticipant(p: ParticipantEvent): void;
+    removeDefaultParticipant(userId: number): void;
+    toObject(): {
+        templateId: number;
+        groupId: number;
+        adminId: number;
+        description: string;
+        title: string;
+        preViewImg: string;
+        options: string[];
+        autoPost: boolean;
+        defaultTime: string;
+        defaultDayOfWeek: number;
+        defaultLocation: string;
+        defaultDuration: string;
+        defaultParticipants: ParticipantEvent[];
+        maxPlayers: number;
+        createdAt: Date;
+    };
+}

package/dist/domain/event-template.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventTemplate = void 0;
+class EventTemplate {
+    constructor(templateId, groupId, adminId, description, title, preViewImg, options, autoPost, defaultTime, defaultDayOfWeek, // 0..6
+    defaultLocation, defaultDuration, defaultParticipants, maxPlayers, createdAt) {
+        this.templateId = templateId;
+        this.groupId = groupId;
+        this.adminId = adminId;
+        this.description = description;
+        this.title = title;
+        this.preViewImg = preViewImg;
+        this.options = options;
+        this.autoPost = autoPost;
+        this.defaultTime = defaultTime;
+        this.defaultDayOfWeek = defaultDayOfWeek;
+        this.defaultLocation = defaultLocation;
+        this.defaultDuration = defaultDuration;
+        this.defaultParticipants = defaultParticipants;
+        this.maxPlayers = maxPlayers;
+        this.createdAt = createdAt;
+    }
+    static create(p) {
+        if (!p.title?.trim())
+            throw new Error("Title is required");
+        if (p.maxPlayers < 1)
+            throw new Error("maxPlayers must be >= 1");
+        return new EventTemplate(p.templateId, p.groupId, p.adminId, p.description.trim(), p.title.trim(), p.previewImg, [...p.options], p.autoPost ?? false, p.defaultTime, p.defaultDayOfWeek, p.defaultLocation, p.defaultDuration, [...(p.defaultParticipants ?? [])], p.maxPlayers, p.createdAt ?? new Date());
+    }
+    // ---- GETTERS
+    getTemplateId() { return this.templateId; }
+    getGroupId() { return this.groupId; }
+    getAdminId() { return this.adminId; }
+    getDescription() { return this.description; }
+    getTitle() { return this.title; }
+    getPreViewImg() { return this.preViewImg; }
+    getOptions() { return this.options; }
+    getAutoPost() { return this.autoPost; }
+    getDefaultTime() { return this.defaultTime; }
+    getDefaultDayOfWeek() { return this.defaultDayOfWeek; }
+    getDefaultLocation() { return this.defaultLocation; }
+    getDefaultDuration() { return this.defaultDuration; }
+    getDefaultParticipants() { return this.defaultParticipants; }
+    getMaxPlayers() { return this.maxPlayers; }
+    getCreatedAt() { return this.createdAt; }
+    // ---- SETTERS 
+    setGroupId(groupId) { this.groupId = groupId; }
+    setAdminId(adminId) { this.adminId = adminId; }
+    setDescription(description) { this.description = description; }
+    setTitle(title) { this.title = title; }
+    setPreViewImg(url) { this.preViewImg = url; }
+    setOptions(options) { this.options = options; }
+    setAutoPost(flag) { this.autoPost = flag; }
+    setDefaultTime(time) { this.defaultTime = time; }
+    setDefaultDayOfWeek(day) { this.defaultDayOfWeek = day; }
+    setDefaultLocation(loc) { this.defaultLocation = loc; }
+    setDefaultDuration(duration) { this.defaultDuration = duration; }
+    setDefaultParticipants(participants) { this.defaultParticipants = participants; }
+    setMaxPlayers(n) { this.maxPlayers = n; }
+    addDefaultParticipant(p) {
+        this.defaultParticipants = [...this.defaultParticipants, p];
+    }
+    removeDefaultParticipant(userId) {
+        this.defaultParticipants = this.defaultParticipants.filter(p => p.userId !== userId);
+    }
+    toObject() {
+        return {
+            templateId: this.templateId,
+            groupId: this.groupId,
+            adminId: this.adminId,
+            description: this.description,
+            title: this.title,
+            preViewImg: this.preViewImg,
+            options: this.options,
+            autoPost: this.autoPost,
+            defaultTime: this.defaultTime,
+            defaultDayOfWeek: this.defaultDayOfWeek,
+            defaultLocation: this.defaultLocation,
+            defaultDuration: this.defaultDuration,
+            defaultParticipants: this.defaultParticipants,
+            maxPlayers: this.maxPlayers,
+            createdAt: this.createdAt,
+        };
+    }
+}
+exports.EventTemplate = EventTemplate;

package/dist/domain/event.d.ts

@@ -0,0 +1,59 @@
+import { EventStatus, Match, ParticipantEvent, Team } from "../types";
+export declare class Event {
+    private readonly eventId;
+    private readonly groupId;
+    private messageId;
+    private readonly templateId;
+    private date;
+    private participants;
+    private teams;
+    private matches;
+    private readonly createdBy;
+    private isRatingApplied;
+    private seasonName;
+    private reportMessageId?;
+    private status;
+    private constructor();
+    static create(params: {
+        eventId: number;
+        groupId: number;
+        templateId: number;
+        date: Date;
+        createdBy: number;
+        seasonName: string;
+        participants?: ParticipantEvent[];
+        teams?: Team[];
+        matches?: Match[];
+        messageId?: number;
+        reportMessageId?: number;
+        isRatingApplied?: boolean;
+        status?: EventStatus;
+    }): Event;
+    getEventId(): number;
+    getGroupId(): number;
+    getTemplateId(): number;
+    getMessageId(): number;
+    getReportMessageId(): number | undefined;
+    getDate(): Date;
+    getSeasonName(): string;
+    getParticipants(): ParticipantEvent[];
+    getTeams(): Team[];
+    getMatches(): Match[];
+    getCreatedBy(): number;
+    getStatus(): EventStatus;
+    getIsRatingApplied(): boolean;
+    renameSeason(newName: string): void;
+    reschedule(newDate: Date): void;
+    attachMessage(messageId: number): void;
+    attachReportMessage(reportMessageId: number): void;
+    replaceParticipants(list: ParticipantEvent[]): void;
+    replaceTeams(teams: Team[]): void;
+    replaceMatches(matches: Match[]): void;
+    markRatingApplied(): void;
+    start(): void;
+    complete(): void;
+    reset(): void;
+    isActive(): boolean;
+    isInProgress(): boolean;
+    isCompleted(): boolean;
+}

package/dist/domain/event.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Event = void 0;
+class Event {
+    constructor(eventId, groupId, messageId, templateId, date, participants, teams, matches, createdBy, isRatingApplied, seasonName, reportMessageId, status = "active") {
+        this.eventId = eventId;
+        this.groupId = groupId;
+        this.messageId = messageId;
+        this.templateId = templateId;
+        this.date = date;
+        this.participants = participants;
+        this.teams = teams;
+        this.matches = matches;
+        this.createdBy = createdBy;
+        this.isRatingApplied = isRatingApplied;
+        this.seasonName = seasonName;
+        this.reportMessageId = reportMessageId;
+        this.status = status;
+    }
+    static create(params) {
+        if (!params.seasonName) {
+            throw new Error("Event must have a season name");
+        }
+        return new Event(params.eventId, params.groupId, params.messageId ?? 0, params.templateId, params.date, params.participants ?? [], params.teams ?? [], params.matches ?? [], params.createdBy, params.isRatingApplied ?? false, params.seasonName, params.reportMessageId, params.status ?? "active");
+    }
+    getEventId() { return this.eventId; }
+    getGroupId() { return this.groupId; }
+    getTemplateId() { return this.templateId; }
+    getMessageId() { return this.messageId; }
+    getReportMessageId() { return this.reportMessageId; }
+    getDate() { return this.date; }
+    getSeasonName() { return this.seasonName; }
+    getParticipants() { return this.participants; }
+    getTeams() { return this.teams; }
+    getMatches() { return this.matches; }
+    getCreatedBy() { return this.createdBy; }
+    getStatus() { return this.status; }
+    getIsRatingApplied() { return this.isRatingApplied; }
+    renameSeason(newName) {
+        if (!newName)
+            throw new Error("Season name cannot be empty");
+        this.seasonName = newName;
+    }
+    reschedule(newDate) {
+        this.date = newDate;
+    }
+    attachMessage(messageId) {
+        this.messageId = messageId;
+    }
+    attachReportMessage(reportMessageId) {
+        this.reportMessageId = reportMessageId;
+    }
+    replaceParticipants(list) {
+        this.participants = list;
+    }
+    replaceTeams(teams) {
+        this.teams = teams;
+    }
+    replaceMatches(matches) {
+        this.matches = matches;
+    }
+    markRatingApplied() {
+        this.isRatingApplied = true;
+    }
+    start() {
+        this.status = "in_progress";
+    }
+    complete() {
+        this.status = "completed";
+    }
+    reset() {
+        this.status = "active";
+        this.isRatingApplied = false;
+    }
+    isActive() { return this.status === "active"; }
+    isInProgress() { return this.status === "in_progress"; }
+    isCompleted() { return this.status === "completed"; }
+}
+exports.Event = Event;

package/dist/domain/group.d.ts

@@ -0,0 +1,31 @@
+import { ParticipantGroup, PlayerPosition } from "../types";
+export declare class Group {
+    private readonly groupId;
+    private readonly groupName;
+    private participants;
+    private timezone;
+    private isMessageLast;
+    private constructor();
+    static create(params: {
+        groupId: number;
+        groupName: string;
+        participants?: ParticipantGroup[];
+        timezone?: string;
+        isMessageLast?: boolean;
+    }): Group;
+    getGroupId(): number;
+    getGroupName(): string;
+    getTimezone(): string;
+    getIsMessageLast(): boolean;
+    getParticipants(): ParticipantGroup[];
+    getAdmins(): ParticipantGroup[];
+    getAdminIds(): number[];
+    setTimezone(tz: string): void;
+    setIsMessageLast(v: boolean): void;
+    addAdmin(userId: number): void;
+    removeAdmin(userId: number): void;
+    addParticipant(userId: number, isAdmin?: boolean, initialRating?: number): boolean;
+    removeParticipant(userId: number): void;
+    setPosition(userId: number, pos: PlayerPosition): void;
+    addRatingPoint(userId: number, value: number, at?: Date): void;
+}

package/dist/domain/group.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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) {
+        this.groupId = groupId;
+        this.groupName = groupName;
+        this.participants = participants;
+        this.timezone = timezone;
+        this.isMessageLast = isMessageLast;
+    }
+    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);
+    }
+    getGroupId() { return this.groupId; }
+    getGroupName() { return this.groupName; }
+    getTimezone() { return this.timezone; }
+    getIsMessageLast() { return this.isMessageLast; }
+    getParticipants() { return this.participants; }
+    getAdmins() {
+        return this.participants.filter(p => p.isAdmin);
+    }
+    getAdminIds() {
+        return this.participants.filter(p => p.isAdmin).map(p => p.userId);
+    }
+    setTimezone(tz) {
+        this.timezone = tz;
+    }
+    setIsMessageLast(v) {
+        this.isMessageLast = v;
+    }
+    addAdmin(userId) {
+        const p = this.participants.find(x => x.userId === userId);
+        if (p) {
+            p.isAdmin = true;
+        }
+        else {
+            this.participants.push({
+                userId,
+                position: types_1.PlayerPosition.UN,
+                ratingHistory: (0, utils_1.addRating)([], 0),
+                isAdmin: true,
+            });
+        }
+    }
+    removeAdmin(userId) {
+        const p = this.participants.find(x => x.userId === userId);
+        if (p)
+            p.isAdmin = false;
+    }
+    addParticipant(userId, isAdmin = false, initialRating = 0) {
+        if (this.participants.some(p => p.userId === userId))
+            return false;
+        this.participants.push({
+            userId,
+            position: types_1.PlayerPosition.UN,
+            ratingHistory: (0, utils_1.addRating)([], initialRating),
+            isAdmin,
+        });
+        return true;
+    }
+    removeParticipant(userId) {
+        this.participants = this.participants.filter(p => p.userId !== userId);
+    }
+    setPosition(userId, pos) {
+        const p = this.participants.find(x => x.userId === userId);
+        if (p)
+            p.position = pos;
+    }
+    addRatingPoint(userId, value, at = new Date()) {
+        const p = this.participants.find(x => x.userId === userId);
+        if (!p)
+            return;
+        p.ratingHistory = (0, utils_1.addRating)(p.ratingHistory, value, at);
+    }
+}
+exports.Group = Group;

package/dist/domain/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./user";
+export * from "./group";
+export * from "./event";
+export * from "./event-template";

package/dist/domain/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./user"), exports);
+__exportStar(require("./group"), exports);
+__exportStar(require("./event"), exports);
+__exportStar(require("./event-template"), exports);

package/dist/domain/user.d.ts

@@ -0,0 +1,20 @@
+import { LanguageType } from "../types";
+export declare class User {
+    private readonly userId;
+    private readonly firstName;
+    private readonly username?;
+    private language;
+    private constructor();
+    static create(params: {
+        userId: number;
+        firstName: string;
+        username?: string;
+        language?: LanguageType;
+    }): User;
+    getUserId(): number;
+    getFirstName(): string;
+    getUsername(): string | undefined;
+    getLanguage(): LanguageType;
+    setLanguage(language: LanguageType): void;
+    getFullName(): string;
+}

package/dist/domain/user.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+class User {
+    constructor(userId, firstName, username, language = "ru") {
+        this.userId = userId;
+        this.firstName = firstName;
+        this.username = username;
+        this.language = language;
+    }
+    static create(params) {
+        if (!params.firstName || !params.userId) {
+            throw new Error("User must have a first name and userId");
+        }
+        return new User(params.userId, params.firstName, params.username, params.language ?? "ru");
+    }
+    getUserId() {
+        return this.userId;
+    }
+    getFirstName() {
+        return this.firstName;
+    }
+    getUsername() {
+        return this.username;
+    }
+    getLanguage() {
+        return this.language;
+    }
+    setLanguage(language) {
+        this.language = language;
+    }
+    getFullName() {
+        return this.username
+            ? `${this.firstName} (${this.username})`
+            : this.firstName;
+    }
+}
+exports.User = User;

package/dist/index.d.ts

@@ -1,2 +1,6 @@
 export * from "./types";
+export * from "./utils";
+export * from "./domain";
+export * from "./ports";
 export * from "./mongo";
+export * from "./repositories";

package/dist/index.js

@@ -15,4 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./domain"), exports);
+__exportStar(require("./ports"), exports);
 __exportStar(require("./mongo"), exports);
+__exportStar(require("./repositories"), exports);

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

@@ -12,7 +12,7 @@ export interface EventDoc {
     matches: Match[];
     seasonName: string;
     status: EventStatus;
-    isRatingApplied?: boolean;
+    isRatingApplied: boolean;
     reportMessageId?: number;
 }
 export declare function createParticipantEventSchema(): Schema<ParticipantEvent, import("mongoose").Model<ParticipantEvent, any, any, any, import("mongoose").Document<unknown, any, ParticipantEvent> & ParticipantEvent & {

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

@@ -0,0 +1,11 @@
+import { EventTemplate } from "../domain/event-template";
+import { ParticipantEvent } from "../types";
+export interface IEventTemplatesRepository {
+    getById(templateId: number): Promise<EventTemplate | null>;
+    getByGroupId(groupId: number): Promise<EventTemplate[]>;
+    getAll(): Promise<EventTemplate[]>;
+    createFromDomain(entity: EventTemplate): Promise<EventTemplate | null>;
+    updateFromDomain(entity: EventTemplate): Promise<EventTemplate | null>;
+    deleteById(templateId: number): Promise<void>;
+    setDefaultParticipants(templateId: number, participants: ParticipantEvent[]): Promise<EventTemplate | null>;
+}

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

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

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

@@ -0,0 +1,29 @@
+import { Event } from "../domain/event";
+import { ParticipantEvent, Team, Match, EventStatus } from "../types";
+export type EventWrite = {
+    eventId: number;
+    groupId: number;
+    messageId: number;
+    templateId: number;
+    date: Date;
+    createdBy: number;
+    participants: ParticipantEvent[];
+    teams: Team[];
+    matches: Match[];
+    status: EventStatus;
+    seasonName: string;
+    isRatingApplied?: boolean;
+    reportMessageId?: number;
+};
+export interface EventsRepository {
+    create(eventData: EventWrite): Promise<Event>;
+    findById(eventId: number): Promise<Event | null>;
+    findByGroupAndStatuses(groupId: number, statuses: string[]): Promise<Event | null>;
+    findByTemplateAndGroup(templateId: number, groupId: number): Promise<Event | null>;
+    update(eventId: number, updates: Partial<EventWrite>): Promise<Event | null>;
+    findLastByGroup(groupId: number): Promise<Event | null>;
+    findAllByGroup(groupId: number): Promise<Event[]>;
+    countEvents(): Promise<number>;
+    countMatches(): Promise<number>;
+    getAll(): Promise<Event[]>;
+}

package/dist/ports/events.repository.js

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