@remnawave/backend-contract 2.9.31 → 2.9.32

package/build/frontend/constants/response-rules/response-rules.contants.js

@@ -1,16 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION = exports.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION = exports.RESPONSE_RULES_CONDITION_OPERATORS_VALUES = exports.RESPONSE_RULES_RESPONSE_TYPES_VALUES = exports.RESPONSE_RULES_RESPONSE_TYPES = exports.RESPONSE_RULES_CONDITION_OPERATORS = exports.RESPONSE_RULE_CONDITION_TYPES = exports.RESPONSE_RULES_OPERATORS = exports.RESPONSE_RULES_CONFIG_VERSION = void 0;
+exports.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION = exports.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION = exports.RESPONSE_RULES_CONDITION_OPERATORS_VALUES = exports.RESPONSE_RULES_RESPONSE_TYPES_VALUES = exports.RESPONSE_RULES_RESPONSE_TYPES = exports.RESPONSE_RULES_CONDITION_OPERATORS = exports.RESPONSE_RULES_GROUP_OPERATORS_DESCRIPTION = exports.RESPONSE_RULES_GROUP_OPERATORS_VALUES = exports.RESPONSE_RULES_GROUP_OPERATORS = exports.RESPONSE_RULES_OPERATORS = exports.RESPONSE_RULES_CONFIG_VERSION = void 0;
 const subscription_template_1 = require("../subscription-template");
 exports.RESPONSE_RULES_CONFIG_VERSION = {
     1: '1',
+    2: '2',
 };
+/**
+ * Version 1
+ */
 exports.RESPONSE_RULES_OPERATORS = {
     AND: 'AND',
     OR: 'OR',
 };
-exports.RESPONSE_RULE_CONDITION_TYPES = {
-    HEADER: 'HEADER',
+/**
+ * Version 2
+ */
+exports.RESPONSE_RULES_GROUP_OPERATORS = {
+    AND: 'AND',
+    OR: 'OR',
+    NOT: 'NOT',
+};
+exports.RESPONSE_RULES_GROUP_OPERATORS_VALUES = Object.values(exports.RESPONSE_RULES_GROUP_OPERATORS);
+exports.RESPONSE_RULES_GROUP_OPERATORS_DESCRIPTION = {
+    [exports.RESPONSE_RULES_GROUP_OPERATORS.AND]: 'Matches only if **all** nested conditions match. `conditions.every()`',
+    [exports.RESPONSE_RULES_GROUP_OPERATORS.OR]: 'Matches if **at least one** nested condition matches. `conditions.some()`',
+    [exports.RESPONSE_RULES_GROUP_OPERATORS.NOT]: 'Inverts the result of the nested **condition**. `!condition`',
 };
 exports.RESPONSE_RULES_CONDITION_OPERATORS = {
     EQUALS: 'EQUALS',
@@ -23,6 +38,8 @@ exports.RESPONSE_RULES_CONDITION_OPERATORS = {
     NOT_ENDS_WITH: 'NOT_ENDS_WITH',
     REGEX: 'REGEX',
     NOT_REGEX: 'NOT_REGEX',
+    EXISTS: 'EXISTS',
+    NOT_EXISTS: 'NOT_EXISTS',
 };
 exports.RESPONSE_RULES_RESPONSE_TYPES = {
     ...subscription_template_1.SUBSCRIPTION_TEMPLATE_TYPE,
@@ -58,4 +75,6 @@ exports.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION = {
     [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_ENDS_WITH]: 'Confirms the header value does not end with the specified string. `!string.endsWith()`',
     [exports.RESPONSE_RULES_CONDITION_OPERATORS.REGEX]: 'Evaluates if the header value matches the specified regular expression pattern. `regex.test()`',
     [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_REGEX]: 'Evaluates if the header value does not match the specified regular expression pattern. `!regex.test()`',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.EXISTS]: 'Checks that the header is present in the request, regardless of its value. `value` is not required. `string !== undefined`',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_EXISTS]: 'Checks that the header is not present in the request. `value` is not required. `string === undefined`',
 };

package/build/frontend/models/response-rules/index.js

@@ -18,3 +18,5 @@ __exportStar(require("./response-rule-condition.schema"), exports);
 __exportStar(require("./response-rule-modifications.schema"), exports);
 __exportStar(require("./response-rule.schema"), exports);
 __exportStar(require("./response-rules-config.schema"), exports);
+__exportStar(require("./response-rules-legacy.schema"), exports);
+__exportStar(require("./response-rules-migration"), exports);

package/build/frontend/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/frontend/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/frontend/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/frontend/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/frontend/models/response-rules/response-rules-legacy.schema.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseRulesLegacyConfigSchema = exports.ResponseRuleLegacySchema = exports.ResponseRuleLegacyConditionSchema = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../constants");
+const response_rule_modifications_schema_1 = require("./response-rule-modifications.schema");
+const response_rule_settings_schema_1 = require("./response-rule-settings.schema");
+/**
+ * Frozen legacy (version 1) response rules config.
+ *
+ * Kept only to accept old configs and migrate them to version 2
+ * via `migrateResponseRulesConfig`. Do not extend.
+ */
+exports.ResponseRuleLegacyConditionSchema = zod_1.z.object({
+    headerName: zod_1.z.string(),
+    operator: zod_1.z.enum(constants_1.RESPONSE_RULES_CONDITION_OPERATORS),
+    value: zod_1.z.string(),
+    caseSensitive: zod_1.z.boolean(),
+});
+exports.ResponseRuleLegacySchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    enabled: zod_1.z.boolean(),
+    operator: zod_1.z.enum(constants_1.RESPONSE_RULES_OPERATORS),
+    conditions: zod_1.z.array(exports.ResponseRuleLegacyConditionSchema),
+    responseType: zod_1.z.enum(constants_1.RESPONSE_RULES_RESPONSE_TYPES),
+    responseModifications: response_rule_modifications_schema_1.ResponseRuleModificationsSchema,
+});
+exports.ResponseRulesLegacyConfigSchema = zod_1.z.object({
+    version: zod_1.z.literal(constants_1.RESPONSE_RULES_CONFIG_VERSION[1]),
+    settings: response_rule_settings_schema_1.ResponseRuleSettingsSchema,
+    rules: zod_1.z.array(exports.ResponseRuleLegacySchema),
+});

