eva4j 1.0.13 → 1.0.14

package/src/utils/yaml-to-entity.js

@@ -26,7 +26,8 @@ async function parseDomainYaml(yamlPath, packageName = '', moduleName = '') {
   
   return {
     aggregates,
-    allEnums: extractAllEnums(domainData.aggregates)
+    allEnums: extractAllEnums(domainData.aggregates),
+    endpoints: parseEndpoints(domainData)
   };
 }
 
@@ -91,7 +92,8 @@ function parseAggregate(aggregateData) {
     valueObjects: parsedValueObjects,
     aggregateMethods,
     allEntities: parsedEntities,
-    domainEvents
+    domainEvents,
+    enums: aggregateEnums
   };
 }
 
@@ -961,6 +963,33 @@ function extractAllEnums(aggregates) {
   return Array.from(enumsMap.values());
 }
 
+/**
+ * Parse the optional endpoints section from domain.yaml.
+ * When present, controls which use cases and versioned controllers are generated.
+ * @param {Object} domainData - Raw parsed YAML data
+ * @returns {Object|null} Parsed endpoints structure or null if not declared
+ */
+function parseEndpoints(domainData) {
+  if (!domainData.endpoints) return null;
+  const { basePath = '/', versions = [] } = domainData.endpoints;
+  return {
+    basePath,
+    versions: versions.map(v => ({
+      version: v.version,
+      operations: (v.operations || []).map(op => {
+        const method = (op.method || 'GET').toUpperCase();
+        return {
+          method,
+          path: op.path || '/',
+          description: op.description || '',
+          useCase: toPascalCase(op.useCase),
+          type: method === 'GET' ? 'query' : 'command'
+        };
+      })
+    }))
+  };
+}
+
 module.exports = {
   parseDomainYaml,
   parseAggregate,

package/templates/aggregate/AggregateRepository.java.ejs

@@ -20,4 +20,9 @@ public interface <%= rootEntity.name %>Repository {
     void deleteById(<%= rootEntity.fields[0].javaType %> id);
     
     boolean existsById(<%= rootEntity.fields[0].javaType %> id);
+<% if (findByOps && findByOps.length > 0) { %>
+<% findByOps.forEach(function(op) { %>
+    Page<<%= rootEntity.name %>> <%= op.jpaMethodName %>(<%= op.fieldJavaType %> <%= op.fieldName %>, Pageable pageable);
+<% }); %>
+<% } %>
 }

package/templates/aggregate/AggregateRepositoryImpl.java.ejs

@@ -58,4 +58,13 @@ public class <%= rootEntity.name %>RepositoryImpl implements <%= rootEntity.name
     public boolean existsById(<%= rootEntity.fields[0].javaType %> id) {
         return jpaRepository.existsById(id);
     }
+<% if (findByOps && findByOps.length > 0) { %>
+<% findByOps.forEach(function(op) { %>
+    @Override
+    public Page<<%= rootEntity.name %>> <%= op.jpaMethodName %>(<%= op.fieldJavaType %> <%= op.fieldName %>, Pageable pageable) {
+        return jpaRepository.<%= op.jpaMethodName %>(<%= op.fieldName %>, pageable)
+                .map(mapper::toDomain);
+    }
+<% }); %>
+<% } %>
 }

package/templates/aggregate/DomainEventHandler.java.ejs

@@ -6,32 +6,37 @@ import org.springframework.transaction.event.TransactionalEventListener;
 <% domainEvents.forEach(event => { %>
 import <%= packageName %>.<%= moduleName %>.domain.models.events.<%= event.name %>;
 <% }); %>
