eva4j 1.0.14 → 1.0.16

package/templates/postman/UnifiedCollection.json.ejs

@@ -0,0 +1,185 @@
+<%
+/**
+ * UnifiedCollection.json.ejs
+ *
+ * Generates a single Postman 2.1.0 collection covering ALL modules in the
+ * system.  The hierarchy is:
+ *
+ *   {SystemName} API
+ *   └── {ModuleName}
+ *       └── {AggregateName}
+ *           ├── POST   Create {Agg}
+ *           ├── GET    Get {Agg} by ID
+ *           ├── GET    Get All {Agg}s
+ *           ├── PUT    Update {Agg}
+ *           ├── DELETE Delete {Agg}
+ *           └── PUT    {Custom} {Agg}   (confirm, cancel, …)
+ *
+ * Context expected:
+ *   - systemName        : string
+ *   - collectionId      : string (UUID)
+ *   - port              : number
+ *   - modules           : Array<ModuleCtx>
+ *
+ * ModuleCtx:
+ *   - name              : string   (module name, e.g. "product")
+ *   - aggregates        : Array<AggregateCtx>
+ *
+ * AggregateCtx:
+ *   - name              : string   (PascalCase, e.g. "Product")
+ *   - trackUser         : boolean
+ *   - idType            : string   ("String" | "UUID" | "Long")
+ *   - exampleId         : string
+ *   - operations        : Array<OperationCtx>   (when endpoints: section exists)
+ *   - defaultCrud       : boolean               (true when no endpoints: section)
+ *   - bodies            : { [useCase]: object }  (pre-generated JSON bodies keyed by useCase)
+ *
+ * OperationCtx:
+ *   - useCase           : string
+ *   - method            : string   (GET, POST, PUT, PATCH, DELETE)
+ *   - path              : string   (e.g. "/{id}" or "/publish")
+ *   - basePath          : string   (e.g. "/products")
+ *   - version           : string   (e.g. "v1")
+ */
+
+function buildUrl(port, version, basePath, opPath) {
+  // Normalise: remove leading slash from basePath if present, and from opPath
+  let bPath = basePath.replace(/^\//, '');
+  let oPath = opPath.replace(/^\//, '');
+
+  // Build full path segments
+  const segments = ['api', version];
+  if (bPath) segments.push(...bPath.split('/').filter(Boolean));
+  if (oPath) segments.push(...oPath.split('/').filter(Boolean));
+
+  const raw = 'http://localhost:' + port + '/' + segments.join('/');
+  return { raw, segments, port: String(port) };
+}
+
+function hasBody(method) {
+  return method === 'POST' || method === 'PUT' || method === 'PATCH';
+}
+
+// ----- Build the items tree ------------------------------------------------
+const moduleItems = [];
+
+for (const mod of modules) {
+  const aggregateItems = [];
+
+  for (const agg of mod.aggregates) {
+    const requestItems = [];
+
+    if (agg.operations && agg.operations.length > 0) {
+      // Endpoint-driven: use declared operations
+      for (const op of agg.operations) {
+        const url = buildUrl(port, op.version, op.basePath, op.path);
+        // Replace {id} with example ID
+        const rawUrl = url.raw.replace(/\{id\}/g, agg.exampleId);
+        const pathSegments = url.segments.map(s => s === '{id}' ? agg.exampleId : s);
+
+        const headers = [{ key: 'Content-Type', value: 'application/json', type: 'text' }];
+        if (agg.trackUser) {
+          headers.push({ key: 'X-User', value: 'system', type: 'text' });
+        }
+
+        const item = {
+          name: op.useCase,
+          request: {
+            method: op.method,
+            header: headers,
+            url: {
+              raw: rawUrl,
+              protocol: 'http',
+              host: ['localhost'],
+              port: String(port),
+              path: pathSegments
+            }
+          },
+          response: []
+        };
+
+        if (hasBody(op.method) && agg.bodies[op.useCase]) {
+          item.request.body = {
+            mode: 'raw',
+            raw: JSON.stringify(agg.bodies[op.useCase], null, 2),
+            options: { raw: { language: 'json' } }
+          };
+        }
+
+        requestItems.push(item);
+      }
+    } else if (agg.defaultCrud) {
+      // No endpoints section → generate 5 standard CRUD requests
+      const resource = agg.resourceNameKebab;
+      const crudOps = [
+        { useCase: 'Create ' + agg.name,           method: 'POST',   path: '' },
+        { useCase: 'Get ' + agg.name + ' by ID',   method: 'GET',    path: '/' + agg.exampleId },
+        { useCase: 'Get All ' + agg.name + 's',    method: 'GET',    path: '' },
+        { useCase: 'Update ' + agg.name,            method: 'PUT',    path: '/' + agg.exampleId },
+        { useCase: 'Delete ' + agg.name,            method: 'DELETE', path: '/' + agg.exampleId },
+      ];
+
+      for (const op of crudOps) {
+        const url = buildUrl(port, 'v1', resource, op.path);
+
+        const headers = [{ key: 'Content-Type', value: 'application/json', type: 'text' }];
+        if (agg.trackUser) {
+          headers.push({ key: 'X-User', value: 'system', type: 'text' });
+        }
+
+        const item = {
+          name: op.useCase,
+          request: {
+            method: op.method,
+            header: headers,
+            url: {
+              raw: url.raw,
+              protocol: 'http',
+              host: ['localhost'],
+              port: String(port),
+              path: url.segments
+            }
+          },
+          response: []
+        };
+
+        if (hasBody(op.method) && agg.bodies['default']) {
+          item.request.body = {
+            mode: 'raw',
+            raw: JSON.stringify(agg.bodies['default'], null, 2),
+            options: { raw: { language: 'json' } }
+          };
+        }
+
+        requestItems.push(item);
+      }
+    }
+
+    if (requestItems.length > 0) {
+      aggregateItems.push({
+        name: agg.name,
+        item: requestItems
+      });
+    }
+  }
+
+  if (aggregateItems.length > 0) {
+    moduleItems.push({
+      name: mod.name,
+      item: aggregateItems
+    });
+  }
+}
+
+const collection = {
+  info: {
+    _postman_id: collectionId,
+    name: systemName + ' API',
+    description: 'Auto-generated unified API collection for all modules in ' + systemName + '.\nGenerated by eva4j with realistic fake data.',
+    schema: 'https://schema.getpostman.com/json/collection/v2.1.0/collection.json',
+    version: '1.0.0'
+  },
+  item: moduleItems
+};
+%>
+<%- JSON.stringify(collection, null, 2) %>

package/templates/shared/annotations/LogAfter.java.ejs

@@ -8,4 +8,6 @@ import java.lang.annotation.Target;
 @Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface LogAfter {
+    LogLevel level() default LogLevel.INFO;
+    String[] excludeArgs() default {};
 }

package/templates/shared/annotations/LogBefore.java.ejs

@@ -8,4 +8,6 @@ import java.lang.annotation.Target;
 @Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface LogBefore {
+    LogLevel level() default LogLevel.INFO;
+    String[] excludeArgs() default {};
 }

package/templates/shared/annotations/LogExceptions.java.ejs

@@ -8,4 +8,6 @@ import java.lang.annotation.Target;
 @Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface LogExceptions {
+    LogLevel level() default LogLevel.WARN;
+    String[] excludeArgs() default {};
 }

package/templates/shared/annotations/LogLevel.java.ejs

@@ -0,0 +1,8 @@
+package <%= packageName %>.shared.domain.annotations;
+
+public enum LogLevel {
+    TRACE,
+    DEBUG,
+    INFO,
+    WARN;
+}

package/templates/shared/annotations/LogTimer.java.ejs

@@ -8,4 +8,5 @@ import java.lang.annotation.Target;
 @Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface LogTimer {
+    LogLevel level() default LogLevel.INFO;
 }

package/templates/shared/annotations/Loggable.java.ejs

@@ -0,0 +1,17 @@
+package <%= packageName %>.shared.domain.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Loggable {
+    boolean before() default true;
+    boolean after() default true;
+    boolean exceptions() default true;
+    boolean timer() default false;
+    LogLevel level() default LogLevel.INFO;
+    String[] excludeArgs() default {};
+}

package/templates/shared/configurations/eventPublicationConfig/EventPublicationSchemaConfig.java.ejs

@@ -0,0 +1,109 @@
+package <%= packageName %>.shared.infrastructure.configurations.eventPublicationConfig;
+
+import java.util.Map;
+import javax.sql.DataSource;
+
+import org.hibernate.boot.model.relational.Namespace;
+import org.hibernate.boot.model.relational.Sequence;
+import org.hibernate.mapping.Table;
+import org.hibernate.tool.schema.spi.SchemaFilter;
+import org.hibernate.tool.schema.spi.SchemaFilterProvider;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.boot.autoconfigure.orm.jpa.HibernatePropertiesCustomizer;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * Fixes Spring Modulith JPA event_publication table columns.
+ * <p>
+ * Hibernate maps the internal {@code JpaEventPublication} String fields
+ * as {@code varchar(255)} by default, which is too short for serialised
+ * domain event payloads.
+ * <p>
+ * This config does two things:
+ * <ol>
+ *   <li>Excludes the {@code event_publication} table from Hibernate DDL auto
+ *       so it never tries to ALTER columns back to {@code varchar(255)}.</li>
+ *   <li>Runs an {@link ApplicationRunner} that ensures the columns are {@code TEXT}.</li>
+ * </ol>
+ */
+@Configuration
+public class EventPublicationSchemaConfig implements HibernatePropertiesCustomizer {
+
+    private static final Logger log = LoggerFactory.getLogger(EventPublicationSchemaConfig.class);
+
+    @Override
+    public void customize(Map<String, Object> hibernateProperties) {
+        hibernateProperties.put(
+            "hibernate.hbm2ddl.schema_filter_provider",
+            new EventPublicationFilterProvider()
+        );
+    }
+
+    @Bean
+    ApplicationRunner eventPublicationSchemaFix(DataSource dataSource) {
+        return args -> {
+            try (var conn = dataSource.getConnection()) {
+                var db = conn.getMetaData().getDatabaseProductName().toLowerCase();
+                String[] statements;
+
+                if (db.contains("postgre")) {
+                    statements = new String[]{
+                        "CREATE TABLE IF NOT EXISTS event_publication (id UUID NOT NULL PRIMARY KEY, completion_date TIMESTAMP, event_type TEXT NOT NULL, listener_id TEXT NOT NULL, publication_date TIMESTAMP, serialized_event TEXT NOT NULL)",
+                        "ALTER TABLE event_publication ALTER COLUMN serialized_event TYPE TEXT",
+                        "ALTER TABLE event_publication ALTER COLUMN event_type TYPE TEXT",
+                        "ALTER TABLE event_publication ALTER COLUMN listener_id TYPE TEXT"
+                    };
+                } else if (db.contains("mysql") || db.contains("maria")) {
+                    statements = new String[]{
+                        "CREATE TABLE IF NOT EXISTS event_publication (id VARCHAR(36) NOT NULL PRIMARY KEY, completion_date DATETIME, event_type TEXT NOT NULL, listener_id TEXT NOT NULL, publication_date DATETIME, serialized_event TEXT NOT NULL)",
+                        "ALTER TABLE event_publication MODIFY COLUMN serialized_event TEXT",
+                        "ALTER TABLE event_publication MODIFY COLUMN event_type TEXT",
+                        "ALTER TABLE event_publication MODIFY COLUMN listener_id TEXT"
+                    };
+                } else {
+                    // H2 and other databases
+                    statements = new String[]{
+                        "CREATE TABLE IF NOT EXISTS event_publication (id UUID NOT NULL PRIMARY KEY, completion_date TIMESTAMP, event_type TEXT NOT NULL, listener_id TEXT NOT NULL, publication_date TIMESTAMP, serialized_event TEXT NOT NULL)",
+                        "ALTER TABLE IF EXISTS event_publication ALTER COLUMN serialized_event TEXT",
+                        "ALTER TABLE IF EXISTS event_publication ALTER COLUMN event_type TEXT",
+                        "ALTER TABLE IF EXISTS event_publication ALTER COLUMN listener_id TEXT"
+                    };
+                }
+
+                for (var sql : statements) {
+                    try (var stmt = conn.createStatement()) {
+                        stmt.execute(sql);
+                    } catch (Exception e) {
+                        // Column already TEXT or statement not applicable — safe to ignore
+                    }
+                }
+                log.debug("event_publication columns verified (TEXT)");
+            }
+        };
+    }
+
+    // ── Hibernate Schema Filter ────────────────────────────────────────────
+    // Excludes event_publication from ddl-auto so Hibernate never tries
+    // to ALTER its columns back to varchar(255).
+
+    static class EventPublicationFilterProvider implements SchemaFilterProvider {
+        private static final SchemaFilter FILTER = new EventPublicationFilter();
+
+        @Override public SchemaFilter getCreateFilter()    { return FILTER; }
+        @Override public SchemaFilter getDropFilter()      { return FILTER; }
+        @Override public SchemaFilter getMigrateFilter()   { return FILTER; }
+        @Override public SchemaFilter getValidateFilter()  { return FILTER; }
+        @Override public SchemaFilter getTruncatorFilter() { return FILTER; }
+    }
+
+    static class EventPublicationFilter implements SchemaFilter {
+        @Override public boolean includeNamespace(Namespace namespace) { return true; }
+        @Override public boolean includeSequence(Sequence sequence)    { return true; }
+        @Override public boolean includeTable(Table table) {
+            return !"event_publication".equalsIgnoreCase(table.getName());
+        }
+    }
+}

package/templates/shared/configurations/loggerConfig/HandlerLogs.java.ejs

@@ -1,56 +1,144 @@
 package <%= packageName %>.shared.infrastructure.configurations.loggerConfig;
 
-import org.apache.logging.log4j.LogManager;
+import <%= packageName %>.shared.domain.annotations.*;
 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.*;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Component;
 
+import java.util.Set;
+import java.util.StringJoiner;
 
 @Component
 @Aspect
 public class HandlerLogs {
 
-  @Before("@annotation(<%= packageName %>.shared.domain.annotations.LogBefore)")
-  public void executionBeforeMethod(JoinPoint joinPoint){
-    LogManager.getLogger(joinPoint.getSignature().getDeclaringTypeName()).info(
-            "Method {} executed with {} arguments",
-            joinPoint.getSignature().getName(),
-            joinPoint.getArgs()
-    );
+  // ── Individual annotations ──────────────────────────────────────
+
+  @Before("@annotation(logBefore)")
+  public void executionBeforeMethod(JoinPoint joinPoint, LogBefore logBefore) {
+    Logger logger = getLogger(joinPoint);
+    log(logger, logBefore.level(),
+        "▶ Entering {} with args: [{}]",
+        joinPoint.getSignature().getName(),
+        formatArgs(joinPoint, Set.of(logBefore.excludeArgs())));
   }
 
-  @AfterReturning(pointcut = "@annotation(<%= packageName %>.shared.domain.annotations.LogAfter)")
-  public void executionSuccessMethod(JoinPoint joinPoint){
-    LogManager.getLogger(joinPoint.getSignature().getDeclaringTypeName()).info(
-            "Method {} executed with {} arguments",
-            joinPoint.getSignature().getName(),
-            joinPoint.getArgs()
-    );
+  @AfterReturning(pointcut = "@annotation(logAfter)", returning = "result")
+  public void executionSuccessMethod(JoinPoint joinPoint, LogAfter logAfter, Object result) {
+    Logger logger = getLogger(joinPoint);
+    log(logger, logAfter.level(),
+        "◀ Completed {} with args: [{}] | return: {}",
+        joinPoint.getSignature().getName(),
+        formatArgs(joinPoint, Set.of(logAfter.excludeArgs())),
+        result);
   }
 
-  @AfterThrowing(pointcut = "@annotation(<%= packageName %>.shared.domain.annotations.LogExceptions)", throwing = "exception")
-  public void executionFailMethod(JoinPoint joinPoint, Exception exception){
-    LogManager.getLogger(joinPoint.getSignature().getDeclaringTypeName()).error(
-            "Method {} executed with {} arguments throw exception: {}",
-            joinPoint.getSignature().getName(),
-            joinPoint.getArgs(),
-            exception.getClass().getSimpleName()
-    );
+  @AfterThrowing(pointcut = "@annotation(logExceptions)", throwing = "exception")
+  public void executionFailMethod(JoinPoint joinPoint, LogExceptions logExceptions, Exception exception) {
+    Logger logger = getLogger(joinPoint);
+    log(logger, logExceptions.level(),
+        "✖ Method {} failed with args: [{}] | exception: {} | message: {}",
+        joinPoint.getSignature().getName(),
+        formatArgs(joinPoint, Set.of(logExceptions.excludeArgs())),
+        exception.getClass().getSimpleName(),
+        exception.getMessage());
   }
 
-  @Around("@annotation(<%= packageName %>.shared.domain.annotations.LogTimer)")
-  public Object executionTimeMethod(ProceedingJoinPoint joinPoint) throws Throwable {
+  @Around("@annotation(logTimer)")
+  public Object executionTimeMethod(ProceedingJoinPoint joinPoint, LogTimer logTimer) throws Throwable {
     long start = System.currentTimeMillis();
-    Object proceed = joinPoint.proceed();
+    Object result = joinPoint.proceed();
     long executionTime = System.currentTimeMillis() - start;
-    LogManager.getLogger(joinPoint.getSignature().getDeclaringTypeName()).info(
-            "Method {} executed in {} ms",
-            joinPoint.getSignature().getName(),
-            executionTime
-    );
-    return proceed;
+    Logger logger = getLogger(joinPoint);
+    log(logger, logTimer.level(),
+        "⏱ Method {} executed in {} ms",
+        joinPoint.getSignature().getName(),
+        executionTime);
+    return result;
   }
 
+  // ── Unified @Loggable annotation ───────────────────────────────
+
+  @Around("@annotation(loggable)")
+  public Object executionLoggableMethod(ProceedingJoinPoint joinPoint, Loggable loggable) throws Throwable {
+    Logger logger = getLogger(joinPoint);
+    String methodName = joinPoint.getSignature().getName();
+    Set<String> excluded = Set.of(loggable.excludeArgs());
+
+    if (loggable.before()) {
+      log(logger, loggable.level(),
+          "▶ Entering {} with args: [{}]",
+          methodName,
+          formatArgs(joinPoint, excluded));
+    }
+
+    long start = loggable.timer() ? System.currentTimeMillis() : 0;
+
+    try {
+      Object result = joinPoint.proceed();
+
+      if (loggable.after()) {
+        log(logger, loggable.level(),
+            "◀ Completed {} with args: [{}] | return: {}",
+            methodName,
+            formatArgs(joinPoint, excluded),
+            result);
+      }
+
+      if (loggable.timer()) {
+        long executionTime = System.currentTimeMillis() - start;
+        log(logger, loggable.level(),
+            "⏱ Method {} executed in {} ms",
+            methodName,
+            executionTime);
+      }
+
+      return result;
+    } catch (Exception exception) {
+      if (loggable.exceptions()) {
+        logger.warn("✖ Method {} failed with args: [{}] | exception: {} | message: {}",
+            methodName,
+            formatArgs(joinPoint, excluded),
+            exception.getClass().getSimpleName(),
+            exception.getMessage());
+      }
+      throw exception;
+    }
+  }
 
+  // ── Private helpers ────────────────────────────────────────────
+
+  private Logger getLogger(JoinPoint joinPoint) {
+    return LoggerFactory.getLogger(joinPoint.getSignature().getDeclaringTypeName());
+  }
+
+  private String formatArgs(JoinPoint joinPoint, Set<String> excludedArgs) {
+    MethodSignature signature = (MethodSignature) joinPoint.getSignature();
+    String[] paramNames = signature.getParameterNames();
+    Object[] args = joinPoint.getArgs();
+
+    if (paramNames == null || paramNames.length == 0) {
+      return "";
+    }
+
+    StringJoiner joiner = new StringJoiner(", ");
+    for (int i = 0; i < paramNames.length; i++) {
+      joiner.add(paramNames[i] + "=" +
+          (excludedArgs.contains(paramNames[i]) ? "[PROTECTED]" : args[i]));
+    }
+    return joiner.toString();
+  }
+
+  private void log(Logger logger, LogLevel level, String message, Object... args) {
+    switch (level) {
+      case TRACE -> logger.trace(message, args);
+      case DEBUG -> logger.debug(message, args);
+      case INFO  -> logger.info(message, args);
+      case WARN  -> logger.warn(message, args);
+    }
+  }
 }

package/templates/shared/errorMessage/ErrorResponse.java.ejs

@@ -0,0 +1,23 @@
+package <%= packageName %>.shared.domain.errorMessage;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public record ErrorResponse(
+        LocalDateTime timestamp,
+        int status,
+        String error,
+        String message,
+        List<String> details
+) {
+    public ErrorResponse(int status, String error, String message) {
+        this(LocalDateTime.now(), status, error, message, null);
+    }
+
+    public ErrorResponse(int status, String error, String message, List<String> details) {
+        this(LocalDateTime.now(), status, error, message, details);
+    }
+}