@asyncapi/cli 3.1.1 → 3.3.0

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>;
+}

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

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HelpController = void 0;
+const tslib_1 = require("tslib");
+const express_1 = require("express");
+const problem_exception_1 = require("../exceptions/problem.exception");
+const app_openapi_1 = require("../../../utils/app-openapi");
+const getCommandsFromRequest = (req) => {
+    return req.params.command
+        ? req.params.command.split('/').filter((cmd) => cmd.trim())
+        : [];
+};
+const isKeyValid = (key, obj) => {
+    return Object.keys(obj).includes(key);
+};
+const getPathKeysMatchingCommands = (commands, pathKeys) => {
+    if (!Array.isArray(pathKeys) ||
+        !pathKeys.every((key) => typeof key === 'string')) {
+        return undefined;
+    }
+    return pathKeys.find((pathKey) => {
+        const pathParts = pathKey.split('/').filter((part) => part !== '');
+        return pathParts.every((pathPart, i) => {
+            const command = commands[Number(i)];
+            return pathPart === command || pathPart.startsWith('{');
+        });
+    });
+};
+const getFullRequestBodySpec = (operationDetails) => {
+    return isKeyValid('requestBody', operationDetails)
+        ? operationDetails.requestBody.content['application/json'].schema
+        : null;
+};
+const buildResponseObject = (matchedPathKey, method, operationDetails, requestBodySchema) => {
+    return {
+        command: matchedPathKey,
+        method: method.toUpperCase(),
+        summary: operationDetails.summary || '',
+        requestBody: requestBodySchema,
+    };
+};
+class HelpController {
+    constructor() {
+        this.basepath = '/help';
+    }
+    boot() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const router = (0, express_1.Router)();
+            router.get('/help/:command*?', (req, res, next) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                const commands = getCommandsFromRequest(req);
+                let openapiSpec;
+                try {
+                    openapiSpec = yield (0, app_openapi_1.getAppOpenAPI)();
+                }
+                catch (err) {
+                    return next(err);
+                }
+                if (commands.length === 0) {
+                    const routes = isKeyValid('paths', openapiSpec)
+                        ? Object.keys(openapiSpec.paths).map((path) => ({
+                            command: path.replace(/^\//, ''),
+                            url: `${this.basepath}${path}`,
+                        }))
+                        : [];
+                    return res.json(routes);
+                }
+                const pathKeys = isKeyValid('paths', openapiSpec)
+                    ? Object.keys(openapiSpec.paths)
+                    : [];
+                const matchedPathKey = getPathKeysMatchingCommands(commands, pathKeys);
+                if (!matchedPathKey) {
+                    return next(new problem_exception_1.ProblemException({
+                        type: 'invalid-asyncapi-command',
+                        title: 'Invalid AsyncAPI Command',
+                        status: 404,
+                        detail: 'The given AsyncAPI command is not valid.',
+                    }));
+                }
+                const pathInfo = isKeyValid(matchedPathKey, openapiSpec.paths)
+                    ? openapiSpec.paths[String(matchedPathKey)]
+                    : undefined;
+                const method = commands.length > 1 ? 'get' : 'post';
+                const operationDetails = isKeyValid(method, pathInfo)
+                    ? pathInfo[String(method)]
+                    : undefined;
+                if (!operationDetails) {
+                    return next(new problem_exception_1.ProblemException({
+                        type: 'invalid-asyncapi-command',
+                        title: 'Invalid AsyncAPI Command',
+                        status: 404,
+                        detail: 'The given AsyncAPI command is not valid.',
+                    }));
+                }
+                const requestBodySchema = getFullRequestBodySpec(operationDetails);
+                return res.json(buildResponseObject(matchedPathKey, method, operationDetails, requestBodySchema));
+            }));
+            return router;
+        });
+    }
+}
+exports.HelpController = HelpController;

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

