@zumito-team/analytics-module 0.8.0 → 0.9.0

package/README.md

@@ -8,7 +8,34 @@
 npm install @zumito-team/analytics-module
 ```
 
-Add to your `zumito.config.ts` (note the `/dist` suffix):
+Add to your `zumito.config.ts`:
+
+### Modules (recommended)
+
+```ts
+import { defineConfig } from 'zumito-framework';
+import { analyticsModule } from '@zumito-team/analytics-module';
+
+export default defineConfig({
+    modules: [
+        analyticsModule({
+            defaultTrackCommandPerformance: true,
+        }),
+    ]
+});
+```
+
+Or with plain string:
+
+```ts
+import { defineConfig } from 'zumito-framework';
+
+export default defineConfig({
+    modules: ['@zumito-team/analytics-module']
+});
+```
+
+### Legacy bundles
 
 ```ts
 {

package/dist/config.d.ts

@@ -7,5 +7,6 @@ export declare class AnalyticsModuleConfig {
     static defaultTrackCommands: boolean;
     static defaultTrackCommandPerformance: boolean;
     static defaultTrackPerChannelVoice: boolean;
+    static defaultTrackPerChannelMessages: boolean;
     static configure(opts: Partial<typeof AnalyticsModuleConfig>): void;
 }

package/dist/config.js

@@ -11,3 +11,4 @@ AnalyticsModuleConfig.defaultTrackMembers = true;
 AnalyticsModuleConfig.defaultTrackCommands = true;
 AnalyticsModuleConfig.defaultTrackCommandPerformance = false;
 AnalyticsModuleConfig.defaultTrackPerChannelVoice = false;
+AnalyticsModuleConfig.defaultTrackPerChannelMessages = false;

package/dist/index.d.ts

@@ -8,6 +8,18 @@ export declare class AnalyticsModule extends Module {
     initialize(): Promise<void>;
     onAllReady(): Promise<void>;
 }
+export interface AnalyticsModuleEntryConfig {
+    defaultRetentionDays?: number;
+    cleanupIntervalHours?: number;
+    defaultTrackMessages?: boolean;
+    defaultTrackVoice?: boolean;
+    defaultTrackMembers?: boolean;
+    defaultTrackCommands?: boolean;
+    defaultTrackCommandPerformance?: boolean;
+    defaultTrackPerChannelVoice?: boolean;
+    defaultTrackPerChannelMessages?: boolean;
+}
+export declare const analyticsModule: (config?: AnalyticsModuleEntryConfig) => import("zumito-framework").ModuleEntry;
 export { AnalyticsCollector } from './services/AnalyticsCollector.js';
 export type { CommandExecutedPayload } from './services/AnalyticsCollector.js';
 export { AnalyticsModuleConfig } from './config.js';

package/dist/index.js

@@ -1,10 +1,12 @@
 import 'reflect-metadata';
-import { Module, ServiceContainer } from 'zumito-framework';
+import { Module, ServiceContainer, createModuleEntry } from 'zumito-framework';
 import { AnalyticsCollector } from './services/AnalyticsCollector.js';
+import { AnalyticsModuleConfig } from './config.js';
 export class AnalyticsModule extends Module {
     constructor(modulePath = import.meta.url) {
         super(modulePath);
         ServiceContainer.addService(AnalyticsCollector, [], true);
+        AnalyticsModuleConfig.configure(this.moduleConfig);
     }
     async initialize() {
         await super.initialize();
@@ -84,6 +86,7 @@ export class AnalyticsModule extends Module {
 AnalyticsModule.moduleName = 'analytics-module';
 AnalyticsModule.dependencies = [];
 AnalyticsModule.optionalDependencies = ['admin-module', 'user-panel-module'];
+export const analyticsModule = createModuleEntry(import.meta.url);
 export { AnalyticsCollector } from './services/AnalyticsCollector.js';
 export { AnalyticsModuleConfig } from './config.js';
 export { GuildDailyStats } from './models/GuildDailyStats.js';

package/dist/models/CommandExecuted.d.ts

@@ -0,0 +1,9 @@
+export declare class CommandExecuted {
+    id: string;
+    guild_id: string;
+    command_name: string;
+    type: 'slash' | 'prefix';
+    execution_time_ms: number;
+    error: boolean;
+    executed_at: string;
+}

package/dist/models/CommandExecuted.js

@@ -0,0 +1,34 @@
+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 CommandExecuted = class CommandExecuted {
+};
+__decorate([
+    Field({ type: 'string', primary: true, unique: true })
+], CommandExecuted.prototype, "id", void 0);
+__decorate([
+    Field({ type: 'string' })
+], CommandExecuted.prototype, "guild_id", void 0);
+__decorate([
+    Field({ type: 'string' })
+], CommandExecuted.prototype, "command_name", void 0);
+__decorate([
+    Field({ type: 'string' })
+], CommandExecuted.prototype, "type", void 0);
+__decorate([
+    Field({ type: 'number', default: 0 })
+], CommandExecuted.prototype, "execution_time_ms", void 0);
+__decorate([
+    Field({ type: 'boolean', default: false })
+], CommandExecuted.prototype, "error", void 0);
+__decorate([
+    Field({ type: 'string' })
+], CommandExecuted.prototype, "executed_at", void 0);
+CommandExecuted = __decorate([
+    Collection({ name: 'analytics_commands_executed' })
+], CommandExecuted);
+export { CommandExecuted };

package/dist/models/GuildAnalyticsConfig.d.ts

@@ -7,6 +7,7 @@ export declare class GuildAnalyticsConfig {
     track_commands: boolean;
     track_command_performance: boolean;
     track_per_channel_voice: boolean;
+    track_per_channel_messages: boolean;
     retention_days: number;
     public_stats_page: boolean;
 }

package/dist/models/GuildAnalyticsConfig.js

@@ -31,6 +31,9 @@ __decorate([
 __decorate([
     Field({ type: 'boolean', default: false })
 ], GuildAnalyticsConfig.prototype, "track_per_channel_voice", void 0);
+__decorate([
+    Field({ type: 'boolean', default: false })
+], GuildAnalyticsConfig.prototype, "track_per_channel_messages", void 0);
 __decorate([
     Field({ type: 'number' })
 ], GuildAnalyticsConfig.prototype, "retention_days", void 0);

package/dist/routes/AdminAnalyticsCommands.js

@@ -18,9 +18,11 @@ export class AdminAnalyticsCommands extends Route {
             return res.redirect('/admin/login');
         const daysBack = parseInt(req.query.days) || 7;
         const commandsPerDay = await this.collector.getCommandsPerDay(null, daysBack);
+        const commandsPerDayByType = await this.collector.getCommandsPerDayByType(null, daysBack);
+        const commandsByType = await this.collector.getCommandsByType(null, daysBack);
         const topCommands = await this.collector.getTopCommands(null, daysBack, 15);
         const slowestCommands = await this.collector.getSlowestCommands(null, daysBack, 10);
-        const content = await ejs.renderFile(path.resolve(__dirname, '../views/admin-analytics-commands.ejs'), { commandsPerDay, topCommands, slowestCommands, daysBack });
+        const content = await ejs.renderFile(path.resolve(__dirname, '../views/admin-analytics-commands.ejs'), { commandsPerDay, commandsPerDayByType, commandsByType, topCommands, slowestCommands, daysBack });
         const { AdminViewService } = await import('@zumito-team/admin-module/services/AdminViewService.js');
         const view = ServiceContainer.getService(AdminViewService);
         const html = await view.render({

package/dist/routes/UserPanelAnalyticsCommands.js

@@ -37,10 +37,10 @@ export class UserPanelAnalyticsCommands extends Route {
         const langMgr = ServiceContainer.getService(UserPanelLanguageManager);
         const { t } = langMgr.getLanguageVariables(req, res);
         const commandsPerDay = await this.collector.getCommandsPerDay(guildId, daysBack);
+        const commandsPerDayByType = await this.collector.getCommandsPerDayByType(guildId, daysBack);
+        const commandsByType = await this.collector.getCommandsByType(guildId, daysBack);
         const topCommands = await this.collector.getTopCommands(guildId, daysBack, 15);
-        const slowestCommands = await this.collector.getSlowestCommands(guildId, daysBack, 10);
-        const config = await this.collector.getConfig(guildId);
-        const content = await ejs.renderFile(path.resolve(__dirname, '../views/user-analytics-commands.ejs'), { commandsPerDay, topCommands, slowestCommands: config.track_command_performance ? slowestCommands : null, t, daysBack });
+        const content = await ejs.renderFile(path.resolve(__dirname, '../views/user-analytics-commands.ejs'), { commandsPerDay, commandsPerDayByType, commandsByType, topCommands, t, daysBack });
         const view = ServiceContainer.getService(UserPanelViewService);
         const html = await view.render({ content, reqPath: req.path, req, res });
         res.send(html);

package/dist/services/AnalyticsCollector.d.ts

@@ -1,5 +1,4 @@
 import { GuildDailyStats } from '../models/GuildDailyStats.js';
-import { CommandDailyStats } from '../models/CommandDailyStats.js';
 import { VoiceChannelDailyStats } from '../models/VoiceChannelDailyStats.js';
 import { GuildAnalyticsConfig } from '../models/GuildAnalyticsConfig.js';
 import { ChannelMessageStats } from '../models/ChannelMessageStats.js';
@@ -46,14 +45,30 @@ export declare class AnalyticsCollector {
         date: string;
         count: number;
     }[]>;
+    private getCommandExecutedRows;
+    private getCommandDailyStatsRows;
     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 & {
+    getCommandsPerDayByType(guildId: string | null, daysBack: number): Promise<{
+        date: string;
+        slash: number;
+        prefix: number;
+    }[]>;
+    getCommandsByType(guildId: string | null, daysBack: number): Promise<{
+        slash: number;
+        prefix: number;
+    }>;
+    getTopCommands(guildId: string | null, daysBack: number, limit?: number): Promise<{
+        command_name: string;
+        usage_count: number;
+    }[]>;
+    getSlowestCommands(guildId: string | null, daysBack: number, limit?: number): Promise<{
+        command_name: string;
         avgExecutionTimeMs: number;
-    })[]>;
+        total_executions: number;
+    }[]>;
     getVoiceChannelStats(guildId: string, daysBack: number): Promise<VoiceChannelDailyStats[]>;
     getChannelMessageStats(guildId: string, daysBack: number): Promise<ChannelMessageStats[]>;
     getConfig(guildId: string): Promise<GuildAnalyticsConfig>;

package/dist/services/AnalyticsCollector.js

@@ -1,6 +1,7 @@
 import { DatabaseManager, ServiceContainer } from 'zumito-framework';
 import { GuildDailyStats } from '../models/GuildDailyStats.js';
 import { CommandDailyStats } from '../models/CommandDailyStats.js';
+import { CommandExecuted } from '../models/CommandExecuted.js';
 import { VoiceChannelDailyStats } from '../models/VoiceChannelDailyStats.js';
 import { GuildAnalyticsConfig } from '../models/GuildAnalyticsConfig.js';
 import { ChannelMessageStats } from '../models/ChannelMessageStats.js';
@@ -35,6 +36,7 @@ export class AnalyticsCollector {
             track_commands: AnalyticsModuleConfig.defaultTrackCommands,
             track_command_performance: AnalyticsModuleConfig.defaultTrackCommandPerformance,
             track_per_channel_voice: AnalyticsModuleConfig.defaultTrackPerChannelVoice,
+            track_per_channel_messages: AnalyticsModuleConfig.defaultTrackPerChannelMessages,
             retention_days: AnalyticsModuleConfig.defaultRetentionDays,
             public_stats_page: false,
         };
@@ -55,7 +57,7 @@ export class AnalyticsCollector {
             this.dailyMessageAuthors.get(authorKey).add(authorId);
         }
         // Track per-channel stats
-        if (channelId && config.track_per_channel_voice) {
+        if (channelId && config.track_per_channel_messages) {
             const date = today();
             const chanKey = `${guildId}_${channelId}_${date}`;
             const repo = this.repo(ChannelMessageStats);
@@ -163,29 +165,17 @@ export class AnalyticsCollector {
             return;
         await this.upsertGuildStats(payload.guildId, { command_count: 1 });
         const date = today();
-        const id = `${payload.guildId}_${payload.commandName}_${date}`;
-        const repo = this.repo(CommandDailyStats);
-        const existing = await repo.findOne({ id });
-        const executionTime = config.track_command_performance ? payload.executionTimeMs : 0;
-        const errorAdd = payload.success ? 0 : 1;
-        if (existing) {
-            await repo.update({ id }, {
-                usage_count: existing.usage_count + 1,
-                total_execution_time_ms: existing.total_execution_time_ms + executionTime,
-                error_count: existing.error_count + errorAdd,
-            });
-        }
-        else {
-            await repo.insert({
-                id,
-                guild_id: payload.guildId,
-                command_name: payload.commandName,
-                date,
-                usage_count: 1,
-                total_execution_time_ms: executionTime,
-                error_count: errorAdd,
-            });
-        }
+        const id = `${payload.guildId}_${payload.commandName}_${Date.now()}`;
+        const repo = this.repo(CommandExecuted);
+        await repo.insert({
+            id,
+            guild_id: payload.guildId,
+            command_name: payload.commandName,
+            type: payload.type,
+            execution_time_ms: payload.executionTimeMs,
+            error: !payload.success,
+            executed_at: date,
+        });
     }
     async recordMemberCount(guildId, memberCount) {
         const config = await this.ensuredConfig(guildId);
@@ -306,125 +296,125 @@ export class AnalyticsCollector {
             .map(([date, count]) => ({ date, count }))
             .sort((a, b) => a.date.localeCompare(b.date));
     }
-    async getCommandsPerDay(guildId, daysBack) {
-        const repo = this.repo(GuildDailyStats);
+    async getCommandExecutedRows(guildId, daysBack) {
+        const repo = this.repo(CommandExecuted);
         const dateMin = this.dateDaysAgo(daysBack);
-        let rows;
+        let rows = await repo.query()
+            .where('executed_at', 'gte', dateMin)
+            .exec();
         if (guildId) {
-            rows = await repo.query()
-                .where('guild_id', 'eq', guildId)
-                .where('date', 'gte', dateMin)
-                .sort('date', 'asc')
-                .exec();
+            rows = rows.filter(r => r.guild_id === guildId);
         }
-        else {
-            rows = await repo.query()
-                .where('date', 'gte', dateMin)
-                .sort('date', 'asc')
-                .exec();
+        return rows;
+    }
+    async getCommandDailyStatsRows(guildId, daysBack) {
+        const repo = this.repo(CommandDailyStats);
+        const dateMin = this.dateDaysAgo(daysBack);
+        let rows = await repo.query()
+            .where('date', 'gte', dateMin)
+            .exec();
+        if (guildId) {
+            rows = rows.filter(r => r.guild_id === guildId);
         }
+        return rows;
+    }
+    async getCommandsPerDay(guildId, daysBack) {
+        const newRows = await this.getCommandExecutedRows(guildId, daysBack);
+        const oldRows = await this.getCommandDailyStatsRows(guildId, daysBack);
         const byDate = new Map();
-        for (const row of rows) {
-            byDate.set(row.date, (byDate.get(row.date) || 0) + row.command_count);
+        for (const row of newRows) {
+            byDate.set(row.executed_at, (byDate.get(row.executed_at) || 0) + 1);
+        }
+        for (const row of oldRows) {
+            byDate.set(row.date, (byDate.get(row.date) || 0) + row.usage_count);
         }
         return Array.from(byDate.entries())
             .map(([date, count]) => ({ date, count }))
             .sort((a, b) => a.date.localeCompare(b.date));
     }
-    async getTopCommands(guildId, daysBack, limit = 10) {
-        const repo = this.repo(CommandDailyStats);
-        const dateMin = this.dateDaysAgo(daysBack);
-        let rows;
-        if (guildId) {
-            rows = await repo.query()
-                .where('guild_id', 'eq', guildId)
-                .where('date', 'gte', dateMin)
-                .exec();
+    async getCommandsPerDayByType(guildId, daysBack) {
+        const newRows = await this.getCommandExecutedRows(guildId, daysBack);
+        const oldRows = await this.getCommandDailyStatsRows(guildId, daysBack);
+        const byDate = new Map();
+        for (const row of newRows) {
+            const entry = byDate.get(row.executed_at) || { slash: 0, prefix: 0 };
+            if (row.type === 'slash')
+                entry.slash += 1;
+            else
+                entry.prefix += 1;
+            byDate.set(row.executed_at, entry);
         }
-        else {
-            rows = await repo.query()
-                .where('date', 'gte', dateMin)
-                .exec();
+        for (const row of oldRows) {
+            const entry = byDate.get(row.date) || { slash: 0, prefix: 0 };
+            entry.prefix += row.usage_count;
+            byDate.set(row.date, entry);
+        }
+        return Array.from(byDate.entries())
+            .map(([date, counts]) => ({ date, ...counts }))
+            .sort((a, b) => a.date.localeCompare(b.date));
+    }
+    async getCommandsByType(guildId, daysBack) {
+        const newRows = await this.getCommandExecutedRows(guildId, daysBack);
+        const oldRows = await this.getCommandDailyStatsRows(guildId, daysBack);
+        let slash = 0;
+        let prefix = 0;
+        for (const row of newRows) {
+            if (row.type === 'slash')
+                slash++;
+            else
+                prefix++;
         }
+        for (const row of oldRows) {
+            prefix += row.usage_count;
+        }
+        return { slash, prefix };
+    }
+    async getTopCommands(guildId, daysBack, limit = 10) {
+        const newRows = await this.getCommandExecutedRows(guildId, daysBack);
+        const oldRows = await this.getCommandDailyStatsRows(guildId, daysBack);
         const aggregated = new Map();
-        for (const row of rows) {
-            const key = row.command_name;
-            if (aggregated.has(key)) {
-                const existing = aggregated.get(key);
-                existing.usage_count += row.usage_count;
-                existing.total_execution_time_ms += row.total_execution_time_ms;
-                existing.error_count += row.error_count;
-            }
-            else {
-                aggregated.set(key, {
-                    id: key,
-                    guild_id: guildId || 'global',
-                    command_name: row.command_name,
-                    date: '',
-                    usage_count: row.usage_count,
-                    total_execution_time_ms: row.total_execution_time_ms,
-                    error_count: row.error_count,
-                });
-            }
+        for (const row of newRows) {
+            aggregated.set(row.command_name, (aggregated.get(row.command_name) || 0) + 1);
+        }
+        for (const row of oldRows) {
+            aggregated.set(row.command_name, (aggregated.get(row.command_name) || 0) + row.usage_count);
         }
-        return Array.from(aggregated.values())
+        return Array.from(aggregated.entries())
+            .map(([command_name, usage_count]) => ({ command_name, usage_count }))
             .sort((a, b) => b.usage_count - a.usage_count)
             .slice(0, limit);
     }
     async getSlowestCommands(guildId, daysBack, limit = 10) {
-        const repo = this.repo(CommandDailyStats);
-        const dateMin = this.dateDaysAgo(daysBack);
-        let rows;
-        if (guildId) {
-            rows = await repo.query()
-                .where('guild_id', 'eq', guildId)
-                .where('date', 'gte', dateMin)
-                .exec();
-        }
-        else {
-            rows = await repo.query()
-                .where('date', 'gte', dateMin)
-                .exec();
-        }
+        const newRows = await this.getCommandExecutedRows(guildId, daysBack);
+        const oldRows = await this.getCommandDailyStatsRows(guildId, daysBack);
         const aggregated = new Map();
-        for (const row of rows) {
-            const key = row.command_name;
-            if (aggregated.has(key)) {
-                const e = aggregated.get(key);
-                e.usage_count += row.usage_count;
-                e.totalTime += row.total_execution_time_ms;
-                e.errors += row.error_count;
+        for (const row of newRows) {
+            const existing = aggregated.get(row.command_name);
+            if (existing) {
+                existing.totalTime += row.execution_time_ms;
+                existing.count += 1;
             }
             else {
-                aggregated.set(key, {
-                    usage_count: row.usage_count,
-                    totalTime: row.total_execution_time_ms,
-                    errors: row.error_count,
-                });
+                aggregated.set(row.command_name, { totalTime: row.execution_time_ms, count: 1 });
+            }
+        }
+        for (const row of oldRows) {
+            const existing = aggregated.get(row.command_name);
+            if (existing) {
+                existing.totalTime += row.total_execution_time_ms;
+                existing.count += row.usage_count;
+            }
+            else {
+                aggregated.set(row.command_name, { totalTime: row.total_execution_time_ms, count: row.usage_count });
             }
         }
         return Array.from(aggregated.entries())
-            .map(([name, data]) => ({
-            id: name,
-            guild_id: guildId || 'global',
-            command_name: name,
-            date: '',
-            usage_count: data.usage_count,
-            total_execution_time_ms: data.totalTime,
-            error_count: data.errors,
-            avgExecutionTimeMs: data.usage_count > 0 ? Math.round(data.totalTime / data.usage_count) : 0,
+            .map(([command_name, data]) => ({
+            command_name,
+            avgExecutionTimeMs: data.count > 0 ? Math.round(data.totalTime / data.count) : 0,
+            total_executions: data.count,
         }))
-            .sort((a, b) => {
-            const aHasPerf = a.total_execution_time_ms > 0;
-            const bHasPerf = b.total_execution_time_ms > 0;
-            if (aHasPerf && bHasPerf)
-                return b.avgExecutionTimeMs - a.avgExecutionTimeMs;
-            if (aHasPerf)
-                return -1;
-            if (bHasPerf)
-                return 1;
-            return b.usage_count - a.usage_count;
-        })
+            .sort((a, b) => b.avgExecutionTimeMs - a.avgExecutionTimeMs)
             .slice(0, limit);
     }
     async getVoiceChannelStats(guildId, daysBack) {
@@ -492,6 +482,14 @@ export class AnalyticsCollector {
             for (const cmd of oldCmds) {
                 await cmdRepo.delete({ id: cmd.id });
             }
+            const cmdExRepo = this.repo(CommandExecuted);
+            const oldExecs = await cmdExRepo.query()
+                .where('guild_id', 'eq', guildId)
+                .where('executed_at', 'lt', cutoffDate)
+                .exec();
+            for (const exec of oldExecs) {
+                await cmdExRepo.delete({ id: exec.id });
+            }
             const voiceRepo = this.repo(VoiceChannelDailyStats);
             const oldVoice = await voiceRepo.query()
                 .where('guild_id', 'eq', guildId)

package/dist/views/admin-analytics-commands.ejs

@@ -7,11 +7,25 @@
             <a href="?days=90" class="text-sm px-3 py-1 rounded bg-discord-dark-100 text-discord-foreground/70 hover:text-discord-foreground">90d</a>
         </div>
     </div>
+    <div class="grid grid-cols-2 gap-4 mb-6">
+        <div class="card text-center">
+            <div class="text-3xl font-bold text-blue-400"><%= commandsByType.slash %></div>
+            <div class="text-sm text-discord-foreground/60">Slash Commands</div>
+        </div>
+        <div class="card text-center">
+            <div class="text-3xl font-bold text-green-400"><%= commandsByType.prefix %></div>
+            <div class="text-sm text-discord-foreground/60">Prefix Commands</div>
+        </div>
+    </div>
     <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
         <div class="card">
             <h3 class="text-lg font-semibold mb-4 text-discord-foreground">Comandos por Dia</h3>
             <canvas id="chartCommands" width="400" height="200"></canvas>
         </div>
+        <div class="card">
+            <h3 class="text-lg font-semibold mb-4 text-discord-foreground">Comandos por Tipo</h3>
+            <canvas id="chartCommandsType" width="400" height="200"></canvas>
+        </div>
         <div class="card">
             <h3 class="text-lg font-semibold mb-4 text-discord-foreground">Top Comandos</h3>
             <canvas id="chartTop" width="400" height="200"></canvas>
@@ -30,15 +44,36 @@ new Chart(document.getElementById('chartCommands'), {
     type: 'bar',
     data: {
         labels: <%- JSON.stringify(commandsPerDay.map(v => v.date)) %>,
-        datasets: [{ label: 'Comandos', data: <%- JSON.stringify(commandsPerDay.map(v => v.count)) %>, backgroundColor: '#5865f2', borderRadius: 4 }]
+        datasets: [{
+            label: 'Slash',
+            data: <%- JSON.stringify(commandsPerDayByType.map(v => v.slash)) %>,
+            backgroundColor: '#5865f2',
+            borderRadius: 4
+        }, {
+            label: 'Prefix',
+            data: <%- JSON.stringify(commandsPerDayByType.map(v => v.prefix)) %>,
+            backgroundColor: '#57f287',
+            borderRadius: 4
+        }]
+    },
+    options: { responsive: true, scales: { x: { stacked: true }, y: { stacked: true } } }
+});
+new Chart(document.getElementById('chartCommandsType'), {
+    type: 'doughnut',
+    data: {
+        labels: ['Slash', 'Prefix'],
+        datasets: [{
+            data: [<%= commandsByType.slash %>, <%= commandsByType.prefix %>],
+            backgroundColor: ['#5865f2', '#57f287']
+        }]
     },
-    options: { responsive: true, plugins: { legend: { display: false } } }
+    options: { responsive: true, plugins: { legend: { position: 'bottom' } } }
 });
 new Chart(document.getElementById('chartTop'), {
     type: 'bar',
     data: {
         labels: <%- JSON.stringify(topCommands.map(v => v.command_name)) %>,
-        datasets: [{ label: 'Usos', data: <%- JSON.stringify(topCommands.map(v => v.usage_count)) %>, backgroundColor: topCommands.map((_, i) => 'rgba(88,101,242,' + Math.max(0.3, 1 - i * 0.08) + ')'), borderRadius: 4 }]
+        datasets: [{ label: 'Usos', data: <%- JSON.stringify(topCommands.map(v => v.usage_count)) %>, backgroundColor: <%- JSON.stringify(topCommands.map((_, i) => 'rgba(88,101,242,' + Math.max(0.3, 1 - i * 0.08) + ')')) %>, borderRadius: 4 }]
     },
     options: { indexAxis: 'y', responsive: true, plugins: { legend: { display: false } } }
 });

package/dist/views/user-analytics-commands.ejs

@@ -7,6 +7,16 @@
             <a href="?days=90" class="text-sm px-3 py-1 rounded bg-discord-dark-100 text-discord-foreground/70 hover:text-discord-foreground">90d</a>
         </div>
     </div>
+    <div class="grid grid-cols-2 gap-4 mb-6">
+        <div class="card text-center">
+            <div class="text-3xl font-bold text-blue-400"><%= commandsByType.slash %></div>
+            <div class="text-sm text-discord-foreground/60">Slash Commands</div>
+        </div>
+        <div class="card text-center">
+            <div class="text-3xl font-bold text-green-400"><%= commandsByType.prefix %></div>
+            <div class="text-sm text-discord-foreground/60">Prefix Commands</div>
+        </div>
+    </div>
     <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
         <div class="card">
             <h3 class="text-lg font-semibold mb-4 text-discord-foreground"><%= t('analytics.commandsPerDay') %></h3>
@@ -17,39 +27,33 @@
             <canvas id="chartTop" width="400" height="200"></canvas>
         </div>
     </div>
-    <% if (slowestCommands && slowestCommands.length > 0) { %>
-    <div class="card mt-6">
-        <h3 class="text-lg font-semibold mb-4 text-discord-foreground"><%= t('analytics.slowestCommands') %></h3>
-        <canvas id="chartSlow" width="700" height="250"></canvas>
-    </div>
-    <% } %>
 </div>
 <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.min.js"></script>
 <script>
 new Chart(document.getElementById('chartCommands'), {
     type: 'bar',
     data: {
-        labels: <%- JSON.stringify(commandsPerDay.map(v => v.date)) %>,
-        datasets: [{ label: '<%= t("analytics.commands") %>', data: <%- JSON.stringify(commandsPerDay.map(v => v.count)) %>, backgroundColor: '#5865f2', borderRadius: 4 }]
+        labels: <%- JSON.stringify(commandsPerDayByType.map(v => v.date)) %>,
+        datasets: [{
+            label: 'Slash',
+            data: <%- JSON.stringify(commandsPerDayByType.map(v => v.slash)) %>,
+            backgroundColor: '#5865f2',
+            borderRadius: 4
+        }, {
+            label: 'Prefix',
+            data: <%- JSON.stringify(commandsPerDayByType.map(v => v.prefix)) %>,
+            backgroundColor: '#57f287',
+            borderRadius: 4
+        }]
     },
-    options: { responsive: true, plugins: { legend: { display: false } } }
+    options: { responsive: true, scales: { x: { stacked: true }, y: { stacked: true } } }
 });
 new Chart(document.getElementById('chartTop'), {
     type: 'bar',
     data: {
         labels: <%- JSON.stringify(topCommands.map(v => v.command_name)) %>,
-        datasets: [{ label: '<%= t("analytics.usageCount") %>', data: <%- JSON.stringify(topCommands.map(v => v.usage_count)) %>, backgroundColor: topCommands.map((_, i) => 'rgba(88,101,242,' + Math.max(0.3, 1 - i * 0.08) + ')'), borderRadius: 4 }]
+        datasets: [{ label: '<%= t("analytics.usageCount") %>', data: <%- JSON.stringify(topCommands.map(v => v.usage_count)) %>, backgroundColor: <%- JSON.stringify(topCommands.map((_, i) => 'rgba(88,101,242,' + Math.max(0.3, 1 - i * 0.08) + ')')) %>, borderRadius: 4 }]
     },
     options: { indexAxis: 'y', responsive: true, plugins: { legend: { display: false } } }
 });
-<% if (slowestCommands && slowestCommands.length > 0) { %>
-new Chart(document.getElementById('chartSlow'), {
-    type: 'bar',
-    data: {
-        labels: <%- JSON.stringify(slowestCommands.map(v => v.command_name)) %>,
-        datasets: [{ label: 'ms', data: <%- JSON.stringify(slowestCommands.map(v => v.avgExecutionTimeMs)) %>, backgroundColor: '#fee75c', borderRadius: 4 }]
-    },
-    options: { responsive: true, plugins: { legend: { display: false } }, scales: { y: { title: { display: true, text: 'ms' } } } }
-});
-<% } %>
 </script>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zumito-team/analytics-module",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Server analytics module with configurable tracking and optional panel integration",
   "type": "module",
   "main": "dist/index.js",
@@ -13,14 +13,19 @@
     "build": "tsc -p tsconfig.json && cp -r translations dist/ && cp -r views dist/"
   },
   "dependencies": {
+    "ejs": "^3.1.10",
+    "reflect-metadata": "^0.2.2"
+  },
+  "peerDependencies": {
     "@zumito-team/admin-module": "^1.8.0",
     "@zumito-team/user-panel-module": "^0.10.0",
-    "ejs": "^3.1.10",
-    "reflect-metadata": "^0.2.2",
-    "zumito-framework": "^1.22.2"
+    "zumito-framework": "^1.24.0"
   },
   "devDependencies": {
     "@types/ejs": "^3.1.5",
-    "typescript": "^5.9.3"
+    "@zumito-team/admin-module": "^1.8.0",
+    "@zumito-team/user-panel-module": "^0.10.0",
+    "typescript": "^5.9.3",
+    "zumito-framework": "^1.24.0"
   }
 }