@asyncapi/generator 2.6.0 → 2.7.1

package/lib/generator.js

@@ -2,7 +2,6 @@ const path = require('path');
 const fs = require('fs');
 const xfs = require('fs.extra');
 const minimatch = require('minimatch');
-const jmespath = require('jmespath');
 const filenamify = require('filenamify');
 const git = require('simple-git');
 const log = require('loglevel');
@@ -10,12 +9,12 @@ const Arborist = require('@npmcli/arborist');
 const Config = require('@npmcli/config');
 const requireg = require('requireg');
 const npmPath = requireg.resolve('npm').replace('index.js','');
-
 const { isAsyncAPIDocument } = require('@asyncapi/parser/cjs/document');
 
 const { configureReact, renderReact, saveRenderedReactContent } = require('./renderer/react');
 const { configureNunjucks, renderNunjucks } = require('./renderer/nunjucks');
 const { validateTemplateConfig } = require('./templateConfigValidator');
+const { isGenerationConditionMet } = require('./conditionalGeneration');
 const {
   convertMapToObject,
   isFileSystemPath,
@@ -135,7 +134,7 @@ class Generator {
         enumerable: true,
         get() {
           if (!self.templateConfig.parameters?.[key]) {
-            throw new Error(`Template parameter "${key}" has not been defined in the package.json file under generator property. Please make sure it's listed there before you use it in your template.`);
+            throw new Error(`Template parameter "${key}" has not been defined in the Generator Configuration. Please make sure it's listed there before you use it in your template.`);
           }
           return templateParams[key];
         }
@@ -620,7 +619,7 @@ class Generator {
         path: packagePath,
       };
     } catch (err) {
-      throw new Error('Installation failed', err);
+      throw new Error(`Installation failed: ${ err.message }`);
     }
   }
 
