@featurevisor/core 2.26.1 → 3.0.1

package/src/linter/targetSchema.spec.ts

@@ -0,0 +1,159 @@
+import type { ProjectConfig } from "../config";
+import { getTargetZodSchema } from "./targetSchema";
+
+function minimalProjectConfig(overrides: Partial<ProjectConfig> = {}): ProjectConfig {
+  return {
+    featuresDirectoryPath: "",
+    segmentsDirectoryPath: "",
+    attributesDirectoryPath: "",
+    groupsDirectoryPath: "",
+    schemasDirectoryPath: "",
+    targetsDirectoryPath: "",
+    testsDirectoryPath: "",
+    stateDirectoryPath: "",
+    datafilesDirectoryPath: "",
+    datafileNamePattern: "",
+    revisionFileName: "",
+    catalogDirectoryPath: "",
+    setsDirectoryPath: "",
+    environments: ["staging", "production"],
+    sets: false,
+    namespaceCharacter: ".",
+    tags: ["all", "web", "mobile"],
+    adapter: {},
+    plugins: [],
+    defaultBucketBy: "userId",
+    parser: "yml",
+    prettyState: true,
+    prettyDatafile: false,
+    stringify: true,
+    ...overrides,
+  };
+}
+
+function parseTarget(input: unknown) {
+  return getTargetZodSchema(minimalProjectConfig()).safeParse(input);
+}
+
+describe("targetSchema.ts :: getTargetZodSchema", () => {
+  it("accepts a valid target", () => {
+    const result = parseTarget({
+      description: "Web target",
+      tags: { and: ["all", "web"] },
+      context: { device: "desktop" },
+      promotable: true,
+    });
+
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts a single tag", () => {
+    const result = parseTarget({
+      description: "Web target",
+      tag: "web",
+    });
+
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts feature patterns and the direct all-features wildcard", () => {
+    expect(
+      parseTarget({
+        description: "Selected features",
+        includeFeatures: ["checkout*", "account.profile"],
+        excludeFeatures: ["checkout.internal*"],
+      }).success,
+    ).toBe(true);
+
+    expect(
+      parseTarget({
+        description: "All features",
+        includeFeatures: "*",
+      }).success,
+    ).toBe(true);
+  });
+
+  it("rejects non-wildcard scalar feature selectors and empty pattern arrays", () => {
+    expect(
+      parseTarget({ description: "Scalar feature", includeFeatures: "checkout" }).success,
+    ).toBe(false);
+    expect(parseTarget({ description: "Empty include", includeFeatures: [] }).success).toBe(false);
+    expect(parseTarget({ description: "Empty exclude", excludeFeatures: [] }).success).toBe(false);
+  });
+
+  it("rejects empty tag selectors", () => {
+    expect(parseTarget({ description: "Empty tags", tags: [] }).success).toBe(false);
+    expect(parseTarget({ description: "Empty or", tags: { or: [] } }).success).toBe(false);
+    expect(parseTarget({ description: "Empty and", tags: { and: [] } }).success).toBe(false);
+  });
+
+  it("rejects malformed feature glob patterns", () => {
+    expect(parseTarget({ description: "Empty pattern", includeFeatures: [""] }).success).toBe(
+      false,
+    );
+    expect(parseTarget({ description: "Spaces", includeFeatures: [" checkout*"] }).success).toBe(
+      false,
+    );
+    expect(
+      parseTarget({ description: "Double wildcard", includeFeatures: ["checkout**"] }).success,
+    ).toBe(false);
+  });
+
+  it("rejects unknown single tag", () => {
+    const result = parseTarget({ description: "Unknown tag", tag: "unknown" });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues.map((issue) => issue.message).join(" ")).toContain(
+        'Unknown tag "unknown"',
+      );
+    }
+  });
+
+  it("rejects tag and tags together", () => {
+    const result = parseTarget({
+      description: "Too many tag selectors",
+      tag: "web",
+      tags: ["mobile"],
+    });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues.map((issue) => issue.message).join(" ")).toContain(
+        'Only one of "tag" or "tags" can be defined',
+      );
+    }
+  });
+
+  it("requires description", () => {
+    const result = parseTarget({ tags: ["all"] });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues.map((issue) => issue.message).join(" ")).toContain("Required");
+    }
+  });
+
+  it("rejects unknown tags", () => {
+    const result = parseTarget({ description: "Unknown tag", tags: ["unknown"] });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues.map((issue) => issue.message).join(" ")).toContain(
+        'Unknown tag "unknown"',
+      );
+    }
+  });
+
+  it("rejects invalid tag shapes", () => {
+    const result = parseTarget({ description: "Invalid tags", tags: { xor: ["web"] } });
+
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects non-boolean promotable", () => {
+    const result = parseTarget({ description: "Bad promotable", promotable: "no" });
+
+    expect(result.success).toBe(false);
+  });
+});

