@remnawave/backend-contract 2.9.30 → 2.9.32

package/build/backend/models/response-rules/response-rule-condition.schema.js

@@ -1,10 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResponseRuleConditionSchema = void 0;
+exports.ResponseRuleConditionNodeSchema = exports.ResponseRuleConditionNotSchema = exports.ResponseRuleConditionGroupSchema = exports.ResponseRuleConditionSchema = exports.RESPONSE_RULES_MAX_CONDITION_NODES = exports.RESPONSE_RULES_MAX_CONDITION_DEPTH = void 0;
+exports.forEachResponseRuleCondition = forEachResponseRuleCondition;
+exports.measureResponseRuleConditionTree = measureResponseRuleConditionTree;
 const zod_1 = require("zod");
 const constants_1 = require("../../constants");
+exports.RESPONSE_RULES_MAX_CONDITION_DEPTH = 10;
+exports.RESPONSE_RULES_MAX_CONDITION_NODES = 100;
+const OPERATORS_WITHOUT_VALUE = [
+    constants_1.RESPONSE_RULES_CONDITION_OPERATORS.EXISTS,
+    constants_1.RESPONSE_RULES_CONDITION_OPERATORS.NOT_EXISTS,
+];
 exports.ResponseRuleConditionSchema = zod_1.z
-    .object({
+    .strictObject({
     headerName: zod_1.z
         .string()
         .regex(/^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/, 'Invalid header name. Only letters(a-z, A-Z), numbers(0-9), underscores(_) and hyphens(-) are allowed.')
@@ -21,14 +29,27 @@ exports.ResponseRuleConditionSchema = zod_1.z
         .string()
         .min(1, 'Value is required')
         .max(255, 'Value must be less than 255 characters')
+        .optional()
         .meta({
-        markdownDescription: '**Value** to check against the **headerName**.',
+        markdownDescription: '**Value** to check against the **headerName**. Required for all operators except `EXISTS` and `NOT_EXISTS`.',
     }),
-    caseSensitive: zod_1.z.boolean().meta({
-        markdownDescription: 'Whether the value is **case sensitive**. \n\n - `true`: the value will be compared as is. \n\n - `false`: the value will be lowercased **before** comparison.',
+    caseSensitive: zod_1.z.boolean().optional().meta({
+        default: false,
+        markdownDescription: 'Whether the value is **case sensitive**. Optional, defaults to `false`. \n\n - `true`: the value will be compared as is. \n\n - `false`: the value will be lowercased **before** comparison.',
     }),
+})
+    .superRefine((condition, ctx) => {
+    if (condition.value === undefined &&
+        !OPERATORS_WITHOUT_VALUE.includes(condition.operator)) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['value'],
+            message: `Value is required for operator "${condition.operator}".`,
+        });
+    }
 })
     .meta({
+    title: 'Condition',
     markdownDescription: 'Condition to check against the **headerName**.',
     defaultSnippets: [
         {
@@ -38,8 +59,137 @@ exports.ResponseRuleConditionSchema = zod_1.z
                 headerName: 'accept',
                 operator: 'CONTAINS',
                 value: 'text/html',
-                caseSensitive: true,
+            },
+        },
+        {
+            label: 'Examples: Check if header exists',
+            markdownDescription: 'Condition to check if **headerName** is present in the request',
+            body: {
+                headerName: 'x-hwid',
+                operator: 'EXISTS',
+            },
+        },
+    ],
+});
+exports.ResponseRuleConditionGroupSchema = zod_1.z
+    .strictObject({
+    operator: zod_1.z
+        .enum([constants_1.RESPONSE_RULES_GROUP_OPERATORS.AND, constants_1.RESPONSE_RULES_GROUP_OPERATORS.OR])
+        .meta({
+        markdownDescription: 'Logical operator to use for combining nested **conditions**.',
+        markdownEnumDescriptions: [
+            constants_1.RESPONSE_RULES_GROUP_OPERATORS_DESCRIPTION.AND,
+            constants_1.RESPONSE_RULES_GROUP_OPERATORS_DESCRIPTION.OR,
+        ],
+    }),
+    get conditions() {
+        return zod_1.z
+            .array(exports.ResponseRuleConditionNodeSchema)
+            .min(1, 'Group must contain at least one condition')
+            .meta({
+            title: 'Conditions',
+            markdownDescription: 'Array of nested conditions. Each item is either a **condition** or another **group** (`AND`/`OR`/`NOT`), so groups can be nested to express complex logic.',
+        });
+    },
+})
+    .meta({
+    title: 'Condition Group',
+    markdownDescription: 'Group of nested conditions combined with a logical **operator** (`AND`/`OR`). Groups can be nested inside each other.',
+    defaultSnippets: [
+        {
+            label: 'Examples: OR group',
+            markdownDescription: 'Group that matches if **at least one** nested condition matches',
+            body: {
+                operator: 'OR',
+                conditions: [
+                    {
+                        headerName: 'user-agent',
+                        operator: 'CONTAINS',
+                        value: 'Hiddify',
+                    },
+                    {
+                        headerName: 'user-agent',
+                        operator: 'CONTAINS',
+                        value: 'FoxRay',
+                    },
+                ],
+            },
+        },
+    ],
+});
+exports.ResponseRuleConditionNotSchema = zod_1.z
+    .strictObject({
+    operator: zod_1.z.literal(constants_1.RESPONSE_RULES_GROUP_OPERATORS.NOT).meta({
+        markdownDescription: constants_1.RESPONSE_RULES_GROUP_OPERATORS_DESCRIPTION.NOT,
+    }),
+    get condition() {
+        return exports.ResponseRuleConditionNodeSchema.meta({
+            title: 'Condition',
+            markdownDescription: 'Nested condition to invert. Can be a **condition** or a **group**.',
+        });
+    },
+})
+    .meta({
+    title: 'NOT Group',
+    markdownDescription: 'Inverts the result of the nested **condition**. The nested condition can be a single condition or a whole group.',
+    defaultSnippets: [
+        {
+            label: 'Examples: NOT group',
+            markdownDescription: 'Matches if the nested condition does **not** match',
+            body: {
+                operator: 'NOT',
+                condition: {
+                    headerName: 'user-agent',
+                    operator: 'CONTAINS',
+                    value: 'Happ',
+                },
             },
         },
     ],
 });
