@zumito-team/analytics-module 0.1.0

package/models/VoiceChannelDailyStats.js

@@ -0,0 +1,31 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Collection, Field } from 'zumito-framework';
+let VoiceChannelDailyStats = class VoiceChannelDailyStats {
+};
+__decorate([
+    Field({ type: 'string', primary: true, unique: true })
+], VoiceChannelDailyStats.prototype, "id", void 0);
+__decorate([
+    Field({ type: 'string' })
+], VoiceChannelDailyStats.prototype, "guild_id", void 0);
+__decorate([
+    Field({ type: 'string' })
+], VoiceChannelDailyStats.prototype, "channel_id", void 0);
+__decorate([
+    Field({ type: 'string' })
+], VoiceChannelDailyStats.prototype, "date", void 0);
+__decorate([
+    Field({ type: 'number', default: 0 })
+], VoiceChannelDailyStats.prototype, "total_minutes", void 0);
+__decorate([
+    Field({ type: 'number', default: 0 })
+], VoiceChannelDailyStats.prototype, "unique_users", void 0);
+VoiceChannelDailyStats = __decorate([
+    Collection({ name: 'analytics_voice_channel_daily_stats' })
+], VoiceChannelDailyStats);
+export { VoiceChannelDailyStats };

package/models/VoiceChannelDailyStats.ts

@@ -0,0 +1,22 @@
+import { Collection, Field } from 'zumito-framework';
+
+@Collection({ name: 'analytics_voice_channel_daily_stats' })
+export class VoiceChannelDailyStats {
+    @Field({ type: 'string', primary: true, unique: true })
+    id!: string;
+
+    @Field({ type: 'string' })
+    guild_id!: string;
+
+    @Field({ type: 'string' })
+    channel_id!: string;
+
+    @Field({ type: 'string' })
+    date!: string;
+
+    @Field({ type: 'number', default: 0 })
+    total_minutes!: number;
+
+    @Field({ type: 'number', default: 0 })
+    unique_users!: number;
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@zumito-team/analytics-module",
+  "version": "0.1.0",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "description": "Server analytics module with configurable tracking and optional panel integration",
+  "type": "module",
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@zumito-team/admin-module": "^1.8.0",
+    "@zumito-team/user-panel-module": "^0.10.0",
+    "ejs": "^3.1.10",
+    "zumito-framework": "^1.22.2"
+  },
+  "devDependencies": {
+    "@types/ejs": "^3.1.5",
+    "typescript": "^5.9.3"
+  }
+}

package/routes/AdminAnalytics.d.ts

@@ -0,0 +1,11 @@
+import { Route, RouteMethod } from 'zumito-framework';
+import { Client } from 'zumito-framework/discord';
+import { AnalyticsCollector } from '../services/AnalyticsCollector.js';
+export declare class AdminAnalytics extends Route {
+    private collector;
+    private client;
+    method: RouteMethod;
+    path: string;
+    constructor(collector?: AnalyticsCollector, client?: Client);
+    execute(req: any, res: any): Promise<void>;
+}

package/routes/AdminAnalytics.js

