feat: add support for disabled hosts in raw sub

Adds ability to include disabled hosts in raw subscription responses via query parameter

- Introduces new `withDisabledHosts` query parameter for raw subscription endpoint
- Updates repository layer to conditionally include disabled hosts
- Adds host database metadata to subscription response
- Makes HWID device limit checks configurable in API requests

Author: kastov

libs/contract/commands/subscription/get-raw-subscription-by-short-uuid.command.ts

@@ -20,6 +20,16 @@ export namespace GetRawSubscriptionByShortUuidCommand {
 
     export type Request = z.infer<typeof RequestSchema>;
 
+    export const RequestQuerySchema = z.object({
+        withDisabledHosts: z
+            .string()
+            .transform((str) => str === 'true')
+            .optional()
+            .default('false'),
+    });
+
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
     export const ResponseSchema = z.object({
         response: z.object({
             user: z.object({
@@ -81,6 +91,17 @@ export namespace GetRawSubscriptionByShortUuidCommand {
                             }),
                         ),
                     ),
+                    dbData: z.optional(
+                        z.object({
+                            rawInbound: z.nullable(z.object({})),
+                            tag: z.string(),
+                            uuid: z.string(),
+                            configProfileUuid: z.nullable(z.string()),
+                            configProfileInboundUuid: z.nullable(z.string()),
+                            isDisabled: z.boolean(),
+                            viewPosition: z.number(),
+                        }),
+                    ),
                 }),
             ),
             headers: z.record(z.string(), z.string()),

libs/contract/package.json

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

src/modules/hosts/queries/get-hosts-for-user/get-hosts-for-user.handler.ts

@@ -18,7 +18,10 @@ export class GetHostsForUserHandler
 
     async execute(query: GetHostsForUserQuery): Promise<ICommandResponse<HostsEntity[]>> {
         try {
-            const hosts = await this.hostsRepository.findActiveHostsByUserUuid(query.userUuid);
+            const hosts = await this.hostsRepository.findActiveHostsByUserUuid(
+                query.userUuid,
+                query.returnDisabledHosts,
+            );
 
             return {
                 isOk: true,

src/modules/hosts/queries/get-hosts-for-user/get-hosts-for-user.query.ts

@@ -1,3 +1,6 @@
 export class GetHostsForUserQuery {
-    constructor(public readonly userUuid: string) {}
+    constructor(
+        public readonly userUuid: string,
+        public readonly returnDisabledHosts?: boolean,
+    ) {}
 }

src/modules/hosts/repositories/hosts.repository.ts

@@ -130,7 +130,10 @@ export class HostsRepository implements ICrud<HostsEntity> {
         return !!result;
     }
 
-    public async findActiveHostsByUserUuid(userUuid: string): Promise<HostWithRawInbound[]> {
+    public async findActiveHostsByUserUuid(
+        userUuid: string,
+        returnDisabledHosts: boolean = false,
+    ): Promise<HostWithRawInbound[]> {
         const hosts = await this.qb.kysely
             .selectFrom('hosts')
             .distinct()
@@ -149,7 +152,7 @@ export class HostsRepository implements ICrud<HostsEntity> {
                 'configProfileInbounds.uuid',
                 'hosts.configProfileInboundUuid',
             )
-            .where('hosts.isDisabled', '=', false)
+            .$if(!returnDisabledHosts, (eb) => eb.where('hosts.isDisabled', '=', false))
             .where('internalSquadMembers.userUuid', '=', getKyselyUuid(userUuid))
             .selectAll('hosts')
             .select(['configProfileInbounds.rawInbound', 'configProfileInbounds.tag'])

src/modules/hwid-user-devices/hwid-user-devices.service.ts

@@ -14,12 +14,20 @@ import { CreateUserHwidDeviceRequestDto } from './dtos';
 @Injectable()
 export class HwidUserDevicesService {
     private readonly logger = new Logger(HwidUserDevicesService.name);
+    private readonly hwidDeviceLimitEnabled: boolean;
+    private readonly hwidGlobalDeviceLimit: number | undefined;
 
     constructor(
         private readonly hwidUserDevicesRepository: HwidUserDevicesRepository,
         private readonly configService: ConfigService,
         private readonly queryBus: QueryBus,
-    ) {}
+    ) {
+        this.hwidDeviceLimitEnabled =
+            this.configService.getOrThrow<string>('HWID_DEVICE_LIMIT_ENABLED') === 'true';
+        this.hwidGlobalDeviceLimit = this.configService.get<number | undefined>(
+            'HWID_FALLBACK_DEVICE_LIMIT',
+        );
+    }
 
     public async createUserHwidDevice(
         dto: CreateUserHwidDeviceRequestDto,
@@ -44,10 +52,6 @@ export class HwidUserDevicesService {
                 };
             }
 
-            const hwidGlobalDeviceLimit = this.configService.getOrThrow<number>(
-                'HWID_FALLBACK_DEVICE_LIMIT',
-            );
-
             const isDeviceExists = await this.hwidUserDevicesRepository.checkHwidExists(
                 dto.hwid,
                 dto.userUuid,
@@ -60,15 +64,17 @@ export class HwidUserDevicesService {
                 };
             }
 
-            const count = await this.hwidUserDevicesRepository.countByUserUuid(dto.userUuid);
+            if (this.hwidDeviceLimitEnabled && this.hwidGlobalDeviceLimit) {
+                const count = await this.hwidUserDevicesRepository.countByUserUuid(dto.userUuid);
 
-            const deviceLimit = user.response.hwidDeviceLimit ?? hwidGlobalDeviceLimit;
+                const deviceLimit = user.response.hwidDeviceLimit ?? this.hwidGlobalDeviceLimit;
 
-            if (count >= deviceLimit) {
-                return {
-                    isOk: false,
-                    ...ERRORS.USER_HWID_DEVICE_LIMIT_REACHED,
-                };
+                if (count >= deviceLimit) {
+                    return {
+                        isOk: false,
+                        ...ERRORS.USER_HWID_DEVICE_LIMIT_REACHED,
+                    };
+                }
             }
 
             await this.hwidUserDevicesRepository.create(new HwidUserDeviceEntity(dto));

src/modules/subscription-template/generators/format-hosts.service.ts

@@ -42,6 +42,7 @@ export class FormatHostsService {
     public async generateFormattedHosts(
         hosts: HostWithRawInbound[],
         user: UserEntity,
+        returnDbHost: boolean = false,
     ): Promise<IFormattedHost[]> {
         const formattedHosts: IFormattedHost[] = [];
 
@@ -319,6 +320,20 @@ export class FormatHostsService {
 
             const spiderX = spiderXFromConfig || '';
 
+            let dbData: IFormattedHost['dbData'] | undefined;
+
+            if (returnDbHost) {
+                dbData = {
+                    rawInbound: inputHost.rawInbound,
+                    tag: inputHost.tag,
+                    uuid: inputHost.uuid,
+                    configProfileUuid: inputHost.configProfileUuid,
+                    configProfileInboundUuid: inputHost.configProfileInboundUuid,
+                    isDisabled: inputHost.isDisabled,
+                    viewPosition: inputHost.viewPosition,
+                };
+            }
+
             formattedHosts.push({
                 remark,
                 address,
@@ -345,6 +360,7 @@ export class FormatHostsService {
                 serverDescription,
                 muxParams,
                 sockoptParams,
+                dbData,
             });
         }
 

src/modules/subscription-template/generators/interfaces/formatted-hosts.interface.ts

@@ -29,4 +29,13 @@ export interface IFormattedHost {
     muxParams?: null | object;
     sockoptParams?: null | object;
     serverDescription?: string;
+    dbData?: {
+        rawInbound: object | null;
+        tag: string;
+        uuid: string;
+        configProfileUuid: string | null;
+        configProfileInboundUuid: string | null;
+        isDisabled: boolean;
+        viewPosition: number;
+    };
 }

src/modules/subscription-template/generators/interfaces/raw-host.interface.ts

@@ -1,6 +1,16 @@
 import { StreamSettingsObject } from '@common/helpers/xray-config/interfaces/transport.config';
 
 export interface IRawHost {
+    dbData?: {
+        rawInbound: object | null;
+        tag: string;
+        uuid: string;
+        configProfileUuid: string | null;
+        configProfileInboundUuid: string | null;
+        isDisabled: boolean;
+        viewPosition: number;
+    };
+
     address: string;
     alpn: string;
     fingerprint: string;

src/modules/subscription-template/render-templates.service.ts

@@ -118,7 +118,11 @@ export class RenderTemplatesService {
     }> {
         const { user, hosts } = params;
 
-        const formattedHosts = await this.formatHostsService.generateFormattedHosts(hosts, user);
+        const formattedHosts = await this.formatHostsService.generateFormattedHosts(
+            hosts,
+            user,
+            true,
+        );
 
         const rawHosts = await this.rawHostsGeneratorService.generateConfig(formattedHosts);