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

package/lib/apps/cli/commands/generate/fromTemplate.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const BaseGeneratorCommand_1 = require("../../internal/base/BaseGeneratorCommand");
+const SpecificationFile_1 = require("../../../../domains/models/SpecificationFile");
+const validation_error_1 = require("../../../../errors/validation-error");
+const generator_error_1 = require("../../../../errors/generator-error");
+const prompts_1 = require("@clack/prompts");
+const picocolors_1 = require("picocolors");
+const fromTemplate_flags_1 = require("../../internal/flags/generate/fromTemplate.flags");
+const flags_1 = require("../../../../utils/generate/flags");
+const prompts_2 = require("../../../../utils/generate/prompts");
+class Template extends BaseGeneratorCommand_1.BaseGeneratorCommand {
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const { args, flags } = yield this.parse(Template); // NOSONAR
+            const interactive = !flags['no-interactive'];
+            let asyncapi = (_a = args['asyncapi']) !== null && _a !== void 0 ? _a : '';
+            let template = (_b = args['template']) !== null && _b !== void 0 ? _b : '';
+            let output = flags.output;
+            const { proxyPort, proxyHost } = flags;
+            if (interactive) {
+                (0, prompts_1.intro)((0, picocolors_1.inverse)('AsyncAPI Generator'));
+                const parsedArgs = yield this.parseArgs(args, output);
+                asyncapi = parsedArgs.asyncapi;
+                template = parsedArgs.template;
+                output = parsedArgs.output;
+            }
+            const parsedFlags = (0, flags_1.parseGeneratorFlags)(flags['disable-hook'], flags['param'], flags['map-base-url'], flags['registry-url'], flags['registry-auth'], flags['registry-token']);
+            const options = yield this.buildGeneratorOptions(flags, parsedFlags);
+            // Apply proxy configuration using base class method
+            asyncapi = this.applyProxyConfiguration(asyncapi, proxyHost, proxyPort);
+            const asyncapiInput = yield this.loadAsyncAPIInput(asyncapi);
+            this.specFile = asyncapiInput;
+            this.metricsMetadata.template = template;
+            const watchTemplate = flags['watch'];
+            const genOption = this.buildGenOption(flags, parsedFlags);
+            let specification;
+            try {
+                specification = yield (0, SpecificationFile_1.load)(asyncapi);
+            }
+            catch (err) {
+                return this.error(new validation_error_1.ValidationError({
+                    // eslint-disable-next-line sonarjs/no-duplicate-string
+                    type: 'invalid-file',
+                    filepath: asyncapi,
+                }), { exit: 1 });
+            }
+            const result = yield this.generatorService.generate(specification, template, output, options, // GeneratorService expects different options interface
+            genOption, interactive);
+            if (!result.success) {
+                throw new generator_error_1.GeneratorError(new Error(result.error));
+            }
+            // Output logs in non-interactive mode
+            if (!interactive && ((_c = result.data) === null || _c === void 0 ? void 0 : _c.logs)) {
+                for (const log of result.data.logs) {
+                    this.log(log);
+                }
+            }
+            if (watchTemplate) {
+                yield this.handleWatchMode(asyncapi, template, output, options, genOption, interactive);
+            }
+        });
+    }
+    parseArgs(args, output) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // Use base class method for common args
+            const commonArgs = yield this.parseCommonArgs(args, output);
+            let template = args['template'];
+            if (!template) {
+                template = yield (0, prompts_2.promptForTemplate)();
+            }
+            this.handleCancellation(template);
+            return {
+                asyncapi: commonArgs.asyncapi,
+                template,
+                output: commonArgs.output
+            };
+        });
+    }
+}
+Template.description = 'Generates whatever you want using templates compatible with AsyncAPI Generator.';
+Template.examples = [
+    'asyncapi generate fromTemplate asyncapi.yaml @asyncapi/html-template --param version=1.0.0 singleFile=true --output ./docs --force-write',
+];
+Template.flags = Object.assign(Object.assign({}, (0, fromTemplate_flags_1.fromTemplateFlags)()), BaseGeneratorCommand_1.BaseGeneratorCommand.flags);
+Template.args = Object.assign(Object.assign({}, BaseGeneratorCommand_1.BaseGeneratorCommand.args), { template: core_1.Args.string({ description: '- Name of the generator template like for example @asyncapi/html-template or https://github.com/asyncapi/html-template', required: false }) });
+exports.default = Template;

