jarvis-arch-hexagonal-gen 1.0.0

package/.create-resource.json

@@ -0,0 +1,6 @@
+{
+  "pluginsDir": "src/plugins",
+  "templatesDir": "templates",
+  "outputDir": "src/modules",
+  "defaultPlugin": "resource"
+}

package/README.md

@@ -0,0 +1,74 @@
+folder/
+├── package.json
+├── tsconfig.json
+├── README.md
+├── bin/
+│   └── create-resource.js       # Ponto de entrada da CLI
+├── src/
+│   ├── core/
+│   │   ├── Generator.ts    # Motor principal (renderiza templates + executa hooks)
+│   │   ├── PluginManager.ts # Carrega plugins e resolve dependências
+│   │   ├── Parser.ts       # Converte "Product" → metadados enriquecidos
+│   │   └── HookRunner.ts   # Executa hooks (pré/pós geração)
+│   ├── cli/
+│   │   ├── index.ts        # Comandos da CLI (generate, init, list)
+│   │   └── commands/
+│   │       ├── generate.ts
+│   │       ├── init.ts
+│   │       └── list.ts
+│   ├── plugins/            # Plugins nativos (cada um com manifesto + templates + hooks)
+│   │   ├── dto/
+│   │   │   ├── manifest.json
+│   │   │   ├── templates/
+│   │   │   │   ├── create.ejs
+│   │   │   │   └── update.ejs
+│   │   │   └── hooks.ts
+│   │   ├── controller/
+│   │   │   ├── manifest.json
+│   │   │   ├── templates/
+│   │   │   │   └── controller.ejs
+│   │   │   └── hooks.ts
+│   │   ├── repository/
+│   │   │   ├── manifest.json
+│   │   │   ├── templates/
+│   │   │   │   ├── interface.ejs
+│   │   │   │   └── repository.ejs
+│   │   │   └── hooks.ts
+│   │   ├── usecases/
+│   │   │   ├── manifest.json
+│   │   │   ├── templates/
+│   │   │   │   ├── create.ejs
+│   │   │   │   ├── update.ejs
+│   │   │   │   ├── delete.ejs
+│   │   │   │   ├── find-by-id.ejs
+│   │   │   │   └── find-all.ejs
+│   │   │   └── hooks.ts
+│   │   ├── routes/
+│   │   │   ├── manifest.json
+│   │   │   ├── templates/
+│   │   │   │   └── routes.ejs
+│   │   │   └── hooks.ts
+│   │   ├── tests/
+│   │   │   ├── manifest.json
+│   │   │   ├── templates/
+│   │   │   │   ├── usecase.spec.ejs
+│   │   │   │   └── integration.ejs
+│   │   │   └── hooks.ts
+│   │   ├── swagger/
+│   │   │   ├── manifest.json
+│   │   │   ├── templates/
+│   │   │   │   └── swagger.ejs
+│   │   │   └── hooks.ts
+│   │   └── bundles/          # Combinações de plugins (ex: resource, crud)
+│   │       ├── resource/
+│   │       │   ├── manifest.json   # extends: [dto, controller, repository, routes, tests]
+│   │       │   └── hooks.ts
+│   │       └── crud/
+│   │           ├── manifest.json   # extends: [resource, swagger]
+│   │           └── hooks.ts
+│   └── utils/
+│       ├── file-system.ts
+│       └── logger.ts
+└── templates/               # Templates globais (opcionais, podem ser usados por vários plugins)
+    └── shared/
+        └── header.ejs

package/bin/create-resource.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+// Carrega o módulo principal
+const { main } = require('../dist/cli');
+
+// Executa a CLI com os argumentos da linha de comando
+main().catch((error) => {
+  console.error('❌ Erro fatal:', error.message);
+  process.exit(1);
+});

package/dist/.create-resource.json

@@ -0,0 +1,6 @@
+{
+  "pluginsDir": "dist/plugins",
+  "templatesDir": "templates",
+  "outputDir": "src/",
+  "defaultPlugin": "resource"
+}

package/dist/cli/commands/generate.js

@@ -0,0 +1,33 @@
+"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;
+// src/cli/commands/generate.ts
+const generator_1 = require("../../core/generator");
+const parser_1 = require("../../core/parser");
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../../utils/config");
+async function generateCommand(plugin, entity, options) {
+    let columns = [];
+    if (options.fields) {
+        columns = options.fields.split(',').map((field) => {
+            const [name, type] = field.split(':');
+            return { name, type: type || 'string' };
+        });
+    }
+    const metadata = (0, parser_1.parseEntity)(entity, { columns });
+    // Lê configuração
+    const config = (0, config_1.loadConfig)();
+    const pluginsDir = config.pluginsDir || 'src/plugins';
+    const generator = new generator_1.Generator(path_1.default.join(process.cwd(), pluginsDir));
+    try {
+        await generator.generate(plugin, metadata, options);
+        console.log('✨ Geração concluída!');
+    }
+    catch (error) {
+        console.error('❌ Erro:', error.message);
+        process.exit(1);
+    }
+}

package/dist/cli/commands/init.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+/**
+ * Inicializa um novo projeto com a estrutura mínima necessária para usar o gerador.
+ * Cria pastas, arquivos de exemplo e instala dependências recomendadas.
+ */
+async function initCommand() {
+    const cwd = process.cwd();
+    const folders = [
+        'src/modules',
+        'src/shared',
+        'tests/unit',
+        'tests/integration',
+        'plugins',
+    ];
+    console.log(chalk_1.default.bold.blue('\n🚀 Inicializando projeto com create-api...\n'));
+    // 1. Cria estrutura de pastas
+    for (const folder of folders) {
+        const fullPath = path_1.default.join(cwd, folder);
+        if (!fs_extra_1.default.existsSync(fullPath)) {
+            fs_extra_1.default.ensureDirSync(fullPath);
+            console.log(chalk_1.default.green(`✅ Criado: ${folder}`));
+        }
+        else {
+            console.log(chalk_1.default.gray(`ℹ️  Já existe: ${folder}`));
+        }
+    }
+    // 2. Cria um arquivo de configuração .create-api.json
+    const configPath = path_1.default.join(cwd, '.create-api.json');
+    if (!fs_extra_1.default.existsSync(configPath)) {
+        const defaultConfig = {
+            pluginsDir: 'plugins',
+            templatesDir: 'templates',
+            outputDir: 'src/modules',
+            defaultPlugin: 'resource',
+        };
+        fs_extra_1.default.writeJsonSync(configPath, defaultConfig, { spaces: 2 });
+        console.log(chalk_1.default.green('✅ Criado: .create-api.json'));
+    }
+    else {
+        console.log(chalk_1.default.gray('ℹ️  .create-api.json já existe.'));
+    }
+    // 3. Cria um exemplo de plugin (opcional, mas didático)
+    const examplePluginDir = path_1.default.join(cwd, 'plugins', 'example');
+    if (!fs_extra_1.default.existsSync(examplePluginDir)) {
+        fs_extra_1.default.ensureDirSync(examplePluginDir);
+        fs_extra_1.default.ensureDirSync(path_1.default.join(examplePluginDir, 'templates'));
+        // Manifesto exemplo
+        const manifestExample = {
+            name: 'example',
+            description: 'Exemplo de plugin para demonstrar a estrutura',
+            dependencies: [],
+            files: [
+                {
+                    template: 'hello.ejs',
+                    output: 'src/modules/<%= route %>/hello.txt',
+                },
+            ],
+        };
+        fs_extra_1.default.writeJsonSync(path_1.default.join(examplePluginDir, 'manifest.json'), manifestExample, { spaces: 2 });
+        // Template exemplo
+        const templateContent = 'Olá, <%= entity %>! Este é um template de exemplo.';
+        fs_extra_1.default.writeFileSync(path_1.default.join(examplePluginDir, 'templates', 'hello.ejs'), templateContent);
+        console.log(chalk_1.default.green('✅ Criado plugin de exemplo: plugins/example'));
+    }
+    else {
+        console.log(chalk_1.default.gray('ℹ️  Plugin de exemplo já existe.'));
+    }
+    // 4. (Opcional) Instala dependências básicas
+    console.log(chalk_1.default.yellow('\n📦 Instalando dependências recomendadas...'));
+    try {
+        (0, child_process_1.execSync)('npm install -D typescript @types/node ts-node ejs fs-extra chalk text-table commander', {
+            stdio: 'inherit',
+            cwd,
+        });
+        console.log(chalk_1.default.green('✅ Dependências instaladas.'));
+    }
+    catch (error) {
+        console.warn(chalk_1.default.yellow('⚠️  Falha ao instalar dependências. Faça manualmente:'));
+        console.warn('   npm install -D typescript @types/node ts-node ejs fs-extra chalk text-table commander');
+    }
+    // 5. Cria um script de exemplo no package.json
+    const pkgPath = path_1.default.join(cwd, 'package.json');
+    if (fs_extra_1.default.existsSync(pkgPath)) {
+        const pkg = fs_extra_1.default.readJsonSync(pkgPath);
+        if (!pkg.scripts)
+            pkg.scripts = {};
+        if (!pkg.scripts['generate']) {
+            pkg.scripts['generate'] = 'create-api generate';
+            fs_extra_1.default.writeJsonSync(pkgPath, pkg, { spaces: 2 });
+            console.log(chalk_1.default.green('✅ Adicionado script "generate" ao package.json'));
+        }
+    }
+    else {
+        console.warn(chalk_1.default.yellow('⚠️  package.json não encontrado. Crie um com "npm init -y".'));
+    }
+    console.log(chalk_1.default.bold.green('\n✨ Projeto inicializado com sucesso!\n'));
+    console.log(chalk_1.default.cyan('Próximos passos:'));
+    console.log('  1. Crie seus próprios plugins em plugins/');
+    console.log('  2. Gere artefatos com:');
+    console.log(`     ${chalk_1.default.white('create-api generate resource Product')}`);
+    console.log('  3. Ou use:');
+    console.log(`     ${chalk_1.default.white('npm run generate resource Product')}\n`);
+}