+exports.ResponseRuleConditionNodeSchema = zod_1.z
+    .lazy(() => zod_1.z.discriminatedUnion('operator', [
+    exports.ResponseRuleConditionSchema,
+    exports.ResponseRuleConditionGroupSchema,
+    exports.ResponseRuleConditionNotSchema,
+]))
+    .meta({
+    title: 'Condition Node',
+    markdownDescription: 'Either a single **condition** (header check) or a **group** (`AND`/`OR`/`NOT`) with nested conditions. Groups can be nested to express complex logic, e.g. `A AND (B OR C)`.',
+});
+function forEachResponseRuleCondition(node, callback) {
+    switch (node.operator) {
+        case constants_1.RESPONSE_RULES_GROUP_OPERATORS.AND:
+        case constants_1.RESPONSE_RULES_GROUP_OPERATORS.OR:
+            for (const child of node.conditions) {
+                forEachResponseRuleCondition(child, callback);
+            }
+            return;
+        case constants_1.RESPONSE_RULES_GROUP_OPERATORS.NOT:
+            forEachResponseRuleCondition(node.condition, callback);
+            return;
+        default:
+            callback(node);
+    }
+}
+function measureResponseRuleConditionTree(node) {
+    switch (node.operator) {
+        case constants_1.RESPONSE_RULES_GROUP_OPERATORS.AND:
+        case constants_1.RESPONSE_RULES_GROUP_OPERATORS.OR: {
+            let depth = 0;
+            let nodes = 1;
+            for (const child of node.conditions) {
+                const childMetrics = measureResponseRuleConditionTree(child);
+                depth = Math.max(depth, childMetrics.depth);
+                nodes += childMetrics.nodes;
+            }
+            return { depth: depth + 1, nodes };
+        }
+        case constants_1.RESPONSE_RULES_GROUP_OPERATORS.NOT: {
+            const childMetrics = measureResponseRuleConditionTree(node.condition);
+            return { depth: childMetrics.depth + 1, nodes: childMetrics.nodes + 1 };
+        }
+        default:
+            return { depth: 1, nodes: 1 };
+    }
+}

