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

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

@@ -0,0 +1,11 @@
+type ErrorType = 'parser-error' | 'invalid-file' | 'no-spec-found' | 'invalid-syntax-file';
+interface IValidationErrorInput {
+    type: ErrorType;
+    err?: any;
+    filepath?: string;
+}
+export declare class ValidationError extends Error {
+    constructor(error: IValidationErrorInput);
+    private buildError;
+}
+export {};

package/lib/errors/validation-error.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = void 0;
+class ValidationError extends Error {
+    constructor(error) {
+        super();
+        if (error.type === 'parser-error') {
+            this.buildError(error.err);
+        }
+        if (error.type === 'invalid-file') {
+            this.message = `There is no file or context with name "${error.filepath}".`;
+        }
+        if (error.type === 'invalid-syntax-file') {
+            this.message = `Syntax Error in "${error.filepath}".`;
+        }
+        if (error.type === 'no-spec-found') {
+            this.message =
+                'Unable to perform validation. Specify what AsyncAPI file should be validated.\n\nThese are your options to specify in the CLI what AsyncAPI file should be used:\n- You can provide a path to the AsyncAPI file: asyncapi validate path/to/file/asyncapi.yml\n- You can also pass a saved context that points to your AsyncAPI file: asyncapi validate mycontext\n- 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 context use mycontext\n- 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.';
+        }
+        this.name = 'ValidationError';
+    }
+    buildError(err) {
+        const errorsInfo = [];
+        if (err.title) {
+            errorsInfo.push(err.title);
+        }
+        if (err.detail) {
+            errorsInfo.push(err.details);
+        }
+        if (err.validationErrors) {
+            for (const e of err.validationErrors) {
+                const errorHasTitle = !!e.title;
+                const errorHasLocation = !!e.location;
+                /*
+                 * All the conditions below are needed since validationErrors (from ParserError) come from Parser JS library,
+                 * so we cannot assure that all the fields or properties are always provided in the error. There might be cases
+                 * that even title is not provided.
+                 */
+                if (errorHasTitle && errorHasLocation) {
+                    errorsInfo.push(`${e.title} ${e.location.startLine}:${e.location.startColumn}`);
+                    continue;
+                }
+                if (errorHasTitle) {
+                    errorsInfo.push(`${e.title}`);
+                    continue;
+                }
+                if (errorHasLocation) {
+                    errorsInfo.push(`${e.location.startLine}:${e.location.startColumn}`);
+                }
+            }
+        }
+        this.message = errorsInfo.join('\n');
+    }
+}
+exports.ValidationError = ValidationError;

package/lib/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/lib/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = require("@oclif/core");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });
+/**
+ * For NodeJS < 15, unhandled rejections are treated as warnings.
+ * This is required for consistency in error handling.
+ */
+process.on('unhandledRejection', (reason) => {
+    throw new Error(reason);
+});

package/lib/interfaces/index.d.ts