package/build/frontend/models/response-rules/response-rules-migration.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateResponseRulesConfig = migrateResponseRulesConfig;
+const constants_1 = require("../../constants");
+/**
+ * Migrates a legacy (version 1) response rules config to version 2.
+ */
+function migrateResponseRulesConfig(config) {
+    if (config.version === constants_1.RESPONSE_RULES_CONFIG_VERSION[2]) {
+        return config;
+    }
+    return {
+        version: constants_1.RESPONSE_RULES_CONFIG_VERSION[2],
+        ...(config.settings !== undefined && { settings: config.settings }),
+        rules: config.rules.map(migrateLegacyResponseRule),
+    };
+}
+function migrateLegacyResponseRule(rule) {
+    const { operator, conditions, ...rest } = rule;
+    const when = migrateLegacyConditions(operator, conditions);
+    return {
+        ...rest,
+        ...(when !== undefined && { when }),
+    };
+}
+function migrateLegacyConditions(operator, conditions) {
+    if (conditions.length === 0) {
+        return undefined;
+    }
+    if (conditions.length === 1) {
+        return migrateLegacyCondition(conditions[0]);
+    }
+    return {
+        operator,
+        conditions: conditions.map(migrateLegacyCondition),
+    };
+}
+function migrateLegacyCondition(condition) {
+    return {
+        headerName: condition.headerName,
+        operator: condition.operator,
+        value: condition.value,
+        ...(condition.caseSensitive && { caseSensitive: true }),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnawave/backend-contract",
-  "version": "2.9.31",
+  "version": "2.9.32",
   "description": "A contract library for Remnawave Backend. It can be used in backend and frontend.",
   "keywords": [],
   "homepage": "https://github.com/remnawave",