@asyncapi/cli 3.2.0 → 3.4.0

package/assets/create-template/templates/default/package-lock.json

@@ -2416,9 +2416,10 @@
       "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
     },
     "node_modules/brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "license": "MIT",
       "dependencies": {
         "balanced-match": "^1.0.0",
         "concat-map": "0.0.1"

package/lib/apps/api/app.d.ts

@@ -0,0 +1,15 @@
+import express from 'express';
+import { Controller } from '../../interfaces';
+export declare class App {
+    private readonly controllers;
+    private readonly port;
+    private readonly env;
+    private app;
+    constructor(controllers: Controller[], port?: number | string, env?: string);
+    init(): Promise<void>;
+    listen(): void;
+    getServer(): express.Application;
+    private initializeMiddlewares;
+    private initializeControllers;
+    private initializeErrorHandling;
+}

package/lib/apps/api/app.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.App = void 0;
+const tslib_1 = require("tslib");
+const body_parser_1 = tslib_1.__importDefault(require("body-parser"));
+const compression_1 = tslib_1.__importDefault(require("compression"));
+const config_1 = tslib_1.__importDefault(require("config"));
+const cors_1 = tslib_1.__importDefault(require("cors"));
+const express_1 = tslib_1.__importDefault(require("express"));
+const helmet_1 = tslib_1.__importDefault(require("helmet"));
+// import { problemMiddleware } from './middlewares/problem.middleware';
+const logger_1 = require("../../utils/logger");
+const constants_1 = require("./constants");
+const problem_middleware_1 = require("./middlewares/problem.middleware");
+class App {
+    constructor(controllers, port = process.env.PORT || 80, env = process.env.NODE_ENV || 'development') {
+        this.controllers = controllers;
+        this.port = port;
+        this.env = env;
+        this.app = (0, express_1.default)();
+    }
+    init() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // initialize core middlewares
+            yield this.initializeMiddlewares();
+            // initialize controllers
+            yield this.initializeControllers();
+            // initialize error handling
+            yield this.initializeErrorHandling();
+        });
+    }
+    listen() {
+        this.app.listen(this.port, () => {
+            logger_1.logger.info('=================================');
+            logger_1.logger.info(`= ENV: ${this.env}`);
+            logger_1.logger.info(`= 🚀 AsyncAPI Server API listening on the port ${this.port}`);
+            logger_1.logger.info('=================================');
+        });
+    }
+    getServer() {
+        return this.app;
+    }
+    initializeMiddlewares() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const requestBodyLimit = config_1.default.get('request.body.limit');
+            this.app.use((0, cors_1.default)({
+                origin: config_1.default.get('cors.origin'),
+                credentials: config_1.default.get('cors.credentials'),
+            }));
+            this.app.use((0, compression_1.default)());
+            this.app.use(body_parser_1.default.text({ type: ['text/*'], limit: requestBodyLimit }));
+            this.app.use(body_parser_1.default.urlencoded({ extended: true, limit: requestBodyLimit }));
+            this.app.use(body_parser_1.default.json({
+                type: ['json', '*/json', '+json'],
+                limit: requestBodyLimit,
+            }));
+            this.app.use((0, helmet_1.default)({
+                contentSecurityPolicy: {
+                    directives: {
+                        // for `/docs` path - we need to fetch redoc component from unpkg.com domain and hash for inline script
+                        'script-src': [
+                            '\'self\'',
+                            'unpkg.com',
+                            '\'sha256-HoDNcNPq7PEOgc6zsff39t5lZ/S65RY7Zl4hI67unp0=\'',
+                        ],
+                        // for schemas
+                        'connect-src': ['\'self\'', 'http:'],
+                        'worker-src': ['\'self\' blob:'],
+                    },
+                },
+                // for `/docs` path
+                crossOriginEmbedderPolicy: false,
+            }));
+        });
+    }
+    initializeControllers() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            for (const controller of this.controllers) {
+                this.app.use(`/${constants_1.API_VERSION}/`, yield controller.boot());
+            }
+        });
+    }
+    initializeErrorHandling() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this.app.use(problem_middleware_1.problemMiddleware);
+        });
+    }
+}
+exports.App = App;

package/lib/apps/api/configs/development.json

@@ -0,0 +1,16 @@
+{
+    "env": "development",
+    "log": {
+        "format": "dev",
+        "dir": "../logs"
+    },
+    "cors": {
+        "origin": true,
+        "credentials": false
+    },
+    "request": {
+        "body": {
+            "limit": "5mb"
+        }
+    }
+}

package/lib/apps/api/configs/production.json

@@ -0,0 +1,16 @@
+{
+    "env": "production",
+    "log": {
+        "format": "combined",
+        "dir": "../logs"
+    },
+    "cors": {
+        "origin": true,
+        "credentials": false
+    },
+    "request": {
+        "body": {
+            "limit": "5mb"
+        }
+    }
+}

package/lib/apps/api/configs/test.json

@@ -0,0 +1,16 @@
+{
+    "env": "test",
+    "log": {
+        "format": "dev",
+        "dir": "../logs"
+    },
+    "cors": {
+        "origin": true,
+        "credentials": false
+    },
+    "request": {
+        "body": {
+            "limit": "5mb"
+        }
+    }
+}

package/lib/apps/api/constants.d.ts

@@ -0,0 +1 @@
+export declare const API_VERSION = "v1";

package/lib/apps/api/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_VERSION = void 0;
+exports.API_VERSION = 'v1';

package/lib/apps/api/controllers/bundle.controller.d.ts

@@ -0,0 +1,7 @@
+import { Router } from 'express';
+import { Controller } from '../../../interfaces';
+export declare class BundleController implements Controller {
+    basepath: string;
+    private bundle;
+    boot(): Promise<Router>;
+}

package/lib/apps/api/controllers/bundle.controller.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BundleController = void 0;
+const tslib_1 = require("tslib");
+const express_1 = require("express");
+const bundler_1 = tslib_1.__importDefault(require("@asyncapi/bundler"));
+const validation_middleware_1 = require("../middlewares/validation.middleware");
+const problem_exception_1 = require("../exceptions/problem.exception");
+class BundleController {
+    constructor() {
+        this.basepath = '/bundle';
+    }
+    bundle(req, res, next) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const asyncapis = req.body.asyncapis;
+            const base = req.body.base;
+            try {
+                const document = yield (0, bundler_1.default)(asyncapis, { base });
+                const bundled = document.json();
+                res.status(200).json({ bundled });
+            }
+            catch (err) {
+                return next(new problem_exception_1.ProblemException({
+                    type: 'internal-bundler-error',
+                    title: 'Internal Bundler error',
+                    status: 500,
+                    detail: err.message,
+                }));
+            }
+        });
+    }
+    boot() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const router = (0, express_1.Router)();
+            router.post(this.basepath, yield (0, validation_middleware_1.validationMiddleware)({
+                path: this.basepath,
+                method: 'post',
+                documents: ['asyncapis', 'base'],
+            }), this.bundle.bind(this));
+            return router;
+        });
+    }
+}
+exports.BundleController = BundleController;

package/lib/apps/api/controllers/convert.controller.d.ts

@@ -0,0 +1,11 @@
+import { Router } from 'express';
+import { Controller } from '../../../interfaces';
+/**
+ * Controller which exposes the Convert functionality
+ */
+export declare class ConvertController implements Controller {
+    basepath: string;
+    private conversionService;
+    private convert;
+    boot(): Promise<Router>;
+}

