@featurevisor/core 1.31.0 → 1.32.0

package/src/builder/buildProject.ts

@@ -1,4 +1,5 @@
-import { SCHEMA_VERSION } from "../config";
+import { SCHEMA_VERSION, ProjectConfig } from "../config";
+import { Datasource } from "../datasource";
 
 import { getNextRevision } from "./revision";
 import { buildDatafile, getCustomDatafile } from "./buildDatafile";
@@ -19,6 +20,58 @@ export interface BuildCLIOptions {
   datafilesDir?: string;
 }
 
+async function buildForEnvironment({
+  projectConfig,
+  datasource,
+  nextRevision,
+  environment,
+  tags,
+  cliOptions,
+}: {
+  projectConfig: ProjectConfig;
+  datasource: Datasource;
+  nextRevision: string;
+  environment: string | false;
+  tags: string[];
+  cliOptions: BuildCLIOptions;
+}) {
+  console.log(`\nBuilding datafiles for environment: ${environment}`);
+
+  const existingState = await datasource.readState(environment);
+
+  for (const tag of tags) {
+    console.log(`\n  => Tag: ${tag}`);
+
+    const datafileContent = await buildDatafile(
+      projectConfig,
+      datasource,
+      {
+        schemaVersion: cliOptions.schemaVersion || SCHEMA_VERSION,
+        revision: nextRevision,
+        environment: environment,
+        tag: tag,
+        inflate: cliOptions.inflate,
+      },
+      existingState,
+    );
+
+    // write datafile for environment/tag
+    await datasource.writeDatafile(datafileContent, {
+      environment,
+      tag,
+      datafilesDir: cliOptions.datafilesDir,
+    });
+  }
+
+  if (typeof cliOptions.stateFiles === "undefined" || cliOptions.stateFiles) {
+    // write state for environment
+    await datasource.writeState(environment, existingState);
+
+    // write revision
+    await datasource.writeRevision(nextRevision);
+  }
+}
+
 export async function buildProject(deps: Dependencies, cliOptions: BuildCLIOptions = {}) {
   const { projectConfig, datasource } = deps;
 
@@ -63,42 +116,30 @@ export async function buildProject(deps: Dependencies, cliOptions: BuildCLIOptio
   const nextRevision =
     (cliOptions.revision && cliOptions.revision.toString()) || getNextRevision(currentRevision);
 
-  for (const environment of environments) {
-    console.log(`\nBuilding datafiles for environment: ${environment}`);
-
-    const existingState = await datasource.readState(environment);
-
-    for (const tag of tags) {
-      console.log(`\n  => Tag: ${tag}`);
-
-      const datafileContent = await buildDatafile(
+  // with environments
+  if (Array.isArray(environments)) {
+    for (const environment of environments) {
+      await buildForEnvironment({
         projectConfig,
         datasource,
-        {
-          schemaVersion: cliOptions.schemaVersion || SCHEMA_VERSION,
-          revision: nextRevision,
-          environment: environment,
-          tag: tag,
-          inflate: cliOptions.inflate,
-        },
-        existingState,
-      );
-
-      // write datafile for environment/tag
-      await datasource.writeDatafile(datafileContent, {
+        nextRevision,
         environment,
-        tag,
-        datafilesDir: cliOptions.datafilesDir,
+        tags,
+        cliOptions,
       });
     }
+  }
 
-    if (typeof cliOptions.stateFiles === "undefined" || cliOptions.stateFiles) {
-      // write state for environment
-      await datasource.writeState(environment, existingState);
-
-      // write revision
-      await datasource.writeRevision(nextRevision);
-    }
+  // no environment
+  if (environments === false) {
+    await buildForEnvironment({
+      projectConfig,
+      datasource,
+      nextRevision,
+      environment: false,
+      tags,
+      cliOptions,
+    });
   }
 
   console.log("\nLatest revision:", nextRevision);

package/src/config/projectConfig.ts

@@ -39,7 +39,7 @@ export interface ProjectConfig {
   outputDirectoryPath: string;
   siteExportDirectoryPath: string;
 
-  environments: string[];
+  environments: string[] | false;
   tags: string[];
 
   adapter: any; // @TODO: type this properly later

package/src/datasource/adapter.ts

@@ -9,7 +9,7 @@ import {
 } from "@featurevisor/types";
 
 export interface DatafileOptions {
-  environment: EnvironmentKey;
+  environment: EnvironmentKey | false;
   tag: string;
   datafilesDir?: string;
 }
@@ -23,8 +23,11 @@ export abstract class Adapter {
   abstract deleteEntity(entityType: EntityType, entityKey: string): Promise<void>;
 
   // state
-  abstract readState(environment: EnvironmentKey): Promise<ExistingState>;
-  abstract writeState(environment: EnvironmentKey, existingState: ExistingState): Promise<void>;
+  abstract readState(environment: EnvironmentKey | false): Promise<ExistingState>;
+  abstract writeState(
+    environment: EnvironmentKey | false,
+    existingState: ExistingState,
+  ): Promise<void>;
 
   // datafile
   abstract readDatafile(options: DatafileOptions): Promise<DatafileContent>;

package/src/datasource/datasource.ts

@@ -35,11 +35,11 @@ export class Datasource {
   /**
    * State
    */
-  readState(environment: EnvironmentKey): Promise<ExistingState> {
+  readState(environment: EnvironmentKey | false): Promise<ExistingState> {
     return this.adapter.readState(environment);
   }
 
-  writeState(environment: EnvironmentKey, existingState: ExistingState) {
+  writeState(environment: EnvironmentKey | false, existingState: ExistingState) {
     return this.adapter.writeState(environment, existingState);
   }
 

package/src/datasource/filesystemAdapter.ts

@@ -23,9 +23,11 @@ const commitRegex = /^commit (\w+)\nAuthor: (.+) <(.+)>\nDate:   (.+)\n\n(.+)/gm
 
 export function getExistingStateFilePath(
   projectConfig: ProjectConfig,
-  environment: EnvironmentKey,
+  environment: EnvironmentKey | false,
 ): string {
-  return path.join(projectConfig.stateDirectoryPath, `existing-state-${environment}.json`);
+  const fileName = environment ? `existing-state-${environment}.json` : `existing-state.json`;
+
+  return path.join(projectConfig.stateDirectoryPath, fileName);
 }
 
 export function getRevisionFilePath(projectConfig: ProjectConfig): string {
@@ -185,7 +187,11 @@ export class FilesystemAdapter extends Adapter {
     const fileName = `datafile-tag-${options.tag}.json`;
     const dir = options.datafilesDir || this.config.outputDirectoryPath;
 
-    return path.join(dir, options.environment, fileName);
+    if (options.environment) {
+      return path.join(dir, options.environment, fileName);
+    }
+
+    return path.join(dir, fileName);
   }
 
   async readDatafile(options: DatafileOptions): Promise<DatafileContent> {
@@ -199,7 +205,9 @@ export class FilesystemAdapter extends Adapter {
   async writeDatafile(datafileContent: DatafileContent, options: DatafileOptions): Promise<void> {
     const dir = options.datafilesDir || this.config.outputDirectoryPath;
 
-    const outputEnvironmentDirPath = path.join(dir, options.environment);
+    const outputEnvironmentDirPath = options.environment
+      ? path.join(dir, options.environment)
+      : dir;
     mkdirp.sync(outputEnvironmentDirPath);
 
     const outputFilePath = this.getDatafilePath(options);

package/src/evaluate/index.ts

@@ -50,7 +50,7 @@ function printHeader(message: string) {
 }
 
 export interface EvaluateOptions {
-  environment: string;
+  environment?: string;
   feature: string;
   context: Record<string, unknown>;
   print?: boolean;
@@ -69,14 +69,14 @@ export interface Log {
 export async function evaluateFeature(deps: Dependencies, options: EvaluateOptions) {
   const { datasource, projectConfig } = deps;
 
-  const existingState = await datasource.readState(options.environment);
+  const existingState = await datasource.readState(options.environment || false);
   const datafileContent = await buildDatafile(
     projectConfig,
     datasource,
     {
       schemaVersion: options.schemaVersion || SCHEMA_VERSION,
       revision: "include-all-features",
-      environment: options.environment,
+      environment: options.environment || false,
       inflate: options.inflate,
     },
     existingState,

package/src/find-usage/index.ts

@@ -52,34 +52,70 @@ export async function findAllUsageInFeatures(deps: Dependencies): Promise<UsageI
     }
 
     // variable overrides inside variations
-    projectConfig.environments.forEach((environment) => {
-      if (feature.variations) {
-        feature.variations.forEach((variation) => {
-          if (variation.variables) {
-            variation.variables.forEach((variable) => {
-              if (variable.overrides) {
-                variable.overrides.forEach((override) => {
-                  if (override.segments) {
-                    extractSegmentKeysFromGroupSegments(override.segments).forEach((segmentKey) =>
-                      usageInFeatures[featureKey].segments.add(segmentKey),
-                    );
-                  }
-
-                  if (override.conditions) {
-                    extractAttributeKeysFromConditions(override.conditions).forEach(
-                      (attributeKey) => usageInFeatures[featureKey].attributes.add(attributeKey),
-                    );
-                  }
-                });
-              }
-            });
-          }
-        });
-      }
+    if (feature.variations) {
+      feature.variations.forEach((variation) => {
+        if (variation.variables) {
+          variation.variables.forEach((variable) => {
+            if (variable.overrides) {
+              variable.overrides.forEach((override) => {
+                if (override.segments) {
+                  extractSegmentKeysFromGroupSegments(override.segments).forEach((segmentKey) =>
+                    usageInFeatures[featureKey].segments.add(segmentKey),
+                  );
+                }
+
+                if (override.conditions) {
+                  extractAttributeKeysFromConditions(override.conditions).forEach((attributeKey) =>
+                    usageInFeatures[featureKey].attributes.add(attributeKey),
+                  );
+                }
+              });
+            }
+          });
+        }
+      });
+    }
+
+    // with environments
+    if (Array.isArray(projectConfig.environments)) {
+      projectConfig.environments.forEach((environment) => {
+        if (!feature.environments) {
+          return;
+        }
+
+        // force
+        if (feature.environments[environment].force) {
+          feature.environments[environment].force?.forEach((force) => {
+            if (force.segments) {
+              extractSegmentKeysFromGroupSegments(force.segments).forEach((segmentKey) =>
+                usageInFeatures[featureKey].segments.add(segmentKey),
+              );
+            }
+
+            if (force.conditions) {
+              extractAttributeKeysFromConditions(force.conditions).forEach((attributeKey) =>
+                usageInFeatures[featureKey].attributes.add(attributeKey),
+              );
+            }
+          });
+        }
 
+        // rules
+        if (feature.environments[environment].rules) {
+          feature.environments[environment].rules?.forEach((rule) => {
+            extractSegmentKeysFromGroupSegments(rule.segments).forEach((segmentKey) =>
+              usageInFeatures[featureKey].segments.add(segmentKey),
+            );
+          });
+        }
+      });
+    }
+
+    // no environments
+    if (projectConfig.environments === false) {
       // force
-      if (feature.environments[environment].force) {
-        feature.environments[environment].force?.forEach((force) => {
+      if (feature.force) {
+        feature.force.forEach((force) => {
           if (force.segments) {
             extractSegmentKeysFromGroupSegments(force.segments).forEach((segmentKey) =>
               usageInFeatures[featureKey].segments.add(segmentKey),
@@ -95,14 +131,14 @@ export async function findAllUsageInFeatures(deps: Dependencies): Promise<UsageI
       }
 
       // rules
-      if (feature.environments[environment].rules) {
-        feature.environments[environment].rules?.forEach((rule) => {
+      if (feature.rules) {
+        feature.rules.forEach((rule) => {
           extractSegmentKeysFromGroupSegments(rule.segments).forEach((segmentKey) =>
             usageInFeatures[featureKey].segments.add(segmentKey),
           );
         });
       }
-    });
+    }
   }
 
   return usageInFeatures;

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(),