refactor: improve user config generation and module structure

- Refactored XRay config generation to optimize user and inbound handling
- Added support for excluding specific inbounds when fetching users
- Simplified XRay config module and service initialization
- Enhanced users repository query to support inbound exclusion
- Improved memory management in config generation methods

Author: kastov

package.json

@@ -35,6 +35,7 @@
     "migrate:generate": "prisma generate",
     "migrate:deploy": "PRISMA_HIDE_UPDATE_MESSAGE=true prisma migrate deploy",
     "migrate:seed": "prisma db seed",
+    "migrate:seed:dev": "npm run build:seed && prisma db seed",
     "docs:serve": "compodoc -p tsconfig.json -s",
     "generate:openapi": "nest start --config nest-cli.gen-doc.json"
   },

src/common/helpers/xray-config/xray-config.validator.ts

@@ -207,56 +207,72 @@ export class XRayConfig {
     }
 
     public includeUsers(users: UserForConfigEntity[]): IXrayConfig {
-        const config = structuredClone(this.config);
+        const config = JSON.parse(JSON.stringify(this.config)) as IXrayConfig;
 
         const inboundMap = new Map(config.inbounds.map((inbound) => [inbound.tag, inbound]));
 
+        const usersByTag = new Map<string, UserForConfigEntity[]>();
         for (const user of users) {
-            const inbound = inboundMap.get(user.tag);
-            if (!inbound) {
-                continue;
+            if (!usersByTag.has(user.tag)) {
+                usersByTag.set(user.tag, []);
             }
+            usersByTag.get(user.tag)!.push(user);
+        }
+
+        for (const [tag, tagUsers] of usersByTag) {
+            const inbound = inboundMap.get(tag);
+            if (!inbound) continue;
 
             inbound.settings ??= {} as InboundSettings;
-            // inbound.settings.clients ??= [];
 
-            switch (inbound.protocol) {
-                case 'trojan':
-                    (inbound.settings as TrojanSettings).clients ??= [];
+            this.addUsersToInbound(inbound, tagUsers);
+        }
+
+        return config;
+    }
+
+    public prepareConfigForNode(users: UserForConfigEntity[]): IXrayConfig {
+        const configWithUsers = this.includeUsers(users);
+        return this.processCertificates(configWithUsers);
+    }
+
+    public getSortedConfig(): IXrayConfig {
+        return this.sortObjectByKeys<IXrayConfig>(this.config);
+    }
+
+    private addUsersToInbound(inbound: Inbound, users: UserForConfigEntity[]): void {
+        switch (inbound.protocol) {
+            case 'trojan':
+                (inbound.settings as TrojanSettings).clients ??= [];
+                for (const user of users) {
                     (inbound.settings as TrojanSettings).clients.push({
                         password: user.trojanPassword,
                         email: `${user.username}`,
                     });
-                    break;
-                case 'vless':
-                    (inbound.settings as VLessSettings).clients ??= [];
+                }
+                break;
+            case 'vless':
+                (inbound.settings as VLessSettings).clients ??= [];
+                for (const user of users) {
                     (inbound.settings as VLessSettings).clients.push({
                         id: user.vlessUuid,
                         email: `${user.username}`,
                         flow: getVlessFlow(inbound),
                     });
-                    break;
-                case 'shadowsocks':
+                }
+                break;
+            case 'shadowsocks':
+                (inbound.settings as ShadowsocksSettings).clients ??= [];
+                for (const user of users) {
                     (inbound.settings as ShadowsocksSettings).clients.push({
                         password: user.ssPassword,
                         method: 'chacha20-ietf-poly1305',
                         email: user.username,
                     });
-                    break;
-                default:
-                    throw new Error(`Protocol ${inbound.protocol} is not supported.`);
-            }
+                }
+                break;
+            default:
+                throw new Error(`Protocol ${inbound.protocol} is not supported.`);
         }
-
-        return config;
-    }
-
-    public prepareConfigForNode(users: UserForConfigEntity[]): IXrayConfig {
-        const configWithUsers = this.includeUsers(users);
-        return this.processCertificates(configWithUsers);
-    }
-
-    public getSortedConfig(): IXrayConfig {
-        return this.sortObjectByKeys<IXrayConfig>(this.config);
     }
 }

src/modules/users/builders/users-with-inbound-tag/users-with-inbound-tag.builder.ts

@@ -2,6 +2,8 @@ import { Prisma } from '@prisma/client';
 
 import { USERS_STATUS } from '@libs/contracts/constants';
 
+import { InboundsEntity } from '@modules/inbounds/entities';
+
 export class UsersWithInboundTagBuilder {
     public query: Prisma.Sql;
 
@@ -30,3 +32,40 @@ export class UsersWithInboundTagBuilder {
         return Prisma.raw(query);
     }
 }
