@featurevisor/core 2.11.0 → 2.13.0

package/src/linter/lintProject.ts

@@ -1,24 +1,47 @@
 // for use in node only
 import * as path from "path";
 
+import type { Schema } from "@featurevisor/types";
+import type { ZodError } from "zod";
+
 import { getAttributeZodSchema } from "./attributeSchema";
 import { getConditionsZodSchema } from "./conditionSchema";
 import { getSegmentZodSchema } from "./segmentSchema";
 import { getGroupZodSchema } from "./groupSchema";
 import { getFeatureZodSchema } from "./featureSchema";
+import { getSchemaZodSchema } from "./schema";
 import { getTestsZodSchema } from "./testSchema";
 
 import { checkForCircularDependencyInRequired } from "./checkCircularDependency";
 import { checkForFeatureExceedingGroupSlotPercentage } from "./checkPercentageExceedingSlot";
-import { printZodError } from "./printError";
+import { getLintIssuesFromZodError, printZodError } from "./printError";
 import { Dependencies } from "../dependencies";
 import { CLI_FORMAT_RED, CLI_FORMAT_BOLD_UNDERLINE } from "../tester/cliFormat";
 import { Plugin } from "../cli";
 
+export type LintEntityType = "attribute" | "segment" | "feature" | "group" | "schema" | "test";
+
 export interface LintProjectOptions {
   keyPattern?: string;
   entityType?: string;
   authors?: boolean;
+  json?: boolean;
+  pretty?: boolean;
+}
+
+export interface LintErrorItem {
+  filePath: string;
+  entityType: LintEntityType;
+  key: string;
+  message: string;
+  path: (string | number)[];
+  code?: string;
+  value?: unknown;
+}
+
+export interface LintResult {
+  hasError: boolean;
+  errors: LintErrorItem[];
 }
 
 const ENTITY_NAME_REGEX = /^[a-zA-Z0-9_\-./]+$/;
