@asyncapi/cli 0.25.1 → 0.25.3

package/lib/commands/start/studio.js

@@ -6,11 +6,13 @@ const base_1 = tslib_1.__importDefault(require("../../base"));
 const Studio_1 = require("../../models/Studio");
 const SpecificationFile_1 = require("../../models/SpecificationFile");
 class StartStudio extends base_1.default {
-    async run() {
-        const { flags } = await this.parse(StartStudio);
-        const filePath = flags.file || (await (0, SpecificationFile_1.load)()).getFilePath();
-        const port = flags.port;
-        (0, Studio_1.start)(filePath, port);
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { flags } = yield this.parse(StartStudio);
+            const filePath = flags.file || (yield (0, SpecificationFile_1.load)()).getFilePath();
+            const port = flags.port;
+            (0, Studio_1.start)(filePath, port);
+        });
     }
 }
 exports.default = StartStudio;

package/lib/commands/validate.js

@@ -9,30 +9,32 @@ const SpecificationFile_1 = require("../models/SpecificationFile");
 const globals_1 = require("../globals");
 const flags_1 = require("../flags");
 class Validate extends base_1.default {
-    async run() {
-        const { args, flags } = await this.parse(Validate); //NOSONAR
-        const filePath = args['spec-file'];
-        const watchMode = flags['watch'];
-        const specFile = await (0, SpecificationFile_1.load)(filePath);
-        if (watchMode) {
-            (0, globals_1.specWatcher)({ spec: specFile, handler: this, handlerName: 'validate' });
-        }
-        try {
-            if (specFile.getFilePath()) {
-                await parser.parse(specFile.text());
-                this.log(`File ${specFile.getFilePath()} successfully validated!`);
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { args, flags } = yield this.parse(Validate); //NOSONAR
+            const filePath = args['spec-file'];
+            const watchMode = flags['watch'];
+            const specFile = yield (0, SpecificationFile_1.load)(filePath);
+            if (watchMode) {
+                (0, globals_1.specWatcher)({ spec: specFile, handler: this, handlerName: 'validate' });
             }
-            else if (specFile.getFileURL()) {
-                await parser.parse(specFile.text());
-                this.log(`URL ${specFile.getFileURL()} successfully validated`);
+            try {
+                if (specFile.getFilePath()) {
+                    yield parser.parse(specFile.text());
+                    this.log(`File ${specFile.getFilePath()} successfully validated!`);
+                }
+                else if (specFile.getFileURL()) {
+                    yield parser.parse(specFile.text());
+                    this.log(`URL ${specFile.getFileURL()} successfully validated`);
+                }
             }
-        }
-        catch (error) {
-            throw new validation_error_1.ValidationError({
-                type: 'parser-error',
-                err: error
-            });
-        }
+            catch (error) {
+                throw new validation_error_1.ValidationError({
+                    type: 'parser-error',
+                    err: error
+                });
+            }
+        });
     }
 }
 exports.default = Validate;

package/lib/flags.d.ts

@@ -1 +1 @@
-export declare const watchFlag: (description?: string) => import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+export declare const watchFlag: (description?: string | undefined) => import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;

package/lib/globals.js

@@ -27,15 +27,15 @@ const specWatcher = (params) => {
         WATCH_MESSAGES.logOnStart(filePath);
         chokidar_1.default
             .watch(filePath, CHOKIDAR_CONFIG)
-            .on('change', async () => {
+            .on('change', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             WATCH_MESSAGES.logOnChange(params.handlerName);
             try {
-                await params.handler.run();
+                yield params.handler.run();
             }
             catch (err) {
-                await params.handler.catch(err);
+                yield params.handler.catch(err);
             }
-        });
+        }));
         CHOKIDAR_INSTANCE_STORE.set(params.label || '_default', true);
     }
     catch (error) {

package/lib/models/Context.js

@@ -9,94 +9,108 @@ const context_error_1 = require("../errors/context-error");
 const { readFile, writeFile } = fs_1.promises;
 const CONTEXT_FILENAME = process.env.CONTEXT_FILENAME || '.asyncapi';
 exports.DEFAULT_CONTEXT_FILE_PATH = path.resolve(process.env.CONTEXT_FILE_PATH || os.homedir(), CONTEXT_FILENAME);
-async function loadContext(contextName) {
-    const fileContent = await loadContextFile();
-    if (contextName) {
-        const context = fileContent.store[String(contextName)];
-        if (!context) {
-            throw new context_error_1.ContextNotFound(contextName);
+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.ContextNotFound(contextName);
+            }
+            return context;
         }
-        return context;
-    }
-    else if (fileContent.current) {
-        const context = fileContent.store[fileContent.current];
-        if (!context) {
-            throw new context_error_1.ContextNotFound(fileContent.current);
+        else if (fileContent.current) {
+            const context = fileContent.store[fileContent.current];
+            if (!context) {
+                throw new context_error_1.ContextNotFound(fileContent.current);
+            }
+            return context;
         }
-        return context;
-    }
-    throw new context_error_1.MissingCurrentContextError();
+        throw new context_error_1.MissingCurrentContextError();
+    });
 }
 exports.loadContext = loadContext;