package/dist/cli/commands/list.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCommand = listCommand;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const text_table_1 = __importDefault(require("text-table"));
+/**
+ * Lista todos os plugins disponíveis, exibindo nome, descrição e dependências.
+ */
+async function listCommand() {
+    const pluginsDir = path_1.default.join(__dirname, '../../../plugins');
+    if (!fs_extra_1.default.existsSync(pluginsDir)) {
+        console.error(chalk_1.default.red('❌ Diretório de plugins não encontrado.'));
+        console.error(chalk_1.default.yellow('Execute `create-api init` para criar a estrutura.'));
+        process.exit(1);
+    }
+    const pluginFolders = fs_extra_1.default.readdirSync(pluginsDir).filter((item) => {
+        const stat = fs_extra_1.default.statSync(path_1.default.join(pluginsDir, item));
+        return stat.isDirectory() && !item.startsWith('.');
+    });
+    if (pluginFolders.length === 0) {
+        console.log(chalk_1.default.yellow('⚠️  Nenhum plugin encontrado.'));
+        return;
+    }
+    console.log(chalk_1.default.bold.blue('\n📦 Plugins disponíveis:\n'));
+    const rows = [
+        [chalk_1.default.bold('Nome'), chalk_1.default.bold('Descrição'), chalk_1.default.bold('Dependências')],
+    ];
+    for (const folder of pluginFolders) {
+        const manifestPath = path_1.default.join(pluginsDir, folder, 'manifest.json');
+        if (!fs_extra_1.default.existsSync(manifestPath)) {
+            continue;
+        }
+        try {
+            const manifest = fs_extra_1.default.readJsonSync(manifestPath);
+            const name = chalk_1.default.green(folder);
+            const description = manifest.description || '';
+            const deps = (manifest.dependencies || []).join(', ') || '—';
+            rows.push([name, description, deps]);
+        }
+        catch (error) {
+            // Ignora manifestos inválidos
+        }
+    }
+    console.log((0, text_table_1.default)(rows, { align: ['l', 'l', 'l'] }));
+    console.log(`\n💡 Use: ${chalk_1.default.cyan('create-api generate <plugin> <Entity>')}`);
+}

package/dist/cli/index.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const generate_1 = require("./commands/generate");
+const init_1 = require("./commands/init");
+const list_1 = require("./commands/list");
+const program = new commander_1.Command();
+program
+    .name('create-api')
+    .description('Gerador de código baseado em plugins')
+    .version('1.0.0');
+program
+    .command('generate <plugin> <entity>')
+    .description('Gera artefatos usando um plugin')
+    .option('--swagger', 'Inclui documentação Swagger')
+    .option('--fields <fields>', 'Define campos (ex: name:string age:number)')
+    .action(generate_1.generateCommand);
+program
+    .command('init')
+    .description('Inicializa um projeto com exemplos')
+    .action(init_1.initCommand);
+program
+    .command('list')
+    .description('Lista todos os plugins disponíveis')
+    .action(list_1.listCommand);
+program.parse(process.argv);

