@asyncapi-actions-test/trusted-publishing-test_asyncapi-cli 4.1.3

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

@@ -0,0 +1,54 @@
+import { BaseService } from './base.service';
+import { ValidationOptions, ValidationResult, ServiceResult, ParsedDocument, DiagnosticsFormat, SeverityKind } from '../../interfaces';
+import type { Diagnostic } from '@asyncapi/parser/cjs';
+import { Specification } from '../models/SpecificationFile';
+import { ParseOptions } from '@asyncapi/parser';
+import { ParserOptions } from '@asyncapi/parser/cjs/parser';
+export declare enum ValidationStatus {
+    INVALID = "invalid",
+    VALID = "valid"
+}
+export declare class ValidationService extends BaseService {
+    private parser;
+    constructor(parserOptions?: ParserOptions);
+    /**
+     * Determine validation status from diagnostics
+     */
+    private determineDiagnosticsStatus;
+    /**
+     * Parses an AsyncAPI document and returns the parsed result
+     */
+    parseDocument(specFile: Specification, parseOptions?: ParseOptions, options?: ValidationOptions): Promise<ServiceResult<ParsedDocument>>;
+    /**
+     * Validates an AsyncAPI document
+     */
+    validateDocument(specFile: Specification, options?: ValidationOptions): Promise<ServiceResult<ValidationResult>>;
+    /**
+     * Helper to build and register a custom parser with suppressed rules
+     */
+    private buildAndRegisterCustomParser;
+    /**
+     * Save validation diagnostics to file
+     */
+    saveDiagnosticsToFile(outputPath: string, format: DiagnosticsFormat, formatOutput: string): Promise<ServiceResult<string>>;
+    /**
+     * Generate governance message based on validation results
+     */
+    generateGovernanceMessage(sourceString: string, hasIssues: boolean, isFailSeverity: boolean): string;
+    /**
+     * Check if diagnostics contain failure severity issues
+     */
+    private hasFailSeverity;
+    /**
+     * Format validation diagnostics output
+     */
+    formatDiagnosticsOutput(diagnostics: Diagnostic[], format?: DiagnosticsFormat, failSeverity?: SeverityKind): string;
+    /**
+     * Format diagnostics in stylish format with severity grouping
+     */
+    private formatStylish;
+    /**
+     * Get colored severity title
+     */
+    private getSeverityTitle;
+}

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

