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

package/lib/domains/models/Studio.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PORT = void 0;
+exports.start = start;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const specification_file_1 = require("../../errors/specification-file");
+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 package_json_1 = require("@asyncapi/studio/package.json");
+const picocolors_1 = require("picocolors");
+const { readFile, writeFile } = fs_1.promises;
+const sockets = [];
+const messageQueue = [];
+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 start(filePath, port = exports.DEFAULT_PORT, noBrowser) {
+    if (filePath && !isValidFilePath(filePath)) {
+        throw new specification_file_1.SpecificationFileNotFound(filePath);
+    }
+    // Locate @asyncapi/studio package
+    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);
+        if (filePath) {
+            getFileContent(filePath).then((code) => {
+                messageQueue.push(JSON.stringify({
+                    type: 'file:loaded',
+                    code,
+                }));
+                sendQueuedMessages();
+            });
+        }
+        else {
+            messageQueue.push(JSON.stringify({
+                type: 'file:loaded',
+                code: '',
+            }));
+            sendQueuedMessages();
+        }
+        socket.on('message', (event) => {
+            try {
+                const json = JSON.parse(event);
+                if (filePath && json.type === 'file:update') {
+                    saveFileContent(filePath, json.code);
+                }
+                else {
+                    console.warn('Live Server: An unknown event has been received. See details:');
+                    console.log(json);
+                }
+            }
+            catch (e) {
+                console.error(`Live Server: An invalid event has been received. See details:\n${event}`);
+            }
+        });
+    });
+    wsServer.on('close', (socket) => {
+        sockets.splice(sockets.findIndex((s) => s === socket));
+    });
+    app.prepare().then(() => {
+        if (filePath) {
+            chokidar_1.default.watch(filePath).on('all', (event, path) => {
+                switch (event) {
+                    case 'add':
+                    case 'change':
+                        getFileContent(path).then((code) => {
+                            messageQueue.push(JSON.stringify({
+                                type: 'file:changed',
+                                code,
+                            }));
+                            sendQueuedMessages();
+                        });
+                        break;
+                    case 'unlink':
+                        messageQueue.push(JSON.stringify({
+                            type: 'file:deleted',
+                            filePath,
+                        }));
+                        sendQueuedMessages();
+                        break;
+                }
+            });
+        }
+        const server = (0, http_1.createServer)((req, res) => {
+            if (req.url === '/close') {
+                for (const socket of wsServer.clients) {
+                    socket.close();
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ message: 'Server is shutting down' }));
+                // 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 === '/live-server') {
+                console.log('🔗 WebSocket connection established.');
+                wsServer.handleUpgrade(request, socket, head, (sock) => {
+                    wsServer.emit('connection', sock, request);
+                });
+            }
+            else {
+                socket.destroy();
+            }
+        });
+        server.listen(port, () => {
+            const addr = server.address();
+            const listenPort = (addr && typeof addr === 'object' && 'port' in addr) ? addr.port : port;
+            const url = `http://localhost:${listenPort}?liveServer=${listenPort}&studio-version=${package_json_1.version}`;
+            console.log(`🎉 Connected to Live 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 process.`);
+            if (filePath) {
+                console.log(`👁️ Watching changes on file ${(0, picocolors_1.blueBright)(filePath)}`);
+            }
+            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 (!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(2);
+            }
+            else {
+                console.error(`Failed to start server on port ${port}`);
+            }
+        });
+    });
+}
+function sendQueuedMessages() {
+    while (messageQueue.length && sockets.length) {
+        const nextMessage = messageQueue.shift();
+        for (const socket of sockets) {
+            socket.send(nextMessage);
+        }
+    }
+}
+function getFileContent(filePath) {
+    return new Promise((resolve) => {
+        readFile(filePath, { encoding: 'utf8' })
+            .then((code) => {
+            resolve(code);
+        })
+            .catch(console.error);
+    });
+}
+function saveFileContent(filePath, fileContent) {
+    writeFile(filePath, fileContent, { encoding: 'utf8' }).catch(console.error);
+}

package/lib/domains/models/generate/ClientLanguages.d.ts

