@featurevisor/core 2.26.1 → 3.0.1

package/src/config/projectConfig.ts

@@ -1,64 +1,62 @@
 import * as path from "path";
 
-import type { BucketBy, Context, Tag } from "@featurevisor/types";
+import type { BucketBy } from "@featurevisor/types";
 import { Parser, parsers } from "@featurevisor/parsers";
 
 import { FilesystemAdapter } from "../datasource/filesystemAdapter";
 import type { Plugin } from "../cli";
-import type { BuildTags } from "../builder/buildDatafile";
+import { CLI_COLOR_CYAN, CLI_FORMAT_BOLD, colorize } from "../tester/cliFormat";
 
 export const FEATURES_DIRECTORY_NAME = "features";
 export const SEGMENTS_DIRECTORY_NAME = "segments";
 export const ATTRIBUTES_DIRECTORY_NAME = "attributes";
 export const GROUPS_DIRECTORY_NAME = "groups";
 export const SCHEMAS_DIRECTORY_NAME = "schemas";
+export const TARGETS_DIRECTORY_NAME = "targets";
 export const TESTS_DIRECTORY_NAME = "tests";
 export const STATE_DIRECTORY_NAME = ".featurevisor";
 export const DATAFILES_DIRECTORY_NAME = "datafiles";
 export const DATAFILE_NAME_PATTERN = "featurevisor-%s.json";
 export const REVISION_FILE_NAME = "REVISION";
-export const SITE_EXPORT_DIRECTORY_NAME = "out";
-export const ENVIRONMENTS_DIRECTORY_NAME = "environments";
+export const CATALOG_DIRECTORY_NAME = "catalog";
+export const SETS_DIRECTORY_NAME = "sets";
 
 export const CONFIG_MODULE_NAME = "featurevisor.config.js";
 export const ROOT_DIR_PLACEHOLDER = "<rootDir>";
 
-export const DEFAULT_ENVIRONMENTS = ["staging", "production"];
+export const DEFAULT_NAMESPACE_CHARACTER = ".";
 export const DEFAULT_TAGS = ["all"];
 export const DEFAULT_BUCKET_BY_ATTRIBUTE = "userId";
+export const DEFAULT_SETS = false;
 
 export const DEFAULT_PRETTY_STATE = true;
 export const DEFAULT_PRETTY_DATAFILE = false;
 
 export const DEFAULT_PARSER: Parser = "yml";
 