package/lib/apps/api/controllers/convert.controller.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConvertController = void 0;
+const tslib_1 = require("tslib");
+const express_1 = require("express");
+const validation_middleware_1 = require("../middlewares/validation.middleware");
+const convert_service_1 = require("../../../domains/services/convert.service");
+const problem_exception_1 = require("../exceptions/problem.exception");
+const SpecificationFile_1 = require("../../../domains/models/SpecificationFile");
+/**
+ * Controller which exposes the Convert functionality
+ */
+class ConvertController {
+    constructor() {
+        this.basepath = '/convert';
+        this.conversionService = new convert_service_1.ConversionService();
+    }
+    convert(req, res, next) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                const options = req.body;
+                const specFile = new SpecificationFile_1.Specification(typeof options.source === 'string'
+                    ? options.source
+                    : JSON.stringify(options.source));
+                const result = yield this.conversionService.convertDocument(specFile, options);
+                if (!result.success) {
+                    return next(new problem_exception_1.ProblemException({
+                        type: 'conversion-error',
+                        title: 'Conversion failed',
+                        status: 400,
+                        detail: result.error,
+                    }));
+                }
+                res.status(200).json({
+                    converted: (_a = result.data) === null || _a === void 0 ? void 0 : _a.convertedDocument,
+                    sourceFormat: (_b = result.data) === null || _b === void 0 ? void 0 : _b.originalFormat,
+                });
+            }
+            catch (err) {
+                if (err instanceof problem_exception_1.ProblemException) {
+                    return next(err);
+                }
+                return next(new problem_exception_1.ProblemException({
+                    type: 'internal-server-error',
+                    title: 'Internal server error',
+                    status: 500,
+                    detail: err.message,
+                }));
+            }
+        });
+    }
+    boot() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const router = (0, express_1.Router)();
+            router.post(this.basepath, yield (0, validation_middleware_1.validationMiddleware)({
+                path: this.basepath,
+                method: 'post',
+                documents: ['source'],
+                condition: (req) => {
+                    const body = req.body;
+                    return body.format === 'asyncapi';
+                },
+            }), this.convert.bind(this));
+            return router;
+        });
+    }
+}
+exports.ConvertController = ConvertController;

package/lib/apps/api/controllers/diff.controller.d.ts

@@ -0,0 +1,7 @@
+import { Router } from 'express';
+import { Controller } from '../../../interfaces';
+export declare class DiffController implements Controller {
+    basepath: string;
+    private diff;
+    boot(): Promise<Router>;
+}

package/lib/apps/api/controllers/diff.controller.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffController = void 0;
+const tslib_1 = require("tslib");
+const express_1 = require("express");
+const diff_1 = require("@asyncapi/diff");
+const validation_middleware_1 = require("../middlewares/validation.middleware");
+const problem_exception_1 = require("../exceptions/problem.exception");
+class DiffController {
+    constructor() {
+        this.basepath = '/diff';
+    }
+    diff(req, res, next) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { asyncapis } = req.body;
+            try {
+                const output = (0, diff_1.diff)(asyncapis[0], asyncapis[1]).getOutput();
+                res.status(200).json({ diff: output });
+            }
+            catch (err) {
+                return next(new problem_exception_1.ProblemException({
+                    type: 'internal-diff-error',
+                    title: 'Internal Diff error',
+                    status: 500,
+                    detail: err.message,
+                }));
+            }
+        });
+    }
+    boot() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const router = (0, express_1.Router)();
+            router.post(this.basepath, yield (0, validation_middleware_1.validationMiddleware)({
+                path: this.basepath,
+                method: 'post',
+                documents: ['asyncapis'],
+            }), this.diff.bind(this));
+            return router;
+        });
+    }
+}
+exports.DiffController = DiffController;

package/lib/apps/api/controllers/docs.controller.d.ts

@@ -0,0 +1,6 @@
+import { Router } from 'express';
+import { Controller } from '../../../interfaces';
+export declare class DocsController implements Controller {
+    basepath: string;
+    boot(): Router;
+}