package/dist/core/generator.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Generator = void 0;
+// src/core/Generator.ts
+const ejs_1 = __importDefault(require("ejs"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const plugin_manager_1 = require("./plugin-manager");
+const hook_runner_1 = require("./hook-runner");
+class Generator {
+    constructor(pluginsDir) {
+        const defaultPluginsDir = path_1.default.join(process.cwd(), 'src', 'plugins');
+        this.pluginManager = new plugin_manager_1.PluginManager(pluginsDir || defaultPluginsDir);
+        this.hookRunner = new hook_runner_1.HookRunner();
+    }
+    async generate(pluginName, metadata, options = {}) {
+        const plugin = this.pluginManager.load(pluginName);
+        if (!plugin)
+            throw new Error(`Plugin "${pluginName}" não encontrado`);
+        // Executa dependências primeiro (se houver)
+        if (plugin.dependencies && plugin.dependencies.length > 0) {
+            for (const dep of plugin.dependencies) {
+                await this.generate(dep, metadata, options);
+            }
+        }
+        // Executa hooks pré (do plugin atual)
+        if (plugin.hooks?.pre) {
+            await this.hookRunner.run(plugin.hooks.pre, metadata, options);
+        }
+        // Processa os arquivos do plugin
+        for (const file of plugin.files || []) {
+            if (file.condition && !this.evaluateCondition(file.condition, options)) {
+                continue;
+            }
+            const outputPath = ejs_1.default.render(file.output, { ...metadata, ...options });
+            const fullOutputPath = path_1.default.join(process.cwd(), outputPath);
+            const templatePath = path_1.default.join(plugin.templatesDir, file.template);
+            if (!fs_extra_1.default.existsSync(templatePath)) {
+                console.warn(`⚠️  Template não encontrado: ${templatePath}`);
+                continue;
+            }
+            const templateContent = await fs_extra_1.default.readFile(templatePath, 'utf-8');
+            const rendered = ejs_1.default.render(templateContent, { ...metadata, ...options });
+            await fs_extra_1.default.ensureDir(path_1.default.dirname(fullOutputPath));
+            await fs_extra_1.default.writeFile(fullOutputPath, rendered);
+            console.log(`✅ Gerado: ${outputPath}`);
+        }
+        // Executa hooks pós
+        if (plugin.hooks?.post) {
+            await this.hookRunner.run(plugin.hooks.post, metadata, options);
+        }
+    }
+    /**
+     * Avalia se um arquivo deve ser gerado com base na condição definida
+     * no manifesto e nas opções fornecidas pelo usuário.
+     *
+     * Atualmente são suportados os seguintes operadores:
+     *
+     * - equals:
+     *   Compara o valor de uma opção com um valor esperado.
+     *
+     *   Exemplo:
+     *   {
+     *     option: "swagger",
+     *     equals: true
+     *   }
+     *
+     *   options:
+     *   {
+     *     swagger: true
+     *   }
+     *
+     *   Resultado: true
+     *
+     * ------------------------------------------------------------
+     *
+     * - in:
+     *   Verifica se o valor da opção pertence a uma lista de valores.
+     *
+     *   Exemplo:
+     *   {
+     *     option: "orm",
+     *     in: ["typeorm", "prisma"]
+     *   }
+     *
+     *   options:
+     *   {
+     *     orm: "typeorm"
+     *   }
+     *
+     *   Resultado: true
+     *
+     * ------------------------------------------------------------
+     *
+     * O retorno possui a seguinte semântica:
+     *
+     * true  -> A condição foi satisfeita e o arquivo será gerado.
+     * false -> A condição não foi satisfeita e o arquivo será ignorado.
+     *
+     * Recomenda-se lançar uma exceção quando a condição possuir um formato
+     * desconhecido, evitando que manifestos inválidos passem despercebidos.
+     *
+     * @param condition Condição declarada no manifesto.
+     * @param options Opções informadas pelo usuário durante a execução da CLI.
+     * @returns `true` quando o arquivo deve ser gerado; caso contrário, `false`.
+     * @throws Error Quando o formato da condição não é suportado.
+     */
+    evaluateCondition(condition, options) {
+        if ("equals" in condition) {
+            return options[condition.option] === condition.equals;
+        }
+        if ("in" in condition) {
+            return condition.in.includes(options[condition.option]);
+        }
+        throw new Error(`Unsupported condition: ${JSON.stringify(condition)}`);
+    }
+}
+exports.Generator = Generator;

package/dist/core/hook-runner.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookRunner = void 0;
+class HookRunner {
+    async run(hookFunction, metadata, options) {
+        // O hookFunction pode ser o nome da função exportada no hooks.ts
+        // ou um caminho para um script.
+        // Para simplificar, assumimos que está no mesmo plugin.
+        // Implementação real pode usar require dinâmico.
+        console.log(`⏳ Executando hook: ${hookFunction}`);
+        // ...
+    }
+}
+exports.HookRunner = HookRunner;

package/dist/core/parser.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEntity = parseEntity;
+function parseEntity(entityName, options = {}) {
+    const entity = entityName.charAt(0).toUpperCase() + entityName.slice(1);
+    const entityLower = entity.toLowerCase();
+    const plural = entity + 's';
+    const pluralLower = plural.toLowerCase();
+    const route = pluralLower;
+    const table = `tb_${pluralLower}`;
+    // Colunas podem vir das opções ou de um schema
+    const columns = options.columns || [
+        { name: 'id', type: 'number', primary: true },
+        { name: 'name', type: 'string' },
+        { name: 'createdAt', type: 'Date' },
+        { name: 'updatedAt', type: 'Date' },
+    ];
+    return { entity, entityName: entity, entityLower, plural, pluralLower, route, table, columns };
+}

package/dist/core/plugin-manager.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginManager = void 0;
+// src/core/PluginManager.ts
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+class PluginManager {
+    constructor(pluginsDir) {
+        this.cache = new Map();
+        this.pluginsDir = pluginsDir;
+    }
+    load(pluginName) {
+        if (this.cache.has(pluginName))
+            return this.cache.get(pluginName);
+        const foundPath = this.findPluginPath(pluginName);
+        if (!foundPath) {
+            throw new Error(`Manifest não encontrado para o plugin "${pluginName}"`);
+        }
+        const manifestPath = path_1.default.join(foundPath, 'manifest.json');
+        const manifest = fs_extra_1.default.readJsonSync(manifestPath);
+        const templatesDir = path_1.default.join(foundPath, 'templates');
+        let hooks = null;
+        const hooksPath = path_1.default.join(foundPath, 'hooks.ts');
+        if (fs_extra_1.default.existsSync(hooksPath)) {
+            try {
+                hooks = require(hooksPath);
+            }
+            catch {
+                // ignora
+            }
+        }
+        const plugin = {
+            ...manifest,
+            templatesDir,
+            hooks,
+            path: foundPath,
+        };
+        this.cache.set(pluginName, plugin);
+        return plugin;
+    }
+    findPluginPath(pluginName) {
+        const search = (dir) => {
+            const items = fs_extra_1.default.readdirSync(dir);
+            for (const item of items) {
+                const fullPath = path_1.default.join(dir, item);
+                const stat = fs_extra_1.default.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    if (item === pluginName && fs_extra_1.default.existsSync(path_1.default.join(fullPath, 'manifest.json'))) {
+                        return fullPath;
+                    }
+                    const found = search(fullPath);
+                    if (found)
+                        return found;
+                }
+            }
+            return null;
+        };
+        return search(this.pluginsDir);
+    }
+}
+exports.PluginManager = PluginManager;

package/dist/plugins/bundles/crud/hooks.js

@@ -0,0 +1 @@
+"use strict";

package/dist/plugins/bundles/crud/manifest.json

@@ -0,0 +1,6 @@
+{
+  "name": "crud",
+  "description": "Gera CRUD com Swagger",
+  "dependencies": ["resource", "swagger"],
+  "files": []
+}

package/dist/plugins/bundles/resource/hooks.js

@@ -0,0 +1 @@
+"use strict";

package/dist/plugins/bundles/resource/manifest.json

@@ -0,0 +1,6 @@
+{
+  "name": "resource",
+  "description": "Gera um CRUD completo",
+  "dependencies": ["dto", "controller", "repository", "usecases", "routes", "tests"],
+  "files": []
+}

package/dist/plugins/controller/hooks.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRoutes = registerRoutes;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+async function registerRoutes(metadata, options) {
+    const routesFile = path_1.default.join(process.cwd(), 'src/routes/index.ts');
+    if (await fs_extra_1.default.pathExists(routesFile)) {
+        const content = await fs_extra_1.default.readFile(routesFile, 'utf-8');
+        const newImport = `import { ${metadata.entity}Controller } from '../modules/${metadata.route}/${metadata.entity}Controller';\n`;
+        const newRoute = `router.use('/${metadata.route}', ${metadata.entity}Controller);\n`;
+        if (!content.includes(newImport)) {
+            await fs_extra_1.default.appendFile(routesFile, `\n${newImport}${newRoute}`);
+            console.log(`📝 Registrada rota em routes/index.ts`);
+        }
+    }
+}

package/dist/plugins/controller/manifest.json

@@ -0,0 +1,14 @@
+{
+  "name": "controller",
+  "description": "Gera um controller CRUD",
+  "dependencies": ["dto"],
+  "files": [
+    {
+      "template": "controller.ejs",
+      "output": "src/adapters/inbound/controllers/<%= entity %>Controller.ts"
+    }
+  ],
+  "hooks": {
+    "post": "registerRoutes"
+  }
+}

package/dist/plugins/controller/templates/controller.ejs

@@ -0,0 +1,66 @@
+import { Request, Response } from 'express';
+import { Create<%= entity %>UseCase } from '../usecases/create-<%= entityLower %>.usecase';
+import { Update<%= entity %>UseCase } from '../usecases/update-<%= entityLower %>.usecase';
+import { Delete<%= entity %>UseCase } from '../usecases/delete-<%= entityLower %>.usecase';
+import { Find<%= entity %>ByIdUseCase } from '../usecases/find-<%= entityLower %>-by-id.usecase';
+import { FindAll<%= plural %>UseCase } from '../usecases/find-all-<%= pluralLower %>.usecase';
+
+export class <%= entity %>Controller {
+  constructor(
+    private readonly createUseCase: Create<%= entity %>UseCase,
+    private readonly updateUseCase: Update<%= entity %>UseCase,
+    private readonly deleteUseCase: Delete<%= entity %>UseCase,
+    private readonly findByIdUseCase: Find<%= entity %>ByIdUseCase,
+    private readonly findAllUseCase: FindAll<%= plural %>UseCase
+  ) {}
+
+  async create(req: Request, res: Response): Promise<Response> {
+    try {
+      const data = req.body;
+      const result = await this.createUseCase.execute(data);
+      return res.status(201).json(result);
+    } catch (error: any) {
+      return res.status(400).json({ error: error.message });
+    }
+  }
+
+  async update(req: Request, res: Response): Promise<Response> {
+    try {
+      const id = Number(req.params.id);
+      const data = req.body;
+      const result = await this.updateUseCase.execute(id, data);
+      return res.json(result);
+    } catch (error: any) {
+      return res.status(400).json({ error: error.message });
+    }
+  }
+
+  async delete(req: Request, res: Response): Promise<Response> {
+    try {
+      const id = Number(req.params.id);
+      await this.deleteUseCase.execute(id);
+      return res.status(204).send();
+    } catch (error: any) {
+      return res.status(400).json({ error: error.message });
+    }
+  }
+
+  async findById(req: Request, res: Response): Promise<Response> {
+    try {
+      const id = Number(req.params.id);
+      const result = await this.findByIdUseCase.execute(id);
+      return res.json(result);
+    } catch (error: any) {
+      return res.status(404).json({ error: error.message });
+    }
+  }
+
+  async findAll(req: Request, res: Response): Promise<Response> {
+    try {
+      const result = await this.findAllUseCase.execute();
+      return res.json(result);
+    } catch (error: any) {
+      return res.status(500).json({ error: error.message });
+    }
+  }
+}

package/dist/plugins/dto/hooks.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preGenerate = preGenerate;
+exports.postGenerate = postGenerate;
+function preGenerate(metadata, options) {
+    console.log(`📦 Preparando DTOs para ${metadata.entity}`);
+}
+function postGenerate(metadata, options) {
+    // Pode atualizar um arquivo central de exportação
+    // ou instalar dependências, etc.
+}

package/dist/plugins/dto/manifest.json

@@ -0,0 +1,19 @@
+{
+  "name": "dto",
+  "description": "Gera DTOs de criação e atualização",
+  "dependencies": [],
+  "files": [
+    {
+      "template": "create.ejs",
+      "output": "src/core/dtos/create-<%= route %>.dto.ts"
+    },
+    {
+      "template": "update.ejs",
+      "output": "src/core/dtos/update-<%= route %>.dto.ts"
+    }
+  ],
+  "hooks": {
+    "pre": "preGenerate",
+    "post": "postGenerate"
+  }
+}

package/dist/plugins/dto/templates/create.ejs

@@ -0,0 +1,11 @@
+export class Create<%= entityName %>Dto {
+
+<% columns
+.filter(c => !c.generated)
+.forEach(column => { %>
+
+    <%= column.name %>: <%= column.type %>;
+
+<% }) %>
+
+}

package/dist/plugins/dto/templates/update.ejs

@@ -0,0 +1,11 @@
+export class Update<%= entityName %>Dto {
+
+<% columns
+.filter(c => !c.generated)
+.forEach(column => { %>
+
+    <%= column.name %>?: <%= column.type %>;
+
+<% }) %>
+
+}

package/dist/plugins/repository/hooks.js

@@ -0,0 +1 @@
+"use strict";

package/dist/plugins/repository/manifest.json

@@ -0,0 +1,15 @@
+{
+  "name": "repository",
+  "description": "Gera interface e implementação do repositório para uma entidade",
+  "dependencies": [],
+  "files": [
+    {
+      "template": "interface.ejs",
+      "output": "src/core/ports/outbound/repositories/I<%= entity %>Repository.ts"
+    },
+    {
+      "template": "repository.ejs",
+      "output": "src/adapters/outbound/persistence/typeorm/repositories/<%= entity %>Repository.ts"
+    }
+  ]
+}

package/dist/plugins/repository/templates/interface.ejs

@@ -0,0 +1,9 @@
+import { <%= entity %> } from '../entities/<%= entityLower %>.entity';
+
+export interface I<%= entity %>Repository {
+  create(data: Omit<<%= entity %>, 'id'>): Promise<<%= entity %>>;
+  update(id: number, data: Partial<<%= entity %>>): Promise<<%= entity %>>;
+  delete(id: number): Promise<void>;
+  findById(id: number): Promise<<%= entity %> | null>;
+  findAll(): Promise<<%= entity %>[]>;
+}

package/dist/plugins/repository/templates/repository.ejs

@@ -0,0 +1,38 @@
+import { <%= entity %> } from '../entities/<%= entityLower %>.entity';
+import { I<%= entity %>Repository } from './I<%= entity %>Repository';
+
+export class <%= entity %>Repository implements I<%= entity %>Repository {
+  private items: <%= entity %>[] = [];
+  private currentId = 1;
+
+  async create(data: Omit<<%= entity %>, 'id'>): Promise<<%= entity %>> {
+    const newItem: <%= entity %> = {
+      id: this.currentId++,
+      ...data,
+    } as <%= entity %>;
+    this.items.push(newItem);
+    return newItem;
+  }
+
+  async update(id: number, data: Partial<<%= entity %>>): Promise<<%= entity %>> {
+    const index = this.items.findIndex(item => item.id === id);
+    if (index === -1) throw new Error('<%= entity %> not found');
+    const updated = { ...this.items[index], ...data };
+    this.items[index] = updated;
+    return updated;
+  }
+
+  async delete(id: number): Promise<void> {
+    const index = this.items.findIndex(item => item.id === id);
+    if (index === -1) throw new Error('<%= entity %> not found');
+    this.items.splice(index, 1);
+  }
+
+  async findById(id: number): Promise<<%= entity %> | null> {
+    return this.items.find(item => item.id === id) || null;
+  }
+
+  async findAll(): Promise<<%= entity %>[]> {
+    return this.items;
+  }
+}

package/dist/plugins/routes/hooks.js

@@ -0,0 +1 @@
+"use strict";

package/dist/plugins/routes/manifest.json

@@ -0,0 +1,11 @@
+{
+  "name": "routes",
+  "description": "Gera rotas Express para a entidade, com injeção de dependências",
+  "dependencies": ["controller"],
+  "files": [
+    {
+      "template": "routes.ejs",
+      "output": "src/adapters/inbound/routes/<%= route %>/<%= route %>.routes.ts"
+    }
+  ]
+}

package/dist/plugins/routes/templates/routes.ejs

@@ -0,0 +1,34 @@
+import { Router } from 'express';
+import { <%= entity %>Controller } from './<%= entityLower %>.controller';
+import { <%= entity %>Repository } from './repositories/<%= entityLower %>.repository';
+import { Create<%= entity %>UseCase } from './usecases/create-<%= entityLower %>.usecase';
+import { Update<%= entity %>UseCase } from './usecases/update-<%= entityLower %>.usecase';
+import { Delete<%= entity %>UseCase } from './usecases/delete-<%= entityLower %>.usecase';
+import { Find<%= entity %>ByIdUseCase } from './usecases/find-<%= entityLower %>-by-id.usecase';
+import { FindAll<%= plural %>UseCase } from './usecases/find-all-<%= pluralLower %>.usecase';
+
+const router = Router();
+
+// Instâncias
+const repository = new <%= entity %>Repository();
+const createUseCase = new Create<%= entity %>UseCase(repository);
+const updateUseCase = new Update<%= entity %>UseCase(repository);
+const deleteUseCase = new Delete<%= entity %>UseCase(repository);
+const findByIdUseCase = new Find<%= entity %>ByIdUseCase(repository);
+const findAllUseCase = new FindAll<%= plural %>UseCase(repository);
+
+const controller = new <%= entity %>Controller(
+  createUseCase,
+  updateUseCase,
+  deleteUseCase,
+  findByIdUseCase,
+  findAllUseCase
+);
+
+router.post('/', (req, res) => controller.create(req, res));
+router.put('/:id', (req, res) => controller.update(req, res));
+router.delete('/:id', (req, res) => controller.delete(req, res));
+router.get('/:id', (req, res) => controller.findById(req, res));
+router.get('/', (req, res) => controller.findAll(req, res));
+
+export default router;

package/dist/plugins/swagger/hooks.js

@@ -0,0 +1 @@
+"use strict";

package/dist/plugins/swagger/manifest.json

@@ -0,0 +1,11 @@
+{
+  "name": "swagger",
+  "description": "Gera documentação Swagger/OpenAPI em YAML para a entidade",
+  "dependencies": [],
+  "files": [
+    {
+      "template": "swagger.ejs",
+      "output": "src/swagger.yaml"
+    }
+  ]
+}

package/dist/plugins/swagger/templates/swagger.ejs

@@ -0,0 +1,123 @@
+openapi: 3.0.0
+info:
+  title: API - <%= plural %>
+  version: 1.0.0
+  description: Documentação da API para gerenciamento de <%= pluralLower %>
+
+paths:
+  /api/<%= route %>:
+    post:
+      summary: Cria um novo <%= entityLower %>
+      tags:
+        - <%= plural %>
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/<%= entity %>Input'
+      responses:
+        '201':
+          description: Criado com sucesso
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/<%= entity %>'
+        '400':
+          description: Dados inválidos
+    get:
+      summary: Lista todos os <%= pluralLower %>
+      tags:
+        - <%= plural %>
+      responses:
+        '200':
+          description: Lista de <%= pluralLower %>
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: '#/components/schemas/<%= entity %>'
+
+  /api/<%= route %>/{id}:
+    get:
+      summary: Busca um <%= entityLower %> por ID
+      tags:
+        - <%= plural %>
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema:
+            type: integer
+      responses:
+        '200':
+          description: <%= entity %> encontrado
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/<%= entity %>'
+        '404':
+          description: <%= entity %> não encontrado
+    put:
+      summary: Atualiza um <%= entityLower %>
+      tags:
+        - <%= plural %>
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema:
+            type: integer
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/<%= entity %>Input'
+      responses:
+        '200':
+          description: Atualizado com sucesso
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/<%= entity %>'
+        '404':
+          description: <%= entity %> não encontrado
+        '400':
+          description: Dados inválidos
+    delete:
+      summary: Deleta um <%= entityLower %>
+      tags:
+        - <%= plural %>
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema:
+            type: integer
+      responses:
+        '204':
+          description: Deletado com sucesso
+        '404':
+          description: <%= entity %> não encontrado
+
+components:
+  schemas:
+    <%= entity %>:
+      type: object
+      properties:
+<% columns.forEach(c => { %>        <%= c.name %>:
+          type: <%= c.type === 'number' ? 'number' : 'string' %>
+<% if (c.primary) { %>          readOnly: true
+<% } %><% }) %>      required:
+<% columns.filter(c => !c.primary).forEach(c => { %>        - <%= c.name %>
+<% }) %>
+    <%= entity %>Input:
+      type: object
+      properties:
+<% columns.filter(c => !c.primary).forEach(c => { %>        <%= c.name %>:
+          type: <%= c.type === 'number' ? 'number' : 'string' %>
+<% }) %>      required:
+<% columns.filter(c => !c.primary).forEach(c => { %>        - <%= c.name %>
+<% }) %>

package/dist/plugins/usecases/hooks.js

@@ -0,0 +1 @@
+"use strict";

package/dist/plugins/usecases/manifest.json

@@ -0,0 +1,27 @@
+{
+  "name": "usecases",
+  "description": "Gera todos os use cases para a entidade (CRUD)",
+  "dependencies": ["repository"],
+  "files": [
+    {
+      "template": "create.ejs",
+      "output": "src/core/usecases/<%= route %>/create-<%= entityLower %>.usecase.ts"
+    },
+    {
+      "template": "update.ejs",
+      "output": "src/core/usecases/<%= route %>/update-<%= entityLower %>.usecase.ts"
+    },
+    {
+      "template": "delete.ejs",
+      "output": "src/core/usecases/<%= route %>/delete-<%= entityLower %>.usecase.ts"
+    },
+    {
+      "template": "find-by-id.ejs",
+      "output": "src/core/usecases/<%= route %>/find-<%= entityLower %>-by-id.usecase.ts"
+    },
+    {
+      "template": "find-all.ejs",
+      "output": "src/core/usecases/<%= route %>/find-all-<%= pluralLower %>.usecase.ts"
+    }
+  ]
+}

package/dist/plugins/usecases/templates/create.ejs

@@ -0,0 +1,11 @@
+import { <%= entity %> } from '../entities/<%= entityLower %>.entity';
+import { I<%= entity %>Repository } from '../repositories/I<%= entity %>Repository';
+
+export class Create<%= entity %>UseCase {
+  constructor(private readonly repository: I<%= entity %>Repository) {}
+
+  async execute(data: Omit<<%= entity %>, 'id'>): Promise<<%= entity %>> {
+    // Aqui pode adicionar validações, regras de negócio, etc.
+    return this.repository.create(data);
+  }
+}

package/dist/plugins/usecases/templates/delete.ejs

@@ -0,0 +1,11 @@
+import { I<%= entity %>Repository } from '../repositories/I<%= entity %>Repository';
+
+export class Delete<%= entity %>UseCase {
+  constructor(private readonly repository: I<%= entity %>Repository) {}
+
+  async execute(id: number): Promise<void> {
+    const existing = await this.repository.findById(id);
+    if (!existing) throw new Error('<%= entity %> not found');
+    await this.repository.delete(id);
+  }
+}

package/dist/plugins/usecases/templates/find-all.ejs

@@ -0,0 +1,10 @@
+import { <%= entity %> } from '../entities/<%= entityLower %>.entity';
+import { I<%= entity %>Repository } from '../repositories/I<%= entity %>Repository';
+
+export class FindAll<%= plural %>UseCase {
+  constructor(private readonly repository: I<%= entity %>Repository) {}
+
+  async execute(): Promise<<%= entity %>[]> {
+    return this.repository.findAll();
+  }
+}

package/dist/plugins/usecases/templates/find-by-id.ejs

@@ -0,0 +1,12 @@
+import { <%= entity %> } from '../entities/<%= entityLower %>.entity';
+import { I<%= entity %>Repository } from '../repositories/I<%= entity %>Repository';
+
+export class Find<%= entity %>ByIdUseCase {
+  constructor(private readonly repository: I<%= entity %>Repository) {}
+
+  async execute(id: number): Promise<<%= entity %>> {
+    const result = await this.repository.findById(id);
+    if (!result) throw new Error('<%= entity %> not found');
+    return result;
+  }
+}

package/dist/plugins/usecases/templates/update.ejs

@@ -0,0 +1,12 @@
+import { <%= entity %> } from '../entities/<%= entityLower %>.entity';
+import { I<%= entity %>Repository } from '../repositories/I<%= entity %>Repository';
+
+export class Update<%= entity %>UseCase {
+  constructor(private readonly repository: I<%= entity %>Repository) {}
+
+  async execute(id: number, data: Partial<<%= entity %>>): Promise<<%= entity %>> {
+    const existing = await this.repository.findById(id);
+    if (!existing) throw new Error('<%= entity %> not found');
+    return this.repository.update(id, data);
+  }
+}

package/dist/utils/config.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+function loadConfig() {
+    const configPath = path_1.default.join(process.cwd(), '.create-resource.json');
+    if (fs_extra_1.default.existsSync(configPath)) {
+        return fs_extra_1.default.readJsonSync(configPath);
+    }
+    return {};
+}

package/dist/utils/file-system.js

@@ -0,0 +1 @@
+"use strict";

package/dist/utils/logger.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggerFormated = void 0;
+const loggerFormated = (data) => {
+    return console.log(JSON.stringify(data, null, 2));
+};
+exports.loggerFormated = loggerFormated;

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "jarvis-arch-hexagonal-gen",
+  "version": "1.0.0",
+  "description": "Gerador de recursos para projetos Node.js com TypeScript",
+  "keywords": [
+    "Arquitetura Hexagonal",
+    "Gerador de Códigos"
+  ],
+  "author": "Anderson Paiva",
+  "license": "ISC",
+  "main": "./dist/cli/index.js",
+  "type": "commonjs",
+  "bin": {
+    "create-resource": "./dist/cli/index.js"
+  },
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "generate": "ts-node src/cli/index.ts generate",
+    "build": "tsc && npm run copy-plugins",
+    "copy-plugins": "node scripts/copy-plugins.js"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^15.0.0",
+    "ejs": "^6.0.1",
+    "text-table": "^0.2.0"
+  },
+  "devDependencies": {
+    "@types/chalk": "^0.4.31",
+    "@types/ejs": "^3.1.5",
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^26.0.1",
+    "@types/supertest": "^7.2.0",
+    "@types/text-table": "^0.2.5",
+    "copyfiles": "^2.4.1",
+    "cpx": "^1.5.0",
+    "fs-extra": "^11.3.5",
+    "jest": "^30.4.2",
+    "supertest": "^7.2.2",
+    "ts-jest": "^29.4.11",
+    "ts-node": "^10.9.2",
+    "typescript": "^6.0.3"
+  }
+}