@@ -0,0 +1,55 @@
+import { Route, RouteMethod, ServiceContainer } from 'zumito-framework';
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { Client } from 'zumito-framework/discord';
+import { AnalyticsCollector } from '../services/AnalyticsCollector.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class AdminAnalytics extends Route {
+    constructor(collector = ServiceContainer.getService(AnalyticsCollector), client = ServiceContainer.getService(Client)) {
+        super();
+        this.collector = collector;
+        this.client = client;
+        this.method = RouteMethod.get;
+        this.path = '/admin/analytics';
+    }
+    async execute(req, res) {
+        const { AdminAuthService } = await import('@zumito-team/admin-module/services/AdminAuthService.js');
+        const auth = await ServiceContainer.getService(AdminAuthService).isLoginValid(req);
+        if (!auth?.isValid)
+            return res.redirect('/admin/login');
+        const daysBack = parseInt(req.query.days) || 7;
+        const summary = await this.collector.getGlobalStatsSummary(daysBack);
+        const guildGrowth = await this.collector.getGuildGrowth(daysBack);
+        const messagesPerDay = await this.collector.getMessagesPerDay(daysBack);
+        const commandsPerDay = await this.collector.getCommandsPerDay(null, daysBack);
+        const topCommands = await this.collector.getTopCommands(null, daysBack);
+        const slowestCommands = await this.collector.getSlowestCommands(null, daysBack);
+        const chartData = {
+            guildGrowth,
+            messagesPerDay,
+            commandsPerDay,
+            topCommands,
+            slowestCommands,
+        };
+        const { TranslationManager } = await import('zumito-framework');
+        const tm = ServiceContainer.getService(TranslationManager);
+        const t = (key, params) => tm.get(key, 'en', params);
+        const content = await ejs.renderFile(path.resolve(__dirname, '../views/admin-analytics.ejs'), {
+            summary,
+            chartData,
+            slowestCommands: slowestCommands.length > 0 ? slowestCommands : undefined,
+            t,
+            daysBack,
+        });
+        const { AdminViewService } = await import('@zumito-team/admin-module/services/AdminViewService.js');
+        const view = ServiceContainer.getService(AdminViewService);
+        const html = await view.render({
+            title: 'Analiticas',
+            content,
+            reqPath: this.path,
+            user: { name: 'Admin' },
+        });
+        res.send(html);
+    }
+}

package/routes/AdminAnalytics.ts

@@ -0,0 +1,69 @@
+import { Route, RouteMethod, ServiceContainer } from 'zumito-framework';
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { Client } from 'zumito-framework/discord';
+import { AnalyticsCollector } from '../services/AnalyticsCollector.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export class AdminAnalytics extends Route {
+    method = RouteMethod.get;
+    path = '/admin/analytics';
+
+    constructor(
+        private collector: AnalyticsCollector = ServiceContainer.getService(AnalyticsCollector) as AnalyticsCollector,
+        private client: Client = ServiceContainer.getService(Client),
+    ) {
+        super();
+    }
+
+    async execute(req: any, res: any): Promise<void> {
+        const { AdminAuthService } = await import('@zumito-team/admin-module/services/AdminAuthService.js');
+        const auth = await ServiceContainer.getService(AdminAuthService).isLoginValid(req);
+        if (!auth?.isValid) return res.redirect('/admin/login');
+
+        const daysBack = parseInt(req.query.days as string) || 7;
+
+        const summary = await this.collector.getGlobalStatsSummary(daysBack);
+        const guildGrowth = await this.collector.getGuildGrowth(daysBack);
+        const messagesPerDay = await this.collector.getMessagesPerDay(daysBack);
+        const commandsPerDay = await this.collector.getCommandsPerDay(null, daysBack);
+        const topCommands = await this.collector.getTopCommands(null, daysBack);
+        const slowestCommands = await this.collector.getSlowestCommands(null, daysBack);
+
+        const chartData = {
+            guildGrowth,
+            messagesPerDay,
+            commandsPerDay,
+            topCommands,
+            slowestCommands,
+        };
+
+        const { TranslationManager } = await import('zumito-framework');
+        const tm = ServiceContainer.getService(TranslationManager) as any;
+        const t = (key: string, params?: any) => tm.get(key, 'en', params);
+
+        const content = await ejs.renderFile(
+            path.resolve(__dirname, '../views/admin-analytics.ejs'),
+            {
+                summary,
+                chartData,
+                slowestCommands: slowestCommands.length > 0 ? slowestCommands : undefined,
+                t,
+                daysBack,
+            },
+        );
+
+        const { AdminViewService } = await import('@zumito-team/admin-module/services/AdminViewService.js');
+        const view = ServiceContainer.getService(AdminViewService);
+        const html = await view.render({
+            title: 'Analiticas',
+            content,
+            reqPath: this.path,
+            user: { name: 'Admin' },
+        });
+
+        res.send(html);
+    }
+}

package/routes/UserPanelAnalytics.d.ts

