@alagoni97/cli 0.72.1

package/dist/commands/init.js

@@ -0,0 +1,544 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable sonarjs/no-duplicate-string */
+/* eslint-disable sonarjs/no-collapsible-if */
+/* eslint-disable prefer-const */
+const core_1 = require("@oclif/core");
+const promises_1 = require("node:fs/promises");
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+// eslint-disable-next-line @typescript-eslint/no-require-imports, no-undef
+const inquirer = require('inquirer');
+const generators_1 = require("../codegen/generators");
+const gitignore_1 = require("../utils/gitignore");
+const telemetry_1 = require("../telemetry");
+const base_1 = require("./base");
+const ConfigOptions = ['esm', 'json', 'yaml', 'ts'];
+const LanguageOptions = ['typescript'];
+const map = {
+    inputFile: {
+        description: 'File path for the code generation input such as AsyncAPI document'
+    },
+    configName: {
+        description: 'The name to use for the configuration file (dont include file extension)',
+        default: 'codegen'
+    },
+    outputDirectory: {
+        description: 'Output configuration location, path to where the configuration file should be located. If relative path, the current working directory of the terminal will be used'
+    },
+    configType: {
+        description: `The type of configuration file. 'esm', 'ts' can do everything, 'json' and 'yaml' is more restrictive. Read more here: https://github.com/the-codegen-project/cli/blob/main/docs/configurations.md`,
+        options: ConfigOptions,
+        default: 'esm'
+    }
+};
+class Init extends base_1.BaseCommand {
+    static description = 'Initialize The Codegen Project in your project';
+    static args = {};
+    static flags = {
+        help: core_1.Flags.help(),
+        verbose: core_1.Flags.boolean({
+            char: 'v',
+            description: 'Show detailed output'
+        }),
+        quiet: core_1.Flags.boolean({
+            char: 'q',
+            description: 'Only show errors and warnings'
+        }),
+        'no-color': core_1.Flags.boolean({
+            description: 'Disable colored output'
+        }),
+        'input-file': core_1.Flags.file({
+            description: map.inputFile.description
+        }),
+        'config-name': core_1.Flags.file({
+            description: map.configName.description,
+            default: map.configName.default
+        }),
+        'input-type': core_1.Flags.string({
+            description: 'Input file type',
+            options: ['asyncapi', 'openapi']
+        }),
+        'output-directory': core_1.Flags.string({
+            description: map.outputDirectory.description,
+            default: './'
+        }),
+        'config-type': core_1.Flags.string({
+            description: map.configType.description,
+            options: map.configType.options,
+            default: map.configType.default
+        }),
+        languages: core_1.Flags.string({
+            description: 'Which languages do you wish to generate code for?',
+            options: LanguageOptions
+        }),
+        'no-tty': core_1.Flags.boolean({
+            description: 'Do not use an interactive terminal'
+        }),
+        'include-payloads': core_1.Flags.boolean({
+            description: 'Include payloads generation, available for TypeScript',
+            relationships: [
+                {
+                    flags: [
+                        {
+                            name: 'languages',
+                            when: async (flags) => flags['languages'] === 'typescript'
+                        },
+                        {
+                            name: 'input-type',
+                            when: async (flags) => flags['input-type'] === 'asyncapi'
+                        }
+                    ],
+                    type: 'all'
+                }
+            ]
+        }),
+        'include-headers': core_1.Flags.boolean({
+            description: 'Include headers generation, available for TypeScript',
+            relationships: [
+                {
+                    flags: [
+                        {
+                            name: 'languages',
+                            when: async (flags) => flags['languages'] === 'typescript'
+                        },
+                        {
+                            name: 'input-type',
+                            when: async (flags) => flags['input-type'] === 'asyncapi'
+                        }
+                    ],
+                    type: 'all'
+                }
+            ]
+        }),
+        'include-client': core_1.Flags.boolean({
+            description: 'Include client generation, available for TypeScript',
+            relationships: [
+                {
+                    flags: [
+                        {
+                            name: 'languages',
+                            when: async (flags) => flags['languages'] === 'typescript'
+                        },
+                        {
+                            name: 'input-type',
+                            when: async (flags) => flags['input-type'] === 'asyncapi'
+                        }
+                    ],
+                    type: 'all'
+                }
+            ]
+        }),
+        'include-parameters': core_1.Flags.boolean({
+            description: 'Include parameters generation, available for TypeScript',
+            relationships: [
+                {
+                    flags: [
+                        {
+                            name: 'languages',
+                            when: async (flags) => flags['languages'] === 'typescript'
+                        },
+                        {
+                            name: 'input-type',
+                            when: async (flags) => flags['input-type'] === 'asyncapi'
+                        }
+                    ],
+                    type: 'all'
+                }
+            ]
+        }),
+        'include-channels': core_1.Flags.boolean({
+            description: 'Include channels generation, available for TypeScript',
+            relationships: [
+                {
+                    flags: [
+                        {
+                            name: 'languages',
+                            when: async (flags) => flags['languages'] === 'typescript'
+                        },
+                        {
+                            name: 'input-type',
+                            when: async (flags) => flags['input-type'] === 'asyncapi'
+                        }
+                    ],
+                    type: 'all'
+                }
+            ]
+        }),
+        'no-output': core_1.Flags.boolean({
+            description: 'For testing only, ignore',
+            hidden: true
+        }),
+        'gitignore-generated': core_1.Flags.boolean({
+            description: 'Add generated output directories to .gitignore'
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(Init);
+        // Configure logger based on flags
+        this.setupLogger(flags);
+        // eslint-disable-next-line no-undef
+        const isTTY = process.stdout.isTTY;
+        const realizedFlags = this.realizeFlags(flags);
+        if (!flags['no-tty'] && isTTY) {
+            return this.runInteractive(realizedFlags);
+        }
+        await this.createConfiguration(realizedFlags);
+    }
+    realizeConfigFile(flags) {
+        // eslint-disable-next-line no-undef
+        const processCurrentDir = process.cwd();
+        return path_1.default.resolve(processCurrentDir, flags.outputDirectory, `${flags.configName}.${flags.configType}`);
+    }
+    realizeFlags(flags) {
+        const inputFile = flags['input-file'];
+        const inputType = flags['input-type'];
+        const configName = flags['config-name'];
+        const configType = flags['config-type'];
+        const outputDirectory = flags['output-directory'];
+        const includePayloads = flags['include-payloads'];
+        const includeHeaders = flags['include-headers'];
+        const includeClient = flags['include-client'];
+        const includeParameters = flags['include-parameters'];
+        const includeChannels = flags['include-channels'];
+        const languages = flags['languages'];
+        const noOutput = flags['no-output'];
+        const gitignoreGenerated = flags['gitignore-generated'];
+        return {
+            includeChannels,
+            includeParameters,
+            includePayloads,
+            includeHeaders,
+            includeClient,
+            outputDirectory,
+            configName,
+            inputFile,
+            inputType,
+            configType,
+            languages,
+            noOutput,
+            gitignoreGenerated
+        };
+    }
+    /**
+     * Interactively ask the user for which configuration to create
+     */
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    async runInteractive(flags) {
+        let { includeChannels, includeParameters, includePayloads, includeHeaders, includeClient, configName, outputDirectory, inputFile, inputType, configType, languages, noOutput, gitignoreGenerated } = flags;
+        const questions = [];
+        questions.push({
+            name: 'configName',
+            message: map.configName.description,
+            default: map.configName.default,
+            type: 'input'
+        });
+        if (!inputFile) {
+            questions.push({
+                name: 'inputFile',
+                message: map.inputFile.description,
+                type: 'input'
+            });
+        }
+        if (!inputType) {
+            questions.push({
+                name: 'inputType',
+                message: 'Type of the input file to generate code from',
+                type: 'list',
+                choices: [
+                    {
+                        name: 'asyncapi',
+                        checked: true,
+                        value: 'asyncapi',
+                        line: 'AsyncAPI document'
+                    },
+                    {
+                        name: 'openapi',
+                        checked: false,
+                        value: 'openapi',
+                        line: 'OpenAPI document'
+                    }
+                ]
+            });
+        }
+        questions.push({
+            name: 'configType',
+            message: 'Type of configuration?',
+            type: 'list',
+            choices: [
+                {
+                    name: 'esm',
+                    checked: true,
+                    value: 'esm',
+                    line: 'ESM JavaScript style configuration, enables all features'
+                },
+                {
+                    name: 'json',
+                    value: 'json',
+                    line: 'JSON style configuration, enables most features'
+                },
+                {
+                    name: 'yaml',
+                    value: 'yaml',
+                    line: 'YAML style configuration, enables most features'
+                },
+                {
+                    name: 'ts',
+                    value: 'ts',
+                    line: 'TS style configuration, enables all features'
+                }
+            ]
+        });
+        if (!languages) {
+            questions.push({
+                name: 'languages',
+                message: 'Which language do you wish generate for?',
+                type: 'list',
+                choices: [
+                    {
+                        name: 'typescript',
+                        checked: true,
+                        value: 'typescript',
+                        line: 'Generate TypeScript'
+                    }
+                ]
+            });
+        }
+        if (!includeClient) {
+            questions.push({
+                name: 'includeClient',
+                message: 'Do you want to include client wrapper?',
+                type: 'confirm',
+                when: (answers) => answers.languages === 'typescript' && answers.inputType === 'asyncapi'
+            });
+        }
+        if (!includePayloads) {
+            questions.push({
+                name: 'includePayloads',
+                message: 'Do you want to include payload structures?',
+                type: 'confirm',
+                when: (answers) => answers.languages === 'typescript' && answers.inputType === 'asyncapi'
+            });
+        }
+        if (!includeHeaders) {
+            questions.push({
+                name: 'includeHeaders',
+                message: 'Do you want to include headers structures?',
+                type: 'confirm',
+                when: (answers) => answers.languages === 'typescript' && answers.inputType === 'asyncapi'
+            });
+        }
+        if (!includeParameters) {
+            questions.push({
+                name: 'includeParameters',
+                message: 'Do you want to include parameters structures?',
+                type: 'confirm',
+                when: (answers) => answers.languages === 'typescript' && answers.inputType === 'asyncapi'
+            });
+        }
+        if (!includeChannels) {
+            questions.push({
+                name: 'includeChannels',
+                message: 'Do you want to include helper functions for interacting with channels?',
+                type: 'confirm',
+                when: (answers) => answers.languages === 'typescript' && answers.inputType === 'asyncapi'
+            });
+        }
+        questions.push({
+            name: 'gitignoreGenerated',
+            message: 'GitIgnore generated files?',
+            type: 'confirm',
+            default: true
+        });
+        if (questions.length) {
+            const answers = await inquirer.prompt(questions);
+            configType = answers.configType;
+            includeChannels ??= answers.includeChannels;
+            includeParameters ??= answers.includeParameters;
+            includePayloads ??= answers.includePayloads;
+            includeHeaders ??= answers.includeHeaders;
+            includeClient ??= answers.includeClient;
+            inputFile ??= answers.inputFile;
+            inputType ??= answers.inputType;
+            configName ??= answers.configName;
+            languages ??= answers.languages;
+            gitignoreGenerated ??= answers.gitignoreGenerated;
+        }
+        await this.createConfiguration({
+            configType,
+            includeChannels,
+            includeParameters,
+            includePayloads,
+            includeHeaders,
+            includeClient,
+            inputFile,
+            inputType,
+            languages,
+            noOutput,
+            configName,
+            outputDirectory,
+            gitignoreGenerated
+        });
+    }
+    /**
+     * Based on the flags, create the appropriate configuration file
+     */
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    async createConfiguration(flags) {
+        const configuration = {
+            inputType: flags.inputType,
+            inputPath: flags.inputFile,
+            language: flags.languages,
+            generators: []
+        };
+        if (flags.includeChannels) {
+            if (flags.languages === 'typescript' && flags.inputType === 'asyncapi') {
+                const generator = { ...generators_1.defaultTypeScriptChannelsGenerator };
+                delete generator.dependencies;
+                delete generator.id;
+                delete generator.language;
+                delete generator.parameterGeneratorId;
+                delete generator.payloadGeneratorId;
+                configuration.generators.push(generator);
+            }
+        }
+        if (flags.includePayloads) {
+            if (flags.languages === 'typescript' && flags.inputType === 'asyncapi') {
+                const generator = { ...generators_1.defaultTypeScriptPayloadGenerator };
+                delete generator.dependencies;
+                delete generator.id;
+                delete generator.language;
+                configuration.generators.push(generator);
+            }
+        }
+        if (flags.includeHeaders) {
+            if (flags.languages === 'typescript' && flags.inputType === 'asyncapi') {
+                const generator = { ...generators_1.defaultTypeScriptHeadersOptions };
+                delete generator.dependencies;
+                delete generator.id;
+                delete generator.language;
+                configuration.generators.push(generator);
+            }
+        }
+        if (flags.includeClient) {
+            if (flags.languages === 'typescript' && flags.inputType === 'asyncapi') {
+                const generator = { ...generators_1.defaultTypeScriptClientGenerator };
+                delete generator.dependencies;
+                delete generator.id;
+                delete generator.language;
+                delete generator.channelsGeneratorId;
+                configuration.generators.push(generator);
+            }
+        }
+        // eslint-disable-next-line sonarjs/no-collapsible-if
+        if (flags.includeParameters) {
+            if (flags.languages === 'typescript' && flags.inputType === 'asyncapi') {
+                const generator = { ...generators_1.defaultTypeScriptParametersOptions };
+                delete generator.dependencies;
+                delete generator.id;
+                delete generator.language;
+                configuration.generators.push(generator);
+            }
+        }
+        let fileOutput = '';
+        let fileExtension = 'mjs';
+        if (flags.configType === 'json') {
+            fileExtension = 'json';
+            fileOutput = JSON.stringify({
+                $schema: 'https://raw.githubusercontent.com/the-codegen-project/cli/main/schemas/configuration-schema-0.json',
+                ...configuration
+            }, null, 2);
+        }
+        else if (flags.configType === 'yaml') {
+            fileExtension = 'yaml';
+            fileOutput = `# yaml-language-server: $schema=https://raw.githubusercontent.com/the-codegen-project/cli/main/schemas/configuration-schema-0.json
+${yaml_1.default.stringify(configuration)}`;
+        }
+        else if (flags.configType === 'esm') {
+            const stringifiedConfiguration = JSON.stringify(configuration, null, 2);
+            const unquotedConfiguration = stringifiedConfiguration.replace(/"([^"]+)":/g, '$1:');
+            fileOutput = `/** @type {import("@the-codegen-project/cli").TheCodegenConfiguration} **/
+export default ${unquotedConfiguration};`;
+        }
+        else if (flags.configType === 'ts') {
+            fileExtension = 'ts';
+            const stringifiedConfiguration = JSON.stringify(configuration, null, 2);
+            const unquotedConfiguration = stringifiedConfiguration.replace(/"([^"]+)":/g, '$1:');
+            fileOutput = `import { TheCodegenConfiguration } from '@the-codegen-project/cli';
+const config: TheCodegenConfiguration = ${unquotedConfiguration};
+export default config;`;
+        }
+        const outputPath = this.realizeConfigFile(flags);
+        let outputFilePath = path_1.default.parse(outputPath);
+        outputFilePath = path_1.default.resolve(outputFilePath.dir, `${outputFilePath.name}.${fileExtension}`);
+        if (flags.noOutput) {
+            this.log(`${outputFilePath}: ${fileOutput}`);
+        }
+        else {
+            await (0, promises_1.writeFile)(outputFilePath, fileOutput);
+        }
+        this.log(`Successfully created your sparkling new generation file at ${outputFilePath}`);
+        // Handle .gitignore updates
+        if (flags.gitignoreGenerated && !flags.noOutput) {
+            const outputPaths = [];
+            // Collect all output paths from enabled generators
+            if (flags.includeChannels) {
+                outputPaths.push(generators_1.defaultTypeScriptChannelsGenerator.outputPath);
+            }
+            if (flags.includePayloads) {
+                outputPaths.push(generators_1.defaultTypeScriptPayloadGenerator.outputPath);
+            }
+            if (flags.includeHeaders) {
+                outputPaths.push(generators_1.defaultTypeScriptHeadersOptions.outputPath);
+            }
+            if (flags.includeClient) {
+                outputPaths.push(generators_1.defaultTypeScriptClientGenerator.outputPath);
+            }
+            if (flags.includeParameters) {
+                outputPaths.push(generators_1.defaultTypeScriptParametersOptions.outputPath);
+            }
+            if (outputPaths.length > 0) {
+                const result = await (0, gitignore_1.updateGitignore)(outputPaths);
+                if (result.success) {
+                    this.log(result.message);
+                }
+                else {
+                    this.log(`Warning: ${result.message}`);
+                }
+            }
+        }
+        await this.handleSuccessfulInitTelemetry(flags);
+    }
+    async handleSuccessfulInitTelemetry(flags) {
+        // Track init completion (non-blocking, never throws)
+        const enabledGenerators = [];
+        if (flags.includePayloads) {
+            enabledGenerators.push('payloads');
+        }
+        if (flags.includeParameters) {
+            enabledGenerators.push('parameters');
+        }
+        if (flags.includeHeaders) {
+            enabledGenerators.push('headers');
+        }
+        if (flags.includeChannels) {
+            enabledGenerators.push('channels');
+        }
+        if (flags.includeClient) {
+            enabledGenerators.push('client');
+        }
+        // Track init completion (fire and forget, never throws)
+        (0, telemetry_1.trackEvent)({
+            event: 'init_executed',
+            config_type: flags.configType,
+            input_type: flags.inputType,
+            generators: enabledGenerators.length > 0 ? enabledGenerators.join(',') : 'none',
+            language: flags.languages,
+            completed: true
+        });
+    }
+}
+exports.default = Init;