@@ -0,0 +1,87 @@
+import { AsyncAPIDocumentInterface } from '@asyncapi/parser/cjs';
+import { OutputFormat } from '@stoplight/spectral-cli/dist/services/config';
+export type DiagnosticsFormat = 'stylish' | 'json' | 'junit' | 'html' | 'text' | 'teamcity' | 'pretty';
+export type SeverityKind = 'error' | 'warn' | 'info' | 'hint';
+export type Adapter = 'cli' | 'api';
+import specs from '@asyncapi/specs';
+import { Router } from 'express';
+import { AsyncAPIConvertVersion } from '@asyncapi/converter';
+export interface Controller {
+    basepath: string;
+    boot(): Router | Promise<Router>;
+}
+export interface Problem {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    [key: string]: any;
+}
+export type AsyncAPIDocument = {
+    asyncapi: string;
+} & Record<string, unknown>;
+export declare const ALL_SPECS: string[];
+export declare const LAST_SPEC_VERSION: string;
+export type SpecsEnum = keyof typeof specs | 'latest';
+export interface AsyncAPIServiceOptions {
+    source?: string;
+    path?: string;
+}
+export interface ServiceResult<T = any> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    diagnostics?: any[];
+}
+export interface ParsedDocument {
+    document: AsyncAPIDocumentInterface;
+    diagnostics: any[];
+    status: 'valid' | 'invalid';
+}
+export interface ValidationOptions {
+    'log-diagnostics'?: boolean;
+    'diagnostics-format'?: `${OutputFormat}`;
+    'fail-severity'?: SeverityKind;
+    output?: string;
+    suppressWarnings?: string[];
+    suppressAllWarnings?: boolean;
+}
+export interface ValidationResult {
+    status: 'valid' | 'invalid';
+    document?: AsyncAPIDocument;
+    diagnostics?: any[];
+    score?: number;
+}
+export interface ConversionOptions {
+    format: 'asyncapi' | 'openapi' | 'postman-collection';
+    'target-version'?: AsyncAPIConvertVersion;
+    perspective?: 'client' | 'server';
+}
+export interface ConversionResult {
+    convertedDocument: string;
+    originalFormat: string;
+}
+export interface IMapBaseUrlToFlag {
+    url: string;
+    folder: string;
+}
+export interface GenerationOptions {
+    templateParams?: Record<string, any>;
+    forceWrite?: boolean;
+    install?: boolean;
+    debug?: boolean;
+    noOverwriteGlobs?: string[];
+    disabledHooks?: Record<string, string>;
+    mapBaseUrl?: IMapBaseUrlToFlag;
+    registry?: {
+        url?: string;
+        auth?: string;
+        token?: string;
+    };
+}
+export interface GenerationResult {
+    success: boolean;
+    outputPath: string;
+    logs?: string[];
+}

package/lib/interfaces/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAST_SPEC_VERSION = exports.ALL_SPECS = void 0;
+const tslib_1 = require("tslib");
+const specs_1 = tslib_1.__importDefault(require("@asyncapi/specs"));
+exports.ALL_SPECS = [...Object.keys(specs_1.default)];
+exports.LAST_SPEC_VERSION = exports.ALL_SPECS[exports.ALL_SPECS.length - 1];

package/lib/utils/ajv.d.ts

@@ -0,0 +1,2 @@
+import type AjvCore from 'ajv/dist/core';
+export declare function createAjvInstance(): AjvCore;

package/lib/utils/ajv.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAjvInstance = createAjvInstance;
+const tslib_1 = require("tslib");
+const ajv_1 = tslib_1.__importDefault(require("ajv"));
+const ajv_formats_1 = tslib_1.__importDefault(require("ajv-formats"));
+function createAjvInstance() {
+    const ajv = new ajv_1.default({
+        allErrors: true,
+        meta: true,
+        strict: false,
+        allowUnionTypes: true,
+        logger: false,
+        unicodeRegExp: false,
+    });
+    (0, ajv_formats_1.default)(ajv);
+    return ajv;
+}

package/lib/utils/app-openapi.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Retrieve application's OpenAPI document.
+ */
+export declare function getAppOpenAPI(): Promise<any>;

package/lib/utils/app-openapi.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppOpenAPI = getAppOpenAPI;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const path_1 = tslib_1.__importDefault(require("path"));
+const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
+const json_schema_ref_parser_1 = tslib_1.__importDefault(require("@apidevtools/json-schema-ref-parser"));
+let parsedOpenAPI = undefined;
+/**
+ * Retrieve application's OpenAPI document.
+ */
+function getAppOpenAPI() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (parsedOpenAPI) {
+            return parsedOpenAPI;
+        }
+        const openaAPI = yield fs_1.promises.readFile(path_1.default.join(__dirname, '../../openapi.yaml'), 'utf-8');
+        parsedOpenAPI = js_yaml_1.default.load(openaAPI);
+        // due to the fact that `@asyncapi/specs: 3.0.0` have moved to a new way of bundling schemas, it makes no sense to resolve the references for AsyncAPI specs
+        parsedOpenAPI.components.schemas.AsyncAPIDocument.oneOf = {
+            type: ['string', 'object'],
+        };
+        const refParser = new json_schema_ref_parser_1.default();
+        yield refParser.dereference(parsedOpenAPI);
+        return parsedOpenAPI;
+    });
+}

package/lib/utils/generate/flags.d.ts

@@ -0,0 +1,2 @@
+import { ParsedFlags } from '../../domains/models/generate/Flags';
+export declare function parseGeneratorFlags(disableHooks?: string[], params?: string[], mapBaseUrl?: string, registryUrl?: string, registryAuth?: string, registryToken?: string): ParsedFlags;

package/lib/utils/generate/flags.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGeneratorFlags = parseGeneratorFlags;
+const parseParams_1 = require("./parseParams");
+const registry_1 = require("./registry");
+function parseGeneratorFlags(disableHooks, params, mapBaseUrl, registryUrl, registryAuth, registryToken) {
+    return {
+        params: (0, parseParams_1.paramParser)(params),
+        disableHooks: (0, parseParams_1.disableHooksParser)(disableHooks),
+        mapBaseUrlToFolder: (0, parseParams_1.mapBaseURLParser)(mapBaseUrl),
+        registryURLValidation: (0, registry_1.registryURLParser)(registryUrl),
+        registryAuthentication: (0, registry_1.registryValidation)(registryUrl, registryAuth, registryToken)
+    };
+}

package/lib/utils/generate/mapBaseUrl.d.ts

@@ -0,0 +1,6 @@
+import { IMapBaseUrlToFlag } from '../../domains/models/generate/Flags';
+export declare function getMapBaseUrlToFolderResolver(urlToFolder: IMapBaseUrlToFlag): {
+    order: number;
+    canRead(): boolean;
+    read(file: any): Promise<unknown>;
+};

package/lib/utils/generate/mapBaseUrl.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMapBaseUrlToFolderResolver = getMapBaseUrlToFolderResolver;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+function getMapBaseUrlToFolderResolver(urlToFolder) {
+    return {
+        order: 1,
+        canRead() {
+            return true;
+        },
+        read(file) {
+            const baseUrl = urlToFolder.url;
+            const baseDir = urlToFolder.folder;
+            return new Promise((resolve, reject) => {
+                let localpath = file.url;
+                localpath = localpath.replace(baseUrl, baseDir);
+                try {
+                    fs.readFile(localpath, (err, data) => {
+                        if (err) {
+                            reject(`Error opening file "${localpath}"`);
+                        }
+                        else {
+                            resolve(data);
+                        }
+                    });
+                }
+                catch (err) {
+                    reject(`Error opening file "${localpath}"`);
+                }
+            });
+        }
+    };
+}

package/lib/utils/generate/parseParams.d.ts

@@ -0,0 +1,3 @@
+export declare function paramParser(inputs?: string[]): Record<string, any>;
+export declare function disableHooksParser(inputs?: string[]): Record<string, any>;
+export declare function mapBaseURLParser(input?: string): any;