@@ -0,0 +1,12 @@
+export declare enum AvailableLanguage {
+    Dart = "dart",
+    Java = "java",
+    Javascript = "javascript",
+    Python = "python"
+}
+export declare const availableLanguages: readonly ["dart", "java", "javascript", "python"];
+export type AvailableLanguageType = typeof availableLanguages[number];
+/**
+ * Returns the first available language as the default option.
+ */
+export declare const getDefaultLanguage: () => AvailableLanguageType;

package/lib/domains/models/generate/ClientLanguages.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultLanguage = exports.availableLanguages = exports.AvailableLanguage = void 0;
+// Auto-generated. Do not edit manually.
+var AvailableLanguage;
+(function (AvailableLanguage) {
+    AvailableLanguage["Dart"] = "dart";
+    AvailableLanguage["Java"] = "java";
+    AvailableLanguage["Javascript"] = "javascript";
+    AvailableLanguage["Python"] = "python";
+})(AvailableLanguage || (exports.AvailableLanguage = AvailableLanguage = {}));
+exports.availableLanguages = ['dart', 'java', 'javascript', 'python'];
+/**
+ * Returns the first available language as the default option.
+ */
+const getDefaultLanguage = () => exports.availableLanguages[0];
+exports.getDefaultLanguage = getDefaultLanguage;

package/lib/domains/models/generate/Flags.d.ts

@@ -0,0 +1,9 @@
+export interface IMapBaseUrlToFlag {
+    url: string;
+    folder: string;
+}
+export interface ParsedFlags {
+    params: Record<string, string>;
+    disableHooks: Record<string, string>;
+    mapBaseUrlToFolder: IMapBaseUrlToFlag;
+}

package/lib/domains/models/generate/Flags.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/domains/services/archiver.service.d.ts

@@ -0,0 +1,17 @@
+import archiver, { Archiver } from 'archiver';
+import { Response } from 'express';
+/**
+ * Service wrapping the `archiver` module:
+    - easier zip creation
+    - adding proper `Content-Type` header
+    - easier adding an AsyncAPI document to the archive
+    - easier stream finalization
+ */
+export declare class ArchiverService {
+    createZip(res?: Response): archiver.Archiver;
+    appendDirectory(archive: Archiver, from: string, to: string): void;
+    appendAsyncAPIDocument(archive: Archiver, asyncapi: string, fileName?: string): void;
+    finalize(archive: Archiver): Promise<void>;
+    createTempDirectory(): Promise<string>;
+    removeTempDirectory(tmpDir: string): Promise<void>;
+}

package/lib/domains/services/archiver.service.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArchiverService = void 0;
+const tslib_1 = require("tslib");
+const archiver_1 = tslib_1.__importDefault(require("archiver"));
+const retrieve_language_1 = require("../../utils/retrieve-language");
+const temp_dir_1 = require("../../utils/temp-dir");
+/**
+ * Service wrapping the `archiver` module:
+    - easier zip creation
+    - adding proper `Content-Type` header
+    - easier adding an AsyncAPI document to the archive
+    - easier stream finalization
+ */
+class ArchiverService {
+    createZip(res) {
+        const zip = (0, archiver_1.default)('zip', { zlib: { level: 9 } });
+        if (res) {
+            zip.pipe(res);
+            res.attachment('asyncapi.zip');
+        }
+        return zip;
+    }
+    appendDirectory(archive, from, to) {
+        archive.directory(from, to);
+    }
+    appendAsyncAPIDocument(archive, asyncapi, fileName = 'asyncapi') {
+        asyncapi = JSON.stringify(asyncapi);
+        const language = (0, retrieve_language_1.retrieveLangauge)(asyncapi);
+        if (language === 'yaml') {
+            archive.append(asyncapi, { name: `${fileName}.yml` });
+        }
+        else {
+            archive.append(asyncapi, { name: `${fileName}.json` });
+        }
+    }
+    finalize(archive) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve) => {
+                // wait for end stream
+                archive.on('end', resolve);
+                archive.finalize();
+            });
+        });
+    }
+    createTempDirectory() {
+        return (0, temp_dir_1.createTempDirectory)();
+    }
+    removeTempDirectory(tmpDir) {
+        return (0, temp_dir_1.removeTempDirectory)(tmpDir);
+    }
+}
+exports.ArchiverService = ArchiverService;

package/lib/domains/services/base.service.d.ts

