dscaffold/dist/commands/generate.js

A TypeScript framework for scaffolding modular Discord bot projects with dynamic command and event loading

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateCommand = generateCommand;
const inquirer_1 = __importDefault(require("inquirer"));
const path_1 = __importDefault(require("path"));
const utils_1 = require("../utils");
const CommandGenerator_1 = require("../generators/CommandGenerator");
const EventGenerator_1 = require("../generators/EventGenerator");
const SchemaGenerator_1 = require("../generators/SchemaGenerator");
async function generateCommand(type, name, options) {
    try {
        const currentDir = (0, utils_1.getCurrentWorkingDir)();
        const packageJsonPath = path_1.default.join(currentDir, 'package.json');
        // Check if we're in a valid Discord bot project
        if (!(await (0, utils_1.pathExists)(packageJsonPath))) {
            utils_1.Logger.error('This command must be run in a Discord bot project directory');
            utils_1.Logger.info('Run "dscaffold create" to create a new project first');
            return;
        }
        const spinner = utils_1.Logger.spinner(`Generating ${type}: ${name}...`);
        spinner.start();
        let generator;
        switch (type) {
            case 'command':
                generator = new CommandGenerator_1.CommandGenerator({
                    name,
                    category: options?.category || 'general',
                    description: options?.description || `${name} command`,
                    isSlash: options?.slash || false,
                });
                break;
            case 'event':
                generator = new EventGenerator_1.EventGenerator({
                    name,
                    once: options?.once || false,
                });
                break;
            case 'schema':
                const schemaOptions = await getSchemaOptions(name, options);
                generator = new SchemaGenerator_1.SchemaGenerator(schemaOptions);
                break;
            default:
                throw new Error(`Unknown generator type: ${type}`);
        }
        await generator.generate(currentDir);
        spinner.stop();
        utils_1.Logger.success(`${type.charAt(0).toUpperCase() + type.slice(1)} "${name}" generated successfully!`);
    }
    catch (error) {
        utils_1.Logger.error(`Failed to generate ${type}: ${error instanceof Error ? error.message : 'Unknown error'}`);
        process.exit(1);
    }
}
async function getSchemaOptions(name, options) {
    const answers = await inquirer_1.default.prompt([
        {
            type: 'list',
            name: 'type',
            message: 'Choose database type:',
            choices: [
                { name: 'Mongoose (MongoDB)', value: 'mongoose' },
                { name: 'Prisma (SQL)', value: 'prisma' },
                { name: 'Sequelize (SQL)', value: 'sequelize' },
            ],
            default: options?.type || 'mongoose',
        },
        {
            type: 'input',
            name: 'fields',
            message: 'Enter field definitions (format: name:type:required, separated by commas):',
            default: 'id:string:true,name:string:true,createdAt:date:true',
            validate: (input) => {
                try {
                    const fields = input.split(',').map(field => {
                        const [name, type, required] = field.trim().split(':');
                        if (!name || !type) {
                            throw new Error('Invalid field format');
                        }
                        return { name, type, required: required === 'true' };
                    });
                    return fields.length > 0 || 'At least one field is required';
                }
                catch {
                    return 'Invalid field format. Use: name:type:required (e.g., id:string:true)';
                }
            },
        },
    ]);
    const fields = answers.fields.split(',').map((field) => {
        const [fieldName, type, required] = field.trim().split(':');
        return {
            name: fieldName,
            type,
            required: required === 'true',
        };
    });
    return {
        name,
        type: answers.type,
        fields,
    };
}
//# sourceMappingURL=generate.js.map