@asyncapi/cli 4.1.1 → 5.0.1

package/lib/domains/models/SpecificationFile.js

@@ -17,6 +17,8 @@ const Context_1 = require("./Context");
 const specification_file_1 = require("../../errors/specification-file");
 const context_error_1 = require("../../errors/context-error");
 const https_proxy_agent_1 = require("https-proxy-agent");
+const logger_1 = require("../../utils/logger");
+const error_handler_1 = require("../../utils/error-handler");
 const { readFile, lstat } = fs_1.promises;
 const allowedFileNames = [
     'asyncapi.json',
@@ -107,6 +109,7 @@ class Specification {
                         response = yield fetch(targetUrl, fetchOptions);
                     }
                     catch (err) {
+                        logger_1.logger.error(`Proxy connection error: ${(0, error_handler_1.getErrorMessage)(err)}`);
                         throw new Error('Proxy Connection Error: Unable to establish a connection to the proxy check hostName or PortNumber');
                     }
                 }
@@ -118,7 +121,7 @@ class Specification {
                 }
             }
             catch (error) {
-                console.log(error);
+                logger_1.logger.error(`Error loading spec from URL: ${(0, error_handler_1.getErrorMessage)(error)}`);
                 throw new specification_file_1.ErrorLoadingSpec('url', targetUrl);
             }
             return new Specification((yield (response === null || response === void 0 ? void 0 : response.text())), {
@@ -272,6 +275,12 @@ function retrieveFileFormat(content) {
         return undefined;
     }
 }
+/**
+ * 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
+ */
 function convertToYaml(spec) {
     try {
         // JS object -> YAML string
@@ -279,9 +288,16 @@ function convertToYaml(spec) {
         return js_yaml_1.default.dump(jsonContent);
     }
     catch (err) {
-        console.error(err);
+        logger_1.logger.error(`Failed to convert spec to YAML: ${(0, error_handler_1.getErrorMessage)(err)}`);
+        return undefined;
     }
 }
+/**
+ * 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
+ */
 function convertToJSON(spec) {
     try {
         // JSON or YAML String -> JS object
@@ -290,6 +306,7 @@ function convertToJSON(spec) {
         return JSON.stringify(jsonContent, null, 2);
     }
     catch (err) {
-        console.error(err);
+        logger_1.logger.error(`Failed to convert spec to JSON: ${(0, error_handler_1.getErrorMessage)(err)}`);
+        return undefined;
     }
 }

package/lib/domains/models/Studio.js

@@ -9,7 +9,6 @@ const http_1 = require("http");
 const ws_1 = require("ws");
 const chokidar_1 = tslib_1.__importDefault(require("chokidar"));
 const open_1 = tslib_1.__importDefault(require("open"));
-const next_1 = tslib_1.__importDefault(require("next"));
 const path_1 = tslib_1.__importDefault(require("path"));
 const package_json_1 = require("@asyncapi/studio/package.json");
 const picocolors_1 = require("picocolors");
@@ -20,6 +19,13 @@ exports.DEFAULT_PORT = 0;
 function isValidFilePath(filePath) {
     return (0, fs_1.existsSync)(filePath);
 }
+function resolveStudioNextInstance(studioPath) {
+    var _a;
+    const resolvedNextPath = require.resolve('next', { paths: [studioPath] });
+    // eslint-disable-next-line @typescript-eslint/no-var-requires,security/detect-non-literal-require
+    const nextModule = require(resolvedNextPath);
+    return (_a = nextModule.default) !== null && _a !== void 0 ? _a : nextModule;
+}
 // eslint-disable-next-line sonarjs/cognitive-complexity
 function start(filePath, port = exports.DEFAULT_PORT, noBrowser) {
     if (filePath && !isValidFilePath(filePath)) {
@@ -27,7 +33,8 @@ function start(filePath, port = exports.DEFAULT_PORT, noBrowser) {
     }
     // Locate @asyncapi/studio package
     const studioPath = path_1.default.dirname(require.resolve('@asyncapi/studio/package.json'));
-    const app = (0, next_1.default)({
+    const nextInstance = resolveStudioNextInstance(studioPath);
+    const app = nextInstance({
         dev: false,
         dir: studioPath,
         conf: {

package/lib/domains/services/base.service.d.ts

@@ -1,6 +1,30 @@
 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 declare 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>;
-    protected createErrorResult(error: string, diagnostics?: any[]): ServiceResult;
-    protected handleServiceError(error: any): Promise<ServiceResult>;
+    /**
+     * 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?: Diagnostic[]): ServiceResult<T>;
+    /**
+     * 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 handleServiceError<T>(error: unknown): Promise<ServiceResult<T>>;
 }

package/lib/domains/services/base.service.js

@@ -2,13 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseService = void 0;
 const tslib_1 = require("tslib");
+/**
+ * Base service class providing common functionality for all domain services.
+ * Provides standardized result handling and error management.
+ */
 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
+     */
     createSuccessResult(data) {
         return {
             success: true,
             data,
         };
     }
+    /**
+     * 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
+     */
     createErrorResult(error, diagnostics) {
         return {
             success: false,
@@ -16,6 +33,12 @@ class BaseService {
             diagnostics,
         };
     }
+    /**
+     * 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
+     */
     handleServiceError(error) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const errorMessage = error instanceof Error ? error.message : String(error);

package/lib/domains/services/convert.service.d.ts

@@ -7,6 +7,19 @@ export declare class ConversionService extends BaseService {
      */
     convertDocument(specFile: Specification, options: ConversionOptions): Promise<ServiceResult<ConversionResult>>;
     handleLogging(specFile: Specification, flags: ConversionOptions): string;
+    /**
+     * 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;
+    /**
+     * 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
+     */
     handleOutput(outputPath: string, convertedFileFormatted: string): Promise<void>;
 }

package/lib/domains/services/convert.service.js

@@ -47,16 +47,27 @@ class ConversionService extends base_service_1.BaseService {
         };
         return `🎉 The ${outputMap[flags.format]} from ${(0, picocolors_1.cyan)(sourcePath)} has been successfully converted to AsyncAPI version ${(0, picocolors_1.green)(targetVersion)}!!`;
     }
-    // Helper function to format the converted file
+    /**
+     * 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
+     */
     formatConvertedFile(convertedFile) {
         return typeof convertedFile === 'object'
             ? JSON.stringify(convertedFile, null, 4)
             : convertedFile;
     }
-    // Helper function to handle output
+    /**
+     * 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
+     */
     handleOutput(outputPath, convertedFileFormatted) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            yield fs_1.promises.writeFile(`${outputPath}`, convertedFileFormatted, {
+            yield fs_1.promises.writeFile(outputPath, convertedFileFormatted, {
                 encoding: 'utf8',
             });
         });

package/lib/domains/services/generator.service.d.ts

@@ -1,6 +1,13 @@
 import { GenerationOptions, GenerationResult, ServiceResult } from '../../interfaces';
 import { Specification } from '../models/SpecificationFile';
 import { BaseService } from './base.service';
+/**
+ * Options passed to the generator for code generation.
+ */
+interface GeneratorRunOptions {
+    path?: Specification;
+    [key: string]: unknown;
+}
 export declare class GeneratorService extends BaseService {
     private defaultInteractive;
     constructor(interactive?: boolean);
@@ -11,6 +18,17 @@ export declare class GeneratorService extends BaseService {
     private verifyTemplateSupportForV3;
     private getGenerationSuccessMessage;
     private checkV3NotSupported;
-    generate(asyncapi: Specification, template: string, output: string, options: GenerationOptions, genOption: any, interactive?: boolean): Promise<ServiceResult<GenerationResult>>;
-    generateUsingNewGenerator(asyncapi: Specification, template: string, output: string, options: any, genOption: any): Promise<ServiceResult<GenerationResult>>;
+    /**
+     * 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
+     */
+    generate(asyncapi: Specification, template: string, output: string, options: GenerationOptions, genOption?: GeneratorRunOptions, interactive?: boolean): Promise<ServiceResult<GenerationResult>>;
 }
+export {};

package/lib/domains/services/generator.service.js

@@ -4,11 +4,11 @@ exports.GeneratorService = void 0;
 const tslib_1 = require("tslib");
 const base_service_1 = require("./base.service");
 const generator_1 = tslib_1.__importDefault(require("@asyncapi/generator"));
-const generator_v2_1 = tslib_1.__importDefault(require("generator-v2"));
 const prompts_1 = require("@clack/prompts");
 const path_1 = tslib_1.__importDefault(require("path"));
 const os_1 = tslib_1.__importDefault(require("os"));
 const picocolors_1 = require("picocolors");
+const error_handler_1 = require("../../utils/error-handler");
 class GeneratorService extends base_service_1.BaseService {
     constructor(interactive = false) {
         super();
@@ -45,48 +45,41 @@ class GeneratorService extends base_service_1.BaseService {
             }
         }
     }
-    generate(asyncapi_1, template_1, output_1, options_1, genOption_1) {
-        return tslib_1.__awaiter(this, arguments, void 0, function* (asyncapi, template, output, options, genOption, interactive = this.defaultInteractive) {
+    /**
+     * 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
+     */
+    generate(asyncapi_1, template_1, output_1, options_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (asyncapi, template, output, options, genOption = {}, interactive = this.defaultInteractive) {
             const v3NotSupported = this.checkV3NotSupported(asyncapi, template);
             if (v3NotSupported) {
                 return this.createErrorResult(v3NotSupported);
             }
+            const logs = [];
             const generator = new generator_1.default(template, output || path_1.default.resolve(os_1.default.tmpdir(), 'asyncapi-generator'), options);
             const s = interactive
                 ? (0, prompts_1.spinner)()
-                : { start: () => null, stop: (string) => console.log(string) };
+                : { start: () => null, stop: (message) => logs.push(message) };
             s.start('Generation in progress. Keep calm and wait a bit');
             try {
                 yield generator.generateFromString(asyncapi.text(), Object.assign(Object.assign({}, genOption), { path: asyncapi }));
             }
             catch (err) {
-                console.log(err);
                 s.stop('Generation failed');
-                return this.createErrorResult(err.message, err.diagnostics);
+                const errorMessage = (0, error_handler_1.getErrorMessage)(err, 'Generation failed');
+                const diagnostics = err && typeof err === 'object' && 'diagnostics' in err
+                    ? err.diagnostics
+                    : undefined;
+                return this.createErrorResult(errorMessage, diagnostics);
             }
             s.stop(this.getGenerationSuccessMessage(output));
-            return this.createSuccessResult({
-                success: true,
-                outputPath: output,
-            });
-        });
-    }
-    generateUsingNewGenerator(asyncapi, template, output, options, genOption) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const v3NotSupported = this.checkV3NotSupported(asyncapi, template);
-            if (v3NotSupported) {
-                return this.createErrorResult(v3NotSupported);
-            }
-            const logs = [];
-            const generator = new generator_v2_1.default(template, output || path_1.default.resolve(os_1.default.tmpdir(), 'asyncapi-generator'), options);
-            try {
-                yield generator.generateFromString(asyncapi.text(), Object.assign(Object.assign({}, genOption), { path: asyncapi }));
-            }
-            catch (err) {
-                logs.push('Generation failed');
-                return this.createErrorResult(err.message, err.diagnostics);
-            }
-            logs.push(this.getGenerationSuccessMessage(output));
             return this.createSuccessResult({
                 success: true,
                 outputPath: output,

package/lib/domains/services/validation.service.d.ts

@@ -23,6 +23,22 @@ export declare class ValidationService extends BaseService {
      * Validates an AsyncAPI document
      */
     validateDocument(specFile: Specification, options?: ValidationOptions): Promise<ServiceResult<ValidationResult>>;
+    /**
+     * Creates a custom parser with specific rules turned off.
+     */
+    private buildCustomParser;
+    /**
+     * Registers all schema parsers for the given parser instance.
+     */
+    private registerSchemaParsers;
+    /**
+     * Builds a parser that suppresses all discovered warnings.
+     */
+    private buildParserWithAllWarningsSuppressed;
+    /**
+     * Builds a parser that suppresses specific warnings, handling invalid rules gracefully.
+     */
+    private buildParserWithSpecificWarningsSuppressed;
     /**
      * Helper to build and register a custom parser with suppressed rules
      */

package/lib/domains/services/validation.service.js

@@ -126,13 +126,10 @@ class ValidationService extends base_service_1.BaseService {
         var _a, _b, _c;
         super();
         // Create parser with custom GitHub resolver
-        const customParserOptions = Object.assign(Object.assign({}, parserOptions), { __unstable: Object.assign({ resolver: {
-                    cache: false,
-                    resolvers: [
+        const customParserOptions = Object.assign(Object.assign({}, parserOptions), { __unstable: Object.assign(Object.assign({}, parserOptions.__unstable), { resolver: Object.assign(Object.assign({}, (_a = parserOptions.__unstable) === null || _a === void 0 ? void 0 : _a.resolver), { cache: false, resolvers: [
                         createHttpWithAuthResolver(),
-                        ...(((_b = (_a = parserOptions.__unstable) === null || _a === void 0 ? void 0 : _a.resolver) === null || _b === void 0 ? void 0 : _b.resolvers) || [])
-                    ],
-                } }, (_c = parserOptions.__unstable) === null || _c === void 0 ? void 0 : _c.resolver) });
+                        ...(((_c = (_b = parserOptions.__unstable) === null || _b === void 0 ? void 0 : _b.resolver) === null || _c === void 0 ? void 0 : _c.resolvers) || [])
+                    ] }) }) });
         this.parser = new cjs_1.Parser(customParserOptions);
         this.parser.registerSchemaParser((0, openapi_schema_parser_1.OpenAPISchemaParser)());
         this.parser.registerSchemaParser((0, raml_dt_schema_parser_1.RamlDTSchemaParser)());
@@ -206,63 +203,77 @@ class ValidationService extends base_service_1.BaseService {
         });
     }
     /**
-     * Helper to build and register a custom parser with suppressed rules
+     * Creates a custom parser with specific rules turned off.
      */
-    buildAndRegisterCustomParser(specFile, suppressedWarnings, suppressAllWarnings) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            // Helper to build a parser with given rules turned off
-            const buildCustomParser = (rulesToSuppress) => new cjs_1.Parser({
-                ruleset: {
-                    extends: [],
-                    rules: Object.fromEntries(rulesToSuppress.map((rule) => [rule, 'off'])),
-                },
-                __unstable: {
-                    resolver: {
-                        cache: false,
-                        resolvers: [createHttpWithAuthResolver()],
-                    },
+    buildCustomParser(rulesToSuppress) {
+        return new cjs_1.Parser({
+            ruleset: {
+                extends: [],
+                rules: Object.fromEntries(rulesToSuppress.map((rule) => [rule, 'off'])),
+            },
+            __unstable: {
+                resolver: {
+                    cache: false,
+                    resolvers: [createHttpWithAuthResolver()],
                 },
+            },
+        });
+    }
+    /**
+     * Registers all schema parsers for the given parser instance.
+     */
+    registerSchemaParsers(parser) {
+        parser.registerSchemaParser((0, avro_schema_parser_1.AvroSchemaParser)());
+        parser.registerSchemaParser((0, openapi_schema_parser_1.OpenAPISchemaParser)());
+        parser.registerSchemaParser((0, raml_dt_schema_parser_1.RamlDTSchemaParser)());
+        parser.registerSchemaParser((0, protobuf_schema_parser_1.ProtoBuffSchemaParser)());
+    }
+    /**
+     * Builds a parser that suppresses all discovered warnings.
+     */
+    buildParserWithAllWarningsSuppressed(specFile) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const diagnostics = yield this.parser.validate(specFile.text(), {
+                source: specFile.getSource(),
             });
-            let activeParser;
-            if (suppressAllWarnings || suppressedWarnings.length) {
-                if (suppressAllWarnings) {
-                    // Run the default parser to discover all rule codes
-                    const diagnostics = yield this.parser.validate(specFile.text(), {
-                        source: specFile.getSource(),
-                    });
-                    const allRuleNames = Array.from(new Set(diagnostics
-                        .map((d) => d.code)
-                        .filter((c) => typeof c === 'string')));
-                    activeParser = buildCustomParser(allRuleNames);
-                }
-                else {
-                    try {
-                        activeParser = buildCustomParser(suppressedWarnings);
-                    }
-                    catch (e) {
-                        const msg = e.message || '';
-                        const matches = [
-                            ...msg.matchAll(/Cannot extend non-existing rule: "([^"]+)"/g),
-                        ];
-                        const invalidRules = matches.map((m) => m[1]);
-                        if (invalidRules.length > 0) {
-                            const validRules = suppressedWarnings.filter((rule) => !invalidRules.includes(rule));
-                            activeParser = buildCustomParser(validRules);
-                        }
-                        else {
-                            throw e;
-                        }
-                    }
-                }
-                // Register schema parsers for active parser
-                activeParser.registerSchemaParser((0, avro_schema_parser_1.AvroSchemaParser)());
-                activeParser.registerSchemaParser((0, openapi_schema_parser_1.OpenAPISchemaParser)());
-                activeParser.registerSchemaParser((0, raml_dt_schema_parser_1.RamlDTSchemaParser)());
-                activeParser.registerSchemaParser((0, protobuf_schema_parser_1.ProtoBuffSchemaParser)());
+            const allRuleNames = Array.from(new Set(diagnostics
+                .map((d) => d.code)
+                .filter((c) => typeof c === 'string')));
+            return this.buildCustomParser(allRuleNames);
+        });
+    }
+    /**
+     * Builds a parser that suppresses specific warnings, handling invalid rules gracefully.
+     */
+    buildParserWithSpecificWarningsSuppressed(suppressedWarnings) {
+        try {
+            return this.buildCustomParser(suppressedWarnings);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : '';
+            const matches = [
+                ...msg.matchAll(/Cannot extend non-existing rule: "([^"]+)"/g),
+            ];
+            const invalidRules = matches.map((m) => m[1]);
+            if (invalidRules.length > 0) {
+                const validRules = suppressedWarnings.filter((rule) => !invalidRules.includes(rule));
+                return this.buildCustomParser(validRules);
             }
-            else {
+            throw e;
+        }
+    }
+    /**
+     * Helper to build and register a custom parser with suppressed rules
+     */
+    buildAndRegisterCustomParser(specFile, suppressedWarnings, suppressAllWarnings) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!suppressAllWarnings && !suppressedWarnings.length) {
                 throw new Error('No rules to suppress provided');
             }
+            const activeParser = suppressAllWarnings
+                ? yield this.buildParserWithAllWarningsSuppressed(specFile)
+                : this.buildParserWithSpecificWarningsSuppressed(suppressedWarnings);
+            this.registerSchemaParsers(activeParser);
             return activeParser;
         });
     }

package/lib/index.d.ts

@@ -1 +1,5 @@
 export { run } from '@oclif/core';
+export * from './utils/error-handler';
+export * from './utils/validation';
+export * from './utils/proxy';
+export * from './interfaces';

package/lib/index.js

@@ -1,7 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
 var core_1 = require("@oclif/core");
 Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });
+// Export utilities for external consumption
+tslib_1.__exportStar(require("./utils/error-handler"), exports);
+tslib_1.__exportStar(require("./utils/validation"), exports);
+tslib_1.__exportStar(require("./utils/proxy"), exports);
+// Export interfaces
+tslib_1.__exportStar(require("./interfaces"), exports);
 /**
  * For NodeJS < 15, unhandled rejections are treated as warnings.
  * This is required for consistency in error handling.