improve code structure

Author: AayushSaini101

src/apps/cli/internal/base.ts

@@ -35,15 +35,15 @@ export default abstract class extends Command {
     await this.recordActionInvoked(commandName, this.metricsMetadata);
   }
 
-  async catch(err: Error & { exitCode?: number }): Promise<any> {
+  async catch(err: Error & { exitCode?: number }): Promise<void> {
     try {
-      return await super.catch(err);
-    } catch (e: any) {
-      if (e.message.includes('EEXIT: 0')) {
-        process.exitCode = 0;
-        return;
-      }
+      await super.catch(err);
+    } catch (e: unknown) {
       if (e instanceof Error) {
+        if (e.message.includes('EEXIT: 0')) {
+          process.exitCode = 0;
+          return;
+        }
         this.logToStderr(`${e.name}: ${e.message}`);
         process.exitCode = 1;
       }
@@ -63,7 +63,7 @@ export default abstract class extends Command {
           // @ts-ignore
           metadata = MetadataFromDocument(document, metadata);
         }
-      } catch (e: any) {
+      } catch (e: unknown) {
         if (e instanceof Error) {
           this.log(
             `Skipping submitting anonymous metrics due to the following error: ${e.name}: ${e.message}`,
@@ -92,7 +92,7 @@ export default abstract class extends Command {
       await this.setSource();
       await recordFunc(await this.recorder);
       await (await this.recorder).flush();
-    } catch (e: any) {
+    } catch (e: unknown) {
       if (e instanceof Error) {
         this.log(
           `Skipping submitting anonymous metrics due to the following error: ${e.name}: ${e.message}`,
@@ -109,8 +109,9 @@ export default abstract class extends Command {
     try {
       const stats = await stat(specFilePath);
       this.metricsMetadata['file_creation_timestamp'] = stats.birthtimeMs;
-    } catch (e: any) {
-      // If there's an error with the file, we don't handle it here because it's expected to be handled and reported in the 'finally' method of the command.
+    } catch {
+      // If there's an error with the file, we don't handle it here 
+      // because it's expected to be handled and reported in the 'finally' method of the command.
     }
   }
   async finally(error: Error | undefined): Promise<any> {

src/apps/cli/internal/globals.ts

@@ -2,6 +2,7 @@ import chokidar from 'chokidar';
 import chalk from 'chalk';
 import Command from './base';
 import { Specification } from '@models/SpecificationFile';
+import { getErrorMessage } from '@utils/error-handler';
 
 const GreenLog = chalk.hex('#00FF00');
 const OrangeLog = chalk.hex('#FFA500');
@@ -50,12 +51,12 @@ export const specWatcher = (params: SpecWatcherParams) => {
 
       try {
         await params.handler.run();
-      } catch (err: any) {
-        await params.handler.catch(err);
+      } catch (err: unknown) {
+        await params.handler.catch(err as Error);
       }
     });
     CHOKIDAR_INSTANCE_STORE.set(params.label || '_default', true);
-  } catch (error) {
-    console.log(error);
+  } catch (error: unknown) {
+    console.error(chalk.red(`Watch error: ${getErrorMessage(error)}`));
   }
 };

src/domains/models/SpecificationFile.ts

@@ -7,6 +7,8 @@ import { ErrorLoadingSpec } from '@errors/specification-file';
 import { MissingContextFileError } from '@errors/context-error';
 import { fileFormat } from '@cli/internal/flags/format.flags';
 import { HttpsProxyAgent } from 'https-proxy-agent';
+import { logger } from '@utils/logger';
+import { getErrorMessage } from '@utils/error-handler';
 const { readFile, lstat } = fs;
 const allowedFileNames: string[] = [
   'asyncapi.json',
@@ -102,7 +104,7 @@ export class Specification {
       // Validate the target URL
       new URL(targetUrl);
 
-      const fetchOptions: any = { method: 'GET' };
+      const fetchOptions: RequestInit & { agent?: HttpsProxyAgent<string> } = { method: 'GET' };
 
       // If proxy URL is provided, create a proxy agent
       if (proxyUrl) {
@@ -111,7 +113,8 @@ export class Specification {
           const proxyAgent = new HttpsProxyAgent(proxyUrl);
           fetchOptions.agent = proxyAgent;
           response = await fetch(targetUrl, fetchOptions);
-        } catch (err: any) {
+        } catch (err: unknown) {
+          logger.error(`Proxy connection error: ${getErrorMessage(err)}`);
           throw new Error(
             'Proxy Connection Error: Unable to establish a connection to the proxy check hostName or PortNumber',
           );
@@ -122,8 +125,8 @@ export class Specification {
           throw new ErrorLoadingSpec('url', targetUrl);
         }
       }
-    } catch (error) {
-      console.log(error);
+    } catch (error: unknown) {
+      logger.error(`Error loading spec from URL: ${getErrorMessage(error)}`);
       throw new ErrorLoadingSpec('url', targetUrl);
     }
 
@@ -289,23 +292,37 @@ export function retrieveFileFormat(content: string): fileFormat | undefined {
   }
 }
 
-export function convertToYaml(spec: string) {
+/**
+ * Converts a JSON or YAML specification to YAML format.
+ * 
+ * @param spec - The specification content as a string
+ * @returns The YAML formatted string, or undefined if conversion fails
+ */
+export function convertToYaml(spec: string): string | undefined {
   try {
     // JS object -> YAML string
     const jsonContent = yaml.load(spec);
     return yaml.dump(jsonContent);
-  } catch (err) {
-    console.error(err);
+  } catch (err: unknown) {
+    logger.error(`Failed to convert spec to YAML: ${getErrorMessage(err)}`);
+    return undefined;
   }
 }
 
-export function convertToJSON(spec: string) {
+/**
+ * Converts a JSON or YAML specification to JSON format.
+ * 
+ * @param spec - The specification content as a string
+ * @returns The JSON formatted string, or undefined if conversion fails
+ */
+export function convertToJSON(spec: string): string | undefined {
   try {
     // JSON or YAML String -> JS object
     const jsonContent = yaml.load(spec);
     // JS Object -> pretty JSON string
     return JSON.stringify(jsonContent, null, 2);
-  } catch (err) {
-    console.error(err);
+  } catch (err: unknown) {
+    logger.error(`Failed to convert spec to JSON: ${getErrorMessage(err)}`);
+    return undefined;
   }
 }

src/domains/services/base.service.ts

@@ -1,26 +1,50 @@
 import { ServiceResult } from '@/interfaces';
+import type { Diagnostic } from '@asyncapi/parser/cjs';
 
+/**
+ * Base service class providing common functionality for all domain services.
+ * Provides standardized result handling and error management.
+ */
 export abstract class BaseService {
+  /**
+   * Creates a successful service result with the provided data.
+   *
+   * @param data - The data to include in the result
+   * @returns A successful ServiceResult containing the data
+   */
   protected createSuccessResult<T>(data: T): ServiceResult<T> {
     return {
       success: true,
       data,
     };
   }
 
-  protected createErrorResult(
+  /**
+   * Creates an error service result with the provided error message.
+   *
+   * @param error - The error message
+   * @param diagnostics - Optional diagnostics array for validation errors
+   * @returns A failed ServiceResult containing the error
+   */
+  protected createErrorResult<T>(
     error: string,
-    diagnostics?: any[],
-  ): ServiceResult {
+    diagnostics?: Diagnostic[],
+  ): ServiceResult<T> {
     return {
       success: false,
       error,
       diagnostics,
     };
   }
 
-  protected async handleServiceError(error: any): Promise<ServiceResult> {
+  /**
+   * Handles service errors by converting them to a standardized error result.
+   *
+   * @param error - The caught error (can be any type)
+   * @returns A failed ServiceResult with the error message
+   */
+  protected async handleServiceError<T>(error: unknown): Promise<ServiceResult<T>> {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    return this.createErrorResult(errorMessage);
+    return this.createErrorResult<T>(errorMessage);
   }
 }

src/domains/services/convert.service.ts

@@ -68,16 +68,27 @@ export class ConversionService extends BaseService {
     return `🎉 The ${outputMap[flags.format]} from ${cyan(sourcePath)} has been successfully converted to AsyncAPI version ${green(targetVersion)}!!`;
   }
 
-  // Helper function to format the converted file
-  private formatConvertedFile(convertedFile: any) {
+  /**
+   * Formats the converted document for output.
+   * Objects are stringified with indentation, strings are returned as-is.
+   *
+   * @param convertedFile - The converted file content
+   * @returns Formatted string representation
+   */
+  private formatConvertedFile(convertedFile: string | object): string {
     return typeof convertedFile === 'object'
       ? JSON.stringify(convertedFile, null, 4)
       : convertedFile;
   }
 
-  // Helper function to handle output
-  async handleOutput(outputPath: string, convertedFileFormatted: string) {
-    await fPromises.writeFile(`${outputPath}`, convertedFileFormatted, {
+  /**
+   * Writes the converted document to the specified output path.
+   *
+   * @param outputPath - The path to write the file to
+   * @param convertedFileFormatted - The formatted content to write
+   */
+  async handleOutput(outputPath: string, convertedFileFormatted: string): Promise<void> {
+    await fPromises.writeFile(outputPath, convertedFileFormatted, {
       encoding: 'utf8',
     });
   }

src/domains/services/generator.service.ts

@@ -11,6 +11,15 @@ import { spinner } from '@clack/prompts';
 import path from 'path';
 import os from 'os';
 import { yellow, magenta } from 'picocolors';
+import { getErrorMessage } from '@utils/error-handler';
+
+/**
+ * Options passed to the generator for code generation.
+ */
+interface GeneratorRunOptions {
+  path?: Specification;
+  [key: string]: unknown;
+}
 
 export class GeneratorService extends BaseService {
   private defaultInteractive: boolean;
@@ -63,12 +72,23 @@ export class GeneratorService extends BaseService {
     }
   }
 
+  /**
+   * Generates code from an AsyncAPI specification using the specified template.
+   *
+   * @param asyncapi - The AsyncAPI specification to generate from
+   * @param template - The template to use for generation
+   * @param output - The output directory for generated files
+   * @param options - Generator options
+   * @param genOption - Additional generator run options
+   * @param interactive - Whether to show interactive spinner (default: false)
+   * @returns ServiceResult containing generation result or error
+   */
   async generate(
     asyncapi: Specification,
     template: string,
     output: string,
     options: GenerationOptions,
-    genOption: any,
+    genOption: GeneratorRunOptions = {},
     interactive = this.defaultInteractive,
   ): Promise<ServiceResult<GenerationResult>> {
     const v3NotSupported = this.checkV3NotSupported(asyncapi, template);
@@ -84,16 +104,20 @@ export class GeneratorService extends BaseService {
     );
     const s = interactive
       ? spinner()
-      : { start: () => null, stop: (string: string) => logs.push(string) };
+      : { start: () => null, stop: (message: string) => logs.push(message) };
     s.start('Generation in progress. Keep calm and wait a bit');
     try {
       await generator.generateFromString(asyncapi.text(), {
         ...genOption,
         path: asyncapi,
       });
-    } catch (err: any) {
+    } catch (err: unknown) {
       s.stop('Generation failed');
-      return this.createErrorResult(err.message, err.diagnostics);
+      const errorMessage = getErrorMessage(err, 'Generation failed');
+      const diagnostics = err && typeof err === 'object' && 'diagnostics' in err 
+        ? (err as { diagnostics?: unknown[] }).diagnostics as Parameters<typeof this.createErrorResult>[1]
+        : undefined;
+      return this.createErrorResult(errorMessage, diagnostics);
     }
     s.stop(
       this.getGenerationSuccessMessage(output),