feat: support noOverwriteGlobs for templates based on react

lib/filtersRegistry.js

@@ -12,7 +12,7 @@ const { isAsyncFunction } = require('./utils');
  */
 module.exports.registerFilters = async (nunjucks, templateConfig, templateDir, filtersDir) => {
   await registerLocalFilters(nunjucks, templateDir, filtersDir);
-  registerConfigFilters(nunjucks, templateDir, templateConfig);
+  await registerConfigFilters(nunjucks, templateDir, templateConfig);
 };
 
 /**
@@ -22,7 +22,7 @@ module.exports.registerFilters = async (nunjucks, templateConfig, templateDir, f
  * @param {String} templateDir Directory where template is located.
  * @param {String} filtersDir Directory where local filters are located.
  */
-function registerLocalFilters(nunjucks, templateDir, filtersDir) {
+async function registerLocalFilters(nunjucks, templateDir, filtersDir) {
   return new Promise((resolve, reject) => {
     const localFilters = path.resolve(templateDir, filtersDir);
 

lib/generator.js

@@ -144,6 +144,8 @@ class Generator {
         }
       });
     });
+    // PR 1162: set log level during construction to avoid asynchronous issues
+    this.setLogLevel();
   }
 
   /**
@@ -196,7 +198,8 @@ class Generator {
   async generate(asyncapiDocument, parseOptions = {}) {
     this.validateAsyncAPIDocument(asyncapiDocument);
     await this.setupOutput();
-    this.setLogLevel();
+    // PR 1162: always set log level during construction to avoid asynchronous issues
+    // this.setLogLevel();
 
     await this.installAndSetupTemplate();
     await this.configureTemplateWorkflow(parseOptions);
@@ -847,14 +850,14 @@ class Generator {
    * @param {String} outputPath Path to the resulting rendered file.
    * @param {Object} [extraTemplateData] Extra data to pass to the template.
    */
-  async renderAndWriteToFile(asyncapiDocument, templateFilePath, outputpath, extraTemplateData) {
+  async renderAndWriteToFile(asyncapiDocument, templateFilePath, outputPath, extraTemplateData) {
     const renderContent = await this.renderFile(asyncapiDocument, templateFilePath, extraTemplateData);
     if (renderContent === undefined) {
       return;
     } else if (isReactTemplate(this.templateConfig)) {
-      await saveRenderedReactContent(renderContent, outputpath);
+      await saveRenderedReactContent(renderContent, outputPath, this.noOverwriteGlobs);
     } else {
-      await writeFile(outputpath, renderContent);
+      await writeFile(outputPath, renderContent);
     }
   }
 

lib/logMessages.js

@@ -38,6 +38,10 @@ function relativeSourceFileNotGenerated(relativeSourceFile , subject) {
   return `${relativeSourceFile} was not generated because ${subject} specified in template configuration in conditionalFiles was not found in provided AsyncAPI specification file.`;
 }
 
+function skipOverwrite(testFilePath) {
+  return `Skipping overwrite for: ${testFilePath}`;
+}
+
 function conditionalFilesMatched(relativeSourceFile) {
   return `${relativeSourceFile} was not generated because condition specified for this file in template configuration in conditionalFiles matched.`;
 }
@@ -54,6 +58,7 @@ module.exports = {
   installationDebugMessage,
   templateSuccessfullyInstalled,
   relativeSourceFileNotGenerated,
-  conditionalFilesMatched
+  conditionalFilesMatched,
+  skipOverwrite
 
 };

lib/renderer/react.js

@@ -1,5 +1,8 @@
 const path = require('path');
 const AsyncReactSDK = require('@asyncapi/generator-react-sdk');
+const minimatch = require('minimatch');
+const logMessage = require('../logMessages.js');
+const log = require('loglevel');
 const {
   writeFile
 } = require('../utils');
@@ -8,7 +11,7 @@ const reactExport = module.exports;
 
 /**
  * Configures React templating system, this handles all the transpilation work.
- * 
+ *
  * @private
  * @param {string} templateLocation located for thetemplate
  * @param {string} templateContentDir where the template content are located
@@ -23,76 +26,95 @@ reactExport.configureReact = async (templateLocation, templateContentDir, transp
 
 /**
  * Renders the template with react and returns the content and meta data for the file.
- * 
+ *
  * @private
- * @param {AsyncAPIDocument} asyncapiDocument 
+ * @param {AsyncAPIDocument} asyncapiDocument
  * @param {string} filePath path to the template file
  * @param {Object} extraTemplateData Extra data to pass to the template.
  * @param {string} templateLocation located for thetemplate
  * @param {string} templateContentDir where the template content are located
  * @param {string} transpiledTemplateLocation folder for the transpiled code
  * @param {Object} templateParams provided template parameters
  * @param {boolean} debug flag
- * @param {string} originalAsyncAPI 
+ * @param {string} originalAsyncAPI
  * @return {Promise<TemplateRenderResult>}
  */
 reactExport.renderReact = async (asyncapiDocument, filePath, extraTemplateData, templateLocation, templateContentDir, transpiledTemplateLocation, templateParams, debug, originalAsyncAPI) => {
   extraTemplateData = extraTemplateData || {};
   filePath = filePath.replace(templateContentDir, path.resolve(templateLocation, transpiledTemplateLocation));
   return await AsyncReactSDK.renderTemplate(
-    filePath, 
+    filePath,
     {
       asyncapi: asyncapiDocument,
       params: templateParams,
       originalAsyncAPI,
       ...extraTemplateData
-    }, 
+    },
     debug
   );
 };
 
 /**
  * Save the single rendered react content based on the meta data available.
- * 
+ *
  * @private
  * @param {TemplateRenderResult} renderedContent the react content rendered
  * @param {String} outputPath Path to the file being rendered.
+ * @param {String[]} noOverwriteGlobs globs to check for files that should not be overwritten.
  */