@@ -37,12 +60,19 @@ async function getAuthorsOfEntity(datasource, entityType, entityKey): Promise<st
 export async function lintProject(
   deps: Dependencies,
   options: LintProjectOptions = {},
-): Promise<boolean> {
+): Promise<LintResult> {
   const { projectConfig, datasource } = deps;
 
-  let hasError = false;
+  const isJsonMode = options.json === true;
+  const errors: LintErrorItem[] = [];
 
-  function getFullPathFromKey(type: string, key: string, relative = false) {
+  function log(...args: unknown[]) {
+    if (!isJsonMode) {
+      console.log(...args);
+    }
+  }
+
+  function getFullPathFromKey(type: LintEntityType, key: string, relative = false) {
     const fileName = `${key}.${datasource.getExtension()}`;
     let fullPath = "";
 
@@ -54,10 +84,10 @@ export async function lintProject(
       fullPath = path.join(projectConfig.featuresDirectoryPath, fileName);
     } else if (type === "group") {
       fullPath = path.join(projectConfig.groupsDirectoryPath, fileName);
-    } else if (type === "test") {
-      fullPath = path.join(projectConfig.testsDirectoryPath, fileName);
+    } else if (type === "schema") {
+      fullPath = path.join(projectConfig.schemasDirectoryPath, fileName);
     } else {
-      throw new Error(`Unknown type: ${type}`);
+      fullPath = path.join(projectConfig.testsDirectoryPath, fileName);
     }
 
     if (relative) {
@@ -67,12 +97,118 @@ export async function lintProject(
     return fullPath;
   }
 
+  async function printEntityHeader(entityType: LintEntityType, key: string, fullPath: string) {
+    if (isJsonMode) {
+      return;
+    }
+
+    console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
+
+    if (options.authors) {
+      const authors = await getAuthorsOfEntity(datasource, entityType, key);
+      console.log(`     Authors: ${authors.join(", ")}\n`);
+    }
+  }
+
+  function recordError(error: LintErrorItem) {
+    errors.push(error);
+  }
+
+  async function reportSimpleError({
+    entityType,
+    key,
+    fullPath,
+    message,
+    detail,
+    pathParts = [],
+    code,
+    value,
+  }: {
+    entityType: LintEntityType;
+    key: string;
+    fullPath: string;
+    message: string;
+    detail?: string;
+    pathParts?: (string | number)[];
+    code?: string;
+    value?: unknown;
+  }) {
+    recordError({
+      filePath: path.relative(process.cwd(), fullPath),
+      entityType,
+      key,
+      message,
+      path: pathParts,
+      code,
+      value,
+    });
+
+    if (!isJsonMode) {
+      await printEntityHeader(entityType, key, fullPath);
+      console.log(CLI_FORMAT_RED, `  => Error: ${message}`);
+      if (detail) {
+        console.log(CLI_FORMAT_RED, `     ${detail}`);
+      }
+      console.log("");
+    }
+  }
+
+  async function reportThrownError(
+    entityType: LintEntityType,
+    key: string,
+    fullPath: string,
+    error: unknown,
+  ) {
+    const message = error instanceof Error ? error.message : String(error);
+
+    recordError({
+      filePath: path.relative(process.cwd(), fullPath),
+      entityType,
+      key,
+      message,
+      path: [],
+      code: error instanceof Error ? error.name : undefined,
+    });
+
+    if (!isJsonMode) {
+      await printEntityHeader(entityType, key, fullPath);
+      console.log("");
+      console.log(error);
+    }
+  }
+
+  async function reportZodValidationError(
+    entityType: LintEntityType,
+    key: string,
+    fullPath: string,
+    error: ZodError,
+  ) {
+    const issues = getLintIssuesFromZodError(error);
+
+    issues.forEach((issue) => {
+      recordError({
+        filePath: path.relative(process.cwd(), fullPath),
+        entityType,
+        key,
+        message: issue.message,
+        path: issue.path,
+        code: issue.code,
+        value: issue.value,
+      });
+    });
+
+    if (!isJsonMode) {
+      await printEntityHeader(entityType, key, fullPath);
+      printZodError(error);
+    }
+  }
+
   const keyPattern = options.keyPattern ? new RegExp(options.keyPattern) : null;
 
   if (keyPattern) {
-    console.log("");
-    console.log(`Linting only keys matching pattern: ${keyPattern}`);
-    console.log("");
+    log("");
+    log(`Linting only keys matching pattern: ${keyPattern}`);
+    log("");
   }
 
   // lint attributes
@@ -85,57 +221,32 @@ export async function lintProject(
       : attributes.filter((key) => keyPattern.test(key));
 
     if (filteredKeys.length > 0) {
-      console.log(`Linting ${filteredKeys.length} attributes...\n`);
+      log(`Linting ${filteredKeys.length} attributes...\n`);
     }
 
     for (const key of filteredKeys) {
       const fullPath = getFullPathFromKey("attribute", key);
 
       if (!ATTRIBUTE_NAME_REGEX.test(key)) {
-        console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
-
-        if (options.authors) {
-          const authors = await getAuthorsOfEntity(datasource, "attribute", key);
-          console.log(`     Authors: ${authors.join(", ")}\n`);
-        }
-
-        console.log(CLI_FORMAT_RED, `  => Error: Invalid name: "${key}"`);
-        console.log(CLI_FORMAT_RED, `     ${ATTRIBUTE_NAME_REGEX_ERROR}`);
-        console.log("");
-        hasError = true;
+        await reportSimpleError({
+          entityType: "attribute",
+          key,
+          fullPath,
+          message: `Invalid name: "${key}"`,
+          detail: ATTRIBUTE_NAME_REGEX_ERROR,
+          code: "invalid_name",
+        });
       }
 
       try {
         const parsed = await datasource.readAttribute(key);
-
         const result = attributeZodSchema.safeParse(parsed);
 
-        if (!result.success) {
-          console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
-
-          if (options.authors) {
-            const authors = await getAuthorsOfEntity(datasource, "attribute", key);
-            console.log(`     Authors: ${authors.join(", ")}\n`);
-          }
-
-          if ("error" in result) {
-            printZodError(result.error);
-          }
-
-          hasError = true;
+        if (!result.success && "error" in result) {
+          await reportZodValidationError("attribute", key, fullPath, result.error);
         }
-      } catch (e) {
-        console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
-
-        if (options.authors) {
-          const authors = await getAuthorsOfEntity(datasource, "attribute", key);
-          console.log(`     Authors: ${authors.join(", ")}\n`);
-        }
-
-        console.log("");
-        console.log(e);
-
-        hasError = true;
+      } catch (error) {
+        await reportThrownError("attribute", key, fullPath, error);
       }
     }
   }
@@ -154,61 +265,47 @@ export async function lintProject(
     const filteredKeys = !keyPattern ? segments : segments.filter((key) => keyPattern.test(key));
 
     if (filteredKeys.length > 0) {
-      console.log(`Linting ${filteredKeys.length} segments...\n`);
+      log(`Linting ${filteredKeys.length} segments...\n`);
     }
 
     for (const key of filteredKeys) {
       const fullPath = getFullPathFromKey("segment", key);
 
       if (!ENTITY_NAME_REGEX.test(key)) {
-        console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
-
-        if (options.authors) {
-          const authors = await getAuthorsOfEntity(datasource, "segment", key);
-          console.log(`     Authors: ${authors.join(", ")}\n`);
-        }
-
-        console.log(CLI_FORMAT_RED, `  => Error: Invalid name: "${key}"`);
-        console.log(CLI_FORMAT_RED, `     ${ENTITY_NAME_REGEX_ERROR}`);
-        console.log("");
-        hasError = true;
+        await reportSimpleError({
+          entityType: "segment",
+          key,
+          fullPath,
+          message: `Invalid name: "${key}"`,
+          detail: ENTITY_NAME_REGEX_ERROR,
+          code: "invalid_name",
+        });
       }
 
       try {
         const parsed = await datasource.readSegment(key);
-
         const result = segmentZodSchema.safeParse(parsed);
 
-        if (!result.success) {
-          console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
-
-          if (options.authors) {
-            const authors = await getAuthorsOfEntity(datasource, "segment", key);
-            console.log(`     Authors: ${authors.join(", ")}\n`);
-          }
-
-          if ("error" in result) {
-            printZodError(result.error);
-          }
-
-          hasError = true;
+        if (!result.success && "error" in result) {
+          await reportZodValidationError("segment", key, fullPath, result.error);
         }
-      } catch (e) {
-        console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
-
-        if (options.authors) {
-          const authors = await getAuthorsOfEntity(datasource, "segment", key);
-          console.log(`     Authors: ${authors.join(", ")}\n`);
-        }
-
-        console.log("");
-        console.log(e);
-
-        hasError = true;
+      } catch (error) {
+        await reportThrownError("segment", key, fullPath, error);
       }
     }
   }
 
+  // List schemas and load parsed schemas for feature variable validation (schema references)
+  const schemas = await datasource.listSchemas();
+  const schemasByKey: Record<string, Schema> = {};
+  for (const key of schemas) {
+    try {
+      schemasByKey[key] = await datasource.readSchema(key);
+    } catch {
+      // Schema file may be invalid; skip for feature variable resolution
+    }
+  }
+
   // lint features
   const features = await datasource.listFeatures();
   const featureZodSchema = getFeatureZodSchema(
@@ -217,30 +314,29 @@ export async function lintProject(
     flattenedAttributes as [string, ...string[]],
     segments as [string, ...string[]],
     features as [string, ...string[]],
+    schemas,
+    schemasByKey,
   );
 
   if (!options.entityType || options.entityType === "feature") {
     const filteredKeys = !keyPattern ? features : features.filter((key) => keyPattern.test(key));
 
     if (filteredKeys.length > 0) {
-      console.log(`Linting ${filteredKeys.length} features...\n`);
+      log(`Linting ${filteredKeys.length} features...\n`);
     }
 
     for (const key of filteredKeys) {
       const fullPath = getFullPathFromKey("feature", key);
 
       if (!ENTITY_NAME_REGEX.test(key)) {
-        console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
-
-        if (options.authors) {
-          const authors = await getAuthorsOfEntity(datasource, "feature", key);
-          console.log(`     Authors: ${authors.join(", ")}\n`);
-        }
-
-        console.log(CLI_FORMAT_RED, `  => Error: Invalid name: "${key}"`);
-        console.log(CLI_FORMAT_RED, `     ${ENTITY_NAME_REGEX_ERROR}`);
-        console.log("");
-        hasError = true;
+        await reportSimpleError({
+          entityType: "feature",
+          key,
+          fullPath,
+          message: `Invalid name: "${key}"`,
+          detail: ENTITY_NAME_REGEX_ERROR,
+          code: "invalid_name",
+        });
       }
 
       let parsed;
@@ -250,48 +346,24 @@ export async function lintProject(
 
         const result = featureZodSchema.safeParse(parsed);
 
-        if (!result.success) {
-          console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
-
-          if (options.authors) {
-            const authors = await getAuthorsOfEntity(datasource, "feature", key);
-            console.log(`     Authors: ${authors.join(", ")}\n`);
-          }
-
-          if ("error" in result) {
-            printZodError(result.error);
-          }
-
-          hasError = true;
-        }
-      } catch (e) {
-        console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
-
-        if (options.authors) {
-          const authors = await getAuthorsOfEntity(datasource, "feature", key);
-          console.log(`     Authors: ${authors.join(", ")}\n`);
+        if (!result.success && "error" in result) {
+          await reportZodValidationError("feature", key, fullPath, result.error);
         }
-
-        console.log("");
-        console.log(e);
-
-        hasError = true;
+      } catch (error) {
+        await reportThrownError("feature", key, fullPath, error);
       }
 
       if (parsed && parsed.required) {
         try {
           await checkForCircularDependencyInRequired(datasource, key, parsed.required);
-        } catch (e) {
-          console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
-
-          if (options.authors) {
-            const authors = await getAuthorsOfEntity(datasource, "feature", key);
-            console.log(`     Authors: ${authors.join(", ")}\n`);
-          }
-
-          console.log(CLI_FORMAT_RED, `  => Error: ${e.message}`);
-
-          hasError = true;
+        } catch (error) {
+          await reportSimpleError({
+            entityType: "feature",
+            key,
+            fullPath,
+            message: error instanceof Error ? error.message : String(error),
+            code: error instanceof Error ? error.name : "error",
+          });
         }
       }
     }
@@ -305,24 +377,21 @@ export async function lintProject(
     const filteredKeys = !keyPattern ? groups : groups.filter((key) => keyPattern.test(key));
 
     if (filteredKeys.length > 0) {
-      console.log(`Linting ${filteredKeys.length} groups...\n`);
+      log(`Linting ${filteredKeys.length} groups...\n`);
     }
 
     for (const key of filteredKeys) {
       const fullPath = getFullPathFromKey("group", key);
 
       if (!ENTITY_NAME_REGEX.test(key)) {
-        console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
-        console.log(CLI_FORMAT_RED, `  => Error: Invalid name: "${key}"`);
-
-        if (options.authors) {
-          const authors = await getAuthorsOfEntity(datasource, "group", key);
-          console.log(`     Authors: ${authors.join(", ")}\n`);
-        }
-
-        console.log(CLI_FORMAT_RED, `     ${ENTITY_NAME_REGEX_ERROR}`);
-        console.log("");
-        hasError = true;
+        await reportSimpleError({
+          entityType: "group",
+          key,
+          fullPath,
+          message: `Invalid name: "${key}"`,
+          detail: ENTITY_NAME_REGEX_ERROR,
+          code: "invalid_name",
+        });
       }
 
       let parsed;
@@ -332,41 +401,24 @@ export async function lintProject(
 
         const result = groupZodSchema.safeParse(parsed);
 
-        if (!result.success) {
-          console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
-
-          if (options.authors) {
-            const authors = await getAuthorsOfEntity(datasource, "group", key);
-            console.log(`     Authors: ${authors.join(", ")}\n`);
-          }
-
-          if ("error" in result) {
-            printZodError(result.error);
-          }
-
-          hasError = true;
-        }
-      } catch (e) {
-        console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
-
-        if (options.authors) {
-          const authors = await getAuthorsOfEntity(datasource, "group", key);
-          console.log(`     Authors: ${authors.join(", ")}\n`);
+        if (!result.success && "error" in result) {
+          await reportZodValidationError("group", key, fullPath, result.error);
         }
-
-        console.log("");
-        console.log(e);
-
-        hasError = true;
+      } catch (error) {
+        await reportThrownError("group", key, fullPath, error);
       }
 
       if (parsed) {
         try {
           await checkForFeatureExceedingGroupSlotPercentage(datasource, parsed, features);
-        } catch (e) {
-          console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
-          console.log(CLI_FORMAT_RED, `  => Error: ${e.message}`);
-          hasError = true;
+        } catch (error) {
+          await reportSimpleError({
+            entityType: "group",
+            key,
+            fullPath,
+            message: error instanceof Error ? error.message : String(error),
+            code: error instanceof Error ? error.name : "error",
+          });
         }
       }
     }
@@ -374,6 +426,44 @@ export async function lintProject(
 
   // @TODO: feature cannot exist in multiple groups
 
+  // lint schemas (schemas and schemasByKey already loaded above for feature linting)
+  const schemaZodSchema = getSchemaZodSchema(schemas);
+
+  if (!options.entityType || options.entityType === "schema") {
+    const filteredKeys = !keyPattern ? schemas : schemas.filter((key) => keyPattern.test(key));
+
+    if (filteredKeys.length > 0) {
+      log(`Linting ${filteredKeys.length} schemas...\n`);
+    }
+
+    for (const key of filteredKeys) {
+      const fullPath = getFullPathFromKey("schema", key);
+
+      if (!ENTITY_NAME_REGEX.test(key)) {
+        await reportSimpleError({
+          entityType: "schema",
+          key,
+          fullPath,
+          message: `Invalid name: "${key}"`,
+          detail: ENTITY_NAME_REGEX_ERROR,
+          code: "invalid_name",
+        });
+      }
+
+      try {
+        const parsed = await datasource.readSchema(key);
+
+        const result = schemaZodSchema.safeParse(parsed);
+
+        if (!result.success && "error" in result) {
+          await reportZodValidationError("schema", key, fullPath, result.error);
+        }
+      } catch (error) {
+        await reportThrownError("schema", key, fullPath, error);
+      }
+    }
+  }
+
   // lint tests
   const tests = await datasource.listTests();
 
@@ -387,24 +477,21 @@ export async function lintProject(
     const filteredKeys = !keyPattern ? tests : tests.filter((key) => keyPattern.test(key));
 
     if (filteredKeys.length > 0) {
-      console.log(`Linting ${filteredKeys.length} tests...\n`);
+      log(`Linting ${filteredKeys.length} tests...\n`);
     }
 
     for (const key of filteredKeys) {
       const fullPath = getFullPathFromKey("test", key);
 
       if (!ENTITY_NAME_REGEX.test(key)) {
-        console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
-
-        if (options.authors) {
-          const authors = await getAuthorsOfEntity(datasource, "test", key);
-          console.log(`     Authors: ${authors.join(", ")}\n`);
-        }
-
-        console.log(CLI_FORMAT_RED, `  => Error: Invalid name: "${key}"`);
-        console.log(CLI_FORMAT_RED, `     ${ENTITY_NAME_REGEX_ERROR}`);
-        console.log("");
-        hasError = true;
+        await reportSimpleError({
+          entityType: "test",
+          key,
+          fullPath,
+          message: `Invalid name: "${key}"`,
+          detail: ENTITY_NAME_REGEX_ERROR,
+          code: "invalid_name",
+        });
       }
 
       try {
@@ -412,39 +499,19 @@ export async function lintProject(
 
         const result = testsZodSchema.safeParse(parsed);
 
-        if (!result.success) {
-          console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
-
-          if (options.authors) {
-            const authors = await getAuthorsOfEntity(datasource, "test", key);
-            console.log(`     Authors: ${authors.join(", ")}\n`);
-          }
-
-          if ("error" in result) {
-            printZodError(result.error);
-
-            process.exit(1);
-          }
-
-          hasError = true;
-        }
-      } catch (e) {
-        console.log(CLI_FORMAT_BOLD_UNDERLINE, fullPath);
-
-        if (options.authors) {
-          const authors = await getAuthorsOfEntity(datasource, "test", key);
-          console.log(`     Authors: ${authors.join(", ")}\n`);
+        if (!result.success && "error" in result) {
+          await reportZodValidationError("test", key, fullPath, result.error);
         }
-
-        console.log("");
-        console.log(e);
-
-        hasError = true;
+      } catch (error) {
+        await reportThrownError("test", key, fullPath, error);
       }
     }
   }
 
-  return hasError;
+  return {
+    hasError: errors.length > 0,
+    errors,
+  };
 }
 
 export const lintPlugin: Plugin = {
@@ -452,7 +519,7 @@ export const lintPlugin: Plugin = {
   handler: async function (options) {
     const { rootDirectoryPath, projectConfig, datasource, parsed } = options;
 
-    const hasError = await lintProject(
+    const result = await lintProject(
       {
         rootDirectoryPath,
         projectConfig,
@@ -463,10 +530,17 @@ export const lintPlugin: Plugin = {
         keyPattern: parsed.keyPattern,
         entityType: parsed.entityType,
         authors: parsed.authors,
+        json: parsed.json,
+        pretty: parsed.pretty,
       },
     );
 
-    if (hasError) {
+    if (parsed.json) {
+      const payload = { errors: result.errors };
+      console.log(parsed.pretty ? JSON.stringify(payload, null, 2) : JSON.stringify(payload));
+    }
+
+    if (result.hasError) {
       return false;
     }
   },
@@ -487,6 +561,10 @@ export const lintPlugin: Plugin = {
       command: "lint --entityType=group",
       description: "lint only groups",
     },
+    {
+      command: "lint --entityType=schema",
+      description: "lint only schemas",
+    },
     {
       command: "lint --entityType=test",
       description: "lint only tests",
@@ -495,5 +573,13 @@ export const lintPlugin: Plugin = {
       command: 'lint --keyPattern="abc"',
       description: `lint only entities with keys containing "abc"`,
     },
+    {
+      command: "lint --json",
+      description: "print lint errors as JSON",
+    },
+    {
+      command: "lint --json --pretty",
+      description: "print lint errors as pretty JSON",
+    },
   ],
 };