@@ -0,0 +1,6 @@
+import { ServiceResult } from '../../interfaces';
+export declare abstract class BaseService {
+    protected createSuccessResult<T>(data: T): ServiceResult<T>;
+    protected createErrorResult(error: string, diagnostics?: any[]): ServiceResult;
+    protected handleServiceError(error: any): Promise<ServiceResult>;
+}

package/lib/domains/services/base.service.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseService = void 0;
+const tslib_1 = require("tslib");
+class BaseService {
+    createSuccessResult(data) {
+        return {
+            success: true,
+            data,
+        };
+    }
+    createErrorResult(error, diagnostics) {
+        return {
+            success: false,
+            error,
+            diagnostics,
+        };
+    }
+    handleServiceError(error) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return this.createErrorResult(errorMessage);
+        });
+    }
+}
+exports.BaseService = BaseService;

package/lib/domains/services/config.service.d.ts

@@ -0,0 +1,42 @@
+export interface AuthEntry {
+    pattern: string;
+    token: string;
+    authType?: string;
+    headers?: Record<string, string>;
+}
+export interface AuthResult {
+    token: string;
+    authType: string;
+    headers: Record<string, string>;
+}
+interface Config {
+    auth?: AuthEntry[];
+}
+export declare class ConfigService {
+    /**
+     * Load config file (~/.asyncapi/config.json)
+     */
+    static loadConfig(): Promise<Config>;
+    /**
+     * Save config back to file
+     */
+    static saveConfig(config: Config): Promise<void>;
+    /**
+     * Add a new auth entry
+     */
+    static addAuthEntry(entry: AuthEntry): Promise<void>;
+    /**
+     * Reads auth config from ~/.asyncapi/config.json and
+     * returns auth info matching the given URL, or null if no match.
+     *
+     * @param url - URL to match against auth patterns
+     * @returns Auth info or null if no match found
+     */
+    static getAuthForUrl(url: string): Promise<AuthResult | null>;
+    /**
+     * Convert wildcard pattern (*, **) to RegExp matching start of string
+     * @param pattern - wildcard pattern
+     */
+    private static wildcardToRegex;
+}
+export {};

package/lib/domains/services/config.service.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigService = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const os_1 = tslib_1.__importDefault(require("os"));
+const fs_1 = require("fs");
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.asyncapi');
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
+class ConfigService {
+    /**
+     * Load config file (~/.asyncapi/config.json)
+     */
+    static loadConfig() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const content = yield fs_1.promises.readFile(CONFIG_FILE, 'utf8');
+                return JSON.parse(content);
+            }
+            catch (err) {
+                if (err.code === 'ENOENT') {
+                    return {}; // no config yet
+                }
+                throw new Error(`Error reading config file: ${err.message}`);
+            }
+        });
+    }
+    /**
+     * Save config back to file
+     */
+    static saveConfig(config) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield fs_1.promises.mkdir(CONFIG_DIR, { recursive: true });
+            yield fs_1.promises.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf8');
+        });
+    }
+    /**
+     * Add a new auth entry
+     */
+    static addAuthEntry(entry) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const config = yield this.loadConfig();
+            if (!config.auth) {
+                config.auth = [];
+            }
+            config.auth.push(entry);
+            yield this.saveConfig(config);
+        });
+    }
+    /**
+     * Reads auth config from ~/.asyncapi/config.json and
+     * returns auth info matching the given URL, or null if no match.
+     *
+     * @param url - URL to match against auth patterns
+     * @returns Auth info or null if no match found
+     */
+    static getAuthForUrl(url) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const config = yield this.loadConfig();
+            if (!config.auth || !Array.isArray(config.auth)) {
+                console.warn('⚠️ No valid "auth" array found in config');
+                return null;
+            }
+            for (const entry of config.auth) {
+                try {
+                    const regex = this.wildcardToRegex(entry.pattern);
+                    if (regex.test(url)) {
+                        return {
+                            token: entry.token,
+                            authType: entry.authType || 'Bearer',
+                            headers: entry.headers || {}
+                        };
+                    }
+                }
+                catch (err) {
+                    console.warn(`⚠️ Invalid pattern "${entry.pattern}": ${err.message}`);
+                }
+            }
+            return null;
+        });
+    }
+    /**
+     * Convert wildcard pattern (*, **) to RegExp matching start of string
+     * @param pattern - wildcard pattern
+     */
+    static wildcardToRegex(pattern) {
+        const escaped = pattern.replace(/[-/\\^$+?.()|[\]{}]/g, '\\$&');
+        const regexStr = escaped
+            .replace(/\*\*/g, '.*')
+            .replace(/\*/g, '[^/]*');
+        // eslint-disable-next-line security/detect-non-literal-regexp
+        return new RegExp(`^${regexStr}`);
+    }
+}
+exports.ConfigService = ConfigService;

