chore: update nodes usage response structure

Author: kastov

libs/contract/commands/nodes/stats/get-nodes-usage-by-range.command.ts

@@ -21,20 +21,27 @@ export namespace GetNodesUsageByRangeCommand {
     export type RequestQuery = z.infer<typeof RequestQuerySchema>;
 
     export const ResponseSchema = z.object({
-        response: z.array(
-            z.object({
-                nodeUuid: z.string().uuid(),
-                nodeName: z.string(),
-                nodeCountryCode: z.string(),
-                total: z.number(),
-                totalDownload: z.number(),
-                totalUpload: z.number(),
-                humanReadableTotal: z.string(),
-                humanReadableTotalDownload: z.string(),
-                humanReadableTotalUpload: z.string(),
-                date: z.string().transform((str) => new Date(str)),
-            }),
-        ),
+        response: z.object({
+            categories: z.array(z.string()),
+            sparklineData: z.array(z.number()),
+            topNodes: z.array(
+                z.object({
+                    uuid: z.string().uuid(),
+                    name: z.string(),
+                    countryCode: z.string(),
+                    total: z.number(),
+                }),
+            ),
+            series: z.array(
+                z.object({
+                    uuid: z.string().uuid(),
+                    name: z.string(),
+                    countryCode: z.string(),
+                    total: z.number(),
+                    data: z.array(z.number()),
+                }),
+            ),
+        }),
     });
 
     export type Response = z.infer<typeof ResponseSchema>;

libs/contract/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnawave/backend-contract",
-  "version": "2.3.61",
+  "version": "2.3.64",
   "public": true,
   "license": "AGPL-3.0-only",
   "description": "A contract library for Remnawave Backend. It can be used in backend and frontend.",

src/modules/nodes-usage-history/interfaces/get-nodes-usage-by-range.interface.ts

@@ -1,9 +1,14 @@
 export interface IGetNodesUsageByRange {
-    nodeName: string;
-    nodeUuid: string;
-    nodeCountryCode: string;
+    uuid: string;
+    name: string;
+    countryCode: string;
     total: bigint;
-    totalDownload: bigint;
-    totalUpload: bigint;
-    date: string;
+    data: bigint[];
+}
+
+export interface ITopNode {
+    uuid: string;
+    name: string;
+    countryCode: string;
+    total: number;
 }

src/modules/nodes-usage-history/models/get-nodes-usage-by-range.response.model.ts

@@ -1,29 +1,37 @@
-import { prettyBytesUtil } from '@common/utils/bytes';
-
-import { IGetNodesUsageByRange } from '../interfaces';
+import { IGetNodesUsageByRange, ITopNode } from '../interfaces';
 
 export class GetNodesUsageByRangeResponseModel {
-    nodeUuid: string;
-    nodeName: string;
-    nodeCountryCode: string;
-    total: number;
-    totalDownload: number;
-    totalUpload: number;
-    humanReadableTotal: string;
-    humanReadableTotalDownload: string;
-    humanReadableTotalUpload: string;
-    date: Date;
+    public readonly categories: string[];
+    public readonly series: {
+        uuid: string;
+        name: string;
+        countryCode: string;
+        total: number;
+        data: number[];
+    }[];
+    public readonly sparklineData: number[];
+    public readonly topNodes: {
+        uuid: string;
+        name: string;
+        countryCode: string;
+        total: number;
+    }[];
 
-    constructor(data: IGetNodesUsageByRange) {
-        this.nodeUuid = data.nodeUuid;
-        this.nodeName = data.nodeName;
-        this.nodeCountryCode = data.nodeCountryCode;
-        this.total = Number(data.total);
-        this.totalDownload = Number(data.totalDownload);
-        this.totalUpload = Number(data.totalUpload);
-        this.date = new Date(data.date);
-        this.humanReadableTotal = prettyBytesUtil(this.total, true, 3, true);
-        this.humanReadableTotalDownload = prettyBytesUtil(this.totalDownload, true, 3, true);
-        this.humanReadableTotalUpload = prettyBytesUtil(this.totalUpload, true, 3, true);
+    constructor(data: {
+        categories: string[];
+        series: IGetNodesUsageByRange[];
+        sparklineData: number[];
+        topNodes: ITopNode[];
+    }) {
+        this.categories = data.categories;
+        this.series = data.series.map((item) => ({
+            uuid: item.uuid,
+            name: item.name,
+            countryCode: item.countryCode,
+            total: Number(item.total),
+            data: item.data.map((item) => Number(item)),
+        }));
+        this.sparklineData = data.sparklineData;
+        this.topNodes = data.topNodes;
     }
 }

src/modules/nodes-usage-history/nodes-usage-history.service.ts

@@ -16,22 +16,49 @@ export class NodesUsageHistoryService {
     async getNodesUsageByRange(
         start: Date,
         end: Date,
-    ): Promise<TResult<GetNodesUsageByRangeResponseModel[]>> {
+    ): Promise<TResult<GetNodesUsageByRangeResponseModel>> {
         try {
             const startDate = dayjs(start).utc().toDate();
             const endDate = dayjs(end).utc().toDate();
 
+            const dates = this.generateDateArray(startDate, endDate);
+
+            const dailyTraffic = await this.nodeUsageHistoryRepository.getDailyTrafficSum(
+                startDate,
+                endDate,
+                dates,
+            );
+
+            const topNodes = await this.nodeUsageHistoryRepository.getTopNodesByTraffic(
+                startDate,
+                endDate,
+            );
+
             const nodesUsage = await this.nodeUsageHistoryRepository.getNodesUsageByRange(
                 startDate,
                 endDate,
+                dates,
             );
 
             return ok(
-                nodesUsage.map((nodeUsage) => new GetNodesUsageByRangeResponseModel(nodeUsage)),
+                new GetNodesUsageByRangeResponseModel({
+                    categories: dates,
+                    series: nodesUsage,
+                    sparklineData: dailyTraffic,
+                    topNodes: topNodes,
+                }),
             );
         } catch (error) {
             this.logger.error(error);
-            return fail(ERRORS.GET_NODES_USAGE_BY_RANGE_ERROR);
+            return fail(ERRORS.INTERNAL_SERVER_ERROR);
         }
     }
+
+    private generateDateArray(start: Date, end: Date): string[] {
+        const startDate = dayjs(start).utc().startOf('day');
+        const endDate = dayjs(end).utc().startOf('day');
+        const days = endDate.diff(startDate, 'day') + 1;
+
+        return Array.from({ length: days }, (_, i) => startDate.add(i, 'day').format('YYYY-MM-DD'));
+    }
 }

src/modules/nodes-usage-history/repositories/nodes-usage-history.repository.ts

@@ -1,18 +1,22 @@
+import { Prisma } from '@prisma/client';
+
 import { TransactionalAdapterPrisma } from '@nestjs-cls/transactional-adapter-prisma';
 import { TransactionHost } from '@nestjs-cls/transactional';
 import { Injectable } from '@nestjs/common';
 
+import { TxKyselyService } from '@common/database/tx-kysely.service';
 import { ICrudHistoricalRecords } from '@common/types/crud-port';
 
 import { NodesUsageHistoryEntity } from '../entities/nodes-usage-history.entity';
+import { IGet7DaysStats, IGetNodesUsageByRange, ITopNode } from '../interfaces';
 import { NodesUsageHistoryConverter } from '../nodes-usage-history.converter';
-import { IGet7DaysStats, IGetNodesUsageByRange } from '../interfaces';
 import { Get7DaysStatsBuilder } from '../builders';
 
 @Injectable()
 export class NodesUsageHistoryRepository implements ICrudHistoricalRecords<NodesUsageHistoryEntity> {
     constructor(
         private readonly prisma: TransactionHost<TransactionalAdapterPrisma>,
+        private readonly qb: TxKyselyService,
         private readonly converter: NodesUsageHistoryConverter,
     ) {}
 
@@ -77,23 +81,106 @@ export class NodesUsageHistoryRepository implements ICrudHistoricalRecords<Nodes
         return result;
     }
 
-    public async getNodesUsageByRange(start: Date, end: Date): Promise<IGetNodesUsageByRange[]> {
-        return await this.prisma.tx.$queryRaw<IGetNodesUsageByRange[]>`
+    public async getNodesUsageByRange(
+        start: Date,
+        end: Date,
+        dates: string[],
+    ): Promise<IGetNodesUsageByRange[]> {
+        const query = Prisma.sql`
+            WITH daily_usage AS (
+                SELECT
+                    n.uuid,
+                    n.name,
+                    n.country_code,
+                    DATE_TRUNC('day', h.created_at)::date AS date,
+                    SUM(h.total_bytes) AS bytes
+                FROM nodes n
+                INNER JOIN nodes_usage_history h ON h.node_uuid = n.uuid
+                WHERE
+                    h.created_at >= ${start}
+                    AND h.created_at <= ${end}
+                GROUP BY n.uuid, n.name, n.country_code, DATE_TRUNC('day', h.created_at)
+            ),
+            nodes_with_totals AS (
+                SELECT
+                    uuid,
+                    name,
+                    country_code,
+                    SUM(bytes) AS total_bytes
+                FROM daily_usage
+                GROUP BY uuid, name, country_code
+            )
+            SELECT
+                nt.uuid as "uuid",
+                nt.name as "name",
+                nt.country_code as "countryCode",
+                nt.total_bytes as "total",
+                ARRAY_AGG(
+                    COALESCE(du.bytes, 0)
+                    ORDER BY d.ord
+                ) AS "data"
+            FROM nodes_with_totals nt
+            CROSS JOIN unnest(${dates}::date[]) WITH ORDINALITY AS d(date, ord)
+            LEFT JOIN daily_usage du
+                ON du.uuid = nt.uuid
+                AND du.date = d.date
+            GROUP BY nt.uuid, nt.name, nt.country_code, nt.total_bytes
+            ORDER BY nt.total_bytes DESC;
+        `;
+
+        return await this.prisma.tx.$queryRaw<IGetNodesUsageByRange[]>(query);
+    }
+
+    public async getTopNodesByTraffic(
+        start: Date,
+        end: Date,
+        limit: number = 5,
+    ): Promise<ITopNode[]> {
+        const result = await this.qb.kysely
+            .selectFrom('nodes as n')
+            .innerJoin('nodesUsageHistory as h', 'h.nodeUuid', 'n.uuid')
+            .select([
+                'n.uuid',
+                'n.name',
+                'n.countryCode',
+                (eb) => eb.fn.sum<bigint>('h.totalBytes').as('total'),
+            ])
+            .where('h.createdAt', '>=', start)
+            .where('h.createdAt', '<=', end)
+            .groupBy(['n.uuid', 'n.name', 'n.countryCode'])
+            .orderBy((eb) => eb.fn.sum<bigint>('h.totalBytes'), 'desc')
+            .limit(limit)
+            .execute();
+
+        return result.map((item) => ({
+            uuid: item.uuid,
+            name: item.name,
+            countryCode: item.countryCode,
+            total: Number(item.total),
+        }));
+    }
+
+    public async getDailyTrafficSum(start: Date, end: Date, dates: string[]): Promise<number[]> {
+        const query = Prisma.sql`
+            WITH daily_traffic AS (
+                SELECT 
+                    DATE_TRUNC('day', created_at AT TIME ZONE 'UTC')::date AS date,
+                    SUM(total_bytes) AS bytes
+                FROM nodes_usage_history
+                WHERE 
+                    created_at >= ${start}
+                    AND created_at <= ${end}
+                GROUP BY DATE_TRUNC('day', created_at AT TIME ZONE 'UTC')
+            )
             SELECT 
-                n.uuid as "nodeUuid",
-                n.name as "nodeName",
-                n.country_code as "nodeCountryCode",
-                COALESCE(SUM(h."total_bytes"), 0) as total,
-                COALESCE(SUM(h."download_bytes"), 0) as "totalDownload",
-                COALESCE(SUM(h."upload_bytes"), 0) as "totalUpload",
-                DATE_TRUNC('day', h."created_at") as "date"
-            FROM nodes n
-            INNER JOIN "nodes_usage_history" h ON h."node_uuid" = n.uuid 
-                AND h."created_at" >= ${start}
-                AND h."created_at" <= ${end}
-            GROUP BY n.uuid, n.name, n.country_code, DATE_TRUNC('day', h."created_at")
-            ORDER BY "date" ASC
+                COALESCE(dt.bytes, 0) AS value
+            FROM unnest(${dates}::date[]) WITH ORDINALITY AS d(date, ord)
+            LEFT JOIN daily_traffic dt ON dt.date = d.date
+            ORDER BY d.ord;
         `;
+
+        const result = await this.prisma.tx.$queryRaw<Array<{ value: bigint }>>(query);
+        return result.map((item) => Number(item.value));
     }
 
     public async getSumLifetime(): Promise<string> {