@asyncapi/cli 3.2.0 → 3.4.0

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

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

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validationMiddleware = validationMiddleware;
+const tslib_1 = require("tslib");
+const problem_exception_1 = require("../exceptions/problem.exception");
+const ajv_1 = require("../../../utils/ajv");
+const app_openapi_1 = require("../../../utils/app-openapi");
+const validation_service_1 = require("../../../domains/services/validation.service");
+const SpecificationFile_1 = require("../../../domains/models/SpecificationFile");
+const ajvInstance = (0, ajv_1.createAjvInstance)();
+/**
+ * Create AJV's validator function for given path in the OpenAPI document.
+ */
+function compileAjv(options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const appOpenAPI = yield (0, app_openapi_1.getAppOpenAPI)();
+        const paths = appOpenAPI.paths || {};
+        const pathName = options.path;
+        const path = paths[String(pathName)];
+        if (!path) {
+            throw new Error(`Path "${pathName}" doesn't exist in the OpenAPI document.`);
+        }
+        const methodName = options.method;
+        const method = path[String(methodName)];
+        if (!method) {
+            throw new Error(`Method "${methodName}" for "${pathName}" path doesn't exist in the OpenAPI document.`);
+        }
+        const requestBody = method.requestBody;
+        if (!requestBody) {
+            return;
+        }
+        let schema = requestBody.content['application/json'].schema;
+        if (!schema) {
+            return;
+        }
+        schema = Object.assign({}, schema);
+        schema['$schema'] = 'http://json-schema.org/draft-07/schema';
+        if (options.documents && schema.properties) {
+            schema.properties = Object.assign({}, schema.properties);
+            for (const field of options.documents) {
+                if (schema.properties[String(field)].items) {
+                    schema.properties[String(field)] = Object.assign({}, schema.properties[String(field)]);
+                    schema.properties[String(field)].items = true;
+                }
+                else {
+                    schema.properties[String(field)] = true;
+                }
+            }
+        }
+        return ajvInstance.compile(schema);
+    });
+}
+function validateRequestBody(validate, body) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const valid = validate(body);
+        const errors = validate.errors && [...validate.errors];
+        if (valid === false) {
+            throw new problem_exception_1.ProblemException({
+                type: 'invalid-request-body',
+                title: 'Invalid Request Body',
+                status: 422,
+                validationErrors: errors,
+            });
+        }
+    });
+}
+function validateSingleDocument(asyncapi, path, validationService) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (typeof asyncapi === 'object') {
+            asyncapi = JSON.stringify(asyncapi);
+        }
+        const specFile = new SpecificationFile_1.Specification(asyncapi, { fileURL: path });
+        return validationService
+            .validateDocument(specFile, {
+            'fail-severity': 'error',
+            suppressAllWarnings: false,
+        })
+            .then((result) => {
+            var _a, _b;
+            if (!result.success || ((_a = result.data) === null || _a === void 0 ? void 0 : _a.status) !== 'valid') {
+                throw new problem_exception_1.ProblemException({
+                    type: 'invalid-asyncapi-document',
+                    title: 'Invalid AsyncAPI Document',
+                    status: 422,
+                    detail: result.error || 'The provided AsyncAPI document is invalid.',
+                    diagnostics: result.diagnostics || ((_b = result.data) === null || _b === void 0 ? void 0 : _b.diagnostics),
+                });
+            }
+            return result.data;
+        });
+    });
+}
+function validateListDocuments(asyncapis, path, validationService) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const validationResults = [];
+        for (const asyncapi of asyncapis) {
+            const parsed = yield validateSingleDocument(asyncapi, path, validationService);
+            if (parsed) {
+                validationResults.push(parsed);
+            }
+            else {
+                throw new problem_exception_1.ProblemException({
+                    type: 'invalid-asyncapi-document',
+                    title: 'Invalid AsyncAPI Document',
+                    status: 422,
+                    detail: 'One or more provided AsyncAPI documents are invalid.',
+                });
+            }
+        }
+        return validationResults;
+    });
+}
+/**
+ * Validate RequestBody and sent AsyncAPI document(s) for given path and method based on the OpenAPI Document.
+ */
+function validationMiddleware(options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        options.version = options.version || 'v1';
+        const validate = yield compileAjv(options);
+        const documents = options.documents || [];
+        return (req, res, next) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Check if the condition is met
+            if (options.condition && !options.condition(req)) {
+                return next();
+            }
+            try {
+                if (!validate) {
+                    throw new problem_exception_1.ProblemException({
+                        type: 'invalid-request-body',
+                        title: 'Invalid Request Body',
+                        status: 422,
+                        detail: `Request body validation is not supported for "${options.path}" path with "${options.method}" method.`,
+                    });
+                }
+                yield validateRequestBody(validate, req.body);
+            }
+            catch (error) {
+                if (error instanceof problem_exception_1.ProblemException) {
+                    return next(error);
+                }
+                // Handle unexpected errors
+                return next(new problem_exception_1.ProblemException({
+                    type: 'internal-server-error',
+                    title: 'Internal Server Error',
+                    status: 500,
+                    detail: `An unexpected error occurred during request validation: ${(_a = error.message) !== null && _a !== void 0 ? _a : 'Unknown error'}`,
+                }));
+            }
+            const parserConfig = {
+                __unstable: {
+                    resolver: {
+                        resolvers: [
+                        // @TODO: Add Cookie Based Resolvers after migration and understanding some
+                        // details about how to use them in the new parser-js version.
+                        ],
+                    },
+                },
+            };
+            const validationService = new validation_service_1.ValidationService(parserConfig);
+            const resolveURL = req.header('x-asyncapi-resolve-url') ||
+                req.header('referer') ||
+                req.header('origin') ||
+                '';
+            try {
+                req.asyncapi = req.asyncapi || {};
+                for (const field of documents) {
+                    const body = req.body[String(field)];
+                    if (Array.isArray(body)) {
+                        const results = yield validateListDocuments(body, resolveURL, validationService);
+                        const parsedDocuments = results.map((result) => result.document);
+                        req.asyncapi.parsedDocuments = parsedDocuments;
+                        req.asyncapi.validationResults = results;
+                    }
+                    else {
+                        const result = yield validateSingleDocument(body, resolveURL, validationService);
+                        req.asyncapi.parsedDocument = result === null || result === void 0 ? void 0 : result.document;
+                        req.asyncapi.validationResult = result;
+                    }
+                }
+                next();
+            }
+            catch (err) {
+                return next(err);
+            }
+        });
+    });
+}
+const TYPES_400 = [
+    'null-or-falsey-document',
+    'impossible-to-convert-to-json',
+    'invalid-document-type',
+    'invalid-json',
+    'invalid-yaml',
+];
+/**
+ * Some error types have to be treated as 400 HTTP Status Code, another as 422.
+ */
+function retrieveStatusCode(type) {
+    if (TYPES_400.includes(type)) {
+        return 400;
+    }
+    return 422;
+}
+/**
+ * Merges fields from ParserError to ProblemException.
+ */
+function mergeParserError(error, parserError) {
+    if (parserError.detail) {
+        error.set('detail', parserError.detail);
+    }
+    if (parserError.validationErrors) {
+        error.set('validationErrors', parserError.validationErrors);
+    }
+    if (parserError.parsedJSON) {
+        error.set('parsedJSON', parserError.parsedJSON);
+    }
+    if (parserError.location) {
+        error.set('location', parserError.location);
+    }
+    if (parserError.refs) {
+        error.set('refs', parserError.refs);
+    }
+    return error;
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function tryConvertToProblemException(err) {
+    const typeName = err.type.replace('https://github.com/asyncapi/parser-js/', '');
+    const error = new problem_exception_1.ProblemException({
+        type: typeName,
+        title: err.title,
+        status: retrieveStatusCode(typeName),
+    });
+    mergeParserError(error, err);
+    return error;
+}

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

@@ -0,0 +1,3 @@
+import './configs/production.json';
+import './configs/development.json';
+import './configs/test.json';

package/lib/apps/api/server.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+// include configs in the `dist` folder
+require("./configs/production.json");
+require("./configs/development.json");
+require("./configs/test.json");
+// for `config` module
+process.env['NODE_CONFIG_DIR'] = `${__dirname}/configs`;
+const app_1 = require("./app");
+const _1 = require(".");
+function main() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const app = new app_1.App(_1.CONTROLLERS);
+        yield app.init();
+        app.listen();
+    });
+}
+main();

