@featurevisor/core 2.10.0 → 2.12.0

package/lib/linter/featureSchema.spec.js

@@ -0,0 +1,978 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const conditionSchema_1 = require("./conditionSchema");
+const featureSchema_1 = require("./featureSchema");
+/** Minimal project config for feature schema tests (no file paths used for variable validation). */
+function minimalProjectConfig(overrides = {}) {
+    return {
+        featuresDirectoryPath: "",
+        segmentsDirectoryPath: "",
+        attributesDirectoryPath: "",
+        groupsDirectoryPath: "",
+        schemasDirectoryPath: "",
+        testsDirectoryPath: "",
+        stateDirectoryPath: "",
+        datafilesDirectoryPath: "",
+        datafileNamePattern: "",
+        revisionFileName: "",
+        siteExportDirectoryPath: "",
+        environments: ["staging", "production"],
+        tags: ["all"],
+        adapter: {},
+        plugins: [],
+        defaultBucketBy: "userId",
+        parser: "yml",
+        prettyState: true,
+        prettyDatafile: false,
+        stringify: true,
+        enforceCatchAllRule: false,
+        ...overrides,
+    };
+}
+/** Attributes and segments that appear in conditions; keep small for tests. */
+const TEST_ATTRIBUTES = ["userId", "country", "device"];
+const TEST_SEGMENTS = ["*", "countries/germany", "countries/france"];
+const TEST_FEATURES = ["testFeature"];
+const TEST_SCHEMA_KEYS = ["link", "slugSchema"];
+/** Resolved schema for "slugSchema": string with pattern and length. */
+const slugSchemaResolved = {
+    type: "string",
+    minLength: 1,
+    maxLength: 30,
+    pattern: "^[a-z0-9-]+$",
+};
+/** Resolved schema for "link": object with title and url. */
+const linkSchemaResolved = {
+    type: "object",
+    required: ["title", "url"],
+    properties: {
+        title: { type: "string" },
+        url: { type: "string" },
+    },
+};
+const TEST_SCHEMAS_BY_KEY = {
+    link: linkSchemaResolved,
+    slugSchema: slugSchemaResolved,
+};
+function getFeatureSchema() {
+    const projectConfig = minimalProjectConfig();
+    const conditionsZodSchema = (0, conditionSchema_1.getConditionsZodSchema)(projectConfig, TEST_ATTRIBUTES);
+    return (0, featureSchema_1.getFeatureZodSchema)(projectConfig, conditionsZodSchema, TEST_ATTRIBUTES, TEST_SEGMENTS, TEST_FEATURES, TEST_SCHEMA_KEYS, TEST_SCHEMAS_BY_KEY);
+}
+/** Base feature shape required by getFeatureZodSchema (description, tags, bucketBy, rules). */
+function baseFeature(overrides = {}) {
+    return {
+        description: "Test feature",
+        tags: ["all"],
+        bucketBy: "userId",
+        rules: {
+            staging: [{ key: "r1", segments: "*", percentage: 100 }],
+            production: [{ key: "r1", segments: "*", percentage: 100 }],
+        },
+        ...overrides,
+    };
+}
+function parseFeature(feature) {
+    return getFeatureSchema().safeParse(feature);
+}
+function expectParseSuccess(feature) {
+    const result = parseFeature(feature);
+    expect(result.success).toBe(true);
+    if (!result.success) {
+        const err = result.error;
+        const msg = err.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+        throw new Error(`Expected success but got: ${msg}`);
+    }
+}
+function expectParseFailure(feature, messageSubstring) {
+    const result = parseFeature(feature);
+    expect(result.success).toBe(false);
+    if (result.success)
+        throw new Error("Expected parse failure");
+    const err = result.error;
+    if (messageSubstring) {
+        const messages = err.issues
+            .map((i) => (typeof i.message === "string" ? i.message : ""))
+            .join(" ");
+        expect(messages).toContain(messageSubstring);
+    }
+    return err;
+}
+/** Assert that an intentional mistake produces an error at the expected path with expected message. */
+function expectErrorSurfaces(feature, opts) {
+    const err = expectParseFailure(feature, opts.messageContains);
+    const pathStrings = err.issues.map((i) => i.path.join("."));
+    const hasMatchingPath = pathStrings.some((p) => opts.pathContains.every((seg) => p.includes(seg)));
+    expect(hasMatchingPath).toBe(true);
+}
+describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable values)", () => {
+    describe("variablesSchema: schema reference", () => {
+        it("accepts variable with schema reference and valid defaultValue", () => {
+            expectParseSuccess(baseFeature({
+                variablesSchema: {
+                    myLink: {
+                        schema: "link",
+                        defaultValue: { title: "Home", url: "/" },
+                    },
+                },
+            }));
+        });
+        it("rejects variable with unknown schema reference", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    myLink: {
+                        schema: "nonexistentSchema",
+                        defaultValue: { title: "Home", url: "/" },
+                    },
+                },
+            }), "Unknown schema");
+        });
+        it("rejects variable with schema reference when defaultValue does not match schema", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    myLink: {
+                        schema: "link",
+                        defaultValue: { title: "Home" }, // missing required "url"
+                    },
+                },
+            }));
+        });
+    });
+    describe("variablesSchema: inline schema and defaultValue", () => {
+        it("accepts inline string variable with valid defaultValue", () => {
+            expectParseSuccess(baseFeature({
+                variablesSchema: {
+                    label: { type: "string", defaultValue: "hello" },
+                },
+            }));
+        });
+        it("accepts inline integer with min/max and defaultValue in range", () => {
+            expectParseSuccess(baseFeature({
+                variablesSchema: {
+                    level: {
+                        type: "integer",
+                        minimum: 1,
+                        maximum: 10,
+                        defaultValue: 5,
+                    },
+                },
+            }));
+        });
+        it("rejects inline integer defaultValue below minimum", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    level: {
+                        type: "integer",
+                        minimum: 1,
+                        maximum: 10,
+                        defaultValue: 0,
+                    },
+                },
+            }), "minimum");
+        });
+        it("rejects inline integer defaultValue above maximum", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    level: {
+                        type: "integer",
+                        minimum: 1,
+                        maximum: 10,
+                        defaultValue: 11,
+                    },
+                },
+            }), "maximum");
+        });
+        it("rejects inline string defaultValue that violates minLength", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    slug: {
+                        type: "string",
+                        minLength: 3,
+                        defaultValue: "ab",
+                    },
+                },
+            }), "minLength");
+        });
+        it("rejects inline string defaultValue that violates maxLength", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    slug: {
+                        type: "string",
+                        maxLength: 5,
+                        defaultValue: "toolong",
+                    },
+                },
+            }), "maxLength");
+        });
+        it("rejects inline string defaultValue that does not match pattern", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    slug: {
+                        type: "string",
+                        pattern: "^[a-z0-9-]+$",
+                        defaultValue: "INVALID",
+                    },
+                },
+            }), "pattern");
+        });
+        it("rejects inline array defaultValue with length below minItems", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    tags: {
+                        type: "array",
+                        items: { type: "string" },
+                        minItems: 2,
+                        defaultValue: ["one"],
+                    },
+                },
+            }), "minItems");
+        });
+        it("rejects inline array defaultValue with length above maxItems", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    tags: {
+                        type: "array",
+                        items: { type: "string" },
+                        maxItems: 2,
+                        defaultValue: ["a", "b", "c"],
+                    },
+                },
+            }), "maxItems");
+        });
+        it("rejects inline array defaultValue with duplicate items when uniqueItems is true", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    codes: {
+                        type: "array",
+                        items: { type: "string" },
+                        uniqueItems: true,
+                        defaultValue: ["x", "x"],
+                    },
+                },
+            }), "duplicate");
+        });
+        it("rejects inline const variable when defaultValue does not equal const", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    status: {
+                        type: "string",
+                        const: "active",
+                        defaultValue: "inactive",
+                    },
+                },
+            }), "constant");
+        });
+        it("rejects inline enum variable when defaultValue is not in enum", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    theme: {
+                        type: "string",
+                        enum: ["light", "dark"],
+                        defaultValue: "blue",
+                    },
+                },
+            }));
+        });
+        it("accepts inline oneOf variable when defaultValue matches exactly one branch", () => {
+            expectParseSuccess(baseFeature({
+                variablesSchema: {
+                    idOrLink: {
+                        oneOf: [{ type: "string" }, { schema: "link" }],
+                        defaultValue: "ref-123",
+                    },
+                },
+            }));
+        });
+        it("rejects when variable has both schema reference and inline type", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    myLink: {
+                        schema: "link",
+                        type: "object",
+                        defaultValue: { title: "Home", url: "/" },
+                    },
+                },
+            }), "schema");
+        });
+        it("rejects reserved variable key 'variation'", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    variation: { type: "string", defaultValue: "control" },
+                },
+            }), "reserved");
+        });
+    });
+    describe("variablesSchema: disabledValue", () => {
+        it("accepts valid disabledValue matching variable schema", () => {
+            expectParseSuccess(baseFeature({
+                variablesSchema: {
+                    label: {
+                        type: "string",
+                        defaultValue: "on",
+                        disabledValue: "off",
+                    },
+                },
+            }));
+        });
+        it("rejects disabledValue that does not match variable schema", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    level: {
+                        type: "integer",
+                        minimum: 1,
+                        maximum: 10,
+                        defaultValue: 5,
+                        disabledValue: 99,
+                    },
+                },
+            }), "maximum");
+        });
+    });
+    describe("variations: variables", () => {
+        it("accepts variation variables that match variablesSchema", () => {
+            expectParseSuccess(baseFeature({
+                variablesSchema: {
+                    label: { type: "string", defaultValue: "default" },
+                },
+                variations: [
+                    { value: "control", weight: 50 },
+                    { value: "treatment", weight: 50, variables: { label: "treatment-label" } },
+                ],
+            }));
+        });
+        it("rejects variation variable value that does not match schema", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    level: { type: "integer", minimum: 1, maximum: 10, defaultValue: 1 },
+                },
+                variations: [
+                    { value: "control", weight: 50 },
+                    { value: "treatment", weight: 50, variables: { level: 100 } },
+                ],
+            }), "maximum");
+        });
+        it("rejects when variation uses a variable key not defined in variablesSchema", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    label: { type: "string", defaultValue: "default" },
+                },
+                variations: [
+                    { value: "control", weight: 50 },
+                    { value: "treatment", weight: 50, variables: { unknownVar: "x" } },
+                ],
+            }), "not defined in");
+        });
+    });
+    describe("variations: variableOverrides", () => {
+        it("accepts variableOverrides with values matching variable schema", () => {
+            expectParseSuccess(baseFeature({
+                variablesSchema: {
+                    slug: {
+                        type: "string",
+                        pattern: "^[a-z0-9-]+$",
+                        minLength: 1,
+                        maxLength: 20,
+                        defaultValue: "home",
+                    },
+                },
+                variations: [
+                    { value: "control", weight: 50 },
+                    {
+                        value: "treatment",
+                        weight: 50,
+                        variables: { slug: "treatment" },
+                        variableOverrides: {
+                            slug: [
+                                { segments: "countries/germany", value: "de" },
+                                { segments: "countries/france", value: "fr" },
+                            ],
+                        },
+                    },
+                ],
+            }));
+        });
+        it("rejects variableOverride value that does not match schema", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    slug: {
+                        type: "string",
+                        pattern: "^[a-z]+$",
+                        defaultValue: "home",
+                    },
+                },
+                variations: [
+                    { value: "control", weight: 50 },
+                    {
+                        value: "treatment",
+                        weight: 50,
+                        variableOverrides: {
+                            slug: [{ segments: "*", value: "UPPERCASE" }],
+                        },
+                    },
+                ],
+            }), "pattern");
+        });
+        it("rejects variableOverride for variable key not in variablesSchema", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    label: { type: "string", defaultValue: "default" },
+                },
+                variations: [
+                    { value: "control", weight: 50 },
+                    {
+                        value: "treatment",
+                        weight: 50,
+                        variableOverrides: {
+                            notDefined: [{ segments: "*", value: "x" }],
+                        },
+                    },
+                ],
+            }), "not defined in");
+        });
+        it("validates variableOverrides even when variation has no variables", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    slug: { type: "string", maxLength: 5, defaultValue: "home" },
+                },
+                variations: [
+                    { value: "control", weight: 50 },
+                    {
+                        value: "treatment",
+                        weight: 50,
+                        variableOverrides: {
+                            slug: [{ segments: "*", value: "toolongvalue" }],
+                        },
+                    },
+                ],
+            }), "maxLength");
+        });
+    });
+    describe("rules: variables", () => {
+        it("accepts rule variables that match variablesSchema", () => {
+            expectParseSuccess(baseFeature({
+                variablesSchema: {
+                    title: { type: "string", defaultValue: "Default" },
+                },
+                rules: {
+                    staging: [
+                        { key: "r1", segments: "*", percentage: 100 },
+                        {
+                            key: "r2",
+                            segments: "countries/germany",
+                            percentage: 100,
+                            variables: { title: "Germany" },
+                        },
+                    ],
+                    production: [{ key: "r1", segments: "*", percentage: 100 }],
+                },
+            }));
+        });
+        it("rejects rule variable value that does not match schema", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    count: { type: "integer", minimum: 0, maximum: 10, defaultValue: 0 },
+                },
+                rules: {
+                    staging: [
+                        { key: "r1", segments: "*", percentage: 100 },
+                        {
+                            key: "r2",
+                            segments: "countries/germany",
+                            percentage: 100,
+                            variables: { count: 100 },
+                        },
+                    ],
+                    production: [{ key: "r1", segments: "*", percentage: 100 }],
+                },
+            }), "maximum");
+        });
+        it("rejects rule variable key not defined in variablesSchema", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    title: { type: "string", defaultValue: "Default" },
+                },
+                rules: {
+                    staging: [
+                        { key: "r1", segments: "*", percentage: 100 },
+                        {
+                            key: "r2",
+                            segments: "countries/germany",
+                            percentage: 100,
+                            variables: { unknownVar: "x" },
+                        },
+                    ],
+                    production: [{ key: "r1", segments: "*", percentage: 100 }],
+                },
+            }), "not defined in");
+        });
+    });
+    describe("force: variables", () => {
+        it("accepts force variables that match variablesSchema", () => {
+            expectParseSuccess(baseFeature({
+                variablesSchema: {
+                    title: { type: "string", defaultValue: "Default" },
+                },
+                variations: [
+                    { value: "control", weight: 50 },
+                    { value: "treatment", weight: 50 },
+                ],
+                force: {
+                    staging: [
+                        {
+                            conditions: [{ attribute: "userId", operator: "equals", value: "u1" }],
+                            variation: "treatment",
+                            variables: { title: "Forced" },
+                        },
+                    ],
+                    production: [],
+                },
+            }));
+        });
+        it("rejects force variable value that does not match schema", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    level: { type: "integer", minimum: 1, maximum: 5, defaultValue: 1 },
+                },
+                variations: [
+                    { value: "control", weight: 50 },
+                    { value: "treatment", weight: 50 },
+                ],
+                force: {
+                    staging: [
+                        {
+                            conditions: [{ attribute: "userId", operator: "equals", value: "u1" }],
+                            variation: "control",
+                            variables: { level: 10 },
+                        },
+                    ],
+                    production: [],
+                },
+            }), "maximum");
+        });
+        it("rejects force variable key not defined in variablesSchema", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    title: { type: "string", defaultValue: "Default" },
+                },
+                variations: [
+                    { value: "control", weight: 50 },
+                    { value: "treatment", weight: 50 },
+                ],
+                force: {
+                    staging: [
+                        {
+                            conditions: [{ attribute: "userId", operator: "equals", value: "u1" }],
+                            variation: "control",
+                            variables: { notDefined: "x" },
+                        },
+                    ],
+                    production: [],
+                },
+            }), "not defined in");
+        });
+    });
+    describe("oneOf: value must match exactly one branch", () => {
+        it("rejects defaultValue that matches no oneOf branch", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    idOrLink: {
+                        oneOf: [{ type: "string" }, { schema: "link" }],
+                        defaultValue: 42, // number matches neither
+                    },
+                },
+            }));
+        });
+        it("rejects defaultValue that matches more than one oneOf branch when one is string", () => {
+            // If we had two branches that both accept the same value, we'd get "matched more than one"
+            expectParseSuccess(baseFeature({
+                variablesSchema: {
+                    idOrLink: {
+                        oneOf: [{ type: "string" }, { schema: "link" }],
+                        defaultValue: "id-1",
+                    },
+                },
+            }));
+        });
+    });
+    describe("schema reference: defaultValue resolved and validated", () => {
+        it("rejects defaultValue for schema-ref variable when value violates resolved schema", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    slug: {
+                        schema: "slugSchema",
+                        defaultValue: "INVALID-SLUG", // pattern is ^[a-z0-9-]+$
+                    },
+                },
+            }));
+        });
+        it("accepts defaultValue for schema-ref variable when value satisfies resolved schema", () => {
+            expectParseSuccess(baseFeature({
+                variablesSchema: {
+                    slug: {
+                        schema: "slugSchema",
+                        defaultValue: "valid-slug",
+                    },
+                },
+            }));
+        });
+    });
+    describe("complex cases (mirroring example-1 withSchema / withComplexSchema)", () => {
+        it("accepts inline object variable with properties and valid defaultValue (e.g. settings)", () => {
+            expectParseSuccess(baseFeature({
+                variablesSchema: {
+                    settings: {
+                        type: "object",
+                        properties: {
+                            theme: { type: "string" },
+                            compact: { type: "boolean" },
+                        },
+                        defaultValue: { theme: "light", compact: true },
+                    },
+                },
+            }));
+        });
+        it("rejects inline object variable when defaultValue is missing required property", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    settings: {
+                        type: "object",
+                        properties: {
+                            theme: { type: "string" },
+                            compact: { type: "boolean" },
+                        },
+                        required: ["theme"],
+                        defaultValue: { compact: true },
+                    },
+                },
+            }));
+        });
+        it("accepts inline array variable with items schema ref (e.g. linkPair)", () => {
+            expectParseSuccess(baseFeature({
+                variablesSchema: {
+                    linkPair: {
+                        type: "array",
+                        items: { schema: "link" },
+                        defaultValue: [
+                            { title: "First", url: "/first" },
+                            { title: "Second", url: "/second" },
+                        ],
+                    },
+                },
+            }));
+        });
+        it("rejects inline array with items schema ref when an item does not match schema", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    linkPair: {
+                        type: "array",
+                        items: { schema: "link" },
+                        defaultValue: [{ title: "Only title, missing url" }],
+                    },
+                },
+            }));
+        });
+        it("accepts oneOf variable when defaultValue matches object branch (e.g. refOrLink as link)", () => {
+            expectParseSuccess(baseFeature({
+                variablesSchema: {
+                    refOrLink: {
+                        oneOf: [{ type: "string" }, { schema: "link" }],
+                        defaultValue: { title: "Home", url: "/" },
+                    },
+                },
+            }));
+        });
+        it("accepts object variable with nested const in property (e.g. statusInfo.kind const active)", () => {
+            expectParseSuccess(baseFeature({
+                variablesSchema: {
+                    statusInfo: {
+                        type: "object",
+                        properties: {
+                            kind: { type: "string", const: "active" },
+                            label: { type: "string" },
+                        },
+                        required: ["kind", "label"],
+                        defaultValue: { kind: "active", label: "Default" },
+                    },
+                },
+            }));
+        });
+        it("rejects object variable when nested const property has wrong value", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    statusInfo: {
+                        type: "object",
+                        properties: {
+                            kind: { type: "string", const: "active" },
+                            label: { type: "string" },
+                        },
+                        required: ["kind", "label"],
+                        defaultValue: { kind: "inactive", label: "Default" },
+                    },
+                },
+            }));
+        });
+        it("accepts object variable with nested enum in property (e.g. themeConfig.theme)", () => {
+            expectParseSuccess(baseFeature({
+                variablesSchema: {
+                    themeConfig: {
+                        type: "object",
+                        properties: {
+                            theme: { type: "string", enum: ["light", "dark", "system"] },
+                            label: { type: "string" },
+                        },
+                        required: ["theme", "label"],
+                        defaultValue: { theme: "light", label: "Default" },
+                    },
+                },
+            }));
+        });
+        it("rejects object variable when nested enum property has invalid value", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    themeConfig: {
+                        type: "object",
+                        properties: {
+                            theme: { type: "string", enum: ["light", "dark", "system"] },
+                            label: { type: "string" },
+                        },
+                        required: ["theme", "label"],
+                        defaultValue: { theme: "invalid", label: "Default" },
+                    },
+                },
+            }));
+        });
+        it("accepts rule variables with object value (e.g. singleLink, themeColor in rules)", () => {
+            expectParseSuccess(baseFeature({
+                variablesSchema: {
+                    singleLink: {
+                        schema: "link",
+                        defaultValue: { title: "Home", url: "/" },
+                    },
+                },
+                rules: {
+                    staging: [
+                        {
+                            key: "r1",
+                            segments: "*",
+                            percentage: 100,
+                            variables: {
+                                singleLink: { title: "DE Link", url: "/de" },
+                            },
+                        },
+                    ],
+                    production: [{ key: "r1", segments: "*", percentage: 100 }],
+                },
+            }));
+        });
+        it("rejects rule variable when object value does not match schema", () => {
+            expectParseFailure(baseFeature({
+                variablesSchema: {
+                    singleLink: {
+                        schema: "link",
+                        defaultValue: { title: "Home", url: "/" },
+                    },
+                },
+                rules: {
+                    staging: [
+                        {
+                            key: "r1",
+                            segments: "*",
+                            percentage: 100,
+                            variables: {
+                                singleLink: { title: "Missing url" },
+                            },
+                        },
+                    ],
+                    production: [{ key: "r1", segments: "*", percentage: 100 }],
+                },
+            }));
+        });
+    });
+    describe("errors surface properly: intentional mistakes produce correct path and message", () => {
+        it("unknown schema ref: error path points to variable and message says Unknown schema", () => {
+            expectErrorSurfaces(baseFeature({
+                variablesSchema: {
+                    myLink: {
+                        schema: "nonexistent",
+                        defaultValue: { title: "Home", url: "/" },
+                    },
+                },
+            }), {
+                pathContains: ["variablesSchema", "myLink", "schema"],
+                messageContains: "Unknown schema",
+            });
+        });
+        it("defaultValue below minimum: error path includes defaultValue, message mentions minimum", () => {
+            expectErrorSurfaces(baseFeature({
+                variablesSchema: {
+                    level: {
+                        type: "integer",
+                        minimum: 10,
+                        maximum: 100,
+                        defaultValue: 5,
+                    },
+                },
+            }), { pathContains: ["variablesSchema", "level", "defaultValue"], messageContains: "minimum" });
+        });
+        it("defaultValue above maximum: error path includes defaultValue, message mentions maximum", () => {
+            expectErrorSurfaces(baseFeature({
+                variablesSchema: {
+                    level: {
+                        type: "integer",
+                        minimum: 0,
+                        maximum: 10,
+                        defaultValue: 99,
+                    },
+                },
+            }), { pathContains: ["variablesSchema", "level", "defaultValue"], messageContains: "maximum" });
+        });
+        it("variation uses undeclared variable: error path points to variations.*.variables, message says not defined", () => {
+            expectErrorSurfaces(baseFeature({
+                variablesSchema: {
+                    label: { type: "string", defaultValue: "x" },
+                },
+                variations: [
+                    { value: "control", weight: 50 },
+                    { value: "treatment", weight: 50, variables: { typoVar: "y" } },
+                ],
+            }), {
+                pathContains: ["variations", "variables", "typoVar"],
+                messageContains: "not defined in",
+            });
+        });
+        it("variableOverrides value violates pattern: error path points to variableOverrides.*.value", () => {
+            expectErrorSurfaces(baseFeature({
+                variablesSchema: {
+                    slug: {
+                        type: "string",
+                        pattern: "^[a-z-]+$",
+                        defaultValue: "home",
+                    },
+                },
+                variations: [
+                    { value: "control", weight: 50 },
+                    {
+                        value: "treatment",
+                        weight: 50,
+                        variableOverrides: {
+                            slug: [{ segments: "*", value: "INVALID-UPPERCASE" }],
+                        },
+                    },
+                ],
+            }), {
+                pathContains: ["variableOverrides", "slug", "value"],
+                messageContains: "pattern",
+            });
+        });
+        it("rule variable wrong type: error path points to rules.*.variables, message surfaces constraint", () => {
+            expectErrorSurfaces(baseFeature({
+                variablesSchema: {
+                    count: {
+                        type: "integer",
+                        minimum: 0,
+                        maximum: 10,
+                        defaultValue: 0,
+                    },
+                },
+                rules: {
+                    staging: [
+                        {
+                            key: "r1",
+                            segments: "*",
+                            percentage: 100,
+                            variables: { count: 100 },
+                        },
+                    ],
+                    production: [{ key: "r1", segments: "*", percentage: 100 }],
+                },
+            }), {
+                pathContains: ["rules", "variables", "count"],
+                messageContains: "maximum",
+            });
+        });
+        it("disabledValue violates schema: error path includes disabledValue", () => {
+            expectErrorSurfaces(baseFeature({
+                variablesSchema: {
+                    level: {
+                        type: "integer",
+                        minimum: 1,
+                        maximum: 5,
+                        defaultValue: 1,
+                        disabledValue: 99,
+                    },
+                },
+            }), {
+                pathContains: ["variablesSchema", "level", "disabledValue"],
+                messageContains: "maximum",
+            });
+        });
+        it("reserved key variation: error path points to variablesSchema.variation", () => {
+            expectErrorSurfaces(baseFeature({
+                variablesSchema: {
+                    variation: { type: "string", defaultValue: "control" },
+                },
+            }), {
+                pathContains: ["variablesSchema", "variation"],
+                messageContains: "reserved",
+            });
+        });
+        it("object defaultValue missing required property: error path includes defaultValue and key, message says Missing required", () => {
+            expectErrorSurfaces(baseFeature({
+                variablesSchema: {
+                    settings: {
+                        type: "object",
+                        properties: { theme: { type: "string" }, requiredKey: { type: "string" } },
+                        required: ["requiredKey"],
+                        defaultValue: { theme: "light" },
+                    },
+                },
+            }), {
+                pathContains: ["variablesSchema", "settings", "defaultValue"],
+                messageContains: "Missing required",
+            });
+        });
+        it("nested const property wrong: error path points into object value", () => {
+            expectErrorSurfaces(baseFeature({
+                variablesSchema: {
+                    statusInfo: {
+                        type: "object",
+                        properties: {
+                            kind: { type: "string", const: "active" },
+                            label: { type: "string" },
+                        },
+                        required: ["kind", "label"],
+                        defaultValue: { kind: "inactive", label: "x" },
+                    },
+                },
+            }), {
+                pathContains: ["variablesSchema", "statusInfo", "defaultValue"],
+                messageContains: "constant",
+            });
+        });
+        it("force variable not in variablesSchema: error path points to force.*.variables", () => {
+            expectErrorSurfaces(baseFeature({
+                variablesSchema: {
+                    title: { type: "string", defaultValue: "Default" },
+                },
+                variations: [
+                    { value: "control", weight: 50 },
+                    { value: "treatment", weight: 50 },
+                ],
+                force: {
+                    staging: [
+                        {
+                            conditions: [{ attribute: "userId", operator: "equals", value: "u1" }],
+                            variation: "control",
+                            variables: { typoKey: "x" },
+                        },
+                    ],
+                    production: [],
+                },
+            }), {
+                pathContains: ["force", "variables", "typoKey"],
+                messageContains: "not defined in",
+            });
+        });
+    });
+});
+//# sourceMappingURL=featureSchema.spec.js.map