@featurevisor/core 1.5.1 → 1.6.0

package/src/linter/lintProject.ts

@@ -1,16 +1,18 @@
 // for use in node only
-import * as Joi from "joi";
+import * as path from "path";
 
-import { getAttributeJoiSchema } from "./attributeSchema";
-import { getConditionsJoiSchema } from "./conditionSchema";
-import { getSegmentJoiSchema } from "./segmentSchema";
-import { getGroupJoiSchema } from "./groupSchema";
-import { getFeatureJoiSchema } from "./featureSchema";
-import { getTestsJoiSchema } from "./testSchema";
+import { getAttributeZodSchema } from "./attributeSchema";
+import { getConditionsZodSchema } from "./conditionSchema";
+import { getSegmentZodSchema } from "./segmentSchema";
+import { getGroupZodSchema } from "./groupSchema";
+import { getFeatureZodSchema } from "./featureSchema";
+import { getTestsZodSchema } from "./testSchema";
 
 import { checkForCircularDependencyInRequired } from "./checkCircularDependency";
-import { printJoiError } from "./printJoiError";
+import { checkForFeatureExceedingGroupSlotPercentage } from "./checkPercentageExceedingSlot";
+import { printZodError } from "./printError";
 import { Dependencies } from "../dependencies";
+import { CLI_FORMAT_RED, CLI_FORMAT_UNDERLINE } from "../tester/cliFormat";
 
 export async function lintProject(deps: Dependencies): Promise<boolean> {
   const { projectConfig, datasource } = deps;
@@ -21,26 +23,59 @@ export async function lintProject(deps: Dependencies): Promise<boolean> {
   const availableSegmentKeys: string[] = [];
   const availableFeatureKeys: string[] = [];
 
+  function getFullPathFromKey(type: string, key: string, relative = false) {
+    const fileName = `${key}.${datasource.getExtension()}`;
+    let fullPath = "";
+
+    if (type === "attribute") {
+      fullPath = path.join(projectConfig.attributesDirectoryPath, fileName);
+    } else if (type === "segment") {
+      fullPath = path.join(projectConfig.segmentsDirectoryPath, fileName);
+    } else if (type === "feature") {
+      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 {
+      throw new Error(`Unknown type: ${type}`);
+    }
+
+    if (relative) {
+      fullPath = path.relative(process.cwd(), fullPath);
+    }
+
+    return fullPath;
+  }
+
   // lint attributes
   const attributes = await datasource.listAttributes();
   console.log(`Linting ${attributes.length} attributes...\n`);
 
-  const attributeJoiSchema = getAttributeJoiSchema();
+  const attributeZodSchema = getAttributeZodSchema();
 
   for (const key of attributes) {
+    const fullPath = getFullPathFromKey("attribute", key);
+
     try {
       const parsed = await datasource.readAttribute(key);
       availableAttributeKeys.push(key);
-      await attributeJoiSchema.validateAsync(parsed);
-    } catch (e) {
-      console.log("  =>", key);
-      console.log("");
 
-      if (e instanceof Joi.ValidationError) {
-        printJoiError(e);
-      } else {
-        console.log(e);
+      const result = attributeZodSchema.safeParse(parsed);
+
+      if (!result.success) {
+        console.log(CLI_FORMAT_UNDERLINE, fullPath);
+
+        if ("error" in result) {
+          printZodError(result.error);
+        }
+
+        hasError = true;
       }
+    } catch (e) {
+      console.log(CLI_FORMAT_UNDERLINE, fullPath);
+      console.log("");
+      console.log(e);
 
       hasError = true;
     }
@@ -50,23 +85,34 @@ export async function lintProject(deps: Dependencies): Promise<boolean> {
   const segments = await datasource.listSegments();
   console.log(`\nLinting ${segments.length} segments...\n`);
 
-  const conditionsJoiSchema = getConditionsJoiSchema(projectConfig, availableAttributeKeys);
-  const segmentJoiSchema = getSegmentJoiSchema(projectConfig, conditionsJoiSchema);
+  const conditionsZodSchema = getConditionsZodSchema(
+    projectConfig,
+    availableAttributeKeys as [string, ...string[]],
+  );
+  const segmentZodSchema = getSegmentZodSchema(projectConfig, conditionsZodSchema);
 
   for (const key of segments) {
+    const fullPath = getFullPathFromKey("segment", key);
+
     try {
       const parsed = await datasource.readSegment(key);
       availableSegmentKeys.push(key);
-      await segmentJoiSchema.validateAsync(parsed);
-    } catch (e) {
-      console.log("  =>", key);
-      console.log("");
 
-      if (e instanceof Joi.ValidationError) {
-        printJoiError(e);
-      } else {
-        console.log(e);
+      const result = segmentZodSchema.safeParse(parsed);
+
+      if (!result.success) {
+        console.log(CLI_FORMAT_UNDERLINE, fullPath);
+
+        if ("error" in result) {
+          printZodError(result.error);
+        }
+
+        hasError = true;
       }
+    } catch (e) {
+      console.log(CLI_FORMAT_UNDERLINE, fullPath);
+      console.log("");
+      console.log(e);
 
       hasError = true;
     }
@@ -76,30 +122,37 @@ export async function lintProject(deps: Dependencies): Promise<boolean> {
   const features = await datasource.listFeatures();
   console.log(`\nLinting ${features.length} features...\n`);
 
-  const featureJoiSchema = getFeatureJoiSchema(
+  const featureZodSchema = getFeatureZodSchema(
     projectConfig,
-    conditionsJoiSchema,
-    availableSegmentKeys,
-    availableFeatureKeys,
+    conditionsZodSchema,
+    availableAttributeKeys as [string, ...string[]],
+    availableSegmentKeys as [string, ...string[]],
+    features as [string, ...string[]],
   );
 
   for (const key of features) {
+    const fullPath = getFullPathFromKey("feature", key);
     let parsed;
 
     try {
       parsed = await datasource.readFeature(key);
       availableFeatureKeys.push(key);
 
-      await featureJoiSchema.validateAsync(parsed);
-    } catch (e) {
-      console.log("  =>", key);
-      console.log("");
+      const result = featureZodSchema.safeParse(parsed);
+
+      if (!result.success) {
+        console.log(CLI_FORMAT_UNDERLINE, fullPath);
+
+        if ("error" in result) {
+          printZodError(result.error);
+        }
 
-      if (e instanceof Joi.ValidationError) {
-        printJoiError(e);
-      } else {
-        console.log(e);
+        hasError = true;
       }
+    } catch (e) {
+      console.log(CLI_FORMAT_UNDERLINE, fullPath);
+      console.log("");
+      console.log(e);
 
       hasError = true;
     }
@@ -108,8 +161,8 @@ export async function lintProject(deps: Dependencies): Promise<boolean> {
       try {
         await checkForCircularDependencyInRequired(datasource, key, parsed.required);
       } catch (e) {
-        console.log("  =>", key);
-        console.log("     => Error:", e.message);
+        console.log(CLI_FORMAT_UNDERLINE, fullPath);
+        console.log(CLI_FORMAT_RED, `  => Error: ${e.message}`);
         hasError = true;
       }
     }
@@ -120,24 +173,43 @@ export async function lintProject(deps: Dependencies): Promise<boolean> {
   console.log(`\nLinting ${groups.length} groups...\n`);
 
   // @TODO: feature it slots can be from availableFeatureKeys only
-  const groupJoiSchema = getGroupJoiSchema(projectConfig, datasource, availableFeatureKeys);
+  const groupZodSchema = getGroupZodSchema(projectConfig, datasource, availableFeatureKeys);
 
   for (const key of groups) {
+    const fullPath = getFullPathFromKey("group", key);
+    let parsed;
+
     try {
-      const parsed = await datasource.readGroup(key);
-      await groupJoiSchema.validateAsync(parsed);
-    } catch (e) {
-      console.log("  =>", key);
-      console.log("");
+      parsed = await datasource.readGroup(key);
+
+      const result = groupZodSchema.safeParse(parsed);
 
-      if (e instanceof Joi.ValidationError) {
-        printJoiError(e);
-      } else {
-        console.log(e);
+      if (!result.success) {
+        console.log(CLI_FORMAT_UNDERLINE, fullPath);
+
+        if ("error" in result) {
+          printZodError(result.error);
+        }
+
+        hasError = true;
       }
+    } catch (e) {
+      console.log(CLI_FORMAT_UNDERLINE, fullPath);
+      console.log("");
+      console.log(e);
 
       hasError = true;
     }
+
+    if (parsed) {
+      try {
+        await checkForFeatureExceedingGroupSlotPercentage(datasource, parsed, availableFeatureKeys);
+      } catch (e) {
+        console.log(CLI_FORMAT_UNDERLINE, fullPath);
+        console.log(CLI_FORMAT_RED, `  => Error: ${e.message}`);
+        hasError = true;
+      }
+    }
   }
 
   // @TODO: feature cannot exist in multiple groups
@@ -146,25 +218,35 @@ export async function lintProject(deps: Dependencies): Promise<boolean> {
   const tests = await datasource.listTests();
   console.log(`\nLinting ${tests.length} tests...\n`);
 
-  const testsJoiSchema = getTestsJoiSchema(
+  const testsZodSchema = getTestsZodSchema(
     projectConfig,
-    availableFeatureKeys,
-    availableSegmentKeys,
+    availableFeatureKeys as [string, ...string[]],
+    availableSegmentKeys as [string, ...string[]],
   );
 
   for (const key of tests) {
+    const fullPath = getFullPathFromKey("test", key);
+
     try {
       const parsed = await datasource.readTest(key);
-      await testsJoiSchema.validateAsync(parsed);
-    } catch (e) {
-      console.log("  =>", key);
-      console.log("");
 
-      if (e instanceof Joi.ValidationError) {
-        printJoiError(e);
-      } else {
-        console.log(e);
+      const result = testsZodSchema.safeParse(parsed);
+
+      if (!result.success) {
+        console.log(CLI_FORMAT_UNDERLINE, fullPath);
+
+        if ("error" in result) {
+          printZodError(result.error);
+
+          process.exit(1);
+        }
+
+        hasError = true;
       }
+    } catch (e) {
+      console.log(CLI_FORMAT_UNDERLINE, fullPath);
+      console.log("");
+      console.log(e);
 
       hasError = true;
     }

package/src/linter/printError.ts

@@ -0,0 +1,21 @@
+import { ZodError } from "zod";
+
+import { CLI_FORMAT_RED } from "../tester/cliFormat";
+
+export function printZodError(e: ZodError) {
+  const { issues } = e;
+
+  issues.forEach((issue) => {
+    console.error(CLI_FORMAT_RED, `  => Error: ${issue.message}`);
+    console.error("     Path:", issue.path.join("."));
+
+    const receivedValue = (issue as any).received;
+    if (typeof receivedValue !== "undefined" && receivedValue !== "undefined") {
+      console.error("     Value:", receivedValue);
+    }
+
+    if (issues.length > 1) {
+      console.error("");
+    }
+  });
+}

package/src/linter/segmentSchema.ts

@@ -1,13 +1,15 @@
-import * as Joi from "joi";
+import { z } from "zod";
 
 import { ProjectConfig } from "../config";
 
-export function getSegmentJoiSchema(projectConfig: ProjectConfig, conditionsJoiSchema) {
-  const segmentJoiSchema = Joi.object({
-    archived: Joi.boolean().optional(),
-    description: Joi.string().required(),
-    conditions: conditionsJoiSchema.required(),
-  });
+export function getSegmentZodSchema(projectConfig: ProjectConfig, conditionsZodSchema) {
+  const segmentZodSchema = z
+    .object({
+      archived: z.boolean().optional(),
+      description: z.string(),
+      conditions: conditionsZodSchema,
+    })
+    .strict();
 
-  return segmentJoiSchema;
+  return segmentZodSchema;
 }

package/src/linter/testSchema.ts

@@ -1,62 +1,79 @@
-import * as Joi from "joi";
+import { z } from "zod";
 
 import { ProjectConfig } from "../config";
 
-export function getTestsJoiSchema(
+export function getTestsZodSchema(
   projectConfig: ProjectConfig,
-  availableFeatureKeys: string[],
-  availableSegmentKeys: string[],
+  availableFeatureKeys: [string, ...string[]],
+  availableSegmentKeys: [string, ...string[]],
 ) {
-  const segmentTestJoiSchema = Joi.object({
-    segment: Joi.string()
-      .valid(...availableSegmentKeys)
-      .required(),
-    assertions: Joi.array().items(
-      Joi.object({
-        matrix: Joi.object().optional(), // @TODO: make it stricter
-        description: Joi.string().optional(),
-        context: Joi.object(),
-        expectedToMatch: Joi.boolean(),
-      }),
-    ),
-  });
+  const segmentTestZodSchema = z
+    .object({
+      segment: z.string().refine(
+        (value) => availableSegmentKeys.includes(value),
+        (value) => ({
+          message: `Unknown segment "${value}"`,
+        }),
+      ),
+      assertions: z.array(
+        z
+          .object({
+            matrix: z.record(z.unknown()).optional(), // @TODO: make it stricter
+            description: z.string().optional(),
+            context: z.record(z.unknown()),
+            expectedToMatch: z.boolean(),
+          })
+          .strict(),
+      ),
+    })
+    .strict();
 
-  const featureTestJoiSchema = Joi.object({
-    feature: Joi.string()
-      .valid(...availableFeatureKeys)
-      .required(),
-    assertions: Joi.array().items(
-      Joi.object({
-        matrix: Joi.object().optional(), // @TODO: make it stricter
-        description: Joi.string().optional(),
-        at: Joi.alternatives().try(
-          Joi.number().precision(3).min(0).max(100).required(),
+  const featureTestZodSchema = z
+    .object({
+      feature: z.string().refine(
+        (value) => availableFeatureKeys.includes(value),
+        (value) => ({
+          message: `Unknown feature "${value}"`,
+        }),
+      ),
+      assertions: z.array(
+        z
+          .object({
+            matrix: z.record(z.unknown()).optional(), // @TODO: make it stricter
+            description: z.string().optional(),
+            at: z.union([
+              z.number().min(0).max(100),
 
-          // because of supporting matrix
-          Joi.string().required(),
-        ),
-        environment: Joi.string()
-          .custom((value, helpers) => {
-            if (value.indexOf("${{") === 0) {
-              // allow unknown strings for matrix
-              return value;
-            }
+              // because of supporting matrix
+              z.string(),
+            ]),
+            environment: z.string().refine(
+              (value) => {
+                if (value.indexOf("${{") === 0) {
+                  // allow unknown strings for matrix
+                  return true;
+                }
 
-            // otherwise only known environments should be passed
-            if (projectConfig.environments.includes(value)) {
-              return value;
-            }
+                // otherwise only known environments should be passed
+                if (projectConfig.environments.includes(value)) {
+                  return true;
+                }
 
-            return helpers.error("any.invalid");
+                return false;
+              },
+              (value) => ({
+                message: `Unknown environment "${value}"`,
+              }),
+            ),
+            context: z.record(z.unknown()),
+            expectedToBeEnabled: z.boolean(),
+            expectedVariation: z.string().optional(),
+            expectedVariables: z.record(z.unknown()).optional(),
           })
-          .required(),
-        context: Joi.object().required(),
-        expectedToBeEnabled: Joi.boolean().required(),
-        expectedVariation: Joi.alternatives().try(Joi.string(), Joi.number(), Joi.boolean()),
-        expectedVariables: Joi.object(),
-      }),
-    ),
-  });
+          .strict(),
+      ),
+    })
+    .strict();
 
-  return Joi.alternatives().try(segmentTestJoiSchema, featureTestJoiSchema);
+  return z.union([segmentTestZodSchema, featureTestZodSchema]);
 }

package/src/tester/cliFormat.ts

@@ -2,3 +2,4 @@ export const CLI_FORMAT_RED = "\x1b[31m%s\x1b[0m";
 export const CLI_FORMAT_GREEN = "\x1b[32m%s\x1b[0m";
 
 export const CLI_FORMAT_BOLD = "\x1b[1m%s\x1b[0m";
+export const CLI_FORMAT_UNDERLINE = "\x1b[4m%s\x1b[0m";

package/lib/linter/printJoiError.d.ts

@@ -1,2 +0,0 @@
-import * as Joi from "joi";
-export declare function printJoiError(e: Joi.ValidationError): void;

package/lib/linter/printJoiError.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.printJoiError = void 0;
-function printJoiError(e) {
-    var details = e.details;
-    details.forEach(function (detail) {
-        var _a;
-        console.error("     => Error:", detail.message);
-        console.error("     => Path:", detail.path.join("."));
-        console.error("     => Value:", (_a = detail.context) === null || _a === void 0 ? void 0 : _a.value);
-    });
-}
-exports.printJoiError = printJoiError;
-//# sourceMappingURL=printJoiError.js.map

package/lib/linter/printJoiError.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"printJoiError.js","sourceRoot":"","sources":["../../src/linter/printJoiError.ts"],"names":[],"mappings":";;;AAEA,SAAgB,aAAa,CAAC,CAAsB;IAC1C,IAAA,OAAO,GAAK,CAAC,QAAN,CAAO;IAEtB,OAAO,CAAC,OAAO,CAAC,UAAC,MAAM;;QACrB,OAAO,CAAC,KAAK,CAAC,gBAAgB,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;QAChD,OAAO,CAAC,KAAK,CAAC,eAAe,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QACtD,OAAO,CAAC,KAAK,CAAC,gBAAgB,EAAE,MAAA,MAAM,CAAC,OAAO,0CAAE,KAAK,CAAC,CAAC;IACzD,CAAC,CAAC,CAAC;AACL,CAAC;AARD,sCAQC"}

package/src/linter/printJoiError.ts

@@ -1,11 +0,0 @@
-import * as Joi from "joi";
-
-export function printJoiError(e: Joi.ValidationError) {
-  const { details } = e;
-
-  details.forEach((detail) => {
-    console.error("     => Error:", detail.message);
-    console.error("     => Path:", detail.path.join("."));
-    console.error("     => Value:", detail.context?.value);
-  });
-}