+
+export class UsersWithInboundTagAndExcludedInboundsBuilder {
+    public query: Prisma.Sql;
+    private excludedInbounds: InboundsEntity[];
+
+    constructor(excludedInbounds: InboundsEntity[]) {
+        this.excludedInbounds = excludedInbounds;
+        this.query = this.getQuery();
+        return this;
+    }
+
+    public getQuery(): Prisma.Sql {
+        const excludedUuidsCondition =
+            this.excludedInbounds.length > 0
+                ? `AND i.uuid NOT IN (${this.excludedInbounds.map((inbound) => `'${inbound.uuid}'`).join(',')})`
+                : '';
+
+        const query = `
+        SELECT 
+            u.subscription_uuid as "subscriptionUuid",
+            u.username,
+            u.trojan_password as "trojanPassword",
+            u.vless_uuid as "vlessUuid",
+            u.ss_password as "ssPassword",
+            i.tag
+        FROM users u
+        INNER JOIN active_user_inbounds aui 
+            ON aui.user_uuid = u.uuid
+        INNER JOIN inbounds i 
+            ON i.uuid = aui.inbound_uuid
+        WHERE u.status = '${USERS_STATUS.ACTIVE}'
+            ${excludedUuidsCondition}
+    `;
+
+        return Prisma.raw(query);
+    }
+}

src/modules/users/queries/get-users-for-config/get-users-for-config.handler.ts

@@ -15,11 +15,11 @@ export class GetUsersForConfigHandler
     private readonly logger = new Logger(GetUsersForConfigHandler.name);
     constructor(private readonly usersRepository: UsersRepository) {}
 