package/lib/domains/services/convert.service.d.ts

@@ -0,0 +1,12 @@
+import { ConversionOptions, ConversionResult, ServiceResult } from '../../interfaces';
+import { Specification } from '../models/SpecificationFile';
+import { BaseService } from './base.service';
+export declare class ConversionService extends BaseService {
+    /**
+     * Handles the conversion of AsyncAPI, Postman or OpenAPI documents based on the provided flags.
+     */
+    convertDocument(specFile: Specification, options: ConversionOptions): Promise<ServiceResult<ConversionResult>>;
+    handleLogging(specFile: Specification, flags: ConversionOptions): string;
+    private formatConvertedFile;
+    handleOutput(outputPath: string, convertedFileFormatted: string): Promise<void>;
+}

package/lib/domains/services/convert.service.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversionService = void 0;
+const tslib_1 = require("tslib");
+const base_service_1 = require("./base.service");
+const converter_1 = require("@asyncapi/converter");
+const picocolors_1 = require("picocolors");
+const fs_1 = require("fs");
+class ConversionService extends base_service_1.BaseService {
+    /**
+     * Handles the conversion of AsyncAPI, Postman or OpenAPI documents based on the provided flags.
+     */
+    convertDocument(specFile, options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            let convertedDocument;
+            switch (options.format) {
+                case 'asyncapi':
+                    convertedDocument = (0, converter_1.convert)((_a = specFile.text()) !== null && _a !== void 0 ? _a : '', options['target-version'] || '3.0.0');
+                    break;
+                case 'openapi':
+                    convertedDocument = (0, converter_1.convertOpenAPI)((_b = specFile.text()) !== null && _b !== void 0 ? _b : '', specFile.toJson().openapi, {
+                        perspective: options.perspective,
+                    });
+                    break;
+                case 'postman-collection':
+                    convertedDocument = (0, converter_1.convertPostman)((_c = specFile.text()) !== null && _c !== void 0 ? _c : '', '3.0.0', {
+                        perspective: options.perspective,
+                    });
+                    break;
+                default:
+                    return this.createErrorResult(`Unsupported conversion format: ${options.format}`);
+            }
+            return this.createSuccessResult({
+                convertedDocument: this.formatConvertedFile(convertedDocument),
+                originalFormat: options.format,
+            });
+        });
+    }
+    handleLogging(specFile, flags) {
+        const sourcePath = specFile.getFilePath() || specFile.getFileURL();
+        const targetVersion = flags['target-version'] || 'latest';
+        const outputMap = {
+            asyncapi: 'AsyncAPI document',
+            openapi: 'OpenAPI document',
+            'postman-collection': 'Postman Collection',
+        };
+        return `🎉 The ${outputMap[flags.format]} from ${(0, picocolors_1.cyan)(sourcePath)} has been successfully converted to AsyncAPI version ${(0, picocolors_1.green)(targetVersion)}!!`;
+    }
+    // Helper function to format the converted file
+    formatConvertedFile(convertedFile) {
+        return typeof convertedFile === 'object'
+            ? JSON.stringify(convertedFile, null, 4)
+            : convertedFile;
+    }
+    // Helper function to handle output
+    handleOutput(outputPath, convertedFileFormatted) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield fs_1.promises.writeFile(`${outputPath}`, convertedFileFormatted, {
+                encoding: 'utf8',
+            });
+        });
+    }
+}
+exports.ConversionService = ConversionService;

package/lib/domains/services/generator.service.d.ts