@@ -687,7 +686,7 @@ class Generator {
 
       walker.on('directory', async (root, stats, next) => {
         try {
-          this.ignoredDirHandler(root, stats, next);
+          await this.ignoredDirHandler(root, stats, next);
         } catch (e) {
           reject(e);
         }
@@ -711,10 +710,23 @@ class Generator {
    * @param  {String} stats Information about the file.
    * @param  {Function} next Callback function
    */
-  ignoredDirHandler(root, stats, next) {
+  async ignoredDirHandler(root, stats, next) {
     const relativeDir = path.relative(this.templateContentDir, path.resolve(root, stats.name));
     const dirPath = path.resolve(this.targetDir, relativeDir);
-    if (!shouldIgnoreDir(relativeDir)) {
+    const conditionalEntry = this.templateConfig?.conditionalGeneration?.[relativeDir];
+    let shouldGenerate =  true;
+    if (conditionalEntry) {
+      shouldGenerate = await isGenerationConditionMet(
+        this.templateConfig,
+        relativeDir,
+        this.templateParams,
+        this.asyncapiDocument
+      );
+      if (!shouldGenerate) {
+        log.debug(logMessage.conditionalGenerationMatched(relativeDir));
+      }
+    }  
+    if (!shouldIgnoreDir(relativeDir) && shouldGenerate) {
       xfs.mkdirpSync(dirPath);
     }
     next();
@@ -854,7 +866,7 @@ class Generator {
       await writeFile(outputpath, renderContent);
     }
   }
-
+  
   /**
    * Generates a file.
    *
@@ -867,34 +879,61 @@ class Generator {
   async generateFile(asyncapiDocument, fileName, baseDir) {
     const sourceFile = path.resolve(baseDir, fileName);
     const relativeSourceFile = path.relative(this.templateContentDir, sourceFile);
+    const relativeSourceDirectory = relativeSourceFile.split(path.sep)[0] || '.';
+  
     const targetFile = path.resolve(this.targetDir, this.maybeRenameSourceFile(relativeSourceFile));
     const relativeTargetFile = path.relative(this.targetDir, targetFile);
-
+    let shouldGenerate = true;
+  
     if (shouldIgnoreFile(relativeSourceFile)) return;
+    
+    if (!(await this.shouldOverwriteFile(relativeTargetFile))) return;
+
+    // conditionalFiles becomes deprecated with this PR, and soon will be removed.
+    // TODO: https://github.com/asyncapi/generator/issues/1553
+    let conditionalPath = '';
+    if (
+      this.templateConfig.conditionalFiles &&
+      this.templateConfig.conditionalGeneration
+    ) {
+      log.debug(
+        'Both \'conditionalFiles\' and \'conditionalGeneration\' are defined. Ignoring \'conditionalFiles\' and using \'conditionalGeneration\' only.'
+      );
+    }
 
-    const shouldOverwriteFile = await this.shouldOverwriteFile(relativeTargetFile);
-    if (!shouldOverwriteFile) return;
-
-    if (this.templateConfig.conditionalFiles?.[relativeSourceFile]) {
-      const server = this.templateParams.server && asyncapiDocument.servers().get(this.templateParams.server);
-      const source = jmespath.search({
-        ...asyncapiDocument.json(),
-        ...{
-          server: server ? server.json() : undefined,
-        },
-      }, this.templateConfig.conditionalFiles[relativeSourceFile].subject);
-
-      if (!source) return log.debug(logMessage.relativeSourceFileNotGenerated(relativeSourceFile, this.templateConfig.conditionalFiles[relativeSourceFile].subject));
-
-      if (source) {
-        const validate = this.templateConfig.conditionalFiles[relativeSourceFile].validate;
-        const valid = validate(source);
-        if (!valid) return log.debug(logMessage.conditionalFilesMatched(relativeSourceFile));
+    if (this.templateConfig.conditionalGeneration?.[relativeSourceDirectory]) {
+      conditionalPath = relativeSourceDirectory;
+    } else if (this.templateConfig.conditionalGeneration?.[relativeSourceFile]) {
+      conditionalPath = relativeSourceFile;
+    } else
+    if (this.templateConfig.conditionalFiles?.[relativeSourceFile]) {  
+      // conditionalFiles becomes deprecated with this PR, and soon will be removed.
+      // TODO: https://github.com/asyncapi/generator/issues/1553
+      conditionalPath = relativeSourceDirectory;
+    }
+   
+    if (conditionalPath) {
+      shouldGenerate = await isGenerationConditionMet(
+        this.templateConfig,
+        conditionalPath,
+        this.templateParams,
+        asyncapiDocument
+      );
+    }
+    
+    if (!shouldGenerate) {
+      if (this.templateConfig.conditionalFiles?.[relativeSourceFile]) {
+        // conditionalFiles becomes deprecated with this PR, and soon will be removed.
+        // TODO: https://github.com/asyncapi/generator/issues/1553
+        return log.debug(logMessage.conditionalFilesMatched(relativeSourceFile));
       }
+      
+      return log.debug(logMessage.conditionalGenerationMatched(conditionalPath));
     }
-
+    
     if (this.isNonRenderableFile(relativeSourceFile)) return await copyFile(sourceFile, targetFile);
     await this.renderAndWriteToFile(asyncapiDocument, sourceFile, targetFile);
+    log.debug(`Successfully rendered template and wrote file ${relativeSourceFile} to location: ${targetFile}`);
   }
 
   /**
@@ -942,10 +981,9 @@ class Generator {
    */
   isNonRenderableFile(fileName) {
     const nonRenderableFiles = this.templateConfig.nonRenderableFiles || [];
-    if (!Array.isArray(nonRenderableFiles)) return false;
-    if (nonRenderableFiles.some(globExp => minimatch(fileName, globExp))) return true;
-    if (isReactTemplate(this.templateConfig) && !isJsFile(fileName)) return true;
-    return false;
+    return Array.isArray(nonRenderableFiles) &&
+    (nonRenderableFiles.some(globExp => minimatch(fileName, globExp)) ||
+    (isReactTemplate(this.templateConfig) && !isJsFile(fileName)));
   }
 
   /**
@@ -968,19 +1006,34 @@ class Generator {
    * @private
    */
   async loadTemplateConfig() {
+    this.templateConfig = {};
+    
+    // Try to load config from .ageneratorrc
+    try {
+      const rcConfigPath = path.resolve(this.templateDir, '.ageneratorrc');
+      const yaml = await readFile(rcConfigPath, { encoding: 'utf8' });
+      const yamlConfig = require('js-yaml').load(yaml);
+      this.templateConfig = yamlConfig || {};
+      
+      await this.loadDefaultValues();
+      return;
+    } catch (rcError) {
+      // console.error('Could not load .ageneratorrc file:', rcError);
+      log.debug('Could not load .ageneratorrc file:', rcError);
+      // Continue to try package.json if .ageneratorrc fails
+    }
+    
+    // Try to load config from package.json
     try {
       const configPath = path.resolve(this.templateDir, CONFIG_FILENAME);
-      if (!fs.existsSync(configPath)) {
-        this.templateConfig = {};
-        return;
-      }
-
       const json = await readFile(configPath, { encoding: 'utf8' });
       const generatorProp = JSON.parse(json).generator;
       this.templateConfig = generatorProp || {};
-    } catch (e) {
-      this.templateConfig = {};
+    } catch (packageError) {
+      // console.error('Could not load generator config from package.json:', packageError);
+      log.debug('Could not load generator config from package.json:', packageError);
     }
+    
     await this.loadDefaultValues();
   }
 
@@ -1085,4 +1138,4 @@ class Generator {
 Generator.DEFAULT_TEMPLATES_DIR = DEFAULT_TEMPLATES_DIR;
 Generator.TRANSPILED_TEMPLATE_LOCATION = TRANSPILED_TEMPLATE_LOCATION;
 
-module.exports = Generator;
+module.exports = Generator;

package/lib/hooksRegistry.js

@@ -9,7 +9,7 @@ const { exists, registerTypeScript } = require('./utils');
  * @param {String} templateDir Directory where template is located.
  * @param {String} hooksDir Directory where local hooks are located.
  */
-module.exports.registerHooks = async (hooks, templateConfig, templateDir, hooksDir) => {
+async function registerHooks (hooks, templateConfig, templateDir, hooksDir) {
   await registerLocalHooks(hooks, templateDir, hooksDir);
 
   if (templateConfig && Object.keys(templateConfig).length > 0) await registerConfigHooks(hooks, templateDir, templateConfig);
@@ -122,3 +122,10 @@ function addHook(hooks, mod, config) {
   });
   return hooks;
 }
+
+module.exports = {
+  registerHooks,
+  registerLocalHooks,
+  registerConfigHooks,
+  addHook
+};

package/lib/logMessages.js

@@ -22,7 +22,6 @@ function packageNotAvailable(packageDetails) {
   if (packageDetails?.pkgPath) {
     return `Unable to resolve template location at ${packageDetails.pkgPath}. Package is not available locally.`;
   }
-
   return `Template is not available locally and expected location is undefined. Known details are: ${JSON.stringify(packageDetails, null, 2)}`;
 }
 
@@ -42,6 +41,11 @@ function skipOverwrite(testFilePath) {
   return `Skipping overwrite for: ${testFilePath}`;
 }
 
+function conditionalGenerationMatched(conditionalPath) {
+  return `${conditionalPath} was not generated because condition specified for this location in template configuration in conditionalGeneration matched.`;
+}
+// conditionalFiles becomes deprecated with this PR, and soon will be removed.
+// TODO: https://github.com/asyncapi/generator/issues/1553
 function conditionalFilesMatched(relativeSourceFile) {
   return `${relativeSourceFile} was not generated because condition specified for this file in template configuration in conditionalFiles matched.`;
 }
@@ -62,6 +66,7 @@ module.exports = {
   installationDebugMessage,
   templateSuccessfullyInstalled,
   relativeSourceFileNotGenerated,
+  conditionalGenerationMatched,
   conditionalFilesMatched,
   compileEnabled,
   skipOverwrite

package/lib/parser.js

@@ -50,6 +50,14 @@ parser.getProperApiDocument = (asyncapiDocument, templateConfig = {}) => {
   return ConvertDocumentParserAPIVersion(asyncapiDocument, apiVersion);
 };
 
+/**
+ * Converts old parser options to the new format.
+ * 
+ * @private - This function should not be used outside this module.
+ * @param {object} oldOptions - The old options to convert.
+ * @param {object} generator - The generator instance.
+ * @returns {object} The converted options.
+ */
 // The new options for the v2 Parser are different from those for the v1 version, but in order not to release Generator v2, we are converting the old options of Parser to the new ones.
 function convertOldOptionsToNew(oldOptions, generator) {
   if (!oldOptions) return;
@@ -143,3 +151,5 @@ function canReadFn(uri, canRead) {
   }
   return false;
 }
+
+module.exports.convertOldOptionsToNew = convertOldOptionsToNew;

package/lib/templateConfigValidator.js

@@ -24,9 +24,14 @@ const supportedParserAPIMajorVersions = [
  * @return {Boolean}
  */
 module.exports.validateTemplateConfig = (templateConfig, templateParams, asyncapiDocument) => {
-  const { parameters, supportedProtocols, conditionalFiles, generator, apiVersion } = templateConfig;
+  // conditionalFiles becomes deprecated with this PR, and soon will be removed.
+  // TODO: https://github.com/asyncapi/generator/issues/1553
+  const { parameters, supportedProtocols, conditionalFiles, conditionalGeneration, generator, apiVersion } = templateConfig;
 
+  // conditionalFiles becomes deprecated with this PR, and soon will be removed.
+  // TODO: https://github.com/asyncapi/generator/issues/1553
   validateConditionalFiles(conditionalFiles);
+  validateConditionalGeneration(conditionalGeneration);
   isTemplateCompatible(generator, apiVersion);
   isRequiredParamProvided(parameters, templateParams);
   isProvidedTemplateRendererSupported(templateConfig);
@@ -148,6 +153,8 @@ function isServerProvidedInDocument(server, paramsServerName) {
   if (typeof paramsServerName === 'string' && !server) throw new Error(`Couldn't find server with name ${paramsServerName}.`);
 }
 
+// conditionalFiles becomes deprecated with this PR, and soon will be removed.
+// TODO: https://github.com/asyncapi/generator/issues/1553
 /**
  * Checks if conditional files are specified properly in the template
  * @private
@@ -165,3 +172,25 @@ function validateConditionalFiles(conditionalFiles) {
     });
   }
 }
+
+/**
+ * Validates conditionalGeneration settings in the template config.
+ * @private
+ * @param {Object} conditionalGeneration - The conditions specified in the template config.
+ */
+function validateConditionalGeneration(conditionalGeneration) {
+  if (!conditionalGeneration || typeof conditionalGeneration !== 'object') return;
+  
+  for (const [fileName, def] of Object.entries(conditionalGeneration)) {
+    const { subject, parameter, validation } = def;
+    if (subject && typeof subject !== 'string')
+      throw new Error(`Invalid 'subject' for ${fileName}: ${subject}`);
+    if (parameter && typeof parameter !== 'string')
+      throw new Error(`Invalid 'parameter' for ${fileName}: ${parameter}`);
+    if (subject && parameter)
+      throw new Error(`Both 'subject' and 'parameter' cannot be defined for ${fileName}`);
+    if (typeof validation !== 'object')
+      throw new Error(`Invalid 'validation' object for ${fileName}: ${validation}`);
+    def.validate = ajv.compile(validation);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asyncapi/generator",
-  "version": "2.6.0",
+  "version": "2.7.1",
   "description": "The AsyncAPI generator. It can generate documentation, code, anything!",
   "main": "./lib/generator.js",
   "bin": {
@@ -16,12 +16,11 @@
     "test:unit": "jest --coverage --testPathIgnorePatterns=integration --testPathIgnorePatterns=test-project",
     "test:dev": "npm run test:unit -- --watchAll",
     "test:integration": "npm run test:cleanup && jest --testPathPattern=integration --modulePathIgnorePatterns='./__mocks__(?!\\/loglevel\\.js$)'",
-    "test:integration:update": "jest --updateSnapshot --testPathPattern=integration --modulePathIgnorePatterns='./__mocks__(?!\\/loglevel\\.js$)'",
+    "test:integration:update": "npm run test:integration -- -u",
     "test:cleanup": "rimraf \"test/temp\"",
     "docs": "jsdoc2md --partial docs/jsdoc2md-handlebars/custom-sig-name.hbs docs/jsdoc2md-handlebars/main.hbs docs/jsdoc2md-handlebars/docs.hbs docs/jsdoc2md-handlebars/header.hbs docs/jsdoc2md-handlebars/defaultvalue.hbs docs/jsdoc2md-handlebars/link.hbs docs/jsdoc2md-handlebars/params-table.hbs --files lib/generator.js > docs/api.md",
     "docker:build": "docker build -t asyncapi/generator:latest .",
     "lint": "eslint --max-warnings 0 --config ../../.eslintrc --ignore-path ../../.eslintignore .",
-    "lint:tpl:validator": "eslint --fix --config ../../.eslintrc ../../.github/templates-list-validator",
     "generate:readme:toc": "markdown-toc -i README.md",
     "generate:assets": "npm run docs && npm run generate:readme:toc",
     "bump:version": "npm --no-git-tag-version --allow-same-version version $VERSION"
@@ -48,10 +47,10 @@
   "license": "Apache-2.0",
   "homepage": "https://github.com/asyncapi/generator",
   "dependencies": {
-    "@asyncapi/generator-react-sdk": "^1.1.2",
+    "@asyncapi/generator-hooks": "*",
+    "@asyncapi/generator-react-sdk": "*",
     "@asyncapi/multi-parser": "^2.1.1",
     "@asyncapi/nunjucks-filters": "*",
-    "@asyncapi/generator-hooks": "*",
     "@asyncapi/parser": "^3.0.14",
     "@npmcli/arborist": "5.6.3",
     "@npmcli/config": "^8.0.2",

package/test/generator.test.js

@@ -51,7 +51,7 @@ describe('Generator', () => {
       expect(gen.forceWrite).toStrictEqual(true);
       expect(gen.install).toStrictEqual(true);
       expect(gen.compile).toStrictEqual(false);
-      expect(() => gen.templateParams.test).toThrow('Template parameter "test" has not been defined in the package.json file under generator property. Please make sure it\'s listed there before you use it in your template.');
+      expect(() => gen.templateParams.test).toThrow('Template parameter "test" has not been defined in the Generator Configuration. Please make sure it\'s listed there before you use it in your template.');
 
       // Mock params on templateConfig so it doesn't fail.
       gen.templateConfig.parameters = { test: {} };

package/test/hooksRegistry.test.js

@@ -0,0 +1,173 @@
+/**
+ * @jest-environment node
+ */
+const fs = require('fs');
+const path = require('path');
+const { addHook, registerLocalHooks, registerConfigHooks, registerHooks } = require('../lib/hooksRegistry');
+
+jest.mock('fs');
+jest.mock('path');
+
+describe('hooksRegistry', () => {
+  let hooks;
+
+  beforeEach(() => {
+    hooks = {};  // reset hooks for each test
+    jest.clearAllMocks(); // Reset all mocks
+    jest.resetModules(); // Reset modules
+  });
+
+  describe('registerHooks', () => {
+    it('registers both local and config hooks', async () => {
+      const templateDir = path.join(__dirname, 'fixtures', 'template', 'hooks');      
+      const hooksDir = path.join(__dirname, 'hooks');
+      
+      fs.mkdirSync(hooksDir, { recursive: true });
+      fs.writeFileSync(path.join(hooksDir, 'preGenerate.js'), `
+        module.exports = function localPreGenerateHook() {};
+      `);
+
+      const templateConfig = {
+        hooks: {
+          '@asyncapi/hooks-module': ['configPreGenerateHook']
+        }
+      };
+
+      jest.mock('@asyncapi/hooks-module', () => ({
+        preGenerate: [function configPreGenerateHook() {}]
+      }), { virtual: true });
+
+      const result = await registerHooks(hooks, templateConfig, templateDir, 'hooks');
+      
+      expect(result.preGenerate).toHaveLength(1); 
+      expect(result.preGenerate[0].name).toBe('configPreGenerateHook');
+      
+      fs.rmSync(hooksDir, { recursive: true, force: true });
+    });
+  });
+
+  describe('registerLocalHooks', () => {
+    const mockPreGenerateHook = function preGenerateHook() {};
+  
+    beforeAll(() => {
+      path.join.mockImplementation((...args) => args.join('/'));
+    });
+  
+    beforeEach(() => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readdirSync.mockReturnValue(['preGenerate.js']);
+      
+      jest.mock('fixtures/template/hooks/preGenerate.js', () => mockPreGenerateHook, { virtual: true });
+    });
+  
+    it('handles missing hooks directory', async () => {
+      fs.existsSync.mockReturnValueOnce(false);
+      
+      const result = await registerLocalHooks(hooks, '/non/existent/path', 'hooks');
+      expect(result).toBe(hooks);
+      expect(result.preGenerate).toBeUndefined();
+    });
+    
+    it('handles errors during hook loading', async () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readdirSync.mockReturnValue(['errorHook.js']);
+      
+      jest.mock('fixtures/template/hooks/errorHook.js', () => {
+        throw new Error('Mock import error');
+      }, { virtual: true });
+      
+      await expect(registerLocalHooks(hooks, 'fixtures/template', 'hooks'))
+        .resolves.not.toThrow();
+        
+      expect(hooks).toEqual({});
+    });
+  });
+
+  describe('registerConfigHooks', () => {
+    it('registers hooks from template config', async () => {
+      const templateDir = path.join(__dirname, 'fixtures', 'template');
+      const templateConfig = {
+        hooks: {
+          '@asyncapi/hooks-module': ['preGenerateHook']
+        }
+      };
+
+      // Mock the hook module
+      jest.mock('@asyncapi/hooks-module', () => ({
+        preGenerate: [function preGenerateHook() {}]
+      }), { virtual: true });
+
+      const result = await registerConfigHooks(hooks, templateDir, templateConfig);
+      
+      expect(result.preGenerate).toHaveLength(1);
+      expect(result.preGenerate[0].name).toBe('preGenerateHook');
+    });
+
+    it('handles missing hooks in config', async () => {
+      const result = await registerConfigHooks(hooks, '', {});
+      expect(result).toBeUndefined();
+      expect(hooks).toEqual({}); 
+    });
+  });
+
+  describe('addHooks', () => {
+    it('adds hooks from module to hooks object', () => {
+      const mod = {
+        preGenerate: [function preGenerateHook() {}],
+        postGenerate: [function postGenerateHook() {}]
+      };
+
+      addHook(hooks, mod, null);
+
+      expect(hooks.preGenerate).toHaveLength(1);
+      expect(hooks.postGenerate).toHaveLength(1);
+      expect(hooks.preGenerate[0].name).toBe('preGenerateHook');
+      expect(hooks.postGenerate[0].name).toBe('postGenerateHook');
+    });
+
+    it('adds hooks from module.default if it exists', () => {
+      const mod = {
+        default: {
+          preGenerate: [function preGenerateHook() {}],
+          postGenerate: [function postGenerateHook() {}]
+        }
+      };
+
+      addHook(hooks, mod, null);
+
+      expect(hooks.preGenerate).toHaveLength(1);
+      expect(hooks.postGenerate).toHaveLength(1);
+      expect(hooks.preGenerate[0].name).toBe('preGenerateHook');
+      expect(hooks.postGenerate[0].name).toBe('postGenerateHook');
+    });
+
+    it('does not add hooks that are not in config', () => {
+      const mod = {
+        preGenerate: [function preGenerateHook() {}],
+        postGenerate: [function postGenerateHook() {}]
+      };
+      const config = ['preGenerateHook'];
+
+      addHook(hooks, mod, config);
+
+      expect(hooks.preGenerate).toHaveLength(1);
+      expect(hooks.postGenerate).toBeUndefined();
+      expect(hooks.preGenerate[0].name).toBe('preGenerateHook');
+    });
+
+    it('adds hooks that are in config', () => {
+      const mod = {
+        preGenerate: [function preGenerateHook() {}],
+        postGenerate: [function postGenerateHook() {}]
+      };
+      const config = ['preGenerateHook', 'postGenerateHook'];
+
+      addHook(hooks, mod, config);
+
+      expect(hooks.preGenerate).toHaveLength(1);
+      expect(hooks.postGenerate).toHaveLength(1);
+      expect(hooks.preGenerate[0].name).toBe('preGenerateHook');
+      expect(hooks.postGenerate[0].name).toBe('postGenerateHook');
+    });
+  });
+});

package/test/integration.test.js

@@ -153,4 +153,51 @@ describe('Integration testing generateFromFile() to make sure the result of the
        Include log message test in the future to ensure that the log.debug for skipping overwrite is called
      */
   });
+
+  it('should not generate the conditionalFolder if the singleFolder parameter is set true', async () => {
+    const outputDir = generateFolderName();
+    const generator = new Generator(reactTemplate, outputDir, {
+      forceWrite: true ,
+      templateParams: { version: 'v1', mode: 'production', singleFolder: 'true' }
+    });
+    await generator.generateFromFile(dummySpecPath);
+    const conditionalFolderPath = path.join(outputDir, 'conditionalFolder');
+    const exists = await access(conditionalFolderPath).then(() => true).catch(() => false);
+    expect(exists).toBe(false);
+  });
+  it('should not generate the conditionalFile if the singleFile parameter is set true', async () => {
+    const outputDir = generateFolderName();
+    const generator = new Generator(reactTemplate, outputDir, {
+      forceWrite: true ,
+      templateParams: { version: 'v1', mode: 'production', singleFile: 'true' }
+    });
+    await generator.generateFromFile(dummySpecPath);
+    const conditionalFilePath = path.join(outputDir, 'conditionalFile.txt');
+    const exists = await readFile(conditionalFilePath).then(() => true).catch(() => false);
+    expect(exists).toBe(false);
+  });
+
+  it('should generate the conditionalFile if the singleFile parameter is set false', async () => {
+    const outputDir = generateFolderName();
+    const generator = new Generator(reactTemplate, outputDir, {
+      forceWrite: true ,
+      templateParams: { version: 'v1', mode: 'production', singleFile: 'false' }
+    });
+    await generator.generateFromFile(dummySpecPath);
+    const conditionalFilePath = path.join(outputDir, 'conditionalFile.txt');
+    const exists = await readFile(conditionalFilePath).then(() => true).catch(() => false);
+    expect(exists).toBe(true);
+  });
+
+  it('should generate the conditionalFile if the singleFile parameter is set false using enum validation', async () => {
+    const outputDir = generateFolderName();
+    const generator = new Generator(reactTemplate, outputDir, {
+      forceWrite: true ,
+      templateParams: { version: 'v1', mode: 'production', singleFile: 'false' }
+    });
+    await generator.generateFromFile(dummySpecPath);
+    const conditionalFilePath = path.join(outputDir, 'conditionalFolder2/input.txt');
+    const exists = await readFile(conditionalFilePath).then(() => true).catch(() => false);
+    expect(exists).toBe(true);
+  });
 });