@@ -0,0 +1,375 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationService = exports.ValidationStatus = void 0;
+const tslib_1 = require("tslib");
+const base_service_1 = require("./base.service");
+const avro_schema_parser_1 = require("@asyncapi/avro-schema-parser");
+const openapi_schema_parser_1 = require("@asyncapi/openapi-schema-parser");
+const cjs_1 = require("@asyncapi/parser/cjs");
+const raml_dt_schema_parser_1 = require("@asyncapi/raml-dt-schema-parser");
+const protobuf_schema_parser_1 = require("@asyncapi/protobuf-schema-parser");
+const spectral_core_1 = require("@stoplight/spectral-core");
+const spectral_formatters_1 = require("@stoplight/spectral-formatters");
+const chalk_1 = require("chalk");
+const fs_1 = require("fs");
+const path_1 = tslib_1.__importDefault(require("path"));
+const scoreCalculator_1 = require("../../utils/scoreCalculator");
+const config_service_1 = require("./config.service");
+/**
+ * Helper function to validate if a URL is a GitHub blob URL
+ */
+const isValidGitHubBlobUrl = (url) => {
+    try {
+        const parsedUrl = new URL(url);
+        return (parsedUrl.hostname === 'github.com' &&
+            parsedUrl.pathname.split('/')[3] === 'blob');
+    }
+    catch (error) {
+        return false;
+    }
+};
+/**
+ * Convert GitHub web URL to API URL
+ */
+const convertGitHubWebUrl = (url) => {
+    // Remove fragment from URL before processing
+    const urlWithoutFragment = url.split('#')[0];
+    // Handle GitHub web URLs like: https://github.com/owner/repo/blob/branch/path
+    // eslint-disable-next-line no-useless-escape
+    const githubWebPattern = /^https:\/\/github\.com\/([^\/]+)\/([^\/]+)\/blob\/([^\/]+)\/(.+)$/;
+    const match = urlWithoutFragment.match(githubWebPattern);
+    if (match) {
+        const [, owner, repo, branch, filePath] = match;
+        return `https://api.github.com/repos/${owner}/${repo}/contents/${filePath}?ref=${branch}`;
+    }
+    return url;
+};
+/**
+ * Custom resolver for private repositories
+ */
+const createHttpWithAuthResolver = () => ({
+    schema: 'https',
+    order: 1,
+    read: (uri) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        let url = uri.toString();
+        // Default headers
+        const headers = {
+            'User-Agent': 'AsyncAPI-CLI',
+        };
+        const authInfo = yield config_service_1.ConfigService.getAuthForUrl(url);
+        if (isValidGitHubBlobUrl(url)) {
+            url = convertGitHubWebUrl(url);
+        }
+        if (authInfo) {
+            headers['Authorization'] = `${authInfo.authType} ${authInfo.token}`;
+            Object.assign(headers, authInfo.headers); // merge custom headers
+        }
+        if (url.includes('api.github.com')) {
+            headers['Accept'] = 'application/vnd.github.v3+json';
+            const res = yield fetch(url, { headers });
+            if (!res.ok) {
+                throw new Error(`Failed to fetch GitHub API URL: ${url} - ${res.statusText}`);
+            }
+            const fileInfo = (yield res.json());
+            if (fileInfo.download_url) {
+                const contentRes = yield fetch(fileInfo.download_url, { headers });
+                if (!contentRes.ok) {
+                    throw new Error(`Failed to fetch content from download URL: ${fileInfo.download_url} - ${contentRes.statusText}`);
+                }
+                return yield contentRes.text();
+            }
+            throw new Error(`No download URL found in GitHub API response for: ${url}`);
+        }
+        else if (url.includes('raw.githubusercontent.com')) {
+            headers['Accept'] = 'application/vnd.github.v3.raw';
+            const res = yield fetch(url, { headers });
+            if (!res.ok) {
+                throw new Error(`Failed to fetch GitHub URL: ${url} - ${res.statusText}`);
+            }
+            return yield res.text();
+        }
+        else {
+            const res = yield fetch(url, { headers });
+            if (!res.ok) {
+                throw new Error(`Failed to fetch URL: ${url} - ${res.statusText}`);
+            }
+            return yield res.text();
+        }
+    }),
+});
+const { writeFile } = fs_1.promises;
+var ValidationStatus;
+(function (ValidationStatus) {
+    ValidationStatus["INVALID"] = "invalid";
+    ValidationStatus["VALID"] = "valid";
+})(ValidationStatus || (exports.ValidationStatus = ValidationStatus = {}));
+const formatExtensions = {
+    stylish: '.txt',
+    json: '.json',
+    junit: '.xml',
+    html: '.html',
+    text: '.txt',
+    teamcity: '.txt',
+    pretty: '.txt',
+};
+const validFormats = [
+    'stylish',
+    'json',
+    'junit',
+    'html',
+    'text',
+    'teamcity',
+    'pretty',
+];
+class ValidationService extends base_service_1.BaseService {
+    constructor(parserOptions = {}) {
+        var _a, _b, _c;
+        super();
+        // Create parser with custom GitHub resolver
+        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(),
+                        ...(((_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)());
+        this.parser.registerSchemaParser((0, avro_schema_parser_1.AvroSchemaParser)());
+        this.parser.registerSchemaParser((0, protobuf_schema_parser_1.ProtoBuffSchemaParser)());
+    }
+    /**
+     * Determine validation status from diagnostics
+     */
+    determineDiagnosticsStatus(diagnostics, options) {
+        var _a;
+        const failSeverity = (_a = options['fail-severity']) !== null && _a !== void 0 ? _a : 'error';
+        const hasIssues = diagnostics.length > 0;
+        const isFailSeverity = hasIssues && this.hasFailSeverity(diagnostics, failSeverity);
+        return isFailSeverity ? ValidationStatus.INVALID : ValidationStatus.VALID;
+    }
+    /**
+     * Parses an AsyncAPI document and returns the parsed result
+     */
+    parseDocument(specFile_1, parseOptions_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (specFile, parseOptions, options = {}) {
+            try {
+                const { document, diagnostics } = yield this.parser.parse(specFile.text(), Object.assign({ source: specFile.getSource() }, parseOptions));
+                if (!document) {
+                    return this.createErrorResult('Failed to parse document');
+                }
+                const status = this.determineDiagnosticsStatus(diagnostics, options);
+                const result = {
+                    document,
+                    diagnostics,
+                    status: status,
+                };
+                return this.createSuccessResult(result);
+            }
+            catch (error) {
+                return this.handleServiceError(error);
+            }
+        });
+    }
+    /**
+     * Validates an AsyncAPI document
+     */
+    validateDocument(specFile_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (specFile, options = {}) {
+            var _a, _b;
+            try {
+                const suppressAllWarnings = (_a = options.suppressAllWarnings) !== null && _a !== void 0 ? _a : false;
+                const suppressedWarnings = (_b = options.suppressWarnings) !== null && _b !== void 0 ? _b : [];
+                let activeParser;
+                if (suppressAllWarnings || suppressedWarnings.length) {
+                    activeParser = yield this.buildAndRegisterCustomParser(specFile, suppressedWarnings, suppressAllWarnings);
+                }
+                else {
+                    activeParser = this.parser;
+                }
+                const { document, diagnostics } = yield activeParser.parse(specFile.text(), {
+                    source: specFile.getSource(),
+                });
+                const status = this.determineDiagnosticsStatus(diagnostics, options);
+                const result = {
+                    status: status,
+                    diagnostics,
+                    score: yield (0, scoreCalculator_1.calculateScore)(document),
+                    document: (document === null || document === void 0 ? void 0 : document.json) ? document.json() : undefined,
+                };
+                return this.createSuccessResult(result);
+            }
+            catch (error) {
+                return this.handleServiceError(error);
+            }
+        });
+    }
+    /**
+     * 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* () {
+            // 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()],
+                    },
+                },
+            });
+            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)());
+            }
+            else {
+                throw new Error('No rules to suppress provided');
+            }
+            return activeParser;
+        });
+    }
+    /**
+     * Save validation diagnostics to file
+     */
+    saveDiagnosticsToFile(outputPath, format, formatOutput) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!validFormats.includes(format)) {
+                    return this.createErrorResult(`Invalid diagnostics format: "${format}"`);
+                }
+                const expectedExtension = formatExtensions[format];
+                const actualExtension = path_1.default.extname(outputPath);
+                // Validate file extension against diagnostics format
+                if (expectedExtension && actualExtension !== expectedExtension) {
+                    return this.createErrorResult(`Invalid file extension for format "${format}". Expected extension: "${expectedExtension}"`);
+                }
+                yield writeFile(path_1.default.resolve(process.cwd(), outputPath), formatOutput, {
+                    encoding: 'utf-8',
+                });
+                return this.createSuccessResult(outputPath);
+            }
+            catch (error) {
+                return this.handleServiceError(error);
+            }
+        });
+    }
+    /**
+     * Generate governance message based on validation results
+     */
+    generateGovernanceMessage(sourceString, hasIssues, isFailSeverity) {
+        if (!hasIssues) {
+            return `\n${sourceString} is valid! ${sourceString} and referenced documents don't have governance issues.`;
+        }
+        if (isFailSeverity) {
+            return `\n${sourceString} and/or referenced documents have governance issues.`;
+        }
+        return `\n${sourceString} is valid but has (itself and/or referenced documents) governance issues.`;
+    }
+    /**
+     * Check if diagnostics contain failure severity issues
+     */
+    hasFailSeverity(diagnostics, failSeverity) {
+        const diagnosticSeverity = (0, spectral_core_1.getDiagnosticSeverity)(failSeverity);
+        return diagnostics.some((diagnostic) => diagnostic.severity <= diagnosticSeverity);
+    }
+    /**
+     * Format validation diagnostics output
+     */
+    formatDiagnosticsOutput(diagnostics, format = 'stylish', failSeverity = 'error') {
+        const diagnosticSeverity = (0, spectral_core_1.getDiagnosticSeverity)(failSeverity);
+        const options = {
+            failSeverity: diagnosticSeverity !== -1
+                ? diagnosticSeverity
+                : cjs_1.DiagnosticSeverity.Error,
+        };
+        switch (format) {
+            case 'stylish':
+                return this.formatStylish(diagnostics, options);
+            case 'json':
+                return (0, spectral_formatters_1.json)(diagnostics, options);
+            case 'junit':
+                return (0, spectral_formatters_1.junit)(diagnostics, options);
+            case 'html':
+                return (0, spectral_formatters_1.html)(diagnostics, options);
+            case 'text':
+                return (0, spectral_formatters_1.text)(diagnostics, options);
+            case 'teamcity':
+                return (0, spectral_formatters_1.teamcity)(diagnostics, options);
+            case 'pretty':
+                return (0, spectral_formatters_1.pretty)(diagnostics, options);
+            default:
+                return (0, spectral_formatters_1.stylish)(diagnostics, options);
+        }
+    }
+    /**
+     * Format diagnostics in stylish format with severity grouping
+     */
+    formatStylish(diagnostics, options) {
+        const groupedDiagnostics = diagnostics.reduce((acc, diagnostic) => {
+            const severity = diagnostic.severity;
+            if (!acc[severity]) {
+                acc[severity] = [];
+            }
+            acc[severity].push(diagnostic);
+            return acc;
+        }, {});
+        return Object.entries(groupedDiagnostics)
+            .map(([severity, diagnostics]) => {
+            return `${this.getSeverityTitle(Number(severity))} ${(0, spectral_formatters_1.stylish)(diagnostics, options)}`;
+        })
+            .join('\n');
+    }
+    /**
+     * Get colored severity title
+     */
+    getSeverityTitle(severity) {
+        switch (severity) {
+            case cjs_1.DiagnosticSeverity.Error:
+                return (0, chalk_1.red)('Errors');
+            case cjs_1.DiagnosticSeverity.Warning:
+                return (0, chalk_1.yellow)('Warnings');
+            case cjs_1.DiagnosticSeverity.Information:
+                return (0, chalk_1.cyan)('Information');
+            case cjs_1.DiagnosticSeverity.Hint:
+                return (0, chalk_1.green)('Hints');
+            default:
+                return 'Unknown';
+        }
+    }
+}
+exports.ValidationService = ValidationService;