package/build/backend/models/response-rules/response-rule.schema.d.ts

@@ -3,27 +3,7 @@ export declare const ResponseRuleSchemaBase: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     enabled: z.ZodBoolean;
-    operator: z.ZodEnum<{
-        readonly AND: "AND";
-        readonly OR: "OR";
-    }>;
-    conditions: z.ZodArray<z.ZodObject<{
-        headerName: z.ZodString;
-        operator: z.ZodEnum<{
-            readonly EQUALS: "EQUALS";
-            readonly NOT_EQUALS: "NOT_EQUALS";
-            readonly CONTAINS: "CONTAINS";
-            readonly NOT_CONTAINS: "NOT_CONTAINS";
-            readonly STARTS_WITH: "STARTS_WITH";
-            readonly NOT_STARTS_WITH: "NOT_STARTS_WITH";
-            readonly ENDS_WITH: "ENDS_WITH";
-            readonly NOT_ENDS_WITH: "NOT_ENDS_WITH";
-            readonly REGEX: "REGEX";
-            readonly NOT_REGEX: "NOT_REGEX";
-        }>;
-        value: z.ZodString;
-        caseSensitive: z.ZodBoolean;
-    }, z.core.$strip>>;
+    when: z.ZodOptional<z.ZodType<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown>>>;
     responseType: z.ZodEnum<{
         readonly BROWSER: "BROWSER";
         readonly BLOCK: "BLOCK";
@@ -57,32 +37,12 @@ export declare const ResponseRuleSchemaBase: z.ZodObject<{
         }, z.core.$strip>>;
         excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export declare const ResponseRuleSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     enabled: z.ZodBoolean;
-    operator: z.ZodEnum<{
-        readonly AND: "AND";
-        readonly OR: "OR";
-    }>;
-    conditions: z.ZodArray<z.ZodObject<{
-        headerName: z.ZodString;
-        operator: z.ZodEnum<{
-            readonly EQUALS: "EQUALS";
-            readonly NOT_EQUALS: "NOT_EQUALS";
-            readonly CONTAINS: "CONTAINS";
-            readonly NOT_CONTAINS: "NOT_CONTAINS";
-            readonly STARTS_WITH: "STARTS_WITH";
-            readonly NOT_STARTS_WITH: "NOT_STARTS_WITH";
-            readonly ENDS_WITH: "ENDS_WITH";
-            readonly NOT_ENDS_WITH: "NOT_ENDS_WITH";
-            readonly REGEX: "REGEX";
-            readonly NOT_REGEX: "NOT_REGEX";
-        }>;
-        value: z.ZodString;
-        caseSensitive: z.ZodBoolean;
-    }, z.core.$strip>>;
+    when: z.ZodOptional<z.ZodType<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown>>>;
     responseType: z.ZodEnum<{
         readonly BROWSER: "BROWSER";
         readonly BLOCK: "BLOCK";
@@ -116,5 +76,5 @@ export declare const ResponseRuleSchema: z.ZodObject<{
         }, z.core.$strip>>;
         excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 //# sourceMappingURL=response-rule.schema.d.ts.map

package/build/backend/models/response-rules/response-rule.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response-rule.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAexB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmB7B,CAAC"}
+{"version":3,"file":"response-rule.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmBxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0DjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmB7B,CAAC"}

package/build/backend/models/response-rules/response-rule.schema.js

@@ -6,7 +6,7 @@ const constants_1 = require("../../constants");
 const response_rule_condition_schema_1 = require("./response-rule-condition.schema");
 const response_rule_modifications_schema_1 = require("./response-rule-modifications.schema");
 const response_rules_examples_1 = require("./response-rules-examples");
-exports.ResponseRuleSchemaBase = zod_1.z.object({
+exports.ResponseRuleSchemaBase = zod_1.z.strictObject({
     name: zod_1.z
         .string()
         .min(1, 'Name is required')
@@ -28,12 +28,28 @@ exports.ResponseRuleSchemaBase = zod_1.z.object({
         title: 'Enabled',
         markdownDescription: 'Control whether the response rule is enabled or disabled. \n\n - `true` the rule will be applied. \n\n - `false` the rule will be always ignored.',
     }),
-    operator: zod_1.z.enum(constants_1.RESPONSE_RULES_OPERATORS).meta({
-        markdownDescription: 'Operator to use for combining conditions in the rule.',
-    }),
-    conditions: zod_1.z.array(response_rule_condition_schema_1.ResponseRuleConditionSchema).meta({
-        title: 'Conditions',
-        markdownDescription: 'Array of conditions to check against the request headers. Conditions are applied with **operator**. If conditions are empty, the rule will be matched.',
+    when: response_rule_condition_schema_1.ResponseRuleConditionNodeSchema.optional()
+        .superRefine((node, ctx) => {
+        if (!node) {
+            return;
+        }
+        const { depth, nodes } = (0, response_rule_condition_schema_1.measureResponseRuleConditionTree)(node);
+        if (depth > response_rule_condition_schema_1.RESPONSE_RULES_MAX_CONDITION_DEPTH) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `Condition tree is too deep. Maximum depth is ${response_rule_condition_schema_1.RESPONSE_RULES_MAX_CONDITION_DEPTH}.`,
+            });
+        }
+        if (nodes > response_rule_condition_schema_1.RESPONSE_RULES_MAX_CONDITION_NODES) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `Condition tree is too big. Maximum number of nodes is ${response_rule_condition_schema_1.RESPONSE_RULES_MAX_CONDITION_NODES}.`,
+            });
+        }
+    })
+        .meta({
+        title: 'When',
+        markdownDescription: 'Condition tree to check against the request headers. The root is either a single **condition** or a **group** (`AND`/`OR`/`NOT`) with nested conditions — groups can be nested to express complex logic, e.g. `A AND (B OR C)`. If **when** is omitted, the rule will always be matched.',
     }),
     responseType: zod_1.z.enum(constants_1.RESPONSE_RULES_RESPONSE_TYPES).meta({
         errorMessage: 'Invalid response type. Please select a valid response type.',
@@ -54,10 +70,10 @@ exports.ResponseRuleSchema = exports.ResponseRuleSchemaBase.meta({
             },
         },
         {
-            label: 'Examples: Block Legacy Clients',
-            markdownDescription: `Block requests from legacy clients\n\`\`\`json\n${JSON.stringify(response_rules_examples_1.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE, null, 2)}\n\`\`\``,
+            label: 'Examples: Nested conditions (AND with OR inside)',
+            markdownDescription: `Block browser requests from legacy clients using nested conditions: \`accept AND (user-agent OR user-agent)\`\n\`\`\`json\n${JSON.stringify(response_rules_examples_1.EXAMPLES_SRR_NESTED_CONDITIONS_RULE, null, 2)}\n\`\`\``,
             body: {
-                ...response_rules_examples_1.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE,
+                ...response_rules_examples_1.EXAMPLES_SRR_NESTED_CONDITIONS_RULE,
             },
         },
     ],

package/build/backend/models/response-rules/response-rules-config.schema.d.ts

@@ -1,8 +1,6 @@
 import { z } from 'zod';
 export declare const ResponseRulesConfigSchema: z.ZodObject<{
-    version: z.ZodEnum<{
-        readonly 1: "1";
-    }>;
+    version: z.ZodLiteral<"2">;
     settings: z.ZodOptional<z.ZodObject<{
         disableSubscriptionAccessByPath: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
@@ -10,27 +8,7 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
         name: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         enabled: z.ZodBoolean;
-        operator: z.ZodEnum<{
-            readonly AND: "AND";
-            readonly OR: "OR";
-        }>;
-        conditions: z.ZodArray<z.ZodObject<{
-            headerName: z.ZodString;
-            operator: z.ZodEnum<{
-                readonly EQUALS: "EQUALS";
-                readonly NOT_EQUALS: "NOT_EQUALS";
-                readonly CONTAINS: "CONTAINS";
-                readonly NOT_CONTAINS: "NOT_CONTAINS";
-                readonly STARTS_WITH: "STARTS_WITH";
-                readonly NOT_STARTS_WITH: "NOT_STARTS_WITH";
-                readonly ENDS_WITH: "ENDS_WITH";
-                readonly NOT_ENDS_WITH: "NOT_ENDS_WITH";
-                readonly REGEX: "REGEX";
-                readonly NOT_REGEX: "NOT_REGEX";
-            }>;
-            value: z.ZodString;
-            caseSensitive: z.ZodBoolean;
-        }, z.core.$strip>>;
+        when: z.ZodOptional<z.ZodType<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown>>>;
         responseType: z.ZodEnum<{
             readonly BROWSER: "BROWSER";
             readonly BLOCK: "BLOCK";
@@ -64,6 +42,6 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
             }, z.core.$strip>>;
             excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>;
-    }, z.core.$strip>>;
+    }, z.core.$strict>>;
 }, z.core.$strip>;
 //# sourceMappingURL=response-rules-config.schema.d.ts.map

package/build/backend/models/response-rules/response-rules-config.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response-rules-config.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rules-config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYpC,CAAC"}
+{"version":3,"file":"response-rules-config.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rules-config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBhC,CAAC"}

package/build/backend/models/response-rules/response-rules-config.schema.js

@@ -6,15 +6,20 @@ const constants_1 = require("../../constants");
 const response_rule_settings_schema_1 = require("./response-rule-settings.schema");
 const response_rule_schema_1 = require("./response-rule.schema");
 const response_rules_examples_1 = require("./response-rules-examples");
-exports.ResponseRulesConfigSchema = zod_1.z.object({
-    version: zod_1.z.enum(constants_1.RESPONSE_RULES_CONFIG_VERSION).meta({
+exports.ResponseRulesConfigSchema = zod_1.z
+    .object({
+    version: zod_1.z.literal(constants_1.RESPONSE_RULES_CONFIG_VERSION[2]).meta({
         title: 'Response Rules Config Version',
-        markdownDescription: 'Version of the **response rules** config. Currently supported version is **1**.',
+        markdownDescription: 'Version of the **response rules** config. Currently supported version is **2**. Legacy version **1** configs can be migrated with `migrateResponseRulesConfig`.',
     }),
     settings: response_rule_settings_schema_1.ResponseRuleSettingsSchema,
     rules: zod_1.z.array(response_rule_schema_1.ResponseRuleSchema).meta({
         title: 'Response Rules',
-        markdownDescription: `Array of **response rules**. Rules are evaluated in order and the first rule that matches is applied. If no rule matches, request will be blocked by default.\n\n**Example:**\n\`\`\`json\n${JSON.stringify([response_rules_examples_1.EXAMPLES_SRR_BLANK_RULE], null, 2)}\n\`\`\``,
+        markdownDescription: `Array of **response rules**. Rules are evaluated in order and the first rule that matches is applied. If no rule matches, request will be blocked by default.\n\n**Example:**\n\`\`\`json\n${JSON.stringify([response_rules_examples_1.EXAMPLES_SRR_NESTED_CONDITIONS_RULE], null, 2)}\n\`\`\``,
         defaultSnippets: [],
     }),
+})
+    .meta({
+    title: 'Response Rules Config',
+    markdownDescription: 'Configuration of the **response rules**.',
 });

package/build/backend/models/response-rules/response-rules-examples.d.ts

@@ -1,6 +1,6 @@
-import z from 'zod';
 import type { ResponseRuleSchemaBase } from './response-rule.schema';
+import z from 'zod';
 export declare const EXAMPLES_SRR_BLANK_RULE: z.infer<typeof ResponseRuleSchemaBase>;
-export declare const EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE: z.infer<typeof ResponseRuleSchemaBase>;
+export declare const EXAMPLES_SRR_NESTED_CONDITIONS_RULE: z.infer<typeof ResponseRuleSchemaBase>;
 export declare function generateResponseRuleDescription(schema: typeof ResponseRuleSchemaBase): string;
 //# sourceMappingURL=response-rules-examples.d.ts.map

package/build/backend/models/response-rules/response-rules-examples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response-rules-examples.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rules-examples.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAOpB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAErE,eAAO,MAAM,uBAAuB,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAU1E,CAAC;AAEF,eAAO,MAAM,sCAAsC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAoBzF,CAAC;AAEF,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,OAAO,sBAAsB,UAcpF"}
+{"version":3,"file":"response-rules-examples.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rules-examples.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAErE,OAAO,CAAC,MAAM,KAAK,CAAC;AAQpB,eAAO,MAAM,uBAAuB,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAQ1E,CAAC;AAEF,eAAO,MAAM,mCAAmC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CA8BtF,CAAC;AAEF,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,OAAO,sBAAsB,UAcpF"}

package/build/backend/models/response-rules/response-rules-examples.js

@@ -1,38 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE = exports.EXAMPLES_SRR_BLANK_RULE = void 0;
+exports.EXAMPLES_SRR_NESTED_CONDITIONS_RULE = exports.EXAMPLES_SRR_BLANK_RULE = void 0;
 exports.generateResponseRuleDescription = generateResponseRuleDescription;
 const constants_1 = require("../../constants");
 exports.EXAMPLES_SRR_BLANK_RULE = {
     name: 'Blank rule',
     description: 'Blank rule',
-    operator: 'AND',
     enabled: true,
-    conditions: [],
     responseType: 'BLOCK',
     responseModifications: {
         headers: [],
     },
 };
-exports.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE = {
-    name: 'Block Legacy Clients',
-    description: 'Block requests from legacy clients',
+exports.EXAMPLES_SRR_NESTED_CONDITIONS_RULE = {
+    name: 'Block Legacy Browsers',
+    description: 'Block browser requests from legacy clients',
     enabled: true,
-    operator: constants_1.RESPONSE_RULES_OPERATORS.OR,
-    conditions: [
-        {
-            headerName: 'user-agent',
-            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
-            value: 'Hiddify',
-            caseSensitive: true,
-        },
-        {
-            headerName: 'user-agent',
-            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
-            value: 'FoxRay',
-            caseSensitive: true,
-        },
-    ],
+    when: {
+        operator: constants_1.RESPONSE_RULES_GROUP_OPERATORS.AND,
+        conditions: [
+            {
+                headerName: 'accept',
+                operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+                value: 'text/html',
+            },
+            {
+                operator: constants_1.RESPONSE_RULES_GROUP_OPERATORS.OR,
+                conditions: [
+                    {
+                        headerName: 'user-agent',
+                        operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+                        value: 'Hiddify',
+                    },
+                    {
+                        headerName: 'user-agent',
+                        operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+                        value: 'FoxRay',
+                    },
+                ],
+            },
+        ],
+    },
     responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
 };
 function generateResponseRuleDescription(schema) {
@@ -46,5 +54,5 @@ function generateResponseRuleDescription(schema) {
     const fieldsText = fields
         .map((field) => `- **${field.name}**: ${field.description}`)
         .join('\n');
-    return `Response rule configuration.\n\n**Fields:**\n${fieldsText}\n\n**Example:**\n\`\`\`json\n${JSON.stringify(exports.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE, null, 2)}\n\`\`\``;
+    return `Response rule configuration.\n\n**Fields:**\n${fieldsText}\n\n**Example:**\n\`\`\`json\n${JSON.stringify(exports.EXAMPLES_SRR_NESTED_CONDITIONS_RULE, null, 2)}\n\`\`\``;
 }

package/build/backend/models/response-rules/response-rules-legacy.schema.d.ts

@@ -0,0 +1,157 @@
+import { z } from 'zod';
+/**
+ * Frozen legacy (version 1) response rules config.
+ *
+ * Kept only to accept old configs and migrate them to version 2
+ * via `migrateResponseRulesConfig`. Do not extend.
+ */
+export declare const ResponseRuleLegacyConditionSchema: z.ZodObject<{
+    headerName: z.ZodString;
+    operator: z.ZodEnum<{
+        readonly EQUALS: "EQUALS";
+        readonly NOT_EQUALS: "NOT_EQUALS";
+        readonly CONTAINS: "CONTAINS";
+        readonly NOT_CONTAINS: "NOT_CONTAINS";
+        readonly STARTS_WITH: "STARTS_WITH";
+        readonly NOT_STARTS_WITH: "NOT_STARTS_WITH";
+        readonly ENDS_WITH: "ENDS_WITH";
+        readonly NOT_ENDS_WITH: "NOT_ENDS_WITH";
+        readonly REGEX: "REGEX";
+        readonly NOT_REGEX: "NOT_REGEX";
+        readonly EXISTS: "EXISTS";
+        readonly NOT_EXISTS: "NOT_EXISTS";
+    }>;
+    value: z.ZodString;
+    caseSensitive: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const ResponseRuleLegacySchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodBoolean;
+    operator: z.ZodEnum<{
+        readonly AND: "AND";
+        readonly OR: "OR";
+    }>;
+    conditions: z.ZodArray<z.ZodObject<{
+        headerName: z.ZodString;
+        operator: z.ZodEnum<{
+            readonly EQUALS: "EQUALS";
+            readonly NOT_EQUALS: "NOT_EQUALS";
+            readonly CONTAINS: "CONTAINS";
+            readonly NOT_CONTAINS: "NOT_CONTAINS";
+            readonly STARTS_WITH: "STARTS_WITH";
+            readonly NOT_STARTS_WITH: "NOT_STARTS_WITH";
+            readonly ENDS_WITH: "ENDS_WITH";
+            readonly NOT_ENDS_WITH: "NOT_ENDS_WITH";
+            readonly REGEX: "REGEX";
+            readonly NOT_REGEX: "NOT_REGEX";
+            readonly EXISTS: "EXISTS";
+            readonly NOT_EXISTS: "NOT_EXISTS";
+        }>;
+        value: z.ZodString;
+        caseSensitive: z.ZodBoolean;
+    }, z.core.$strip>>;
+    responseType: z.ZodEnum<{
+        readonly BROWSER: "BROWSER";
+        readonly BLOCK: "BLOCK";
+        readonly STATUS_CODE_404: "STATUS_CODE_404";
+        readonly STATUS_CODE_451: "STATUS_CODE_451";
+        readonly SOCKET_DROP: "SOCKET_DROP";
+        readonly XRAY_JSON: "XRAY_JSON";
+        readonly XRAY_BASE64: "XRAY_BASE64";
+        readonly MIHOMO: "MIHOMO";
+        readonly STASH: "STASH";
+        readonly CLASH: "CLASH";
+        readonly SINGBOX: "SINGBOX";
+    }>;
+    responseModifications: z.ZodOptional<z.ZodObject<{
+        headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>>>;
+        applyHeadersToEnd: z.ZodOptional<z.ZodBoolean>;
+        subscriptionTemplate: z.ZodOptional<z.ZodString>;
+        ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
+        ignoreServeJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;
+        additionalExtendedClientsRegex: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        disableHwidCheck: z.ZodOptional<z.ZodBoolean>;
+        encryption: z.ZodOptional<z.ZodObject<{
+            method: z.ZodEnum<{
+                age1: "age1";
+                age1pq1: "age1pq1";
+            }>;
+            key: z.ZodString;
+        }, z.core.$strip>>;
+        excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ResponseRulesLegacyConfigSchema: z.ZodObject<{
+    version: z.ZodLiteral<"1">;
+    settings: z.ZodOptional<z.ZodObject<{
+        disableSubscriptionAccessByPath: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    rules: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodBoolean;
+        operator: z.ZodEnum<{
+            readonly AND: "AND";
+            readonly OR: "OR";
+        }>;
+        conditions: z.ZodArray<z.ZodObject<{
+            headerName: z.ZodString;
+            operator: z.ZodEnum<{
+                readonly EQUALS: "EQUALS";
+                readonly NOT_EQUALS: "NOT_EQUALS";
+                readonly CONTAINS: "CONTAINS";
+                readonly NOT_CONTAINS: "NOT_CONTAINS";
+                readonly STARTS_WITH: "STARTS_WITH";
+                readonly NOT_STARTS_WITH: "NOT_STARTS_WITH";
+                readonly ENDS_WITH: "ENDS_WITH";
+                readonly NOT_ENDS_WITH: "NOT_ENDS_WITH";
+                readonly REGEX: "REGEX";
+                readonly NOT_REGEX: "NOT_REGEX";
+                readonly EXISTS: "EXISTS";
+                readonly NOT_EXISTS: "NOT_EXISTS";
+            }>;
+            value: z.ZodString;
+            caseSensitive: z.ZodBoolean;
+        }, z.core.$strip>>;
+        responseType: z.ZodEnum<{
+            readonly BROWSER: "BROWSER";
+            readonly BLOCK: "BLOCK";
+            readonly STATUS_CODE_404: "STATUS_CODE_404";
+            readonly STATUS_CODE_451: "STATUS_CODE_451";
+            readonly SOCKET_DROP: "SOCKET_DROP";
+            readonly XRAY_JSON: "XRAY_JSON";
+            readonly XRAY_BASE64: "XRAY_BASE64";
+            readonly MIHOMO: "MIHOMO";
+            readonly STASH: "STASH";
+            readonly CLASH: "CLASH";
+            readonly SINGBOX: "SINGBOX";
+        }>;
+        responseModifications: z.ZodOptional<z.ZodObject<{
+            headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strip>>>;
+            applyHeadersToEnd: z.ZodOptional<z.ZodBoolean>;
+            subscriptionTemplate: z.ZodOptional<z.ZodString>;
+            ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
+            ignoreServeJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;
+            additionalExtendedClientsRegex: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            disableHwidCheck: z.ZodOptional<z.ZodBoolean>;
+            encryption: z.ZodOptional<z.ZodObject<{
+                method: z.ZodEnum<{
+                    age1: "age1";
+                    age1pq1: "age1pq1";
+                }>;
+                key: z.ZodString;
+            }, z.core.$strip>>;
+            excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TResponseRuleLegacy = z.infer<typeof ResponseRuleLegacySchema>;
+export type TResponseRulesLegacyConfig = z.infer<typeof ResponseRulesLegacyConfigSchema>;
+//# sourceMappingURL=response-rules-legacy.schema.d.ts.map

package/build/backend/models/response-rules/response-rules-legacy.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-rules-legacy.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rules-legacy.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB;;;;;GAKG;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;iBAK5C,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQnC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI1C,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC3E,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC"}