-    async execute(): Promise<ICommandResponse<UserForConfigEntity[]>> {
+    async execute(query: GetUsersForConfigQuery): Promise<ICommandResponse<UserForConfigEntity[]>> {
         let users: UserForConfigEntity[] | null = null;
 
         try {
-            users = await this.usersRepository.getUsersForConfig();
+            users = await this.usersRepository.getUsersForConfig(query.excludedInbounds);
 
             return {
                 isOk: true,

src/modules/users/queries/get-users-for-config/get-users-for-config.query.ts

@@ -1,3 +1,5 @@
+import { InboundsEntity } from '@modules/inbounds/entities';
+
 export class GetUsersForConfigQuery {
-    constructor() {}
+    constructor(public readonly excludedInbounds: InboundsEntity[]) {}
 }

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

@@ -10,12 +10,14 @@ import { Injectable } from '@nestjs/common';
 import { ICrud } from '@common/types/crud-port';
 import { GetAllUsersV2Command } from '@libs/contracts/commands';
 
+import { InboundsEntity } from '@modules/inbounds/entities';
+
 import {
     BatchResetLimitedUsersUsageBuilder,
     BatchResetUsersUsageBuilder,
     BulkDeleteByStatusBuilder,
     BulkUpdateUserUsedTrafficBuilder,
-    UsersWithInboundTagBuilder,
+    UsersWithInboundTagAndExcludedInboundsBuilder,
 } from '../builders';
 import {
     UserEntity,
@@ -271,8 +273,10 @@ export class UsersRepository implements ICrud<UserEntity> {
         return result.map((value) => new UserWithActiveInboundsEntity(value));
     }
 
-    public async getUsersForConfig(): Promise<UserForConfigEntity[]> {
-        const { query } = new UsersWithInboundTagBuilder();
+    public async getUsersForConfig(
+        excludedInbounds: InboundsEntity[],
+    ): Promise<UserForConfigEntity[]> {
+        const { query } = new UsersWithInboundTagAndExcludedInboundsBuilder(excludedInbounds);
         return await this.prisma.tx.$queryRaw<UserForConfigEntity[]>(query);
     }
 

src/modules/xray-config/queries/get-prepared-config-with-users/get-prepared-config-with-users.handler.ts

@@ -23,46 +23,48 @@ export class GetPreparedConfigWithUsersHandler
     ) {}
 
     async execute(query: GetPreparedConfigWithUsersQuery): Promise<ICommandResponse<IXrayConfig>> {
+        let config: ICommandResponse<IXrayConfig> | null = null;
+        let users: ICommandResponse<UserForConfigEntity[]> | null = null;
+
         try {
             const { excludedInbounds } = query;
-            const excludedTags = new Set(excludedInbounds.map((inbound) => inbound.tag));
 
-            const users = await this.getUsersForConfig();
+            users = await this.getUsersForConfig({
+                excludedInbounds,
+            });
 
             if (!users.isOk || !users.response) {
                 throw new Error('Failed to get users for config');
             }
 
-            const config = await this.xrayService.getConfigWithUsers(users.response);
+            config = await this.xrayService.getConfigWithUsers(users.response);
 
             if (!config.response) {
                 throw new Error('Config response is empty');
             }
 
-            const filteredConfig: IXrayConfig = {
-                ...config.response,
-                inbounds: config.response.inbounds.filter(
-                    (inbound) => !excludedTags.has(inbound.tag),
-                ),
-            };
-
             return {
                 isOk: true,
-                response: filteredConfig,
+                response: config.response,
             };
         } catch (error) {
             this.logger.error(error);
             return {
                 isOk: false,
                 ...ERRORS.INTERNAL_SERVER_ERROR,
             };
+        } finally {
+            config = null;
+            users = null;
         }
     }
 
-    private getUsersForConfig(): Promise<ICommandResponse<UserForConfigEntity[]>> {
+    private getUsersForConfig(
+        dto: GetPreparedConfigWithUsersQuery,
+    ): Promise<ICommandResponse<UserForConfigEntity[]>> {
         return this.queryBus.execute<
             GetUsersForConfigQuery,
             ICommandResponse<UserForConfigEntity[]>
-        >(new GetUsersForConfigQuery());
+        >(new GetUsersForConfigQuery(dto.excludedInbounds));
     }
 }

src/modules/xray-config/queries/index.ts

@@ -1,4 +1,4 @@
 import { GetPreparedConfigWithUsersHandler } from './get-prepared-config-with-users';
 import { GetValidatedConfigHandler } from './get-validated-config';
 
-export const QUERIES = [GetPreparedConfigWithUsersHandler, GetValidatedConfigHandler];
+export const QUERIES = [GetValidatedConfigHandler, GetPreparedConfigWithUsersHandler];

src/modules/xray-config/xray-config.module.ts

@@ -1,21 +1,16 @@
-import { Module, OnApplicationBootstrap } from '@nestjs/common';
 import { CqrsModule } from '@nestjs/cqrs';
+import { Module } from '@nestjs/common';
 
 import { XrayConfigRepository } from './repositories/xray-config.repository';
 import { XrayConfigController } from './xray-config.controller';
 import { XrayConfigConverter } from './xray-config.converter';
 import { XrayConfigService } from './xray-config.service';
 import { QUERIES } from './queries';
+
 @Module({
     imports: [CqrsModule],
     controllers: [XrayConfigController],
-    providers: [XrayConfigRepository, XrayConfigConverter, XrayConfigService, ...QUERIES],
+    providers: [XrayConfigService, XrayConfigRepository, XrayConfigConverter, ...QUERIES],
+    exports: [],
 })
-export class XrayConfigModule implements OnApplicationBootstrap {
-    constructor(private readonly xrayConfigService: XrayConfigService) {}
-
-    async onApplicationBootstrap() {
-        await this.xrayConfigService.syncInbounds();
-    }
-}
-// export class XrayConfigModule {}
+export class XrayConfigModule {}

src/modules/xray-config/xray-config.service.ts

@@ -1,7 +1,7 @@
 import { ERRORS } from '@contract/constants';
 
+import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
 import { CommandBus, EventBus, QueryBus } from '@nestjs/cqrs';
-import { Injectable, Logger } from '@nestjs/common';
 
 import { ICommandResponse } from '@common/types/command-response.type';
 import { IXrayConfig } from '@common/helpers/xray-config/interfaces';
@@ -21,16 +21,20 @@ import { UpdateConfigRequestDto } from './dtos/update-config.dto';
 import { XrayConfigEntity } from './entities/xray-config.entity';
 
 @Injectable()
-export class XrayConfigService {
+export class XrayConfigService implements OnApplicationBootstrap {
     private readonly logger = new Logger(XrayConfigService.name);
 
     constructor(
-        private readonly xrayConfigRepository: XrayConfigRepository,
         private readonly commandBus: CommandBus,
         private readonly queryBus: QueryBus,
         private readonly eventBus: EventBus,
+        private readonly xrayConfigRepository: XrayConfigRepository,
     ) {}
 
+    async onApplicationBootstrap() {
+        await this.syncInbounds();
+    }
+
     public async updateConfig(config: object): Promise<ICommandResponse<XrayConfigEntity>> {
         try {
             const existingConfig = await this.xrayConfigRepository.findFirst();
@@ -170,6 +174,7 @@ export class XrayConfigService {
     public async getConfigWithUsers(
         users: UserForConfigEntity[],
     ): Promise<ICommandResponse<IXrayConfig>> {
+        let configWithUsers: IXrayConfig | null = null;
         try {
             const config = await this.getConfig();
             if (!config.response) {
@@ -179,7 +184,7 @@ export class XrayConfigService {
                 };
             }
             const parsedConf = new XRayConfig(config.response);
-            const configWithUsers = parsedConf.prepareConfigForNode(users);
+            configWithUsers = parsedConf.prepareConfigForNode(users);
             return {
                 isOk: true,
                 response: configWithUsers,
@@ -190,6 +195,8 @@ export class XrayConfigService {
                 isOk: false,
                 ...ERRORS.GET_CONFIG_WITH_USERS_ERROR,
             };
+        } finally {
+            configWithUsers = null;
         }
     }