-export const SCHEMA_VERSION = "2"; // default schema version
-
-export interface Scope {
-  name: string;
-  context: Context;
-  tag?: Tag;
-  tags?: BuildTags;
-}
-
 export interface ProjectConfig {
+  promotionFlows?: Array<{
+    from: string;
+    to: string;
+  }>;
+  namespaceCharacter: string;
   featuresDirectoryPath: string;
   segmentsDirectoryPath: string;
   attributesDirectoryPath: string;
   groupsDirectoryPath: string;
   schemasDirectoryPath: string;
+  targetsDirectoryPath: string;
   testsDirectoryPath: string;
   stateDirectoryPath: string;
   datafilesDirectoryPath: string;
   datafileNamePattern: string;
   revisionFileName: string;
-  siteExportDirectoryPath: string;
-  environmentsDirectoryPath: string;
+  catalogDirectoryPath: string;
+  setsDirectoryPath: string;
 
-  environments: string[] | false;
-  splitByEnvironment: boolean;
+  environments?: string[];
+  sets: boolean;
   tags: string[];
-  scopes?: Scope[];
 
   adapter: any; // @NOTE: type this properly later
   plugins: Plugin[];
@@ -80,9 +78,11 @@ export interface ProjectConfig {
 // rootDirectoryPath: path to the root directory of the project (without ending with a slash)
 export function getProjectConfig(rootDirectoryPath: string): ProjectConfig {
   const baseConfig: ProjectConfig = {
-    environments: DEFAULT_ENVIRONMENTS,
+    environments: undefined,
+    sets: DEFAULT_SETS,
+    promotionFlows: undefined,
+    namespaceCharacter: DEFAULT_NAMESPACE_CHARACTER,
     tags: DEFAULT_TAGS,
-    scopes: [],
     defaultBucketBy: "userId",
 
     parser: DEFAULT_PARSER,
@@ -94,21 +94,21 @@ export function getProjectConfig(rootDirectoryPath: string): ProjectConfig {
     adapter: FilesystemAdapter,
 
     featuresDirectoryPath: path.join(rootDirectoryPath, FEATURES_DIRECTORY_NAME),
-    environmentsDirectoryPath: path.join(rootDirectoryPath, ENVIRONMENTS_DIRECTORY_NAME),
+    setsDirectoryPath: path.join(rootDirectoryPath, SETS_DIRECTORY_NAME),
     segmentsDirectoryPath: path.join(rootDirectoryPath, SEGMENTS_DIRECTORY_NAME),
     attributesDirectoryPath: path.join(rootDirectoryPath, ATTRIBUTES_DIRECTORY_NAME),
     groupsDirectoryPath: path.join(rootDirectoryPath, GROUPS_DIRECTORY_NAME),
     schemasDirectoryPath: path.join(rootDirectoryPath, SCHEMAS_DIRECTORY_NAME),
+    targetsDirectoryPath: path.join(rootDirectoryPath, TARGETS_DIRECTORY_NAME),
     testsDirectoryPath: path.join(rootDirectoryPath, TESTS_DIRECTORY_NAME),
     stateDirectoryPath: path.join(rootDirectoryPath, STATE_DIRECTORY_NAME),
     datafilesDirectoryPath: path.join(rootDirectoryPath, DATAFILES_DIRECTORY_NAME),
     datafileNamePattern: DATAFILE_NAME_PATTERN,
     revisionFileName: REVISION_FILE_NAME,
-    siteExportDirectoryPath: path.join(rootDirectoryPath, SITE_EXPORT_DIRECTORY_NAME),
+    catalogDirectoryPath: path.join(rootDirectoryPath, CATALOG_DIRECTORY_NAME),
 
     enforceCatchAllRule: false,
     plugins: [],
-    splitByEnvironment: false,
 
     maxVariableStringLength: undefined,
     maxVariableArrayStringifiedLength: undefined,
@@ -141,15 +141,83 @@ export function getProjectConfig(rootDirectoryPath: string): ProjectConfig {
     finalConfig.parser = parsers[finalConfig.parser];
   }
 
-  if (finalConfig.splitByEnvironment && finalConfig.environments === false) {
+  if (typeof finalConfig.sets !== "boolean") {
+    throw new Error(`Invalid sets: ${finalConfig.sets}. It must be a boolean.`);
+  }
+
+  if (typeof finalConfig.environments !== "undefined") {
+    if (!Array.isArray(finalConfig.environments)) {
+      throw new Error(
+        `Invalid environments: ${finalConfig.environments}. It must be an array of strings when defined.`,
+      );
+    }
+
+    finalConfig.environments.forEach((environment: unknown, index: number) => {
+      if (typeof environment !== "string") {
+        throw new Error(`Invalid environments[${index}]: ${environment}. It must be a string.`);
+      }
+    });
+  }
+
+  if (
+    typeof finalConfig.namespaceCharacter !== "string" ||
+    finalConfig.namespaceCharacter.length === 0
+  ) {
     throw new Error(
-      "Invalid configuration: splitByEnvironment=true requires environments to be an array",
+      `Invalid namespaceCharacter: ${finalConfig.namespaceCharacter}. It must be a non-empty string.`,
     );
   }
 
+  if (typeof finalConfig.promotionFlows !== "undefined") {
+    if (!Array.isArray(finalConfig.promotionFlows)) {
+      throw new Error(
+        `Invalid promotionFlows: ${finalConfig.promotionFlows}. It must be an array.`,
+      );
+    }
+
+    finalConfig.promotionFlows.forEach((entry: any, index: number) => {
+      if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+        throw new Error(
+          `Invalid promotionFlows[${index}]: ${entry}. Each entry must be an object with exactly "from" and "to" string fields.`,
+        );
+      }
+
+      const keys = Object.keys(entry).sort();
+
+      if (keys.length !== 2 || keys[0] !== "from" || keys[1] !== "to") {
+        throw new Error(
+          `Invalid promotionFlows[${index}]: ${JSON.stringify(entry)}. Each entry must contain exactly "from" and "to".`,
+        );
+      }
+
+      if (typeof entry.from !== "string" || typeof entry.to !== "string") {
+        throw new Error(
+          `Invalid promotionFlows[${index}]: ${JSON.stringify(entry)}. "from" and "to" must be strings.`,
+        );
+      }
+    });
+  }
+
   return finalConfig as ProjectConfig;
 }
 
+export function getProjectConfigForSet(projectConfig: ProjectConfig, set: string): ProjectConfig {
+  const setRootDirectoryPath = path.join(projectConfig.setsDirectoryPath, set);
+
+  return {
+    ...projectConfig,
+    featuresDirectoryPath: path.join(setRootDirectoryPath, FEATURES_DIRECTORY_NAME),
+    segmentsDirectoryPath: path.join(setRootDirectoryPath, SEGMENTS_DIRECTORY_NAME),
+    attributesDirectoryPath: path.join(setRootDirectoryPath, ATTRIBUTES_DIRECTORY_NAME),
+    groupsDirectoryPath: path.join(setRootDirectoryPath, GROUPS_DIRECTORY_NAME),
+    schemasDirectoryPath: path.join(setRootDirectoryPath, SCHEMAS_DIRECTORY_NAME),
+    targetsDirectoryPath: path.join(setRootDirectoryPath, TARGETS_DIRECTORY_NAME),
+    testsDirectoryPath: path.join(setRootDirectoryPath, TESTS_DIRECTORY_NAME),
+    stateDirectoryPath: path.join(projectConfig.stateDirectoryPath, SETS_DIRECTORY_NAME, set),
+    datafilesDirectoryPath: path.join(projectConfig.datafilesDirectoryPath, set),
+  };
+}
+
 export interface ShowProjectConfigOptions {
   json?: boolean;
   pretty?: boolean;
@@ -167,7 +235,9 @@ export function showProjectConfig(
     return;
   }
 
-  console.log("\nProject configuration:\n");
+  console.log("");
+  console.log(CLI_FORMAT_BOLD, "Project configuration");
+  console.log("");
 
   const keys = Object.keys(projectConfig);
   const longestKeyLength = keys.reduce((acc, key) => (key.length > acc ? key.length : acc), 0);
@@ -178,7 +248,9 @@ export function showProjectConfig(
       continue;
     }
 
-    console.log(`  - ${key.padEnd(longestKeyLength, " ")}: ${projectConfig[key]}`);
+    console.log(
+      `  ${colorize(key.padEnd(longestKeyLength, " "), CLI_COLOR_CYAN)}: ${projectConfig[key]}`,
+    );
   }
 }
 

package/src/datasource/adapter.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 import type {
   DatafileContent,
   EnvironmentKey,
@@ -9,23 +8,21 @@ import type {
   EntityType,
 } from "@featurevisor/types";
 
-import type { Scope } from "../config";
-
 export interface DatafileOptions {
   environment: EnvironmentKey | false;
-  tag?: string;
-  scope?: Scope;
+  target?: string;
   datafilesDir?: string;
 }
 
-export type FeatureEnvironmentProperty = "rules" | "force" | "expose";
-
-export interface FeatureSourcePaths {
-  baseFilePath: string;
-  environmentFilePaths: Record<string, string>;
+export interface DatafileFile {
+  path: string;
+  size: number;
+  gzipSize: number;
 }
 
 export abstract class Adapter {
+  abstract listSets(): Promise<string[]>;
+
   // entities
   abstract listEntities(entityType: EntityType): Promise<string[]>;
   abstract entityExists(entityType: EntityType, entityKey: string): Promise<boolean>;
@@ -41,6 +38,7 @@ export abstract class Adapter {
   ): Promise<void>;
 
   // datafile
+  listDatafiles?(): Promise<DatafileFile[]>;
   abstract readDatafile(options: DatafileOptions): Promise<DatafileContent>;
   abstract writeDatafile(datafileContent: DatafileContent, options: DatafileOptions): Promise<void>;
 
@@ -55,17 +53,4 @@ export abstract class Adapter {
     entityType?: EntityType,
     entityKey?: string,
   ): Promise<Commit>;
-
-  // feature source helpers (used by lint/history attribution)
-  async getFeatureSourcePaths(_featureKey: string): Promise<FeatureSourcePaths | undefined> {
-    return undefined;
-  }
-
-  async getFeaturePropertySourcePath(
-    _featureKey: string,
-    _property: FeatureEnvironmentProperty,
-    _environment?: string,
-  ): Promise<string | undefined> {
-    return undefined;
-  }
 }

package/src/datasource/datasource.ts

@@ -13,29 +13,45 @@ import type {
   EntityType,
   SchemaKey,
   Schema,
+  Target,
+  TargetKey,
 } from "@featurevisor/types";
 
-import { ProjectConfig } from "../config";
+import { getProjectConfigForSet, ProjectConfig } from "../config";
 import type { CustomParser } from "@featurevisor/parsers";
 
-import {
-  Adapter,
-  DatafileOptions,
-  FeatureEnvironmentProperty,
-  FeatureSourcePaths,
-} from "./adapter";
+import { Adapter, DatafileFile, DatafileOptions } from "./adapter";
 
 export class Datasource {
   private adapter: Adapter;
+  private rootConfig: ProjectConfig;
 
   constructor(
     private config: ProjectConfig,
     private rootDirectoryPath?: string,
+    private set?: string,
   ) {
-    this.adapter = new config.adapter(config, rootDirectoryPath);
+    this.rootConfig = config;
+    this.config = set ? getProjectConfigForSet(this.rootConfig, set) : config;
+    this.adapter = new this.config.adapter(this.config, rootDirectoryPath);
+  }
+
+  getConfig() {
+    return this.config;
+  }
+
+  getSet() {
+    return this.set;
+  }
+
+  forSet(set: string) {
+    return new Datasource(this.rootConfig, this.rootDirectoryPath, set);
+  }
+
+  listSets() {
+    return this.adapter.listSets();
   }
 
-  // @NOTE: only site generator needs it, find a way to get it out of here later
   getExtension() {
     return (this.config.parser as CustomParser).extension;
   }
@@ -65,6 +81,10 @@ export class Datasource {
   /**
    * Datafile
    */
+  listDatafiles(): Promise<DatafileFile[]> {
+    return this.adapter.listDatafiles ? this.adapter.listDatafiles() : Promise.resolve([]);
+  }
+
   readDatafile(options: DatafileOptions) {
     return this.adapter.readDatafile(options);
   }
@@ -98,18 +118,6 @@ export class Datasource {
     return this.adapter.deleteEntity("feature", featureKey);
   }
 
-  getFeatureSourcePaths(featureKey: FeatureKey): Promise<FeatureSourcePaths | undefined> {
-    return this.adapter.getFeatureSourcePaths(featureKey);
-  }
-
-  getFeaturePropertySourcePath(
-    featureKey: FeatureKey,
-    property: FeatureEnvironmentProperty,
-    environment?: string,
-  ): Promise<string | undefined> {
-    return this.adapter.getFeaturePropertySourcePath(featureKey, property, environment);
-  }
-
   async getRequiredFeaturesChain(
     featureKey: FeatureKey,
     chain = new Set<FeatureKey>(),
@@ -244,6 +252,27 @@ export class Datasource {
     return this.adapter.deleteEntity("schema", schemaKey);
   }
 
+  // targets
+  listTargets() {
+    return this.adapter.listEntities("target");
+  }
+
+  targetExists(targetKey: TargetKey) {
+    return this.adapter.entityExists("target", targetKey);
+  }
+
+  readTarget(targetKey: TargetKey) {
+    return this.adapter.readEntity<Target>("target", targetKey);
+  }
+
+  writeTarget(targetKey: TargetKey, target: Target) {
+    return this.adapter.writeEntity<Target>("target", targetKey, target);
+  }
+
+  deleteTarget(targetKey: TargetKey) {
+    return this.adapter.deleteEntity("target", targetKey);
+  }
+
   // tests
   listTests() {
     return this.adapter.listEntities("test");

package/src/datasource/filesystemAdapter.spec.ts

@@ -4,100 +4,131 @@ import * as path from "path";
 
 import { getProjectConfig } from "../config";
 import { Datasource } from "./datasource";
+import { getExistingStateFilePath } from "./filesystemAdapter";
 
 function writeFile(filePath: string, content: string) {
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
   fs.writeFileSync(filePath, content, "utf8");
 }
 
-function createSplitProject(configBody: string) {
+function createProject(configBody: string) {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "featurevisor-fs-adapter-"));
   writeFile(path.join(root, "featurevisor.config.js"), configBody);
 
   return root;
 }
 
-describe("core: filesystemAdapter (splitByEnvironment)", () => {
-  it("merges environment files into readFeature output", async () => {
-    const root = createSplitProject(
-      "module.exports = { environments: ['staging', 'production'], splitByEnvironment: true };",
-    );
+describe("core: filesystemAdapter", () => {
+  it("lists generated datafiles as sorted relative paths", async () => {
+    const root = createProject("module.exports = {};");
+    writeFile(path.join(root, "datafiles", "production", "featurevisor-all.json"), "{}");
+    writeFile(path.join(root, "datafiles", "staging", "nested", "featurevisor-web.json"), "abc");
+    writeFile(path.join(root, "datafiles", "staging", "featurevisor-mobile.txt"), "abcd");
+    writeFile(path.join(root, "datafiles", "REVISION"), "1");
+    writeFile(path.join(root, "datafiles", ".DS_Store"), "");
+
+    const datasource = new Datasource(getProjectConfig(root), root);
+
+    await expect(datasource.listDatafiles()).resolves.toMatchObject([
+      { path: "production/featurevisor-all.json", size: 2, gzipSize: expect.any(Number) },
+      { path: "staging/featurevisor-mobile.txt", size: 4, gzipSize: expect.any(Number) },
+      { path: "staging/nested/featurevisor-web.json", size: 3, gzipSize: expect.any(Number) },
+    ]);
+  });
+
+  it("lists nested entity paths with dot namespace character by default", async () => {
+    const root = createProject("module.exports = {};");
 
     writeFile(
-      path.join(root, "features", "checkout.yml"),
+      path.join(root, "features", "checkout", "page.yml"),
       [
-        "key: checkout",
-        "description: Checkout feature",
+        "description: Checkout page",
         "tags:",
         "  - all",
         "bucketBy: userId",
+        "rules:",
+        "  staging:",
+        "    - key: everyone",
+        "      segments: '*'",
+        "      percentage: 100",
+        "  production:",
+        "    - key: everyone",
+        "      segments: '*'",
+        "      percentage: 100",
       ].join("\n"),
     );
-
-    writeFile(
-      path.join(root, "environments", "staging", "checkout.yml"),
-      ["rules:", "  - key: everyone", "    segments: '*'", "    percentage: 100"].join("\n"),
-    );
-
     writeFile(
-      path.join(root, "environments", "production", "checkout.yml"),
+      path.join(root, "segments", "countries", "germany.yml"),
       [
-        "rules:",
-        "  - key: everyone",
-        "    segments: '*'",
-        "    percentage: 0",
-        "expose: false",
+        "description: Germany",
+        "conditions:",
+        "  - attribute: country",
+        "    operator: equals",
+        "    value: de",
       ].join("\n"),
     );
 
     const config = getProjectConfig(root);
     const datasource = new Datasource(config, root);
-    const feature = await datasource.readFeature("checkout");
-    const rulesByEnvironment = feature.rules as Record<string, any[]>;
-    const exposeByEnvironment = feature.expose as Record<string, unknown>;
 
-    expect(rulesByEnvironment?.staging?.[0]?.percentage).toBe(100);
-    expect(rulesByEnvironment?.production?.[0]?.percentage).toBe(0);
-    expect(exposeByEnvironment?.production).toBe(false);
+    await expect(datasource.listFeatures()).resolves.toEqual(["checkout.page"]);
+    await expect(datasource.listSegments()).resolves.toEqual(["countries.germany"]);
+    await datasource.writeTarget("apps.web", {
+      description: "Web app",
+      tags: ["all"],
+      context: { platform: "web" },
+    });
+    await expect(datasource.listTargets()).resolves.toEqual(["apps.web"]);
+    await expect(datasource.readTarget("apps.web")).resolves.toMatchObject({
+      description: "Web app",
+      tags: ["all"],
+    });
+    await datasource.deleteTarget("apps.web");
+    await expect(datasource.listTargets()).resolves.toEqual([]);
+    await expect(datasource.readFeature("checkout.page")).resolves.toMatchObject({
+      description: "Checkout page",
+    });
   });
 
-  it("throws when any environment feature file is missing", async () => {
-    const root = createSplitProject(
-      "module.exports = { environments: ['staging', 'production'], splitByEnvironment: true };",
-    );
-
-    writeFile(
-      path.join(root, "features", "myFeature.yml"),
-      ["key: myFeature", "description: My feature", "tags:", "  - all", "bucketBy: userId"].join(
-        "\n",
-      ),
-    );
+  it("keeps slash-separated keys when namespaceCharacter is slash", async () => {
+    const root = createProject('module.exports = { namespaceCharacter: "/" };');
 
     writeFile(
-      path.join(root, "environments", "staging", "myFeature.yml"),
-      ["rules:", "  - key: everyone", "    segments: '*'", "    percentage: 100"].join("\n"),
+      path.join(root, "features", "checkout", "page.yml"),
+      [
+        "description: Checkout page",
+        "tags:",
+        "  - all",
+        "bucketBy: userId",
+        "rules:",
+        "  staging:",
+        "    - key: everyone",
+        "      segments: '*'",
+        "      percentage: 100",
+        "  production:",
+        "    - key: everyone",
+        "      segments: '*'",
+        "      percentage: 100",
+      ].join("\n"),
     );
 
     const config = getProjectConfig(root);
     const datasource = new Datasource(config, root);
 
-    await expect(datasource.readFeature("myFeature")).rejects.toMatchObject({
-      featurevisorFilePath: expect.stringContaining(
-        path.join("environments", "production", "myFeature.yml"),
-      ),
+    await expect(datasource.listFeatures()).resolves.toEqual(["checkout/page"]);
+    await expect(datasource.readFeature("checkout/page")).resolves.toMatchObject({
+      description: "Checkout page",
     });
   });
 
-  it("throws when base feature file still defines rules in split mode", async () => {
-    const root = createSplitProject(
-      "module.exports = { environments: ['staging'], splitByEnvironment: true };",
-    );
+  it("lists sets and reads entities from selected set", async () => {
+    const root = createProject("module.exports = { sets: true };");
 
     writeFile(
-      path.join(root, "features", "foo.yml"),
+      path.join(root, "sets", "storefront", "features", "banner.yml"),
       [
-        "key: foo",
-        "description: Foo",
+        "key: banner",
+        "description: Storefront banner",
         "tags:",
         "  - all",
         "bucketBy: userId",
@@ -106,48 +137,76 @@ describe("core: filesystemAdapter (splitByEnvironment)", () => {
         "    - key: everyone",
         "      segments: '*'",
         "      percentage: 100",
+        "  production:",
+        "    - key: everyone",
+        "      segments: '*'",
+        "      percentage: 100",
       ].join("\n"),
     );
 
     writeFile(
-      path.join(root, "environments", "staging", "foo.yml"),
-      ["rules:", "  - key: everyone", "    segments: '*'", "    percentage: 100"].join("\n"),
+      path.join(root, "sets", "admin", "features", "banner.yml"),
+      [
+        "key: banner",
+        "description: Admin banner",
+        "tags:",
+        "  - all",
+        "bucketBy: userId",
+        "rules:",
+        "  staging:",
+        "    - key: everyone",
+        "      segments: '*'",
+        "      percentage: 0",
+        "  production:",
+        "    - key: everyone",
+        "      segments: '*'",
+        "      percentage: 0",
+      ].join("\n"),
     );
 
     const config = getProjectConfig(root);
     const datasource = new Datasource(config, root);
 
-    await expect(datasource.readFeature("foo")).rejects.toThrow(
-      "base file must not define rules, force, or expose when splitByEnvironment=true",
+    await expect(datasource.listSets()).resolves.toEqual(["admin", "storefront"]);
+
+    const storefrontDatasource = datasource.forSet("storefront");
+    const feature = await storefrontDatasource.readFeature("banner");
+
+    expect(feature.description).toBe("Storefront banner");
+    expect(storefrontDatasource.getSet()).toBe("storefront");
+    expect(storefrontDatasource.getConfig().featuresDirectoryPath).toBe(
+      path.join(root, "sets", "storefront", "features"),
     );
+    expect(storefrontDatasource.getConfig().targetsDirectoryPath).toBe(
+      path.join(root, "sets", "storefront", "targets"),
+    );
+    await storefrontDatasource.writeTarget("web", { description: "Storefront web" });
+    await expect(storefrontDatasource.listTargets()).resolves.toEqual(["web"]);
   });
 
-  it("throws when environment file has unknown keys", async () => {
-    const root = createSplitProject(
-      "module.exports = { environments: ['staging'], splitByEnvironment: true };",
-    );
+  it("writes compact state when prettyState is disabled", async () => {
+    const root = createProject("module.exports = { prettyState: false };");
+    const config = getProjectConfig(root);
+    const datasource = new Datasource(config, root);
+    const state = { features: {} };
 
-    writeFile(
-      path.join(root, "features", "foo.yml"),
-      ["key: foo", "description: Foo", "tags:", "  - all", "bucketBy: userId"].join("\n"),
-    );
+    await datasource.writeState(false, state);
 
-    writeFile(
-      path.join(root, "environments", "staging", "foo.yml"),
-      [
-        "rules:",
-        "  - key: everyone",
-        "    segments: '*'",
-        "    percentage: 100",
-        "extraKey: not allowed",
-      ].join("\n"),
+    expect(fs.readFileSync(getExistingStateFilePath(config, false), "utf8")).toBe(
+      JSON.stringify(state),
     );
+  });
 
+  it("writes formatted state when prettyState is enabled", async () => {
+    const root = createProject("module.exports = { prettyState: true };");
     const config = getProjectConfig(root);
     const datasource = new Datasource(config, root);
+    const state = { features: {} };
+
+    await datasource.writeState(false, state);
 
-    await expect(datasource.readFeature("foo")).rejects.toThrow(
-      "Unknown key(s) in environment feature file: extraKey",
+    expect(fs.readFileSync(getExistingStateFilePath(config, false), "utf8")).toBe(
+      JSON.stringify(state, null, 2),
     );
   });
 });