package/lib/apps/cli/commands/generate/index.d.ts

@@ -0,0 +1,5 @@
+import Command from '../../internal/base';
+export default class Generate extends Command {
+    static description: string;
+    run(): Promise<void>;
+}

package/lib/apps/cli/commands/generate/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const base_1 = tslib_1.__importDefault(require("../../internal/base"));
+const core_1 = require("@oclif/core");
+class Generate extends base_1.default {
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const help = new core_1.Help(this.config);
+            help.showHelp(['generate', '--help']);
+        });
+    }
+}
+Generate.description = 'Generate typed models or other things like clients, applications or docs using AsyncAPI Generator templates.';
+exports.default = Generate;

package/lib/apps/cli/commands/generate/models.d.ts

@@ -0,0 +1,16 @@
+import Command from '../../internal/base';
+import { Specification } from '../../../../domains/models/SpecificationFile';
+import { ValidationStatus } from '../../../../domains/services/validation.service';
+import { Diagnostic } from '@asyncapi/parser/cjs';
+export default class Models extends Command {
+    static description: string;
+    private validationService;
+    static readonly args: any;
+    static readonly flags: {
+        proxyHost: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        proxyPort: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private parseArgs;
+    handleGovernanceMessage(document: Specification, diagnostics: Diagnostic[], status: ValidationStatus): Promise<void>;
+}

package/lib/apps/cli/commands/generate/models.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const base_1 = tslib_1.__importDefault(require("../../internal/base"));
+const SpecificationFile_1 = require("../../../../domains/models/SpecificationFile");
+const prompts_1 = require("@clack/prompts");
+const picocolors_1 = require("picocolors");
+const modelina_cli_1 = require("@asyncapi/modelina-cli");
+const models_flags_1 = require("../../internal/flags/generate/models.flags");
+const proxy_flags_1 = require("../../internal/flags/proxy.flags");
+const validation_service_1 = require("../../../../domains/services/validation.service");
+class Models extends base_1.default {
+    constructor() {
+        super(...arguments);
+        this.validationService = new validation_service_1.ValidationService();
+    }
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { args, flags } = yield this.parse(Models);
+            let { language, file } = args;
+            let { output } = flags;
+            const { proxyPort, proxyHost } = flags;
+            const interactive = !flags['no-interactive'];
+            if (!interactive) {
+                (0, prompts_1.intro)((0, picocolors_1.inverse)('AsyncAPI Generate Models'));
+                const parsedArgs = yield this.parseArgs(args, output);
+                language = parsedArgs.language;
+                file = parsedArgs.file;
+                output = parsedArgs.output;
+            }
+            if (proxyHost && proxyPort) {
+                const proxyUrl = `http://${proxyHost}:${proxyPort}`;
+                file = `${file}+${proxyUrl}`;
+            }
+            const inputFile = (yield (0, SpecificationFile_1.load)(file)) || (yield (0, SpecificationFile_1.load)());
+            const result = yield this.validationService.parseDocument(inputFile, {}, flags);
+            if (!result.success) {
+                this.error(`Failed to parse the AsyncAPI document: ${result.error}`, {
+                    exit: 1,
+                });
+            }
+            else if (!result.data) {
+                this.error('No data returned from parsing the AsyncAPI document.', {
+                    exit: 1,
+                });
+            }
+            const { document, diagnostics, status } = result.data;
+            if (!document || status === 'invalid') {
+                const severityErrors = diagnostics.filter((obj) => obj.severity === 0);
+                this.log(`Input is not a correct AsyncAPI document so it cannot be processed.${this.validationService.formatDiagnosticsOutput(severityErrors, 'stylish', 'error')}`);
+                return;
+            }
+            if (flags['log-diagnostics'] && inputFile) {
+                this.handleGovernanceMessage(inputFile, diagnostics, status);
+                this.log(this.validationService.formatDiagnosticsOutput(diagnostics, flags['diagnostics-format'], flags['fail-severity']));
+            }
+            const logger = {
+                info: (message) => {
+                    this.log(message);
+                },
+                debug: (message) => {
+                    this.debug(message);
+                },
+                warn: (message) => {
+                    this.warn(message);
+                },
+                error: (message) => {
+                    this.error(message);
+                },
+            };
+            const s = (0, prompts_1.spinner)();
+            s.start('Generating models...');
+            try {
+                const generatedModels = yield (0, modelina_cli_1.generateModels)(Object.assign(Object.assign({}, flags), { output }), document, logger, language);
+                if (output && output !== 'stdout') {
+                    const generatedModelStrings = generatedModels.map((model) => {
+                        return model.modelName;
+                    });
+                    s.stop((0, picocolors_1.green)(`Successfully generated the following models: ${generatedModelStrings.join(', ')}`));
+                    return;
+                }
+                const generatedModelStrings = generatedModels.map((model) => {
+                    return `
+  ## Model name: ${model.modelName}
+  ${model.result}
+        `;
+                });
+                s.stop((0, picocolors_1.green)(`Successfully generated the following models: ${generatedModelStrings.join('\n')}`));
+            }
+            catch (error) {
+                s.stop((0, picocolors_1.green)('Failed to generate models'));
+                if (error instanceof Error) {
+                    this.error(error.message);
+                }
+                else {
+                    this.error('An unknown error occurred during model generation.');
+                }
+            }
+        });
+    }
+    parseArgs(args, output) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let { language, file } = args;
+            let askForOutput = false;
+            const operationCancelled = 'Operation cancelled by the user.';
+            if (!language) {
+                language = yield (0, prompts_1.select)({
+                    message: 'Select the language you want to generate models for',
+                    options: Object.keys(modelina_cli_1.Languages).map((key) => ({
+                        value: key,
+                        label: key,
+                        hint: modelina_cli_1.Languages[key],
+                    })),
+                });
+                askForOutput = true;
+            }
+            if ((0, prompts_1.isCancel)(language)) {
+                (0, prompts_1.cancel)(operationCancelled);
+                this.exit();
+            }
+            if (!file) {
+                file = yield (0, prompts_1.text)({
+                    message: 'Enter the path or URL to the AsyncAPI document',
+                    defaultValue: 'asyncapi.yaml',
+                    placeholder: 'asyncapi.yaml',
+                });
+                askForOutput = true;
+            }
+            if ((0, prompts_1.isCancel)(file)) {
+                (0, prompts_1.cancel)(operationCancelled);
+                this.exit();
+            }
+            if (!output && askForOutput) {
+                output = (yield (0, prompts_1.text)({
+                    message: 'Enter the output directory or stdout to write the models to',
+                    defaultValue: 'stdout',
+                    placeholder: 'stdout',
+                }));
+            }
+            if ((0, prompts_1.isCancel)(output)) {
+                (0, prompts_1.cancel)(operationCancelled);
+                this.exit();
+            }
+            return { language, file, output: output !== null && output !== void 0 ? output : 'stdout' };
+        });
+    }
+    handleGovernanceMessage(document, diagnostics, status) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const sourceString = document.toSourceString();
+            const hasIssues = diagnostics && diagnostics.length > 0;
+            const isFailSeverity = status === validation_service_1.ValidationStatus.INVALID;
+            const governanceMessage = this.validationService.generateGovernanceMessage(sourceString, hasIssues, isFailSeverity);
+            if (isFailSeverity) {
+                this.logToStderr(governanceMessage);
+            }
+            else {
+                this.log(governanceMessage);
+            }
+        });
+    }
+}
+Models.description = 'Generates typed models';
+Models.args = modelina_cli_1.ModelinaArgs;
+Models.flags = Object.assign(Object.assign({}, (0, models_flags_1.modelsFlags)()), (0, proxy_flags_1.proxyFlags)());
+exports.default = Models;