@@ -0,0 +1,11 @@
+import { Route, RouteMethod } from 'zumito-framework';
+import { Client } from 'zumito-framework/discord';
+import { AnalyticsCollector } from '../services/AnalyticsCollector.js';
+export declare class UserPanelAnalytics extends Route {
+    private collector;
+    private client;
+    method: RouteMethod;
+    path: string;
+    constructor(collector?: AnalyticsCollector, client?: Client);
+    execute(req: any, res: any): Promise<void>;
+}

package/routes/UserPanelAnalytics.js

@@ -0,0 +1,81 @@
+import { Route, RouteMethod, ServiceContainer } from 'zumito-framework';
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { Client, PermissionFlagsBits } from 'zumito-framework/discord';
+import { AnalyticsCollector } from '../services/AnalyticsCollector.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class UserPanelAnalytics extends Route {
+    constructor(collector = ServiceContainer.getService(AnalyticsCollector), client = ServiceContainer.getService(Client)) {
+        super();
+        this.collector = collector;
+        this.client = client;
+        this.method = RouteMethod.get;
+        this.path = '/panel/:guildId/analytics';
+    }
+    async execute(req, res) {
+        const { UserPanelAuthService } = await import('@zumito-team/user-panel-module/services/UserPanelAuthService');
+        const { UserPanelViewService } = await import('@zumito-team/user-panel-module/services/UserPanelViewService');
+        const { UserPanelLanguageManager } = await import('@zumito-team/user-panel-module/services/UserPanelLanguageManager');
+        const authService = ServiceContainer.getService(UserPanelAuthService);
+        const authData = await authService.isLoginValid(req);
+        if (!authData.isValid)
+            return res.redirect('/panel/login');
+        const userId = authData.data.discordUserData.id;
+        const guildId = req.params.guildId;
+        const guild = this.client.guilds.cache.get(guildId);
+        if (!guild)
+            return res.status(404).send('Server not found');
+        let member = guild.members.cache.get(userId);
+        if (!member)
+            member = await guild.members.fetch(userId).catch(() => null);
+        if (!member || !(member.permissions.has(PermissionFlagsBits.Administrator) ||
+            member.permissions.has(PermissionFlagsBits.ManageGuild) ||
+            guild.ownerId === userId)) {
+            return res.status(403).send('No tienes permisos en este servidor');
+        }
+        const daysBack = parseInt(req.query.days) || 7;
+        const langMgr = ServiceContainer.getService(UserPanelLanguageManager);
+        const { t } = langMgr.getLanguageVariables(req, res);
+        const stats = await this.collector.getGuildStats(guildId, daysBack);
+        let guildSummary = {
+            totalMessages: 0, totalJoins: 0, totalLeaves: 0,
+            totalVoiceMinutes: 0, totalCommands: 0,
+        };
+        const joinsPerDay = [];
+        const leavesPerDay = [];
+        const messagesPerDay = [];
+        const voicePerDay = [];
+        for (const s of stats) {
+            guildSummary.totalMessages += s.message_count;
+            guildSummary.totalJoins += s.join_count;
+            guildSummary.totalLeaves += s.leave_count;
+            guildSummary.totalVoiceMinutes += s.voice_minutes;
+            guildSummary.totalCommands += s.command_count;
+            messagesPerDay.push({ date: s.date, count: s.message_count });
+            joinsPerDay.push({ date: s.date, count: s.join_count });
+            leavesPerDay.push({ date: s.date, count: s.leave_count });
+            voicePerDay.push({ date: s.date, count: s.voice_minutes });
+        }
+        const commandsPerDay = await this.collector.getCommandsPerDay(guildId, daysBack);
+        const topCommands = await this.collector.getTopCommands(guildId, daysBack);
+        const slowestCommands = await this.collector.getSlowestCommands(guildId, daysBack);
+        const channelVoice = await this.collector.getVoiceChannelStats(guildId, daysBack);
+        const chartData = {
+            messagesPerDay, joinsPerDay, leavesPerDay, voicePerDay,
+            commandsPerDay, topCommands, slowestCommands, channelVoice,
+        };
+        const config = await this.collector.getConfig(guildId);
+        const content = await ejs.renderFile(path.resolve(__dirname, '../views/user-analytics.ejs'), {
+            guildSummary,
+            chartData,
+            slowestCommands: (config.track_command_performance && slowestCommands.length > 0) ? slowestCommands : undefined,
+            channelVoice: (config.track_per_channel_voice && channelVoice.length > 0) ? channelVoice : undefined,
+            t,
+            daysBack,
+        });
+        const view = ServiceContainer.getService(UserPanelViewService);
+        const html = await view.render({ content, reqPath: req.path, req, res });
+        res.send(html);
+    }
+}

