@featurevisor/core 2.13.0 → 2.15.0

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);
+      }
     }
   }