@@ -0,0 +1,10 @@
+import { Router } from 'express';
+import { Controller } from '../../../interfaces';
+/**
+ * Controller which exposes the Parser functionality, to parse the AsyncAPI document.
+ */
+export declare class ParseController implements Controller {
+    basepath: string;
+    private parse;
+    boot(): Promise<Router>;
+}

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseController = void 0;
+const tslib_1 = require("tslib");
+const express_1 = require("express");
+const validation_middleware_1 = require("../middlewares/validation.middleware");
+/**
+ * Controller which exposes the Parser functionality, to parse the AsyncAPI document.
+ */
+class ParseController {
+    constructor() {
+        this.basepath = '/parse';
+    }
+    parse(req, res) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const stringified = JSON.stringify((_a = req.asyncapi) === null || _a === void 0 ? void 0 : _a.parsedDocument);
+            res.status(200).json({
+                parsed: stringified,
+            });
+        });
+    }
+    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: ['asyncapi'],
+            }), this.parse.bind(this));
+            return router;
+        });
+    }
+}
+exports.ParseController = ParseController;

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

@@ -0,0 +1,10 @@
+import { Router } from 'express';
+import { Controller } from '../../../interfaces';
+/**
+ * Controller which exposes the Parser functionality, to validate the AsyncAPI document.
+ */
+export declare class ValidateController implements Controller {
+    basepath: string;
+    private validate;
+    boot(): Promise<Router>;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidateController = void 0;
+const tslib_1 = require("tslib");
+const express_1 = require("express");
+const validation_middleware_1 = require("../middlewares/validation.middleware");
+/**
+ * Controller which exposes the Parser functionality, to validate the AsyncAPI document.
+ */
+class ValidateController {
+    constructor() {
+        this.basepath = '/validate';
+    }
+    validate(req, res) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            if ((_b = (_a = req.asyncapi) === null || _a === void 0 ? void 0 : _a.parsedDocuments) === null || _b === void 0 ? void 0 : _b.length) {
+                const results = ((_c = req.asyncapi.validationResults) === null || _c === void 0 ? void 0 : _c.map((result) => ({
+                    status: result.status,
+                    asyncapi: result.document,
+                    diagnostics: result.diagnostics,
+                    score: result.score,
+                }))) || [];
+                res.status(200).json({
+                    results,
+                });
+            }
+            else {
+                res.status(200).json({
+                    status: (_e = (_d = req.asyncapi) === null || _d === void 0 ? void 0 : _d.validationResult) === null || _e === void 0 ? void 0 : _e.status,
+                    asyncapi: (_g = (_f = req.asyncapi) === null || _f === void 0 ? void 0 : _f.validationResult) === null || _g === void 0 ? void 0 : _g.document,
+                    diagnostics: (_j = (_h = req.asyncapi) === null || _h === void 0 ? void 0 : _h.validationResult) === null || _j === void 0 ? void 0 : _j.diagnostics,
+                    score: (_l = (_k = req.asyncapi) === null || _k === void 0 ? void 0 : _k.validationResult) === null || _l === void 0 ? void 0 : _l.score,
+                });
+            }
+        });
+    }
+    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: ['asyncapi'],
+            }), this.validate.bind(this));
+            return router;
+        });
+    }
+}
+exports.ValidateController = ValidateController;

package/lib/apps/api/exceptions/problem.exception.d.ts

