@featurevisor/core 2.20.0 → 2.22.1

package/src/linter/featureSchema.spec.ts

@@ -4,7 +4,7 @@
  * rules, force). Ensures every place a variable value can be set is validated against
  * the variable's schema.
  */
-import type { Schema } from "@featurevisor/types";
+import type { Attribute, Schema } from "@featurevisor/types";
 import { z } from "zod";
 
 import type { ProjectConfig } from "../config";
@@ -42,7 +42,44 @@ function minimalProjectConfig(overrides: Partial<ProjectConfig> = {}): ProjectCo
 }
 
 /** Attributes and segments that appear in conditions; keep small for tests. */
-const TEST_ATTRIBUTES: [string, ...string[]] = ["userId", "country", "device"];
+const TEST_ATTRIBUTES: Record<string, Attribute> = {
+  userId: {
+    description: "User ID",
+    type: "string",
+  },
+  country: {
+    description: "Country",
+    type: "string",
+  },
+  device: {
+    description: "Device",
+    type: "string",
+  },
+  permissions: {
+    description: "Permissions",
+    type: "array",
+    items: {
+      type: "string",
+      enum: ["read", "write", "admin"],
+    },
+  },
+  version: {
+    description: "Version",
+    oneOf: [{ type: "string" }, { type: "double" }],
+  },
+  traits: {
+    description: "Traits",
+    type: "object",
+  },
+};
+const TEST_ATTRIBUTE_KEYS: [string, ...string[]] = [
+  "userId",
+  "country",
+  "device",
+  "permissions",
+  "version",
+  "traits",
+];
 const TEST_SEGMENTS: [string, ...string[]] = ["*", "countries/germany", "countries/france"];
 const TEST_FEATURES: [string, ...string[]] = ["testFeature"];
 const TEST_SCHEMA_KEYS = ["link", "slugSchema"];
