@acorex/platform 20.7.4 → 20.7.5

package/fesm2022/acorex-platform-workflow.mjs

@@ -966,6 +966,11 @@ class WorkflowExpressionScopeService {
                 Object.assign(outputs, activityOutputs);
             }
         }
+        // Convenience alias for the last activity output (if available).
+        // This allows expressions like: {{outputs.last.someField}}
+        if (outputs['last'] === undefined && state.lastActivityOutput !== undefined) {
+            outputs['last'] = state.lastActivityOutput;
+        }
         return this.buildScope({
             inputs: state.input || {},
             variables: state.variables || {},
@@ -1020,11 +1025,16 @@ class ActivityExecutor {
     async execute(task, workflowState, activityOutputs) {
         try {
             const activityName = task.activityType;
+            debugger;
             // Evaluate inputs if workflow state is provided
             let evaluatedInputs = task.input || {};
             if (workflowState) {
+                // Prefer explicit outputs, fallback to outputs stored in state
+                const outputsForScope = activityOutputs ??
+                    workflowState.activityOutputs ??
+                    undefined;
                 // Build expression scope from workflow state
-                const scope = this.expressionScopeService.buildScopeFromState(workflowState, activityOutputs);
+                const scope = this.expressionScopeService.buildScopeFromState(workflowState, outputsForScope);
                 // Evaluate all inputs recursively (handles nested objects and arrays)
                 evaluatedInputs = await this.expressionEvaluator.evaluate(task.input || {}, scope);
             }
@@ -1147,11 +1157,15 @@ class AXPWorkflowManager {
      * @param lastActivityOutput - Last activity output (for expression evaluation)
      * @returns Final result with nextTask (if human-task) or completion status
      */
-    async executeInteractiveFlow(instanceId, task, state, lastActivityOutput) {
+    async executeInteractiveFlow(instanceId, task, state, activityOutputs) {
         // Backend decides what to execute - frontend only executes ui-activity with frontend/both executionMode
         // If backend returns a task that's not executable here, return it as-is
         let currentTask = task;
         let currentState = state;
+        let currentActivityOutputs = {
+            ...(currentState.activityOutputs || {}),
+            ...(activityOutputs || {}),
+        };
         const maxIterations = 100; // Prevent infinite loops
         let iterationCount = 0;
         while (currentTask && iterationCount < maxIterations) {
@@ -1161,7 +1175,12 @@ class AXPWorkflowManager {
             if (currentTask.taskType === 'ui-activity' &&
                 (currentTask.executionMode === 'frontend' || currentTask.executionMode === 'both')) {
                 // Execute frontend activity
-                const execResult = await this.activityExecutor.execute(currentTask, currentState, lastActivityOutput);
+                const execResult = await this.activityExecutor.execute(currentTask, currentState, currentActivityOutputs);
+                // Track outputs locally (backend should also persist and return them)
+                currentActivityOutputs = {
+                    ...currentActivityOutputs,
+                    [currentTask.activityId]: execResult.output,
+                };
                 // Send result to backend
                 const completeResponse = await this.workflowEngine.frontActivtyComplete({
                     instanceId,
@@ -1176,6 +1195,11 @@ class AXPWorkflowManager {
                         normalizedState.lastUpdated = new Date(normalizedState.lastUpdated);
                     }
                     currentState = normalizedState;
+                    // Prefer outputs returned by backend; fallback to local cache
+                    currentActivityOutputs = {
+                        ...currentActivityOutputs,
+                        ...(normalizedState.activityOutputs || {}),
+                    };
                     this.stateCache.set(instanceId, normalizedState);
                 }
                 // Backend decides: if no nextTask, workflow is completed
@@ -1197,7 +1221,6 @@ class AXPWorkflowManager {
                 }
                 // Continue with next executable frontend task
                 currentTask = completeResponse.nextTask;
-                lastActivityOutput = execResult.output;
             }
             else {
                 // Not a frontend ui-activity - return as-is
@@ -1259,7 +1282,7 @@ class AXPWorkflowManager {
             if (response.pendingTask &&
                 response.pendingTask.taskType === 'ui-activity' &&
                 (response.pendingTask.executionMode === 'frontend' || response.pendingTask.executionMode === 'both')) {
-                const interactiveResult = await this.executeInteractiveFlow(response.instanceId, response.pendingTask, startNormalizedState, response.lastActivityOutput);
+                const interactiveResult = await this.executeInteractiveFlow(response.instanceId, response.pendingTask, startNormalizedState, response.activityOutputs || response.state.activityOutputs);
                 finalNextTask = interactiveResult.nextTask;
                 startNormalizedState = interactiveResult.state;
                 if (interactiveResult.output !== undefined) {
@@ -1329,7 +1352,7 @@ class AXPWorkflowManager {
             if (response.nextTask &&
                 response.nextTask.taskType === 'ui-activity' &&
                 (response.nextTask.executionMode === 'frontend' || response.nextTask.executionMode === 'both')) {
-                const interactiveResult = await this.executeInteractiveFlow(instanceId, response.nextTask, normalizedState);
+                const interactiveResult = await this.executeInteractiveFlow(instanceId, response.nextTask, normalizedState, normalizedState?.activityOutputs);
                 finalNextTask = interactiveResult.nextTask;
                 normalizedState = interactiveResult.state;
                 if (interactiveResult.output !== undefined) {
@@ -1484,6 +1507,8 @@ class AXPWorkflowLocalEngine {
             workflowId: request.workflowId,
             status: 'running',
             variables: {},
+            activityOutputs: {},
+            lastActivityOutput: undefined,
             input: request.input || {},
             output: undefined,
             lastUpdated: now,
@@ -1514,6 +1539,8 @@ class AXPWorkflowLocalEngine {
             instanceId,
             state: localState.state,
             pendingTask: pendingTask || null,
+            activityOutputs: localState.state.activityOutputs,
+            lastActivityOutput: localState.state.lastActivityOutput,
         };
     }
     /**
@@ -1539,6 +1566,12 @@ class AXPWorkflowLocalEngine {
             outcome: request.outcome,
         });
         localState.completedActivities.add(request.stepId);
+        // Store activity output for expression evaluation
+        localState.state.activityOutputs = {
+            ...(localState.state.activityOutputs || {}),
+            [request.stepId]: request.userInput || {},
+        };
+        localState.state.lastActivityOutput = request.userInput || {};
         // Merge output/userInput into state variables
         if (request.userInput) {
             localState.state.variables = {
@@ -1757,7 +1790,42 @@ class AXPWorkflowLocalEngine {
         return null;
     }
     async frontActivtyComplete(request) {
-        return {};
+        const localState = this.instances.get(request.instanceId);
+        if (!localState) {
+            throw new Error(`Workflow instance not found: ${request.instanceId}`);
+        }
+        // Store activity result
+        localState.activityResults.set(request.activityNode, {
+            output: request.output || {},
+            outcome: request.outcome,
+        });
+        localState.completedActivities.add(request.activityNode);
+        // Store outputs for expression evaluation
+        localState.state.activityOutputs = {
+            ...(localState.state.activityOutputs || {}),
+            [request.activityNode]: request.output || {},
+        };
+        localState.state.lastActivityOutput = request.output || {};
+        // Merge output into workflow variables
+        localState.state.variables = {
+            ...localState.state.variables,
+            ...(request.output || {}),
+        };
+        // Continue workflow progression
+        const nextTask = await this.executeWorkflowSteps(localState);
+        // Update state timestamp
+        localState.state.lastUpdated = new Date();
+        // Determine final status
+        if (!nextTask && localState.state.status === 'running') {
+            localState.state.status = 'completed';
+            localState.state.output = localState.state.variables;
+        }
+        return {
+            output: request.output || {},
+            outcomes: { [request.outcome]: true },
+            nextTask: nextTask || null,
+            state: localState.state,
+        };
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPWorkflowLocalEngine, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPWorkflowLocalEngine }); }