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

package/lib/apps/cli/internal/globals.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.specWatcher = void 0;
+const tslib_1 = require("tslib");
+const chokidar_1 = tslib_1.__importDefault(require("chokidar"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const GreenLog = chalk_1.default.hex('#00FF00');
+const OrangeLog = chalk_1.default.hex('#FFA500');
+const CHOKIDAR_CONFIG = {
+// awaitWriteFinish: true // Used for large size specification files.
+};
+const WATCH_MESSAGES = {
+    logOnStart: (filePath) => console.log(GreenLog(`Watching AsyncAPI file at ${filePath}\n`)),
+    logOnChange: (handlerName) => console.log(OrangeLog(`Change detected, running ${handlerName}\n`)),
+    logOnAutoDisable: (docVersion = '') => console.log(OrangeLog(`Watch mode for ${docVersion || 'AsyncAPI'} file was not enabled.`), OrangeLog('\nINFO: Watch works only with files from local file system\n')),
+};
+const CHOKIDAR_INSTANCE_STORE = new Map();
+const specWatcher = (params) => {
+    var _a;
+    if (!params.spec.getFilePath()) {
+        return WATCH_MESSAGES.logOnAutoDisable(params.docVersion);
+    }
+    if (CHOKIDAR_INSTANCE_STORE.get((_a = params.label) !== null && _a !== void 0 ? _a : '_default')) {
+        return;
+    }
+    const filePath = params.spec.getFilePath();
+    try {
+        WATCH_MESSAGES.logOnStart(filePath);
+        chokidar_1.default.watch(filePath, CHOKIDAR_CONFIG).on('change', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            if (params.handlerName) {
+                WATCH_MESSAGES.logOnChange(params.handlerName);
+            }
+            try {
+                yield params.handler.run();
+            }
+            catch (err) {
+                yield params.handler.catch(err);
+            }
+        }));
+        CHOKIDAR_INSTANCE_STORE.set(params.label || '_default', true);
+    }
+    catch (error) {
+        console.log(error);
+    }
+};
+exports.specWatcher = specWatcher;

package/lib/apps/cli/internal/hooks/command_not_found/myhook.d.ts

@@ -0,0 +1,4 @@
+import { Hook } from '@oclif/core';
+export declare const closest: (target: string, possibilities: string[]) => string;
+declare const hook: Hook.CommandNotFound;
+export default hook;

package/lib/apps/cli/internal/hooks/command_not_found/myhook.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.closest = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const prompts_1 = require("@clack/prompts");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fast_levenshtein_1 = tslib_1.__importDefault(require("fast-levenshtein"));
+const closest = (target, possibilities) => {
+    var _a, _b;
+    return (_b = (_a = possibilities
+        .map((id) => ({
+        distance: fast_levenshtein_1.default.get(target, id, { useCollator: true }),
+        id,
+    }))
+        .sort((a, b) => a.distance - b.distance)[0]) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : '';
+};
+exports.closest = closest;
+const hook = function (opts) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (opts.id === '--help') {
+            const help = new core_1.Help(this.config);
+            help.showHelp(['--help']);
+            return;
+        }
+        const hiddenCommandIds = new Set(opts.config.commands.filter((c) => c.hidden).map((c) => c.id));
+        const commandIDs = [
+            ...opts.config.commandIDs,
+            ...opts.config.commands.flatMap((c) => c.aliases),
+        ].filter((c) => !hiddenCommandIds.has(c));
+        if (commandIDs.length === 0) {
+            return;
+        }
+        // now we we return if the command id are not there.
+        let binHelp = `${opts.config.bin} --help`;
+        const idSplit = opts.id.split(':');
+        if (opts.config.findTopic(idSplit[0])) {
+            // if valid topic, update binHelp with topic
+            binHelp = `${binHelp} ${idSplit[0]}`;
+        }
+        //if there is a topic in the opts we just upgrade the our commnad like
+        // alter the suggestion in the help scenario so that help is the first command
+        // otherwise the user will be presented 'did you mean 'help'?' instead of 'did you mean "help <command>"?'
+        let suggestion = (/:?help:?/).test(opts.id)
+            ? ['help', ...opts.id.split(':').filter((cmd) => cmd !== 'help')].join(':')
+            : (0, exports.closest)(opts.id, commandIDs);
+        let readableSuggestion = (0, core_1.toConfiguredId)(suggestion, this.config);
+        const originalCmd = (0, core_1.toConfiguredId)(opts.id, this.config);
+        this.warn(`${chalk_1.default.yellow(originalCmd)} is not a ${opts.config.bin} command.`);
+        let response;
+        try {
+            if (opts.id === 'help') {
+                readableSuggestion = '--help';
+            }
+            response = yield (0, prompts_1.confirm)({
+                message: `Did you mean ${chalk_1.default.blueBright(readableSuggestion)}? [y/n]`,
+            });
+        }
+        catch (error) {
+            this.log('');
+            this.debug(error);
+        }
+        if (response === true) {
+            // this will split the original command from the suggested replacement, and gather the remaining args as varargs to help with situations like:
+            // confit set foo-bar -> confit:set:foo-bar -> config:set:foo-bar -> config:set foo-bar
+            let argv = ((_a = opts.argv) === null || _a === void 0 ? void 0 : _a.length)
+                ? opts.argv
+                : opts.id.split(':').slice(suggestion.split(':').length);
+            if (suggestion.startsWith('help:')) {
+                // the args are the command/partial command you need help for (package:version)
+                // we created the suggestion variable to start with "help" so slice the first entry
+                argv = suggestion.split(':').slice(1);
+                // the command is just the word "help"
+                suggestion = 'help';
+            }
+            if (opts.id === 'help') {
+                return this.config.runCommand('--help');
+            }
+            return this.config.runCommand(suggestion, argv);
+        }
+        this.error(`Run ${chalk_1.default.bold.cyan(binHelp)} for a list of available commands.`, { exit: 127 });
+    });
+};
+exports.default = hook;