@@ -76,7 +113,7 @@ function getFeatureSchema() {
   return getFeatureZodSchema(
     projectConfig,
     conditionsZodSchema,
-    TEST_ATTRIBUTES,
+    TEST_ATTRIBUTE_KEYS,
     TEST_SEGMENTS,
     TEST_FEATURES,
     TEST_SCHEMA_KEYS,
@@ -140,6 +177,94 @@ function expectErrorSurfaces(
 }
 
 describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable values)", () => {
+  describe("attribute-aware rule and force conditions", () => {
+    it("accepts force conditions using semver operators on oneOf attributes", () => {
+      expectParseSuccess(
+        baseFeature({
+          variations: [
+            { value: "control", weight: 50 },
+            { value: "treatment", weight: 50 },
+          ],
+          force: {
+            staging: [
+              {
+                conditions: [
+                  { attribute: "version", operator: "semverGreaterThan", value: "5.0.0" },
+                ],
+                variation: "treatment",
+              },
+            ],
+            production: [],
+          },
+        }),
+      );
+    });
+
+    it("accepts force conditions using flat object nested paths", () => {
+      expectParseSuccess(
+        baseFeature({
+          variations: [
+            { value: "control", weight: 50 },
+            { value: "treatment", weight: 50 },
+          ],
+          force: {
+            staging: [
+              {
+                conditions: [
+                  { attribute: "traits.favoriteTheme", operator: "equals", value: "dark" },
+                ],
+                variation: "treatment",
+              },
+            ],
+            production: [],
+          },
+        }),
+      );
+    });
+
+    it("rejects force conditions when oneOf attribute value matches no branch", () => {
+      expectParseFailure(
+        baseFeature({
+          variations: [
+            { value: "control", weight: 50 },
+            { value: "treatment", weight: 50 },
+          ],
+          force: {
+            staging: [
+              {
+                conditions: [{ attribute: "version", operator: "equals", value: true }],
+                variation: "treatment",
+              },
+            ],
+            production: [],
+          },
+        }),
+        'Value does not match the schema of attribute "version"',
+      );
+    });
+
+    it("rejects force conditions when array item value violates enum constraints", () => {
+      expectParseFailure(
+        baseFeature({
+          variations: [
+            { value: "control", weight: 50 },
+            { value: "treatment", weight: 50 },
+          ],
+          force: {
+            staging: [
+              {
+                conditions: [{ attribute: "permissions", operator: "includes", value: "delete" }],
+                variation: "treatment",
+              },
+            ],
+            production: [],
+          },
+        }),
+        'Value does not match the item schema of attribute "permissions"',
+      );
+    });
+  });
+
   describe("variablesSchema: schema reference", () => {
     it("accepts variable with schema reference and valid defaultValue", () => {
       expectParseSuccess(
@@ -174,7 +299,7 @@ describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable
       const schemaWithEmptySchemasByKey = getFeatureZodSchema(
         projectConfig,
         conditionsZodSchema,
-        TEST_ATTRIBUTES,
+        TEST_ATTRIBUTE_KEYS,
         TEST_SEGMENTS,
         TEST_FEATURES,
         ["link"],

package/src/linter/lintProject.ts

@@ -1,7 +1,7 @@
 // for use in node only
 import * as path from "path";
 
-import type { Schema } from "@featurevisor/types";
+import type { Attribute, Schema } from "@featurevisor/types";
 import type { ZodError } from "zod";
 
 import { getAttributeZodSchema } from "./attributeSchema";
@@ -59,6 +59,28 @@ async function getAuthorsOfEntity(datasource, entityType, entityKey): Promise<st
   return authors;
 }
 
+function collectExplicitAttributePaths(
+  attributeKey: string,
+  attribute: Attribute,
+  result: Set<string>,
+): void {
+  result.add(attributeKey);
+
+  function visit(prefix: string, schema: Attribute | Attribute["properties"][string]) {
+    if (!schema || schema.type !== "object" || !schema.properties) {
+      return;
+    }
+
+    for (const propertyKey of Object.keys(schema.properties)) {
+      const propertyPath = `${prefix}.${propertyKey}`;
+      result.add(propertyPath);
+      visit(propertyPath, schema.properties[propertyKey]);
+    }
+  }
+
+  visit(attributeKey, attribute);
+}
+
 export async function lintProject(
   deps: Dependencies,
   options: LintProjectOptions = {},
@@ -326,9 +348,29 @@ export async function lintProject(
     log("");
   }
 
+  // List schemas and load parsed schemas for attribute and feature validation.
+  const schemas = await datasource.listSchemas();
+  const schemasByKey: Record<string, Schema> = {};
+  for (const key of schemas) {
+    try {
+      schemasByKey[key] = await datasource.readSchema(key);
+    } catch {
+      // Schema file may be invalid; skip for cross-entity resolution and let schema linting report it.
+    }
+  }
+
   // lint attributes
   const attributes = await datasource.listAttributes();
   const attributeZodSchema = getAttributeZodSchema();
+  const attributesByKey: Record<string, Attribute> = {};
+
+  for (const key of attributes) {
+    try {
+      attributesByKey[key] = await datasource.readAttribute(key);
+    } catch {
+      // Attribute read failures are reported during attribute linting below.
+    }
+  }
 
   if (!options.entityType || options.entityType === "attribute") {
     const filteredKeys = !keyPattern
@@ -354,7 +396,7 @@ export async function lintProject(
       }
 
       try {
-        const parsed = await datasource.readAttribute(key);
+        const parsed = attributesByKey[key] ?? (await datasource.readAttribute(key));
         const result = attributeZodSchema.safeParse(parsed);
 
         if (!result.success && "error" in result) {
@@ -366,14 +408,20 @@ export async function lintProject(
     }
   }
 
-  const flattenedAttributes = await datasource.listFlattenedAttributes();
+  const explicitAttributePaths = new Set<string>();
+  for (const key of attributes) {
+    const parsed = attributesByKey[key];
+    if (!parsed) {
+      continue;
+    }
+
+    collectExplicitAttributePaths(key, parsed, explicitAttributePaths);
+  }
+  const flattenedAttributes = Array.from(explicitAttributePaths);
 
   // lint segments
   const segments = await datasource.listSegments();
-  const conditionsZodSchema = getConditionsZodSchema(
-    projectConfig,
-    flattenedAttributes as [string, ...string[]],
-  );
+  const conditionsZodSchema = getConditionsZodSchema(projectConfig, attributesByKey, schemasByKey);
   const segmentZodSchema = getSegmentZodSchema(projectConfig, conditionsZodSchema);
 
   if (!options.entityType || options.entityType === "segment") {
@@ -410,17 +458,6 @@ export async function lintProject(
     }
   }
 
-  // List schemas and load parsed schemas for feature variable validation (schema references)
-  const schemas = await datasource.listSchemas();
-  const schemasByKey: Record<string, Schema> = {};
-  for (const key of schemas) {
-    try {
-      schemasByKey[key] = await datasource.readSchema(key);
-    } catch {
-      // Schema file may be invalid; skip for feature variable resolution
-    }
-  }
-
   // lint features
   const features = await datasource.listFeatures();
   const featureZodSchema = getFeatureZodSchema(

package/src/linter/segmentSchema.spec.ts

@@ -5,6 +5,7 @@
  */
 import { z } from "zod";
 
+import type { Attribute } from "@featurevisor/types";
 import type { ProjectConfig } from "../config";
 import { getConditionsZodSchema } from "./conditionSchema";
 import { getSegmentZodSchema } from "./segmentSchema";
@@ -36,7 +37,36 @@ function minimalProjectConfig(): ProjectConfig {
   };
 }
 
-const TEST_ATTRIBUTES: [string, ...string[]] = ["userId", "country", "device"];
+const TEST_ATTRIBUTES: Record<string, Attribute> = {
+  userId: {
+    description: "User ID",
+    type: "string",
+  },
+  country: {
+    description: "Country",
+    type: "string",
+  },
+  device: {
+    description: "Device",
+    type: "string",
+  },
+  permissions: {
+    description: "Permissions",
+    type: "array",
+    items: {
+      type: "string",
+      enum: ["read", "write", "admin"],
+    },
+  },
+  version: {
+    description: "Version",
+    oneOf: [{ type: "string" }, { type: "double" }],
+  },
+  traits: {
+    description: "Traits",
+    type: "object",
+  },
+};
 
 function getSegmentSchema() {
   const projectConfig = minimalProjectConfig();
@@ -187,6 +217,57 @@ describe("segmentSchema.ts :: getSegmentZodSchema", () => {
         "Unknown attribute",
       );
     });
+
+    it("accepts segment conditions using semver operators on oneOf attributes", () => {
+      expectSegmentSuccess({
+        description: "Version above v5",
+        conditions: {
+          and: [
+            { attribute: "device", operator: "equals", value: "desktop" },
+            { attribute: "version", operator: "semverGreaterThan", value: "5.0.0" },
+          ],
+        },
+      });
+    });
+
+    it("accepts segment conditions using flat object nested paths", () => {
+      expectSegmentSuccess({
+        description: "Dark mode users",
+        conditions: {
+          attribute: "traits.favoriteTheme",
+          operator: "equals",
+          value: "dark",
+        },
+      });
+    });
+
+    it("rejects segment conditions when oneOf attribute value matches no branch", () => {
+      expectSegmentFailure(
+        {
+          description: "Bad version",
+          conditions: {
+            attribute: "version",
+            operator: "equals",
+            value: true,
+          },
+        },
+        'Value does not match the schema of attribute "version"',
+      );
+    });
+
+    it("rejects segment conditions when array item value violates enum constraints", () => {
+      expectSegmentFailure(
+        {
+          description: "Bad permission",
+          conditions: {
+            attribute: "permissions",
+            operator: "includes",
+            value: "delete",
+          },
+        },
+        'Value does not match the item schema of attribute "permissions"',
+      );
+    });
   });
 
   describe("optional archived", () => {