package/lib/apps/api/controllers/docs.controller.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocsController = void 0;
+const tslib_1 = require("tslib");
+const express_1 = require("express");
+const redoc_express_1 = tslib_1.__importDefault(require("redoc-express"));
+const constants_1 = require("../constants");
+class DocsController {
+    constructor() {
+        this.basepath = '/docs';
+    }
+    boot() {
+        const router = (0, express_1.Router)();
+        router.get(`${this.basepath}/openapi.yaml`, (_, res) => {
+            res.sendFile('openapi.yaml', { root: '.' });
+        });
+        router.get(this.basepath, (0, redoc_express_1.default)({
+            title: 'OpenAPI Documentation',
+            specUrl: `/${constants_1.API_VERSION}${this.basepath}/openapi.yaml`,
+        }));
+        return router;
+    }
+}
+exports.DocsController = DocsController;

package/lib/apps/api/controllers/generate.controller.d.ts

@@ -0,0 +1,22 @@
+import { Router } from 'express';
+import { Controller } from '../../../interfaces';
+/**
+ * Controller which exposes the Generator functionality
+ */
+export declare class GenerateController implements Controller {
+    basepath: string;
+    private archiverService;
+    private generatorService;
+    private ajv;
+    private generate;
+    private validateTemplateParameters;
+    /**
+     * Retrieve proper AJV's validator function, create or reuse it.
+     */
+    getAjvValidator(templateName: string): Promise<import("ajv/dist/types").AnyValidateFunction<unknown> | undefined>;
+    /**
+     * Serialize template parameters. Read all parameters from template's package.json and create a proper JSON Schema for validating parameters.
+     */
+    serializeTemplateParameters(templateName: string): Promise<object | undefined>;
+    boot(): Promise<Router>;
+}