package/lib/utils/generate/parseParams.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paramParser = paramParser;
+exports.disableHooksParser = disableHooksParser;
+exports.mapBaseURLParser = mapBaseURLParser;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+function paramParser(inputs) {
+    if (!inputs) {
+        return {};
+    }
+    const params = {};
+    for (const input of inputs) {
+        if (!input.includes('=')) {
+            throw new Error(`Invalid param ${input}. It must be in the format of --param name1=value1 name2=value2 `);
+        }
+        const [paramName, paramValue] = input.split(/=(.+)/, 2);
+        params[String(paramName)] = paramValue;
+    }
+    return params;
+}
+function disableHooksParser(inputs) {
+    if (!inputs) {
+        return {};
+    }
+    const disableHooks = {};
+    for (const input of inputs) {
+        const [hookType, hookNames] = input.split(/=/);
+        if (!hookType) {
+            throw new Error('Invalid --disable-hook flag. It must be in the format of: --disable-hook <hookType> or --disable-hook <hookType>=<hookName1>,<hookName2>,...');
+        }
+        if (hookNames) {
+            disableHooks[String(hookType)] = hookNames.split(',');
+        }
+        else {
+            disableHooks[String(hookType)] = true;
+        }
+    }
+    return disableHooks;
+}
+function mapBaseURLParser(input) {
+    if (!input) {
+        return;
+    }
+    const mapBaseURLToFolder = {};
+    const re = /(.*):(.*)/g; // NOSONAR
+    let mapping = [];
+    if ((mapping = re.exec(input)) === null || mapping.length !== 3) {
+        throw new Error('Invalid --map-base-url flag. A mapping <url>:<folder> with delimiter : expected.');
+    }
+    mapBaseURLToFolder.url = mapping[1].replace(/\/$/, '');
+    mapBaseURLToFolder.folder = path_1.default.resolve(mapping[2]);
+    const isURL = /^https?:/;
+    if (!isURL.test(mapBaseURLToFolder.url.toLowerCase())) {
+        throw new Error('Invalid --map-base-url flag. The mapping <url>:<folder> requires a valid http/https url and valid folder with delimiter `:`.');
+    }
+    return mapBaseURLToFolder;
+}

package/lib/utils/generate/prompts.d.ts

@@ -0,0 +1,4 @@
+export declare function promptForAsyncAPIPath(): Promise<string>;
+export declare function promptForLanguage(defaultLanguage: string): Promise<string>;
+export declare function promptForTemplate(): Promise<string>;
+export declare function promptForOutputDir(): Promise<string>;

package/lib/utils/generate/prompts.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptForAsyncAPIPath = promptForAsyncAPIPath;
+exports.promptForLanguage = promptForLanguage;
+exports.promptForTemplate = promptForTemplate;
+exports.promptForOutputDir = promptForOutputDir;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const prompts_1 = require("@clack/prompts");
+const OPERATION_CANCELLED_ERROR = 'Operation cancelled';
+function promptForAsyncAPIPath() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const asyncapi = yield (0, prompts_1.text)({
+            message: 'Please provide the path to the AsyncAPI document',
+            placeholder: 'asyncapi.yaml',
+            defaultValue: 'asyncapi.yaml',
+            validate(value) {
+                if (!value) {
+                    return 'The path to the AsyncAPI document is required';
+                }
+                else if (!fs_1.default.existsSync(value)) {
+                    return 'The file does not exist';
+                }
+            }
+        });
+        if ((0, prompts_1.isCancel)(asyncapi)) {
+            throw new Error(OPERATION_CANCELLED_ERROR);
+        }
+        return asyncapi;
+    });
+}
+function promptForLanguage(defaultLanguage) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const language = yield (0, prompts_1.text)({
+            message: 'Please provide the language of the generated client',
+            placeholder: defaultLanguage,
+            defaultValue: defaultLanguage,
+        });
+        if ((0, prompts_1.isCancel)(language)) {
+            throw new Error(OPERATION_CANCELLED_ERROR);
+        }
+        return language;
+    });
+}
+function promptForTemplate() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const template = yield (0, prompts_1.text)({
+            message: 'Please provide the name of the generator template',
+            placeholder: '@asyncapi/html-template',
+            defaultValue: '@asyncapi/html-template',
+        });
+        if ((0, prompts_1.isCancel)(template)) {
+            throw new Error(OPERATION_CANCELLED_ERROR);
+        }
+        return template;
+    });
+}
+function promptForOutputDir() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const output = yield (0, prompts_1.text)({
+            message: 'Please provide the output directory',
+            placeholder: './docs',
+            validate(value) {
+                if (!value) {
+                    return 'The output directory is required';
+                }
+                else if (typeof value !== 'string') {
+                    return 'The output directory must be a string';
+                }
+            }
+        });
+        if ((0, prompts_1.isCancel)(output)) {
+            throw new Error(OPERATION_CANCELLED_ERROR);
+        }
+        return output;
+    });
+}

