@featurevisor/core 2.14.0 → 2.15.0

package/src/linter/featureSchema.ts

@@ -1465,15 +1465,9 @@ export function getFeatureZodSchema(
         }
       }
 
-      if (!value.variablesSchema) {
-        return;
-      }
-
-      // Every variable value is validated against its schema from variablesSchema. Sources covered:
-      // 1. variablesSchema[key].defaultValue  2. variablesSchema[key].disabledValue
-      // 3. variations[n].variables[key]       4. variations[n].variableOverrides[key][].value
-      // 5. rules[env][n].variables[key]       6. force[env][n].variables[key]
-      const variableSchemaByKey = value.variablesSchema;
+      // When variablesSchema is absent, variableSchemaByKey is {} so any variable key used in
+      // rules/force/variations will be reported as "not defined in variablesSchema".
+      const variableSchemaByKey = value.variablesSchema ?? {};
       const variationValues: string[] = [];
 
       if (value.variations) {
@@ -1482,100 +1476,102 @@ export function getFeatureZodSchema(
         });
       }
 
-      // variablesSchema[key]
-      const variableKeys = Object.keys(variableSchemaByKey);
-      variableKeys.forEach((variableKey) => {
-        const variableSchema = variableSchemaByKey[variableKey];
+      // variablesSchema[key] — only when feature defines variablesSchema
+      if (value.variablesSchema) {
+        const variableKeys = Object.keys(variableSchemaByKey);
+        variableKeys.forEach((variableKey) => {
+          const variableSchema = variableSchemaByKey[variableKey];
 
-        // When variable references a schema by name, ensure it resolves and validate the referenced schema
-        if ("schema" in variableSchema && variableSchema.schema) {
-          const resolvedSchema = resolveVariableSchema(
-            variableSchema as Parameters<typeof resolveVariableSchema>[0],
-            schemasByKey,
-          );
-          if (!resolvedSchema) {
-            ctx.addIssue({
-              code: z.ZodIssueCode.custom,
-              message: `Schema "${variableSchema.schema}" could not be loaded for variable "${variableKey}".`,
-              path: ["variablesSchema", variableKey],
-            });
-          } else {
-            refineRequiredKeysInSchema(
-              resolvedSchema as SchemaLikeForRequired,
-              ["variablesSchema", variableKey],
-              ctx,
+          // When variable references a schema by name, ensure it resolves and validate the referenced schema
+          if ("schema" in variableSchema && variableSchema.schema) {
+            const resolvedSchema = resolveVariableSchema(
+              variableSchema as Parameters<typeof resolveVariableSchema>[0],
               schemasByKey,
             );
+            if (!resolvedSchema) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `Schema "${variableSchema.schema}" could not be loaded for variable "${variableKey}".`,
+                path: ["variablesSchema", variableKey],
+              });
+            } else {
+              refineRequiredKeysInSchema(
+                resolvedSchema as SchemaLikeForRequired,
+                ["variablesSchema", variableKey],
+                ctx,
+                schemasByKey,
+              );
+            }
           }
-        }
-
-        // When type and enum are both present, all enum values must match the type
-        const effectiveSchema = resolveVariableSchema(variableSchema, schemasByKey);
-        if (
-          effectiveSchema &&
-          effectiveSchema.type &&
-          Array.isArray(effectiveSchema.enum) &&
-          effectiveSchema.enum.length > 0
-        ) {
-          refineEnumMatchesType(
-            effectiveSchema as Parameters<typeof refineEnumMatchesType>[0],
-            ["variablesSchema", variableKey],
-            ctx,
-          );
-        }
 
-        // Inline variable schemas: validate minimum/maximum, minLength/maxLength/pattern, minItems/maxItems/uniqueItems
-        if (!("schema" in variableSchema) || !variableSchema.schema) {
-          const pathPrefix = ["variablesSchema", variableKey];
-          refineMinimumMaximum(
-            variableSchema as Parameters<typeof refineMinimumMaximum>[0],
-            pathPrefix,
-            ctx,
-          );
-          refineStringLengthPattern(
-            variableSchema as Parameters<typeof refineStringLengthPattern>[0],
-            pathPrefix,
-            ctx,
-          );
-          refineArrayItems(
-            variableSchema as Parameters<typeof refineArrayItems>[0],
-            pathPrefix,
-            ctx,
-          );
-        }
+          // When type and enum are both present, all enum values must match the type
+          const effectiveSchema = resolveVariableSchema(variableSchema, schemasByKey);
+          if (
+            effectiveSchema &&
+            effectiveSchema.type &&
+            Array.isArray(effectiveSchema.enum) &&
+            effectiveSchema.enum.length > 0
+          ) {
+            refineEnumMatchesType(
+              effectiveSchema as Parameters<typeof refineEnumMatchesType>[0],
+              ["variablesSchema", variableKey],
+              ctx,
+            );
+          }
 
-        if (variableKey === "variation") {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `Variable key "${variableKey}" is reserved and cannot be used.`,
-            path: ["variablesSchema", variableKey],
-          });
-        }
+          // Inline variable schemas: validate minimum/maximum, minLength/maxLength/pattern, minItems/maxItems/uniqueItems
+          if (!("schema" in variableSchema) || !variableSchema.schema) {
+            const pathPrefix = ["variablesSchema", variableKey];
+            refineMinimumMaximum(
+              variableSchema as Parameters<typeof refineMinimumMaximum>[0],
+              pathPrefix,
+              ctx,
+            );
+            refineStringLengthPattern(
+              variableSchema as Parameters<typeof refineStringLengthPattern>[0],
+              pathPrefix,
+              ctx,
+            );
+            refineArrayItems(
+              variableSchema as Parameters<typeof refineArrayItems>[0],
+              pathPrefix,
+              ctx,
+            );
+          }
 
-        // defaultValue
-        superRefineVariableValue(
-          projectConfig,
-          variableSchema,
-          variableSchema.defaultValue,
-          ["variablesSchema", variableKey, "defaultValue"],
-          ctx,
-          variableKey,
-          schemasByKey,
-        );
+          if (variableKey === "variation") {
+            ctx.addIssue({
+              code: z.ZodIssueCode.custom,
+              message: `Variable key "${variableKey}" is reserved and cannot be used.`,
+              path: ["variablesSchema", variableKey],
+            });
+          }
 
-        // disabledValue (only when present)
-        if (variableSchema.disabledValue !== undefined) {
+          // defaultValue
           superRefineVariableValue(
             projectConfig,
             variableSchema,
-            variableSchema.disabledValue,
-            ["variablesSchema", variableKey, "disabledValue"],
+            variableSchema.defaultValue,
+            ["variablesSchema", variableKey, "defaultValue"],
             ctx,
             variableKey,
             schemasByKey,
           );
-        }
-      });
+
+          // disabledValue (only when present)
+          if (variableSchema.disabledValue !== undefined) {
+            superRefineVariableValue(
+              projectConfig,
+              variableSchema,
+              variableSchema.disabledValue,
+              ["variablesSchema", variableKey, "disabledValue"],
+              ctx,
+              variableKey,
+              schemasByKey,
+            );
+          }
+        });
+      }
 
       // variations: validate variation.variables and variation.variableOverrides (each value against its variable schema)
       if (value.variations) {

package/src/linter/lintProject.spec.ts

@@ -15,6 +15,46 @@ 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'],",
+      "};",
+    ].join("\n"),
+    "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"].join("\n"),
+    "utf8",
+  );
+
+  fs.writeFileSync(
+    path.join(tempRoot, "environments", "staging", "foo.yml"),
+    ["rules:", "  - key: everyone", "    segments: '*'", "    percentage: 100"].join("\n"),
+    "utf8",
+  );
+
+  fs.writeFileSync(
+    path.join(tempRoot, "environments", "production", "foo.yml"),
+    ["rules:", "  - key: everyone", "    segments: '*'", "    percentage: 0"].join("\n"),
+    "utf8",
+  );
+
+  return tempRoot;
+}
+
 function getDeps(rootDirectoryPath: string) {
   const projectConfig = getProjectConfig(rootDirectoryPath);
   const datasource = new Datasource(projectConfig, rootDirectoryPath);
@@ -112,4 +152,38 @@ describe("core: lintProject", function () {
     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"].join("\n"),
+      "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);
+  });
 });