package/scripts/copy-plugins.js

@@ -0,0 +1,40 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+// Ajuste o caminho de origem conforme sua estrutura:
+// Se seus plugins estão em 'src/plugins', use:
+const srcDir = path.join(__dirname, '..', 'src', 'plugins');
+// Se estiverem na raiz ('plugins'), use:
+// const srcDir = path.join(__dirname, '..', 'plugins');
+
+const destDir = path.join(__dirname, '..', 'dist', 'plugins');
+
+// Função recursiva para copiar apenas arquivos não-.ts
+function copyNonTsFiles(src, dest) {
+  // Cria o diretório de destino se não existir
+  fs.ensureDirSync(dest);
+
+  const items = fs.readdirSync(src);
+
+  for (const item of items) {
+    const srcPath = path.join(src, item);
+    const destPath = path.join(dest, item);
+    const stat = fs.statSync(srcPath);
+
+    if (stat.isDirectory()) {
+      // Recursivamente para subpastas
+      copyNonTsFiles(srcPath, destPath);
+    } else {
+      // Copia apenas se NÃO for .ts
+      if (!item.endsWith('.ts')) {
+        fs.copySync(srcPath, destPath);
+        // console.log(`Copiado: ${srcPath} -> ${destPath}`);
+      }
+    }
+  }
+}
+
+// Executa a cópia (sem remover nada)
+copyNonTsFiles(srcDir, destDir);
+
+console.log('✅ Arquivos não-.ts copiados de src/plugins para dist/plugins');