package/lib/errors/context-error.d.ts

@@ -0,0 +1,26 @@
+export declare const NO_CONTEXTS_SAVED = "These are your options to specify in the CLI what AsyncAPI file should be used:\n\t- You can provide a path to the AsyncAPI file: asyncapi <command> path/to/file/asyncapi.yml\n\t- You can provide URL to the AsyncAPI file: asyncapi <command> https://example.com/path/to/file/asyncapi.yml\n\t- You can also pass a saved context that points to your AsyncAPI file: asyncapi <command> context-name\n\t- In case you did not specify a context that you want to use, the CLI checks if there is a default context and uses it. To set default context run: asyncapi config context use mycontext\n\t- In case you did not provide any reference to AsyncAPI file and there is no default context, the CLI detects if in your current working directory you have files like asyncapi.json, asyncapi.yaml, asyncapi.yml. Just rename your file accordingly.\n";
+declare class ContextError extends Error {
+    constructor();
+}
+export declare class MissingContextFileError extends ContextError {
+    constructor();
+}
+export declare class MissingCurrentContextError extends ContextError {
+    constructor();
+}
+export declare class ContextNotFoundError extends ContextError {
+    constructor(contextName: string);
+}
+export declare class ContextAlreadyExistsError extends ContextError {
+    constructor(contextName: string, contextFileName: string);
+}
+export declare class ContextFileWrongFormatError extends ContextError {
+    constructor(contextFileName: string);
+}
+export declare class ContextFileEmptyError extends ContextError {
+    constructor(contextFileName: string);
+}
+export declare class ContextFileWriteError extends ContextError {
+    constructor(contextFileName: string);
+}
+export {};

