feat: enable proxy support in the cli

package.json

@@ -29,6 +29,7 @@
     "fast-levenshtein": "^3.0.0",
     "fs-extra": "^11.1.0",
     "generator-v2": "npm:@asyncapi/generator@^2.4.1",
+    "https-proxy-agent": "^7.0.6",
     "inquirer": "^8.2.0",
     "js-yaml": "^4.1.0",
     "lodash.template": "^4.4.0",
@@ -172,4 +173,4 @@
     "action:test": "cd github-action && make test"
   },
   "types": "lib/index.d.ts"
-}
+}

src/commands/convert.ts

@@ -8,7 +8,7 @@ import { SpecificationFileNotFound } from '../core/errors/specification-file';
 import { convert, convertOpenAPI, convertPostman } from '@asyncapi/converter';
 import type { AsyncAPIConvertVersion, OpenAPIConvertVersion } from '@asyncapi/converter';
 import { cyan, green } from 'picocolors';
-
+import { proxyFlags } from '../core/flags/proxy.flags';
 // @ts-ignore
 import specs from '@asyncapi/specs';
 import { convertFlags } from '../core/flags/convert.flags';
@@ -20,15 +20,27 @@ export default class Convert extends Command {
   static metricsMetadata: any = {};
   static description = 'Convert asyncapi documents older to newer versions or OpenAPI/postman-collection documents to AsyncAPI';
 
-  static flags = convertFlags(latestVersion);
+  static flags = {
+    ...convertFlags(latestVersion),
+    ...proxyFlags()
+
+  };
 
   static args = {
     'spec-file': Args.string({description: 'spec path, url, or context-name', required: false}),
+    proxyHost: Args.string({description: 'Name of the Proxy Host', required: false}),
+    proxyPort: Args.string({description: 'Name of the Port of the ProxyHost', required: false}),
   };
 
   async run() {
     const { args, flags } = await this.parse(Convert);
-    const filePath = args['spec-file'];
+    let filePath = args['spec-file'];
+    const proxyHost = flags['proxyHost'];
+    const proxyPort = flags['proxyPort'];
+    if (proxyHost && proxyPort) {
+      const proxyUrl = `http://${proxyHost}:${proxyPort}`;
+      filePath = `${filePath}+${proxyUrl}`; // Update filePath with proxyUrl
+    }
     let convertedFile;
     let convertedFileFormatted;
 

src/commands/optimize.ts

@@ -8,7 +8,7 @@ import chalk from 'chalk';
 import { promises } from 'fs';
 import { Parser } from '@asyncapi/parser';
 import { optimizeFlags } from '../core/flags/optimize.flags';
-
+import { proxyFlags } from '../core/flags/proxy.flags';
 const { writeFile } = promises;
 
 export enum Optimizations {
@@ -42,18 +42,28 @@ export default class Optimize extends Command {
     'asyncapi optimize ./asyncapi.yaml --ignore=schema'
   ];
 
-  static flags = optimizeFlags();
+  static flags = {
+    ...optimizeFlags(),
+    ...proxyFlags(),
+  };
 
   static args = {
     'spec-file': Args.string({description: 'spec path, url, or context-name', required: false}),
+    proxyHost: Args.string({description: 'Name of the Proxy Host', required: false}),
+    proxyPort: Args.string({description: 'Name of the Port of the ProxyHost', required: false}),
   };
 
   parser = new Parser();
 
   async run() {
     const { args, flags } = await this.parse(Optimize); //NOSONAR
-    const filePath = args['spec-file'];
-
+    let filePath = args['spec-file'];
+    const proxyHost = flags['proxyHost'];
+    const proxyPort = flags['proxyPort'];
+    if (proxyHost && proxyPort) {
+      const proxyUrl = `http://${proxyHost}:${proxyPort}`;
+      filePath = `${filePath}+${proxyUrl}`; // Update filePath with proxyUrl
+    }
     try {
       this.specFile = await load(filePath);
     } catch (err) {

src/commands/validate.ts

@@ -4,32 +4,41 @@ import { validate, ValidateOptions, ValidationStatus, parse } from '../core/pars
 import { load } from '../core/models/SpecificationFile';
 import { specWatcher } from '../core/globals';
 import { validateFlags } from '../core/flags/validate.flags';
+import { proxyFlags } from '../core/flags/proxy.flags';
 import { calculateScore } from '../core/utils/scoreCalculator';
 
 export default class Validate extends Command {
   static description = 'validate asyncapi file';
 
-  static flags = validateFlags();
+  static flags = {
+    ...validateFlags(),
+    ...proxyFlags(), // Merge proxyFlags with validateFlags
+  };
 
   static args = {
     'spec-file': Args.string({description: 'spec path, url, or context-name', required: false}),
+    proxyHost: Args.string({description: 'Name of the Proxy Host', required: false}),
+    proxyPort: Args.string({description: 'Name of the Port of the ProxyHost', required: false}),
   };
 
   async run() {
     const { args, flags } = await this.parse(Validate); //NOSONAR
-
-    const filePath = args['spec-file'];
+    let filePath = args['spec-file'];
+    const proxyHost = flags['proxyHost'];
+    const proxyPort = flags['proxyPort'];
+    if (proxyHost && proxyPort) {
+      const proxyUrl = `http://${proxyHost}:${proxyPort}`;
+      filePath = `${filePath}+${proxyUrl}`; // Update filePath with proxyUrl
+    }
+    this.specFile = await load(filePath);
     const watchMode = flags.watch;
     if (flags['score']) {
-      this.specFile = await load(filePath);
       const { document } = await parse(this,this.specFile);
       this.log(`The score of the asyncapi document is ${await calculateScore(document)}`);
     }
-    this.specFile = await load(filePath);
     if (watchMode) {
       specWatcher({ spec: this.specFile, handler: this, handlerName: 'validate' });
     }
-
     const result = await validate(this, this.specFile, flags as ValidateOptions);
     this.metricsMetadata.validation_result = result;
 

src/core/flags/proxy.flags.ts

@@ -0,0 +1,15 @@
+import { Flags } from '@oclif/core';
+
+export const proxyFlags = () => {
+  return {
+    proxyHost: Flags.string({
+      description: 'Name of the ProxyHost',
+      required: false
+    }),
+    proxyPort: Flags.string({
+      description: 'Port number number for the proxyHost.',
+      required: false
+    })
+  };
+};
+

src/core/models/SpecificationFile.ts

@@ -7,7 +7,7 @@ import { loadContext } from './Context';
 import { ErrorLoadingSpec } from '../errors/specification-file';
 import { MissingContextFileError } from '../errors/context-error';
 import { fileFormat } from 'core/flags/format.flags';
-
+import { HttpsProxyAgent } from 'https-proxy-agent';
 const { readFile, lstat } = fs;
 const allowedFileNames: string[] = [
   'asyncapi.json',
@@ -87,15 +87,42 @@ export class Specification {
 
   static async fromURL(URLpath: string) {
     let response;
+    const delimiter = '+';
+    let targetUrl = URLpath;
+    let proxyUrl = '';
+
+    // Check if URLpath contains a proxy URL
+    if (URLpath.includes(delimiter)) {
+      [targetUrl, proxyUrl] = URLpath.split(delimiter);
+    }
+
     try {
-      response = await fetch(URLpath, { method: 'GET' });
+    // Validate the target URL
+      new URL(targetUrl);
+
+      const fetchOptions: any = { method: 'GET' };
+
+      // If proxy URL is provided, create a proxy agent
+      if (proxyUrl) {
+        try {
+          new URL(proxyUrl);
+          const proxyAgent = new HttpsProxyAgent(proxyUrl,);
+          fetchOptions.agent = proxyAgent;
+        } catch (error) {
+          throw new Error(`Invalid proxy URL: ${proxyUrl}`);
+        }
+      }
+
+      // Fetch the target URL
+      response = await fetch(targetUrl, fetchOptions);
       if (!response.ok) {
-        throw new ErrorLoadingSpec('url', URLpath);
+        throw new ErrorLoadingSpec('url', targetUrl);
       }
     } catch (error) {
-      throw new ErrorLoadingSpec('url', URLpath);
+      throw new ErrorLoadingSpec('url', targetUrl);
     }
-    return new Specification(await response?.text() as string, { fileURL: URLpath });
+
+    return new Specification(await response?.text() as string, { fileURL: targetUrl });
   }
 }