refactor: update user model and handling to include tId as bigint

- Modified Users model in Prisma schema to include tId.
- Updated various components to handle tId instead of uuid for user identification.
- Adjusted query and command structures to reflect changes in user data handling.
- Enhanced JSON serialization for BigInt type.

Author: kastov

prisma/schema.prisma

@@ -48,7 +48,7 @@ model RemnawaveSettings {
 
 model Users {
   uuid      String @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
-  tId       BigInt @unique @default(autoincrement()) @map("t_id") @ignore
+  tId       BigInt @unique @default(autoincrement()) @map("t_id")
   shortUuid String @unique @map("short_uuid")
   username  String @unique @map("username")
 

src/bin/processors/processors.ts

@@ -1,3 +1,7 @@
+(BigInt.prototype as any).toJSON = function () {
+    return this.toString();
+};
+
 import { utilities as nestWinstonModuleUtilities, WinstonModule } from 'nest-winston';
 import { createLogger } from 'winston';
 import * as winston from 'winston';

src/bin/scheduler/scheduler.ts

@@ -1,3 +1,7 @@
+(BigInt.prototype as any).toJSON = function () {
+    return this.toString();
+};
+
 import { utilities as nestWinstonModuleUtilities, WinstonModule } from 'nest-winston';
 import { createLogger } from 'winston';
 import compression from 'compression';

src/modules/users/builders/bulk-update-user-used-traffic/bulk-update-user-used-traffic.builder.ts

@@ -9,28 +9,30 @@ export class BulkUpdateUserUsedTrafficBuilder {
     }
 
     public getQuery(userUsageList: { u: string; b: string; n: string }[]): Prisma.Sql {
-        const query = `
-        WITH sorted_data AS (
-            SELECT * FROM (
-                VALUES ${userUsageList.map((h) => `(${h.b}, ${h.u}, '${h.n}'::uuid)`).join(',')}
-            ) AS data("inc_used", "t_id", "last_connected_node_uuid")
-            ORDER BY "t_id"
-        ),
-        updated_users AS (
-            UPDATE "users" AS u
+        const values = Prisma.join(
+            userUsageList.map((h) => Prisma.sql`(${h.b}::bigint, ${h.u}::bigint, ${h.n}::uuid)`),
+        );
+
+        const query = Prisma.sql`
+        WITH updated_users AS ( UPDATE "users" AS u
             SET
-                "used_traffic_bytes" = u."used_traffic_bytes" + sorted_data."inc_used",
-                "lifetime_used_traffic_bytes" = u."lifetime_used_traffic_bytes" + sorted_data."inc_used",
-                "online_at" = NOW(),
-                "first_connected_at" = COALESCE(u."first_connected_at", NOW()),
-                "updated_at" = NOW(),
-                "last_connected_node_uuid" = sorted_data."last_connected_node_uuid"
-            FROM sorted_data
-            WHERE sorted_data."t_id" = u."t_id"
-            RETURNING u."uuid", (u."first_connected_at" = u."online_at") AS "isFirstConnection"
+                "used_traffic_bytes"          = u."used_traffic_bytes" + data."inc_used",
+                "lifetime_used_traffic_bytes" = u."lifetime_used_traffic_bytes" + data."inc_used",
+                "online_at"                   = NOW(),
+                "first_connected_at"          = COALESCE(u."first_connected_at", NOW()),
+                "last_connected_node_uuid"   = data."last_connected_node_uuid"
+        FROM (
+            VALUES ${values}
+            ) AS data("inc_used", "t_id", "last_connected_node_uuid")
+        WHERE data."t_id" = u."t_id"
+        RETURNING
+            u."t_id",
+            (u."first_connected_at" = u."online_at") AS "isFirstConnection"
         )
-        SELECT uuid FROM updated_users WHERE "isFirstConnection";
+        SELECT t_id as "tId"
+        FROM updated_users
+        WHERE "isFirstConnection";
     `;
-        return Prisma.raw(query);
+        return query;
     }
 }

src/modules/users/commands/bulk-increment-used-traffic/bulk-increment-used-traffic.handler.ts

@@ -12,8 +12,7 @@ import { UsersRepository } from '../../repositories/users.repository';
 
 @CommandHandler(BulkIncrementUsedTrafficCommand)
 export class BulkIncrementUsedTrafficHandler
-    implements
-        ICommandHandler<BulkIncrementUsedTrafficCommand, ICommandResponse<{ uuid: string }[]>>
+    implements ICommandHandler<BulkIncrementUsedTrafficCommand, ICommandResponse<{ tId: bigint }[]>>
 {
     public readonly logger = new Logger(BulkIncrementUsedTrafficHandler.name);
 
@@ -25,7 +24,7 @@ export class BulkIncrementUsedTrafficHandler
     })
     async execute(
         command: BulkIncrementUsedTrafficCommand,
-    ): Promise<ICommandResponse<{ uuid: string }[]>> {
+    ): Promise<ICommandResponse<{ tId: bigint }[]>> {
         try {
             const result = await this.usersRepository.bulkIncrementUsedTraffic(
                 command.userUsageList,

src/modules/users/entities/base-users.entity.ts

@@ -3,6 +3,7 @@ import { Users } from '@prisma/client';
 import { TResetPeriods, TUsersStatus } from '@contract/constants';
 
 export class BaseUserEntity implements Users {
+    public tId: bigint;
     public uuid: string;
     public shortUuid: string;
     public username: string;

src/modules/users/queries/get-user-by-unique-field/get-user-by-unique-field.handler.ts

@@ -23,6 +23,7 @@ export class GetUserByUniqueFieldHandler
                     username: query.field.username || undefined,
                     shortUuid: query.field.shortUuid || undefined,
                     uuid: query.field.uuid || undefined,
+                    tId: query.field.tId || undefined,
                 },
                 query.includeOptions,
             );

src/modules/users/queries/get-user-by-unique-field/get-user-by-unique-field.query.ts

@@ -6,7 +6,9 @@ import { BaseUserEntity, UserEntity } from '@modules/users/entities';
 
 export class GetUserByUniqueFieldQuery extends Query<ICommandResponse<UserEntity>> {
     constructor(
-        public readonly field: Partial<Pick<BaseUserEntity, 'uuid' | 'shortUuid' | 'username'>>,
+        public readonly field: Partial<
+            Pick<BaseUserEntity, 'tId' | 'uuid' | 'shortUuid' | 'username'>
+        >,
         public readonly includeOptions: {
             activeInternalSquads: boolean;
             lastConnectedNode: boolean;

src/modules/users/repositories/users.repository.ts

@@ -71,9 +71,11 @@ export class UsersRepository implements ICrud<BaseUserEntity> {
 
     public async bulkIncrementUsedTraffic(
         userUsageList: { u: string; b: string; n: string }[],
-    ): Promise<{ uuid: string }[]> {
+    ): Promise<{ tId: bigint }[]> {
         const { query } = new BulkUpdateUserUsedTrafficBuilder(userUsageList);
-        return await this.prisma.tx.$queryRaw<{ uuid: string }[]>(query);
+        const result = await this.prisma.tx.$queryRaw<{ tId: bigint }[]>(query);
+
+        return result;
     }
 
     public async triggerThresholdNotifications(percentages: number[]): Promise<{ uuid: string }[]> {
@@ -507,7 +509,7 @@ export class UsersRepository implements ICrud<BaseUserEntity> {
     }
 
     public async findUniqueByCriteria(
-        dto: Partial<Pick<BaseUserEntity, 'uuid' | 'shortUuid' | 'username'>>,
+        dto: Partial<Pick<BaseUserEntity, 'uuid' | 'shortUuid' | 'username' | 'tId'>>,
         includeOptions: {
             activeInternalSquads: boolean;
             lastConnectedNode: boolean;
@@ -531,6 +533,7 @@ export class UsersRepository implements ICrud<BaseUserEntity> {
                 if (dto.uuid) conditions.push(eb('uuid', '=', getKyselyUuid(dto.uuid)));
                 if (dto.shortUuid) conditions.push(eb('shortUuid', '=', dto.shortUuid));
                 if (dto.username) conditions.push(eb('username', '=', dto.username));
+                if (dto.tId) conditions.push(eb('tId', '=', dto.tId));
 
                 return eb.or(conditions);
             })

src/modules/users/users.converter.ts

@@ -12,6 +12,7 @@ const modelToEntity = (model: Users): BaseUserEntity => {
 
 const entityToModel = (entity: BaseUserEntity): BaseUserEntity => {
     return {
+        tId: entity.tId,
         uuid: entity.uuid,
         shortUuid: entity.shortUuid,
         username: entity.username,