-async function addContext(contextName, pathToFile) {
-    let fileContent;
-    try {
-        fileContent = await loadContextFile();
-    }
-    catch (err) {
-        if (err instanceof context_error_1.MissingContextFileError) {
-            fileContent = {
-                store: {
-                    [contextName]: pathToFile,
-                }
-            };
+function addContext(contextName, pathToFile) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        let fileContent;
+        try {
+            fileContent = yield loadContextFile();
         }
-        else {
-            throw err;
+        catch (err) {
+            if (err instanceof context_error_1.MissingContextFileError) {
+                fileContent = {
+                    store: {
+                        [contextName]: pathToFile,
+                    }
+                };
+            }
+            else {
+                throw err;
+            }
         }
-    }
-    fileContent.store[String(contextName)] = pathToFile;
-    await saveContextFile(fileContent);
+        fileContent.store[String(contextName)] = pathToFile;
+        yield saveContextFile(fileContent);
+    });
 }
 exports.addContext = addContext;
-async function removeContext(contextName) {
-    const fileContent = await loadContextFile();
-    if (!fileContent.store[String(contextName)]) {
-        throw new context_error_1.ContextNotFound(contextName);
-    }
-    if (fileContent.current === contextName) {
-        delete fileContent.current;
-    }
-    delete fileContent.store[String(contextName)];
-    await saveContextFile(fileContent);
+function removeContext(contextName) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const fileContent = yield loadContextFile();
+        if (!fileContent.store[String(contextName)]) {
+            throw new context_error_1.ContextNotFound(contextName);
+        }
+        if (fileContent.current === contextName) {
+            delete fileContent.current;
+        }
+        delete fileContent.store[String(contextName)];
+        yield saveContextFile(fileContent);
+    });
 }
 exports.removeContext = removeContext;
-async function getCurrentContext() {
-    const fileContent = await loadContextFile();
-    const context = await loadContext();
-    return {
-        current: fileContent.current,
-        context,
-    };
+function getCurrentContext() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const fileContent = yield loadContextFile();
+        const context = yield loadContext();
+        return {
+            current: fileContent.current,
+            context,
+        };
+    });
 }
 exports.getCurrentContext = getCurrentContext;
-async function setCurrentContext(contextName) {
-    const fileContent = await loadContextFile();
-    if (!fileContent.store[String(contextName)]) {
-        throw new context_error_1.ContextNotFound(contextName);
-    }
-    fileContent.current = contextName;
-    await saveContextFile(fileContent);
+function setCurrentContext(contextName) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const fileContent = yield loadContextFile();
+        if (!fileContent.store[String(contextName)]) {
+            throw new context_error_1.ContextNotFound(contextName);
+        }
+        fileContent.current = contextName;
+        yield saveContextFile(fileContent);
+    });
 }
 exports.setCurrentContext = setCurrentContext;
-async function loadContextFile() {
-    try {
-        return JSON.parse(await readFile(exports.DEFAULT_CONTEXT_FILE_PATH, { encoding: 'utf8' }));
-    }
-    catch (e) {
-        throw new context_error_1.MissingContextFileError();
-    }
+function loadContextFile() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            return JSON.parse(yield readFile(exports.DEFAULT_CONTEXT_FILE_PATH, { encoding: 'utf8' }));
+        }
+        catch (e) {
+            throw new context_error_1.MissingContextFileError();
+        }
+    });
 }
 exports.loadContextFile = loadContextFile;
-async function saveContextFile(fileContent) {
-    try {
-        writeFile(exports.DEFAULT_CONTEXT_FILE_PATH, JSON.stringify({
-            current: fileContent.current,
-            store: fileContent.store
-        }), { encoding: 'utf8' });
-        return fileContent;
-    }
-    catch (error) {
-        return;
-    }
+function saveContextFile(fileContent) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            writeFile(exports.DEFAULT_CONTEXT_FILE_PATH, JSON.stringify({
+                current: fileContent.current,
+                store: fileContent.store
+            }), { encoding: 'utf8' });
+            return fileContent;
+        }
+        catch (error) {
+            return;
+        }
+    });
 }

package/lib/models/SpecificationFile.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fileExists = exports.isURL = exports.nameType = exports.load = exports.Specification = void 0;
 const tslib_1 = require("tslib");
 const fs_1 = require("fs");
