feat: add flow configuration to VLESS settings and update flow handling in related services

- Enhanced `getVlessFlow` function to utilize the new `flow` property for determining flow settings based on inbound configurations.
- Updated various generator services to incorporate flow settings from hosts, improving flexibility in flow management.
- Refactored existing flow handling logic to remove hardcoded values and utilize the new configuration.

Author: kastov

src/common/helpers/xray-config/interfaces/protocol-settings.config.ts

@@ -46,6 +46,7 @@ export interface VLessSettings {
     clients: VLessUser[];
     decryption: 'none' | string;
     fallbacks?: VLessFallback[];
+    flow?: 'xtls-rprx-vision' | '' | 'none';
 }
 
 export interface VLessUser extends UserObject {

src/common/utils/flow/get-vless-flow.ts

@@ -1,20 +1,64 @@
+import { VLessSettings } from '@common/helpers/xray-config/interfaces/protocol-settings.config';
 import { InboundObject } from '@common/helpers/xray-config/interfaces/protocols.config';
 
 import { ConfigProfileInboundEntity } from '@modules/config-profiles/entities';
 
-export const getVlessFlow = (inbound: InboundObject) => {
-    if (
-        (inbound.streamSettings?.network === 'tcp' || inbound.streamSettings?.network === 'raw') &&
-        (inbound.streamSettings?.security === 'reality' ||
-            inbound.streamSettings?.security === 'tls')
-    ) {
-        return 'xtls-rprx-vision';
+interface VlessSettingsWithFlow {
+    settings: {
+        flow: 'xtls-rprx-vision' | '' | 'none';
+    };
+}
+
+export const hasVlessSettingsWithFlow = (obj: unknown): obj is VlessSettingsWithFlow => {
+    return (
+        typeof obj === 'object' &&
+        obj !== null &&
+        'settings' in obj &&
+        typeof (obj as VlessSettingsWithFlow).settings === 'object' &&
+        (obj as VlessSettingsWithFlow).settings !== null &&
+        'flow' in (obj as VlessSettingsWithFlow).settings &&
+        typeof (obj as VlessSettingsWithFlow).settings.flow === 'string'
+    );
+};
+
+export const getVlessFlow = (inbound: InboundObject): 'xtls-rprx-vision' | '' | undefined => {
+    if (inbound.protocol !== 'vless') {
+        return undefined;
+    }
+
+    if ((inbound.settings as VLessSettings).flow !== undefined) {
+        if ((inbound.settings as VLessSettings).flow === 'xtls-rprx-vision') {
+            return 'xtls-rprx-vision';
+        } else {
+            return '';
+        }
+    }
+
+    if (inbound.streamSettings) {
+        if (
+            ['reality', 'tls'].includes(inbound.streamSettings.security || '') &&
+            ['raw', 'tcp'].includes(inbound.streamSettings.network)
+        ) {
+            return 'xtls-rprx-vision';
+        }
     }
 
     return '';
 };
 
-export const getVlessFlowFromDbInbound = (inbound: ConfigProfileInboundEntity) => {
+export function getVlessFlowFromDbInbound(
+    inbound: ConfigProfileInboundEntity,
+): 'xtls-rprx-vision' | '' {
+    if (inbound.type === 'vless') {
+        if (inbound.rawInbound && hasVlessSettingsWithFlow(inbound.rawInbound)) {
+            if (inbound.rawInbound.settings.flow === 'xtls-rprx-vision') {
+                return 'xtls-rprx-vision';
+            } else {
+                return '';
+            }
+        }
+    }
+
     if (
         (inbound.network === 'tcp' || inbound.network === 'raw') &&
         (inbound.security === 'reality' || inbound.security === 'tls')
@@ -23,4 +67,4 @@ export const getVlessFlowFromDbInbound = (inbound: ConfigProfileInboundEntity) =
     }
 
     return '';
-};
+}

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

@@ -24,6 +24,7 @@ import { TemplateEngine } from '@common/utils/templates/replace-templates-values
 import { ICommandResponse } from '@common/types/command-response.type';
 import { InboundObject } from '@common/helpers/xray-config/interfaces';
 import { setVlessRouteForUuid } from '@common/utils/vless-route';
+import { getVlessFlow } from '@common/utils/flow';
 import { SECURITY_LAYERS, USERS_STATUS } from '@libs/contracts/constants';
 
 import { SubscriptionSettingsEntity } from '@modules/subscription-settings/entities/subscription-settings.entity';
@@ -45,6 +46,8 @@ interface IGenerateFormattedHostsOptions {
 export class FormatHostsService {
     private readonly nanoid: ReturnType<typeof customAlphabet>;
     private readonly subPublicDomain: string;
+    private readonly domainRegex =
+        /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
 
     constructor(
         private readonly queryBus: QueryBus,
@@ -368,9 +371,7 @@ export class FormatHostsService {
             const tls = tlsFromConfig;
 
             const isDomain = (str: string): boolean => {
-                const domainRegex =
-                    /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
-                return domainRegex.test(str);
+                return this.domainRegex.test(str);
             };
 
             let sni = inputHost.sni || sniFromConfig;
@@ -460,6 +461,7 @@ export class FormatHostsService {
                 dbData,
                 mldsa65Verify: mldsa65PublicKeyFromConfig,
                 encryption: encryptionMap.get(inputHost.inboundTag),
+                flow: getVlessFlow(inbound),
             });
         }
 

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

@@ -38,4 +38,5 @@ export interface IFormattedHost {
     dbData?: IDbHostData;
     mldsa65Verify?: string;
     encryption?: string;
+    flow?: 'xtls-rprx-vision' | '';
 }

src/modules/subscription-template/generators/mihomo.generator.service.ts

@@ -227,22 +227,10 @@ export class MihomoGeneratorService {
                 node.uuid = host.password.vlessPassword;
                 node['packet-encoding'] = 'xudp';
 
-                if (
-                    ['raw', 'tcp'].includes(host.network) &&
-                    host.headerType !== 'http' &&
-                    ['reality', 'tls'].includes(host.tls)
-                ) {
-                    node.flow = 'xtls-rprx-vision';
+                if (host.flow === 'xtls-rprx-vision') {
+                    node.flow = host.flow;
                 }
 
-                // if (
-                //     ['tcp', 'raw', 'kcp'].includes(host.network) &&
-                //     host.headerType !== 'http' &&
-                //     inbound.tls !== 'none'
-                // ) {
-                //     node.flow = settings.flow || '';
-                // }
-
                 if (host.encryption && host.encryption !== 'none') {
                     node.encryption = host.encryption;
                 }

src/modules/subscription-template/generators/raw-hosts.generator.service.ts

@@ -19,19 +19,8 @@ export class RawHostsGeneratorService {
 
                 const rawHost: IRawHost = {
                     ...host,
-                    flow: 'xtls-rprx-vision',
                 };
 
-                if (
-                    !(
-                        ['reality', 'tls'].includes(host.tls) &&
-                        ['raw', 'tcp'].includes(host.network) &&
-                        host.headerType !== 'http'
-                    )
-                ) {
-                    rawHost.flow = undefined;
-                }
-
                 if (host.protocol === 'shadowsocks') {
                     rawHost.protocolOptions = {
                         ss: {

src/modules/subscription-template/generators/singbox.generator.service.ts

@@ -255,13 +255,8 @@ export class SingBoxGeneratorService {
             server_port: params.port,
         };
 
-        if (
-            ['raw', 'tcp'].includes(params.network) &&
-            params.headerType !== 'http' &&
-            ['reality', 'tls'].includes(params.tls) &&
-            params.protocol === 'vless'
-        ) {
-            config.flow = 'xtls-rprx-vision';
+        if (params.flow === 'xtls-rprx-vision') {
+            config.flow = params.flow;
         }
 
         if (params.protocol === 'shadowsocks') {

src/modules/subscription-template/generators/xray-json.generator.service.ts

@@ -149,7 +149,7 @@ export class XrayJsonGeneratorService {
     private createOutboundSettings(host: IFormattedHost): OutboundSettings {
         switch (host.protocol) {
             case 'vless':
-                const vnextWithoutFlow = {
+                return {
                     vnext: [
                         {
                             address: host.address,
@@ -158,25 +158,13 @@ export class XrayJsonGeneratorService {
                                 {
                                     id: host.password.vlessPassword,
                                     encryption: host.encryption || 'none',
-                                    flow: 'xtls-rprx-vision' as string | undefined,
+                                    flow: host.flow,
                                 },
                             ],
                         },
                     ],
                 };
 
-                if (
-                    !(
-                        ['reality', 'tls'].includes(host.tls) &&
-                        ['raw', 'tcp'].includes(host.network) &&
-                        host.headerType !== 'http'
-                    )
-                ) {
-                    vnextWithoutFlow.vnext[0].users[0].flow = undefined;
-                }
-
-                return vnextWithoutFlow;
-
             case 'trojan':
                 return {
                     servers: [

src/modules/subscription-template/generators/xray.generator.service.ts

@@ -124,17 +124,6 @@ export class XrayGeneratorService {
             );
         }
 
-        if (
-            ['reality', 'tls'].includes(params.tls) &&
-            ['raw', 'tcp'].includes(params.network) &&
-            params.protocol !== 'trojan' &&
-            params.headerType !== 'http'
-        ) {
-            Object.assign(payload, {
-                flow: 'xtls-rprx-vision',
-            });
-        }
-
         if (params.network === 'xhttp') {
             Object.assign(payload, {
                 path: params.path,
@@ -198,21 +187,17 @@ export class XrayGeneratorService {
             headerType: params.headerType || '',
         };
 
-        const network = params.network || 'tcp';
+        const network = params.network;
         if (network in NETWORK_CONFIGS) {
             Object.assign(
                 payload,
                 NETWORK_CONFIGS[network as StreamSettingsObject['network']](params),
             );
         }
 
-        if (
-            ['reality', 'tls'].includes(params.tls) &&
-            ['raw', 'tcp'].includes(params.network) &&
-            params.headerType !== 'http'
-        ) {
+        if (params.flow !== undefined) {
             Object.assign(payload, {
-                flow: 'xtls-rprx-vision',
+                flow: params.flow,
             });
         }