@featurevisor/core 1.30.1 → 1.32.0

package/src/linter/featureSchema.ts

@@ -227,93 +227,102 @@ export function getFeatureZodSchema(
 
   const groupSegmentsZodSchema = z.union([z.array(groupSegmentZodSchema), groupSegmentZodSchema]);
 
-  const environmentZodSchema = z
-    .object({
-      expose: z
-        .union([
-          z.boolean(),
-          z.array(z.string().refine((value) => projectConfig.tags.includes(value))),
-        ])
-        .optional(),
-      rules: z
-        .array(
-          z
-            .object({
-              key: z.string(),
-              description: z.string().optional(),
-              segments: groupSegmentsZodSchema,
-              percentage: z.number().min(0).max(100),
-
-              enabled: z.boolean().optional(),
-              variation: variationValueZodSchema.optional(),
-              variables: z.record(variableValueZodSchema).optional(),
-            })
-            .strict(),
-        )
-
-        // must have at least one rule
-        .refine(
-          (value) => value.length > 0,
-          () => ({
-            message: "Must have at least one rule",
-          }),
-        )
+  const exposeSchema = z
+    .union([z.boolean(), z.array(z.string().refine((value) => projectConfig.tags.includes(value)))])
+    .optional();
+
+  const rulesSchema = z
+    .array(
+      z
+        .object({
+          key: z.string(),
+          description: z.string().optional(),
+          segments: groupSegmentsZodSchema,
+          percentage: z.number().min(0).max(100),
+
+          enabled: z.boolean().optional(),
+          variation: variationValueZodSchema.optional(),
+          variables: z.record(variableValueZodSchema).optional(),
+        })
+        .strict(),
+    )
+
+    // must have at least one rule
+    .refine(
+      (value) => value.length > 0,
+      () => ({
+        message: "Must have at least one rule",
+      }),
+    )
+
+    // duplicate rules
+    .refine(
+      (value) => {
+        const keys = value.map((v) => v.key);
+        return keys.length === new Set(keys).size;
+      },
+      (value) => ({
+        message: "Duplicate rule keys found: " + value.map((v) => v.key).join(", "),
+      }),
+    )
 
-        // duplicate rules
-        .refine(
-          (value) => {
-            const keys = value.map((v) => v.key);
-            return keys.length === new Set(keys).size;
-          },
-          (value) => ({
-            message: "Duplicate rule keys found: " + value.map((v) => v.key).join(", "),
-          }),
-        )
+    // enforce catch-all rule
+    .refine(
+      (value) => {
+        if (!projectConfig.enforceCatchAllRule) {
+          return true;
+        }
 
-        // enforce catch-all rule
-        .refine(
-          (value) => {
-            if (!projectConfig.enforceCatchAllRule) {
-              return true;
-            }
+        const hasCatchAllAsLastRule = value[value.length - 1].segments === "*";
+        return hasCatchAllAsLastRule;
+      },
+      () => ({
+        message: `Missing catch-all rule with \`segments: "*"\` at the end`,
+      }),
+    );
+
+  const forceSchema = z
+    .array(
+      z.union([
+        z
+          .object({
+            segments: groupSegmentsZodSchema,
+            enabled: z.boolean().optional(),
+            variation: variationValueZodSchema.optional(),
+            variables: z.record(variableValueZodSchema).optional(),
+          })
+          .strict(),
+        z
+          .object({
+            conditions: conditionsZodSchema,
+            enabled: z.boolean().optional(),
+            variation: variationValueZodSchema.optional(),
+            variables: z.record(variableValueZodSchema).optional(),
+          })
+          .strict(),
+      ]),
+    )
+    .optional();
 
-            const hasCatchAllAsLastRule = value[value.length - 1].segments === "*";
-            return hasCatchAllAsLastRule;
-          },
-          () => ({
-            message: `Missing catch-all rule with \`segments: "*"\` at the end`,
-          }),
-        ),
-      force: z
-        .array(
-          z.union([
-            z
-              .object({
-                segments: groupSegmentsZodSchema,
-                enabled: z.boolean().optional(),
-                variation: variationValueZodSchema.optional(),
-                variables: z.record(variableValueZodSchema).optional(),
-              })
-              .strict(),
-            z
-              .object({
-                conditions: conditionsZodSchema,
-                enabled: z.boolean().optional(),
-                variation: variationValueZodSchema.optional(),
-                variables: z.record(variableValueZodSchema).optional(),
-              })
-              .strict(),
-          ]),
-        )
-        .optional(),
+  const environmentZodSchema = z
+    .object({
+      expose: exposeSchema,
+      rules: rulesSchema,
+      force: forceSchema,
     })
     .strict();
 
-  const allEnvironmentsSchema = {};
-  projectConfig.environments.forEach((environmentKey) => {
-    allEnvironmentsSchema[environmentKey] = environmentZodSchema;
-  });
-  const allEnvironmentsZodSchema = z.object(allEnvironmentsSchema).strict();
+  let allEnvironmentsZodSchema: z.ZodTypeAny = z.never();
+
+  if (Array.isArray(projectConfig.environments)) {
+    const allEnvironmentsSchema = {};
+
+    projectConfig.environments.forEach((environmentKey) => {
+      allEnvironmentsSchema[environmentKey] = environmentZodSchema;
+    });
+
+    allEnvironmentsZodSchema = z.object(allEnvironmentsSchema).strict();
+  }
 
   const attributeKeyZodSchema = z.string().refine(
     (value) => value === "*" || availableAttributeKeys.includes(value),
@@ -447,7 +456,16 @@ export function getFeatureZodSchema(
           }),
         )
         .optional(),
-      environments: allEnvironmentsZodSchema,
+
+      // with environments
+      environments: Array.isArray(projectConfig.environments)
+        ? allEnvironmentsZodSchema
+        : z.never().optional(),
+
+      // no environments
+      expose: projectConfig.environments === false ? exposeSchema : z.never().optional(),
+      rules: projectConfig.environments === false ? rulesSchema : z.never().optional(),
+      force: projectConfig.environments === false ? forceSchema : z.never().optional(),
     })
     .strict()
     .superRefine((value, ctx) => {

package/src/linter/testSchema.ts

@@ -59,24 +59,29 @@ export function getTestsZodSchema(
               // because of supporting matrix
               z.string(),
             ]),
-            environment: z.string().refine(
-              (value) => {
-                if (value.indexOf("${{") === 0) {
-                  // allow unknown strings for matrix
-                  return true;
-                }
+            environment: Array.isArray(projectConfig.environments)
+              ? 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 true;
-                }
+                    // otherwise only known environments should be passed
+                    if (
+                      Array.isArray(projectConfig.environments) &&
+                      projectConfig.environments.includes(value)
+                    ) {
+                      return true;
+                    }
 
-                return false;
-              },
-              (value) => ({
-                message: `Unknown environment "${value}"`,
-              }),
-            ),
+                    return false;
+                  },
+                  (value) => ({
+                    message: `Unknown environment "${value}"`,
+                  }),
+                )
+              : z.never().optional(),
             context: z.record(z.unknown()),
             expectedToBeEnabled: z.boolean(),
             expectedVariation: z.string().optional(),