package/lib/errors/context-error.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextFileWriteError = exports.ContextFileEmptyError = exports.ContextFileWrongFormatError = exports.ContextAlreadyExistsError = exports.ContextNotFoundError = exports.MissingCurrentContextError = exports.MissingContextFileError = exports.NO_CONTEXTS_SAVED = void 0;
+exports.NO_CONTEXTS_SAVED = `These are your options to specify in the CLI what AsyncAPI file should be used:
+	- You can provide a path to the AsyncAPI file: asyncapi <command> path/to/file/asyncapi.yml
+	- You can provide URL to the AsyncAPI file: asyncapi <command> https://example.com/path/to/file/asyncapi.yml
+	- You can also pass a saved context that points to your AsyncAPI file: asyncapi <command> context-name
+	- In case you did not specify a context that you want to use, the CLI checks if there is a default context and uses it. To set default context run: asyncapi config context use mycontext
+	- In case you did not provide any reference to AsyncAPI file and there is no default context, the CLI detects if in your current working directory you have files like asyncapi.json, asyncapi.yaml, asyncapi.yml. Just rename your file accordingly.
+`;
+const MISSING_CURRENT_CONTEXT = 'No context is set as current, please set a current context.';
+const CONTEXT_NOT_FOUND = (contextName) => `Context "${contextName}" does not exist.`;
+const CONTEXT_ALREADY_EXISTS = (contextName, contextFileName) => `Context with name "${contextName}" already exists in context file "${contextFileName}".`;
+const CONTEXT_FILE_WRONG_FORMAT = (contextFileName) => `Context file "${contextFileName}" has wrong format. Make sure your context file follows the structure described in section "Context File structure" at https://www.asyncapi.com/docs/tools/cli/context#context-file-structure`;
+const CONTEXT_FILE_EMPTY = (contextFileName) => `Context file "${contextFileName}" is empty.`;
+const CONTEXT_FILE_WRITE_ERROR = (contextFileName) => `Error writing context file "${contextFileName}".`;
+class ContextError extends Error {
+    constructor() {
+        super();
+        this.name = 'ContextError';
+    }
+}
+class MissingContextFileError extends ContextError {
+    constructor() {
+        super();
+        this.message = exports.NO_CONTEXTS_SAVED;
+    }
+}
+exports.MissingContextFileError = MissingContextFileError;
+class MissingCurrentContextError extends ContextError {
+    constructor() {
+        super();
+        this.message = MISSING_CURRENT_CONTEXT;
+    }
+}
+exports.MissingCurrentContextError = MissingCurrentContextError;
+class ContextNotFoundError extends ContextError {
+    constructor(contextName) {
+        super();
+        this.message = CONTEXT_NOT_FOUND(contextName);
+    }
+}
+exports.ContextNotFoundError = ContextNotFoundError;
+class ContextAlreadyExistsError extends ContextError {
+    constructor(contextName, contextFileName) {
+        super();
+        this.message = CONTEXT_ALREADY_EXISTS(contextName, contextFileName);
+    }
+}
+exports.ContextAlreadyExistsError = ContextAlreadyExistsError;
+class ContextFileWrongFormatError extends ContextError {
+    constructor(contextFileName) {
+        super();
+        this.message = CONTEXT_FILE_WRONG_FORMAT(contextFileName);
+    }
+}
+exports.ContextFileWrongFormatError = ContextFileWrongFormatError;
+class ContextFileEmptyError extends ContextError {
+    constructor(contextFileName) {
+        super();
+        this.message = CONTEXT_FILE_EMPTY(contextFileName);
+    }
+}
+exports.ContextFileEmptyError = ContextFileEmptyError;
+class ContextFileWriteError extends ContextError {
+    constructor(contextFileName) {
+        super();
+        this.message = CONTEXT_FILE_WRITE_ERROR(contextFileName);
+    }
+}
+exports.ContextFileWriteError = ContextFileWriteError;

