eva4j 1.0.16 → 1.0.17

package/templates/aggregate/AggregateRepository.java.ejs

@@ -20,6 +20,10 @@ public interface <%= rootEntity.name %>Repository {
     boolean existsById(<%= rootEntity.fields[0].javaType %> id);
 <% if (!hasSoftDelete) { %>
     void deleteById(<%= rootEntity.fields[0].javaType %> id);
+<% if (hasDeleteLifecycle) { %>
+
+    void delete(<%= rootEntity.name %> <%= rootEntity.fieldName %>);
+<% } %>
 <% } %>
 <% if (findByOps && findByOps.length > 0) { %>
 <% findByOps.forEach(function(op) { %>

package/templates/aggregate/AggregateRepositoryImpl.java.ejs

@@ -58,6 +58,14 @@ public class <%= rootEntity.name %>RepositoryImpl implements <%= rootEntity.name
     public void deleteById(<%= rootEntity.fields[0].javaType %> id) {
         jpaRepository.deleteById(id);
     }
+<% if (hasDeleteLifecycle) { %>
+
+    @Override
+    public void delete(<%= rootEntity.name %> <%= rootEntity.fieldName %>) {
+        <%= rootEntity.fieldName %>.pullDomainEvents().forEach(eventPublisher::publishEvent);
+        jpaRepository.deleteById(<%= rootEntity.fieldName %>.getId());
+    }
+<% } %>
 <% } %>
 <% if (findByOps && findByOps.length > 0) { %>
 <% findByOps.forEach(function(op) { %>

package/templates/aggregate/AggregateRoot.java.ejs

@@ -19,9 +19,14 @@ import <%= packageName %>.<%= moduleName %>.domain.models.events.<%= event.name
 <% }); %>
 <% } %>
 <%
-const _needsLocalDateTimeImport = Object.values(triggeredEventsMap || {}).flat().some(function(ev) {
-  return (ev.fields || []).some(function(ef) { return ef.name.endsWith('At') && ef.javaType === 'LocalDateTime'; });
-}) && !imports.some(function(imp) { return imp.includes('LocalDateTime'); });
+const _allLifecycleEvents = Object.values(lifecycleEventsMap || {}).flat();
+const _needsLocalDateTimeImport = (
+  Object.values(triggeredEventsMap || {}).flat().some(function(ev) {
+    return (ev.fields || []).some(function(ef) { return ef.name.endsWith('At') && ef.javaType === 'LocalDateTime'; });
+  }) ||
+  _allLifecycleEvents.some(function(ev) { return ev.needsLocalDateTime; })
+) && !imports.some(function(imp) { return imp.includes('LocalDateTime'); });
+const _hasCreateLifecycle = ((lifecycleEventsMap || {}).create || []).length > 0;
 %>
 <% if (_needsLocalDateTimeImport) { %>
 import java.time.LocalDateTime;
@@ -36,6 +41,7 @@ import java.util.List;
  */
 public class <%= name %> {
 <% if (domainEvents && domainEvents.length > 0) { %>
+<%   const _needsPublicRaise = ((lifecycleEventsMap || {}).delete || []).length > 0; %>
 
     // ─── Domain Events ──────────────────────────────────────────────────────────
     private final List<DomainEvent> _domainEvents = new ArrayList<>();
@@ -44,7 +50,7 @@ public class <%= name %> {
      * Registers a domain event to be published after successful persistence.
      * Call this inside business methods when something significant happens.
      */
-    protected void raise(DomainEvent event) {
+    <%= _needsPublicRaise ? 'public' : 'protected' %> void raise(DomainEvent event) {
         _domainEvents.add(event);
     }
 
@@ -93,9 +99,13 @@ public class <%= name %> {
 <% const creationFields = fields.filter(f => f.name !== 'id' && f.name !== 'createdAt' && f.name !== 'updatedAt' && f.name !== 'createdBy' && f.name !== 'updatedBy' && f.name !== 'deletedAt' && !f.readOnly && !f.autoInit); %>
 <% const autoInitFields = fields.filter(f => f.autoInit); %>
 <% const defaultValueFields = fields.filter(f => f.readOnly && !f.autoInit && f.javaDefaultValue); %>
+<% const _createLifecycleEvents = (lifecycleEventsMap || {}).create || []; %>
 <% if (creationFields.length > 0 || autoInitFields.length > 0 || defaultValueFields.length > 0) { %>
     // Constructor for new entity creation (without id, audit fields, readOnly and auto-initialized fields)
     public <%= name %>(<% let paramIdx = 0; %><% creationFields.forEach((field, idx) => { %><% if (paramIdx > 0) { %>, <% } %><%- field.javaType %> <%= field.name %><% paramIdx++; %><% }); %>) {
+<% if (_createLifecycleEvents.length > 0) { %>
+        this.id = java.util.UUID.randomUUID().toString();
+<% } %>
 <% creationFields.forEach(field => { %>
         this.<%= field.name %> = <%= field.name %>;
 <% }); %>
@@ -104,6 +114,26 @@ public class <%= name %> {
 <% }); %>
 <% defaultValueFields.forEach(field => { %>
         this.<%= field.name %> = <%- field.javaDefaultValue %>;
+<% }); %>
+<% _createLifecycleEvents.forEach(function(evt) { %>
+        raise(new <%= evt.name %>(<%= evt.resolvedArgs.join(', ') %>));
+<% }); %>
+    }
+<% } %>
+<% const _updateLifecycleEvents = (lifecycleEventsMap || {}).update || []; %>
+<% if (_updateLifecycleEvents.length > 0 && creationFields.length > 0) { %>
+
+    // ─── Update Method (lifecycle: update) ───────────────────────────────────
+    /**
+     * Updates the entity fields and raises domain event(s).
+     * Receives final (already-merged) values — PATCH semantics are resolved by the caller.
+     */
+    public void update(<% creationFields.forEach((field, idx) => { %><%- field.javaType %> <%= field.name %><%= idx < creationFields.length - 1 ? ', ' : '' %><% }); %>) {
+<% creationFields.forEach(field => { %>
+        this.<%= field.name %> = <%= field.name %>;
+<% }); %>
+<% _updateLifecycleEvents.forEach(function(evt) { %>
+        raise(new <%= evt.name %>(<%= evt.resolvedArgs.join(', ') %>));
 <% }); %>
     }
 <% } %>
@@ -243,6 +273,7 @@ public class <%= name %> {
 <% }); %>
 <% } %>
 <% if (hasSoftDelete) { %>
+<% const _softDeleteLifecycleEvents = (lifecycleEventsMap || {}).softDelete || []; %>
 
     // ─── Soft Delete ─────────────────────────────────────────────────────────
     /**
@@ -254,6 +285,9 @@ public class <%= name %> {
             throw new IllegalStateException("<%= name %> is already deleted");
         }
         this.deletedAt = java.time.LocalDateTime.now();
+<% _softDeleteLifecycleEvents.forEach(function(evt) { %>
+        raise(new <%= evt.name %>(<%= evt.resolvedArgs.join(', ') %>));
+<% }); %>
     }
 
     public boolean isDeleted() {

package/templates/aggregate/JpaAggregateRoot.java.ejs

@@ -68,9 +68,9 @@ if (audit && audit.trackUser) {
     private <%- field.javaTypeJpa %> <%= field.name %> = new ArrayList<>();
   <% } else { %>
     <% if (index === 0) { %>@Id
-    <% if (field.javaType === 'String') { %>@GeneratedValue(strategy = GenerationType.UUID)
+    <% if (!hasCreateLifecycle) { %><% if (field.javaType === 'String') { %>@GeneratedValue(strategy = GenerationType.UUID)
     <% } else if (field.javaType === 'Long' || field.javaType === 'Integer') { %>@GeneratedValue(strategy = GenerationType.IDENTITY)
-    <% } %><% } %><% if (field.annotations.length > 0) { %><% field.annotations.forEach(annotation => { %><%= annotation %>
+    <% } %><% } %><% } %><% if (field.annotations.length > 0) { %><% field.annotations.forEach(annotation => { %><%= annotation %>
     <% }); %><% } %><% if (field.isEmbedded || field.isValueObject) { %><% 
     // Find the Value Object definition to get its fields
     const vo = valueObjects && valueObjects.find(v => v.name === field.javaType);

package/templates/crud/DeleteCommandHandler.java.ejs

@@ -2,9 +2,20 @@ package <%= packageName %>.<%= moduleName %>.application.usecases;
 
 import <%= packageName %>.<%= moduleName %>.application.commands.Delete<%= aggregateName %>Command;
 import <%= packageName %>.<%= moduleName %>.domain.repositories.<%= aggregateName %>Repository;
-<% if (hasSoftDelete) { %>
+<% const _deleteLifecycleEvents = (lifecycleEventsMap || {}).delete || []; %>
+<% const _softDeleteLifecycleEvents2 = (lifecycleEventsMap || {}).softDelete || []; %>
+<% if (hasSoftDelete || _deleteLifecycleEvents.length > 0) { %>
 import <%= packageName %>.<%= moduleName %>.domain.models.entities.<%= aggregateName %>;
 <% } %>
+<% if (_deleteLifecycleEvents.length > 0) { %>
+import <%= packageName %>.shared.domain.DomainEvent;
+<% _deleteLifecycleEvents.forEach(function(evt) { %>
+import <%= packageName %>.<%= moduleName %>.domain.models.events.<%= evt.name %>;
+<% }); %>
+<% if (_deleteLifecycleEvents.some(function(evt) { return evt.needsLocalDateTime; })) { %>
+import java.time.LocalDateTime;
+<% } %>
+<% } %>
 import <%= packageName %>.shared.domain.annotations.ApplicationComponent;
 import <%= packageName %>.shared.domain.annotations.LogExceptions;
 import <%= packageName %>.shared.domain.customExceptions.NotFoundException;
@@ -33,6 +44,13 @@ public class Delete<%= aggregateName %>CommandHandler implements CommandHandler<
                 .orElseThrow(() -> new NotFoundException("<%= aggregateName %> not found with id: " + command.id()));
         entity.softDelete();
         repository.save(entity);
+<% } else if (_deleteLifecycleEvents.length > 0) { %>
+        <%= aggregateName %> entity = repository.findById(command.id())
+                .orElseThrow(() -> new NotFoundException("<%= aggregateName %> not found with id: " + command.id()));
+<% _deleteLifecycleEvents.forEach(function(evt) { %>
+        entity.raise(new <%= evt.name %>(<%= evt.resolvedArgs.join(', ') %>));
+<% }); %>
+        repository.delete(entity);
 <% } else { %>
         if (!repository.existsById(command.id())) {
             throw new NotFoundException("<%= aggregateName %> not found with id: " + command.id());

package/templates/crud/UpdateCommandHandler.java.ejs

@@ -6,6 +6,7 @@ import <%= packageName %>.<%= moduleName %>.domain.repositories.<%= aggregateNam
 <% if ((commandFields || []).some(f => f.originalVoType)) { %>
 import <%= packageName %>.<%= moduleName %>.application.mappers.<%= aggregateName %>ApplicationMapper;
 <% } %>
+<% const _updateLifecycleEvents = (lifecycleEventsMap || {}).update || []; %>
 import <%= packageName %>.shared.domain.annotations.ApplicationComponent;
 import <%= packageName %>.shared.domain.annotations.LogExceptions;
 import <%= packageName %>.shared.domain.customExceptions.NotFoundException;
@@ -15,8 +16,13 @@ import org.springframework.transaction.annotation.Transactional;
 /**
  * Update<%= aggregateName %>CommandHandler — PATCH
  *
+<% if (_updateLifecycleEvents.length > 0) { %>
+ * Delegates field updates to the aggregate root's update() method,
+ * which raises domain events internally.
+<% } else { %>
  * Reconstructs the <%= aggregateName %> aggregate using the full constructor,
  * merging each command field with the existing entity value.
+<% } %>
  * Non-null command fields override the current value; null fields are preserved
  * from the loaded entity. No setters are required on the domain entity.
  */
@@ -52,12 +58,56 @@ public class Update<%= aggregateName %>CommandHandler implements CommandHandler<
     const cmdFieldMap = {};
     (commandFields || []).forEach(f => { cmdFieldMap[f.name] = f; });
 
+    function capitalize(s) { return s.charAt(0).toUpperCase() + s.slice(1); }
+
+    // Updatable fields: same filter as creationFields (exclude id, audit, deletedAt, readOnly, autoInit)
+    const updatableFields = (rootEntity.fields || []).filter(f =>
+      f.name !== 'id' && f.name !== 'createdAt' && f.name !== 'updatedAt' &&
+      f.name !== 'createdBy' && f.name !== 'updatedBy' && f.name !== 'deletedAt' && !f.readOnly && !f.autoInit
+    );
+%>
+<% if (_updateLifecycleEvents.length > 0) { %>
+        // Merge: use command value when non-null, otherwise preserve existing value.
+        // The aggregate root's update() method raises domain events internally.
+        existing.update(
+<% updatableFields.forEach((field, idx) => { %>
+<%   const cmdField = cmdFieldMap[field.name]; %>
+<%   const getter = `existing.get${capitalize(field.name)}()`; %>
+<%   const comma = idx < updatableFields.length - 1 ? ',' : ''; %>
+<%   if (cmdField && cmdField.originalVoType) { %>
+                command.<%= field.name %>() != null
+                        ? mapper.to<%= cmdField.originalVoType %>(command.<%= field.name %>())
+                        : <%= getter %><%= comma %>
+<%   } else if (cmdField) { %>
+                command.<%= field.name %>() != null ? command.<%= field.name %>() : <%= getter %><%= comma %>
+<%   } else { %>
+                <%= getter %><%= comma %> // preserved: <%= field.name %>
+<%   } %>
+<% }); %>
+        );
+<% if ((oneToManyRelationships || []).length > 0) { %>
+
+        // TODO: Collection relationships require an explicit replacement strategy.
+        //       Choose the right approach for your domain and uncomment:
+        //
+        //  Option A — Clear-and-replace (simple, loses existing entity ids):
+        //    existing.get<collection>().clear();
+        //    command.<collection>().forEach(dto -> entity.add<Item>(...));
+        //
+        //  Option B — Merge by id (preserves audit trail, more complex):
+        //    reconcile existing items against command items by id
+<% (oneToManyRelationships || []).forEach(rel => { %>
+        // if (command.<%= rel.fieldName %>() != null) { /* replace <%= rel.fieldName %> */ }
+<% }); %>
+<% } %>
+
+        repository.save(existing);
+<% } else { %>
+<%
     // oneToOneRelationships are non-collection non-inverse rels → appear in the full constructor
     const ctorRels = oneToOneRelationships || [];
     const totalArgs = (rootEntity.fields || []).length + ctorRels.length;
     let argIdx = 0;
-
-    function capitalize(s) { return s.charAt(0).toUpperCase() + s.slice(1); }
 %>
         // Merge: use command value when non-null, otherwise preserve existing value.
         // The full constructor is called so no setters are needed on the domain entity.
@@ -98,5 +148,6 @@ public class Update<%= aggregateName %>CommandHandler implements CommandHandler<
 <% } %>
 
         repository.save(updated);
+<% } %>
     }
 }

package/templates/read-model/ReadModelDomain.java.ejs

@@ -0,0 +1,46 @@
+package <%= packageName %>.<%= moduleName %>.domain.models.readmodels;
+<% const needsBigDecimal = fields && fields.some(f => f.javaType === 'BigDecimal'); %>
+<% const needsLocalDate  = fields && fields.some(f => ['LocalDate','LocalDateTime','LocalTime'].includes(f.javaType)); %>
+<% const needsInstant    = fields && fields.some(f => f.javaType === 'Instant'); %>
+<% const needsUUID       = fields && fields.some(f => f.javaType === 'UUID'); %>
+<% if (needsBigDecimal) { %>
+import java.math.BigDecimal;
+<% } %>
+<% if (needsLocalDate) { %>
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+<% } %>
+<% if (needsInstant) { %>
+import java.time.Instant;
+<% } %>
+<% if (needsUUID) { %>
+import java.util.UUID;
+<% } %>
+
+/**
+ * Local Read Model — projection of data from <%= sourceModule %>/<%= sourceName %>.
+ * <p>
+ * This class is read-only from this module's perspective.
+ * The source module owns mutations; this projection is maintained
+ * via domain events (see syncedBy configuration in domain.yaml).
+ * <p>
+ * No business logic, no setters, no empty constructor.
+ */
+public class <%= domainClassName %> {
+<% fields.forEach(field => { %>
+    private final <%- field.javaType %> <%= field.name %>;
+<% }); %>
+
+    public <%= domainClassName %>(<%= fields.map(f => f.javaType + ' ' + f.name).join(', ') %>) {
+<% fields.forEach(field => { %>
+        this.<%= field.name %> = <%= field.name %>;
+<% }); %>
+    }
+<% fields.forEach(field => { %>
+
+    public <%- field.javaType %> get<%= field.name.charAt(0).toUpperCase() + field.name.slice(1) %>() {
+        return this.<%= field.name %>;
+    }
+<% }); %>
+}

package/templates/read-model/ReadModelJpa.java.ejs

@@ -0,0 +1,58 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.database.entities;
+<% const needsBigDecimal = fields && fields.some(f => f.javaType === 'BigDecimal'); %>
+<% const needsLocalDate  = fields && fields.some(f => ['LocalDate','LocalDateTime','LocalTime'].includes(f.javaType)); %>
+<% const needsInstant    = fields && fields.some(f => f.javaType === 'Instant'); %>
+<% const needsUUID       = fields && fields.some(f => f.javaType === 'UUID'); %>
+<% if (needsBigDecimal) { %>
+import java.math.BigDecimal;
+<% } %>
+<% if (needsLocalDate || hasSoftDelete) { %>
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+<% } %>
+<% if (needsInstant) { %>
+import java.time.Instant;
+<% } %>
+<% if (needsUUID) { %>
+import java.util.UUID;
+<% } %>
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+/**
+ * JPA entity for the local read model — table: <%= tableName %>.
+ * Projection of data from <%= sourceModule %>/<%= sourceName %>.
+ * <p>
+ * No audit fields. The @Id mirrors the source entity's ID (not auto-generated).
+ */
+@Entity
+@Table(name = "<%= tableName %>")
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class <%= jpaEntityName %> {
+
+    @Id
+    private String id;
+<% fields.filter(f => f.name !== 'id').forEach(field => { %>
+
+    @Column(name = "<%= field.name.replace(/([A-Z])/g, '_$1').toLowerCase() %>")
+    private <%- field.javaType %> <%= field.name %>;
+<% }); %>
+<% if (hasSoftDelete) { %>
+
+    @Column(name = "deleted_at")
+    private LocalDateTime deletedAt;
+<% } %>
+}

package/templates/read-model/ReadModelJpaRepository.java.ejs

@@ -0,0 +1,11 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.database.repositories;
+
+import <%= packageName %>.<%= moduleName %>.infrastructure.database.entities.<%= jpaEntityName %>;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+/**
+ * Spring Data JPA repository for the <%= domainClassName %> read model.
+ * Table: <%= tableName %>.
+ */
+public interface <%= jpaRepositoryName %> extends JpaRepository<<%= jpaEntityName %>, String> {
+}

package/templates/read-model/ReadModelKafkaListener.java.ejs

@@ -0,0 +1,64 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.kafkaListener;
+<% const isUpsert = action === 'UPSERT'; %>
+<% if (isUpsert) { %>
+
+import <%= packageName %>.<%= moduleName %>.application.events.<%= integrationEventClassName %>;
+<% } %>
+import <%= packageName %>.<%= moduleName %>.application.usecases.<%= syncHandlerName %>;
+import <%= packageName %>.shared.infrastructure.eventEnvelope.EventEnvelope;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.kafka.support.Acknowledgment;
+import org.springframework.stereotype.Component;
+
+import java.util.Map;
+<% if (isUpsert) { %>
+<% const needsBigDecimal = fields && fields.some(f => f.javaType === 'BigDecimal'); %>
+<% const needsLocalDate  = fields && fields.some(f => ['LocalDate','LocalDateTime','LocalTime'].includes(f.javaType)); %>
+<% const needsInstant    = fields && fields.some(f => f.javaType === 'Instant'); %>
+<% const needsUUID       = fields && fields.some(f => f.javaType === 'UUID'); %>
+<% if (needsBigDecimal) { %>import java.math.BigDecimal;
+<% } %><% if (needsLocalDate) { %>import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+<% } %><% if (needsInstant) { %>import java.time.Instant;
+<% } %><% if (needsUUID) { %>import java.util.UUID;
+<% } %>
+<% } %>
+
+/**
+ * Kafka listener for read model sync — topic: <%= topicConstant %>.
+ * Delegates to <%= syncHandlerName %>.on<%= eventBaseName %>().
+ */
+@Component("<%= moduleName %>.<%= listenerClassName %>")
+public class <%= listenerClassName %> {
+
+    private final <%= syncHandlerName %> syncHandler;
+    private final ObjectMapper objectMapper;
+
+    public <%= listenerClassName %>(<%= syncHandlerName %> syncHandler, ObjectMapper objectMapper) {
+        this.syncHandler = syncHandler;
+        this.objectMapper = objectMapper;
+    }
+
+    @KafkaListener(topics = "<%= topicSpringProperty %>", groupId = "${spring.application.name}-<%= moduleName %>-group")
+    public void handle(EventEnvelope<Map<String, Object>> event, Acknowledgment ack) {
+<% if (isUpsert) { %>
+<% (fields || []).forEach(f => { %>
+        <%- f.javaType %> <%= f.name %> = objectMapper.convertValue(event.data().get("<%= f.payloadKey || f.name %>"), <%- f.javaType %>.class);
+<% }); %>
+
+        syncHandler.on<%= eventBaseName %>(new <%= integrationEventClassName %>(
+<% (fields || []).forEach((f, i) => { %>
+                <%= f.name %><%= i < fields.length - 1 ? ',' : '' %>
+<% }); %>
+        ));
+<% } else { %>
+        String id = objectMapper.convertValue(event.data().get("<%= (fields[0] && fields[0].payloadKey) || 'id' %>"), String.class);
+        syncHandler.on<%= eventBaseName %>(id);
+<% } %>
+
+        ack.acknowledge();
+    }
+}

package/templates/read-model/ReadModelRepository.java.ejs

@@ -0,0 +1,42 @@
+package <%= packageName %>.<%= moduleName %>.domain.repositories;
+<% const needsBigDecimal = fields && fields.some(f => f.javaType === 'BigDecimal'); %>
+<% const needsLocalDate  = fields && fields.some(f => ['LocalDate','LocalDateTime','LocalTime'].includes(f.javaType)); %>
+<% const needsInstant    = fields && fields.some(f => f.javaType === 'Instant'); %>
+<% const needsUUID       = fields && fields.some(f => f.javaType === 'UUID'); %>
+<% if (needsBigDecimal) { %>
+import java.math.BigDecimal;
+<% } %>
+<% if (needsLocalDate) { %>
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+<% } %>
+<% if (needsInstant) { %>
+import java.time.Instant;
+<% } %>
+<% if (needsUUID) { %>
+import java.util.UUID;
+<% } %>
+
+import <%= packageName %>.<%= moduleName %>.domain.models.readmodels.<%= domainClassName %>;
+
+import java.util.Optional;
+
+/**
+ * Repository interface for the <%= domainClassName %> read model.
+ * Provides read-only access and upsert/delete for event-driven sync.
+ */
+public interface <%= repositoryName %> {
+
+    void upsert(<%= domainClassName %> readModel);
+
+    void deleteById(String id);
+<% if (hasSoftDelete) { %>
+
+    void softDeleteById(String id);
+<% } %>
+
+    Optional<<%= domainClassName %>> findById(String id);
+
+    boolean existsById(String id);
+}

package/templates/read-model/ReadModelRepositoryImpl.java.ejs

@@ -0,0 +1,81 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.database.repositories;
+<% const needsBigDecimal = fields && fields.some(f => f.javaType === 'BigDecimal'); %>
+<% const needsLocalDate  = fields && fields.some(f => ['LocalDate','LocalDateTime','LocalTime'].includes(f.javaType)); %>
+<% const needsInstant    = fields && fields.some(f => f.javaType === 'Instant'); %>
+<% const needsUUID       = fields && fields.some(f => f.javaType === 'UUID'); %>
+<% if (needsBigDecimal) { %>
+import java.math.BigDecimal;
+<% } %>
+<% if (needsLocalDate || hasSoftDelete) { %>
+import java.time.LocalDateTime;
+<% } %>
+<% if (needsInstant) { %>
+import java.time.Instant;
+<% } %>
+<% if (needsUUID) { %>
+import java.util.UUID;
+<% } %>
+
+import <%= packageName %>.<%= moduleName %>.domain.models.readmodels.<%= domainClassName %>;
+import <%= packageName %>.<%= moduleName %>.domain.repositories.<%= repositoryName %>;
+import <%= packageName %>.<%= moduleName %>.infrastructure.database.entities.<%= jpaEntityName %>;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+/**
+ * Repository implementation for the <%= domainClassName %> read model.
+ * Maps between domain read model and JPA entity.
+ */
+@Repository
+public class <%= repositoryImplName %> implements <%= repositoryName %> {
+
+    private final <%= jpaRepositoryName %> jpaRepository;
+
+    public <%= repositoryImplName %>(<%= jpaRepositoryName %> jpaRepository) {
+        this.jpaRepository = jpaRepository;
+    }
+
+    @Override
+    public void upsert(<%= domainClassName %> readModel) {
+        <%= jpaEntityName %> entity = <%= jpaEntityName %>.builder()
+<% fields.forEach(field => { %>
+                .<%= field.name %>(readModel.get<%= field.name.charAt(0).toUpperCase() + field.name.slice(1) %>())
+<% }); %>
+                .build();
+        jpaRepository.save(entity);
+    }
+
+    @Override
+    public void deleteById(String id) {
+        jpaRepository.deleteById(id);
+    }
+
+    @Override
+    public Optional<<%= domainClassName %>> findById(String id) {
+        return jpaRepository.findById(id).map(this::toDomain);
+    }
+
+    @Override
+    public boolean existsById(String id) {
+        return jpaRepository.existsById(id);
+    }
+<% if (hasSoftDelete) { %>
+
+    @Override
+    public void softDeleteById(String id) {
+        jpaRepository.findById(id).ifPresent(entity -> {
+            entity.setDeletedAt(LocalDateTime.now());
+            jpaRepository.save(entity);
+        });
+    }
+<% } %>
+
+    private <%= domainClassName %> toDomain(<%= jpaEntityName %> entity) {
+        return new <%= domainClassName %>(
+<% fields.forEach((field, idx) => { %>
+                entity.get<%= field.name.charAt(0).toUpperCase() + field.name.slice(1) %>()<%= idx < fields.length - 1 ? ',' : '' %>
+<% }); %>
+        );
+    }
+}

package/templates/read-model/ReadModelSyncHandler.java.ejs

@@ -0,0 +1,52 @@
+package <%= packageName %>.<%= moduleName %>.application.usecases;
+<% const upsertEntries = syncedBy.filter(s => s.action === 'UPSERT'); %>
+<% const upsertImports = [...new Set(upsertEntries.map(s => s.integrationEventClassName))]; %>
+<% upsertImports.forEach(cls => { %>
+import <%= packageName %>.<%= moduleName %>.application.events.<%= cls %>;
+<% }); %>
+import <%= packageName %>.<%= moduleName %>.domain.models.readmodels.<%= domainClassName %>;
+import <%= packageName %>.<%= moduleName %>.domain.repositories.<%= repositoryName %>;
+import <%= packageName %>.shared.domain.annotations.ApplicationComponent;
+import <%= packageName %>.shared.domain.annotations.LogExceptions;
+
+/**
+ * Sync handler for the <%= domainClassName %> read model.
+ * Maintains the local projection by processing events from <%= sourceModule %>/<%= sourceName %>.
+ * <p>
+ * One method per syncedBy event — Kafka listeners delegate directly to these methods.
+ */
+@ApplicationComponent
+public class <%= syncHandlerName %> {
+
+    private final <%= repositoryName %> repository;
+
+    public <%= syncHandlerName %>(<%= repositoryName %> repository) {
+        this.repository = repository;
+    }
+<% syncedBy.forEach(sync => { %>
+<% if (sync.action === 'UPSERT') { %>
+
+    @LogExceptions
+    public void on<%= sync.eventBaseName %>(<%= sync.integrationEventClassName %> event) {
+        <%= domainClassName %> model = new <%= domainClassName %>(
+<% fields.forEach((field, idx) => { %>
+                event.<%= field.name %>()<%= idx < fields.length - 1 ? ',' : '' %>
+<% }); %>
+        );
+        repository.upsert(model);
+    }
+<% } else if (sync.action === 'DELETE') { %>
+
+    @LogExceptions
+    public void on<%= sync.eventBaseName %>(String id) {
+        repository.deleteById(id);
+    }
+<% } else if (sync.action === 'SOFT_DELETE') { %>
+
+    @LogExceptions
+    public void on<%= sync.eventBaseName %>(String id) {
+        repository.softDeleteById(id);
+    }
+<% } %>
+<% }); %>
+}