-const path = tslib_1.__importStar(require("path"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const url_1 = require("url");
 const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
 const Context_1 = require("./Context");
 const specification_file_1 = require("../errors/specification-file");
@@ -32,28 +33,32 @@ class Specification {
     getFileURL() {
         return this.fileURL;
     }
-    static async fromFile(filepath) {
-        let spec;
-        try {
-            spec = await readFile(filepath, { encoding: 'utf8' });
-        }
-        catch (error) {
-            throw new specification_file_1.ErrorLoadingSpec('file', filepath);
-        }
-        return new Specification(spec, { filepath });
-    }
-    static async fromURL(URLpath) {
-        let response;
-        try {
-            response = await (0, node_fetch_1.default)(URLpath, { method: 'GET' });
-            if (!response.ok) {
+    static fromFile(filepath) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let spec;
+            try {
+                spec = yield readFile(filepath, { encoding: 'utf8' });
+            }
+            catch (error) {
+                throw new specification_file_1.ErrorLoadingSpec('file', filepath);
+            }
+            return new Specification(spec, { filepath });
+        });
+    }
+    static fromURL(URLpath) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let response;
+            try {
+                response = yield (0, node_fetch_1.default)(URLpath, { method: 'GET' });
+                if (!response.ok) {
+                    throw new specification_file_1.ErrorLoadingSpec('url', URLpath);
+                }
+            }
+            catch (error) {
                 throw new specification_file_1.ErrorLoadingSpec('url', URLpath);
             }
-        }
-        catch (error) {
-            throw new specification_file_1.ErrorLoadingSpec('url', URLpath);
-        }
-        return new Specification(await (response === null || response === void 0 ? void 0 : response.text()), { fileURL: URLpath });
+            return new Specification(yield (response === null || response === void 0 ? void 0 : response.text()), { fileURL: URLpath });
+        });
     }
 }
 exports.Specification = Specification;
@@ -64,109 +69,123 @@ class SpecificationFile {
     getPath() {
         return this.pathToFile;
     }
-    async read() {
-        return readFile(this.pathToFile, { encoding: 'utf8' });
+    read() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return readFile(this.pathToFile, { encoding: 'utf8' });
+        });
     }
 }
 exports.default = SpecificationFile;
 /* eslint-disable sonarjs/cognitive-complexity */
-async function load(filePathOrContextName, loadType) {
-    if (filePathOrContextName) {
-        if (loadType === null || loadType === void 0 ? void 0 : loadType.file) {
+function load(filePathOrContextName, loadType) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (filePathOrContextName) {
+            if (loadType === null || loadType === void 0 ? void 0 : loadType.file) {
+                return Specification.fromFile(filePathOrContextName);
+            }
+            if (loadType === null || loadType === void 0 ? void 0 : loadType.context) {
+                return loadFromContext(filePathOrContextName);
+            }
+            if (loadType === null || loadType === void 0 ? void 0 : loadType.url) {
+                return Specification.fromURL(filePathOrContextName);
+            }
+            const type = yield nameType(filePathOrContextName);
+            if (type === TYPE_CONTEXT_NAME) {
+                return loadFromContext(filePathOrContextName);
+            }
+            if (type === TYPE_URL) {
+                return Specification.fromURL(filePathOrContextName);
+            }
+            yield fileExists(filePathOrContextName);
             return Specification.fromFile(filePathOrContextName);
         }
-        if (loadType === null || loadType === void 0 ? void 0 : loadType.context) {
-            return loadFromContext(filePathOrContextName);
-        }
-        if (loadType === null || loadType === void 0 ? void 0 : loadType.url) {
-            return Specification.fromURL(filePathOrContextName);
-        }
-        const type = await nameType(filePathOrContextName);
-        if (type === TYPE_CONTEXT_NAME) {
-            return loadFromContext(filePathOrContextName);
-        }
-        if (type === TYPE_URL) {
-            return Specification.fromURL(filePathOrContextName);
-        }
-        await fileExists(filePathOrContextName);
-        return Specification.fromFile(filePathOrContextName);
-    }
-    try {
-        return await loadFromContext();
-    }
-    catch (e) {
-        const autoDetectedSpecFile = await detectSpecFile();
-        if (autoDetectedSpecFile) {
-            return Specification.fromFile(autoDetectedSpecFile);
+        try {
+            return yield loadFromContext();
         }
-        if (e instanceof context_error_1.MissingContextFileError) {
-            throw new specification_file_1.ErrorLoadingSpec();
+        catch (e) {
+            const autoDetectedSpecFile = yield detectSpecFile();
+            if (autoDetectedSpecFile) {
+                return Specification.fromFile(autoDetectedSpecFile);
+            }
+            if (e instanceof context_error_1.MissingContextFileError) {
+                throw new specification_file_1.ErrorLoadingSpec();
+            }
+            throw e;
         }
-        throw e;
-    }
+    });
 }
 exports.load = load;
-async function nameType(name) {
-    if (name.startsWith('.')) {
-        return TYPE_FILE_PATH;
-    }
-    try {
-        if (await fileExists(name)) {
+function nameType(name) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (name.startsWith('.')) {
             return TYPE_FILE_PATH;
         }
-        return TYPE_CONTEXT_NAME;
-    }
-    catch (e) {
-        if (await isURL(name)) {
-            return TYPE_URL;
+        try {
+            if (yield fileExists(name)) {
+                return TYPE_FILE_PATH;
+            }
+            return TYPE_CONTEXT_NAME;
         }
-        return TYPE_CONTEXT_NAME;
-    }
+        catch (e) {
+            if (yield isURL(name)) {
+                return TYPE_URL;
+            }
+            return TYPE_CONTEXT_NAME;
+        }
+    });
 }
 exports.nameType = nameType;
-async function isURL(urlpath) {
-    try {
-        const url = new URL(urlpath);
-        return url.protocol === 'http:' || url.protocol === 'https:';
-    }
-    catch (error) {
-        return false;
-    }
+function isURL(urlpath) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            const url = new url_1.URL(urlpath);
+            return url.protocol === 'http:' || url.protocol === 'https:';
+        }
+        catch (error) {
+            return false;
+        }
+    });
 }
 exports.isURL = isURL;
