Skip to main content
Glama
Ivan-Madera

midd-nestjs-hexagonal-architecture-mcp

by Ivan-Madera

add_use_case

Generates a complete hexagonal use-case slice in a NestJS domain, including ports, services, adapters, controller, DTOs, entities, errors, and modules; merges extra cases into existing modules.

Instructions

Genera un caso de uso completo (vertical slice hexagonal) en un dominio: puerto inbound/outbound, domain service, application service + interface + spec, adapter (TypeORM por defecto; SP opt-in con nombreSp), controller JSON:API + DTOs, entidad de dominio y TypeORM, catálogos de error, y los módulos del dominio. Escribe en src// (carpeta siempre lowercase; las clases salen en PascalCase sin importar el case de "dominio"). MULTI-CASO: al añadir el 2º/3er caso al MISMO dominio, el MCP MERGEA ese caso en los módulos del dominio ya generados (controller, adapter, providers, tokens, forFeature) — tanto en greenfield como en refactor. En refactor NUNCA toca app.module (eso lo cablea el agente). API EXTERNA: con adapterType="http" (apiExterna, rutaApi, metodoHttp) el caso consume una API con el fetch nativo y NO necesita base de datos, conexion ni motor; declara _BASE_URL en config, Joi y .env.example. SP: con adapterType="sp" el wiring es quirúrgico — apunta el módulo al .sp.adapter y quita del forFeature SOLO la entidad de ese caso, preservando las de los casos TypeORM. INFRA (refactor): usa infraStyle="project" + infraRoot (p.ej. "common") para que los imports de infra apunten a la carpeta del proyecto; aun así, concilia a mano los NOMBRES de clase (ResponseJsonApiBase/GenericException de los templates vs los del proyecto).

Input Schema

