@featurevisor/core 1.35.2 → 2.0.0

package/lib/linter/featureSchema.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFeatureZodSchema = getFeatureZodSchema;
-var zod_1 = require("zod");
-var tagRegex = /^[a-z0-9-]+$/;
+const zod_1 = require("zod");
+const tagRegex = /^[a-z0-9-]+$/;
 function isFlatObject(value) {
-    var isFlat = true;
-    Object.keys(value).forEach(function (key) {
+    let isFlat = true;
+    Object.keys(value).forEach((key) => {
         if (typeof value[key] === "object") {
             isFlat = false;
         }
@@ -13,21 +13,21 @@ function isFlatObject(value) {
     return isFlat;
 }
 function isArrayOfStrings(value) {
-    return Array.isArray(value) && value.every(function (v) { return typeof v === "string"; });
+    return Array.isArray(value) && value.every((v) => typeof v === "string");
 }
 function superRefineVariableValue(projectConfig, variableSchema, variableValue, path, ctx) {
     if (!variableSchema) {
-        var message = "Unknown variable with value: ".concat(variableValue);
+        let message = `Unknown variable with value: ${variableValue}`;
         if (path.length > 0) {
-            var lastPath = path[path.length - 1];
+            const lastPath = path[path.length - 1];
             if (typeof lastPath === "string") {
-                message = "Unknown variable \"".concat(lastPath, "\" with value: ").concat(variableValue);
+                message = `Unknown variable "${lastPath}" with value: ${variableValue}`;
             }
         }
         ctx.addIssue({
             code: zod_1.z.ZodIssueCode.custom,
-            message: message,
-            path: path,
+            message,
+            path,
         });
         return;
     }
@@ -36,16 +36,16 @@ function superRefineVariableValue(projectConfig, variableSchema, variableValue,
         if (typeof variableValue !== "string") {
             ctx.addIssue({
                 code: zod_1.z.ZodIssueCode.custom,
-                message: "Invalid value for variable \"".concat(variableSchema.key, "\" (").concat(variableSchema.type, "): ").concat(variableValue),
-                path: path,
+                message: `Invalid value for variable "${variableSchema.key}" (${variableSchema.type}): ${variableValue}`,
+                path,
             });
         }
         if (projectConfig.maxVariableStringLength &&
             variableValue.length > projectConfig.maxVariableStringLength) {
             ctx.addIssue({
                 code: zod_1.z.ZodIssueCode.custom,
-                message: "Variable \"".concat(variableSchema.key, "\" value is too long (").concat(variableValue.length, " characters), max length is ").concat(projectConfig.maxVariableStringLength),
-                path: path,
+                message: `Variable "${variableSchema.key}" value is too long (${variableValue.length} characters), max length is ${projectConfig.maxVariableStringLength}`,
+                path,
             });
         }
         return;
@@ -55,8 +55,8 @@ function superRefineVariableValue(projectConfig, variableSchema, variableValue,
         if (typeof variableValue !== "number") {
             ctx.addIssue({
                 code: zod_1.z.ZodIssueCode.custom,
-                message: "Invalid value for variable \"".concat(variableSchema.key, "\" (").concat(variableSchema.type, "): ").concat(variableValue),
-                path: path,
+                message: `Invalid value for variable "${variableSchema.key}" (${variableSchema.type}): ${variableValue}`,
+                path,
             });
         }
         return;
@@ -66,8 +66,8 @@ function superRefineVariableValue(projectConfig, variableSchema, variableValue,
         if (typeof variableValue !== "boolean") {
             ctx.addIssue({
                 code: zod_1.z.ZodIssueCode.custom,
-                message: "Invalid value for variable \"".concat(variableSchema.key, "\" (").concat(variableSchema.type, "): ").concat(variableValue),
-                path: path,
+                message: `Invalid value for variable "${variableSchema.key}" (${variableSchema.type}): ${variableValue}`,
+                path,
             });
         }
         return;
@@ -77,17 +77,17 @@ function superRefineVariableValue(projectConfig, variableSchema, variableValue,
         if (!Array.isArray(variableValue) || !isArrayOfStrings(variableValue)) {
             ctx.addIssue({
                 code: zod_1.z.ZodIssueCode.custom,
-                message: "Invalid value for variable \"".concat(variableSchema.key, "\" (").concat(variableSchema.type, "): \n\n").concat(variableValue, "\n\n"),
-                path: path,
+                message: `Invalid value for variable "${variableSchema.key}" (${variableSchema.type}): \n\n${variableValue}\n\n`,
+                path,
             });
         }
         if (projectConfig.maxVariableArrayStringifiedLength) {
-            var stringified = JSON.stringify(variableValue);
+            const stringified = JSON.stringify(variableValue);
             if (stringified.length > projectConfig.maxVariableArrayStringifiedLength) {
                 ctx.addIssue({
                     code: zod_1.z.ZodIssueCode.custom,
-                    message: "Variable \"".concat(variableSchema.key, "\" array is too long (").concat(stringified.length, " characters), max length is ").concat(projectConfig.maxVariableArrayStringifiedLength),
-                    path: path,
+                    message: `Variable "${variableSchema.key}" array is too long (${stringified.length} characters), max length is ${projectConfig.maxVariableArrayStringifiedLength}`,
+                    path,
                 });
             }
         }
@@ -98,17 +98,17 @@ function superRefineVariableValue(projectConfig, variableSchema, variableValue,
         if (typeof variableValue !== "object" || !isFlatObject(variableValue)) {
             ctx.addIssue({
                 code: zod_1.z.ZodIssueCode.custom,
-                message: "Invalid value for variable \"".concat(variableSchema.key, "\" (").concat(variableSchema.type, "): \n\n").concat(variableValue, "\n\n"),
-                path: path,
+                message: `Invalid value for variable "${variableSchema.key}" (${variableSchema.type}): \n\n${variableValue}\n\n`,
+                path,
             });
         }
         if (projectConfig.maxVariableObjectStringifiedLength) {
-            var stringified = JSON.stringify(variableValue);
+            const stringified = JSON.stringify(variableValue);
             if (stringified.length > projectConfig.maxVariableObjectStringifiedLength) {
                 ctx.addIssue({
                     code: zod_1.z.ZodIssueCode.custom,
-                    message: "Variable \"".concat(variableSchema.key, "\" object is too long (").concat(stringified.length, " characters), max length is ").concat(projectConfig.maxVariableObjectStringifiedLength),
-                    path: path,
+                    message: `Variable "${variableSchema.key}" object is too long (${stringified.length} characters), max length is ${projectConfig.maxVariableObjectStringifiedLength}`,
+                    path,
                 });
             }
         }
@@ -119,65 +119,147 @@ function superRefineVariableValue(projectConfig, variableSchema, variableValue,
         try {
             JSON.parse(variableValue);
             if (projectConfig.maxVariableJSONStringifiedLength) {
-                var stringified = variableValue;
+                const stringified = variableValue;
                 if (stringified.length > projectConfig.maxVariableJSONStringifiedLength) {
                     ctx.addIssue({
                         code: zod_1.z.ZodIssueCode.custom,
-                        message: "Variable \"".concat(variableSchema.key, "\" JSON is too long (").concat(stringified.length, " characters), max length is ").concat(projectConfig.maxVariableJSONStringifiedLength),
-                        path: path,
+                        message: `Variable "${variableSchema.key}" JSON is too long (${stringified.length} characters), max length is ${projectConfig.maxVariableJSONStringifiedLength}`,
+                        path,
                     });
                 }
             }
+            // eslint-disable-next-line
         }
         catch (e) {
             ctx.addIssue({
                 code: zod_1.z.ZodIssueCode.custom,
-                message: "Invalid value for variable \"".concat(variableSchema.key, "\" (").concat(variableSchema.type, "): \n\n").concat(variableValue, "\n\n"),
-                path: path,
+                message: `Invalid value for variable "${variableSchema.key}" (${variableSchema.type}): \n\n${variableValue}\n\n`,
+                path,
             });
         }
         return;
     }
 }
+function refineForce({ ctx, parsedFeature, // eslint-disable-line
+variableSchemaByKey, variationValues, force, pathPrefix, projectConfig, }) {
+    force.forEach((f, fN) => {
+        // force[n].variation
+        if (f.variation) {
+            if (variationValues.indexOf(f.variation) === -1) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `Unknown variation "${f.variation}" in force`,
+                    path: [...pathPrefix, fN, "variation"],
+                });
+            }
+        }
+        // force[n].variables[key]
+        if (f.variables) {
+            Object.keys(f.variables).forEach((variableKey) => {
+                superRefineVariableValue(projectConfig, variableSchemaByKey[variableKey], f.variables[variableKey], pathPrefix.concat([fN, "variables", variableKey]), ctx);
+            });
+        }
+    });
+}
+function refineRules({ ctx, parsedFeature, variableSchemaByKey, variationValues, rules, pathPrefix, projectConfig, }) {
+    rules.forEach((rule, ruleN) => {
+        // rules[n].variables[key]
+        if (rule.variables) {
+            Object.keys(rule.variables).forEach((variableKey) => {
+                superRefineVariableValue(projectConfig, variableSchemaByKey[variableKey], rule.variables[variableKey], pathPrefix.concat([ruleN, "variables", variableKey]), ctx);
+            });
+        }
+        // rules[n].variationWeights
+        if (rule.variationWeights) {
+            if (!parsedFeature.variations) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: "Variation weights are overridden from rule, but no variations are present in feature.",
+                    path: pathPrefix.concat([ruleN, "variationWeights"]),
+                });
+            }
+            else {
+                const overriddenVariationValues = Object.keys(rule.variationWeights);
+                const overriddenVariationWeights = Object.values(rule.variationWeights);
+                // unique keys
+                if (overriddenVariationValues.length !== new Set(overriddenVariationValues).size) {
+                    ctx.addIssue({
+                        code: zod_1.z.ZodIssueCode.custom,
+                        message: "Duplicate variation values found in variationWeights: " +
+                            overriddenVariationValues.join(", "),
+                        path: pathPrefix.concat([ruleN, "variationWeights"]),
+                    });
+                }
+                // all original variations must be used
+                const missingVariations = variationValues.filter((v) => !overriddenVariationValues.includes(v));
+                if (missingVariations.length > 0) {
+                    ctx.addIssue({
+                        code: zod_1.z.ZodIssueCode.custom,
+                        message: "Missing variations: " + missingVariations.join(", "),
+                        path: pathPrefix.concat([ruleN, "variationWeights"]),
+                    });
+                }
+                // unknown variations
+                const unknownVariations = overriddenVariationValues.filter((v) => !variationValues.includes(v));
+                if (unknownVariations.length > 0) {
+                    ctx.addIssue({
+                        code: zod_1.z.ZodIssueCode.custom,
+                        message: "Variation weights contain unknown variations: " + unknownVariations.join(", "),
+                        path: pathPrefix.concat([ruleN, "variationWeights"]),
+                    });
+                }
+                // weights sum must be 100
+                const weightsSum = overriddenVariationWeights.reduce((sum, weight) => sum + weight, 0);
+                if (weightsSum !== 100) {
+                    ctx.addIssue({
+                        code: zod_1.z.ZodIssueCode.custom,
+                        message: "Variation weights must sum to 100",
+                        path: pathPrefix.concat([ruleN, "variationWeights"]),
+                    });
+                }
+            }
+        }
+    });
+}
 function getFeatureZodSchema(projectConfig, conditionsZodSchema, availableAttributeKeys, availableSegmentKeys, availableFeatureKeys) {
-    var variationValueZodSchema = zod_1.z.string().min(1);
-    var variableValueZodSchema = zod_1.z.union([
+    const variationValueZodSchema = zod_1.z.string().min(1);
+    const variableValueZodSchema = zod_1.z.union([
         zod_1.z.string(),
         zod_1.z.number(),
         zod_1.z.boolean(),
         zod_1.z.array(zod_1.z.string()),
-        zod_1.z.record(zod_1.z.unknown()).refine(function (value) {
+        zod_1.z.record(zod_1.z.unknown()).refine((value) => {
             return isFlatObject(value);
         }, {
             message: "object is not flat",
         }),
     ]);
-    var plainGroupSegment = zod_1.z.string().refine(function (value) { return value === "*" || availableSegmentKeys.includes(value); }, function (value) { return ({
-        message: "Unknown segment key \"".concat(value, "\""),
-    }); });
-    var andOrNotGroupSegment = zod_1.z.union([
+    const plainGroupSegment = zod_1.z.string().refine((value) => value === "*" || availableSegmentKeys.includes(value), (value) => ({
+        message: `Unknown segment key "${value}"`,
+    }));
+    const andOrNotGroupSegment = zod_1.z.union([
         zod_1.z
             .object({
-            and: zod_1.z.array(zod_1.z.lazy(function () { return groupSegmentZodSchema; })),
+            and: zod_1.z.array(zod_1.z.lazy(() => groupSegmentZodSchema)),
         })
             .strict(),
         zod_1.z
             .object({
-            or: zod_1.z.array(zod_1.z.lazy(function () { return groupSegmentZodSchema; })),
+            or: zod_1.z.array(zod_1.z.lazy(() => groupSegmentZodSchema)),
         })
             .strict(),
         zod_1.z
             .object({
-            not: zod_1.z.array(zod_1.z.lazy(function () { return groupSegmentZodSchema; })),
+            not: zod_1.z.array(zod_1.z.lazy(() => groupSegmentZodSchema)),
         })
             .strict(),
     ]);
-    var groupSegmentZodSchema = zod_1.z.union([andOrNotGroupSegment, plainGroupSegment]);
-    var groupSegmentsZodSchema = zod_1.z.union([zod_1.z.array(groupSegmentZodSchema), groupSegmentZodSchema]);
-    var exposeSchema = zod_1.z
-        .union([zod_1.z.boolean(), zod_1.z.array(zod_1.z.string().refine(function (value) { return projectConfig.tags.includes(value); }))])
+    const groupSegmentZodSchema = zod_1.z.union([andOrNotGroupSegment, plainGroupSegment]);
+    const groupSegmentsZodSchema = zod_1.z.union([zod_1.z.array(groupSegmentZodSchema), groupSegmentZodSchema]);
+    const exposeSchema = zod_1.z
+        .union([zod_1.z.boolean(), zod_1.z.array(zod_1.z.string().refine((value) => projectConfig.tags.includes(value)))])
         .optional();
-    var rulesSchema = zod_1.z
+    const rulesSchema = zod_1.z
         .array(zod_1.z
         .object({
         key: zod_1.z.string(),
@@ -187,30 +269,31 @@ function getFeatureZodSchema(projectConfig, conditionsZodSchema, availableAttrib
         enabled: zod_1.z.boolean().optional(),
         variation: variationValueZodSchema.optional(),
         variables: zod_1.z.record(variableValueZodSchema).optional(),
+        variationWeights: zod_1.z.record(zod_1.z.number().min(0).max(100)).optional(),
     })
         .strict())
         // must have at least one rule
-        .refine(function (value) { return value.length > 0; }, function () { return ({
+        .refine((value) => value.length > 0, () => ({
         message: "Must have at least one rule",
-    }); })
+    }))
         // duplicate rules
-        .refine(function (value) {
-        var keys = value.map(function (v) { return v.key; });
+        .refine((value) => {
+        const keys = value.map((v) => v.key);
         return keys.length === new Set(keys).size;
-    }, function (value) { return ({
-        message: "Duplicate rule keys found: " + value.map(function (v) { return v.key; }).join(", "),
-    }); })
+    }, (value) => ({
+        message: "Duplicate rule keys found: " + value.map((v) => v.key).join(", "),
+    }))
         // enforce catch-all rule
-        .refine(function (value) {
+        .refine((value) => {
         if (!projectConfig.enforceCatchAllRule) {
             return true;
         }
-        var hasCatchAllAsLastRule = value[value.length - 1].segments === "*";
+        const hasCatchAllAsLastRule = value[value.length - 1].segments === "*";
         return hasCatchAllAsLastRule;
-    }, function () { return ({
-        message: "Missing catch-all rule with `segments: \"*\"` at the end",
-    }); });
-    var forceSchema = zod_1.z
+    }, () => ({
+        message: `Missing catch-all rule with \`segments: "*"\` at the end`,
+    }));
+    const forceSchema = zod_1.z
         .array(zod_1.z.union([
         zod_1.z
             .object({
@@ -230,41 +313,27 @@ function getFeatureZodSchema(projectConfig, conditionsZodSchema, availableAttrib
             .strict(),
     ]))
         .optional();
-    var environmentZodSchema = zod_1.z
-        .object({
-        expose: exposeSchema,
-        rules: rulesSchema,
-        force: forceSchema,
-    })
-        .strict();
-    var allEnvironmentsZodSchema = zod_1.z.never();
-    if (Array.isArray(projectConfig.environments)) {
-        var allEnvironmentsSchema_1 = {};
-        projectConfig.environments.forEach(function (environmentKey) {
-            allEnvironmentsSchema_1[environmentKey] = environmentZodSchema;
-        });
-        allEnvironmentsZodSchema = zod_1.z.object(allEnvironmentsSchema_1).strict();
-    }
-    var attributeKeyZodSchema = zod_1.z.string().refine(function (value) { return value === "*" || availableAttributeKeys.includes(value); }, function (value) { return ({
-        message: "Unknown attribute \"".concat(value, "\""),
-    }); });
-    var featureKeyZodSchema = zod_1.z.string().refine(function (value) { return availableFeatureKeys.includes(value); }, function (value) { return ({
-        message: "Unknown feature \"".concat(value, "\""),
-    }); });
-    var featureZodSchema = zod_1.z
+    const attributeKeyZodSchema = zod_1.z.string().refine((value) => value === "*" || availableAttributeKeys.includes(value), (value) => ({
+        message: `Unknown attribute "${value}"`,
+    }));
+    const featureKeyZodSchema = zod_1.z.string().refine((value) => availableFeatureKeys.includes(value), (value) => ({
+        message: `Unknown feature "${value}"`,
+    }));
+    const environmentKeys = projectConfig.environments || [];
+    const featureZodSchema = zod_1.z
         .object({
         archived: zod_1.z.boolean().optional(),
         deprecated: zod_1.z.boolean().optional(),
         description: zod_1.z.string(),
         tags: zod_1.z
-            .array(zod_1.z.string().refine(function (value) { return tagRegex.test(value); }, function (value) { return ({
-            message: "Tag \"".concat(value, "\" must be lower cased and alphanumeric, and may contain hyphens."),
-        }); }))
-            .refine(function (value) {
+            .array(zod_1.z.string().refine((value) => tagRegex.test(value), (value) => ({
+            message: `Tag "${value}" must be lower cased and alphanumeric, and may contain hyphens.`,
+        })))
+            .refine((value) => {
             return value.length === new Set(value).size;
-        }, function (value) { return ({
+        }, (value) => ({
             message: "Duplicate tags found: " + value.join(", "),
-        }); }),
+        })),
         required: zod_1.z
             .array(zod_1.z.union([
             featureKeyZodSchema,
@@ -285,124 +354,196 @@ function getFeatureZodSchema(projectConfig, conditionsZodSchema, availableAttrib
             })
                 .strict(),
         ]),
-        // @TODO: in v2, this will become a dictionary
         variablesSchema: zod_1.z
-            .array(zod_1.z
+            .record(zod_1.z
             .object({
             deprecated: zod_1.z.boolean().optional(),
-            key: zod_1.z
-                .string()
-                .min(1)
-                .refine(function (value) { return value !== "variation"; }, {
-                message: "variable key cannot be \"variation\"",
-            }),
             type: zod_1.z.enum(["string", "integer", "boolean", "double", "array", "object", "json"]),
             description: zod_1.z.string().optional(),
             defaultValue: variableValueZodSchema,
+            useDefaultWhenDisabled: zod_1.z.boolean().optional(),
+            disabledValue: variableValueZodSchema.optional(),
         })
             .strict())
-            .refine(function (value) {
-            var keys = value.map(function (v) { return v.key; });
-            return keys.length === new Set(keys).size;
-        }, function (value) { return ({
-            message: "Duplicate variable keys found: " + value.map(function (v) { return v.key; }).join(", "),
-        }); })
             .optional(),
+        disabledVariationValue: variationValueZodSchema.optional(),
         variations: zod_1.z
             .array(zod_1.z
             .object({
             description: zod_1.z.string().optional(),
             value: variationValueZodSchema,
             weight: zod_1.z.number().min(0).max(100),
-            variables: zod_1.z
-                .array(zod_1.z
-                .object({
-                key: zod_1.z.string().min(1),
-                value: variableValueZodSchema,
-                overrides: zod_1.z
-                    .array(zod_1.z.union([
-                    zod_1.z
-                        .object({
-                        conditions: conditionsZodSchema,
-                        value: variableValueZodSchema,
-                    })
-                        .strict(),
-                    zod_1.z
-                        .object({
-                        segments: groupSegmentsZodSchema,
-                        value: variableValueZodSchema,
-                    })
-                        .strict(),
-                ]))
-                    .optional(),
-            })
-                .strict())
+            variables: zod_1.z.record(variableValueZodSchema).optional(),
+            variableOverrides: zod_1.z
+                .record(zod_1.z.array(zod_1.z.union([
+                zod_1.z
+                    .object({
+                    conditions: conditionsZodSchema,
+                    value: variableValueZodSchema,
+                })
+                    .strict(),
+                zod_1.z
+                    .object({
+                    segments: groupSegmentsZodSchema,
+                    value: variableValueZodSchema,
+                })
+                    .strict(),
+            ])))
                 .optional(),
         })
             .strict())
-            .refine(function (value) {
-            var variationValues = value.map(function (v) { return v.value; });
+            .refine((value) => {
+            const variationValues = value.map((v) => v.value);
             return variationValues.length === new Set(variationValues).size;
-        }, function (value) { return ({
-            message: "Duplicate variation values found: " + value.map(function (v) { return v.value; }).join(", "),
-        }); })
+        }, (value) => ({
+            message: "Duplicate variation values found: " + value.map((v) => v.value).join(", "),
+        }))
             .optional(),
-        // with environments
-        environments: Array.isArray(projectConfig.environments)
-            ? allEnvironmentsZodSchema
-            : zod_1.z.never().optional(),
-        // no environments
-        expose: projectConfig.environments === false ? exposeSchema : zod_1.z.never().optional(),
-        rules: projectConfig.environments === false ? rulesSchema : zod_1.z.never().optional(),
-        force: projectConfig.environments === false ? forceSchema : zod_1.z.never().optional(),
+        expose: projectConfig.environments === false
+            ? exposeSchema.optional()
+            : zod_1.z.record(zod_1.z.enum(environmentKeys), exposeSchema).optional(),
+        force: projectConfig.environments === false
+            ? forceSchema
+            : zod_1.z.record(zod_1.z.enum(environmentKeys), forceSchema).optional(),
+        rules: projectConfig.environments === false
+            ? rulesSchema
+            : zod_1.z.record(zod_1.z.enum(environmentKeys), rulesSchema),
     })
         .strict()
-        .superRefine(function (value, ctx) {
+        .superRefine((value, ctx) => {
+        // disabledVariationValue
+        if (value.disabledVariationValue) {
+            if (!value.variations) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: "Disabled variation value is set, but no variations are present in feature.",
+                    path: ["disabledVariationValue"],
+                });
+            }
+            else {
+                const variationValues = value.variations.map((v) => v.value);
+                if (variationValues.indexOf(value.disabledVariationValue) === -1) {
+                    ctx.addIssue({
+                        code: zod_1.z.ZodIssueCode.custom,
+                        message: `Disabled variation value "${value.disabledVariationValue}" is not one of the defined variations: ${variationValues.join(", ")}`,
+                        path: ["disabledVariationValue"],
+                    });
+                }
+            }
+        }
         if (!value.variablesSchema) {
             return;
         }
-        var allVariablesSchema = value.variablesSchema;
-        var variableSchemaByKey = {};
-        // variablesSchema[n].defaultValue
-        allVariablesSchema.forEach(function (variableSchema, n) {
-            variableSchemaByKey[variableSchema.key] = variableSchema;
-            superRefineVariableValue(projectConfig, variableSchema, variableSchema.defaultValue, ["variablesSchema", n, "defaultValue"], ctx);
+        const variableSchemaByKey = value.variablesSchema;
+        const variationValues = [];
+        if (value.variations) {
+            value.variations.forEach((variation) => {
+                variationValues.push(variation.value);
+            });
+        }
+        // variablesSchema[key]
+        const variableKeys = Object.keys(variableSchemaByKey);
+        variableKeys.forEach((variableKey) => {
+            const variableSchema = variableSchemaByKey[variableKey];
+            if (variableKey === "variation") {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `Variable key "${variableKey}" is reserved and cannot be used.`,
+                    path: ["variablesSchema", variableKey],
+                });
+            }
+            // defaultValue
+            superRefineVariableValue(projectConfig, variableSchema, variableSchema.defaultValue, ["variablesSchema", variableKey, "defaultValue"], ctx);
+            // disabledValue
+            superRefineVariableValue(projectConfig, variableSchema, variableSchema.defaultValue, ["variablesSchema", variableKey, "disabledValue"], ctx);
         });
-        // variations[n].variables[n].value
+        // variations
         if (value.variations) {
-            value.variations.forEach(function (variation, variationN) {
+            value.variations.forEach((variation, variationN) => {
                 if (!variation.variables) {
                     return;
                 }
-                variation.variables.forEach(function (variable, variableN) {
-                    superRefineVariableValue(projectConfig, variableSchemaByKey[variable.key], variable.value, ["variations", variationN, "variables", variableN, "value"], ctx);
-                    // variations[n].variables[n].overrides[n].value
-                    if (variable.overrides) {
-                        variable.overrides.forEach(function (override, overrideN) {
-                            superRefineVariableValue(projectConfig, variableSchemaByKey[variable.key], override.value, [
-                                "variations",
-                                variationN,
-                                "variables",
-                                variableN,
-                                "overrides",
-                                overrideN,
-                                "value",
-                            ], ctx);
-                        });
+                // variations[n].variables[key]
+                for (const variableKey of Object.keys(variation.variables)) {
+                    const variableValue = variation.variables[variableKey];
+                    superRefineVariableValue(projectConfig, variableSchemaByKey[variableKey], variableValue, ["variations", variationN, "variables", variableKey], ctx);
+                    // variations[n].variableOverrides[n].value
+                    if (variation.variableOverrides) {
+                        for (const variableKey of Object.keys(variation.variableOverrides)) {
+                            const overrides = variation.variableOverrides[variableKey];
+                            if (Array.isArray(overrides)) {
+                                overrides.forEach((override, overrideN) => {
+                                    superRefineVariableValue(projectConfig, variableSchemaByKey[variableKey], override.value, [
+                                        "variations",
+                                        variationN,
+                                        "variableOverrides",
+                                        variableKey,
+                                        overrideN,
+                                        "value",
+                                    ], ctx);
+                                });
+                            }
+                        }
                     }
-                });
+                }
             });
         }
-        // environments[key].rules[n].variables[key]
-        Object.keys(value.environments).forEach(function (environmentKey) {
-            value.environments[environmentKey].rules.forEach(function (rule, ruleN) {
-                if (rule.variables) {
-                    Object.keys(rule.variables).forEach(function (variableKey) {
-                        superRefineVariableValue(projectConfig, variableSchemaByKey[variableKey], rule.variables[variableKey], ["environments", environmentKey, "rules", ruleN, "variables", variableKey], ctx);
+        if (environmentKeys.length > 0) {
+            // with environments
+            for (const environmentKey of environmentKeys) {
+                // rules
+                if (value.rules && value.rules[environmentKey]) {
+                    refineRules({
+                        parsedFeature: value,
+                        variableSchemaByKey,
+                        variationValues,
+                        rules: value.rules[environmentKey],
+                        pathPrefix: ["rules", environmentKey],
+                        ctx,
+                        projectConfig,
                     });
                 }
-            });
-        });
+                // force
+                if (value.force && value.force[environmentKey]) {
+                    refineForce({
+                        parsedFeature: value,
+                        variableSchemaByKey,
+                        variationValues,
+                        force: value.force[environmentKey],
+                        pathPrefix: ["force", environmentKey],
+                        ctx,
+                        projectConfig,
+                    });
+                }
+            }
+        }
+        else {
+            // no environments
+            // rules
+            if (value.rules) {
+                refineRules({
+                    parsedFeature: value,
+                    variableSchemaByKey,
+                    variationValues,
+                    rules: value.rules,
+                    pathPrefix: ["rules"],
+                    ctx,
+                    projectConfig,
+                });
+            }
+            // force
+            if (value.force) {
+                refineForce({
+                    parsedFeature: value,
+                    variableSchemaByKey,
+                    variationValues,
+                    force: value.force,
+                    pathPrefix: ["force"],
+                    ctx,
+                    projectConfig,
+                });
+            }
+        }
     });
     return featureZodSchema;
 }