package/src/linter/lintProject.ts

@@ -37,6 +37,8 @@ export interface LintErrorItem {
   path: (string | number)[];
   code?: string;
   value?: unknown;
+  /** Present only when splitByEnvironment is true and the error is from an environment-specific file (rules/force/expose). */
+  environment?: string;
 }
 
 export interface LintResult {
@@ -97,6 +99,62 @@ export async function lintProject(
     return fullPath;
   }
 
+  async function getFeaturePathFromIssuePath(
+    featureKey: string,
+    issuePath: (string | number)[] = [],
+  ): Promise<string> {
+    const defaultPath = getFullPathFromKey("feature", featureKey);
+
+    if (!projectConfig.splitByEnvironment) {
+      return defaultPath;
+    }
+
+    if (!Array.isArray(projectConfig.environments)) {
+      return defaultPath;
+    }
+
+    const [topLevelKey, environment] = issuePath;
+    if (
+      (topLevelKey === "rules" || topLevelKey === "force" || topLevelKey === "expose") &&
+      typeof environment === "string"
+    ) {
+      const sourcePath = await datasource.getFeaturePropertySourcePath(
+        featureKey,
+        topLevelKey,
+        environment,
+      );
+
+      if (sourcePath) {
+        return sourcePath;
+      }
+    }
+
+    return defaultPath;
+  }
+
+  /**
+   * When the error is from an environment-specific file (splitByEnvironment), the Zod path
+   * is against the merged feature (e.g. rules.production.1.variables.foo). Return the path
+   * as it appears in that file (e.g. rules.1.variables.foo) by stripping the environment segment.
+   */
+  function getPathRelativeToFeatureFile(
+    issuePath: (string | number)[],
+    targetPath: string,
+    defaultFeaturePath: string,
+  ): (string | number)[] {
+    if (targetPath === defaultFeaturePath || issuePath.length < 2) {
+      return issuePath;
+    }
+    const [topLevelKey, second] = issuePath;
+    if (
+      (topLevelKey === "rules" || topLevelKey === "force" || topLevelKey === "expose") &&
+      typeof second === "string"
+    ) {
+      return [topLevelKey, ...issuePath.slice(2)];
+    }
+    return issuePath;
+  }
+
   async function printEntityHeader(entityType: LintEntityType, key: string, fullPath: string) {
     if (isJsonMode) {
       return;
@@ -159,10 +217,18 @@ export async function lintProject(
     fullPath: string,
     error: unknown,
   ) {
+    const pathFromError =
+      error &&
+      typeof error === "object" &&
+      "featurevisorFilePath" in error &&
+      typeof error.featurevisorFilePath === "string"
+        ? error.featurevisorFilePath
+        : undefined;
+    const targetPath = pathFromError || fullPath;
     const message = error instanceof Error ? error.message : String(error);
 
     recordError({
-      filePath: path.relative(process.cwd(), fullPath),
+      filePath: path.relative(process.cwd(), targetPath),
       entityType,
       key,
       message,
@@ -171,7 +237,7 @@ export async function lintProject(
     });
 
     if (!isJsonMode) {
-      await printEntityHeader(entityType, key, fullPath);
+      await printEntityHeader(entityType, key, targetPath);
       console.log("");
       console.log(error);
     }
@@ -184,22 +250,71 @@ export async function lintProject(
     error: ZodError,
   ) {
     const issues = getLintIssuesFromZodError(error);
+    const defaultFeaturePath =
+      entityType === "feature" ? getFullPathFromKey("feature", key) : fullPath;
+
+    const issuesWithTargetPath: {
+      issue: (typeof issues)[0];
+      targetPath: string;
+      pathRelativeToFile: (string | number)[];
+    }[] = [];
+    for (const issue of issues) {
+      const targetPath =
+        entityType === "feature" ? await getFeaturePathFromIssuePath(key, issue.path) : fullPath;
+      const pathRelativeToFile =
+        entityType === "feature"
+          ? getPathRelativeToFeatureFile(issue.path, targetPath, defaultFeaturePath)
+          : issue.path;
+      const isFromEnvFile =
+        entityType === "feature" &&
+        targetPath !== defaultFeaturePath &&
+        issue.path.length >= 2 &&
+        (issue.path[0] === "rules" || issue.path[0] === "force" || issue.path[0] === "expose") &&
+        typeof issue.path[1] === "string";
+      const environment = isFromEnvFile ? (issue.path[1] as string) : undefined;
+      issuesWithTargetPath.push({ issue, targetPath, pathRelativeToFile });
 
-    issues.forEach((issue) => {
       recordError({
-        filePath: path.relative(process.cwd(), fullPath),
+        filePath: path.relative(process.cwd(), targetPath),
         entityType,
         key,
         message: issue.message,
-        path: issue.path,
+        path: pathRelativeToFile,
         code: issue.code,
         value: issue.value,
+        ...(environment !== undefined && { environment }),
       });
-    });
+    }
 
     if (!isJsonMode) {
-      await printEntityHeader(entityType, key, fullPath);
-      printZodError(error);
+      if (entityType === "feature" && issuesWithTargetPath.length > 0) {
+        const byPath = new Map<
+          string,
+          {
+            issue: (typeof issuesWithTargetPath)[0]["issue"];
+            pathRelativeToFile: (string | number)[];
+          }[]
+        >();
+        for (const { issue, targetPath, pathRelativeToFile } of issuesWithTargetPath) {
+          const pathKey = targetPath;
+          if (!byPath.has(pathKey)) byPath.set(pathKey, []);
+          byPath.get(pathKey)!.push({ issue, pathRelativeToFile });
+        }
+        for (const [targetPathKey, groupItems] of byPath) {
+          await printEntityHeader(entityType, key, targetPathKey);
+          for (const { issue, pathRelativeToFile } of groupItems) {
+            console.log(CLI_FORMAT_RED, `  => Error: ${issue.message}`);
+            console.log("     Path:", pathRelativeToFile.join("."));
+            if (typeof issue.value !== "undefined" && issue.value !== "undefined") {
+              console.log("     Value:", issue.value);
+            }
+            console.log("");
+          }
+        }
+      } else {
+        await printEntityHeader(entityType, key, fullPath);
+        printZodError(error);
+      }
     }
   }
 

package/src/linter/segmentSchema.spec.ts

@@ -22,7 +22,9 @@ function minimalProjectConfig(): ProjectConfig {
     datafileNamePattern: "",
     revisionFileName: "",
     siteExportDirectoryPath: "",
+    environmentsDirectoryPath: "",
     environments: ["staging", "production"],
+    splitByEnvironment: false,
     tags: ["all"],
     adapter: {},
     plugins: [],

package/src/utils/git.ts

@@ -5,6 +5,12 @@ import type { Commit, EntityDiff, EntityType } from "@featurevisor/types";
 import { ProjectConfig } from "../config";
 import { CustomParser } from "../parsers";
 
+function isWithinDirectory(directoryPath: string, fileDirectoryPath: string): boolean {
+  return (
+    fileDirectoryPath === directoryPath || fileDirectoryPath.startsWith(directoryPath + path.sep)
+  );
+}
+
 function parseGitCommitShowOutput(gitShowOutput: string) {
   const result = {
     hash: "",
@@ -83,17 +89,22 @@ export function getCommit(
 
     // get entity type
     let type: EntityType = "attribute";
-    if (relativeDir === projectConfig.attributesDirectoryPath) {
+    if (isWithinDirectory(projectConfig.attributesDirectoryPath, relativeDir)) {
       type = "attribute";
-    } else if (relativeDir === projectConfig.segmentsDirectoryPath) {
+    } else if (isWithinDirectory(projectConfig.segmentsDirectoryPath, relativeDir)) {
       type = "segment";
-    } else if (relativeDir === projectConfig.featuresDirectoryPath) {
+    } else if (isWithinDirectory(projectConfig.featuresDirectoryPath, relativeDir)) {
       type = "feature";
-    } else if (relativeDir === projectConfig.groupsDirectoryPath) {
+    } else if (
+      projectConfig.splitByEnvironment &&
+      isWithinDirectory(projectConfig.environmentsDirectoryPath, relativeDir)
+    ) {
+      type = "feature";
+    } else if (isWithinDirectory(projectConfig.groupsDirectoryPath, relativeDir)) {
       type = "group";
-    } else if (relativeDir === projectConfig.schemasDirectoryPath) {
+    } else if (isWithinDirectory(projectConfig.schemasDirectoryPath, relativeDir)) {
       type = "schema";
-    } else if (relativeDir === projectConfig.testsDirectoryPath) {
+    } else if (isWithinDirectory(projectConfig.testsDirectoryPath, relativeDir)) {
       type = "test";
     } else {
       // unknown type
@@ -109,7 +120,30 @@ export function getCommit(
       return;
     }
 
-    const key = fileName.replace(extensionWithDot, "");
+    let key = fileName.replace(extensionWithDot, "");
+
+    if (
+      type === "feature" &&
+      projectConfig.splitByEnvironment &&
+      absolutePath.startsWith(projectConfig.environmentsDirectoryPath + path.sep)
+    ) {
+      const featureRelativePath = absolutePath
+        .replace(projectConfig.environmentsDirectoryPath + path.sep, "")
+        .split(path.sep)
+        .slice(1)
+        .join(path.sep)
+        .replace(extensionWithDot, "");
+
+      key = featureRelativePath.replace(/\\/g, "/");
+    } else if (
+      type === "feature" &&
+      absolutePath.startsWith(projectConfig.featuresDirectoryPath + path.sep)
+    ) {
+      key = absolutePath
+        .replace(projectConfig.featuresDirectoryPath + path.sep, "")
+        .replace(extensionWithDot, "")
+        .replace(/\\/g, "/");
+    }
 
     const entityDiff: EntityDiff = {
       type,