@featurevisor/core 2.26.1 → 3.0.1

package/src/generate-code/index.ts

@@ -4,6 +4,8 @@ import * as path from "path";
 import { generateTypeScriptCodeForProject } from "./typescript";
 import { Dependencies } from "../dependencies";
 import { Plugin } from "../cli";
+import { getProjectSetExecutions, printSetHeader } from "../sets";
+import { CLI_COLOR_CYAN, CLI_FORMAT_BOLD, colorize } from "../tester/cliFormat";
 
 export const ALLOWED_LANGUAGES_FOR_CODE_GENERATION = ["typescript"];
 
@@ -11,8 +13,8 @@ export interface GenerateCodeCLIOptions {
   language: string;
   outDir: string;
   tag?: string | string[];
+  target?: string | string[];
   react?: boolean;
-  individualFeatures?: boolean;
 }
 
 export async function generateCodeForProject(
@@ -32,13 +34,14 @@ export async function generateCodeForProject(
   const absolutePath = path.resolve(rootDirectoryPath, cliOptions.outDir);
 
   if (!fs.existsSync(absolutePath)) {
-    console.log(`Creating output directory: ${absolutePath}`);
+    console.log(`Creating output directory: ${colorize(absolutePath, CLI_COLOR_CYAN)}`);
     fs.mkdirSync(absolutePath, { recursive: true });
   } else {
-    console.log(`Output directory already exists at: ${absolutePath}`);
+    console.log(`Output directory already exists at: ${colorize(absolutePath, CLI_COLOR_CYAN)}`);
   }
 
   if (!ALLOWED_LANGUAGES_FOR_CODE_GENERATION.includes(cliOptions.language)) {
+    console.log(CLI_FORMAT_BOLD, "Unsupported language");
     console.log(
       `Only these languages are supported: ${ALLOWED_LANGUAGES_FOR_CODE_GENERATION.join(", ")}`,
     );
@@ -49,8 +52,8 @@ export async function generateCodeForProject(
   if (cliOptions.language === "typescript") {
     return await generateTypeScriptCodeForProject(deps, absolutePath, {
       tag: cliOptions.tag,
+      target: cliOptions.target,
       react: cliOptions.react,
-      individualFeatures: cliOptions.individualFeatures,
     });
   }
 
@@ -60,26 +63,31 @@ export async function generateCodeForProject(
 export const generateCodePlugin: Plugin = {
   command: "generate-code",
   handler: async function ({ rootDirectoryPath, projectConfig, datasource, parsed }) {
-    await generateCodeForProject(
-      {
-        rootDirectoryPath,
-        projectConfig,
-        datasource,
-        options: parsed,
-      },
-      {
-        language: parsed.language,
-        outDir: parsed.outDir,
-        tag: parsed.tag,
-        react: parsed.react,
-        individualFeatures:
-          parsed.individualFeatures !== undefined
-            ? Boolean(parsed.individualFeatures)
-            : parsed["individual-features"] !== undefined
-              ? Boolean(parsed["individual-features"])
-              : true,
-      },
-    );
+    if (projectConfig.sets && !parsed.set) {
+      throw new Error("Pass --set=<set> when generating code in a project with sets enabled.");
+    }
+
+    const executions = await getProjectSetExecutions(projectConfig, datasource, parsed.set);
+
+    for (const execution of executions) {
+      printSetHeader(projectConfig, execution.set);
+
+      await generateCodeForProject(
+        {
+          rootDirectoryPath,
+          projectConfig: execution.projectConfig,
+          datasource: execution.datasource,
+          options: parsed,
+        },
+        {
+          language: parsed.language,
+          outDir: parsed.outDir,
+          tag: parsed.tag,
+          target: parsed.target,
+          react: parsed.react,
+        },
+      );
+    }
   },
   examples: [
     {
@@ -90,5 +98,9 @@ export const generateCodePlugin: Plugin = {
       command: "generate-code --language typescript --out-dir src/generated --tag web --react",
       description: "Generate TypeScript and React helper code for tagged features",
     },
+    {
+      command: "generate-code --language typescript --out-dir src/generated --target web",
+      description: "Generate TypeScript code for features selected by a target",
+    },
   ],
 };

package/src/generate-code/typescript.spec.ts

@@ -80,7 +80,10 @@ describe("generate-code/typescript", () => {
 
     const attributesContent = fs.readFileSync(path.join(outputPath, "attributes.ts"), "utf8");
     const contextContent = fs.readFileSync(path.join(outputPath, "context.ts"), "utf8");
+    const featuresContent = fs.readFileSync(path.join(outputPath, "features.ts"), "utf8");
+    const functionsContent = fs.readFileSync(path.join(outputPath, "functions.ts"), "utf8");
     const indexContent = fs.readFileSync(path.join(outputPath, "index.ts"), "utf8");
+    const generatedFiles = fs.readdirSync(outputPath).sort();
 
     expect(attributesContent).toContain(
       'export type AccountAttribute = { plan: "free" | "pro"; locale?: string };',
@@ -104,5 +107,108 @@ describe("generate-code/typescript", () => {
     expect(contextContent).toContain("browser?: BrowserAttribute;");
 
     expect(indexContent).toContain('export * from "./attributes";');
+    expect(indexContent).toContain('export * from "./features";');
+    expect(indexContent).toContain('export * from "./functions";');
+    expect(featuresContent).toContain("export type FeatureKey = keyof Features;");
+    expect(functionsContent).toContain("export function isEnabled(");
+    expect(functionsContent).toContain("export function getVariation<");
+    expect(functionsContent).toContain("export function getVariable<");
+    expect(generatedFiles.some((fileName) => fileName.endsWith("Feature.ts"))).toEqual(false);
+    expect(indexContent).not.toMatch(/Feature";/);
+  });
+
+  it("generates the union of repeated tags and optional React hooks", async () => {
+    const projectConfig = getProjectConfig(tempProjectPath);
+    const datasource = new Datasource(projectConfig, tempProjectPath);
+
+    await generateTypeScriptCodeForProject(
+      {
+        rootDirectoryPath: tempProjectPath,
+        projectConfig,
+        datasource,
+        options: {},
+      } as any,
+      outputPath,
+      { tag: ["checkout", "ecommerce"], react: true },
+    );
+
+    const featuresContent = fs.readFileSync(path.join(outputPath, "features.ts"), "utf8");
+    const indexContent = fs.readFileSync(path.join(outputPath, "index.ts"), "utf8");
+    const generatedFiles = fs.readdirSync(outputPath).sort();
+
+    expect(featuresContent).toContain("discount: null;");
+    expect(featuresContent).toContain("pricing: {");
+    expect(featuresContent).toContain("withComplexSchema: {");
+    expect(featuresContent).not.toContain("accountTargeting:");
+    expect(generatedFiles).toContain("react.ts");
+    expect(generatedFiles.some((fileName) => fileName.endsWith("Feature.ts"))).toEqual(false);
+    expect(indexContent).toContain('export * from "./react";');
+  });
+
+  it("generates the union of repeated targets using their full selectors", async () => {
+    fs.writeFileSync(
+      path.join(tempProjectPath, "targets", "ecommerce-code.yml"),
+      [
+        "description: Ecommerce code",
+        "tags:",
+        "  and:",
+        "    - all",
+        "    - ecommerce",
+        "includeFeatures:",
+        "  - with*",
+        "excludeFeatures:",
+        "  - withMutations",
+      ].join("\n"),
+      "utf8",
+    );
+    const projectConfig = getProjectConfig(tempProjectPath);
+    const datasource = new Datasource(projectConfig, tempProjectPath);
+
+    await generateTypeScriptCodeForProject(
+      {
+        rootDirectoryPath: tempProjectPath,
+        projectConfig,
+        datasource,
+        options: {},
+      } as any,
+      outputPath,
+      { target: ["checkout", "ecommerce-code"] },
+    );
+
+    const featuresContent = fs.readFileSync(path.join(outputPath, "features.ts"), "utf8");
+
+    expect(featuresContent).toContain("discount: null;");
+    expect(featuresContent).toContain("pricing: {");
+    expect(featuresContent).toContain("withComplexSchema: {");
+    expect(featuresContent).not.toContain("withMutations:");
+    expect(featuresContent).not.toContain("accountTargeting:");
+  });
+
+  it("combines tags and targets as a union and rejects unknown selectors", async () => {
+    const projectConfig = getProjectConfig(tempProjectPath);
+    const datasource = new Datasource(projectConfig, tempProjectPath);
+    const deps = {
+      rootDirectoryPath: tempProjectPath,
+      projectConfig,
+      datasource,
+      options: {},
+    } as any;
+
+    await generateTypeScriptCodeForProject(deps, outputPath, {
+      tag: "sign-in",
+      target: "checkout",
+    });
+
+    const featuresContent = fs.readFileSync(path.join(outputPath, "features.ts"), "utf8");
+    expect(featuresContent).toContain("foo: {");
+    expect(featuresContent).toContain("discount: null;");
+    expect(featuresContent).not.toContain("accountTargeting:");
+
+    await expect(
+      generateTypeScriptCodeForProject(deps, outputPath, { tag: "missing" }),
+    ).rejects.toThrow('Unknown tag "missing"');
+    await expect(
+      generateTypeScriptCodeForProject(deps, outputPath, { target: "missing" }),
+    ).rejects.toThrow('Unknown target "missing"');
   });
 });