package/routes/UserPanelAnalytics.ts

@@ -0,0 +1,101 @@
+import { Route, RouteMethod, ServiceContainer } from 'zumito-framework';
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { Client, PermissionFlagsBits } from 'zumito-framework/discord';
+import { AnalyticsCollector } from '../services/AnalyticsCollector.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export class UserPanelAnalytics extends Route {
+    method = RouteMethod.get;
+    path = '/panel/:guildId/analytics';
+
+    constructor(
+        private collector: AnalyticsCollector = ServiceContainer.getService(AnalyticsCollector) as AnalyticsCollector,
+        private client: Client = ServiceContainer.getService(Client) as Client,
+    ) {
+        super();
+    }
+
+    async execute(req: any, res: any): Promise<void> {
+        const { UserPanelAuthService } = await import('@zumito-team/user-panel-module/services/UserPanelAuthService');
+        const { UserPanelViewService } = await import('@zumito-team/user-panel-module/services/UserPanelViewService');
+        const { UserPanelLanguageManager } = await import('@zumito-team/user-panel-module/services/UserPanelLanguageManager');
+
+        const authService = ServiceContainer.getService(UserPanelAuthService);
+        const authData = await authService.isLoginValid(req);
+        if (!authData.isValid) return res.redirect('/panel/login');
+
+        const userId = authData.data.discordUserData.id;
+        const guildId = req.params.guildId as string;
+        const guild = this.client.guilds.cache.get(guildId);
+        if (!guild) return res.status(404).send('Server not found');
+
+        let member = guild.members.cache.get(userId);
+        if (!member) member = await guild.members.fetch(userId).catch(() => null);
+        if (!member || !(
+            member.permissions.has(PermissionFlagsBits.Administrator) ||
+            member.permissions.has(PermissionFlagsBits.ManageGuild) ||
+            guild.ownerId === userId
+        )) {
+            return res.status(403).send('No tienes permisos en este servidor');
+        }
+
+        const daysBack = parseInt(req.query.days as string) || 7;
+        const langMgr = ServiceContainer.getService(UserPanelLanguageManager);
+        const { t } = langMgr.getLanguageVariables(req, res);
+
+        const stats = await this.collector.getGuildStats(guildId, daysBack);
+
+        let guildSummary = {
+            totalMessages: 0, totalJoins: 0, totalLeaves: 0,
+            totalVoiceMinutes: 0, totalCommands: 0,
+        };
+        const joinsPerDay: { date: string; count: number }[] = [];
+        const leavesPerDay: { date: string; count: number }[] = [];
+        const messagesPerDay: { date: string; count: number }[] = [];
+        const voicePerDay: { date: string; count: number }[] = [];
+
+        for (const s of stats) {
+            guildSummary.totalMessages += s.message_count;
+            guildSummary.totalJoins += s.join_count;
+            guildSummary.totalLeaves += s.leave_count;
+            guildSummary.totalVoiceMinutes += s.voice_minutes;
+            guildSummary.totalCommands += s.command_count;
+
+            messagesPerDay.push({ date: s.date, count: s.message_count });
+            joinsPerDay.push({ date: s.date, count: s.join_count });
+            leavesPerDay.push({ date: s.date, count: s.leave_count });
+            voicePerDay.push({ date: s.date, count: s.voice_minutes });
+        }
+
+        const commandsPerDay = await this.collector.getCommandsPerDay(guildId, daysBack);
+        const topCommands = await this.collector.getTopCommands(guildId, daysBack);
+        const slowestCommands = await this.collector.getSlowestCommands(guildId, daysBack);
+        const channelVoice = await this.collector.getVoiceChannelStats(guildId, daysBack);
+
+        const chartData = {
+            messagesPerDay, joinsPerDay, leavesPerDay, voicePerDay,
+            commandsPerDay, topCommands, slowestCommands, channelVoice,
+        };
+
+        const config = await this.collector.getConfig(guildId);
+
+        const content = await ejs.renderFile(
+            path.resolve(__dirname, '../views/user-analytics.ejs'),
+            {
+                guildSummary,
+                chartData,
+                slowestCommands: (config.track_command_performance && slowestCommands.length > 0) ? slowestCommands : undefined,
+                channelVoice: (config.track_per_channel_voice && channelVoice.length > 0) ? channelVoice : undefined,
+                t,
+                daysBack,
+            },
+        );
+
+        const view = ServiceContainer.getService(UserPanelViewService);
+        const html = await view.render({ content, reqPath: req.path, req, res });
+        res.send(html);
+    }
+}