package/src/linter/targetSchema.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+
+import type { ProjectConfig } from "../config";
+import { refineWithMessage } from "./zodHelpers";
+
+const targetTagSchema = (projectConfig: ProjectConfig) =>
+  refineWithMessage(
+    z.string(),
+    (value) => projectConfig.tags.includes(value),
+    (value) => `Unknown tag "${value}"`,
+  );
+
+export function getTargetZodSchema(projectConfig: ProjectConfig) {
+  const tagSchema = targetTagSchema(projectConfig);
+  const featurePatternSchema = z
+    .string()
+    .min(1)
+    .refine((value) => value.trim() === value, "Feature patterns cannot have surrounding spaces")
+    .refine((value) => !value.includes("**"), 'Use "*" for glob-like wildcard matching');
+  const featurePatternsSchema = z.union([z.literal("*"), z.array(featurePatternSchema).min(1)]);
+
+  return z
+    .object({
+      key: z.string().optional(),
+      promotable: z.boolean().optional(),
+      description: z.string({
+        error: (issue) => (issue.input === undefined ? "Required" : undefined),
+      }),
+      tag: tagSchema.optional(),
+      tags: z
+        .union([
+          z.array(tagSchema).min(1),
+          z.object({ or: z.array(tagSchema).min(1) }).strict(),
+          z.object({ and: z.array(tagSchema).min(1) }).strict(),
+        ])
+        .optional(),
+      includeFeatures: featurePatternsSchema.optional(),
+      excludeFeatures: featurePatternsSchema.optional(),
+      context: z.record(z.string(), z.unknown()).optional(),
+    })
+    .strict()
+    .refine((target) => !(target.tag && target.tags), {
+      message: 'Only one of "tag" or "tags" can be defined',
+      path: ["tags"],
+    });
+}

package/src/linter/testSchema.spec.ts

@@ -11,15 +11,17 @@ function minimalProjectConfig(overrides: Partial<ProjectConfig> = {}): ProjectCo
     attributesDirectoryPath: "",
     groupsDirectoryPath: "",
     schemasDirectoryPath: "",
+    targetsDirectoryPath: "",
     testsDirectoryPath: "",
     stateDirectoryPath: "",
     datafilesDirectoryPath: "",
     datafileNamePattern: "",
     revisionFileName: "",
-    siteExportDirectoryPath: "",
-    environmentsDirectoryPath: "",
+    catalogDirectoryPath: "",
+    setsDirectoryPath: "",
     environments: ["staging", "production"],
-    splitByEnvironment: false,
+    sets: false,
+    namespaceCharacter: ".",
     tags: ["all", "beta"],
     adapter: {},
     plugins: [],