@@ -0,0 +1,15 @@
+import { GenerationOptions, GenerationResult, ServiceResult } from '../../interfaces';
+import { Specification } from '../models/SpecificationFile';
+import { BaseService } from './base.service';
+export declare class GeneratorService extends BaseService {
+    private defaultInteractive;
+    constructor(interactive?: boolean);
+    private templatesNotSupportingV3;
+    /**
+     * Verify that a given template support v3, if not, return the link to the issue that needs to be solved.
+     */
+    private verifyTemplateSupportForV3;
+    private getGenerationSuccessMessage;
+    private checkV3NotSupported;
+    generate(asyncapi: Specification, template: string, output: string, options: GenerationOptions, genOption: any, interactive?: boolean): Promise<ServiceResult<GenerationResult>>;
+}

package/lib/domains/services/generator.service.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratorService = void 0;
+const tslib_1 = require("tslib");
+const base_service_1 = require("./base.service");
+const generator_1 = tslib_1.__importDefault(require("@asyncapi/generator"));
+const prompts_1 = require("@clack/prompts");
+const path_1 = tslib_1.__importDefault(require("path"));
+const os_1 = tslib_1.__importDefault(require("os"));
+const picocolors_1 = require("picocolors");
+class GeneratorService extends base_service_1.BaseService {
+    constructor(interactive = false) {
+        super();
+        this.templatesNotSupportingV3 = {
+            '@asyncapi/minimaltemplate': 'some link', // For testing purpose
+            '@asyncapi/dotnet-nats-template': 'https://github.com/asyncapi/dotnet-nats-template/issues/384',
+            '@asyncapi/ts-nats-template': 'https://github.com/asyncapi/ts-nats-template/issues/545',
+            '@asyncapi/python-paho-template': 'https://github.com/asyncapi/python-paho-template/issues/189',
+            '@asyncapi/nodejs-ws-template': 'https://github.com/asyncapi/nodejs-ws-template/issues/294',
+            '@asyncapi/java-spring-cloud-stream-template': 'https://github.com/asyncapi/java-spring-cloud-stream-template/issues/336',
+            '@asyncapi/go-watermill-template': 'https://github.com/asyncapi/go-watermill-template/issues/243',
+            '@asyncapi/java-spring-template': 'https://github.com/asyncapi/java-spring-template/issues/308',
+            '@asyncapi/php-template': 'https://github.com/asyncapi/php-template/issues/191',
+        };
+        this.defaultInteractive = interactive;
+    }
+    /**
+     * Verify that a given template support v3, if not, return the link to the issue that needs to be solved.
+     */
+    verifyTemplateSupportForV3(template) {
+        if (this.templatesNotSupportingV3[`${template}`] !== undefined) {
+            return this.templatesNotSupportingV3[`${template}`];
+        }
+        return undefined;
+    }
+    getGenerationSuccessMessage(output) {
+        return `${(0, picocolors_1.yellow)('Check out your shiny new generated files at ') + (0, picocolors_1.magenta)(output) + (0, picocolors_1.yellow)('.')}\n\n`;
+    }
+    checkV3NotSupported(asyncapi, template) {
+        if (asyncapi.isAsyncAPI3()) {
+            const v3IssueLink = this.verifyTemplateSupportForV3(template);
+            if (v3IssueLink !== undefined) {
+                return `${template} template does not support AsyncAPI v3 documents, please checkout ${v3IssueLink}`;
+            }
+        }
+    }
+    generate(asyncapi_1, template_1, output_1, options_1, genOption_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (asyncapi, template, output, options, genOption, interactive = this.defaultInteractive) {
+            const v3NotSupported = this.checkV3NotSupported(asyncapi, template);
+            if (v3NotSupported) {
+                return this.createErrorResult(v3NotSupported);
+            }
+            const logs = [];
+            const generator = new generator_1.default(template, output || path_1.default.resolve(os_1.default.tmpdir(), 'asyncapi-generator'), options);
+            const s = interactive
+                ? (0, prompts_1.spinner)()
+                : { start: () => null, stop: (string) => logs.push(string) };
+            s.start('Generation in progress. Keep calm and wait a bit');
+            try {
+                yield generator.generateFromString(asyncapi.text(), Object.assign(Object.assign({}, genOption), { path: asyncapi }));
+            }
+            catch (err) {
+                s.stop('Generation failed');
+                return this.createErrorResult(err.message, err.diagnostics);
+            }
+            s.stop(this.getGenerationSuccessMessage(output));
+            return this.createSuccessResult({
+                success: true,
+                outputPath: output,
+                logs,
+            });
+        });
+    }
+}
+exports.GeneratorService = GeneratorService;