-const saveContentToFile = async (renderedContent, outputPath) => {
+const saveContentToFile = async (renderedContent, outputPath, noOverwriteGlobs = []) => {
   let filePath = outputPath;
-  // Might be the same as in the `fs` package, but is an active choice for our default file permission for any rendered files. 
+  // Might be the same as in the `fs` package, but is an active choice for our default file permission for any rendered files.
   let permissions = 0o666;
   const content = renderedContent.content;
 
+  // Error handling for undefined content or non-string type
   if (content === undefined || typeof content !== 'string') {
     throw Error(`Template file not rendered correctly, was rendered as ${content}`);
   }
+
+  // Adjust file permissions based on metadata, if available
   if (renderedContent.metadata !== undefined) {
     if (renderedContent.metadata.permissions !== undefined) {
       permissions = renderedContent.metadata.permissions;
     }
+
+    // Replace the base filename with a new filename from metadata if specified
     if (renderedContent.metadata.fileName !== undefined) {
       const newFileName = renderedContent.metadata.fileName.trim();
       const basepath = path.basename(filePath);
       filePath = filePath.replace(basepath, newFileName);
     }
   }
 
-  await writeFile(filePath, content, {
-    mode: permissions
-  });
+  // get the final file name of the file
+  const finalFileName = path.basename(filePath);
+  // check whether the filename should be ignored based on user's inputs
+  const shouldOverwrite = !noOverwriteGlobs.some(globExp => minimatch(finalFileName, globExp));
+
+  // Write the file only if it should not be skipped
+  if (shouldOverwrite) {
+    await writeFile(filePath, content, {
+      mode: permissions
+    });
+  } else {
+    log.debug(logMessage.skipOverwrite(filePath));
+  }
 };
 
 /**
  * Save the rendered react content based on the meta data available.
- * 
+ *
  * @private
  * @param {TemplateRenderResult[] | TemplateRenderResult} renderedContent the react content rendered
  * @param {String} outputPath Path to the file being rendered.
+ * @param {String[]} noOverwriteGlobs globs to check for files that should not be overwritten.
  */
-reactExport.saveRenderedReactContent = async (renderedContent, outputPath) => {
+reactExport.saveRenderedReactContent = async (renderedContent, outputPath, noOverwriteGlobs = []) => {
+  // If the rendered content is an array, we need to save each file individually
   if (Array.isArray(renderedContent)) {
-    return Promise.all(renderedContent.map(content => saveContentToFile(content, outputPath)));
+    return Promise.all(renderedContent.map(content => saveContentToFile(content, outputPath, noOverwriteGlobs)));
   }
-  return saveContentToFile(renderedContent, outputPath);
+  // Otherwise, we can save the single file
+  return saveContentToFile(renderedContent, outputPath, noOverwriteGlobs);
 };

package.json

@@ -15,8 +15,8 @@
     "test": "npm run test:unit && npm run test:integration && npm run test:cli",
     "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__'",
-    "test:integration:update": "jest --updateSnapshot --testPathPattern=integration --modulePathIgnorePatterns='./__mocks__'",
+    "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:cli": "node cli.js ./test/docs/dummy.yml ./test/test-templates/react-template -o test/output --force-write --debug && test -e test/output/test-file.md",
     "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",
@@ -79,8 +79,8 @@
   "devDependencies": {
     "eslint": "^6.8.0",
     "eslint-plugin-jest": "^23.8.2",
-    "eslint-plugin-sonarjs": "^0.5.0",
     "eslint-plugin-react": "^7.34.1",
+    "eslint-plugin-sonarjs": "^0.5.0",
     "jest": "^25.5.0",
     "jsdoc-to-markdown": "^7.1.1",
     "markdown-toc": "^1.2.0",

test/integration.test.js

@@ -3,25 +3,38 @@
  */
 
 const { readFile } = require('fs').promises;
+const { existsSync } = require('fs');
 const path = require('path');
 const Generator = require('../lib/generator');
 const dummySpecPath = path.resolve(__dirname, './docs/dummy.yml');
 const refSpecPath = path.resolve(__dirname, './docs/apiwithref.json');
 const refSpecFolder = path.resolve(__dirname, './docs/');
 const crypto = require('crypto');
+const {mkdirSync} = require('fs');
+const {exists, writeFile} = require('../lib/utils');
 const mainTestResultPath = 'test/temp/integrationTestResult';
 const reactTemplate = 'test/test-templates/react-template';
 const nunjucksTemplate = 'test/test-templates/nunjucks-template';
+const logMessage = require('../lib/logMessages.js');
+const log = require('loglevel');
 
 describe('Integration testing generateFromFile() to make sure the result of the generation is not changend comparing to snapshot', () => {
   const generateFolderName = () => {
-    //you always want to generate to new directory to make sure test runs in clear environment
+    // you always want to generate to new directory to make sure test runs in clear environment
+    // normalize the path for cross-platform compatibility
+    // return path.normalize(path.resolve(mainTestResultPath, crypto.randomBytes(4).toString('hex')));
     return path.resolve(mainTestResultPath, crypto.randomBytes(4).toString('hex'));
   };
 
   jest.setTimeout(60000);
   const testOutputFile = 'test-file.md';
 
+  beforeAll(() => {
+    if (!existsSync(path.join(reactTemplate, 'package.json'))) {
+      throw new Error(`React template not found at ${reactTemplate}`);
+    }
+  });
+
   it('generated using Nunjucks template', async () => {
     const outputDir = generateFolderName();
     const generator = new Generator(nunjucksTemplate, outputDir, { 
@@ -55,4 +68,39 @@ describe('Integration testing generateFromFile() to make sure the result of the
     const file = await readFile(path.join(outputDir, testOutputFile), 'utf8');
     expect(file).toMatchSnapshot();
   });
+
+  it('should ignore specified files with noOverwriteGlobs', async () => {
+    const logSpyDebug = jest.spyOn(log, 'debug').mockImplementation(() => {});
+    // log.debug = jest.fn(); 
+
+    const outputDir = generateFolderName();
+    // Manually create a file to test if it's not overwritten
+    if (!await exists(outputDir)) {
+      mkdirSync(outputDir, { recursive: true });
+    }
+    // Create a variable to store the file content
+    const testContent = '<script>const initialContent = "This should not change";</script>';
+    // eslint-disable-next-line sonarjs/no-duplicate-string
+    const testFilePath = path.normalize(path.resolve(outputDir, testOutputFile));
+    await writeFile(testFilePath, testContent);
+
+    // Manually create an output first, before generation, with additional custom file to validate if later it is still there, not overwritten
+    const generator = new Generator(reactTemplate, outputDir, {
+      forceWrite: true,
+      noOverwriteGlobs: [`**/${testOutputFile}`],
+      debug: true
+    });
+
+    await generator.generateFromFile(dummySpecPath);
+
+    // Read the file to confirm it was not overwritten
+    const fileContent = await readFile(testFilePath, 'utf8');
+    // Check if the files have been overwritten
+    await expect(fileContent).toBe(testContent);
+    // Check if the log debug message was printed
+    await expect(logSpyDebug).toHaveBeenCalledWith(logMessage.skipOverwrite(testFilePath));
+
+    // Clean up
+    logSpyDebug.mockRestore();
+  });
 });