package/lib/utils/generate/registry.d.ts

@@ -0,0 +1,2 @@
+export declare function registryURLParser(input?: string): void;
+export declare function registryValidation(registryUrl?: string, registryAuth?: string, registryToken?: string): Promise<void>;

package/lib/utils/generate/registry.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registryURLParser = registryURLParser;
+exports.registryValidation = registryValidation;
+const tslib_1 = require("tslib");
+function registryURLParser(input) {
+    if (!input) {
+        return;
+    }
+    const isURL = /^https?:/;
+    if (!isURL.test(input.toLowerCase())) {
+        throw new Error('Invalid --registry-url flag. The param requires a valid http/https url.');
+    }
+}
+function registryValidation(registryUrl, registryAuth, registryToken) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (!registryUrl) {
+            return;
+        }
+        try {
+            const response = yield fetch(registryUrl);
+            if (response.status === 401 && !registryAuth && !registryToken) {
+                throw new Error('You Need to pass either registryAuth in username:password encoded in Base64 or need to pass registryToken');
+            }
+        }
+        catch (error) {
+            throw new Error(`Can't fetch registryURL: ${registryUrl}`);
+        }
+    });
+}

package/lib/utils/generate/watcher.d.ts

@@ -0,0 +1,51 @@
+export declare function isLocalTemplate(templatePath: string): Promise<boolean>;
+export declare class Watcher {
+    private watchers;
+    private fsWait;
+    private filesChanged;
+    private ignorePaths;
+    private paths;
+    constructor(paths: string | string[], ignorePaths: string[]);
+    /**
+     * Initiates watch on a path.
+     * @param {*} path The path the watcher is listening on.
+     * @param {*} changeCallback Callback to call when changed occur.
+     * @param {*} errorCallback Calback to call when it is no longer possible to watch a file.
+     */
+    initiateWatchOnPath(path: string, changeCallback: any, errorCallback: any): void;
+    /**
+     * This method initiate the watch for change in all files
+     * @param {*} callback called when the file(s) change
+     */
+    watch(changeCallback: any, errorCallback: any): Promise<void>;
+    /**
+     * Should be called when a file has changed one way or another.
+     * @param {*} listenerPath The path the watcher is listening on.
+     * @param {*} changedPath The file/dir that was changed
+     * @param {*} eventType What kind of change
+     * @param {*} changeCallback Callback to call when changed occur.
+     * @param {*} errorCallback Calback to call when it is no longer possible to watch a file.
+     */
+    fileChanged(listenerPath: string, changedPath: string, eventType: string, changeCallback: any, errorCallback: any): void;
+    /**
+     * Convert the event type to a more usefull one.
+     * @param {*} currentEventType The current event type (from chokidar)
+     */
+    convertEventType(currentEventType: string): string;
+    /**
+     * Get all paths which no longer exists
+     */
+    getAllNonExistingPaths(): any[];
+    /**
+     * Closes all active watchers down.
+     */
+    closeWatchers(): void;
+    /**
+     * Closes an active watcher down.
+     * @param {*} path The path to close the watcher for.
+     */
+    closeWatcher(path: string): void;
+}
+export declare function runWatchMode(thisArg: any, asyncapi: string, template: string, output: string, generatorClass: any, // ✅ passed in
+watchHandler: (changedFiles: Record<string, any>) => Promise<void>): Promise<void>;
+export declare function watcherHandler(thisArg: any, asyncapi: string, template: string, output: string, options: Record<string, any>, genOption: any, interactive: boolean): (changedFiles: Record<string, any>) => Promise<void>;