package/lib/apps/api/controllers/generate.controller.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateController = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const express_1 = require("express");
+const ajv_1 = tslib_1.__importDefault(require("ajv"));
+const validation_middleware_1 = require("../middlewares/validation.middleware");
+const archiver_service_1 = require("../../../domains/services/archiver.service");
+const generator_service_1 = require("../../../domains/services/generator.service");
+const problem_exception_1 = require("../exceptions/problem.exception");
+const SpecificationFile_1 = require("../../../domains/models/SpecificationFile");
+/**
+ * Controller which exposes the Generator functionality
+ */
+class GenerateController {
+    constructor() {
+        this.basepath = '/generate';
+        this.archiverService = new archiver_service_1.ArchiverService();
+        this.generatorService = new generator_service_1.GeneratorService();
+    }
+    generate(req, res, next) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // try {
+            //   await this.validateTemplateParameters(req);
+            // } catch (err) {
+            //   return next(err);
+            // }
+            const zip = this.archiverService.createZip(res);
+            let tmpDir;
+            try {
+                tmpDir = yield this.archiverService.createTempDirectory();
+                const { asyncapi, template, parameters } = req.body;
+                const options = {
+                    forceWrite: true,
+                    templateParams: parameters,
+                };
+                const generateFunc = req.body['use-fallback-generator']
+                    ? this.generatorService.generate.bind(this.generatorService)
+                    : this.generatorService.generateUsingNewGenerator.bind(this.generatorService);
+                try {
+                    const result = yield generateFunc(new SpecificationFile_1.Specification(typeof asyncapi === 'object' ? JSON.stringify(asyncapi) : asyncapi), template, tmpDir, options, {}, true);
+                    if (!result.success) {
+                        return next(new problem_exception_1.ProblemException({
+                            type: 'generation-error',
+                            title: 'Generation Error',
+                            status: 500,
+                            detail: result.error || 'An error occurred during generation.',
+                        }));
+                    }
+                }
+                catch (genErr) {
+                    return next(new problem_exception_1.ProblemException({
+                        type: 'internal-generator-error',
+                        title: 'Internal Generator error',
+                        status: 500,
+                        detail: genErr.message,
+                    }));
+                }
+                this.archiverService.appendDirectory(zip, tmpDir, 'template');
+                this.archiverService.appendAsyncAPIDocument(zip, asyncapi);
+                res.status(200);
+                return yield this.archiverService.finalize(zip);
+            }
+            catch (err) {
+                return next(new problem_exception_1.ProblemException({
+                    type: 'internal-server-error',
+                    title: 'Internal server error',
+                    status: 500,
+                    detail: err.message,
+                }));
+            }
+            finally {
+                if (tmpDir) {
+                    // Remove the temporary directory after the response is sent
+                    // to avoid leaving temporary files on the server.
+                    yield this.archiverService.removeTempDirectory(tmpDir);
+                }
+            }
+        });
+    }
+    validateTemplateParameters(req) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { template, parameters } = req.body;
+            const validate = yield this.getAjvValidator(template);
+            if (!validate) {
+                throw new problem_exception_1.ProblemException({
+                    type: 'invalid-template',
+                    title: 'Invalid Generator Template',
+                    status: 422,
+                    detail: `Template ${template} is not valid or does not exist.`,
+                });
+            }
+            const valid = validate(parameters || {});
+            const errors = validate.errors && [...validate.errors];
+            if (valid === false) {
+                throw new problem_exception_1.ProblemException({
+                    type: 'invalid-template-parameters',
+                    title: 'Invalid Generator Template parameters',
+                    status: 422,
+                    validationErrors: errors,
+                });
+            }
+        });
+    }
+    /**
+     * Retrieve proper AJV's validator function, create or reuse it.
+     */
+    getAjvValidator(templateName) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!this.ajv) {
+                throw new Error('AJV instance is not initialized');
+            }
+            let validate = this.ajv.getSchema(templateName);
+            if (!validate) {
+                this.ajv.addSchema((yield this.serializeTemplateParameters(templateName)) || {}, templateName);
+                validate = this.ajv.getSchema(templateName);
+            }
+            return validate;
+        });
+    }
+    /**
+     * Serialize template parameters. Read all parameters from template's package.json and create a proper JSON Schema for validating parameters.
+     */
+    serializeTemplateParameters(templateName) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const pathToPackageJSON = path_1.default.join(__dirname, `../../../../node_modules/${templateName}/package.json`);
+            const packageJSONContent = yield fs_1.default.promises.readFile(pathToPackageJSON, 'utf-8');
+            const packageJSON = JSON.parse(packageJSONContent);
+            if (!packageJSON) {
+                return;
+            }
+            const generator = packageJSON.generator;
+            if (!generator || !generator.parameters) {
+                return;
+            }
+            const parameters = generator.parameters || {};
+            const required = [];
+            for (const parameter in parameters) {
+                // at the moment all parameters have to be passed to the Generator instance as string
+                parameters[String(parameter)].type = 'string';
+                if (parameters[String(parameter)].required) {
+                    required.push(parameter);
+                }
+                delete parameters[String(parameter)].required;
+            }
+            return {
+                $schema: 'http://json-schema.org/draft-07/schema#',
+                type: 'object',
+                properties: parameters,
+                required,
+                // don't allow non supported properties
+                additionalProperties: false,
+            };
+        });
+    }
+    boot() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this.ajv = new ajv_1.default({
+                inlineRefs: true,
+                allErrors: true,
+                schemaId: 'id',
+                logger: false,
+            });
+            const router = (0, express_1.Router)();
+            router.post(`${this.basepath}`, yield (0, validation_middleware_1.validationMiddleware)({
+                path: this.basepath,
+                method: 'post',
+                documents: ['asyncapi'],
+            }), this.generate.bind(this));
+            return router;
+        });
+    }
+}
+exports.GenerateController = GenerateController;

package/lib/apps/api/controllers/help.controller.d.ts

@@ -0,0 +1,6 @@
+import { Router } from 'express';
+import { Controller } from '../../../interfaces';
+export declare class HelpController implements Controller {
+    basepath: string;
+    boot(): Promise<Router>;
+}