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

package/lib/utils/generate/watcher.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Watcher = void 0;
+exports.isLocalTemplate = isLocalTemplate;
+exports.runWatchMode = runWatchMode;
+exports.watcherHandler = watcherHandler;
+const tslib_1 = require("tslib");
+// eslint-disable security/detect-object-injection
+const fs = tslib_1.__importStar(require("fs"));
+const util_1 = require("util");
+const chokidar_1 = tslib_1.__importDefault(require("chokidar"));
+const lstat = (0, util_1.promisify)(fs.lstat);
+const path_1 = tslib_1.__importDefault(require("path"));
+const picocolors_1 = require("picocolors");
+const SpecificationFile_1 = require("../../domains/models/SpecificationFile");
+const generator_error_1 = require("../../errors/generator-error");
+function isLocalTemplate(templatePath) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const stats = yield lstat(templatePath);
+        return stats.isSymbolicLink();
+    });
+}
+class Watcher {
+    constructor(paths, ignorePaths) {
+        if (Array.isArray(paths)) {
+            this.paths = paths;
+        }
+        else {
+            this.paths = [paths];
+        }
+        //Ensure all backwards slashes are replaced with forward slash based on the requirement from chokidar
+        for (const pathIndex in this.paths) {
+            const path = this.paths[String(pathIndex)];
+            this.paths[String(pathIndex)] = path.replace(/[\\]/g, '/');
+        }
+        this.fsWait = false;
+        this.watchers = {};
+        this.filesChanged = {};
+        this.ignorePaths = ignorePaths;
+    }
+    /**
+     * 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, changeCallback, errorCallback) {
+        const watcher = chokidar_1.default.watch(path, { ignoreInitial: true, ignored: this.ignorePaths });
+        watcher.on('all', (eventType, changedPath) => this.fileChanged(path, changedPath, eventType, changeCallback, errorCallback));
+        this.watchers[String(path)] = watcher;
+    }
+    /**
+     * This method initiate the watch for change in all files
+     * @param {*} callback called when the file(s) change
+     */
+    watch(changeCallback, errorCallback) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            for (const index in this.paths) {
+                const path = this.paths[String(index)];
+                this.initiateWatchOnPath(path, changeCallback, errorCallback);
+            }
+        });
+    }
+    /**
+     * 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, changedPath, eventType, changeCallback, errorCallback) {
+        try {
+            if (fs.existsSync(listenerPath)) {
+                const newEventType = this.convertEventType(eventType);
+                this.filesChanged[String(changedPath)] = { eventType: newEventType, path: changedPath };
+                // Since multiple changes can occur at the same time, lets wait a bit before processing.
+                if (this.fsWait) {
+                    return;
+                }
+                this.fsWait = setTimeout(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    yield changeCallback(this.filesChanged);
+                    this.filesChanged = {};
+                    this.fsWait = false;
+                }), 500);
+            }
+        }
+        catch (e) {
+            // File was not, find all files that are missing..
+            const unknownPaths = this.getAllNonExistingPaths();
+            this.closeWatchers();
+            errorCallback(unknownPaths);
+        }
+    }
+    /**
+     * Convert the event type to a more usefull one.
+     * @param {*} currentEventType The current event type (from chokidar)
+     */
+    convertEventType(currentEventType) {
+        let newEventType = currentEventType;
+        //Change the naming of the event type
+        switch (newEventType) {
+            case 'unlink':
+            case 'unlinkDir':
+                newEventType = 'removed';
+                break;
+            case 'addDir':
+            case 'add':
+                newEventType = 'added';
+                break;
+            case 'change':
+                newEventType = 'changed';
+                break;
+            case 'rename':
+                newEventType = 'renamed';
+                break;
+            default:
+                newEventType = `unknown (${currentEventType})`;
+        }
+        return newEventType;
+    }
+    /**
+     * Get all paths which no longer exists
+     */
+    getAllNonExistingPaths() {
+        const unknownPaths = [];
+        for (const index in this.paths) {
+            const path = this.paths[String(index)];
+            if (!fs.existsSync(path)) {
+                unknownPaths.push(path);
+            }
+        }
+        return unknownPaths;
+    }
+    /**
+     * Closes all active watchers down.
+     */
+    closeWatchers() {
+        this.filesChanged = {};
+        for (const index in this.paths) {
+            const path = this.paths[String(index)];
+            this.closeWatcher(path);
+        }
+    }
+    /**
+     * Closes an active watcher down.
+     * @param {*} path The path to close the watcher for.
+     */
+    closeWatcher(path) {
+        // Ensure if called before `watch` to do nothing
+        if (path !== null) {
+            const watcher = this.watchers[String(path)];
+            if (watcher !== null) {
+                watcher.close();
+                this.watchers[String(path)] = null;
+            }
+            else {
+                //Watcher not found for path
+            }
+        }
+    }
+}
+exports.Watcher = Watcher;
+function runWatchMode(thisArg, asyncapi, template, output, generatorClass, // ✅ passed in
+watchHandler) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const specification = yield (0, SpecificationFile_1.load)(asyncapi);
+        const watchDir = path_1.default.resolve(template);
+        const outputPath = path_1.default.resolve(watchDir, output);
+        const transpiledTemplatePath = path_1.default.resolve(watchDir, generatorClass.TRANSPILED_TEMPLATE_LOCATION); // ✅ use dynamic class
+        const ignorePaths = [outputPath, transpiledTemplatePath];
+        const specificationFile = specification.getFilePath();
+        // Template name is needed as it is not always a part of the cli command
+        // There is a use case that you run generator from a root of the template with `./` path
+        let templateName = '';
+        try {
+            // eslint-disable-next-line
+            templateName = require(path_1.default.resolve(watchDir, 'package.json')).name;
+        }
+        catch (_) {
+            // intentional
+        }
+        let watcher;
+        if (specificationFile) {
+            thisArg.log(`[WATCHER] Watching for changes in the template directory ${(0, picocolors_1.magenta)(watchDir)} and in the AsyncAPI file ${(0, picocolors_1.magenta)(specificationFile)}`);
+            watcher = new Watcher([specificationFile, watchDir], ignorePaths);
+        }
+        else {
+            thisArg.log(`[WATCHER] Watching for changes in the template directory ${(0, picocolors_1.magenta)(watchDir)}`);
+            watcher = new Watcher(watchDir, ignorePaths);
+        }
+        if (!(yield thisArg.isLocalTemplate(path_1.default.resolve(generatorClass.DEFAULT_TEMPLATES_DIR, templateName)))) {
+            thisArg.warn(`WARNING: ${template} is a remote template. Changes may be lost on subsequent installations.`);
+        }
+        yield watcher.watch(watchHandler, (paths) => {
+            thisArg.error(`[WATCHER] Could not find the file path ${paths}, are you sure it still exists? If it has been deleted or moved please rerun the generator.`, {
+                exit: 1,
+            });
+        });
+    });
+}
+function watcherHandler(thisArg, asyncapi, template, output, options, genOption, interactive) {
+    return (changedFiles) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        console.clear();
+        console.log('[WATCHER] Change detected');
+        for (const [, value] of Object.entries(changedFiles)) {
+            let eventText;
+            switch (value.eventType) {
+                case 'changed':
+                    eventText = (0, picocolors_1.green)(value.eventType);
+                    break;
+                case 'removed':
+                    eventText = (0, picocolors_1.red)(value.eventType);
+                    break;
+                case 'renamed':
+                    eventText = (0, picocolors_1.yellow)(value.eventType);
+                    break;
+                default:
+                    eventText = (0, picocolors_1.yellow)(value.eventType);
+            }
+            thisArg.log(`\t${(0, picocolors_1.magenta)(value.path)} was ${eventText}`);
+        }
+        try {
+            yield thisArg.generate(asyncapi, template, output, options, genOption, interactive);
+        }
+        catch (err) {
+            throw new generator_error_1.GeneratorError(err);
+        }
+    });
+}

