eva4j 1.0.13 → 1.0.15

package/templates/ports/PortRequestDto.java.ejs

@@ -0,0 +1,30 @@
+package <%= packageName %>.<%= moduleName %>.application.dtos;
+<% const needsBigDecimal = bodyFields && bodyFields.some(f => f.javaType === 'BigDecimal'); %>
+<% const needsLocalDate  = bodyFields && bodyFields.some(f => ['LocalDate','LocalDateTime','LocalTime'].includes(f.javaType)); %>
+<% const needsInstant    = bodyFields && bodyFields.some(f => f.javaType === 'Instant'); %>
+<% const needsUUID       = bodyFields && bodyFields.some(f => f.javaType === 'UUID'); %>
+<% const needsList       = bodyFields && bodyFields.some(f => f.javaType && f.javaType.startsWith('List')); %>
+<% 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;
+<% } %><% if (needsList) { %>
+import java.util.List;
+<% } %>
+<% (nestedTypes || []).forEach(nt => { %>import <%= packageName %>.<%= moduleName %>.application.dtos.<%= nt.name %>;
+<% }); %>
+public record <%= dtoName %>(
+<% if (bodyFields && bodyFields.length > 0) { %>
+<% bodyFields.forEach((f, i) => { %>
+    <%- f.javaType %> <%= f.name %><%= i < bodyFields.length - 1 ? ',' : '' %>
+<% }); %>
+<% } else { %>
+    // TODO: Add request body fields
+<% } %>
+) {}

package/templates/ports/PortResponseDto.java.ejs

@@ -0,0 +1,28 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.adapters.<%= adapterPackage %>;
+<% 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'); %>
+<% const needsList       = fields && fields.some(f => f.javaType && f.javaType.startsWith('List')); %>
+<% 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;
+<% } %><% if (needsList) { %>
+import java.util.List;
+<% } %>
+public record <%= dtoName %>(
+<% if (fields && fields.length > 0) { %>
+<% fields.forEach((f, i) => { %>
+    <%- f.javaType %> <%= f.name %><%= i < fields.length - 1 ? ',' : '' %>
+<% }); %>
+<% } else { %>
+    // TODO: Add response fields
+<% } %>
+) {}

package/templates/postman/Collection.json.ejs

@@ -250,7 +250,7 @@ function generateCreateBody() {
       "response": []
     },
     {
-      "name": "Get All <%= aggregateName %>s",
+      "name": "Get All <%= aggregateNamePlural %>",
       "request": {
         "method": "GET",
         "header": [],

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/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());
+        }
+    }
+}