package/lib/domains/models/Context.d.ts

@@ -0,0 +1,21 @@
+export declare const DEFAULT_CONTEXT_FILE_PATH: string;
+export declare let CONTEXT_FILE_PATH: string;
+export interface IContextFile {
+    current?: string;
+    readonly store: {
+        [name: string]: string;
+    };
+}
+export interface ICurrentContext {
+    readonly current: string;
+    readonly context: string;
+}
+export declare function initContext(contextFilePath: string): Promise<string>;
+export declare function loadContext(contextName?: string): Promise<string>;
+export declare function addContext(contextName: string, pathToFile: string): Promise<void>;
+export declare function removeContext(contextName: string): Promise<void>;
+export declare function getCurrentContext(): Promise<ICurrentContext>;
+export declare function setCurrentContext(contextName: string): Promise<void>;
+export declare function editContext(contextName: string, pathToFile: string): Promise<void>;
+export declare function loadContextFile(): Promise<IContextFile>;
+export declare function isContextFileEmpty(fileContent: IContextFile): Promise<boolean>;

package/lib/domains/models/Context.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTEXT_FILE_PATH = exports.DEFAULT_CONTEXT_FILE_PATH = void 0;
+exports.initContext = initContext;
+exports.loadContext = loadContext;
+exports.addContext = addContext;
+exports.removeContext = removeContext;
+exports.getCurrentContext = getCurrentContext;
+exports.setCurrentContext = setCurrentContext;
+exports.editContext = editContext;
+exports.loadContextFile = loadContextFile;
+exports.isContextFileEmpty = isContextFileEmpty;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const path = tslib_1.__importStar(require("path"));
+const os = tslib_1.__importStar(require("os"));
+const context_error_1 = require("../../errors/context-error");
+const { readFile, writeFile } = fs_1.promises;
+// `repoRootPath` is optimistically assigned current working directory's
+// filesystem path because chances are it will become 'official' repository root
+// down the execution.
+//
+// `REPO_ROOT_PATH` will be converted to a real constant after migration of the
+// codebase to ES2022 or higher and introduction of construction
+//
+// const REPO_ROOT_PATH = await getRepoRootPath(process.cwd());
+//
+// See explanation of the situation with `CONTEXT_FILE_PATH` below.
+let REPO_ROOT_PATH = process.cwd();
+getRepoRootPath(process.cwd());
+const DEFAULT_CONTEXT_FILENAME = '.asyncapi-cli';
+const DEFAULT_CONTEXT_FILE_LOCATION = os.homedir();
+exports.DEFAULT_CONTEXT_FILE_PATH = path.resolve(DEFAULT_CONTEXT_FILE_LOCATION, DEFAULT_CONTEXT_FILENAME);
+const CONTEXT_FILENAME = process.env.CUSTOM_CONTEXT_FILENAME || DEFAULT_CONTEXT_FILENAME;
+const CONTEXT_FILE_LOCATION = process.env.CUSTOM_CONTEXT_FILE_LOCATION || DEFAULT_CONTEXT_FILE_LOCATION;
+// Usage of promises for assignment of their resolved values to constants is
+// known to be troublesome:
+// https://www.reddit.com/r/learnjavascript/comments/p7p7zw/assigning_data_from_a_promise_to_a_constant
+//
+// In this particular case and usage of ES6, there is a race condition during
+// code execution, due to faster assignment of default values to
+// `CONTEXT_FILE_PATH` than resolution of the promise. This is the cause
+// `CONTEXT_FILE_PATH` will always pick default values for context file's path
+// instead of waiting for resolution of the promise from `getContextFilePath()`.
+// The situation might become better with use of top-level await which should
+// pause code execution, until promise in construction
+//
+// const CONTEXT_FILE_PATH = await getContextFilePath() || path.resolve(CONTEXT_FILE_LOCATION, CONTEXT_FILENAME) || DEFAULT_CONTEXT_FILE_PATH;
+//
+// is resolved, but for this to be checked, all codebase (including
+// `@oclif/core`) needs to be migrated to ES2022 or higher.
+//
+// Until then `CONTEXT_FILE_PATH` name is mimicking a `const` while right now it
+// is a `let` reassigned inside of `getContextFilePath()`.
+exports.CONTEXT_FILE_PATH = path.resolve(CONTEXT_FILE_LOCATION, CONTEXT_FILENAME) ||
+    exports.DEFAULT_CONTEXT_FILE_PATH;
+// Sonar recognizes next line as a bug `Promises must be awaited, end with a
+// call to .catch, or end with a call to .then with a rejection handler.` but
+// due to absence of top-level await in ES6, this bug cannot be fixed without
+// migrating the codebase to ES2022 or higher, thus suppressing Sonar analysis
+// for this line.
+getContextFilePath(); // NOSONAR
+function initContext(contextFilePath) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const fileContent = {
+            store: {},
+        };
+        let contextWritePath = '';
+        // prettier-ignore
+        switch (contextFilePath) {
+            /* eslint-disable indent */
+            case '.':
+                contextWritePath = process.cwd() + path.sep + CONTEXT_FILENAME;
+                break;
+            case './':
+                contextWritePath = REPO_ROOT_PATH + path.sep + CONTEXT_FILENAME;
+                break;
+            // There are two variants of `~` case because tilde expansion in UNIX
+            // systems is not a guaranteed feature - sometimes `~` can return just `~`
+            // instead of home directory path.
+            // https://stackoverflow.com/questions/491877/how-to-find-a-users-home-directory-on-linux-or-unix#comment17161699_492669
+            case os.homedir():
+                contextWritePath = os.homedir() + path.sep + CONTEXT_FILENAME;
+                break;
+            case '~':
+                contextWritePath = os.homedir() + path.sep + CONTEXT_FILENAME;
+                break;
+            default:
+                contextWritePath = process.cwd() + path.sep + CONTEXT_FILENAME;
+        }
+        try {
+            yield writeFile(contextWritePath, JSON.stringify(fileContent), {
+                encoding: 'utf8',
+            });
+        }
+        catch (e) {
+            throw new context_error_1.ContextFileWriteError(contextWritePath);
+        }
+        return contextWritePath;
+    });
+}
+function loadContext(contextName) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const fileContent = yield loadContextFile();
+        if (contextName) {
+            const context = fileContent.store[String(contextName)];
+            if (!context) {
+                throw new context_error_1.ContextNotFoundError(contextName);
+            }
+            return context;
+        }
+        else if (fileContent.current) {
+            const context = fileContent.store[fileContent.current];
+            if (!context) {
+                throw new context_error_1.ContextNotFoundError(fileContent.current);
+            }
+            return context;
+        }
+        throw new context_error_1.MissingCurrentContextError();
+    });
+}
+function addContext(contextName, pathToFile) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const fileContent = yield loadContextFile();
+        // If context file already has context name similar to the one specified as
+        // an argument, notify user about it (throw `ContextAlreadyExistsError`
+        // error) and exit.
+        if (fileContent.store.hasOwnProperty.call(fileContent.store, contextName)) {
+            throw new context_error_1.ContextAlreadyExistsError(contextName, exports.CONTEXT_FILE_PATH);
+        }
+        fileContent.store[String(contextName)] = String(pathToFile);
+        yield saveContextFile(fileContent);
+    });
+}
+function removeContext(contextName) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const fileContent = yield loadContextFile();
+        if (yield isContextFileEmpty(fileContent)) {
+            throw new context_error_1.ContextFileEmptyError(exports.CONTEXT_FILE_PATH);
+        }
+        if (!fileContent.store[String(contextName)]) {
+            throw new context_error_1.ContextNotFoundError(contextName);
+        }
+        if (fileContent.current === contextName) {
+            delete fileContent.current;
+        }
+        delete fileContent.store[String(contextName)];
+        yield saveContextFile(fileContent);
+    });
+}
+function getCurrentContext() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const fileContent = yield loadContextFile();
+        if (yield isContextFileEmpty(fileContent)) {
+            throw new context_error_1.ContextFileEmptyError(exports.CONTEXT_FILE_PATH);
+        }
+        const context = yield loadContext();
+        return {
+            current: fileContent.current,
+            context,
+        };
+    });
+}
+function setCurrentContext(contextName) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const fileContent = yield loadContextFile();
+        if (yield isContextFileEmpty(fileContent)) {
+            throw new context_error_1.ContextFileEmptyError(exports.CONTEXT_FILE_PATH);
+        }
+        if (!fileContent.store[String(contextName)]) {
+            throw new context_error_1.ContextNotFoundError(contextName);
+        }
+        fileContent.current = String(contextName);
+        yield saveContextFile(fileContent);
+    });
+}
+function editContext(contextName, pathToFile) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        // The expression is not wrapped in a `try...catch` block and is allowed to
+        // throw automatically because it is assumed that `loadContextFile()` works
+        // with a 100%-existing valid file in this case, thus if it threw anyway -
+        // some REAL error happened and user should know about it.
+        const fileContent = yield loadContextFile();
+        if (yield isContextFileEmpty(fileContent)) {
+            throw new context_error_1.ContextFileEmptyError(exports.CONTEXT_FILE_PATH);
+        }
+        fileContent.store[String(contextName)] = String(pathToFile);
+        yield saveContextFile(fileContent);
+    });
+}
+function loadContextFile() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        let fileContent;
+        // If the context file cannot be read then it's a 'MissingContextFileError'
+        // error.
+        try {
+            yield readFile(exports.CONTEXT_FILE_PATH, { encoding: 'utf8' });
+        }
+        catch (e) {
+            throw new context_error_1.MissingContextFileError();
+        }
+        // If the context file cannot be parsed then it's a
+        // 'ContextFileWrongFormatError' error.
+        try {
+            fileContent = JSON.parse(yield readFile(exports.CONTEXT_FILE_PATH, { encoding: 'utf8' }));
+        }
+        catch (e) {
+            // https://stackoverflow.com/questions/29797946/handling-bad-json-parse-in-node-safely
+            throw new context_error_1.ContextFileWrongFormatError(exports.CONTEXT_FILE_PATH);
+        }
+        // If the context file cannot be validated then it's a
+        // 'ContextFileWrongFormatError' error.
+        if (!(yield isContextFileValid(fileContent))) {
+            throw new context_error_1.ContextFileWrongFormatError(exports.CONTEXT_FILE_PATH);
+        }
+        return fileContent;
+    });
+}
+function saveContextFile(fileContent) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            yield writeFile(exports.CONTEXT_FILE_PATH, JSON.stringify({
+                current: fileContent.current,
+                store: fileContent.store,
+            }), { encoding: 'utf8' });
+        }
+        catch (e) {
+            throw new context_error_1.ContextFileWriteError(exports.CONTEXT_FILE_PATH);
+        }
+    });
+}
+function getRepoRootPath(repoRootPath) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        // Asynchronous `fs.exists()` is deprecated, asynchronous `fs.stat()`
+        // introduces race condition, thus synchronous functions are used.
+        let pathToCheck = `${repoRootPath}${path.sep}.git`;
+        // If directory where `init` was requested in, happens to contain `.git`
+        // directory, then it surely is a root of repository, no need to search
+        // further and `REPO_ROOT_PATH` will remain as it was.
+        if ((0, fs_1.existsSync)(pathToCheck) && (0, fs_1.lstatSync)(pathToCheck).isDirectory()) {
+            return null;
+        }
+        // Directory where `init` was requested in, did not happen to contain `.git`
+        // directory, so preparation for iterating through array of filesystem paths
+        // is started.
+        const repoRootPathArray = repoRootPath.split(path.sep);
+        // Last element in array is thrown away because it is already known that it
+        // does not contain directory `.git`.
+        repoRootPathArray.pop();
+        // Backwards search of the array of filesystem paths will now be performed.
+        let i = repoRootPathArray.length - 1;
+        while (i > 0) {
+            pathToCheck = `${repoRootPathArray.join(path.sep)}${path.sep}.git`;
+            if ((0, fs_1.existsSync)(pathToCheck) && (0, fs_1.lstatSync)(pathToCheck).isDirectory()) {
+                REPO_ROOT_PATH = repoRootPathArray.join(path.sep);
+                return REPO_ROOT_PATH;
+            }
+            // Last (`0th`) element is an empty string, so if directory `.git` was not
+            // found on 1st element (last actual directory in filesystem), the search
+            // does not need to continue and `REPO_ROOT_PATH` will remain having the
+            // value of current (where `init` was requested in) directory.
+            if (i === 1) {
+                return null;
+            }
+            repoRootPathArray.pop();
+            i--;
+        }
+        return null;
+    });
+}
+function getContextFilePath() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const currentPath = process
+            .cwd()
+            .slice(REPO_ROOT_PATH.length + 1)
+            .split(path.sep);
+        currentPath.unshift(REPO_ROOT_PATH);
+        for (let i = currentPath.length; i >= 0; i--) {
+            const currentPathString = currentPath[0]
+                ? currentPath.join(path.sep) + path.sep + CONTEXT_FILENAME
+                : os.homedir() + path.sep + CONTEXT_FILENAME;
+            // This `try...catch` is a part of `for` loop and is used only to swallow
+            // errors if the file does not exist or cannot be read, to continue
+            // uninterrupted execution of the loop.
+            try {
+                // If a file is found which can be read and passed validation as a
+                // legitimate context file, then it is considered a legitimate context
+                // file indeed.
+                const fileContent = JSON.parse(
+                //we do not use await readFile because getContextFilePath cannot be called inside async function
+                (0, fs_1.readFileSync)(currentPathString, { encoding: 'utf8' }));
+                if (fileContent &&
+                    (yield isContextFileValid(fileContent))) {
+                    exports.CONTEXT_FILE_PATH = currentPathString;
+                    return exports.CONTEXT_FILE_PATH;
+                }
+            }
+            catch (e) { } // eslint-disable-line
+            currentPath.pop();
+        }
+        return null;
+    });
+}
+function isContextFileValid(fileContent) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        // Validation of context file's format against interface `IContextFile`.
+        return ([1, 2].includes(Object.keys(fileContent).length) &&
+            fileContent.hasOwnProperty.call(fileContent, 'store') &&
+            !Array.from(Object.keys(fileContent.store)).find((elem) => typeof elem !== 'string') &&
+            !Array.from(Object.values(fileContent.store)).find((elem) => typeof elem !== 'string'));
+    });
+}
+function isContextFileEmpty(fileContent) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        // If context file contains only one empty property `store` then the whole
+        // context file is considered empty.
+        return (fileContent &&
+            Object.keys(fileContent).length === 1 &&
+            Object.keys(fileContent.store).length === 0);
+    });
+}

package/lib/domains/models/Preview.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_PORT = 0;
+export declare function startPreview(filePath: string, base: string | undefined, baseDirectory: string | undefined, xOrigin: boolean | undefined, suppressLogs: boolean | undefined, port?: number, noBrowser?: boolean): void;