package/dist/commands/telemetry.d.ts

@@ -0,0 +1,25 @@
+import { BaseCommand } from './base';
+export default class Telemetry extends BaseCommand {
+    static description: string;
+    static args: {
+        action: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        'no-color': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+    /**
+     * Show telemetry status
+     */
+    private showStatus;
+    /**
+     * Enable telemetry
+     */
+    private enableTelemetry;
+    /**
+     * Disable telemetry
+     */
+    private disableTelemetry;
+}

package/dist/commands/telemetry.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-undef */
+const core_1 = require("@oclif/core");
+const LoggingInterface_1 = require("../LoggingInterface");
+const config_1 = require("../telemetry/config");
+const PersistedConfig_1 = require("../PersistedConfig");
+const base_1 = require("./base");
+const picocolors_1 = __importDefault(require("picocolors"));
+class Telemetry extends base_1.BaseCommand {
+    static description = 'Manage telemetry settings';
+    static args = {
+        action: core_1.Args.string({
+            description: 'Action to perform: status, enable, or disable',
+            required: true,
+            options: ['status', 'enable', 'disable']
+        })
+    };
+    static flags = {
+        help: core_1.Flags.help(),
+        'no-color': core_1.Flags.boolean({
+            description: 'Disable colored output'
+        })
+    };
+    static examples = [
+        '<%= config.bin %> <%= command.id %> status',
+        '<%= config.bin %> <%= command.id %> enable',
+        '<%= config.bin %> <%= command.id %> disable'
+    ];
+    async run() {
+        const { args, flags } = await this.parse(Telemetry);
+        // Configure logger based on flags
+        this.setupLogger(flags);
+        const { action } = args;
+        const useColors = !flags['no-color'];
+        try {
+            switch (action) {
+                case 'status':
+                    await this.showStatus(useColors);
+                    break;
+                case 'enable':
+                    await this.enableTelemetry(useColors);
+                    break;
+                case 'disable':
+                    await this.disableTelemetry(useColors);
+                    break;
+                default:
+                    this.error(`Unknown action: ${action}. Use status, enable, or disable.`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(`Failed to ${action} telemetry: ${message}`);
+        }
+    }
+    /**
+     * Show telemetry status
+     */
+    async showStatus(useColors) {
+        const enabled = await (0, config_1.isTelemetryEnabled)();
+        const config = await (0, config_1.getTelemetryConfig)();
+        const configPath = (0, PersistedConfig_1.getConfigFilePath)();
+        const c = useColors
+            ? picocolors_1.default
+            : {
+                cyan: (s) => s,
+                green: (s) => s,
+                red: (s) => s,
+                dim: (s) => s
+            };
+        LoggingInterface_1.Logger.info(`\n${c.cyan('┌─────────────────────────────────────────────┐')}`);
+        LoggingInterface_1.Logger.info(`${c.cyan('│')}         Telemetry Status                    ${c.cyan('│')}`);
+        LoggingInterface_1.Logger.info(`${c.cyan('└─────────────────────────────────────────────┘')}\n`);
+        LoggingInterface_1.Logger.info(`Status: ${enabled ? c.green('ENABLED') : c.red('DISABLED')}`);
+        LoggingInterface_1.Logger.info(`\nConfig file: ${c.dim(configPath)}`);
+        LoggingInterface_1.Logger.info(`Anonymous ID: ${c.dim(config.anonymousId)}`);
+        LoggingInterface_1.Logger.info(`Endpoint: ${c.dim(config.endpoint)}`);
+        LoggingInterface_1.Logger.info('\nWhat we collect:');
+        LoggingInterface_1.Logger.info(`  ${c.green('✓')} Command usage and flags`);
+        LoggingInterface_1.Logger.info(`  ${c.green('✓')} Generator types used`);
+        LoggingInterface_1.Logger.info(`  ${c.green('✓')} Input source types (remote/local)`);
+        LoggingInterface_1.Logger.info(`  ${c.green('✓')} CLI version and Node.js version`);
+        LoggingInterface_1.Logger.info(`  ${c.green('✓')} Error categories (not error messages)`);
+        LoggingInterface_1.Logger.info("\nWhat we DON'T collect:");
+        LoggingInterface_1.Logger.info(`  ${c.red('✗')} File paths or file names`);
+        LoggingInterface_1.Logger.info(`  ${c.red('✗')} File contents`);
+        LoggingInterface_1.Logger.info(`  ${c.red('✗')} Personal information`);
+        LoggingInterface_1.Logger.info(`  ${c.red('✗')} Project names`);
+        LoggingInterface_1.Logger.info(`\nLearn more: ${c.cyan('https://the-codegen-project.org/docs/telemetry')}\n`);
+    }
+    /**
+     * Enable telemetry
+     */
+    async enableTelemetry(useColors) {
+        await (0, config_1.setTelemetryEnabled)(true);
+        const c = useColors ? picocolors_1.default : { cyan: (s) => s };
+        LoggingInterface_1.Logger.info('✅ Telemetry enabled');
+        LoggingInterface_1.Logger.info('\nThank you for helping us improve The Codegen Project!');
+        LoggingInterface_1.Logger.info(`Learn more: ${c.cyan('https://the-codegen-project.org/docs/telemetry')}\n`);
+    }
+    /**
+     * Disable telemetry
+     */
+    async disableTelemetry(useColors) {
+        await (0, config_1.setTelemetryEnabled)(false);
+        const c = useColors ? picocolors_1.default : { dim: (s) => s };
+        LoggingInterface_1.Logger.info('✅ Telemetry disabled');
+        LoggingInterface_1.Logger.info('\nYou can re-enable telemetry anytime with:');
+        LoggingInterface_1.Logger.info(`  ${c.dim('codegen telemetry enable')}\n`);
+    }
+}
+exports.default = Telemetry;