Merge branch 'master' into postmanClient-hopscotchClient

Author: Light13008

Diff for: apps/generator/docs/nunjucks-render-engine.md

@@ -75,7 +75,9 @@ async function asyncCamelCase(str, callback) {
 }
 ```
 
-In case you have more than one template and want to reuse filters, you can put them in a single library. You can configure such a library in the template configuration under `filters` property. To learn how to add such filters to configuration [read more about the configuration file](#configuration-file).
+In case you have more than one template and want to reuse filters, you can put them in a single library. You can configure such a library in the template configuration under `filters` property. To learn how to add such filters to configuration, [read more about the configuration file](configuration-file).
 
 
-You can also use the official AsyncAPI [nunjucks-filters](/apps/nunjucks-filters) that are by default included in the generator library.
+You can also use the official AsyncAPI [nunjucks-filters](https://github.com/asyncapi/generator/tree/master/apps/nunjucks-filters) which is included by default in the generator library.
+
+> **Note:**  The nunjucks-filters is deprecated, and you should migrate to react-renderer instead. For more details, read notes from release [@asyncapi/generator@2.6.0](https://github.com/asyncapi/generator/releases/tag/%40asyncapi%2Fgenerator%402.6.0).

Diff for: apps/generator/lib/generator.js

@@ -943,10 +943,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)));
   }
 
   /**

Diff for: apps/generator/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
+};

Diff for: apps/generator/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;

Diff for: apps/generator/package.json

@@ -48,10 +48,10 @@
   "license": "Apache-2.0",
   "homepage": "https://github.com/asyncapi/generator",
   "dependencies": {
+    "@asyncapi/generator-hooks": "*",
     "@asyncapi/generator-react-sdk": "^1.1.2",
     "@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",

Diff for: apps/generator/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');
+    });
+  });
+});

Diff for: apps/generator/test/parser.test.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const { sanitizeTemplateApiVersion, usesNewAPI, parse } = require('../lib/parser');
+const { sanitizeTemplateApiVersion, usesNewAPI, parse, convertOldOptionsToNew } = require('../lib/parser');
 const dummyV2Document = fs.readFileSync(path.resolve(__dirname, './docs/dummy.yml'), 'utf8');
 const dummyV3Document = fs.readFileSync(path.resolve(__dirname, './docs/dummyV3.yml'), 'utf8');
 
@@ -99,9 +99,107 @@ describe('Parser', () => {
     });
     it('should be able to parse AsyncAPI v3 document for parser API v3', async () => {
       const parsedDocument = await parse(dummyV3Document, {}, {templateConfig: {apiVersion: 'v3'}});
-
       expect(parsedDocument).toBeDefined();
       expect(parsedDocument.document.version()).toEqual('3.0.0');
     });
   });
+  
+  describe('getProperApiDocument', () => {
+    const parser_api_version = 'x-parser-api-version';
+    const parser_spec_parsed = 'x-parser-spec-parsed';
+    const parser_original_schema = 'x-parser-original-schema-format';
+    const parser_original_payload = 'x-parser-original-payload';
+    const parser_message = 'x-parser-message-parsed';
+    it('should convert to old API if apiVersion is undefined', async () => {
+      // parse calls the get properAPIDocument and returns it along with a diagnostic in a Object
+      // so its like called the get properAPIDocument function and then returned the result
+      const templateConfig = {};
+      const properDocument = await parse(dummyV2Document, {}, { templateConfig }); 
+
+      // Validate that properDocument convert it to expected API version from the template
+      expect(properDocument).toBeDefined();
+
+      expect(properDocument).toBeDefined();
+      expect(properDocument.document._json).toBeDefined();
+      expect(properDocument.document._json.asyncapi).toEqual('2.3.0');
+      expect(properDocument.diagnostics).toBeDefined();
+      expect(properDocument.diagnostics.length).toBeGreaterThan(0);
+
+      expect(properDocument.document._json[parser_api_version]).toBeDefined();
+      expect(properDocument.document._json[parser_api_version]).toEqual(0);
+      expect(properDocument.document._json[parser_spec_parsed]).toBeDefined(); 
+      expect(properDocument.document._json[parser_spec_parsed]).toEqual(true); 
+
+      expect(properDocument.document._meta).toBeDefined();
+      expect(properDocument.document._meta).toEqual({});
+      expect(properDocument.document._json.components.messages.dummyCreated).toBeDefined(); 
+      expect(properDocument.document._json.components.messages.dummyCreated[parser_original_schema]).toBeDefined(); // Only old API includes this filed
+      expect(properDocument.document._json.components.messages.dummyCreated[parser_original_payload]).toBeDefined();
+      expect(properDocument.document._json.components.messages.dummyCreated[parser_message]).toBeDefined();
+    });
+
+    it('should convert to specified API version', async () => {
+      const templateConfig = { apiVersion: 'v2' };
+      const properDocument = await parse(dummyV2Document, {}, { templateConfig });
+
+      // Validate that properDocument is defined
+      expect(properDocument).toBeDefined();
+
+      // Validate that the document is converted to the specified API version
+      expect(properDocument.document._json.asyncapi).toEqual('2.3.0');
+      expect(properDocument.diagnostics).toBeDefined();
+      expect(properDocument.diagnostics.length).toBeGreaterThan(0);
+      
+      expect(properDocument.document._json[parser_api_version]).toBeDefined();
+      expect(properDocument.document._json[parser_spec_parsed]).toBeDefined();
+      expect(properDocument.document._json[parser_api_version]).toEqual(2);
+      expect(properDocument.document._json[parser_spec_parsed]).toEqual(true);
+
+      expect(properDocument.document._meta).toBeDefined();
+      expect(properDocument.document._json.components.messages.dummyCreated).toBeDefined(); 
+      expect(properDocument.document._json.components.messages.dummyCreated[parser_original_schema]).toBeUndefined();
+      expect(properDocument.document._json.components.messages.dummyCreated[parser_original_payload]).toBeUndefined();
+      expect(properDocument.document._json.components.messages.dummyCreated[parser_message]).toBeUndefined();
+    
+      // Validate that old API-specific functions and properties are not present
+      expect(properDocument.oldApiSpecificFunction).toBeUndefined();
+      expect(properDocument.oldApiSpecificProperty).toBeUndefined();
+      expect(properDocument.anotherOldApiFunction).toBeUndefined();
+    });
+  });
+
+  describe('convertOldOptionsToNew', () => {
+    it('should convert old options to new options', () => {
+      const oldOptions = {
+        path: './test/docs/',
+        applyTraits: true,
+        resolve: {
+          http: {
+            order: 1,
+            canRead: true,
+            read: jest.fn()
+          }
+        }
+      };
+      const generator = {
+        mapBaseUrlToFolder: {
+          url: 'https://schema.example.com/crm/',
+          folder: './test/docs/'
+        }
+      };
+      const newOptions = convertOldOptionsToNew(oldOptions, generator);
+
+      expect(newOptions).toBeDefined();
+      expect(newOptions.source).toEqual(oldOptions.path);
+      expect(newOptions.applyTraits).toEqual(oldOptions.applyTraits);
+      expect(newOptions.__unstable).toBeDefined();
+      expect(newOptions.__unstable.resolver.resolvers.length).toBeGreaterThan(0);
+    });
+
+    it('should return undefined if oldOptions is not provided', () => {
+      const newOptions = convertOldOptionsToNew(undefined, {});
+
+      expect(newOptions).toBeUndefined();
+    });
+  });
 });

Diff for: apps/hooks/package.json

@@ -4,7 +4,8 @@
   "description": "Library with hooks function for templates using AsyncAPI Generator",
   "main": "src/index.js",
   "scripts": {
-    "test": "echo There are no tests yet",
+    "test": "npm run test:cleanup && jest --coverage",
+    "test:cleanup": "rimraf \"test/temp\"",
     "lint": "eslint --max-warnings 0 --config ../../.eslintrc --ignore-path ../../.eslintignore .",
     "lint:fix": "eslint --fix --max-warnings 0 --config ../../.eslintrc --ignore-path ../../.eslintignore .",
     "generate:assets": "echo 'No additional assets need to be generated at the moment'"
@@ -32,6 +33,8 @@
   "devDependencies": {
     "eslint": "^6.8.0",
     "eslint-plugin-sonarjs": "^0.5.0",
-    "jsdoc-to-markdown": "^7.1.1"
+    "jest": "^27.3.1",
+    "jsdoc-to-markdown": "^7.1.1",
+    "rimraf": "^3.0.2"
   }
 }