package/lib/{commands → apps/cli/commands}/bundle.d.ts

@@ -1,4 +1,4 @@
-import Command from '../core/base';
+import Command from '../internal/base';
 export default class Bundle extends Command {
     static readonly description = "Bundle one or multiple AsyncAPI Documents and their references together.";
     static strict: boolean;

package/lib/{commands → apps/cli/commands}/bundle.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const base_1 = tslib_1.__importDefault(require("../core/base"));
+const base_1 = tslib_1.__importDefault(require("../internal/base"));
 const bundler_1 = tslib_1.__importDefault(require("@asyncapi/bundler"));
 const fs_1 = require("fs");
 const path_1 = tslib_1.__importDefault(require("path"));
-const SpecificationFile_1 = require("../core/models/SpecificationFile");
-const bundle_flags_1 = require("../core/flags/bundle.flags");
+const SpecificationFile_1 = require("../../../domains/models/SpecificationFile");
+const bundle_flags_1 = require("../internal/flags/bundle.flags");
 const { writeFile } = fs_1.promises;
 class Bundle extends base_1.default {
     run() {

package/lib/{commands → apps/cli/commands}/config/analytics.d.ts

@@ -1,4 +1,4 @@
-import Command from '../../core/base';
+import Command from '../../internal/base';
 export default class Analytics extends Command {
     static readonly description = "Enable or disable analytics for metrics collection";
     static readonly flags: {

package/lib/{commands → apps/cli/commands}/config/analytics.js

@@ -2,17 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const path_1 = require("path");
-const base_1 = tslib_1.__importDefault(require("../../core/base"));
+const base_1 = tslib_1.__importDefault(require("../../internal/base"));
 const fs_1 = require("fs");
 const os_1 = require("os");
-const analytics_flags_1 = require("../../core/flags/config/analytics.flags");
+const analytics_flags_1 = require("../../internal/flags/config/analytics.flags");
 const picocolors_1 = require("picocolors");
 const { readFile, writeFile } = fs_1.promises;
 class Analytics extends base_1.default {
     run() {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const { flags } = yield this.parse(Analytics);
-            const analyticsConfigFile = process.env.ASYNCAPI_METRICS_CONFIG_PATH || (0, path_1.join)((0, os_1.homedir)(), '.asyncapi-analytics');
+            const analyticsConfigFile = process.env.ASYNCAPI_METRICS_CONFIG_PATH ||
+                (0, path_1.join)((0, os_1.homedir)(), '.asyncapi-analytics');
             try {
                 const analyticsConfigFileContent = JSON.parse(yield readFile((0, path_1.resolve)(analyticsConfigFile), { encoding: 'utf8' }));
                 if (flags.disable) {

package/lib/{commands → apps/cli/commands}/config/context/add.d.ts

@@ -1,4 +1,4 @@
-import Command from '../../../core/base';
+import Command from '../../../internal/base';
 export default class ContextAdd extends Command {
     static description: string;
     static flags: {