package/lib/apps/cli/commands/new/file.d.ts

@@ -0,0 +1,16 @@
+import Command from '../../internal/base';
+export default class NewFile extends Command {
+    static description: string;
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        'file-name': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        example: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        studio: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        port: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'no-tty': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+    runInteractive(): Promise<void>;
+    createAsyncapiFile(fileName: string, selectedTemplate: string): Promise<void>;
+}

package/lib/apps/cli/commands/new/file.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const base_1 = tslib_1.__importDefault(require("../../internal/base"));
+const inquirer = tslib_1.__importStar(require("inquirer"));
+const Studio_1 = require("../../../../domains/models/Studio");
+const path_1 = require("path");
+const SpecificationFile_1 = require("../../../../domains/models/SpecificationFile");
+const picocolors_1 = require("picocolors");
+const file_flags_1 = require("../../internal/flags/new/file.flags");
+const { writeFile, readFile } = fs_1.promises;
+const DEFAULT_ASYNCAPI_FILE_NAME = 'asyncapi.yaml';
+const DEFAULT_ASYNCAPI_YAML_TEMPLATE = 'default-example.yaml';
+const DEFAULT_ASYNCAPI_JSON_TEMPLATE = 'default-example.json';
+function loadExampleFile() {
+    const exampleFiles = (0, fs_1.readFileSync)((0, path_1.resolve)(__dirname, '../../../../../assets/examples/examples.json'), { encoding: 'utf8' });
+    return JSON.parse(exampleFiles);
+}
+function getExamplesFlagDescription() {
+    const examples = loadExampleFile();
+    let description = 'name of the example to use. Available examples are:';
+    for (const example of examples) {
+        description += `\n\t - ${example.value}`;
+    }
+    return description;
+}
+class NewFile extends base_1.default {
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { flags } = yield this.parse(NewFile); // NOSONAR
+            const isTTY = process.stdout.isTTY;
+            if (!flags['no-tty'] && isTTY) {
+                return this.runInteractive();
+            }
+            const fileName = flags['file-name'] || DEFAULT_ASYNCAPI_FILE_NAME;
+            // Determine template based on file extension
+            let default_template;
+            if (fileName.endsWith('.json')) {
+                default_template = DEFAULT_ASYNCAPI_JSON_TEMPLATE;
+            }
+            else {
+                default_template = DEFAULT_ASYNCAPI_YAML_TEMPLATE;
+            }
+            const template = flags['example'] || default_template;
+            yield this.createAsyncapiFile(fileName, template);
+            if (flags.studio) {
+                if (isTTY) {
+                    (0, Studio_1.start)(fileName, flags.port || Studio_1.DEFAULT_PORT);
+                }
+                else {
+                    this.warn('Warning: --studio flag was passed but the terminal is not interactive. Ignoring...');
+                }
+            }
+        });
+    }
+    /* eslint-disable sonarjs/cognitive-complexity */
+    runInteractive() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // NOSONAR
+            const { flags } = yield this.parse(NewFile); // NOSONAR
+            let fileName = flags['file-name'];
+            let selectedTemplate = flags['example'];
+            let openStudio = flags.studio;
+            let examples = [];
+            const questions = [];
+            if (!fileName) {
+                questions.push({
+                    name: 'filename',
+                    message: 'name of the file?',
+                    type: 'input',
+                    default: DEFAULT_ASYNCAPI_FILE_NAME,
+                });
+            }
+            try {
+                const exampleFiles = yield readFile((0, path_1.resolve)(__dirname, '../../assets/examples/examples.json'), { encoding: 'utf8' });
+                examples = JSON.parse(exampleFiles);
+            }
+            catch (error) {
+                // no examples found
+            }
+            if (!selectedTemplate && examples.length > 0) {
+                questions.push({
+                    name: 'use-example',
+                    message: 'would you like to start your new file from one of our examples?',
+                    type: 'confirm',
+                    default: true,
+                });
+                questions.push({
+                    type: 'list',
+                    name: 'selectedTemplate',
+                    message: 'What example would you like to use?',
+                    choices: examples,
+                    when: (answers) => {
+                        return answers['use-example'];
+                    },
+                });
+            }
+            if (openStudio === undefined) {
+                questions.push({
+                    name: 'studio',
+                    message: 'open in Studio?',
+                    type: 'confirm',
+                    default: true,
+                });
+            }
+            if (questions.length) {
+                const answers = yield inquirer.prompt(questions);
+                if (!fileName) {
+                    fileName = answers.filename;
+                }
+                if (!selectedTemplate) {
+                    selectedTemplate = answers.selectedTemplate;
+                }
+                if (openStudio === undefined) {
+                    openStudio = answers.studio;
+                }
+            }
+            fileName = fileName || DEFAULT_ASYNCAPI_FILE_NAME;
+            // Determine template based on file extension
+            let default_template;
+            if (fileName.endsWith('.json')) {
+                default_template = DEFAULT_ASYNCAPI_JSON_TEMPLATE;
+            }
+            else {
+                default_template = DEFAULT_ASYNCAPI_YAML_TEMPLATE;
+            }
+            selectedTemplate = selectedTemplate || default_template;
+            yield this.createAsyncapiFile(fileName, selectedTemplate);
+            fileName = fileName.includes('.') ? fileName : `${fileName}.yaml`;
+            if (openStudio) {
+                (0, Studio_1.start)(fileName, flags.port || Studio_1.DEFAULT_PORT);
+            }
+        });
+    }
+    createAsyncapiFile(fileName, selectedTemplate) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const asyncApiFile = yield readFile((0, path_1.resolve)(__dirname, '../../../../../assets/examples/', selectedTemplate), { encoding: 'utf8' });
+            let fileNameToWriteToDisk;
+            if (!fileName.includes('.')) {
+                fileNameToWriteToDisk = `${fileName}.yaml`;
+            }
+            else {
+                const extension = fileName.split('.')[1];
+                if (extension === 'yml' || extension === 'yaml' || extension === 'json') {
+                    fileNameToWriteToDisk = fileName;
+                }
+                else {
+                    console.log('CLI Support only yml, yaml and json extension for file');
+                    return;
+                }
+            }
+            try {
+                const content = yield readFile(fileNameToWriteToDisk, {
+                    encoding: 'utf8',
+                });
+                if (content !== undefined) {
+                    console.log(`A file named ${fileNameToWriteToDisk} already exists. Please choose a different name.`);
+                    return;
+                }
+            }
+            catch (e) {
+                if (e.code === 'EACCES') {
+                    this.error('Permission has been denied to access the file.');
+                }
+            }
+            yield writeFile(fileNameToWriteToDisk, asyncApiFile, { encoding: 'utf8' });
+            console.log(`The ${(0, picocolors_1.cyan)(fileNameToWriteToDisk)} has been successfully created.`);
+            this.specFile = yield (0, SpecificationFile_1.load)(fileNameToWriteToDisk);
+            this.metricsMetadata.selected_template = selectedTemplate;
+        });
+    }
+}
+NewFile.description = 'Creates a new asyncapi file';
+NewFile.flags = (0, file_flags_1.fileFlags)(getExamplesFlagDescription());
+NewFile.examples = [
+    'asyncapi new\t - start creation of a file in interactive mode',
+    'asyncapi new --file-name=my-asyncapi.yaml --example=default-example.yaml --no-tty\t - create a new file with a specific name, using one of the examples and without interactive mode',
+];
+exports.default = NewFile;

