feat: support noOverwriteGlobs for templates based on react

lib/generator.js

@@ -532,7 +532,7 @@ class Generator {
       arbOptions.registry = providedRegistry;
       registryUrl = providedRegistry;
     }
-    
+
     const domainName = registryUrl.replace(/^https?:\/\//, '');
     //doing basic if/else so basically only one auth type is used and token as more secure is primary
     if (this.registry.token) {
@@ -541,7 +541,7 @@ class Generator {
     } else if (this.registry.auth) {
       authorizationName = `//${domainName}:_auth`;
       arbOptions[authorizationName] = this.registry.auth;
-    } 
+    }
 
     //not sharing in logs neither token nor auth for security reasons
     log.debug(`Using npm registry ${registryUrl} and authorization type ${authorizationName} to handle template installation.`);
@@ -556,14 +556,14 @@ class Generator {
       let pkgPath;
       let installedPkg;
       let packageVersion;
-  
+
       try {
         installedPkg = getTemplateDetails(this.templateName, PACKAGE_JSON_FILENAME);
         pkgPath = installedPkg && installedPkg.pkgPath;
         packageVersion = installedPkg && installedPkg.version;
         log.debug(logMessage.templateSource(pkgPath));
         if (packageVersion) log.debug(logMessage.templateVersion(packageVersion));
-  
+
         return {
           name: installedPkg.name,
           path: pkgPath
@@ -573,38 +573,38 @@ class Generator {
         // We did our best. Proceed with installation...
       }
     }
-  
+
     const debugMessage = force ? logMessage.TEMPLATE_INSTALL_FLAG_MSG : logMessage.TEMPLATE_INSTALL_DISK_MSG;
     log.debug(logMessage.installationDebugMessage(debugMessage));
-  
+
     if (isFileSystemPath(this.templateName)) log.debug(logMessage.NPM_INSTALL_TRIGGER);
-  
+
     const arbOptions = {
       path: ROOT_DIR,
     };
     if (this.registry) {
       this.initialiseArbOptions(arbOptions);
     }
-  
+
     const arb = new Arborist(arbOptions);
-    
+
     try {
       const installResult = await arb.reify({
         add: [this.templateName],
         saveType: 'prod',
         save: false
       });
-  
+
       const addResult = arb[Symbol.for('resolvedAdd')];
       if (!addResult) throw new Error('Unable to resolve the name of the added package. It was most probably not added to node_modules successfully');
-  
+
       const packageName = addResult[0].name;
       const packageVersion = installResult.children.get(packageName).version;
       const packagePath = installResult.children.get(packageName).path;
-  
+
       if (!isFileSystemPath(this.templateName)) log.debug(logMessage.templateSuccessfullyInstalled(packageName, packagePath));
       if (packageVersion) log.debug(logMessage.templateVersion(packageVersion));
-  
+
       return {
         name: packageName,
         path: packagePath,
@@ -834,14 +834,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/renderer/react.js

@@ -1,5 +1,6 @@
 const path = require('path');
 const AsyncReactSDK = require('@asyncapi/generator-react-sdk');
+const minimatch = require('minimatch');
 const {
   writeFile
 } = require('../utils');
@@ -8,7 +9,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 +24,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 {
+    console.log(`Skipping overwrite for: ${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);
 };

test/integration.test.js

@@ -9,6 +9,8 @@ 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';
 //we do not want to download chromium for html-template if it is not needed
 process.env['PUPPETEER_SKIP_CHROMIUM_DOWNLOAD'] = true;
@@ -25,6 +27,7 @@ describe('Integration testing generateFromFile() to make sure the result of the
     const outputDir = generateFolderName();
     const generator = new Generator('@asyncapi/html-template@0.18.0', outputDir, { forceWrite: true, templateParams: { singleFile: true } });
     await generator.generateFromFile(dummySpecPath);
+    // eslint-disable-next-line sonarjs/no-duplicate-string
     const file = await readFile(path.join(outputDir, 'index.html'), 'utf8');
     expect(file).toMatchSnapshot();
   });
@@ -48,4 +51,27 @@ describe('Integration testing generateFromFile() to make sure the result of the
     const file = await readFile(path.join(outputDir, 'index.html'), 'utf8');
     expect(file).toMatchSnapshot();
   });
+
+  it('should ignore specified files with noOverwriteGlobs', async () => {
+    const outputDir = generateFolderName();
+    // Manually create a file to test if it's not overwritten
+    if (!await exists(outputDir)) {
+      mkdirSync(outputDir, { recursive: true });
+    }
+    // eslint-disable-next-line sonarjs/no-duplicate-string
+    const testFilePath = path.join(outputDir, 'index.html');
+    await writeFile(testFilePath, '<script>const initialContent = "This should not change";</script>');
+
+    // based on the html-template documentation, the default output is index.html
+    const generator = new Generator('@asyncapi/html-template@0.28.0', outputDir, {
+      forceWrite: true,
+      noOverwriteGlobs: ['**/index.html']
+    });
+
+    await generator.generateFromFile(dummySpecPath);
+
+    // Read the file to confirm it was not overwritten
+    const fileContent = await readFile(testFilePath, 'utf8');
+    expect(fileContent).toBe('<script>const initialContent = "This should not change";</script>');
+  });
 });