@featurevisor/core 2.10.0 → 2.12.0

package/src/linter/segmentSchema.spec.ts

@@ -0,0 +1,273 @@
+/**
+ * Unit tests for segment schema validation (segments/*.yml).
+ * Covers getSegmentZodSchema: description, conditions (plain, and/or/not, array, *),
+ * optional archived, and strict (no extra keys).
+ */
+import { z } from "zod";
+
+import type { ProjectConfig } from "../config";
+import { getConditionsZodSchema } from "./conditionSchema";
+import { getSegmentZodSchema } from "./segmentSchema";
+
+function minimalProjectConfig(): ProjectConfig {
+  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,
+  };
+}
+
+const TEST_ATTRIBUTES: [string, ...string[]] = ["userId", "country", "device"];
+
+function getSegmentSchema() {
+  const projectConfig = minimalProjectConfig();
+  const conditionsZodSchema = getConditionsZodSchema(projectConfig, TEST_ATTRIBUTES);
+  return getSegmentZodSchema(projectConfig, conditionsZodSchema);
+}
+
+function parseSegment(input: unknown): z.SafeParseReturnType<unknown, unknown> {
+  return getSegmentSchema().safeParse(input);
+}
+
+function expectSegmentSuccess(input: unknown): void {
+  const result = parseSegment(input);
+  expect(result.success).toBe(true);
+  if (!result.success) {
+    const err = (result as z.SafeParseError<unknown>).error;
+    const msg = err.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+    throw new Error(`Expected segment to pass: ${msg}`);
+  }
+}
+
+function expectSegmentFailure(input: unknown, messageSubstring?: string): z.ZodError {
+  const result = parseSegment(input);
+  expect(result.success).toBe(false);
+  if (result.success) throw new Error("Expected segment to fail");
+  const err = (result as z.SafeParseError<unknown>).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 expectSegmentErrorSurfaces(
+  input: unknown,
+  opts: { pathContains: string[]; messageContains: string },
+): void {
+  const err = expectSegmentFailure(input, 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("segmentSchema.ts :: getSegmentZodSchema", () => {
+  describe("required fields", () => {
+    it("accepts segment with description and conditions (plain condition)", () => {
+      expectSegmentSuccess({
+        description: "Users in Germany",
+        conditions: {
+          attribute: "country",
+          operator: "equals",
+          value: "de",
+        },
+      });
+    });
+
+    it("rejects segment without description", () => {
+      const result = parseSegment({
+        conditions: { attribute: "country", operator: "equals", value: "de" },
+      });
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        const err = (result as z.SafeParseError<unknown>).error;
+        const path = err.issues.map((i) => i.path.join(".")).join(" ");
+        expect(path).toContain("description");
+      }
+    });
+
+    it("rejects segment without conditions", () => {
+      const result = parseSegment({
+        description: "A segment",
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe("conditions: everyone (*)", () => {
+    it("accepts segment with conditions *", () => {
+      expectSegmentSuccess({
+        description: "Everyone",
+        conditions: "*",
+      });
+    });
+  });
+
+  describe("conditions: array of conditions", () => {
+    it("accepts segment with conditions as array", () => {
+      expectSegmentSuccess({
+        description: "Germany or France",
+        conditions: [
+          { attribute: "country", operator: "equals", value: "de" },
+          { attribute: "country", operator: "equals", value: "fr" },
+        ],
+      });
+    });
+  });
+
+  describe("conditions: and / or / not", () => {
+    it("accepts segment with and conditions", () => {
+      expectSegmentSuccess({
+        description: "Germany and mobile",
+        conditions: {
+          and: [
+            { attribute: "country", operator: "equals", value: "de" },
+            { attribute: "device", operator: "equals", value: "mobile" },
+          ],
+        },
+      });
+    });
+
+    it("accepts segment with or conditions", () => {
+      expectSegmentSuccess({
+        description: "Germany or France",
+        conditions: {
+          or: [
+            { attribute: "country", operator: "equals", value: "de" },
+            { attribute: "country", operator: "equals", value: "fr" },
+          ],
+        },
+      });
+    });
+
+    it("accepts segment with not conditions", () => {
+      expectSegmentSuccess({
+        description: "Not US",
+        conditions: {
+          not: [{ attribute: "country", operator: "equals", value: "us" }],
+        },
+      });
+    });
+
+    it("rejects segment when nested condition has unknown attribute", () => {
+      expectSegmentFailure(
+        {
+          description: "Bad attr",
+          conditions: {
+            and: [
+              { attribute: "userId", operator: "equals", value: "u1" },
+              { attribute: "unknownAttr", operator: "equals", value: "x" },
+            ],
+          },
+        },
+        "Unknown attribute",
+      );
+    });
+  });
+
+  describe("optional archived", () => {
+    it("accepts segment with archived true", () => {
+      expectSegmentSuccess({
+        description: "Old segment",
+        conditions: "*",
+        archived: true,
+      });
+    });
+
+    it("accepts segment with archived false", () => {
+      expectSegmentSuccess({
+        description: "Active segment",
+        conditions: "*",
+        archived: false,
+      });
+    });
+
+    it("accepts segment without archived", () => {
+      expectSegmentSuccess({
+        description: "Segment",
+        conditions: "*",
+      });
+    });
+  });
+
+  describe("strict: no extra keys", () => {
+    it("rejects segment with extra key at root", () => {
+      const result = parseSegment({
+        description: "Segment",
+        conditions: "*",
+        extraKey: true,
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe("description type", () => {
+    it("rejects description that is not a string", () => {
+      const result = parseSegment({
+        description: 123,
+        conditions: "*",
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe("errors surface properly: intentional mistakes produce correct path and message", () => {
+    it("missing description: error path includes description", () => {
+      expectSegmentErrorSurfaces(
+        { conditions: { attribute: "country", operator: "equals", value: "de" } },
+        { pathContains: ["description"], messageContains: "Required" },
+      );
+    });
+
+    it("conditions with unknown attribute: error path goes into conditions", () => {
+      expectSegmentErrorSurfaces(
+        {
+          description: "Segment",
+          conditions: {
+            and: [
+              { attribute: "country", operator: "equals", value: "de" },
+              { attribute: "typoAttr", operator: "equals", value: "x" },
+            ],
+          },
+        },
+        { pathContains: ["conditions", "attribute"], messageContains: "Unknown attribute" },
+      );
+    });
+
+    it("extra key at root: parse fails and message mentions unrecognized key", () => {
+      const result = parseSegment({
+        description: "Segment",
+        conditions: "*",
+        extraKey: true,
+      });
+      expect(result.success).toBe(false);
+      const err = (result as z.SafeParseError<unknown>).error;
+      const messages = err.issues
+        .map((i) => (typeof i.message === "string" ? i.message : ""))
+        .join(" ");
+      expect(messages).toMatch(/unrecognized|extraKey/i);
+    });
+  });
+});

package/src/tester/testFeature.ts

@@ -104,8 +104,8 @@ export async function testFeature(
       logLevel,
     });
 
-    const feature = await datasource.readFeature(featureKey);
-    if (!feature) {
+    const parsedFeature = await datasource.readFeature(featureKey);
+    if (!parsedFeature) {
       testResult.notFound = true;
       testResult.passed = false;
 
@@ -208,7 +208,9 @@ export async function testFeature(
 
         let passed;
 
-        const variableSchema = feature.variablesSchema?.[variableKey];
+        // Use feature from datafile so variable schema is always resolved (ResolvedVariableSchema)
+        const featureFromDatafile = datafileContent?.features?.[featureKey];
+        const variableSchema = featureFromDatafile?.variablesSchema?.[variableKey];
 
         if (!variableSchema) {
           testResult.passed = false;

package/src/utils/git.ts

@@ -91,6 +91,8 @@ export function getCommit(
       type = "feature";
     } else if (relativeDir === projectConfig.groupsDirectoryPath) {
       type = "group";
+    } else if (relativeDir === projectConfig.schemasDirectoryPath) {
+      type = "schema";
     } else if (relativeDir === projectConfig.testsDirectoryPath) {
       type = "test";
     } else {

package/lib/linter/propertySchema.d.ts

@@ -1,5 +0,0 @@
-import type { PropertySchema, Value } from "@featurevisor/types";
-import { z } from "zod";
-export declare const valueZodSchema: z.ZodType<Value>;
-export declare const propertyTypeEnum: z.ZodEnum<["boolean", "string", "integer", "double", "object", "array"]>;
-export declare function getPropertyZodSchema(): z.ZodType<PropertySchema, z.ZodTypeDef, PropertySchema>;

package/lib/linter/propertySchema.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.propertyTypeEnum = exports.valueZodSchema = void 0;
-exports.getPropertyZodSchema = getPropertyZodSchema;
-const zod_1 = require("zod");
-// Recursive schema for Value: boolean | string | number | ObjectValue | Value[]
-exports.valueZodSchema = zod_1.z.lazy(() => zod_1.z.union([
-    zod_1.z.boolean(),
-    zod_1.z.string(),
-    zod_1.z.number(),
-    // | Date // @TODO: support in future
-    zod_1.z.record(zod_1.z.string(), exports.valueZodSchema),
-    zod_1.z.array(exports.valueZodSchema),
-]));
-// @TODO: support "date" in future
-// @TODO: consider "semver" in future
-// @TODO: consider "url" in future
-exports.propertyTypeEnum = zod_1.z.enum([
-    "boolean",
-    "string",
-    "integer",
-    "double",
-    "object",
-    "array",
-]);
-function getPropertyZodSchema() {
-    const propertyZodSchema = zod_1.z.lazy(() => zod_1.z
-        .object({
-        description: zod_1.z.string().optional(),
-        type: exports.propertyTypeEnum.optional(),
-        // enum?: Value[]; const?: Value;
-        // Numeric: maximum?, minimum?
-        // String: maxLength?, minLength?, pattern?
-        items: propertyZodSchema.optional(),
-        // maxItems?, minItems?, uniqueItems?
-        required: zod_1.z.array(zod_1.z.string()).optional(),
-        properties: zod_1.z.record(zod_1.z.string(), propertyZodSchema).optional(),
-        // Annotations: default?: Value; examples?: Value[];
-    })
-        .strict());
-    return propertyZodSchema;
-}
-//# sourceMappingURL=propertySchema.js.map

package/lib/linter/propertySchema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"propertySchema.js","sourceRoot":"","sources":["../../src/linter/propertySchema.ts"],"names":[],"mappings":";;;AA2BA,oDAmBC;AA7CD,6BAAwB;AAExB,gFAAgF;AACnE,QAAA,cAAc,GAAqB,OAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAC1D,OAAC,CAAC,KAAK,CAAC;IACN,OAAC,CAAC,OAAO,EAAE;IACX,OAAC,CAAC,MAAM,EAAE;IACV,OAAC,CAAC,MAAM,EAAE;IACV,qCAAqC;IACrC,OAAC,CAAC,MAAM,CAAC,OAAC,CAAC,MAAM,EAAE,EAAE,sBAAc,CAAC;IACpC,OAAC,CAAC,KAAK,CAAC,sBAAc,CAAC;CACxB,CAAC,CACH,CAAC;AAEF,kCAAkC;AAClC,qCAAqC;AACrC,kCAAkC;AACrB,QAAA,gBAAgB,GAAG,OAAC,CAAC,IAAI,CAAC;IACrC,SAAS;IACT,QAAQ;IACR,SAAS;IACT,QAAQ;IACR,QAAQ;IACR,OAAO;CACR,CAAC,CAAC;AAEH,SAAgB,oBAAoB;IAClC,MAAM,iBAAiB,GAA8B,OAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAC/D,OAAC;SACE,MAAM,CAAC;QACN,WAAW,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAClC,IAAI,EAAE,wBAAgB,CAAC,QAAQ,EAAE;QACjC,iCAAiC;QACjC,8BAA8B;QAC9B,2CAA2C;QAC3C,KAAK,EAAE,iBAAiB,CAAC,QAAQ,EAAE;QACnC,qCAAqC;QACrC,QAAQ,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;QACxC,UAAU,EAAE,OAAC,CAAC,MAAM,CAAC,OAAC,CAAC,MAAM,EAAE,EAAE,iBAAiB,CAAC,CAAC,QAAQ,EAAE;QAC9D,oDAAoD;KACrD,CAAC;SACD,MAAM,EAAE,CACZ,CAAC;IAEF,OAAO,iBAAiB,CAAC;AAC3B,CAAC"}

package/src/linter/propertySchema.ts

@@ -1,47 +0,0 @@
-import type { PropertySchema, Value } from "@featurevisor/types";
-import { z } from "zod";
-
-// Recursive schema for Value: boolean | string | number | ObjectValue | Value[]
-export const valueZodSchema: z.ZodType<Value> = z.lazy(() =>
-  z.union([
-    z.boolean(),
-    z.string(),
-    z.number(),
-    // | Date // @TODO: support in future
-    z.record(z.string(), valueZodSchema),
-    z.array(valueZodSchema),
-  ]),
-);
-
-// @TODO: support "date" in future
-// @TODO: consider "semver" in future
-// @TODO: consider "url" in future
-export const propertyTypeEnum = z.enum([
-  "boolean",
-  "string",
-  "integer",
-  "double",
-  "object",
-  "array",
-]);
-
-export function getPropertyZodSchema() {
-  const propertyZodSchema: z.ZodType<PropertySchema> = z.lazy(() =>
-    z
-      .object({
-        description: z.string().optional(),
-        type: propertyTypeEnum.optional(),
-        // enum?: Value[]; const?: Value;
-        // Numeric: maximum?, minimum?
-        // String: maxLength?, minLength?, pattern?
-        items: propertyZodSchema.optional(),
-        // maxItems?, minItems?, uniqueItems?
-        required: z.array(z.string()).optional(),
-        properties: z.record(z.string(), propertyZodSchema).optional(),
-        // Annotations: default?: Value; examples?: Value[];
-      })
-      .strict(),
-  );
-
-  return propertyZodSchema;
-}