eva4j 1.0.17 → 1.0.18

package/templates/temporal-flow/WorkFlowImpl.java.ejs

@@ -1,10 +1,176 @@
 package <%= packageName %>.<%= moduleName %>.application.usecases;
+<%
+// ─── Dual mode: rich (from temporal-system) or simple (from temporal-flow) ──
+const isRichMode = typeof stubActivities !== 'undefined' && Array.isArray(stubActivities);
+-%>
+<% if (isRichMode) { -%>
+<%
+// ─── Helper: parse timeout string to Duration call ──────────────────────────
+function durationOf(t) {
+    if (!t) return 'Duration.ofSeconds(30)';
+    return `Duration.of${t.unit}(${t.value})`;
+}
+-%>
+
+import io.temporal.activity.ActivityOptions;
+import io.temporal.common.RetryOptions;
+<% if (isSaga) { -%>
+import io.temporal.workflow.Saga;
+<% } -%>
+<% if (hasParallelSteps || hasAsyncSteps) { -%>
+import io.temporal.workflow.Async;
+<% } -%>
+<% if (hasParallelSteps) { -%>
+import io.temporal.workflow.Promise;
+<% } -%>
+import io.temporal.workflow.Workflow;
+
+import java.time.Duration;
+<% /* Collect imports for all shared + local activity interfaces and DTOs */ -%>
+<%
+// Build imports with a Map keyed by simple name to prevent duplicate-simple-name
+// compile errors when a local nestedType and a shared type share the same class name.
+// Rule: shared imports (*.shared.domain.contracts.*) always win over local ones.
+const importMap = new Map(); // simpleName → full import statement
+function addImport(fqn) {
+  const simpleName = fqn.split('.').pop().replace(';', '');
+  const existing = importMap.get(simpleName);
+  if (!existing) {
+    importMap.set(simpleName, fqn);
+  } else if (existing !== fqn) {
+    // Collision: prefer shared contract over local dtos/temporal
+    if (fqn.includes('.shared.domain.contracts.')) importMap.set(simpleName, fqn);
+  }
+}
+-%>
+<% for (const stub of stubActivities) { -%>
+<%   if (stub.isLocal) { -%>
+<%     addImport(`import ${packageName}.${moduleName}.application.ports.${stub.interfaceName};`); -%>
+<%     if (stub.hasInput) addImport(`import ${packageName}.${moduleName}.application.dtos.temporal.${stub.activityName}Input;`); -%>
+<%     if (stub.hasOutput) addImport(`import ${packageName}.${moduleName}.application.dtos.temporal.${stub.activityName}Output;`); -%>
+<%     if (stub.nestedTypeImports) for (const nti of stub.nestedTypeImports) { addImport(nti.isExternal ? `import ${packageName}.shared.domain.contracts.${nti.sourceModule}.${nti.name};` : `import ${packageName}.${moduleName}.application.dtos.temporal.${nti.name};`); } -%>
+<%   } else { -%>
+<%     addImport(`import ${packageName}.shared.domain.contracts.${stub.targetModule}.${stub.interfaceName};`); -%>
+<%     if (stub.hasInput) addImport(`import ${packageName}.shared.domain.contracts.${stub.targetModule}.${stub.activityName}Input;`); -%>
+<%     if (stub.hasOutput) addImport(`import ${packageName}.shared.domain.contracts.${stub.targetModule}.${stub.activityName}Output;`); -%>
+<%     if (stub.nestedTypeImports) for (const nti of stub.nestedTypeImports) { addImport(nti.isExternal ? `import ${packageName}.shared.domain.contracts.${nti.sourceModule}.${nti.name};` : `import ${packageName}.shared.domain.contracts.${stub.targetModule}.${nti.name};`); } -%>
+<%   } -%>
+<% } -%>
+<%= Array.from(importMap.values()).sort().join('\n') %>
+
+public class <%= flowPascalCase %>WorkFlowImpl implements <%= flowPascalCase %>WorkFlow {
+
+    // ─── Activity stubs ─────────────────────────────────────────────────────
+<% for (const stub of stubActivities) { %>
+    private final <%= stub.interfaceName %> <%= stub.stubVarName %> = Workflow.newActivityStub(
+        <%= stub.interfaceName %>.class,
+        ActivityOptions.newBuilder()
+            .setTaskQueue("<%= stub.queue %>")
+            .setStartToCloseTimeout(<%= durationOf(stub.timeout) %>)
+            .setRetryOptions(
+                RetryOptions.newBuilder()
+                    .setMaximumAttempts(2)
+                    .setInitialInterval(Duration.ofSeconds(1))
+                    .setMaximumInterval(Duration.ofSeconds(10))
+                    .setBackoffCoefficient(2.0)
+                    .build()
+            ).build());
+<% } -%>
+
+    private String status = "PENDING";
+
+    @Override
+    public void start(<%= flowPascalCase %>Input input) {
+<% if (isSaga) { -%>
+        Saga saga = new Saga(new Saga.Options.Builder().setParallelCompensation(false).build());
+        try {
+<% } -%>
+<%
+// ─── Render blocks ──────────────────────────────────────────────────────────
+const indent = isSaga ? '            ' : '        ';
+for (const block of renderBlocks) {
+    if (block.type === 'sequential') {
+        const step = block.step;
+-%>
+<%= indent %>// Step <%= step.index + 1 %>: <%= step.activityName %><%= step.isLocal ? ' (local)' : ` (→ ${step.targetModule})` %><%= step.isOptional ? ' [optional]' : '' %>
+<% if (step.isOptional) { -%>
+<%= indent %>try {
+<% } -%>
+<% const optIndent = step.isOptional ? indent + '    ' : indent; -%>
+<% if (step.hasOutput) { -%>
+<%= optIndent %><%= step.activityName %>Output <%= step.activityCamel %>Result = <%= step.activityCamel %>Activity.execute(<% if (step.hasInput) { %>
+<%= optIndent %>    new <%= step.activityName %>Input(<%= step.inputSources.map(src => src.source === 'input' ? `input.${src.fieldName}()` : `${src.varName}.${src.fieldName}()`).join(', ') %>)<% } %>);
+<% } else { -%>
+<%= optIndent %><%= step.activityCamel %>Activity.execute(<% if (step.hasInput) { %>
+<%= optIndent %>    new <%= step.activityName %>Input(<%= step.inputSources.map(src => src.source === 'input' ? `input.${src.fieldName}()` : `${src.varName}.${src.fieldName}()`).join(', ') %>)<% } %>);
+<% } -%>
+<% if (step.compensation && isSaga) { -%>
+<%= optIndent %>saga.addCompensation(() -> <%= step.compensation.name.charAt(0).toLowerCase() + step.compensation.name.slice(1) %>Activity.execute(
+<%= optIndent %>    new <%= step.compensation.name %>Input(<%= step.compensation.inputSources.map(src => src.source === 'input' ? `input.${src.fieldName}()` : `${src.varName}.${src.fieldName}()`).join(', ') %>)));
+<% } -%>
+<% if (step.isOptional) { -%>
+<%= indent %>} catch (Exception e) {
+<%= indent %>    // Optional step — continue on failure
+<%= indent %>}
+<% } -%>
+
+<%  } else if (block.type === 'parallel') { -%>
+<%= indent %>// Steps <%= block.steps.map(s => s.index + 1).join('-') %>: Parallel execution
+<% for (const step of block.steps) { -%>
+<% if (step.hasOutput) { -%>
+<%= indent %>Promise<<%= step.activityName %>Output> <%= step.activityCamel %>Promise = Async.function(
+<%= indent %>    () -> <%= step.activityCamel %>Activity.execute(<% if (step.hasInput) { %>new <%= step.activityName %>Input(<%= step.inputSources.map(src => src.source === 'input' ? `input.${src.fieldName}()` : `${src.varName}.${src.fieldName}()`).join(', ') %>)<% } %>));
+<% } else { -%>
+<%= indent %>Promise<Void> <%= step.activityCamel %>Promise = Async.procedure(
+<%= indent %>    () -> <%= step.activityCamel %>Activity.execute(<% if (step.hasInput) { %>new <%= step.activityName %>Input(<%= step.inputSources.map(src => src.source === 'input' ? `input.${src.fieldName}()` : `${src.varName}.${src.fieldName}()`).join(', ') %>)<% } %>));
+<% } -%>
+<% if (step.compensation && isSaga) { -%>
+<%= indent %>saga.addCompensation(() -> <%= step.compensation.name.charAt(0).toLowerCase() + step.compensation.name.slice(1) %>Activity.execute(
+<%= indent %>    new <%= step.compensation.name %>Input(<%= step.compensation.inputSources.map(src => src.source === 'input' ? `input.${src.fieldName}()` : `${src.varName}.${src.fieldName}()`).join(', ') %>)));
+<% } -%>
+<% } -%>
+
+<%= indent %>// Wait for parallel results
+<% for (const step of block.steps) { -%>
+<% if (step.hasOutput) { -%>
+<%= indent %><%= step.activityName %>Output <%= step.activityCamel %>Result = <%= step.activityCamel %>Promise.get();
+<% } else { -%>
+<%= indent %><%= step.activityCamel %>Promise.get();
+<% } -%>
+<% } -%>
+
+<%  } else if (block.type === 'async') {
+        const step = block.step;
+-%>
+<%= indent %>// Step <%= step.index + 1 %>: <%= step.activityName %> (fire-and-forget → <%= step.targetModule %>)
+<%= indent %>Async.procedure(() -> <%= step.activityCamel %>Activity.execute(<% if (step.hasInput) { %>
+<%= indent %>    new <%= step.activityName %>Input(<%= step.inputSources.map(src => src.source === 'input' ? `input.${src.fieldName}()` : `${src.varName}.${src.fieldName}()`).join(', ') %>)<% } %>));
+
+<%  }
+} /* end renderBlocks loop */ -%>
+<% if (isSaga) { -%>
+            this.status = "COMPLETED";
+        } catch (Exception e) {
+            saga.compensate();
+            this.status = "COMPENSATED";
+            throw e;
+        }
+<% } else { -%>
+        this.status = "COMPLETED";
+<% } -%>
+    }
+
+    @Override
+    public String getStatus() {
+        return this.status;
+    }
+}
+<% } else { -%>
+<%/* ─── Simple mode (from eva g temporal-flow) ─────────────────────────────── */%>
 
 import io.temporal.activity.ActivityOptions;
 import io.temporal.common.RetryOptions;
 import io.temporal.workflow.Saga;
-import io.temporal.workflow.SignalMethod;
-import io.temporal.workflow.QueryMethod;
 import io.temporal.workflow.Workflow;
 
 import java.time.Duration;
@@ -19,7 +185,7 @@ public class <%= flowPascalCase %>WorkFlowImpl implements <%= flowPascalCase %>W
 
     private final ActivityOptions lightActivityOptions = ActivityOptions.newBuilder()
         .setStartToCloseTimeout(Duration.ofSeconds(30))
-        .setTaskQueue("LIGHT_TASK_QUEUE")
+        .setTaskQueue("<%= moduleScreamingSnake %>_LIGHT_TASK_QUEUE")
         .setRetryOptions(
             RetryOptions.newBuilder()
                 .setMaximumAttempts(2)
@@ -31,7 +197,7 @@ public class <%= flowPascalCase %>WorkFlowImpl implements <%= flowPascalCase %>W
 
     private final ActivityOptions heavyActivityOptions = ActivityOptions.newBuilder()
         .setStartToCloseTimeout(Duration.ofSeconds(120))
-        .setTaskQueue("HEAVY_TASK_QUEUE")
+        .setTaskQueue("<%= moduleScreamingSnake %>_HEAVY_TASK_QUEUE")
         .setRetryOptions(
             RetryOptions.newBuilder()
                 .setMaximumAttempts(2)
@@ -42,7 +208,7 @@ public class <%= flowPascalCase %>WorkFlowImpl implements <%= flowPascalCase %>W
         ).build();
 
     @Override
-    public void start(String workFlowId) {
+    public void start(String flowId) {
         try {
             //todo: workflow logic
         } catch (Exception e) {
@@ -50,15 +216,9 @@ public class <%= flowPascalCase %>WorkFlowImpl implements <%= flowPascalCase %>W
         }
     }
 
-    @SignalMethod
-    @Override
-    public void confirm() {
-
-    }
-
-    @QueryMethod
     @Override
     public String getStatus() {
         return "";
     }
 }
+<% } -%>

package/templates/temporal-flow/WorkFlowInput.java.ejs

@@ -0,0 +1,11 @@
+package <%= packageName %>.<%= moduleName %>.application.usecases;
+<% if (inputImports && inputImports.length > 0) { %>
+<% inputImports.forEach(imp => { -%>
+<%= imp %>
+<% }); -%>
+<% } %>
+public record <%= flowPascalCase %>Input(
+<% inputFields.forEach((field, i) => { -%>
+    <%- field.javaType %> <%= field.name %><%= i < inputFields.length - 1 ? ',' : '' %>
+<% }); -%>
+) {}

package/templates/temporal-flow/WorkFlowInterface.java.ejs

@@ -1,18 +1,19 @@
 package <%= packageName %>.<%= moduleName %>.application.usecases;
 
 import io.temporal.workflow.QueryMethod;
-import io.temporal.workflow.SignalMethod;
 import io.temporal.workflow.WorkflowInterface;
 import io.temporal.workflow.WorkflowMethod;
 
 @WorkflowInterface
 public interface <%= flowPascalCase %>WorkFlow {
+<% const hasTypedInput = typeof inputFields !== 'undefined' && inputFields.length > 0; -%>
 
     @WorkflowMethod
+<% if (hasTypedInput) { -%>
+    void start(<%= flowPascalCase %>Input input);
+<% } else { -%>
     void start(String flowId);
-
-    @SignalMethod
-    void confirm();
+<% } -%>
 
     @QueryMethod
     String getStatus();

package/templates/temporal-flow/WorkFlowService.java.ejs

@@ -10,38 +10,68 @@ public class <%= flowPascalCase %>WorkFlowService {
 
     private final WorkflowClient workflowClient;
     private final String flowQueue;
+<% const hasTypedInput = typeof inputFields !== 'undefined' && inputFields.length > 0; -%>
 
     public <%= flowPascalCase %>WorkFlowService(
         WorkflowClient workflowClient,
-        @Value("${temporal.flow-queue}") String flowQueue
+        @Value("${temporal.modules.<%= moduleName %>.flow-queue}") String flowQueue
     ) {
         this.workflowClient = workflowClient;
         this.flowQueue = flowQueue;
     }
 
+<% if (hasTypedInput) { -%>
+    /**
+     * Starts the workflow asynchronously with the full typed input.
+     */
+    public void startAsync(String workflowId, <%= flowPascalCase %>Input input) {
+        <%= flowPascalCase %>WorkFlow workflow = getWorkflow(workflowId);
+        WorkflowClient.start(workflow::start, input);
+    }
+
+    /**
+     * Starts the workflow synchronously with the full typed input.
+     */
+    public void startSync(String workflowId, <%= flowPascalCase %>Input input) {
+        <%= flowPascalCase %>WorkFlow workflow = getWorkflow(workflowId);
+        workflow.start(input);
+    }
+
+    /**
+     * Bridge method — starts the workflow using only the aggregate ID.
+     * <p>
+     * The generated {@code DomainEventHandler} calls
+     * {@link #startAsync(String, <%= flowPascalCase %>Input)} directly with a
+     * typed input constructed from the domain event fields. Use this overload
+     * only from custom code that can build the input by other means.
+     *
+     * @throws UnsupportedOperationException always — override or call the typed variant
+     */
+    public void startAsync(String workflowId) {
+        throw new UnsupportedOperationException(
+            "Use startAsync(workflowId, " + "<%= flowPascalCase %>Input) — "
+                + "the DomainEventHandler already calls the typed variant");
+    }
+<% } else { -%>
     public void startAsync(String flowId) {
-        <%= flowPascalCase %>WorkFlow workflow = get<%= flowPascalCase %>WorkFlow(flowId);
+        <%= flowPascalCase %>WorkFlow workflow = getWorkflow(flowId);
         WorkflowClient.start(workflow::start, flowId);
     }
 
     public void startSync(String flowId) {
-        <%= flowPascalCase %>WorkFlow workflow = get<%= flowPascalCase %>WorkFlow(flowId);
+        <%= flowPascalCase %>WorkFlow workflow = getWorkflow(flowId);
         workflow.start(flowId);
     }
+<% } -%>
 
-    public void confirm(String flowId) {
-        <%= flowPascalCase %>WorkFlow workflow = get<%= flowPascalCase %>WorkFlow(flowId);
-        workflow.confirm();
-    }
-
-    public String getStatus(String flowId) {
-        <%= flowPascalCase %>WorkFlow workflow = get<%= flowPascalCase %>WorkFlow(flowId);
+    public String getStatus(String workflowId) {
+        <%= flowPascalCase %>WorkFlow workflow = getWorkflow(workflowId);
         return workflow.getStatus();
     }
 
-    private <%= flowPascalCase %>WorkFlow get<%= flowPascalCase %>WorkFlow(String flowId) {
+    private <%= flowPascalCase %>WorkFlow getWorkflow(String workflowId) {
         WorkflowOptions options = WorkflowOptions.newBuilder()
-            .setWorkflowId(flowId)
+            .setWorkflowId(workflowId)
             .setTaskQueue(flowQueue)
             .build();
         return workflowClient.newWorkflowStub(<%= flowPascalCase %>WorkFlow.class, options);