package/src/site/generateSiteSearchIndex.ts

@@ -23,6 +23,10 @@ export async function generateSiteSearchIndex(
 
   const result: SearchIndex = {
     links: undefined,
+    projectConfig: {
+      tags: projectConfig.tags,
+      environments: projectConfig.environments,
+    },
     entities: {
       attributes: [],
       segments: [],
@@ -115,10 +119,52 @@ export async function generateSiteSearchIndex(
       });
     }
 
-    Object.keys(parsed.environments).forEach((environmentKey) => {
-      const env = parsed.environments[environmentKey];
+    // with environments
+    if (parsed.environments) {
+      Object.keys(parsed.environments).forEach((environmentKey) => {
+        const env = parsed.environments[environmentKey];
+
+        env.rules.forEach((rule) => {
+          if (rule.segments && rule.segments !== "*") {
+            extractSegmentKeysFromGroupSegments(rule.segments).forEach((segmentKey) => {
+              if (!segmentsUsedInFeatures[segmentKey]) {
+                segmentsUsedInFeatures[segmentKey] = new Set();
+              }
+
+              segmentsUsedInFeatures[segmentKey].add(entityName);
+            });
+          }
+        });
+
+        if (env.force) {
+          env.force.forEach((force) => {
+            if (force.segments && force.segments !== "*") {
+              extractSegmentKeysFromGroupSegments(force.segments).forEach((segmentKey) => {
+                if (!segmentsUsedInFeatures[segmentKey]) {
+                  segmentsUsedInFeatures[segmentKey] = new Set();
+                }
 
-      env.rules.forEach((rule) => {
+                segmentsUsedInFeatures[segmentKey].add(entityName);
+              });
+            }
+
+            if (force.conditions) {
+              extractAttributeKeysFromConditions(force.conditions).forEach((attributeKey) => {
+                if (!attributesUsedInFeatures[attributeKey]) {
+                  attributesUsedInFeatures[attributeKey] = new Set();
+                }
+
+                attributesUsedInFeatures[attributeKey].add(entityName);
+              });
+            }
+          });
+        }
+      });
+    }
+
+    // no environments
+    if (parsed.rules) {
+      parsed.rules.forEach((rule) => {
         if (rule.segments && rule.segments !== "*") {
           extractSegmentKeysFromGroupSegments(rule.segments).forEach((segmentKey) => {
             if (!segmentsUsedInFeatures[segmentKey]) {
@@ -129,32 +175,33 @@ export async function generateSiteSearchIndex(
           });
         }
       });
+    }
 
-      if (env.force) {
-        env.force.forEach((force) => {
-          if (force.segments && force.segments !== "*") {
-            extractSegmentKeysFromGroupSegments(force.segments).forEach((segmentKey) => {
-              if (!segmentsUsedInFeatures[segmentKey]) {
-                segmentsUsedInFeatures[segmentKey] = new Set();
-              }
+    if (parsed.force) {
+      parsed.force.forEach((force) => {
+        if (force.segments && force.segments !== "*") {
+          extractSegmentKeysFromGroupSegments(force.segments).forEach((segmentKey) => {
+            if (!segmentsUsedInFeatures[segmentKey]) {
+              segmentsUsedInFeatures[segmentKey] = new Set();
+            }
 
-              segmentsUsedInFeatures[segmentKey].add(entityName);
-            });
-          }
+            segmentsUsedInFeatures[segmentKey].add(entityName);
+          });
+        }
 
-          if (force.conditions) {
-            extractAttributeKeysFromConditions(force.conditions).forEach((attributeKey) => {
-              if (!attributesUsedInFeatures[attributeKey]) {
-                attributesUsedInFeatures[attributeKey] = new Set();
-              }
+        if (force.conditions) {
+          extractAttributeKeysFromConditions(force.conditions).forEach((attributeKey) => {
+            if (!attributesUsedInFeatures[attributeKey]) {
+              attributesUsedInFeatures[attributeKey] = new Set();
+            }
 
-              attributesUsedInFeatures[attributeKey].add(entityName);
-            });
-          }
-        });
-      }
-    });
+            attributesUsedInFeatures[attributeKey].add(entityName);
+          });
+        }
+      });
+    }
 
+    // push
     result.entities.features.push({
       ...parsed,
       key: entityName,

package/src/tester/matrix.ts

@@ -105,7 +105,7 @@ export function getFeatureAssertionsFromMatrix(
 ): FeatureAssertion[] {
   if (!assertionWithMatrix.matrix) {
     const assertion = { ...assertionWithMatrix };
-    assertion.description = `Assertion #${aIndex + 1}: (${assertion.environment}) ${
+    assertion.description = `Assertion #${aIndex + 1}:${assertion.environment ? ` (${assertion.environment})` : ""} ${
       assertion.description || `at ${assertion.at}%`
     }`;
 
@@ -118,7 +118,7 @@ export function getFeatureAssertionsFromMatrix(
   for (let cIndex = 0; cIndex < combinations.length; cIndex++) {
     const combination = combinations[cIndex];
     const assertion = applyCombinationToFeatureAssertion(combination, assertionWithMatrix);
-    assertion.description = `Assertion #${aIndex + 1}: (${assertion.environment}) ${
+    assertion.description = `Assertion #${aIndex + 1}:${assertion.environment ? ` (${assertion.environment})` : ""} ${
       assertion.description || `at ${assertion.at}%`
     }`;
 

package/src/tester/testFeature.ts

@@ -13,6 +13,7 @@ import { ProjectConfig } from "../config";
 import { checkIfArraysAreEqual } from "./checkIfArraysAreEqual";
 import { checkIfObjectsAreEqual } from "./checkIfObjectsAreEqual";
 import { getFeatureAssertionsFromMatrix } from "./matrix";
+import type { DatafileContentByEnvironment } from "./testProject";
 
 export async function testFeature(
   datasource: Datasource,
@@ -20,7 +21,7 @@ export async function testFeature(
   test: TestFeature,
   options: { verbose?: boolean; showDatafile?: boolean } = {},
   patterns,
-  datafileContentByEnvironment: { [environment: string]: DatafileContent } = {},
+  datafileContentByEnvironment: DatafileContentByEnvironment,
 ): Promise<TestResult> {
   const testStartTime = Date.now();
   const featureKey = test.feature;
@@ -54,7 +55,7 @@ export async function testFeature(
         continue;
       }
 
-      const datafileContent = datafileContentByEnvironment[assertion.environment];
+      const datafileContent = datafileContentByEnvironment.get(assertion.environment || false);
 
       if (options.showDatafile) {
         console.log("");

package/src/tester/testProject.ts

@@ -36,9 +36,7 @@ export interface ExecutionResult {
   };
 }
 
-export interface DatafileContentByEnvironment {
-  [environment: string]: DatafileContent;
-}
+export type DatafileContentByEnvironment = Map<string | false, DatafileContent>;
 
 export async function executeTest(
   testFile: string,
@@ -151,23 +149,44 @@ export async function testProject(
   let passedAssertionsCount = 0;
   let failedAssertionsCount = 0;
 
-  const datafileContentByEnvironment: DatafileContentByEnvironment = {};
+  const datafileContentByEnvironment: DatafileContentByEnvironment = new Map();
+
+  // with environments
+  if (Array.isArray(projectConfig.environments)) {
+    for (const environment of projectConfig.environments) {
+      const existingState = await datasource.readState(environment);
+      const datafileContent = await buildDatafile(
+        projectConfig,
+        datasource,
+        {
+          schemaVersion: options.schemaVersion || SCHEMA_VERSION,
+          revision: "include-all-features",
+          environment: environment,
+          inflate: options.inflate,
+        },
+        existingState,
+      );
+
+      datafileContentByEnvironment.set(environment, datafileContent);
+    }
+  }
 
-  for (const environment of projectConfig.environments) {
-    const existingState = await datasource.readState(environment);
+  // no environments
+  if (projectConfig.environments === false) {
+    const existingState = await datasource.readState(false);
     const datafileContent = await buildDatafile(
       projectConfig,
       datasource,
       {
         schemaVersion: options.schemaVersion || SCHEMA_VERSION,
         revision: "include-all-features",
-        environment: environment,
+        environment: false,
         inflate: options.inflate,
       },
       existingState,
     );
 
-    datafileContentByEnvironment[environment] = datafileContent;
+    datafileContentByEnvironment.set(false, datafileContent);
   }
 
   for (const testFile of testFiles) {