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

package/lib/domains/models/Preview.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PORT = void 0;
+exports.startPreview = startPreview;
+const tslib_1 = require("tslib");
+const specification_file_1 = require("../../errors/specification-file");
+const fs_1 = require("fs");
+const bundler_1 = tslib_1.__importDefault(require("@asyncapi/bundler"));
+const http_1 = require("http");
+const ws_1 = require("ws");
+const chokidar_1 = tslib_1.__importDefault(require("chokidar"));
+const open_1 = tslib_1.__importDefault(require("open"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
+const picocolors_1 = require("picocolors");
+const package_json_1 = require("@asyncapi/studio/package.json");
+const sockets = [];
+const messageQueue = [];
+const filePathsToWatch = new Set();
+const defaultErrorMessage = 'error occured while bundling files. use --detailedLog or -l flag to get more details.';
+let bundleError = true;
+exports.DEFAULT_PORT = 0;
+function isValidFilePath(filePath) {
+    return (0, fs_1.existsSync)(filePath);
+}
+function resolveStudioNextInstance(studioPath) {
+    var _a;
+    const resolvedNextPath = require.resolve('next', { paths: [studioPath] });
+    // eslint-disable-next-line @typescript-eslint/no-var-requires,security/detect-non-literal-require
+    const nextModule = require(resolvedNextPath);
+    return (_a = nextModule.default) !== null && _a !== void 0 ? _a : nextModule;
+}
+// eslint-disable-next-line sonarjs/cognitive-complexity
+function startPreview(filePath, base, baseDirectory, xOrigin, suppressLogs, port = exports.DEFAULT_PORT, noBrowser) {
+    if (filePath && !isValidFilePath(filePath)) {
+        throw new specification_file_1.SpecificationFileNotFound(filePath);
+    }
+    const baseDir = path_1.default.dirname(path_1.default.resolve(filePath));
+    (0, bundler_1.default)(filePath).then((doc) => {
+        if (doc) {
+            bundleError = false;
+        }
+    }).catch((err) => {
+        if (suppressLogs) {
+            console.log(defaultErrorMessage);
+        }
+        else {
+            console.log(err);
+        }
+    });
+    const studioPath = path_1.default.dirname(require.resolve('@asyncapi/studio/package.json'));
+    const nextInstance = resolveStudioNextInstance(studioPath);
+    const app = nextInstance({
+        dev: false,
+        dir: studioPath,
+        conf: {
+            distDir: 'build',
+        },
+    });
+    const handle = app.getRequestHandler();
+    const wsServer = new ws_1.WebSocketServer({ noServer: true });
+    wsServer.on('connection', (socket) => {
+        sockets.push(socket);
+        sendQueuedMessages();
+    });
+    wsServer.on('close', (socket) => {
+        sockets.splice(sockets.findIndex(s => s === socket));
+    });
+    app.prepare().then(() => {
+        if (filePath && !bundleError) {
+            messageQueue.push(JSON.stringify({
+                type: 'preview:connected',
+                code: 'Preview server connected'
+            }));
+            sendQueuedMessages();
+            findPathsToWatchFromSchemaRef(filePath, baseDir);
+            filePathsToWatch.add(path_1.default.resolve(baseDir, filePath));
+            chokidar_1.default.watch([...filePathsToWatch]).on('all', (event) => {
+                switch (event) {
+                    case 'add':
+                        (0, bundler_1.default)([filePath], {
+                            base,
+                            baseDir: baseDirectory,
+                            xOrigin,
+                        }).then((intitalDocument) => {
+                            messageQueue.push(JSON.stringify({
+                                type: 'preview:file:added',
+                                code: (path_1.default.extname(filePath) === '.yaml' || path_1.default.extname(filePath) === '.yml') ?
+                                    intitalDocument.yml() : intitalDocument.string()
+                            }));
+                            sendQueuedMessages();
+                        }).catch((e) => {
+                            if (suppressLogs) {
+                                console.log(defaultErrorMessage);
+                            }
+                            else {
+                                console.log(e);
+                            }
+                        });
+                        break;
+                    case 'change':
+                        (0, bundler_1.default)([filePath], {
+                            base,
+                            baseDir: baseDirectory,
+                            xOrigin,
+                        }).then((modifiedDocument) => {
+                            messageQueue.push(JSON.stringify({
+                                type: 'preview:file:changed',
+                                code: (path_1.default.extname(filePath) === '.yaml' || path_1.default.extname(filePath) === '.yml') ?
+                                    modifiedDocument.yml() : modifiedDocument.string()
+                            }));
+                            sendQueuedMessages();
+                        }).catch((error) => {
+                            if (suppressLogs) {
+                                console.log(defaultErrorMessage);
+                            }
+                            else {
+                                console.log(error);
+                            }
+                        });
+                        break;
+                    case 'unlink':
+                        messageQueue.push(JSON.stringify({
+                            type: 'preview:file:deleted',
+                            filePath,
+                        }));
+                        sendQueuedMessages();
+                        break;
+                }
+            });
+        }
+        const server = (0, http_1.createServer)((req, res) => {
+            if (req.url === '/close') {
+                res.writeHead(200, { 'Content-Type': 'text/plain' });
+                res.end('Shutting down server');
+                for (const socket of wsServer.clients) {
+                    socket.close();
+                }
+                // Close the server
+                server.close(() => {
+                    // eslint-disable-next-line no-process-exit
+                    process.exit(0);
+                });
+                return;
+            }
+            handle(req, res);
+        });
+        server.on('upgrade', (request, socket, head) => {
+            if (request.url === '/preview-server' && request.headers['origin'] === `http://localhost:${port}`) {
+                console.log('🔗 WebSocket connection established for the preview.');
+                wsServer.handleUpgrade(request, socket, head, (sock) => {
+                    wsServer.emit('connection', sock, request);
+                });
+            }
+            else {
+                console.log('🔗 WebSocket connection not established.');
+                socket.destroy();
+            }
+        });
+        if (!bundleError) {
+            server.listen(port, () => {
+                const previewServerAddr = server.address();
+                const currentPort = (previewServerAddr && typeof previewServerAddr === 'object' && 'port' in previewServerAddr) ? previewServerAddr.port : port;
+                const url = `http://localhost:${currentPort}?previewServer=${currentPort}&studio-version=${package_json_1.version}`;
+                console.log(`🎉 Connected to Preview Server running at ${(0, picocolors_1.blueBright)(url)}.`);
+                console.log(`🌐 Open this URL in your web browser: ${(0, picocolors_1.blueBright)(url)}`);
+                console.log(`🛑 If needed, press ${(0, picocolors_1.redBright)('Ctrl + C')} to stop the server.`);
+                if (filePath) {
+                    for (const entry of filePathsToWatch) {
+                        console.log(`👁️ Watching changes on file ${(0, picocolors_1.blueBright)(entry)}`);
+                    }
+                }
+                else {
+                    console.warn('Warning: No file was provided, and we couldn\'t find a default file (like "asyncapi.yaml" or "asyncapi.json") in the current folder. Starting Studio with a blank workspace.');
+                }
+                if (!bundleError && !noBrowser) {
+                    (0, open_1.default)(url);
+                }
+            }).on('error', (error) => {
+                if (error.message.includes('EADDRINUSE')) {
+                    console.log(error);
+                    console.error((0, picocolors_1.redBright)(`Error: Port ${port} is already in use.`));
+                    // eslint-disable-next-line no-process-exit
+                    process.exit(1);
+                }
+                else {
+                    console.error(`Failed to start server on port ${port}:`, 'cause', error.cause, '\n', 'name', error.name, '\n', 'stack', error.stack, '\n', 'message', error.message);
+                }
+            });
+        }
+    });
+}
+function sendQueuedMessages() {
+    while (messageQueue.length && sockets.length) {
+        const nextMessage = messageQueue.shift();
+        for (const socket of sockets) {
+            socket.send(nextMessage);
+        }
+    }
+}
+function isLocalRefAPath(key, value) {
+    return (typeof value === 'string' && key === '$ref' &&
+        (value.startsWith('.') || value.startsWith('./') ||
+            value.startsWith('../') || !value.startsWith('#')));
+}
+function findPathsToWatchFromSchemaRef(filePath, baseDir) {
+    if (filePath && !isValidFilePath(filePath)) {
+        throw new specification_file_1.SpecificationFileNotFound(filePath);
+    }
+    const document = js_yaml_1.default.load((0, fs_1.readFileSync)(filePath, 'utf-8'));
+    const stack = [document];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === null || typeof current !== 'object') {
+            continue;
+        }
+        for (const [key, value] of Object.entries(current)) {
+            if (isLocalRefAPath(key, value)) {
+                const absolutePath = path_1.default.resolve(baseDir, value);
+                filePathsToWatch.add(absolutePath);
+            }
+            if (value !== null && typeof value === 'object') {
+                stack.push(value);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+import { fileFormat } from '../../apps/cli/internal/flags/format.flags';
+export declare class Specification {
+    private readonly spec;
+    private readonly filePath?;
+    private readonly fileURL?;
+    private readonly kind?;
+    constructor(spec: string, options?: {
+        filepath?: string;
+        fileURL?: string;
+    });
+    isAsyncAPI3(): boolean;
+    toJson(): Record<string, any>;
+    text(): string;
+    getFilePath(): string | undefined;
+    getFileURL(): string | undefined;
+    getKind(): "url" | "file" | undefined;
+    getSource(): string | undefined;
+    toSourceString(): string;
+    static fromFile(filepath: string): Promise<Specification>;
+    static fromURL(URLpath: string): Promise<Specification>;
+}
+export default class SpecificationFile {
+    private readonly pathToFile;
+    constructor(filePath: string);
+    getPath(): string;
+    read(): Promise<string>;
+}
+interface LoadType {
+    file?: boolean;
+    url?: boolean;
+    context?: boolean;
+}
+export declare function load(filePathOrContextName?: string, loadType?: LoadType): Promise<Specification>;
+export declare function nameType(name: string): Promise<string>;
+export declare function isURL(urlpath: string): Promise<boolean>;
+export declare function fileExists(name: string): Promise<boolean>;
+export declare function retrieveFileFormat(content: string): fileFormat | undefined;
+export declare function convertToYaml(spec: string): string | undefined;
+export declare function convertToJSON(spec: string): string | undefined;
+export {};

package/lib/domains/models/SpecificationFile.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Specification = void 0;
+exports.load = load;
+exports.nameType = nameType;
+exports.isURL = isURL;
+exports.fileExists = fileExists;
+exports.retrieveFileFormat = retrieveFileFormat;
+exports.convertToYaml = convertToYaml;
+exports.convertToJSON = convertToJSON;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const path_1 = tslib_1.__importDefault(require("path"));
+const url_1 = require("url");
+const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
+const Context_1 = require("./Context");
+const specification_file_1 = require("../../errors/specification-file");
+const context_error_1 = require("../../errors/context-error");
+const https_proxy_agent_1 = require("https-proxy-agent");
+const { readFile, lstat } = fs_1.promises;
+const allowedFileNames = [
+    'asyncapi.json',
+    'asyncapi.yml',
+    'asyncapi.yaml',
+];
+const TYPE_CONTEXT_NAME = 'context-name';
+const TYPE_FILE_PATH = 'file-path';
+const TYPE_URL = 'url-path';
+class Specification {
+    constructor(spec, options = {}) {
+        this.spec = spec;
+        if (options.filepath) {
+            this.filePath = options.filepath;
+            this.kind = 'file';
+        }
+        else if (options.fileURL) {
+            this.fileURL = options.fileURL;
+            this.kind = 'url';
+        }
+    }
+    isAsyncAPI3() {
+        const jsObj = this.toJson();
+        return jsObj.asyncapi === '3.0.0';
+    }
+    toJson() {
+        try {
+            return js_yaml_1.default.load(this.spec, { json: true });
+        }
+        catch (e) {
+            return JSON.parse(this.spec);
+        }
+    }
+    text() {
+        return this.spec;
+    }
+    getFilePath() {
+        return this.filePath;
+    }
+    getFileURL() {
+        return this.fileURL;
+    }
+    getKind() {
+        return this.kind;
+    }
+    getSource() {
+        var _a;
+        return (_a = this.getFilePath()) !== null && _a !== void 0 ? _a : this.getFileURL();
+    }
+    toSourceString() {
+        if (this.kind === 'file') {
+            return `File ${this.filePath}`;
+        }
+        return `URL ${this.fileURL}`;
+    }
+    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;
+            const delimiter = '+';
+            let targetUrl = URLpath;
+            let proxyUrl = '';
+            // Check if URLpath contains a proxy URL
+            if (URLpath.includes(delimiter)) {
+                [targetUrl, proxyUrl] = URLpath.split(delimiter);
+            }
+            try {
+                // Validate the target URL
+                new url_1.URL(targetUrl);
+                const fetchOptions = { method: 'GET' };
+                // If proxy URL is provided, create a proxy agent
+                if (proxyUrl) {
+                    try {
+                        new url_1.URL(proxyUrl);
+                        const proxyAgent = new https_proxy_agent_1.HttpsProxyAgent(proxyUrl);
+                        fetchOptions.agent = proxyAgent;
+                        response = yield fetch(targetUrl, fetchOptions);
+                    }
+                    catch (err) {
+                        throw new Error('Proxy Connection Error: Unable to establish a connection to the proxy check hostName or PortNumber');
+                    }
+                }
+                else {
+                    response = yield fetch(targetUrl);
+                    if (!response.ok) {
+                        throw new specification_file_1.ErrorLoadingSpec('url', targetUrl);
+                    }
+                }
+            }
+            catch (error) {
+                console.log(error);
+                throw new specification_file_1.ErrorLoadingSpec('url', targetUrl);
+            }
+            return new Specification((yield (response === null || response === void 0 ? void 0 : response.text())), {
+                fileURL: targetUrl,
+            });
+        });
+    }
+}
+exports.Specification = Specification;
+class SpecificationFile {
+    constructor(filePath) {
+        this.pathToFile = filePath;
+    }
+    getPath() {
+        return this.pathToFile;
+    }
+    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 */
+function load(filePathOrContextName, loadType) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        // NOSONAR
+        try {
+            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);
+            }
+            return yield loadFromContext();
+        }
+        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;
+        }
+    });
+}
+function nameType(name) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (name.startsWith('.')) {
+            return TYPE_FILE_PATH;
+        }
+        try {
+            if (yield fileExists(name)) {
+                return TYPE_FILE_PATH;
+            }
+            return TYPE_CONTEXT_NAME;
+        }
+        catch (e) {
+            if (yield isURL(name)) {
+                return TYPE_URL;
+            }
+            return TYPE_CONTEXT_NAME;
+        }
+    });
+}
+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;
+        }
+    });
+}
+function fileExists(name) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            if ((yield lstat(name)).isFile()) {
+                return true;
+            }
+            const extension = name.split('.')[1];
+            const allowedExtenstion = ['yml', 'yaml', 'json'];
+            if (!allowedExtenstion.includes(extension)) {
+                throw new specification_file_1.ErrorLoadingSpec('invalid file', name);
+            }
+            throw new specification_file_1.ErrorLoadingSpec('file', name);
+        }
+        catch (e) {
+            throw new specification_file_1.ErrorLoadingSpec('file', name);
+        }
+    });
+}
+function loadFromContext(contextName) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            const context = yield (0, Context_1.loadContext)(contextName);
+            return Specification.fromFile(context);
+        }
+        catch (error) {
+            if (error instanceof context_error_1.MissingContextFileError) {
+                throw new specification_file_1.ErrorLoadingSpec();
+            }
+            throw error;
+        }
+    });
+}
+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);
+    });
+}
+function retrieveFileFormat(content) {
+    try {
+        if (content.trimStart()[0] === '{') {
+            JSON.parse(content);
+            return 'json';
+        }
+        // below yaml.load is not a definitive way to determine if a file is yaml or not.
+        // it is able to load .txt text files also.
+        js_yaml_1.default.load(content);
+        return 'yaml';
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function convertToYaml(spec) {
+    try {
+        // JS object -> YAML string
+        const jsonContent = js_yaml_1.default.load(spec);
+        return js_yaml_1.default.dump(jsonContent);
+    }
+    catch (err) {
+        console.error(err);
+    }
+}
+function convertToJSON(spec) {
+    try {
+        // JSON or YAML String -> JS object
+        const jsonContent = js_yaml_1.default.load(spec);
+        // JS Object -> pretty JSON string
+        return JSON.stringify(jsonContent, null, 2);
+    }
+    catch (err) {
+        console.error(err);
+    }
+}

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

@@ -0,0 +1,2 @@
+export declare const DEFAULT_PORT = 0;
+export declare function start(filePath: string, port?: number, noBrowser?: boolean): void;