NameRequiredDescriptionDefault
casoYesNombre del caso de uso en INGLES y PascalCase, p.ej. "RetrieveProduct" (los archivos resultan kebab-case: retrieve-product.*).
modeNoModo de generación. "greenfield" (default): servicio nuevo, cablea app.module y mergea módulos del dataset. "refactor": proyecto existente — NO toca app.module ni módulos ajenos; genera el slice hexagonal para que el agente lo adapte a la infra del proyecto.greenfield
motorNoMotor de la conexión. Greenfield: obligatorio si la conexión es nueva (el MCP la crea completa); "none" = sin base de datos (rechaza adapters TypeORM/SP). Refactor: solo se pasa, junto con "conexion", cuando el usuario pidió EXPRESAMENTE crear una conexión que el proyecto no tiene; si no, se reutiliza la del proyecto y el motor se ignora. Valores: mssql | postgres | mysql | none.
paramYesParámetro principal del método en camelCase, p.ej. "sku". (Legado: usado solo para el fixture del test generado.)
accionYesRuta del endpoint POST (camel o kebab), p.ej. "retrieveProduct".
metodoYesMétodo del puerto en camelCase, p.ej. "retrieveBySku".
dominioYesNombre del bounded context en INGLES y PascalCase, p.ej. "Catalog" o "StoreConfiguration" (varias palabras = PascalCase; la carpeta resulta kebab-case: store-configuration). Si el usuario lo dio en espanol, traducelo y confirmalo en el plan.
entidadYesNombre de la entidad de dominio en INGLES y PascalCase, p.ej. "Product".
requestNoEntidad de dominio request del método principal en PascalCase, p.ej. "RetrieveProductRequest". Canon: los métodos del puerto reciben una entidad tipada, no un string. Por defecto <Caso>Request.
rutaApiNoSolo adapterType="http": ruta del endpoint de la API externa que llama el metodo, empieza con "/", sin query string, p.ej. "/rates".
conexionNoOPCIONAL: no se le pregunta al usuario. Sin valor, la conexión se llama como su motor (Mssql, Postgres, Mysql): se reutiliza la única conexión de ese motor o se crea una nueva. Pásalo solo para una conexión ADICIONAL de un motor que ya tiene una (Mssql2, Mssql3; inspect_project dice cuál toca) y solo si el usuario la pide. En refactor NO lo pases: la conexión del proyecto se detecta y se reutiliza (solo si el proyecto tiene varias, indica cuál). PascalCase, sin el sufijo Connection.
envVarSpNoNombre de la variable de entorno que porta el SP (MAYÚSCULAS, solo si adapterType="sp"). Por defecto se deriva de nombreSp como <NOMBRE_SP>_SP.
nombreSpNoNombre del stored procedure (solo si adapterType="sp"). El MCP lo registra en ConfigurationVariables.storedProcedures + joiSchema + .env.example.
infraRootNoSolo con infraStyle="project": carpeta (relativa a src/) de la infra transversal propia del proyecto que reemplaza a "shared" en los imports generados, p.ej. "common". Por defecto "common".
overwriteNoSi true, sobrescribe archivos existentes. Por defecto false (no pisa).
apiExternaNoSolo adapterType="http": nombre PascalCase de la API externa, p.ej. "ExchangeRates". Su URL base vive en la variable de entorno <NOMBRE>_BASE_URL (EXCHANGE_RATES_BASE_URL), validada con Joi al arrancar.
infraStyleNoCapa de infraestructura transversal (logger, excepciones, respuesta JSON:API base, config) que importan los archivos generados. "dataset" (default, greenfield): usa la capa shared del dataset (src/shared/*). "project" (refactor): los imports apuntan a la carpeta de infra propia del proyecto (ver infraRoot); el agente aún debe conciliar los NOMBRES de símbolo (p.ej. ResponseJsonApiBase vs ResponseJsonApi del proyecto).dataset
metodoHttpNoSolo adapterType="http": verbo de la llamada. GET (default) envia la request como query string; POST y PUT la envian como cuerpo JSON.
adapterTypeNoTipo de acceso a datos. "typeorm" por defecto. "sp" (stored procedure) es OPT-IN: requiere nombreSp. "http" consume una API externa con fetch nativo y NO usa base de datos: requiere apiExterna y rutaApi (y no necesita conexion ni motor).typeorm
projectRootYesRuta absoluta de la raíz del servicio NestJS destino donde se escriben los archivos.
tipoRecursoNoType JSON:API del recurso en kebab-case, en ingles (p.ej. "exchange-rate"). Si se omite: la entidad en kebab-case. Con generate_from_spec sale del resource_type del spec.
prefijoErrorYesPrefijo de errores de la API en mayúsculas. Por ejemplo, CATALOG. Los errores quedarán como CATALOG-PRODUCTNOTFOUND-001; el número va de 001 a 999 y lo asigna el MCP en secuencia por prefijo.
crearConexionNoSOLO refactor, y SOLO si el usuario pidio EXPRESAMENTE crear una conexion. Un refactor reutiliza la conexion que el proyecto ya tiene y, si no tiene ninguna, NO crea una por su cuenta. Con true el MCP crea la conexion completa, nombrada por el motor, asi que tambien hay que pasar el motor (se le pregunta al usuario si no lo dijo).
connectionStyleNoForma de la conexión TypeORM del proyecto. "named" (default): conexión nombrada (<Conexion>Connection). "default": conexión por defecto de forRoot (los adapters no inyectan nombre de conexión). Úsalo según lo que reporte inspect_project.named

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A3.6/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations, so the description carries the full burden and mostly succeeds: it discloses write location and casing rules, that later cases MERGE into existing domain modules, that refactor mode leaves app.module alone, and that class-name reconciliation is manual under infraStyle=project. It says nothing about what the tool returns or reports after generation, and overwrite semantics live only in the schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness2/5

Is the description appropriately sized, front-loaded, and free of redundancy?

A single dense paragraph mixing purpose, mode rules, adapter rules, merge behavior, and manual reconciliation, with ALL-CAPS fragments instead of headings or bullets. Every fact is relevant, but nothing is grouped, and several clauses (http adapter needs no DB, default adapterType) duplicate schema text the agent already sees.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 24-parameter generator with no annotations and no output schema, the description covers the critical decision points and side effects an agent needs before calling: mode semantics, adapter variants, merge behavior, and infra reconciliation caveats. Missing pieces are the return payload and whether inspect_project should run first.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3. The description only re-states a handful of parameters (adapterType modes, nombreSp, apiExterna, infraStyle/infraRoot, motor/conexion defaults) and adds little beyond those schema texts, notably the merge effect of adding a case to an existing domain.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

First sentence gives a specific verb and artifact list (hexagonal vertical slice with port, service, adapter, controller, DTOs, entities, error catalogs, modules) written to src/<dominio>/. The scope is unmistakable. It never contrasts itself with generate_from_spec or scaffold_service, so an agent must infer which generator to pick when both could apply.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Rich conditional guidance: greenfield vs refactor (refactor never touches app.module), adapterType selection with prerequisites (sp requires nombreSp, http requires apiExterna/rutaApi and no DB), infraStyle=project with infraRoot for existing projects, and multi-case merge semantics. It stops short of stating when to prefer this over the sibling generate_from_spec, which is the one routing decision left implicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.