@@ -33,7 +35,7 @@ function minimalProjectConfig(overrides: Partial<ProjectConfig> = {}): ProjectCo
 }
 
 function getSchema(projectConfig = minimalProjectConfig()) {
-  return getTestsZodSchema(projectConfig, ["checkout"], ["desktop"]);
+  return getTestsZodSchema(projectConfig, ["checkout"], ["desktop"], ["web"]);
 }
 
 function parseTest(input: unknown): z.ZodSafeParseResult<unknown> {
@@ -77,7 +79,7 @@ describe("testSchema.ts :: getTestsZodSchema", () => {
           description: "feature assertion",
           at: "${{ score }}",
           environment: "staging",
-          tag: "all",
+          target: "web",
           sticky: {
             flag: { checkout: "cached" },
           },
@@ -126,6 +128,38 @@ describe("testSchema.ts :: getTestsZodSchema", () => {
     });
   });
 
+  it("accepts matrix placeholders for target values", () => {
+    expectTestSuccess({
+      feature: "checkout",
+      assertions: [
+        {
+          matrix: {
+            target: ["web", "mobile"],
+          },
+          at: 1,
+          environment: "staging",
+          target: "${{ target }}",
+        },
+      ],
+    });
+  });
+
+  it("rejects unknown targets", () => {
+    expectTestFailure(
+      {
+        feature: "checkout",
+        assertions: [
+          {
+            at: 1,
+            environment: "staging",
+            target: "mobile",
+          },
+        ],
+      },
+      'Unknown target "mobile"',
+    );
+  });
+
   it("rejects unknown environments with a precise path", () => {
     const error = expectTestFailure(
       {
@@ -145,6 +179,37 @@ describe("testSchema.ts :: getTestsZodSchema", () => {
     );
   });
 
+  it("rejects environment in assertions when environments are omitted", () => {
+    const schema = getSchema(minimalProjectConfig({ environments: undefined }));
+    const testSpec = {
+      feature: "checkout",
+      assertions: [
+        {
+          at: 1,
+          expectedToBeEnabled: true,
+        },
+      ],
+    };
+
+    expect(schema.safeParse(testSpec).success).toBe(true);
+
+    const result = schema.safeParse({
+      feature: "checkout",
+      assertions: [
+        {
+          at: 1,
+          environment: "staging",
+          expectedToBeEnabled: true,
+        },
+      ],
+    });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues.length).toBeGreaterThan(0);
+    }
+  });
+
   it("rejects unknown feature and segment keys", () => {
     expectTestFailure(
       {

package/src/linter/testSchema.ts

@@ -7,9 +7,8 @@ export function getTestsZodSchema(
   projectConfig: ProjectConfig,
   availableFeatureKeys: [string, ...string[]],
   availableSegmentKeys: [string, ...string[]],
+  availableTargetKeys: [string, ...string[]],
 ) {
-  const scopeNames = projectConfig.scopes ? projectConfig.scopes.map((scope) => scope.name) : [];
-
   const matrixZodSchema = z.record(
     z.string(),
     z.array(
@@ -25,6 +24,7 @@ export function getTestsZodSchema(
 
   const segmentTestZodSchema = z
     .object({
+      promotable: z.boolean().optional(),
       segment: refineWithMessage(
         z.string(),
         (value) => availableSegmentKeys.includes(value),
@@ -45,6 +45,7 @@ export function getTestsZodSchema(
 
   const featureTestZodSchema = z
     .object({
+      promotable: z.boolean().optional(),
       feature: refineWithMessage(
         z.string(),
         (value) => availableFeatureKeys.includes(value),
@@ -83,15 +84,16 @@ export function getTestsZodSchema(
                   (value) => `Unknown environment "${value}"`,
                 )
               : z.never().optional(),
-            tag: refineWithMessage(
-              z.string(),
-              (value) => projectConfig.tags.includes(value),
-              (value) => `Unknown tag "${value}"`,
-            ).optional(),
-            scope: refineWithMessage(
+            target: refineWithMessage(
               z.string(),
-              (value) => scopeNames.includes(value),
-              (value) => `Unknown scope "${value}"`,
+              (value) => {
+                if (value.indexOf("${{") === 0) {
+                  return true;
+                }
+
+                return availableTargetKeys.includes(value);
+              },
+              (value) => `Unknown target "${value}"`,
             ).optional(),
 
             // parent

package/src/list/index.spec.ts

@@ -0,0 +1,135 @@
+import type { ParsedFeature } from "@featurevisor/types";
+
+import { formatDatafileSize, listEntities, listProject } from "./index";
+
+function createFeatureFixture(overrides: Partial<ParsedFeature> = {}): ParsedFeature {
+  return {
+    key: "untagged",
+    description: "Untagged feature",
+    bucketBy: "userId",
+    rules: {
+      staging: [{ key: "everyone", segments: "*", percentage: 100 }],
+      production: [{ key: "everyone", segments: "*", percentage: 100 }],
+    },
+    ...overrides,
+  };
+}
+
+describe("core: list", function () {
+  test("excludes features with missing tags when tag filter is provided", async function () {
+    const datasource = {
+      listFeatures: async () => ["untagged"],
+      readFeature: async () => createFeatureFixture(),
+    };
+
+    const result = await listEntities<ParsedFeature>(
+      {
+        rootDirectoryPath: "",
+        projectConfig: {} as any,
+        datasource: datasource as any,
+        options: {
+          tag: "all",
+        },
+      },
+      "feature",
+    );
+
+    expect(result).toEqual([]);
+  });
+
+  test("lists the union of features selected by repeated targets", async function () {
+    const featureFixtures = {
+      web: createFeatureFixture({ key: "web", tags: ["web"] }),
+      mobile: createFeatureFixture({ key: "mobile", tags: ["mobile"] }),
+      internal: createFeatureFixture({ key: "internal", tags: ["internal"] }),
+    };
+    const datasource = {
+      listFeatures: async () => Object.keys(featureFixtures),
+      readFeature: async (key: keyof typeof featureFixtures) => featureFixtures[key],
+      listTargets: async () => ["web", "mobile"],
+      readTarget: async (key: string) => ({ description: key, tag: key }),
+    };
+
+    const result = await listEntities<ParsedFeature>(
+      {
+        rootDirectoryPath: "",
+        projectConfig: {} as any,
+        datasource: datasource as any,
+        options: { target: ["web", "mobile"] },
+      },
+      "feature",
+    );
+
+    expect(result.map((feature) => feature.key).sort()).toEqual(["mobile", "web"]);
+  });
+
+  test("lists generated datafiles", async function () {
+    const log = jest.spyOn(console, "log").mockImplementation();
+    const datasource = {
+      listDatafiles: async () => [
+        { path: "production/featurevisor-all.json", size: 42, gzipSize: 62 },
+      ],
+    };
+
+    await listProject({
+      rootDirectoryPath: "",
+      projectConfig: {} as any,
+      datasource: datasource as any,
+      options: { datafiles: true, json: true },
+    });
+
+    expect(log).toHaveBeenCalledWith(
+      '[{"path":"production/featurevisor-all.json","size":42,"gzipSize":62}]',
+    );
+    log.mockRestore();
+  });
+
+  test("formats datafile sizes with colored units", function () {
+    expect(formatDatafileSize(42)).toBe("42.00 \u001b[33mB\u001b[0m");
+    expect(formatDatafileSize(1024)).toBe("1.00 \u001b[36mkB\u001b[0m");
+    expect(formatDatafileSize(1024 * 1024)).toBe("1.00 \u001b[32mmB\u001b[0m");
+  });
+
+  test("prints datafiles in aligned columns", async function () {
+    const log = jest.spyOn(console, "log").mockImplementation();
+    const datasource = {
+      listDatafiles: async () => [
+        { path: "production/featurevisor-all.json", size: 1024 * 1024, gzipSize: 1024 },
+        { path: "staging/featurevisor-checkout.json", size: 42, gzipSize: 24 },
+        { path: "development/featurevisor-all.json", size: 1024, gzipSize: 512 },
+      ],
+    };
+
+    await listProject({
+      rootDirectoryPath: "",
+      projectConfig: {} as any,
+      datasource: datasource as any,
+      options: { datafiles: true },
+    });
+
+    const output = log.mock.calls.map(([message]) => message).join("\n");
+    const uncoloredOutput = output.replace(/\u001b\[[0-9;]*m/g, "");
+
+    expect(uncoloredOutput).toContain("Datafile");
+    expect(uncoloredOutput).toContain("Size");
+    expect(uncoloredOutput).toContain("Gzip");
+    expect(uncoloredOutput).toContain("production/featurevisor-all.json");
+    expect(uncoloredOutput).toContain("staging/featurevisor-checkout.json");
+    expect(uncoloredOutput.indexOf("development/featurevisor-all.json")).toBeLessThan(
+      uncoloredOutput.indexOf("staging/featurevisor-checkout.json"),
+    );
+    expect(uncoloredOutput.indexOf("staging/featurevisor-checkout.json")).toBeLessThan(
+      uncoloredOutput.indexOf("production/featurevisor-all.json"),
+    );
+    expect(uncoloredOutput).toMatch(/development\/featurevisor-all\.json\s+1\.00 kB/);
+    expect(uncoloredOutput).toMatch(/development\/featurevisor-all\.json\s+1\.00 kB\s+512\.00  B/);
+    expect(uncoloredOutput).toMatch(/staging\/featurevisor-checkout\.json\s+42\.00  B/);
+    expect(uncoloredOutput).toMatch(/production\/featurevisor-all\.json\s+1\.00 mB/);
+    expect(uncoloredOutput).toContain("512.00  B\n\n  staging/");
+    expect(uncoloredOutput).toContain("24.00  B\n\n  production/");
+    expect(output).toContain("\u001b[36mkB\u001b[0m");
+    expect(output).toContain("\u001b[33mB\u001b[0m");
+    expect(output).toContain("\u001b[32mmB\u001b[0m");
+    log.mockRestore();
+  });
+});