package/lib/errors/diff-error.d.ts

@@ -0,0 +1,9 @@
+export declare class DiffOverrideFileError extends Error {
+    constructor();
+}
+export declare class DiffOverrideJSONError extends Error {
+    constructor();
+}
+export declare class DiffBreakingChangeError extends Error {
+    constructor();
+}

package/lib/errors/diff-error.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffBreakingChangeError = exports.DiffOverrideJSONError = exports.DiffOverrideFileError = void 0;
+class DiffOverrideFileError extends Error {
+    constructor() {
+        super();
+        this.name = 'DiffOverrideFileError';
+        this.message = 'Override file not found';
+    }
+}
+exports.DiffOverrideFileError = DiffOverrideFileError;
+class DiffOverrideJSONError extends Error {
+    constructor() {
+        super();
+        this.name = 'DiffOverrideJSONError';
+        this.message = 'Provided override file is not a valid JSON file';
+    }
+}
+exports.DiffOverrideJSONError = DiffOverrideJSONError;
+class DiffBreakingChangeError extends Error {
+    constructor() {
+        super();
+        this.name = 'DiffBreakingChangeError';
+        this.message = 'Breaking changes detected';
+    }
+}
+exports.DiffBreakingChangeError = DiffBreakingChangeError;

package/lib/errors/generator-error.d.ts