package/lib/apps/cli/commands/new/index.d.ts

@@ -0,0 +1,5 @@
+import Command from '../../internal/base';
+export default class New extends Command {
+    static readonly description = "Create a new AsyncAPI project, specification files, or templates for clients and applications.";
+    run(): Promise<void>;
+}

package/lib/apps/cli/commands/new/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const base_1 = tslib_1.__importDefault(require("../../internal/base"));
+const core_1 = require("@oclif/core");
+class New extends base_1.default {
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const help = new core_1.Help(this.config);
+            help.showHelp(['new', '--help']);
+        });
+    }
+}
+New.description = 'Create a new AsyncAPI project, specification files, or templates for clients and applications.';
+exports.default = New;

package/lib/apps/cli/commands/new/template.d.ts

@@ -0,0 +1,18 @@
+import Command from '../../internal/base';
+export declare const successMessage: (projectName: string) => string;
+export default class template extends Command {
+    static description: string;
+    protected commandName: string;
+    static readonly successMessage: (projectName: string) => string;
+    static readonly errorMessages: {
+        alreadyExists: (projectName: string) => string;
+    };
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        template: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        file: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'force-write': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/apps/cli/commands/new/template.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.successMessage = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const base_1 = tslib_1.__importDefault(require("../../internal/base"));
+const path_1 = require("path");
+const SpecificationFile_1 = require("../../../../domains/models/SpecificationFile");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const template_flags_1 = require("../../internal/flags/new/template.flags");
+const picocolors_1 = require("picocolors");
+const jsonfile_1 = tslib_1.__importDefault(require("jsonfile"));
+const path_2 = tslib_1.__importDefault(require("path"));
+const successMessage = (projectName) => `🎉 Your template is succesfully created
+⏩ Next steps: follow the instructions ${(0, picocolors_1.cyan)('below')} to manage your project:
+
+  cd ${projectName}\t\t ${(0, picocolors_1.gray)('# Navigate to the project directory')}
+  npm install\t\t ${(0, picocolors_1.gray)('# Install the project dependencies')}
+  asyncapi generate fromTemplate <templateName> ../${projectName} \t\t ${(0, picocolors_1.gray)('# Execute the template from anasyncapi document')}
+
+You can also open the project in your favourite editor and start tweaking it.
+`;
+exports.successMessage = successMessage;
+const errorMessages = {
+    alreadyExists: (projectName) => `Unable to create the project because the directory "${(0, picocolors_1.cyan)(projectName)}" already exists at "${process.cwd()}/${projectName}".
+To specify a different name for the new project, please run the command below with a unique project name:
+
+    ${(0, picocolors_1.gray)('asyncapi new template --name ') + (0, picocolors_1.gray)(projectName) + (0, picocolors_1.gray)('-1')}`,
+};
+class template extends base_1.default {
+    constructor() {
+        super(...arguments);
+        this.commandName = 'template';
+    }
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { flags } = yield this.parse(template); // NOSONAR
+            const { name: projectName, template: templateName } = flags;
+            const PROJECT_DIRECTORY = (0, path_1.join)(process.cwd(), projectName);
+            const templateDirectory = (0, path_1.resolve)(__dirname, '../../../../../assets/create-template/templates/', templateName);
+            {
+                try {
+                    yield fs_1.promises.mkdir(PROJECT_DIRECTORY);
+                }
+                catch (err) {
+                    switch (err.code) {
+                        case 'EEXIST':
+                            this.error(errorMessages.alreadyExists(projectName));
+                            break;
+                        case 'EACCES':
+                            this.error(`Unable to create the project. We tried to access the "${PROJECT_DIRECTORY}" directory but it was not possible due to file access permissions. Please check the write permissions of your current working directory ("${process.cwd()}").`);
+                            break;
+                        case 'EPERM':
+                            this.error(`Unable to create the project. We tried to create the "${PROJECT_DIRECTORY}" directory but the operation requires elevated privileges. Please check the privileges for your current user.`);
+                            break;
+                        default:
+                            this.error(`Unable to create the project. Please check the following message for further info about the error:\n\n${err}`);
+                    }
+                }
+                try {
+                    yield copyAndModify(templateDirectory, PROJECT_DIRECTORY, projectName);
+                    this.log((0, exports.successMessage)(projectName));
+                }
+                catch (err) {
+                    this.error(`Unable to create the project. Please check the following message for further info about the error:\n\n${err}`);
+                }
+                this.specFile = yield (0, SpecificationFile_1.load)(`${templateDirectory}/asyncapi.yaml`);
+                this.metricsMetadata.template = flags.template;
+            }
+        });
+    }
+}
+template.description = 'Creates a new template';
+template.successMessage = exports.successMessage;
+template.errorMessages = errorMessages;
+template.flags = (0, template_flags_1.templateFlags)();
+exports.default = template;
+function copyAndModify(templateDirectory, PROJECT_DIRECTORY, projectName) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const packageJsonPath = path_2.default.join(templateDirectory, 'package.json');
+        try {
+            yield fs_extra_1.default.copy(templateDirectory, PROJECT_DIRECTORY, {
+                filter: (src) => {
+                    return !src.endsWith('package.json');
+                },
+            });
+            const packageData = yield jsonfile_1.default.readFile(packageJsonPath);
+            if (packageData.generator && 'renderer' in packageData.generator) {
+                packageData.generator.renderer = 'react';
+            }
+            if (packageData.name) {
+                packageData.name = projectName;
+            }
+            yield fs_extra_1.default.writeJSON(`${PROJECT_DIRECTORY}/package.json`, packageData, {
+                spaces: 2,
+            });
+        }
+        catch (err) {
+            console.error('Error:', err);
+        }
+    });
+}