ballrush-core 0.1.1

package/README.md

@@ -0,0 +1,21 @@
+# ballrush-core
+
+Shared core library for **Ballrush** project.  
+Contains TypeScript types and Mongoose schema factories (without models).
+
+## 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`)
+
+## Installation
+
+```bash
+npm install ballrush-core
+```
+
+License
+
+MIT © 2025 Serhii Zghama

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./mongo";

package/dist/index.js

@@ -0,0 +1,18 @@
+"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("./types"), exports);
+__exportStar(require("./mongo"), exports);

package/dist/mongo/index.d.ts

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

package/dist/mongo/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("./schemas/user.schema"), exports);
+__exportStar(require("./schemas/event-template.schema"), exports);
+__exportStar(require("./schemas/event.schema"), exports);
+__exportStar(require("./schemas/group.schema"), exports);

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

@@ -0,0 +1,24 @@
+import { Schema } from "mongoose";
+import { ParticipantEvent } from "../../types";
+export interface EventTemplateDoc {
+    templateId: number;
+    groupId: number;
+    adminId: number;
+    title: string;
+    description: 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;
+}
+export declare function createEventTemplateSchema(): Schema<EventTemplateDoc, import("mongoose").Model<EventTemplateDoc, any, any, any, import("mongoose").Document<unknown, any, EventTemplateDoc> & EventTemplateDoc & {
+    _id: import("mongoose").Types.ObjectId;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, EventTemplateDoc, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<EventTemplateDoc>> & import("mongoose").FlatRecord<EventTemplateDoc> & {
+    _id: import("mongoose").Types.ObjectId;
+}>;

package/dist/mongo/schemas/event-template.schema.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventTemplateSchema = createEventTemplateSchema;
+const mongoose_1 = require("mongoose");
+function createEventTemplateSchema() {
+    const DefaultParticipantSchema = new mongoose_1.Schema({
+        userId: { type: Number, required: true },
+        voteOption: { type: Number, required: true },
+        username: { type: String, required: true },
+        votedAt: { type: Date, required: true },
+    });
+    const schema = new mongoose_1.Schema({
+        templateId: { type: Number, required: true, unique: true, index: true },
+        groupId: { type: Number, required: true, index: true },
+        adminId: { type: Number, required: true },
+        title: { type: String, required: true },
+        description: { type: String, required: true },
+        preViewImg: { type: String, required: true },
+        options: { type: [String], required: true },
+        autoPost: { type: Boolean, required: true },
+        defaultTime: { type: String, required: true },
+        defaultDayOfWeek: { type: Number, enum: [0, 1, 2, 3, 4, 5, 6], required: true },
+        defaultLocation: { type: String, required: true },
+        defaultDuration: { type: String, required: true },
+        defaultParticipants: { type: [DefaultParticipantSchema], default: [] },
+        maxPlayers: { type: Number, required: true, min: 1 },
+        createdAt: { type: Date, default: Date.now },
+    });
+    return schema;
+}

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

@@ -0,0 +1,37 @@
+import { Schema } from "mongoose";
+import { EventStatus, Match, ParticipantEvent, Team } from "../../types";
+export interface EventDoc {
+    eventId: number;
+    groupId: number;
+    messageId: number;
+    templateId: number;
+    date: Date;
+    createdBy: number;
+    participants: ParticipantEvent[];
+    teams: Team[];
+    matches: Match[];
+    seasonName: string;
+    status: EventStatus;
+    isRatingApplied?: boolean;
+    reportMessageId?: number;
+}
+export declare function createParticipantEventSchema(): Schema<ParticipantEvent, import("mongoose").Model<ParticipantEvent, any, any, any, import("mongoose").Document<unknown, any, ParticipantEvent> & ParticipantEvent & {
+    _id: import("mongoose").Types.ObjectId;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, ParticipantEvent, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<ParticipantEvent>> & import("mongoose").FlatRecord<ParticipantEvent> & {
+    _id: import("mongoose").Types.ObjectId;
+}>;
+export declare function createTeamSchema(): Schema<Team, import("mongoose").Model<Team, any, any, any, import("mongoose").Document<unknown, any, Team> & Team & {
+    _id: import("mongoose").Types.ObjectId;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Team, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Team>> & import("mongoose").FlatRecord<Team> & {
+    _id: import("mongoose").Types.ObjectId;
+}>;
+export declare function createMatchSchema(): Schema<Match, import("mongoose").Model<Match, any, any, any, import("mongoose").Document<unknown, any, Match> & Match & {
+    _id: import("mongoose").Types.ObjectId;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Match, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Match>> & import("mongoose").FlatRecord<Match> & {
+    _id: import("mongoose").Types.ObjectId;
+}>;
+export declare function createEventSchema(): Schema<EventDoc, import("mongoose").Model<EventDoc, any, any, any, import("mongoose").Document<unknown, any, EventDoc> & EventDoc & {
+    _id: import("mongoose").Types.ObjectId;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, EventDoc, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<EventDoc>> & import("mongoose").FlatRecord<EventDoc> & {
+    _id: import("mongoose").Types.ObjectId;
+}>;

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createParticipantEventSchema = createParticipantEventSchema;
+exports.createTeamSchema = createTeamSchema;
+exports.createMatchSchema = createMatchSchema;
+exports.createEventSchema = createEventSchema;
+const mongoose_1 = require("mongoose");
+function createParticipantEventSchema() {
+    return new mongoose_1.Schema({
+        userId: { type: Number, required: true },
+        voteOption: { type: Number, required: true },
+        votedAt: { type: Date, required: true },
+        username: { type: String, required: true },
+    });
+}
+function createTeamSchema() {
+    return new mongoose_1.Schema({
+        teamId: { type: Number, required: true },
+        teamName: { type: String, required: true },
+        players: { type: [Number], required: true },
+    });
+}
+function createMatchSchema() {
+    return new mongoose_1.Schema({
+        matchId: { type: Number, required: true },
+        team1Id: { type: Number, required: true },
+        team2Id: { type: Number, required: true },
+        score: { type: [Number], required: true },
+        matchDate: { type: Date, required: true },
+    });
+}
+function createEventSchema() {
+    const ParticipantSchema = createParticipantEventSchema();
+    const TeamSchema = createTeamSchema();
+    const MatchSchema = createMatchSchema();
+    const EventSchema = new mongoose_1.Schema({
+        eventId: { type: Number, required: true, unique: true, index: true },
+        groupId: { type: Number, required: true },
+        messageId: { type: Number, required: true },
+        templateId: { type: Number, required: true },
+        date: { type: Date, required: true },
+        seasonName: { type: String, required: true },
+        createdBy: { type: Number, required: true },
+        participants: { type: [ParticipantSchema], default: [] },
+        teams: { type: [TeamSchema], default: [] },
+        matches: { type: [MatchSchema], default: [] },
+        isRatingApplied: { type: Boolean },
+        reportMessageId: { type: Number },
+        status: {
+            type: String,
+            enum: ["active", "in_progress", "completed"],
+            default: "active",
+        },
+    });
+    return EventSchema;
+}

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

@@ -0,0 +1,24 @@
+import { Schema } from "mongoose";
+import { ParticipantGroup, RatingPoint } from "../../types";
+export interface GroupDoc {
+    groupId: number;
+    groupName: string;
+    participants: ParticipantGroup[];
+    timezone: string;
+    isMessageLast: boolean;
+}
+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;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, RatingPoint, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<RatingPoint>> & import("mongoose").FlatRecord<RatingPoint> & {
+    _id: import("mongoose").Types.ObjectId;
+}>;
+export declare function createParticipantSchema(): Schema<ParticipantGroup, import("mongoose").Model<ParticipantGroup, any, any, any, import("mongoose").Document<unknown, any, ParticipantGroup> & ParticipantGroup & {
+    _id: import("mongoose").Types.ObjectId;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, ParticipantGroup, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<ParticipantGroup>> & import("mongoose").FlatRecord<ParticipantGroup> & {
+    _id: import("mongoose").Types.ObjectId;
+}>;
+export declare function createGroupSchema(): Schema<GroupDoc, import("mongoose").Model<GroupDoc, any, any, any, import("mongoose").Document<unknown, any, GroupDoc> & GroupDoc & {
+    _id: import("mongoose").Types.ObjectId;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, GroupDoc, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<GroupDoc>> & import("mongoose").FlatRecord<GroupDoc> & {
+    _id: import("mongoose").Types.ObjectId;
+}>;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRatingPointSchema = createRatingPointSchema;
+exports.createParticipantSchema = createParticipantSchema;
+exports.createGroupSchema = createGroupSchema;
+const mongoose_1 = require("mongoose");
+function createRatingPointSchema() {
+    return new mongoose_1.Schema({
+        value: { type: Number, required: true },
+        changedAt: { type: Date, default: Date.now },
+    });
+}
+function createParticipantSchema() {
+    const RatingPointSchema = createRatingPointSchema();
+    return new mongoose_1.Schema({
+        userId: { type: Number, required: true },
+        position: { type: String, required: true },
+        ratingHistory: { type: [RatingPointSchema], default: [] },
+        isAdmin: { type: Boolean, required: true },
+    });
+}
+function createGroupSchema() {
+    const ParticipantSchema = createParticipantSchema();
+    const GroupSchema = new mongoose_1.Schema({
+        groupId: { type: Number, required: true, unique: true, index: true },
+        groupName: { type: String, required: true },
+        participants: { type: [ParticipantSchema], default: [] },
+        timezone: { type: String, default: "UTC+0" },
+        isMessageLast: { type: Boolean, default: false },
+    });
+    return GroupSchema;
+}

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

@@ -0,0 +1,13 @@
+import { Schema } from "mongoose";
+import { LanguageType } from "../../types";
+export interface UserDoc {
+    firstName: string;
+    language: LanguageType;
+    userId: number;
+    username?: string;
+}
+export declare function createUserSchema(): Schema<UserDoc, import("mongoose").Model<UserDoc, any, any, any, import("mongoose").Document<unknown, any, UserDoc> & UserDoc & {
+    _id: import("mongoose").Types.ObjectId;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, UserDoc, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<UserDoc>> & import("mongoose").FlatRecord<UserDoc> & {
+    _id: import("mongoose").Types.ObjectId;
+}>;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUserSchema = createUserSchema;
+const mongoose_1 = require("mongoose");
+function createUserSchema() {
+    const UserSchema = new mongoose_1.Schema({
+        firstName: { type: String, required: true },
+        username: { type: String },
+        userId: { type: Number, required: true, unique: true, index: true },
+        language: { type: String, enum: ["ru", "en"], default: "ru" },
+    });
+    return UserSchema;
+}

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./shared";

package/dist/types/index.js

@@ -0,0 +1,17 @@
+"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("./shared"), exports);

package/dist/types/shared.d.ts

@@ -0,0 +1,147 @@
+export type EventStatus = "active" | "in_progress" | "completed";
+export type LanguageType = "en" | "ru";
+export type DayOfWeek = "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday";
+export interface ParticipantBase {
+    userId: number;
+}
+export interface ParticipantEvent extends ParticipantBase {
+    username: string;
+    voteOption: number;
+    votedAt: Date;
+}
+export interface ParticipantGroup extends ParticipantBase {
+    position: PlayerPosition;
+    ratingHistory: RatingPoint[];
+    isAdmin: boolean;
+}
+export interface TeamParticipant extends ParticipantBase {
+    username: string;
+    rating: number;
+    position: PlayerPosition;
+}
+export interface TeamGeneration {
+    participants: TeamParticipant[];
+    totalRating: number;
+}
+export interface TeamVariations {
+    [adminId: number]: TeamGeneration[][];
+}
+export interface Team {
+    teamId: number;
+    teamName: string;
+    players: number[];
+}
+export interface Match {
+    matchId: number;
+    team1Id: number;
+    team2Id: number;
+    score: [number, number];
+    matchDate: Date;
+}
+export interface TeamStats {
+    teamId: number;
+    teamName: string;
+    emoji: string;
+    games: number;
+    wins: number;
+    losses: number;
+    draws: number;
+    points: number;
+    goalsFor: number;
+    goalsAgainst: number;
+}
+export interface Header {
+    title: string;
+    key: string;
+    maxWidth?: number;
+}
+export declare enum PlayerPosition {
+    FW = "FW",// Нападающий (Forward)
+    MF = "MF",// Полузащитник (Midfielder)
+    DF = "DF",// Защитник (Defender)
+    GK = "GK",// Вратарь (Goalkeeper)
+    UN = "UN"
+}
+export interface SelectedParticipants {
+    [adminId: string]: Set<number>;
+}
+export interface SelectedParticipantsDate {
+    [adminId: string]: Map<number, Date>;
+}
+export interface RatingPoint {
+    value: number;
+    changedAt: Date;
+}
+export declare const ACHIEVEMENTS: {
+    readonly WinStreak: {
+        readonly emoji: "🔥";
+        readonly title: "Win Streak";
+        readonly type: "team";
+        readonly description: "Команда выиграла 3 матча подряд.";
+    };
+    readonly HardToBeat: {
+        readonly emoji: "💪";
+        readonly title: "Hard to Beat";
+        readonly type: "team";
+        readonly description: "Команда не проиграла в 5 матчах подряд (включая ничьи).";
+    };
+    readonly IronDefense: {
+        readonly emoji: "🛡️";
+        readonly title: "Iron Defense";
+        readonly type: "team";
+        readonly description: "Команда не пропустила ни одного гола в 3 матчах подряд.";
+    };
+    readonly PerfectHarmony: {
+        readonly emoji: "🤝";
+        readonly title: "Perfect Harmony";
+        readonly type: "team";
+        readonly description: "Команда сыграла 3 матча подряд вничью.";
+    };
+    readonly ConsistentWinners: {
+        readonly emoji: "⚡";
+        readonly title: "Consistent Winners";
+        readonly type: "team";
+        readonly description: "Команда не проиграла ни одного матча за вечер.";
+    };
+    readonly MVPTeam: {
+        readonly emoji: "🏆";
+        readonly title: "MVP Team";
+        readonly type: "team";
+        readonly description: "Команда показала лучший результат во всех ключевых показателях — победах, забитых мячах, набранных очках и наименьшем количестве пропущенных мячей.";
+    };
+};
+export type AchievementId = keyof typeof ACHIEVEMENTS;
+export interface TeamAchievement {
+    teamId: number;
+    achievement: Achievement;
+}
+export type AchievementType = 'team' | 'personal';
+export interface Achievement {
+    emoji: string;
+    title: string;
+    type: AchievementType;
+    description: string;
+}
+export type RenderMode = "view" | "edit";
+export interface DisplayOptions {
+    parseMode?: "HTML" | "Markdown" | undefined;
+    isChangeColor?: boolean;
+    teamIndexToChange?: number;
+    mode?: RenderMode;
+}
+export interface VariationContext {
+    chatId: number;
+    groupId: number;
+    variationIndex: number;
+    messageId: number;
+}
+export interface CursorPos {
+    teamIdx: number;
+    index: number;
+}
+export interface EditSession {
+    baseVariationIndex: number;
+    workingTeams: TeamGeneration[];
+    cursor: CursorPos;
+    selectedPlayerId: number | null;
+}

package/dist/types/shared.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACHIEVEMENTS = exports.PlayerPosition = void 0;
+var PlayerPosition;
+(function (PlayerPosition) {
+    PlayerPosition["FW"] = "FW";
+    PlayerPosition["MF"] = "MF";
+    PlayerPosition["DF"] = "DF";
+    PlayerPosition["GK"] = "GK";
+    PlayerPosition["UN"] = "UN";
+})(PlayerPosition || (exports.PlayerPosition = PlayerPosition = {}));
+exports.ACHIEVEMENTS = {
+    WinStreak: {
+        emoji: '🔥',
+        title: 'Win Streak',
+        type: 'team',
+        description: 'Команда выиграла 3 матча подряд.',
+    },
+    HardToBeat: {
+        emoji: '💪',
+        title: 'Hard to Beat',
+        type: 'team',
+        description: 'Команда не проиграла в 5 матчах подряд (включая ничьи).',
+    },
+    IronDefense: {
+        emoji: '🛡️',
+        title: 'Iron Defense',
+        type: 'team',
+        description: 'Команда не пропустила ни одного гола в 3 матчах подряд.',
+    },
+    PerfectHarmony: {
+        emoji: '🤝',
+        title: 'Perfect Harmony',
+        type: 'team',
+        description: 'Команда сыграла 3 матча подряд вничью.',
+    },
+    ConsistentWinners: {
+        emoji: '⚡',
+        title: 'Consistent Winners',
+        type: 'team',
+        description: 'Команда не проиграла ни одного матча за вечер.',
+    },
+    MVPTeam: {
+        emoji: '🏆',
+        title: 'MVP Team',
+        type: 'team',
+        description: 'Команда показала лучший результат во всех ключевых показателях — победах, забитых мячах, набранных очках и наименьшем количестве пропущенных мячей.',
+    },
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+    "name": "ballrush-core",
+    "version": "0.1.1",
+    "private": false,
+    "license": "MIT",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "files": [
+        "dist/**/*",
+        "README.md",
+        "LICENSE"
+    ],
+    "scripts": {
+        "build": "tsc -p tsconfig.json",
+        "clean": "rimraf dist",
+        "pack:check": "npm pack --dry-run",
+        "prepublishOnly": "npm run clean && npm run build && npm run pack:check"
+    },
+    "peerDependencies": {
+        "mongoose": "^7.0.0 || ^8.0.0"
+    },
+    "devDependencies": {
+        "typescript": "^5.9.0",
+        "rimraf": "^5.0.0",
+        "mongoose": "^7.8.7"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "sideEffects": false,
+    "engines": {
+        "node": ">=18"
+    },
+    "exports": {
+        ".": "./dist/index.js",
+        "./mongo": "./dist/mongo/index.js",
+        "./types": "./dist/types/index.js"
+    },
+    "typesVersions": {
+        "*": {
+            "mongo": [
+                "dist/mongo/index.d.ts"
+            ],
+            "types": [
+                "dist/types/index.d.ts"
+            ]
+        }
+    },
+    "keywords": [
+        "mongoose",
+        "schemas",
+        "typescript",
+        "ddd",
+        "telegram-bot",
+        "ballrush"
+    ]
+}