@remnawave/backend-contract 2.9.32 → 2.9.33

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

@@ -3,7 +3,27 @@ export declare const ResponseRuleSchemaBase: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     enabled: z.ZodBoolean;
-    when: z.ZodOptional<z.ZodType<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown>>>;
+    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>>;
     responseType: z.ZodEnum<{
         readonly BROWSER: "BROWSER";
         readonly BLOCK: "BLOCK";
@@ -37,12 +57,32 @@ export declare const ResponseRuleSchemaBase: z.ZodObject<{
         }, z.core.$strip>>;
         excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export declare const ResponseRuleSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     enabled: z.ZodBoolean;
-    when: z.ZodOptional<z.ZodType<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown>>>;
+    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>>;
     responseType: z.ZodEnum<{
         readonly BROWSER: "BROWSER";
         readonly BLOCK: "BLOCK";
@@ -76,5 +116,5 @@ export declare const ResponseRuleSchema: z.ZodObject<{
         }, z.core.$strip>>;
         excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 //# 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;AAmBxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0DjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmB7B,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;AAexB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmB7B,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.strictObject({
+exports.ResponseRuleSchemaBase = zod_1.z.object({
     name: zod_1.z
         .string()
         .min(1, 'Name is required')
@@ -28,28 +28,12 @@ exports.ResponseRuleSchemaBase = zod_1.z.strictObject({
         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.',
     }),
-    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.',
+    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.',
     }),
     responseType: zod_1.z.enum(constants_1.RESPONSE_RULES_RESPONSE_TYPES).meta({
         errorMessage: 'Invalid response type. Please select a valid response type.',
@@ -70,10 +54,10 @@ exports.ResponseRuleSchema = exports.ResponseRuleSchemaBase.meta({
             },
         },
         {
-            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\`\`\``,
+            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\`\`\``,
             body: {
-                ...response_rules_examples_1.EXAMPLES_SRR_NESTED_CONDITIONS_RULE,
+                ...response_rules_examples_1.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE,
             },
         },
     ],

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

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 export declare const ResponseRulesConfigSchema: z.ZodObject<{
-    version: z.ZodLiteral<"2">;
+    version: z.ZodEnum<{
+        readonly 1: "1";
+    }>;
     settings: z.ZodOptional<z.ZodObject<{
         disableSubscriptionAccessByPath: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
@@ -8,7 +10,27 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
         name: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         enabled: z.ZodBoolean;
-        when: z.ZodOptional<z.ZodType<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown>>>;
+        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>>;
         responseType: z.ZodEnum<{
             readonly BROWSER: "BROWSER";
             readonly BLOCK: "BLOCK";
@@ -42,6 +64,6 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
             }, z.core.$strip>>;
             excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
 }, 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBhC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYpC,CAAC"}

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

@@ -6,20 +6,15 @@ 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.literal(constants_1.RESPONSE_RULES_CONFIG_VERSION[2]).meta({
+exports.ResponseRulesConfigSchema = zod_1.z.object({
+    version: zod_1.z.enum(constants_1.RESPONSE_RULES_CONFIG_VERSION).meta({
         title: 'Response Rules Config Version',
-        markdownDescription: 'Version of the **response rules** config. Currently supported version is **2**. Legacy version **1** configs can be migrated with `migrateResponseRulesConfig`.',
+        markdownDescription: 'Version of the **response rules** config. Currently supported version is **1**.',
     }),
     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_NESTED_CONDITIONS_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_BLANK_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 type { ResponseRuleSchemaBase } from './response-rule.schema';
 import z from 'zod';
+import type { ResponseRuleSchemaBase } from './response-rule.schema';
 export declare const EXAMPLES_SRR_BLANK_RULE: z.infer<typeof ResponseRuleSchemaBase>;
-export declare const EXAMPLES_SRR_NESTED_CONDITIONS_RULE: z.infer<typeof ResponseRuleSchemaBase>;
+export declare const EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_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,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"}
+{"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"}

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

@@ -1,46 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EXAMPLES_SRR_NESTED_CONDITIONS_RULE = exports.EXAMPLES_SRR_BLANK_RULE = void 0;
+exports.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_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_NESTED_CONDITIONS_RULE = {
-    name: 'Block Legacy Browsers',
-    description: 'Block browser requests from legacy clients',
+exports.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE = {
+    name: 'Block Legacy Clients',
+    description: 'Block requests from legacy clients',
     enabled: 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',
-                    },
-                ],
-            },
-        ],
-    },
+    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,
+        },
+    ],
     responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
 };
 function generateResponseRuleDescription(schema) {
@@ -54,5 +46,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_NESTED_CONDITIONS_RULE, null, 2)}\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\`\`\``;
 }

package/build/backend/models/subscription-settings.schema.d.ts

@@ -14,7 +14,9 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
     customResponseHeaders: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
     randomizeHosts: z.ZodBoolean;
     responseRules: z.ZodNullable<z.ZodObject<{
-        version: z.ZodLiteral<"2">;
+        version: z.ZodEnum<{
+            readonly 1: "1";
+        }>;
         settings: z.ZodOptional<z.ZodObject<{
             disableSubscriptionAccessByPath: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
@@ -22,7 +24,27 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
             name: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
             enabled: z.ZodBoolean;
-            when: z.ZodOptional<z.ZodType<import("./response-rules").TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<import("./response-rules").TResponseRuleConditionNode, unknown>>>;
+            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>>;
             responseType: z.ZodEnum<{
                 readonly BROWSER: "BROWSER";
                 readonly BLOCK: "BLOCK";
@@ -56,7 +78,7 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
                 }, z.core.$strip>>;
                 excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
             }, z.core.$strip>>;
-        }, z.core.$strict>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     hwidSettings: z.ZodNullable<z.ZodObject<{
         enabled: z.ZodBoolean;

package/build/backend/models/subscription-settings.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subscription-settings.schema.d.ts","sourceRoot":"","sources":["../../../models/subscription-settings.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBrC,CAAC"}
+{"version":3,"file":"subscription-settings.schema.d.ts","sourceRoot":"","sources":["../../../models/subscription-settings.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBrC,CAAC"}

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

@@ -1,31 +1,16 @@
 "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_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;
+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;
 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',
 };
-/**
- * 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_RULE_CONDITION_TYPES = {
+    HEADER: 'HEADER',
 };
 exports.RESPONSE_RULES_CONDITION_OPERATORS = {
     EQUALS: 'EQUALS',
@@ -38,8 +23,6 @@ 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,
@@ -75,6 +58,4 @@ 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,5 +18,3 @@ __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,18 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+exports.ResponseRuleConditionSchema = void 0;
 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
-    .strictObject({
+    .object({
     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.')
@@ -29,27 +21,14 @@ 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**. Required for all operators except `EXISTS` and `NOT_EXISTS`.',
+        markdownDescription: '**Value** to check against the **headerName**.',
     }),
-    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.',
+    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.',
     }),
-})
-    .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: [
         {
@@ -59,137 +38,8 @@ exports.ResponseRuleConditionSchema = zod_1.z
                 headerName: 'accept',
                 operator: 'CONTAINS',
                 value: 'text/html',
-            },
-        },
-        {
-            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',
-                },
+                caseSensitive: true,
             },
         },
     ],
 });
-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 };
-    }
-}