tao

#!/bin/node

const path = require('node:path');
const fs = require('node:fs');
const args = process.argv.splice(2);
const pc = require('picocolors');

const modelsDir = path.join(__dirname, 'src/app/Models');
const commandsDir = path.join(__dirname, 'src/app/Commands/commands');

const help = () => {
    console.log(`${pc.bold('Welcome to Tao CLI. This is the list of commands avaiable:')}`);
    console.table({
        newModel: {
            name: 'new Model',
            options: 'name',
            description: 'Creates a new Model Module',
            example: 'new Model User'
        },
        newCommand: {
            name: 'new Command',
            options: 'name',
            description: 'Creates a new Command',
            example: 'new Command ping'
        }
    });
}

const validateNew = () => {
    if (args[2] === undefined) {
        console.error(pc.red(` Expected 3 args. Given ${args.length} args `));
        process.exit();
    }
}

const commandTemplate = (CommandName) => `import { SlashCommandBuilder, ChatInputCommandInteraction } from "discord.js";

export default {
    data: new SlashCommandBuilder()
        .setName("${CommandName}")
        .setDescription("${CommandName}'s description"),
    async execute(interaction: ChatInputCommandInteraction) {
        await interaction.reply("here is the reply");
    },
}`;

const modelTemplate = (ModelName) => `export class ${ModelName}Entity {
    id: string;

    constructor(${ModelName.toLowerCase()}: {id: string}) {
        this.id = ${ModelName.toLowerCase()}.id;
    }

    public static ${ModelName.toLowerCase()}FromPrisma(${ModelName.toLowerCase()}: { id: string }): ${ModelName}Entity {
        return new ${ModelName}Entity(${ModelName.toLowerCase()});
    }
}`;

const repositoryTemplate = (ModelName) => `import { ${ModelName}Entity } from "..";

export abstract class I${ModelName}Repository {
    abstract get(condition?: { where: object }): Promise<${ModelName}Entity[] | null>;
    abstract getById(id: string): Promise<${ModelName}Entity | null>;
    abstract create(entity: ${ModelName}Entity): Promise<${ModelName}Entity | null>;
    abstract update(id: string, entity: ${ModelName}Entity): Promise<${ModelName}Entity | null>;
    abstract deleteById(id: string): Promise<${ModelName}Entity | null>;
    abstract delete(condition?: { where: object }): Promise<void>;
}

export class ${ModelName}Repository extends I${ModelName}Repository {

    constructor(private readonly ${ModelName.toLowerCase()}Service: I${ModelName}Repository) {
        super()
    }

    async get(condition?: { where: object, include?: {} } | undefined): Promise<${ModelName}Entity[] | ${ModelName}Entity | null> {
        return (await this.${ModelName.toLowerCase()}Service.get(condition));
    }

    async getById(id: string): Promise<${ModelName}Entity | null> {
        return (await this.${ModelName.toLowerCase()}Service.getById(id));
    }

    async create(entity: ${ModelName}Entity): Promise<${ModelName}Entity | null> {
        return (await this.${ModelName.toLowerCase()}Service.create(entity));
    }

    async update(id: string, entity: ${ModelName}Entity): Promise<${ModelName}Entity | null> {
        return (await this.${ModelName.toLowerCase()}Service.update(id, entity));
    }

    async deleteById(id: string): Promise<${ModelName}Entity | null> {
        return (await this.${ModelName.toLowerCase()}Service.deleteById(id));
    }

    async delete(condition?: { where: object; } | undefined): Promise<void> {
        await this.${ModelName.toLowerCase()}Service.delete(condition);
    }
}`;

const indexModelTemplate = (ModelName) => `import { ${ModelName}Entity } from "./Entity/${ModelName}Entity";
import { ${ModelName}Repository, I${ModelName}Repository } from "./Repositories/${ModelName}Repository";

export {
    ${ModelName}Entity,
    ${ModelName}Repository,
    I${ModelName}Repository,
}`;

const makeCommand = (CommandName) => {
    CommandName = CommandName.toLowerCase();
    fs.writeFileSync(path.join(commandsDir, `${CommandName}.ts`), commandTemplate(CommandName), { encoding: 'utf-8' });
}

const makeModel = (ModelName) => {
    const modelDir = path.join(modelsDir, ModelName);
    fs.mkdirSync(path.join(modelDir, 'Entity'), { recursive: true });
    fs.writeFileSync(path.join(modelDir, 'Entity', `${ModelName}Entity.ts`), modelTemplate(ModelName), { encoding: 'utf-8' });
    fs.mkdirSync(path.join(modelDir, 'Repositories'), { recursive: true });
    fs.writeFileSync(path.join(modelDir, 'Repositories', `${ModelName}Repository.ts`), repositoryTemplate(ModelName), { encoding: 'utf-8' });
    fs.writeFileSync(path.join(modelDir, 'index.ts'), indexModelTemplate(ModelName), { encoding: 'utf-8' });
    fs.mkdirSync(path.join(modelDir, 'Services'), { recursive: true });
}

if (args[0] === undefined || args[0] === 'help') {
    help();
}

if (args[0] === 'new') {
    validateNew();
    switch (args[1]) {
        case 'Model':
            makeModel(args[2]);
            console.log(pc.green(`${args[2]} Module created succesfully`));
            break;
        case 'Command':
            makeCommand(args[2]);
            console.log(pc.green(`${args[2]} Command created succesfully`));
            break;
        default:
            console.error(pc.red(`${args[1]} is not a valid command`));
            console.log(pc.magenta('Use "node tao help" to get the list of commands'));
    }
}