@@ -0,0 +1,14 @@
+export interface ProblemExceptionProps {
+    status: number;
+    [key: string]: any;
+}
+declare const ProblemException_base: {
+    new (problem: import("@asyncapi/problem").ProblemBase & ProblemExceptionProps, options?: import("@asyncapi/problem").ProblemOptions): import("@asyncapi/problem").Problem<ProblemExceptionProps>;
+    createType(type: string): string;
+    captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class ProblemException extends ProblemException_base {
+}
+export {};

package/lib/apps/api/exceptions/problem.exception.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProblemException = void 0;
+const problem_1 = require("@asyncapi/problem");
+const typePrefix = 'https://api.asyncapi.com/problem';
+class ProblemException extends (0, problem_1.ProblemMixin)({
+    typePrefix,
+}) {
+}
+exports.ProblemException = ProblemException;

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

@@ -0,0 +1,9 @@
+import { ValidateController } from './controllers/validate.controller';
+import { ParseController } from './controllers/parse.controller';
+import { GenerateController } from './controllers/generate.controller';
+import { ConvertController } from './controllers/convert.controller';
+import { BundleController } from './controllers/bundle.controller';
+import { DiffController } from './controllers/diff.controller';
+import { DocsController } from './controllers/docs.controller';
+import { HelpController } from './controllers/help.controller';
+export declare const CONTROLLERS: (ValidateController | ParseController | GenerateController | ConvertController | BundleController | DiffController | DocsController | HelpController)[];

package/lib/apps/api/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTROLLERS = void 0;
+const validate_controller_1 = require("./controllers/validate.controller");
+const parse_controller_1 = require("./controllers/parse.controller");
+const generate_controller_1 = require("./controllers/generate.controller");
+const convert_controller_1 = require("./controllers/convert.controller");
+const bundle_controller_1 = require("./controllers/bundle.controller");
+const diff_controller_1 = require("./controllers/diff.controller");
+const docs_controller_1 = require("./controllers/docs.controller");
+const help_controller_1 = require("./controllers/help.controller");
+exports.CONTROLLERS = [
+    new validate_controller_1.ValidateController(),
+    new parse_controller_1.ParseController(),
+    new generate_controller_1.GenerateController(),
+    new convert_controller_1.ConvertController(),
+    new bundle_controller_1.BundleController(),
+    new diff_controller_1.DiffController(),
+    new docs_controller_1.DocsController(),
+    new help_controller_1.HelpController(),
+];

package/lib/apps/api/middlewares/problem.middleware.d.ts

@@ -0,0 +1,6 @@
+import { NextFunction, Request, Response } from 'express';
+import { ProblemException } from '../exceptions/problem.exception';
+/**
+ * Catch problem exception, log it and serialize error to human readable form.
+ */
+export declare function problemMiddleware(error: ProblemException, req: Request, res: Response, next: NextFunction): void;

package/lib/apps/api/middlewares/problem.middleware.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.problemMiddleware = problemMiddleware;
+const logger_1 = require("../../../utils/logger");
+/**
+ * Catch problem exception, log it and serialize error to human readable form.
+ */
+function problemMiddleware(error, req, res, next) {
+    if (res.headersSent) {
+        return next(error);
+    }
+    try {
+        const problemShape = error.get();
+        const status = (problemShape.status = problemShape.status || 500);
+        problemShape.title = problemShape.title || 'Internal server error';
+        logger_1.logger.error(`[${req.method}] ${req.path} >> Status:: ${status}, Type:: ${problemShape.type.replace('https://api.asyncapi.com/problem/', '')}, Title:: ${problemShape.title}, Detail:: ${problemShape.detail}`);
+        const isError = status >= 500;
+        const problem = error.toObject({
+            includeStack: isError,
+            includeCause: isError,
+        });
+        res.status(status).json(problem);
+    }
+    catch (err) {
+        next(err);
+    }
+}

package/lib/apps/api/middlewares/validation.middleware.d.ts

@@ -0,0 +1,12 @@
+import { Request, Response, NextFunction } from 'express';
+export interface ValidationMiddlewareOptions {
+    path: string;
+    method: 'all' | 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head';
+    documents?: Array<string>;
+    version?: 'v1';
+    condition?: (req: Request) => boolean;
+}
+/**
+ * Validate RequestBody and sent AsyncAPI document(s) for given path and method based on the OpenAPI Document.
+ */
+export declare function validationMiddleware(options: ValidationMiddlewareOptions): Promise<(req: Request, res: Response, next: NextFunction) => Promise<void>>;