-<% if (hasKafkaEvents) { %>
-import <%= packageName %>.<%= moduleName %>.domain.repositories.MessageBroker;
+<% if (broker) { %>
+<% domainEvents.forEach(event => { %>
+import <%= packageName %>.<%= moduleName %>.application.events.<%= event.integrationEventClassName %>;
+<% }); %>
+import <%= packageName %>.<%= moduleName %>.application.ports.MessageBroker;
 <% } %>
 
 /**
  * <%= aggregateName %>DomainEventHandler — Domain Event Bridge
  *
- * This handler connects the internal Spring event bus (ApplicationEventPublisher)
- * with the external messaging port (MessageBroker).
+ * Connects the internal Spring event bus (ApplicationEventPublisher) with the
+ * external messaging port (MessageBroker).
  *
  * Architecture:
  *   AggregateRepositoryImpl.save()
- *     → eventPublisher.publishEvent(domainEvent)   [internal Spring bus]
- *       → @TransactionalEventListener(AFTER_COMMIT) [this class]
- *         → messageBroker.send*(event)             [port — broker-agnostic]
+ *     → eventPublisher.publishEvent(domainEvent)        [internal Spring bus]
+ *       → @TransactionalEventListener(AFTER_COMMIT)     [this class]
+ *         → messageBroker.publish*(integrationEvent)    [port — broker-agnostic]
  *
- * AFTER_COMMIT ensures the external event is only published if the
- * database transaction committed successfully, preventing ghost events
- * from rolled-back operations.
+ * AFTER_COMMIT guarantees that external events are published only when the
+ * database transaction committed successfully, preventing ghost events from
+ * rolled-back operations.
  *
- * To switch brokers (Kafka → RabbitMQ → SNS): change only the MessageBroker
- * adapter in infrastructure/. This class never needs modification.
+ * Domain Events  (domain/models/events/)  — internal signals scoped to this bounded context.
+ * Integration Events (application/events/) — broker-facing projections; changing broker
+ *   technology (Kafka → RabbitMQ → SNS) only requires changing the MessageBroker adapter.
+ *   Domain Events — and therefore this class — never need modification.
  */
 @ApplicationComponent
 public class <%= aggregateName %>DomainEventHandler {
-<% if (hasKafkaEvents) { %>
+<% if (broker) { %>
 
     private final MessageBroker messageBroker;
 
@@ -42,16 +47,15 @@ public class <%= aggregateName %>DomainEventHandler {
 <% domainEvents.forEach(event => { %>
 
     /**
-     * Handles {@link <%= event.name %>} after the wrapping transaction commits.
-     * <% if (!event.kafka) { %>
+     * Handles {@link <%= event.name %>} after the wrapping transaction commits.<% if (!broker) { %>
+     * <p>
      * TODO: Implement the side effect for this event (e.g., send notification,
-     *       update a read model, trigger a saga step, etc.).
-     * <% } %>
+     *       update a read model, trigger a saga step, etc.).<% } %>
      */
     @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
-    public void on<%= event.name %>(<%=  event.name %> event) {
-    <% if (event.kafka) { %>
-        messageBroker.send<%= event.name %>(event);
+    public void on<%= event.name %>(<%= event.name %> event) {
+    <% if (broker) { %>
+        messageBroker.publish<%= event.integrationEventClassName %>(new <%= event.integrationEventClassName %>(<% if (event.fields && event.fields.length > 0) { event.fields.forEach(function(field, idx) { %>event.get<%= field.name.charAt(0).toUpperCase() + field.name.slice(1) %>()<%= idx < event.fields.length - 1 ? ', ' : '' %><% }); } %>));
     <% } else { %>
         // TODO: handle <%= event.name %> — add your side-effect logic here
         //   e.g.:  notificationService.notify(event);

package/templates/aggregate/JpaRepository.java.ejs

@@ -8,4 +8,9 @@ import <%= packageName %>.<%= moduleName %>.infrastructure.database.entities.<%=
  * Spring Data JPA repository
  */
 public interface <%= rootEntity.name %>JpaRepository extends JpaRepository<<%= rootEntity.name %>Jpa, <%= rootEntity.fields[0].javaType %>> {
+<% if (findByOps && findByOps.length > 0) { %>
+<% findByOps.forEach(function(op) { %>
+    org.springframework.data.domain.Page<<%= rootEntity.name %>Jpa> <%= op.jpaMethodName %>(<%= op.fieldJavaType %> <%= op.fieldName %>, org.springframework.data.domain.Pageable pageable);
+<% }); %>
+<% } %>
 }