-async function fileExists(name) {
-    try {
-        if ((await lstat(name)).isFile()) {
-            return true;
+function fileExists(name) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            if ((yield lstat(name)).isFile()) {
+                return true;
+            }
+            throw new specification_file_1.ErrorLoadingSpec('file', name);
         }
-        throw new specification_file_1.ErrorLoadingSpec('file', name);
-    }
-    catch (e) {
-        throw new specification_file_1.ErrorLoadingSpec('file', name);
-    }
-}
-exports.fileExists = fileExists;
-async function loadFromContext(contextName) {
-    try {
-        const context = await (0, Context_1.loadContext)(contextName);
-        return Specification.fromFile(context);
-    }
-    catch (error) {
-        if (error instanceof context_error_1.MissingContextFileError) {
-            throw new specification_file_1.ErrorLoadingSpec();
+        catch (e) {
+            throw new specification_file_1.ErrorLoadingSpec('file', name);
         }
-        throw error;
-    }
+    });
 }
-async function detectSpecFile() {
-    const existingFileNames = await Promise.all(allowedFileNames.map(async (filename) => {
+exports.fileExists = fileExists;
+function loadFromContext(contextName) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
         try {
-            const exists = await fileExists(path.resolve(process.cwd(), filename));
-            return exists ? filename : undefined;
+            const context = yield (0, Context_1.loadContext)(contextName);
+            return Specification.fromFile(context);
         }
-        catch (e) {
-            // We did our best...
+        catch (error) {
+            if (error instanceof context_error_1.MissingContextFileError) {
+                throw new specification_file_1.ErrorLoadingSpec();
+            }
+            throw error;
         }
-    }));
-    return existingFileNames.find(filename => filename !== undefined);
+    });
+}
+function detectSpecFile() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const existingFileNames = yield Promise.all(allowedFileNames.map((filename) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const exists = yield fileExists(path_1.default.resolve(process.cwd(), filename));
+                return exists ? filename : undefined;
+            }
+            catch (e) {
+                // We did our best...
+            }
+        })));
+        return existingFileNames.find(filename => filename !== undefined);
+    });
 }

package/lib/utils/generator.js

@@ -7,9 +7,11 @@ 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);
-async function isLocalTemplate(templatePath) {
-    const stats = await lstat(templatePath);
-    return stats.isSymbolicLink();
+function isLocalTemplate(templatePath) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const stats = yield lstat(templatePath);
+        return stats.isSymbolicLink();
+    });
 }
 exports.isLocalTemplate = isLocalTemplate;
 class Watcher {
@@ -45,11 +47,13 @@ class Watcher {
      * This method initiate the watch for change in all files
      * @param {*} callback called when the file(s) change
      */
-    async watch(changeCallback, errorCallback) {
-        for (const index in this.paths) {
-            const path = this.paths[String(index)];
-            this.initiateWatchOnPath(path, changeCallback, errorCallback);
-        }
+    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.
@@ -68,11 +72,11 @@ class Watcher {
                 if (this.fsWait) {
                     return;
                 }
-                this.fsWait = setTimeout(async () => {
-                    await changeCallback(this.filesChanged);
+                this.fsWait = setTimeout(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    yield changeCallback(this.filesChanged);
                     this.filesChanged = {};
                     this.fsWait = false;
-                }, 500);
+                }), 500);
             }
         }
         catch (e) {