package/services/AnalyticsCollector.d.ts

@@ -0,0 +1,62 @@
+import { GuildDailyStats } from '../models/GuildDailyStats.js';
+import { CommandDailyStats } from '../models/CommandDailyStats.js';
+import { VoiceChannelDailyStats } from '../models/VoiceChannelDailyStats.js';
+import { GuildAnalyticsConfig } from '../models/GuildAnalyticsConfig.js';
+export interface CommandExecutedPayload {
+    guildId: string;
+    commandName: string;
+    type: 'prefix' | 'slash';
+    executionTimeMs: number;
+    success: boolean;
+}
+export declare class AnalyticsCollector {
+    private db;
+    private voiceSessions;
+    private dailyVoiceUsers;
+    private cleanupTimer;
+    constructor(db?: any);
+    private repo;
+    private ensuredConfig;
+    recordMessage(guildId: string): Promise<void>;
+    recordMemberJoin(guildId: string): Promise<void>;
+    recordMemberLeave(guildId: string): Promise<void>;
+    recordVoiceJoin(guildId: string, channelId: string, userId: string): Promise<void>;
+    recordVoiceLeave(guildId: string, channelId: string, userId: string): Promise<void>;
+    recordVoiceMinutes(guildId: string, channelId: string, minutes: number, userIds: Set<string>): Promise<void>;
+    recordCommand(payload: CommandExecutedPayload): Promise<void>;
+    recordMemberCount(guildId: string, memberCount: number): Promise<void>;
+    private upsertGuildStats;
+    getGuildStats(guildId: string, daysBack: number): Promise<GuildDailyStats[]>;
+    getGlobalStatsSummary(daysBack: number): Promise<{
+        totalGuilds: number;
+        totalMessages: number;
+        totalCommands: number;
+        totalVoiceMinutes: number;
+        totalJoins: number;
+        totalLeaves: number;
+    }>;
+    getGuildGrowth(daysBack: number): Promise<{
+        date: string;
+        guildCount: number;
+    }[]>;
+    getMessagesPerDay(daysBack: number): Promise<{
+        date: string;
+        count: number;
+    }[]>;
+    getCommandsPerDay(guildId: string | null, daysBack: number): Promise<{
+        date: string;
+        count: number;
+    }[]>;
+    getTopCommands(guildId: string | null, daysBack: number, limit?: number): Promise<CommandDailyStats[]>;
+    getSlowestCommands(guildId: string | null, daysBack: number, limit?: number): Promise<(CommandDailyStats & {
+        avgExecutionTimeMs: number;
+    })[]>;
+    getVoiceChannelStats(guildId: string, daysBack: number): Promise<VoiceChannelDailyStats[]>;
+    getConfig(guildId: string): Promise<GuildAnalyticsConfig>;
+    updateConfig(guildId: string, partial: Partial<GuildAnalyticsConfig>): Promise<void>;
+    runCleanup(): Promise<void>;
+    startCleanupScheduler(): void;
+    stopCleanupScheduler(): void;
+    clearVoiceSessions(): void;
+    private dateDaysAgo;
+}