@@ -0,0 +1,3 @@
+export declare class GeneratorError extends Error {
+    constructor(err: Error);
+}

package/lib/errors/generator-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratorError = void 0;
+class GeneratorError extends Error {
+    constructor(err) {
+        super();
+        this.name = 'Generator Error';
+        this.message = err.message;
+    }
+}
+exports.GeneratorError = GeneratorError;

package/lib/errors/specification-file.d.ts

@@ -0,0 +1,18 @@
+declare class SpecificationFileError extends Error {
+    constructor();
+}
+export declare class SpecificationFileNotFound extends SpecificationFileError {
+    constructor(filePath?: string);
+}
+export declare class SpecificationWrongFileFormat extends SpecificationFileError {
+    constructor(filePath?: string);
+}
+export declare class SpecificationURLNotFound extends SpecificationFileError {
+    constructor(URL: string);
+}
+type From = 'file' | 'url' | 'context' | 'invalid file';
+export declare class ErrorLoadingSpec extends Error {
+    private readonly errorMessages;
+    constructor(from?: From, param?: string);
+}
+export {};

package/lib/errors/specification-file.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorLoadingSpec = exports.SpecificationURLNotFound = exports.SpecificationWrongFileFormat = exports.SpecificationFileNotFound = void 0;
+const context_error_1 = require("./context-error");
+class SpecificationFileError extends Error {
+    constructor() {
+        super();
+        this.name = 'SpecificationFileError';
+    }
+}
+class SpecificationFileNotFound extends SpecificationFileError {
+    constructor(filePath) {
+        super();
+        if (filePath) {
+            this.message = `File ${filePath} does not exist.`;
+        }
+        else {
+            this.message = 'We could not find any AsyncAPI file.';
+        }
+    }
+}
+exports.SpecificationFileNotFound = SpecificationFileNotFound;
+class SpecificationWrongFileFormat extends SpecificationFileError {
+    constructor(filePath) {
+        super();
+        this.message = `File ${filePath} is not of correct format.`;
+    }
+}
+exports.SpecificationWrongFileFormat = SpecificationWrongFileFormat;
+class SpecificationURLNotFound extends SpecificationFileError {
+    constructor(URL) {
+        super();
+        this.message = `Unable to fetch specification file from url: ${URL}`;
+    }
+}
+exports.SpecificationURLNotFound = SpecificationURLNotFound;
+class ErrorLoadingSpec extends Error {
+    constructor(from, param) {
+        super();
+        this.errorMessages = {
+            default: context_error_1.NO_CONTEXTS_SAVED,
+        };
+        if (from === 'file') {
+            this.name = 'error loading AsyncAPI document from file';
+            this.message = `${param} file does not exist.`;
+        }
+        if (from === 'url') {
+            this.name = 'error loading AsyncAPI document from url';
+            this.message = `Failed to download ${param}.`;
+        }
+        if (from === 'context') {
+            this.name = 'error loading AsyncAPI document from context';
+            this.message = `${param} context name does not exist.`;
+        }
+        if (from === 'invalid file') {
+            this.name = 'Invalid AsyncAPI file type';
+            this.message = 'cli only supports yml ,yaml ,json extension';
+        }
+        if (!from) {
+            this.name = 'error locating AsyncAPI document';
+            this.message = this.errorMessages.default;
+        }
+    }
+}
+exports.ErrorLoadingSpec = ErrorLoadingSpec;