chore: enhance bandwidth stats endpoints with new user usage commands and DTOs

Author: kastov

libs/contract/commands/bandwidth-stats/nodes/get-stats-node-users-usage.command.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+
+import { BANDWIDTH_STATS_ROUTES, REST_API } from '../../../api';
+import { getEndpointDetails } from '../../../constants';
+
+export namespace GetStatsNodeUsersUsageCommand {
+    export const url = REST_API.BANDWIDTH_STATS.NODES.GET_USERS;
+    export const TSQ_url = url(':uuid');
+
+    export const endpointDetails = getEndpointDetails(
+        BANDWIDTH_STATS_ROUTES.NODES.GET_USERS(':uuid'),
+        'get',
+        'Get Node Users Usage by Node UUID',
+    );
+
+    export const RequestQuerySchema = z.object({
+        start: z.string().date(),
+        end: z.string().date(),
+        topUsersLimit: z.coerce.number().min(1).default(100),
+    });
+
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        response: z.object({
+            categories: z.array(z.string()),
+            sparklineData: z.array(z.number()),
+            topUsers: z.array(
+                z.object({
+                    color: z.string(),
+                    username: z.string(),
+                    total: z.number(),
+                }),
+            ),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

libs/contract/commands/bandwidth-stats/nodes/index.ts

@@ -1,2 +1,3 @@
+export * from './get-stats-node-users-usage.command';
 export * from './get-stats-nodes-realtime-usage.command';
 export * from './get-stats-nodes-usage.command';

libs/contract/package.json

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

src/common/utils/get-date-range-array.util.ts

@@ -8,8 +8,8 @@ export function getDateRangeArrayUtil(
     endDate: Date;
     dates: string[];
 } {
-    const startDate = dayjs(start).utc().startOf('day');
-    const endDate = dayjs(end).utc().startOf('day');
+    const startDate = dayjs.utc(start).startOf('day');
+    const endDate = dayjs.utc(end).endOf('day');
     const days = endDate.diff(startDate, 'day') + 1;
 
     return {

src/modules/nodes-user-usage-history/bandwidth-stats-nodes.controller.ts

@@ -10,6 +10,7 @@ import { RolesGuard } from '@common/guards/roles';
 import {
     GetLegacyStatsNodeUserUsageCommand,
     GetStatsNodesRealtimeUsageCommand,
+    GetStatsNodeUsersUsageCommand,
 } from '@libs/contracts/commands';
 import { BANDWIDTH_STATS_NODES_CONTROLLER, CONTROLLERS_INFO } from '@libs/contracts/api';
 import { ROLE } from '@libs/contracts/constants';
@@ -19,6 +20,9 @@ import {
     GetLegacyStatsNodesUsersUsageRequestQueryDto,
     GetLegacyStatsNodesUsersUsageResponseDto,
     GetStatsNodesRealtimeUsageResponseDto,
+    GetStatsNodeUsersUsageRequestDto,
+    GetStatsNodeUsersUsageRequestQueryDto,
+    GetStatsNodeUsersUsageResponseDto,
 } from './dtos';
 import {
     GetLegacyStatsNodesUsersUsageResponseModel,
@@ -88,4 +92,47 @@ export class BandwidthStatsNodesController {
             response: data.map((item) => new GetStatsNodesRealtimeUsageResponseModel(item)),
         };
     }
+
+    @ApiOkResponse({
+        type: GetStatsNodeUsersUsageResponseDto,
+        description: 'Stats node users usage fetched successfully',
+    })
+    @ApiParam({ name: 'uuid', type: String, description: 'UUID of the node', required: true })
+    @ApiQuery({
+        name: 'end',
+        type: Date,
+        description: 'End date',
+        required: true,
+    })
+    @ApiQuery({
+        name: 'start',
+        type: Date,
+        description: 'Start date',
+        required: true,
+    })
+    @ApiQuery({
+        name: 'topUsersLimit',
+        type: Number,
+        description: 'Limit of top users to return',
+        required: true,
+    })
+    @Endpoint({
+        command: GetStatsNodeUsersUsageCommand,
+        httpCode: HttpStatus.OK,
+    })
+    async getStatsNodeUsersUsage(
+        @Query() query: GetStatsNodeUsersUsageRequestQueryDto,
+        @Param() paramData: GetStatsNodeUsersUsageRequestDto,
+    ): Promise<GetStatsNodeUsersUsageResponseDto> {
+        const result = await this.nodesUserUsageHistoryService.getStatsNodesUsersUsage(
+            paramData.uuid,
+            query.start,
+            query.end,
+            query.topUsersLimit,
+        );
+        const data = errorHandler(result);
+        return {
+            response: data,
+        };
+    }
 }

src/modules/nodes-user-usage-history/bandwidth-stats-users.controller.ts

@@ -14,15 +14,20 @@ import { errorHandler } from '@common/helpers/error-handler.helper';
 import { Endpoint } from '@common/decorators/base-endpoint';
 import { Roles } from '@common/decorators/roles/roles';
 import { RolesGuard } from '@common/guards/roles';
+import { GetLegacyStatsUserUsageCommand, GetStatsUserUsageCommand } from '@libs/contracts/commands';
 import { BANDWIDTH_STATS_USERS_CONTROLLER, CONTROLLERS_INFO } from '@libs/contracts/api';
-import { GetLegacyStatsUserUsageCommand } from '@libs/contracts/commands';
 import { ROLE } from '@libs/contracts/constants';
 
 import {
     GetLegacyStatsUserUsageRequestDto,
     GetLegacyStatsUserUsageRequestQueryDto,
     GetLegacyStatsUserUsageResponseDto,
 } from './dtos/get-legacy-stats-users-usage.dto';
+import {
+    GetStatsUserUsageRequestDto,
+    GetStatsUserUsageRequestQueryDto,
+    GetStatsUserUsageResponseDto,
+} from './dtos';
 import { NodesUserUsageHistoryService } from './nodes-user-usage-history.service';
 import { GetLegacyStatsUserUsageResponseModel } from './models';
 
@@ -74,4 +79,41 @@ export class BandwidthStatsUsersController {
             response: data.map((item) => new GetLegacyStatsUserUsageResponseModel(item)),
         };
     }
+
+    @ApiOkResponse({
+        type: GetStatsUserUsageResponseDto,
+        description: 'Stats user usage fetched successfully',
+    })
+    @ApiParam({ name: 'uuid', type: String, description: 'UUID of the user', required: true })
+    @ApiQuery({
+        name: 'end',
+        type: Date,
+        description: 'End date',
+        required: true,
+    })
+    @ApiQuery({
+        name: 'start',
+        type: Date,
+        description: 'Start date',
+        required: true,
+    })
+    @Endpoint({
+        command: GetStatsUserUsageCommand,
+        httpCode: HttpStatus.OK,
+    })
+    async getStatsNodesUsage(
+        @Query() query: GetStatsUserUsageRequestQueryDto,
+        @Param() paramData: GetStatsUserUsageRequestDto,
+    ): Promise<GetStatsUserUsageResponseDto> {
+        const result = await this.nodesUserUsageHistoryService.getStatsUserUsage(
+            paramData.uuid,
+            query.start,
+            query.end,
+        );
+
+        const data = errorHandler(result);
+        return {
+            response: data,
+        };
+    }
 }

src/modules/nodes-user-usage-history/dtos/get-stats-node-users-usage.dto.ts

@@ -0,0 +1,15 @@
+import { createZodDto } from 'nestjs-zod';
+
+import { GetStatsNodeUsersUsageCommand } from '@contract/commands';
+
+export class GetStatsNodeUsersUsageRequestQueryDto extends createZodDto(
+    GetStatsNodeUsersUsageCommand.RequestQuerySchema,
+) {}
+
+export class GetStatsNodeUsersUsageRequestDto extends createZodDto(
+    GetStatsNodeUsersUsageCommand.RequestSchema,
+) {}
+
+export class GetStatsNodeUsersUsageResponseDto extends createZodDto(
+    GetStatsNodeUsersUsageCommand.ResponseSchema,
+) {}

src/modules/nodes-user-usage-history/dtos/get-stats-user-usage.dto.ts

@@ -0,0 +1,15 @@
+import { createZodDto } from 'nestjs-zod';
+
+import { GetStatsUserUsageCommand } from '@contract/commands';
+
+export class GetStatsUserUsageRequestQueryDto extends createZodDto(
+    GetStatsUserUsageCommand.RequestQuerySchema,
+) {}
+
+export class GetStatsUserUsageRequestDto extends createZodDto(
+    GetStatsUserUsageCommand.RequestSchema,
+) {}
+
+export class GetStatsUserUsageResponseDto extends createZodDto(
+    GetStatsUserUsageCommand.ResponseSchema,
+) {}

src/modules/nodes-user-usage-history/dtos/index.ts

@@ -1,2 +1,4 @@
 export * from './get-legacy-stats-nodes-users-usage.dto';
+export * from './get-stats-node-users-usage.dto';
 export * from './get-stats-nodes-realtime-usage.dto';
+export * from './get-stats-user-usage.dto';

src/modules/nodes-user-usage-history/interfaces/get-series.interface.ts

@@ -0,0 +1,31 @@
+export interface IGetUniversalSeries {
+    uuid: string;
+    name: string;
+    countryCode: string;
+    total: bigint;
+    data: bigint[];
+}
+
+export interface IGetUniversalTopNode {
+    uuid: string;
+    name: string;
+    countryCode: string;
+    total: bigint;
+}
+
+export interface IGetUniversalSeriesConverted {
+    uuid: string;
+    name: string;
+    color: string;
+    countryCode: string;
+    total: number;
+    data: number[];
+}
+
+export interface IGetUniversalTopNodeConverted {
+    uuid: string;
+    color: string;
+    name: string;
+    countryCode: string;
+    total: number;
+}