package/lib/utils/logger.d.ts

@@ -0,0 +1,6 @@
+import winston from 'winston';
+declare const logger: winston.Logger;
+declare const stream: {
+    write: (message: string) => void;
+};
+export { logger, stream };

package/lib/utils/logger.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stream = exports.logger = void 0;
+const tslib_1 = require("tslib");
+const config_1 = tslib_1.__importDefault(require("config"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const winston_1 = tslib_1.__importDefault(require("winston"));
+const logDir = path_1.default.join(__dirname, config_1.default.has('log.dir') ? config_1.default.get('log.dir') : 'logs');
+if (!fs_1.default.existsSync(logDir)) {
+    fs_1.default.mkdirSync(logDir);
+}
+/*
+ * Log Level
+ * error: 0, warn: 1, info: 2, http: 3, verbose: 4, debug: 5, silly: 6
+ */
+const logger = winston_1.default.createLogger({
+    format: winston_1.default.format.combine(winston_1.default.format.timestamp({
+        format: 'YYYY-MM-DD HH:mm:ss',
+    }), 
+    // Define log format
+    winston_1.default.format.printf(({ timestamp, level, message }) => `${timestamp} ${level}: ${message}`)),
+});
+exports.logger = logger;
+logger.add(new winston_1.default.transports.Console({
+    format: winston_1.default.format.combine(winston_1.default.format.splat(), winston_1.default.format.colorize()),
+}));
+const stream = {
+    write: (message) => {
+        logger.info(message.substring(0, message.lastIndexOf('\n')));
+    },
+};
+exports.stream = stream;

package/lib/utils/retrieve-language.d.ts

@@ -0,0 +1 @@
+export declare function retrieveLangauge(content: string): 'json' | 'yaml';

package/lib/utils/retrieve-language.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrieveLangauge = retrieveLangauge;
+function retrieveLangauge(content) {
+    if (content.trim()[0] === '{') {
+        return 'json';
+    }
+    return 'yaml';
+}

package/lib/utils/scoreCalculator.d.ts

@@ -0,0 +1,2 @@
+import { AsyncAPIDocumentInterface } from '@asyncapi/parser/cjs/models';
+export declare function calculateScore(document: AsyncAPIDocumentInterface | undefined): Promise<number>;

package/lib/utils/scoreCalculator.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateScore = calculateScore;
+const tslib_1 = require("tslib");
+function calculateScore(document) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        let scoreEvaluate = 0;
+        if (document === null || document === void 0 ? void 0 : document.info().hasDescription()) {
+            scoreEvaluate += 0.15;
+        }
+        if (document === null || document === void 0 ? void 0 : document.info().hasLicense()) {
+            scoreEvaluate += 0.25;
+        }
+        if (!(document === null || document === void 0 ? void 0 : document.servers().isEmpty())) {
+            scoreEvaluate += 0.25;
+        }
+        if (!(document === null || document === void 0 ? void 0 : document.channels().isEmpty())) {
+            scoreEvaluate += 0.35;
+        }
+        return (scoreEvaluate / 1) * 100;
+    });
+}

package/lib/utils/temp-dir.d.ts

@@ -0,0 +1,2 @@
+export declare function createTempDirectory(): Promise<string>;
+export declare function removeTempDirectory(tmpDir: string): Promise<void>;

package/lib/utils/temp-dir.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTempDirectory = createTempDirectory;
+exports.removeTempDirectory = removeTempDirectory;
+const tslib_1 = require("tslib");
+const os_1 = tslib_1.__importDefault(require("os"));
+const fs_1 = tslib_1.__importStar(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const uuid_1 = require("uuid");
+const logger_1 = require("./logger");
+function createTempDirectory() {
+    return fs_1.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), (0, uuid_1.v4)()));
+}
+function removeTempDirectory(tmpDir) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            // eslint-disable-next-line no-unused-expressions
+            tmpDir &&
+                fs_1.default.existsSync(tmpDir) &&
+                (yield fs_1.promises.rm(tmpDir, { recursive: true }));
+        }
+        catch (e) {
+            logger_1.logger.error(`An error has occurred while removing the temp folder at ${tmpDir}. Please remove it manually. Error: ${e}`);
+        }
+    });
+}