@featurevisor/core 2.26.1 → 3.0.1

package/src/linter/conditionSchema.spec.ts

@@ -16,15 +16,17 @@ function minimalProjectConfig(): ProjectConfig {
     attributesDirectoryPath: "",
     groupsDirectoryPath: "",
     schemasDirectoryPath: "",
+    targetsDirectoryPath: "",
     testsDirectoryPath: "",
     stateDirectoryPath: "",
     datafilesDirectoryPath: "",
     datafileNamePattern: "",
     revisionFileName: "",
-    siteExportDirectoryPath: "",
-    environmentsDirectoryPath: "",
+    catalogDirectoryPath: "",
+    setsDirectoryPath: "",
     environments: ["staging", "production"],
-    splitByEnvironment: false,
+    sets: false,
+    namespaceCharacter: ".",
     tags: ["all"],
     adapter: {},
     plugins: [],
@@ -389,6 +391,18 @@ describe("conditionSchema.ts :: getConditionsZodSchema", () => {
       );
     });
 
+    it("rejects duplicate regexFlags", () => {
+      expectConditionsFailure(
+        {
+          attribute: "browser.version",
+          operator: "matches",
+          value: "x",
+          regexFlags: "ii",
+        },
+        "unique",
+      );
+    });
+
     it("rejects regexFlags when operator is not matches/notMatches", () => {
       expectConditionsFailure(
         {
@@ -433,6 +447,12 @@ describe("conditionSchema.ts :: getConditionsZodSchema", () => {
       });
     });
 
+    it("rejects empty and/or/not condition arrays", () => {
+      expectConditionsFailure({ and: [] });
+      expectConditionsFailure({ or: [] });
+      expectConditionsFailure({ not: [] });
+    });
+
     it("rejects invalid nested conditions", () => {
       expectConditionsFailure(
         {

package/src/linter/conditionSchema.ts

@@ -578,10 +578,10 @@ export function getConditionsZodSchema(
               return true;
             }
 
-            return /^[gimsuy]{1,}$/.test(value);
+            return /^[gimsuy]+$/.test(value) && new Set(value).size === value.length;
           },
           {
-            message: `regexFlags must of one or more of these characters: g, i, m, s, u, y`,
+            message: `regexFlags must contain unique characters from: g, i, m, s, u, y`,
           },
         )
         .optional(),
@@ -687,17 +687,17 @@ export function getConditionsZodSchema(
   const andOrNotConditionZodSchema = z.union([
     z
       .object({
-        and: z.array(z.lazy(() => conditionZodSchema)),
+        and: z.array(z.lazy(() => conditionZodSchema)).min(1),
       })
       .strict(),
     z
       .object({
-        or: z.array(z.lazy(() => conditionZodSchema)),
+        or: z.array(z.lazy(() => conditionZodSchema)).min(1),
       })
       .strict(),
     z
       .object({
-        not: z.array(z.lazy(() => conditionZodSchema)),
+        not: z.array(z.lazy(() => conditionZodSchema)).min(1),
       })
       .strict(),
   ]);

package/src/linter/featureSchema.spec.ts

@@ -19,15 +19,17 @@ function minimalProjectConfig(overrides: Partial<ProjectConfig> = {}): ProjectCo
     attributesDirectoryPath: "",
     groupsDirectoryPath: "",
     schemasDirectoryPath: "",
+    targetsDirectoryPath: "",
     testsDirectoryPath: "",
     stateDirectoryPath: "",
     datafilesDirectoryPath: "",
     datafileNamePattern: "",
     revisionFileName: "",
-    siteExportDirectoryPath: "",
-    environmentsDirectoryPath: "",
+    catalogDirectoryPath: "",
+    setsDirectoryPath: "",
     environments: ["staging", "production"],
-    splitByEnvironment: false,
+    sets: false,
+    namespaceCharacter: ".",
     tags: ["all"],
     adapter: {},
     plugins: [],
@@ -80,7 +82,7 @@ const TEST_ATTRIBUTE_KEYS: [string, ...string[]] = [
   "version",
   "traits",
 ];
-const TEST_SEGMENTS: [string, ...string[]] = ["*", "countries/germany", "countries/france"];
+const TEST_SEGMENTS: [string, ...string[]] = ["*", "countries.germany", "countries.france"];
 const TEST_FEATURES: [string, ...string[]] = ["testFeature"];
 const TEST_SCHEMA_KEYS = ["link", "slugSchema"];
 
@@ -107,8 +109,8 @@ const TEST_SCHEMAS_BY_KEY: Record<string, Schema> = {
   slugSchema: slugSchemaResolved,
 };
 
-function getFeatureSchema() {
-  const projectConfig = minimalProjectConfig();
+function getFeatureSchema(projectConfigOverrides: Partial<ProjectConfig> = {}) {
+  const projectConfig = minimalProjectConfig(projectConfigOverrides);
   const conditionsZodSchema = getConditionsZodSchema(projectConfig, TEST_ATTRIBUTES);
   return getFeatureZodSchema(
     projectConfig,
@@ -135,12 +137,18 @@ function baseFeature(overrides: Record<string, unknown> = {}) {
   };
 }
 
-function parseFeature(feature: unknown): z.ZodSafeParseResult<unknown> {
-  return getFeatureSchema().safeParse(feature);
+function parseFeature(
+  feature: unknown,
+  projectConfigOverrides: Partial<ProjectConfig> = {},
+): z.ZodSafeParseResult<unknown> {
+  return getFeatureSchema(projectConfigOverrides).safeParse(feature);
 }
 
-function expectParseSuccess(feature: unknown): void {
-  const result = parseFeature(feature);
+function expectParseSuccess(
+  feature: unknown,
+  projectConfigOverrides: Partial<ProjectConfig> = {},
+): void {
+  const result = parseFeature(feature, projectConfigOverrides);
   expect(result.success).toBe(true);
   if (!result.success) {
     const err = (result as z.ZodSafeParseError<unknown>).error;
@@ -149,8 +157,12 @@ function expectParseSuccess(feature: unknown): void {
   }
 }
 
-function expectParseFailure(feature: unknown, messageSubstring?: string): z.ZodError {
-  const result = parseFeature(feature);
+function expectParseFailure(
+  feature: unknown,
+  messageSubstring?: string,
+  projectConfigOverrides: Partial<ProjectConfig> = {},
+): z.ZodError {
+  const result = parseFeature(feature, projectConfigOverrides);
   expect(result.success).toBe(false);
   if (result.success) throw new Error("Expected parse failure");
   const err = (result as z.ZodSafeParseError<unknown>).error;
@@ -177,6 +189,58 @@ function expectErrorSurfaces(
 }
 
 describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable values)", () => {
+  describe("tags", () => {
+    it("accepts missing tags", () => {
+      const feature = baseFeature();
+      delete feature.tags;
+
+      expectParseSuccess(feature);
+    });
+
+    it("accepts tags defined in project config", () => {
+      expectParseSuccess(baseFeature({ tags: ["all", "beta"] }), { tags: ["all", "beta"] });
+    });
+
+    it("rejects tags missing from project config", () => {
+      expectParseFailure(baseFeature({ tags: ["unknown"] }), 'Unknown tag "unknown"');
+    });
+
+    it("rejects duplicate tags", () => {
+      expectParseFailure(baseFeature({ tags: ["all", "all"] }), "Duplicate tags found: all, all");
+    });
+  });
+
+  describe("rule segments", () => {
+    it("rejects empty and/or/not group segment arrays", () => {
+      expectParseFailure(
+        baseFeature({
+          rules: {
+            staging: [{ key: "r1", segments: { and: [] }, percentage: 100 }],
+            production: [{ key: "r1", segments: "*", percentage: 100 }],
+          },
+        }),
+      );
+
+      expectParseFailure(
+        baseFeature({
+          rules: {
+            staging: [{ key: "r1", segments: { or: [] }, percentage: 100 }],
+            production: [{ key: "r1", segments: "*", percentage: 100 }],
+          },
+        }),
+      );
+
+      expectParseFailure(
+        baseFeature({
+          rules: {
+            staging: [{ key: "r1", segments: { not: [] }, percentage: 100 }],
+            production: [{ key: "r1", segments: "*", percentage: 100 }],
+          },
+        }),
+      );
+    });
+  });
+
   describe("attribute-aware rule and force conditions", () => {
     it("accepts force conditions using semver operators on oneOf attributes", () => {
       expectParseSuccess(
@@ -659,8 +723,8 @@ describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable
               variables: { slug: "treatment" },
               variableOverrides: {
                 slug: [
-                  { segments: "countries/germany", value: "de" },
-                  { segments: "countries/france", value: "fr" },
+                  { segments: "countries.germany", value: "de" },
+                  { segments: "countries.france", value: "fr" },
                 ],
               },
             },
@@ -777,7 +841,7 @@ describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable
               { key: "r1", segments: "*", percentage: 100 },
               {
                 key: "r2",
-                segments: "countries/germany",
+                segments: "countries.germany",
                 percentage: 100,
                 variables: { title: "Germany" },
               },
@@ -799,7 +863,7 @@ describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable
               { key: "r1", segments: "*", percentage: 100 },
               {
                 key: "r2",
-                segments: "countries/germany",
+                segments: "countries.germany",
                 percentage: 100,
                 variables: { count: 100 },
               },
@@ -822,7 +886,7 @@ describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable
               { key: "r1", segments: "*", percentage: 100 },
               {
                 key: "r2",
-                segments: "countries/germany",
+                segments: "countries.germany",
                 percentage: 100,
                 variables: { unknownVar: "x" },
               },
@@ -885,7 +949,7 @@ describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable
                 variableOverrides: {
                   config: [
                     {
-                      segments: "countries/germany",
+                      segments: "countries.germany",
                       value: {
                         "nested.count": 5,
                       },
@@ -1100,6 +1164,21 @@ describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable
   });
 
   describe("environment maps", () => {
+    it("allows direct rules, force, and expose when environments are omitted", () => {
+      expectParseSuccess(
+        baseFeature({
+          expose: true,
+          force: [{ segments: "*", variation: "control" }],
+          variations: [
+            { value: "control", weight: 50 },
+            { value: "treatment", weight: 50 },
+          ],
+          rules: [{ key: "r1", segments: "*", percentage: 100 }],
+        }),
+        { environments: undefined },
+      );
+    });
+
     it("allows a subset of configured environments in rules, force, and expose", () => {
       expectParseSuccess(
         baseFeature({
@@ -1120,6 +1199,16 @@ describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable
       );
     });
 
+    it("rejects direct rules when environments are configured", () => {
+      const err = expectParseFailure(
+        baseFeature({
+          rules: [{ key: "r1", segments: "*", percentage: 100 }],
+        }),
+      );
+
+      expect(err.issues.some((issue) => issue.path.join(".").includes("rules"))).toBe(true);
+    });
+
     it("rejects unknown environment keys in rules", () => {
       const err = expectParseFailure(
         baseFeature({

package/src/linter/featureSchema.ts

@@ -14,8 +14,6 @@ import {
 } from "./schema";
 import { refineWithMessage } from "./zodHelpers";
 
-const tagRegex = /^[a-z0-9-]+$/;
-
 function isArrayOfStrings(value: unknown): value is string[] {
   return Array.isArray(value) && value.every((v) => typeof v === "string");
 }
@@ -1324,17 +1322,17 @@ export function getFeatureZodSchema(
   const andOrNotGroupSegment = z.union([
     z
       .object({
-        and: z.array(z.lazy(() => groupSegmentZodSchema)),
+        and: z.array(z.lazy(() => groupSegmentZodSchema)).min(1),
       })
       .strict(),
     z
       .object({
-        or: z.array(z.lazy(() => groupSegmentZodSchema)),
+        or: z.array(z.lazy(() => groupSegmentZodSchema)).min(1),
       })
       .strict(),
     z
       .object({
-        not: z.array(z.lazy(() => groupSegmentZodSchema)),
+        not: z.array(z.lazy(() => groupSegmentZodSchema)).min(1),
       })
       .strict(),
   ]);
@@ -1353,6 +1351,7 @@ export function getFeatureZodSchema(
         .object({
           key: z.string(),
           description: z.string().optional(),
+          promotable: z.boolean().optional(),
           segments: groupSegmentsZodSchema,
           percentage: z.number().min(0).max(100),
 
@@ -1456,21 +1455,23 @@ export function getFeatureZodSchema(
     (value) => `Unknown feature "${value}"`,
   );
 
-  const environmentKeys = projectConfig.environments || [];
+  const environmentKeys = Array.isArray(projectConfig.environments)
+    ? projectConfig.environments
+    : [];
 
   const featureZodSchema = z
     .object({
       archived: z.boolean().optional(),
       deprecated: z.boolean().optional(),
+      promotable: z.boolean().optional(),
       description: z.string(),
 
       tags: z
         .array(
           refineWithMessage(
             z.string(),
-            (value) => tagRegex.test(value),
-            (value) =>
-              `Tag "${value}" must be lower cased and alphanumeric, and may contain hyphens.`,
+            (value) => projectConfig.tags.includes(value),
+            (value) => `Unknown tag "${value}"`,
           ),
         )
         .superRefine((value, ctx) => {
@@ -1480,7 +1481,8 @@ export function getFeatureZodSchema(
               message: "Duplicate tags found: " + value.join(", "),
             });
           }
-        }),
+        })
+        .optional(),
 
       required: z
         .array(
@@ -1675,24 +1677,19 @@ export function getFeatureZodSchema(
         })
         .optional(),
 
-      expose:
-        projectConfig.environments === false
-          ? exposeSchema.optional()
-          : z
-              .partialRecord(z.enum(environmentKeys as [string, ...string[]]), exposeSchema)
-              .optional(),
-
-      force:
-        projectConfig.environments === false
-          ? forceSchema
-          : z
-              .partialRecord(z.enum(environmentKeys as [string, ...string[]]), forceSchema)
-              .optional(),
-
-      rules:
-        projectConfig.environments === false
-          ? rulesSchema
-          : z.partialRecord(z.enum(environmentKeys as [string, ...string[]]), rulesSchema),
+      expose: !Array.isArray(projectConfig.environments)
+        ? exposeSchema.optional()
+        : z
+            .partialRecord(z.enum(environmentKeys as [string, ...string[]]), exposeSchema)
+            .optional(),
+
+      force: !Array.isArray(projectConfig.environments)
+        ? forceSchema
+        : z.partialRecord(z.enum(environmentKeys as [string, ...string[]]), forceSchema).optional(),
+
+      rules: !Array.isArray(projectConfig.environments)
+        ? rulesSchema
+        : z.partialRecord(z.enum(environmentKeys as [string, ...string[]]), rulesSchema),
     })
     .strict()
     .superRefine((value, ctx) => {

package/src/linter/groupSchema.ts

@@ -12,6 +12,7 @@ export function getGroupZodSchema(
   const groupZodSchema = z
     .object({
       description: z.string(),
+      promotable: z.boolean().optional(),
       slots: z
         .array(
           z

package/src/linter/lintProject.spec.ts

@@ -15,58 +15,10 @@ function createTempProjectFromExample1() {
   return tempRoot;
 }
 
-function createTempSplitProject() {
-  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "featurevisor-lint-split-"));
-
-  fs.writeFileSync(
-    path.join(tempRoot, "featurevisor.config.js"),
-    `
-module.exports = {
-  environments: ['staging', 'production'],
-  splitByEnvironment: true,
-  tags: ['all'],
-};
-`.trimStart(),
-    "utf8",
-  );
-
-  fs.mkdirSync(path.join(tempRoot, "features"), { recursive: true });
-  fs.mkdirSync(path.join(tempRoot, "environments", "staging"), { recursive: true });
-  fs.mkdirSync(path.join(tempRoot, "environments", "production"), { recursive: true });
-
-  fs.writeFileSync(
-    path.join(tempRoot, "features", "foo.yml"),
-    `
-key: foo
-description: Foo
-tags:
-  - all
-bucketBy: userId
-`.trimStart(),
-    "utf8",
-  );
-
-  fs.writeFileSync(
-    path.join(tempRoot, "environments", "staging", "foo.yml"),
-    `
-rules:
-  - key: everyone
-    segments: '*'
-    percentage: 100
-`.trimStart(),
-    "utf8",
-  );
-
-  fs.writeFileSync(
-    path.join(tempRoot, "environments", "production", "foo.yml"),
-    `
-rules:
-  - key: everyone
-    segments: '*'
-    percentage: 0
-`.trimStart(),
-    "utf8",
-  );
+function createTempProject(configBody = "module.exports = {};") {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "featurevisor-lint-"));
+
+  fs.writeFileSync(path.join(tempRoot, "featurevisor.config.js"), configBody, "utf8");
 
   return tempRoot;
 }
@@ -109,6 +61,132 @@ describe("core: lintProject", function () {
     });
   });
 
+  it("rejects entity file names containing the namespace character", async () => {
+    const root = createTempProject();
+    tempProjectPath = root;
+
+    fs.mkdirSync(path.join(root, "segments"), { recursive: true });
+    fs.writeFileSync(
+      path.join(root, "segments", "version_5.5.yml"),
+      [
+        "description: Version 5.5",
+        "conditions:",
+        "  - attribute: version",
+        "    operator: semverEquals",
+        "    value: 5.5.0",
+        "",
+      ].join("\n"),
+    );
+
+    const result = await lintProject(getDeps(root) as any, { json: true });
+
+    expect(result.hasError).toBe(true);
+    expect(result.errors).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          entityType: "segment",
+          filePath: expect.stringContaining(path.join("segments", "version_5.5.yml")),
+          message: 'Invalid file or directory name: "version_5.5.yml"',
+          code: "invalid_name",
+        }),
+      ]),
+    );
+  });
+
+  it("allows established test file suffixes with the namespace character", async () => {
+    const root = createTempProject();
+    tempProjectPath = root;
+
+    fs.mkdirSync(path.join(root, "tests", "features"), { recursive: true });
+    fs.writeFileSync(
+      path.join(root, "tests", "features", "checkout.spec.yml"),
+      ["feature: checkout", "assertions: []", ""].join("\n"),
+      "utf8",
+    );
+
+    const result = await lintProject(getDeps(root) as any, { json: true, entityType: "test" });
+
+    expect(
+      result.errors.some(
+        (error) =>
+          error.code === "invalid_name" &&
+          error.filePath.includes(path.join("tests", "features", "checkout.spec.yml")),
+      ),
+    ).toBe(false);
+  });
+
+  it("accepts promotable flags on top-level authored entities", async () => {
+    const files = [
+      path.join(tempProjectPath, "attributes", "userId.yml"),
+      path.join(tempProjectPath, "segments", "everyone.yml"),
+      path.join(tempProjectPath, "features", "showHeader.yml"),
+      path.join(tempProjectPath, "groups", "myExclusionGroup.yml"),
+      path.join(tempProjectPath, "schemas", "money.yml"),
+      path.join(tempProjectPath, "tests", "features", "showHeader.spec.yml"),
+    ];
+
+    for (const file of files) {
+      fs.appendFileSync(file, "\npromotable: false\n");
+    }
+
+    const result = await lintProject(getDeps(tempProjectPath) as any, { json: true });
+
+    expect(result).toEqual({
+      hasError: false,
+      errors: [],
+    });
+  });
+
+  it("accepts promotable flags on feature rules", async () => {
+    replaceInFile(
+      path.join(tempProjectPath, "features", "showHeader.yml"),
+      '    - key: "1"',
+      '    - key: "1"\n      promotable: false',
+    );
+
+    const result = await lintProject(getDeps(tempProjectPath) as any, { json: true });
+
+    expect(result).toEqual({
+      hasError: false,
+      errors: [],
+    });
+  });
+
+  it("rejects non-boolean promotable values", async () => {
+    fs.appendFileSync(
+      path.join(tempProjectPath, "attributes", "userId.yml"),
+      "\npromotable: nope\n",
+    );
+
+    const result = await lintProject(getDeps(tempProjectPath) as any, { json: true });
+
+    expect(result.hasError).toEqual(true);
+    expect(
+      result.errors.some(
+        (error) => error.path.join(".") === "promotable" && error.message.includes("boolean"),
+      ),
+    ).toEqual(true);
+  });
+
+  it("rejects non-boolean rule promotable values", async () => {
+    replaceInFile(
+      path.join(tempProjectPath, "features", "showHeader.yml"),
+      '    - key: "1"',
+      '    - key: "1"\n      promotable: nope',
+    );
+
+    const result = await lintProject(getDeps(tempProjectPath) as any, { json: true });
+
+    expect(result.hasError).toEqual(true);
+    expect(
+      result.errors.some(
+        (error) =>
+          error.path.join(".") === "rules.staging.0.promotable" &&
+          error.message.includes("boolean"),
+      ),
+    ).toEqual(true);
+  });
+
   it("returns structured errors in JSON mode", async () => {
     fs.writeFileSync(
       path.join(tempProjectPath, "attributes", "invalid name.yml"),
@@ -206,7 +284,7 @@ conditions:
         expect.objectContaining({
           filePath: expect.stringContaining(path.join("tests", "features", "withSchema.spec.yml")),
           entityType: "test",
-          key: "features/withSchema.spec",
+          key: "features.withSchema.spec",
           message: 'Unknown environment "qa"',
           path: ["assertions", 0, "environment"],
           code: "custom",
@@ -255,43 +333,4 @@ feature: foo
     expect(result.errors.length).toBeGreaterThan(0);
     expect(processExitSpy).not.toHaveBeenCalled();
   });
-
-  it("reports missing split environment file with environment file path", async () => {
-    const splitProjectPath = createTempSplitProject();
-    fs.unlinkSync(path.join(splitProjectPath, "environments", "production", "foo.yml"));
-
-    const result = await lintProject(getDeps(splitProjectPath) as any, {
-      json: true,
-      entityType: "feature",
-    });
-
-    expect(result.hasError).toBe(true);
-    expect(result.errors[0].filePath).toContain(path.join("environments", "production", "foo.yml"));
-  });
-
-  it("reports split environment feature schema errors against environment file path", async () => {
-    const splitProjectPath = createTempSplitProject();
-    fs.writeFileSync(
-      path.join(splitProjectPath, "environments", "staging", "foo.yml"),
-      `
-rules:
-  - key: everyone
-    segments: '*'
-    percentage: invalid
-`.trimStart(),
-      "utf8",
-    );
-
-    const result = await lintProject(getDeps(splitProjectPath) as any, {
-      json: true,
-      entityType: "feature",
-    });
-
-    expect(result.hasError).toBe(true);
-    expect(
-      result.errors.some((error) =>
-        error.filePath.includes(path.join("environments", "staging", "foo.yml")),
-      ),
-    ).toBe(true);
-  });
 });