@remnawave/backend-contract 2.9.32 → 2.9.33

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.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/frontend/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/frontend/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/package.json

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

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

@@ -1,157 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}

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

@@ -1,33 +0,0 @@
-"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/backend/models/response-rules/response-rules-migration.d.ts

@@ -1,10 +0,0 @@
-import type { ResponseRulesConfigSchema } from './response-rules-config.schema';
-import type { TResponseRulesLegacyConfig } from './response-rules-legacy.schema';
-import type { z } from 'zod';
-type TResponseRulesConfig = z.infer<typeof ResponseRulesConfigSchema>;
-/**
- * Migrates a legacy (version 1) response rules config to version 2.
- */
-export declare function migrateResponseRulesConfig(config: TResponseRulesConfig | TResponseRulesLegacyConfig): TResponseRulesConfig;
-export {};
-//# sourceMappingURL=response-rules-migration.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"response-rules-migration.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rules-migration.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAChF,OAAO,KAAK,EAGR,0BAA0B,EAC7B,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAK7B,KAAK,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAGtE;;GAEG;AACH,wBAAgB,0BAA0B,CACtC,MAAM,EAAE,oBAAoB,GAAG,0BAA0B,GAC1D,oBAAoB,CAUtB"}

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

@@ -1,45 +0,0 @@
-"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/build/frontend/models/response-rules/response-rules-legacy.schema.js

@@ -1,33 +0,0 @@
-"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

@@ -1,45 +0,0 @@
-"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 }),
-    };
-}