@featurevisor/core 2.25.0 → 2.26.1

package/src/linter/segmentSchema.spec.ts

@@ -74,7 +74,7 @@ function getSegmentSchema() {
   return getSegmentZodSchema(projectConfig, conditionsZodSchema);
 }
 
-function parseSegment(input: unknown): z.SafeParseReturnType<unknown, unknown> {
+function parseSegment(input: unknown): z.ZodSafeParseResult<unknown> {
   return getSegmentSchema().safeParse(input);
 }
 
@@ -82,7 +82,7 @@ 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 err = (result as z.ZodSafeParseError<unknown>).error;
     const msg = err.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
     throw new Error(`Expected segment to pass: ${msg}`);
   }
@@ -92,7 +92,7 @@ function expectSegmentFailure(input: unknown, messageSubstring?: string): z.ZodE
   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;
+  const err = (result as z.ZodSafeParseError<unknown>).error;
   if (messageSubstring) {
     const messages = err.issues
       .map((i) => (typeof i.message === "string" ? i.message : ""))
@@ -134,7 +134,7 @@ describe("segmentSchema.ts :: getSegmentZodSchema", () => {
       });
       expect(result.success).toBe(false);
       if (!result.success) {
-        const err = (result as z.SafeParseError<unknown>).error;
+        const err = (result as z.ZodSafeParseError<unknown>).error;
         const path = err.issues.map((i) => i.path.join(".")).join(" ");
         expect(path).toContain("description");
       }
@@ -346,7 +346,7 @@ describe("segmentSchema.ts :: getSegmentZodSchema", () => {
         extraKey: true,
       });
       expect(result.success).toBe(false);
-      const err = (result as z.SafeParseError<unknown>).error;
+      const err = (result as z.ZodSafeParseError<unknown>).error;
       const messages = err.issues
         .map((i) => (typeof i.message === "string" ? i.message : ""))
         .join(" ");

package/src/linter/segmentSchema.ts

@@ -6,7 +6,9 @@ export function getSegmentZodSchema(projectConfig: ProjectConfig, conditionsZodS
   const segmentZodSchema = z
     .object({
       archived: z.boolean().optional(),
-      description: z.string(),
+      description: z.string({
+        error: (issue) => (issue.input === undefined ? "Required" : undefined),
+      }),
       conditions: conditionsZodSchema,
     })
     .strict();

package/src/linter/testSchema.spec.ts

@@ -0,0 +1,193 @@
+import { z } from "zod";
+
+import type { ProjectConfig } from "../config";
+import { getLintIssuesFromZodError } from "./printError";
+import { getTestsZodSchema } from "./testSchema";
+
+function minimalProjectConfig(overrides: Partial<ProjectConfig> = {}): ProjectConfig {
+  return {
+    featuresDirectoryPath: "",
+    segmentsDirectoryPath: "",
+    attributesDirectoryPath: "",
+    groupsDirectoryPath: "",
+    schemasDirectoryPath: "",
+    testsDirectoryPath: "",
+    stateDirectoryPath: "",
+    datafilesDirectoryPath: "",
+    datafileNamePattern: "",
+    revisionFileName: "",
+    siteExportDirectoryPath: "",
+    environmentsDirectoryPath: "",
+    environments: ["staging", "production"],
+    splitByEnvironment: false,
+    tags: ["all", "beta"],
+    adapter: {},
+    plugins: [],
+    defaultBucketBy: "userId",
+    parser: "yml",
+    prettyState: true,
+    prettyDatafile: false,
+    stringify: true,
+    ...overrides,
+  };
+}
+
+function getSchema(projectConfig = minimalProjectConfig()) {
+  return getTestsZodSchema(projectConfig, ["checkout"], ["desktop"]);
+}
+
+function parseTest(input: unknown): z.ZodSafeParseResult<unknown> {
+  return getSchema().safeParse(input);
+}
+
+function expectTestSuccess(input: unknown): void {
+  const result = parseTest(input);
+  expect(result.success).toBe(true);
+  if (!result.success) {
+    const error = (result as z.ZodSafeParseError<unknown>).error;
+    throw new Error(error.issues.map((issue) => issue.message).join("; "));
+  }
+}
+
+function expectTestFailure(input: unknown, messageSubstring: string): z.ZodError {
+  const result = parseTest(input);
+  expect(result.success).toBe(false);
+  if (result.success) {
+    throw new Error("Expected test schema to fail");
+  }
+
+  const error = (result as z.ZodSafeParseError<unknown>).error;
+  expect(error.issues.map((issue) => issue.message).join(" ")).toContain(messageSubstring);
+
+  return error;
+}
+
+describe("testSchema.ts :: getTestsZodSchema", () => {
+  it("accepts a valid feature test with matrix, context, sticky, and expected evaluations", () => {
+    expectTestSuccess({
+      feature: "checkout",
+      assertions: [
+        {
+          matrix: {
+            country: ["nl", "de"],
+            loggedIn: [true, false],
+            score: [1, 2],
+            empty: [null],
+          },
+          description: "feature assertion",
+          at: "${{ score }}",
+          environment: "staging",
+          tag: "all",
+          sticky: {
+            flag: { checkout: "cached" },
+          },
+          context: {
+            userId: "user-1",
+          },
+          defaultVariableValues: {
+            title: "Fallback",
+          },
+          expectedToBeEnabled: true,
+          expectedVariation: "control",
+          expectedVariables: {
+            title: "Checkout",
+          },
+          expectedEvaluations: {
+            flag: { reason: "rule" },
+            variation: { reason: "bucketed" },
+            variables: { title: { reason: "default" } },
+          },
+          children: [
+            {
+              context: {
+                userId: "child-1",
+              },
+              expectedToBeEnabled: false,
+              expectedVariation: null,
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  it("accepts matrix placeholders for environment values", () => {
+    expectTestSuccess({
+      feature: "checkout",
+      assertions: [
+        {
+          matrix: {
+            environment: ["staging", "production"],
+          },
+          at: 1,
+          environment: "${{ environment }}",
+        },
+      ],
+    });
+  });
+
+  it("rejects unknown environments with a precise path", () => {
+    const error = expectTestFailure(
+      {
+        feature: "checkout",
+        assertions: [
+          {
+            at: 1,
+            environment: "qa",
+          },
+        ],
+      },
+      'Unknown environment "qa"',
+    );
+
+    expect(error.issues.some((issue) => issue.path.join(".") === "assertions.0.environment")).toBe(
+      true,
+    );
+  });
+
+  it("rejects unknown feature and segment keys", () => {
+    expectTestFailure(
+      {
+        feature: "not-real",
+        assertions: [{ at: 1, environment: "staging" }],
+      },
+      'Unknown feature "not-real"',
+    );
+
+    expectTestFailure(
+      {
+        segment: "not-real",
+        assertions: [
+          {
+            context: {},
+            expectedToMatch: true,
+          },
+        ],
+      },
+      'Unknown segment "not-real"',
+    );
+  });
+
+  it("rejects invalid matrix values", () => {
+    const error = expectTestFailure(
+      {
+        feature: "checkout",
+        assertions: [
+          {
+            matrix: {
+              country: [{ code: "nl" }],
+            },
+            at: 1,
+            environment: "staging",
+          },
+        ],
+      },
+      "Invalid input",
+    );
+
+    const lintIssues = getLintIssuesFromZodError(error);
+    expect(lintIssues.some((issue) => issue.path.join(".").includes("matrix.country.0"))).toBe(
+      true,
+    );
+  });
+});

package/src/linter/testSchema.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 
 import { ProjectConfig } from "../config";
+import { refineWithMessage } from "./zodHelpers";
 
 export function getTestsZodSchema(
   projectConfig: ProjectConfig,
@@ -10,6 +11,7 @@ export function getTestsZodSchema(
   const scopeNames = projectConfig.scopes ? projectConfig.scopes.map((scope) => scope.name) : [];
 
   const matrixZodSchema = z.record(
+    z.string(),
     z.array(
       z.union([
         // allowed values in arrays
@@ -23,18 +25,17 @@ export function getTestsZodSchema(
 
   const segmentTestZodSchema = z
     .object({
-      segment: z.string().refine(
+      segment: refineWithMessage(
+        z.string(),
         (value) => availableSegmentKeys.includes(value),
-        (value) => ({
-          message: `Unknown segment "${value}"`,
-        }),
+        (value) => `Unknown segment "${value}"`,
       ),
       assertions: z.array(
         z
           .object({
             matrix: matrixZodSchema.optional(),
             description: z.string().optional(),
-            context: z.record(z.unknown()),
+            context: z.record(z.string(), z.unknown()),
             expectedToMatch: z.boolean(),
           })
           .strict(),
@@ -44,11 +45,10 @@ export function getTestsZodSchema(
 
   const featureTestZodSchema = z
     .object({
-      feature: z.string().refine(
+      feature: refineWithMessage(
+        z.string(),
         (value) => availableFeatureKeys.includes(value),
-        (value) => ({
-          message: `Unknown feature "${value}"`,
-        }),
+        (value) => `Unknown feature "${value}"`,
       ),
       assertions: z.array(
         z
@@ -62,7 +62,8 @@ export function getTestsZodSchema(
               z.string(),
             ]),
             environment: Array.isArray(projectConfig.environments)
-              ? z.string().refine(
+              ? refineWithMessage(
+                  z.string(),
                   (value) => {
                     if (value.indexOf("${{") === 0) {
                       // allow unknown strings for matrix
@@ -79,45 +80,35 @@ export function getTestsZodSchema(
 
                     return false;
                   },
-                  (value) => ({
-                    message: `Unknown environment "${value}"`,
-                  }),
+                  (value) => `Unknown environment "${value}"`,
                 )
               : z.never().optional(),
-            tag: z
-              .string()
-              .refine(
-                (value) => projectConfig.tags.includes(value),
-                (value) => ({
-                  message: `Unknown tag "${value}"`,
-                }),
-              )
-              .optional(),
-            scope: z
-              .string()
-              .refine(
-                (value) => scopeNames.includes(value),
-                (value) => ({
-                  message: `Unknown scope "${value}"`,
-                }),
-              )
-              .optional(),
+            tag: refineWithMessage(
+              z.string(),
+              (value) => projectConfig.tags.includes(value),
+              (value) => `Unknown tag "${value}"`,
+            ).optional(),
+            scope: refineWithMessage(
+              z.string(),
+              (value) => scopeNames.includes(value),
+              (value) => `Unknown scope "${value}"`,
+            ).optional(),
 
             // parent
-            sticky: z.record(z.record(z.any())).optional(),
-            context: z.record(z.unknown()).optional(),
+            sticky: z.record(z.string(), z.record(z.string(), z.any())).optional(),
+            context: z.record(z.string(), z.unknown()).optional(),
 
             defaultVariationValue: z.string().optional(),
-            defaultVariableValues: z.record(z.unknown()).optional(),
+            defaultVariableValues: z.record(z.string(), z.unknown()).optional(),
 
             expectedToBeEnabled: z.boolean().optional(),
             expectedVariation: z.string().nullable().optional(),
-            expectedVariables: z.record(z.unknown()).optional(),
+            expectedVariables: z.record(z.string(), z.unknown()).optional(),
             expectedEvaluations: z
               .object({
-                flag: z.record(z.any()).optional(),
-                variation: z.record(z.any()).optional(),
-                variables: z.record(z.record(z.any())).optional(),
+                flag: z.record(z.string(), z.any()).optional(),
+                variation: z.record(z.string(), z.any()).optional(),
+                variables: z.record(z.string(), z.record(z.string(), z.any())).optional(),
               })
               .optional(),
 
@@ -125,21 +116,21 @@ export function getTestsZodSchema(
               .array(
                 z.object({
                   // copied from parent
-                  sticky: z.record(z.record(z.any())).optional(),
-                  context: z.record(z.unknown()).optional(),
+                  sticky: z.record(z.string(), z.record(z.string(), z.any())).optional(),
+                  context: z.record(z.string(), z.unknown()).optional(),
 
                   defaultVariationValue: z.string().optional(),
-                  defaultVariableValues: z.record(z.unknown()).optional(),
+                  defaultVariableValues: z.record(z.string(), z.unknown()).optional(),
 
                   expectedToBeEnabled: z.boolean().optional(),
                   expectedVariation: z.string().nullable().optional(),
-                  expectedVariables: z.record(z.unknown()).optional(),
+                  expectedVariables: z.record(z.string(), z.unknown()).optional(),
 
                   expectedEvaluations: z
                     .object({
-                      flag: z.record(z.any()).optional(),
-                      variation: z.record(z.any()).optional(),
-                      variables: z.record(z.record(z.any())).optional(),
+                      flag: z.record(z.string(), z.any()).optional(),
+                      variation: z.record(z.string(), z.any()).optional(),
+                      variables: z.record(z.string(), z.record(z.string(), z.any())).optional(),
                     })
                     .optional(),
                 }),

package/src/linter/zodHelpers.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+
+export function refineWithMessage<T>(
+  schema: z.ZodType<T>,
+  predicate: (value: T) => boolean,
+  getMessage: (value: T) => string,
+) {
+  return schema.superRefine((value, ctx) => {
+    if (!predicate(value)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: getMessage(value),
+      });
+    }
+  });
+}