@acorex/connectivity 20.7.4 → 20.7.5

package/fesm2022/acorex-connectivity-mock.mjs

@@ -12019,10 +12019,19 @@ class AXCWorkflowEngine {
         const firstStepId = firstActivity?.id || 'root';
         // Extract correlationId from input if provided (remove it from input to avoid pollution)
         const correlationId = request.input?.['correlationId'] || null;
+        const entityRefId = request.input?.['refId'] || null;
+        const entityRefType = request.input?.['refType'] || null;
         const workflowInput = { ...request.input };
         if (correlationId && workflowInput['correlationId']) {
             delete workflowInput['correlationId'];
         }
+        // Remove refId and refType from workflow input (they're stored in instance metadata)
+        if (entityRefId && workflowInput['refId']) {
+            delete workflowInput['refId'];
+        }
+        if (entityRefType && workflowInput['refType']) {
+            delete workflowInput['refType'];
+        }
         // Create workflow state
         const workflowState = {
             id: `state-${instanceId}`,
@@ -12076,10 +12085,23 @@ class AXCWorkflowEngine {
             incidentCount: 0,
             createdAt: now,
             updatedAt: now,
-            finishedAt: null
+            finishedAt: null,
+            // Store entity reference for work item creation
+            entityRefId: entityRefId || null,
+            entityRefType: entityRefType || null,
         };
         // Store instance in IndexedDB
         await this.db.instances.add(instance, instance.id);
+        console.log(`[AXCWorkflowEngine] 💾 Stored workflow instance:`, {
+            id: instance.id,
+            definitionId: instance.definitionId,
+            name: instance.name,
+            correlationId: instance.correlationId,
+            entityRefId: instance.entityRefId,
+            entityRefType: instance.entityRefType,
+            status: instance.status,
+            subStatus: instance.subStatus,
+        });
         // 🎯 Also store in entity service for entity-based access
         await this.saveInstanceToEntityService(instance);
         // Convert to instance state for response (async - needs bookmark lookup)
@@ -12088,7 +12110,8 @@ class AXCWorkflowEngine {
         let currentActivity = firstActivity;
         let executionCount = 0;
         const maxExecutions = 500; // Prevent infinite loops
-        let lastActivityOutput = undefined;
+        let lastActivityOutput = state.lastActivityOutput;
+        let activityOutputs = { ...(state.activityOutputs || {}) };
         while (currentActivity && executionCount < maxExecutions) {
             executionCount++;
             // Activity name is the registry key (e.g., 'workflow-activity:show-toast')
@@ -12111,11 +12134,24 @@ class AXCWorkflowEngine {
                 });
                 // Only create workitem for human-task
                 if (pendingTask.taskType === 'human-task') {
+                    console.log(`[AXCWorkflowEngine] 👤 Creating work item for human-task activity:`, {
+                        instanceId,
+                        activityId: currentActivity.id,
+                        bookmarkId,
+                        activityName: activityDef?.name,
+                        instanceEntityRefId: instance.entityRefId,
+                        instanceEntityRefType: instance.entityRefType,
+                    });
                     await this.createWorkItemFromBookmark(instanceId, currentActivity.id, bookmarkId, activityDef);
                 }
+                else {
+                    console.log(`[AXCWorkflowEngine] ⏭️ Skipping work item creation (taskType: ${pendingTask.taskType}, not human-task)`);
+                }
                 // Update state to suspended (waiting for frontend)
                 state = {
                     ...state,
+                    activityOutputs,
+                    lastActivityOutput,
                     status: pendingTask.taskType == 'human-task' ? 'suspended' : 'running',
                     currentStepId: currentActivity.id,
                 };
@@ -12125,13 +12161,18 @@ class AXCWorkflowEngine {
                     instanceId: instanceId,
                     state,
                     pendingTask,
-                    lastActivityOutput
+                    activityOutputs,
+                    lastActivityOutput,
                 };
             }
             // Backend activity → execute it
             console.log(`[AXCWorkflowEngine] ⚙️ Executing backend activity '${currentActivity.name || currentActivity.id}' (${activityType})`);
             const executionResult = await this.executeBackendActivityLocally(currentActivity, { ...state.variables, ...state.input }, state);
             lastActivityOutput = executionResult.output;
+            activityOutputs = {
+                ...activityOutputs,
+                [currentActivity.id]: executionResult.output,
+            };
             // Update variables with output
             state = {
                 ...state,
@@ -12140,6 +12181,8 @@ class AXCWorkflowEngine {
                     //TODO need here!
                     ...executionResult.output
                 },
+                activityOutputs,
+                lastActivityOutput,
                 currentStepId: currentActivity.id,
                 lastUpdated: new Date()
             };
@@ -12160,7 +12203,9 @@ class AXCWorkflowEngine {
                 return {
                     instanceId: instanceId,
                     state,
-                    pendingTask: null
+                    pendingTask: null,
+                    activityOutputs,
+                    lastActivityOutput,
                 };
             }
             // Find next activity
@@ -12193,13 +12238,16 @@ class AXCWorkflowEngine {
             ...state,
             status: 'completed',
             currentStepId: undefined,
-            output: state.variables
+            output: state.variables,
+            activityOutputs,
+            lastActivityOutput,
         };
         await this.updateInstanceFromState(instanceId, state);
         return {
             instanceId: instanceId,
             state: state,
             pendingTask: null,
+            activityOutputs,
             lastActivityOutput: lastActivityOutput
         };
     }
@@ -12262,6 +12310,12 @@ class AXCWorkflowEngine {
         // Apply frontend outputs into workflow state
         // Merge userInput into variables (not as separate keys)
         const userInput = request.userInput || {};
+        let activityOutputs = { ...(state.activityOutputs || {}) };
+        let lastActivityOutput = userInput;
+        activityOutputs = {
+            ...activityOutputs,
+            [request.stepId]: userInput,
+        };
         state = {
             ...state,
             variables: {
@@ -12269,6 +12323,8 @@ class AXCWorkflowEngine {
                 ...userInput, // Merge userInput directly into variables
                 [`${request.stepId}_outcome`]: request.outcome, // Keep outcome for reference
             },
+            activityOutputs,
+            lastActivityOutput,
             lastUpdated: new Date()
         };
         // Find next activity based on outcome from frontend
@@ -12281,7 +12337,9 @@ class AXCWorkflowEngine {
                 ...state,
                 status: 'completed',
                 currentStepId: undefined,
-                output: state.variables
+                output: state.variables,
+                activityOutputs,
+                lastActivityOutput,
             };
             console.log('[AXCWorkflowExecutionService] 📝 Updating instance to completed state');
             await this.updateInstanceFromState(request.instanceId, state);
@@ -12335,6 +12393,8 @@ class AXCWorkflowEngine {
                 // - ui-activity: running (workflow manager will execute it immediately)
                 state = {
                     ...state,
+                    activityOutputs,
+                    lastActivityOutput,
                     status: taskType === 'human-task' ? 'suspended' : 'running',
                     currentStepId: currentActivity.id,
                 };
@@ -12350,6 +12410,11 @@ class AXCWorkflowEngine {
             // Backend activity → execute it
             console.log(`[AXCWorkflowEngine] ⚙️ Executing backend activity '${currentActivity.name || currentActivity.id}' (${activityType})`);
             const executionResult = await this.executeBackendActivityLocally(currentActivity, { ...state.variables, ...state.input }, state);
+            lastActivityOutput = executionResult.output;
+            activityOutputs = {
+                ...activityOutputs,
+                [currentActivity.id]: executionResult.output,
+            };
             // Update variables with output
             state = {
                 ...state,
@@ -12357,6 +12422,8 @@ class AXCWorkflowEngine {
                     ...state.variables,
                     ...executionResult.output
                 },
+                activityOutputs,
+                lastActivityOutput,
                 currentStepId: currentActivity.id,
                 lastUpdated: new Date()
             };
@@ -12371,7 +12438,9 @@ class AXCWorkflowEngine {
                     ...state,
                     status: 'completed',
                     currentStepId: undefined,
-                    output: state.variables
+                    output: state.variables,
+                    activityOutputs,
+                    lastActivityOutput,
                 };
                 await this.updateInstanceFromState(request.instanceId, state);
                 return {
@@ -12411,7 +12480,9 @@ class AXCWorkflowEngine {
             ...state,
             status: 'completed',
             currentStepId: undefined,
-            output: state.variables
+            output: state.variables,
+            activityOutputs,
+            lastActivityOutput,
         };
         await this.updateInstanceFromState(request.instanceId, state);
         return {
@@ -12921,12 +12992,26 @@ class AXCWorkflowEngine {
      */
     async createWorkItemFromBookmark(instanceId, activityId, bookmarkId, activityDef) {
         try {
+            console.log(`[AXCWorkflowEngine] 📋 createWorkItemFromBookmark called:`, {
+                instanceId,
+                activityId,
+                bookmarkId,
+                activityDefName: activityDef?.name,
+            });
             // Get workflow instance to get workflow name
             const instance = await this.db.instances.get(instanceId);
             if (!instance) {
                 console.warn(`[AXCWorkflowEngine] ⚠️ Instance ${instanceId} not found, skipping work item creation`);
                 return;
             }
+            console.log(`[AXCWorkflowEngine] 📦 Workflow instance found:`, {
+                id: instance.id,
+                definitionId: instance.definitionId,
+                name: instance.name,
+                correlationId: instance.correlationId,
+                entityRefId: instance.entityRefId,
+                entityRefType: instance.entityRefType,
+            });
             // Get bookmark to extract taskToken
             const bookmark = await this.db.bookmarks.get(bookmarkId);
             let taskToken = null;
@@ -12942,11 +13027,25 @@ class AXCWorkflowEngine {
             // Get workflow definition to get workflow title
             const workflowDef = await this.getDefinition(instance.definitionId || instance.name || '');
             const workflowTitle = workflowDef?.title || instance.name || 'Workflow';
+            console.log(`[AXCWorkflowEngine] 📖 Workflow definition:`, {
+                definitionId: instance.definitionId,
+                name: instance.name,
+                workflowTitle,
+                workflowDefFound: !!workflowDef,
+            });
             // Get activity definition for title
             const activityTitle = activityDef?.title || activityId;
             // Create a meaningful title
             const workItemTitle = `${workflowTitle} - ${activityTitle}`;
             const now = new Date().toISOString();
+            // Extract entity reference from instance
+            const entityRefId = instance.entityRefId || null;
+            const entityRefType = instance.entityRefType || null;
+            console.log(`[AXCWorkflowEngine] 🏷️ Entity reference:`, {
+                entityRefId,
+                entityRefType,
+                hasEntityRef: !!(entityRefId && entityRefType),
+            });
             // Create work item
             const workItem = {
                 id: AXPDataGenerator.uuid(),
@@ -12961,8 +13060,8 @@ class AXCWorkflowEngine {
                 priority: 'Normal',
                 assignedUserId: null, // Will be assigned later
                 correlationId: instance.correlationId || null,
-                entityRefId: instance.entityRefId || null,
-                entityRefType: instance.entityRefType || null,
+                entityRefId: entityRefId,
+                entityRefType: entityRefType,
                 createdAt: now,
                 updatedAt: now,
             };
@@ -12971,13 +13070,146 @@ class AXCWorkflowEngine {
                 workItem.taskToken = taskToken;
             }
             await this.entityStorageService.insertOne('WorkflowManagement.WorkItem', workItem);
-            console.log(`[AXCWorkflowEngine] ✅ Created work item: ${workItem.id} for bookmark ${bookmarkId} with title: ${workItemTitle}`);
+            console.log(`[AXCWorkflowEngine] ✅ Created work item:`, {
+                id: workItem.id,
+                instanceId: instanceId,
+                bookmarkId: bookmarkId,
+                activityNodeId: activityId,
+                title: workItemTitle,
+                entityRefId: workItem.entityRefId,
+                entityRefType: workItem.entityRefType,
+                status: workItem.status,
+                priority: workItem.priority,
+                assignedUserId: workItem.assignedUserId,
+                createdAt: workItem.createdAt,
+            });
+            // 🎯 Try to set assignedUserId from entity data if entityRefId is available
+            // COMMENTED FOR TESTING: Allow all tasks to appear in task board
+            // if (entityRefId && entityRefType && !workItem.assignedUserId) {
+            //   try {
+            //     await this.updateWorkItemAssigneeFromEntity(workItem.id, entityRefType, entityRefId);
+            //   } catch (error) {
+            //     console.warn(`[AXCWorkflowEngine] ⚠️ Failed to set assignee from entity data:`, error);
+            //     // Continue without assignee - can be set later
+            //   }
+            // }
         }
         catch (error) {
             console.error(`[AXCWorkflowEngine] ❌ Failed to create work item for bookmark ${bookmarkId}:`, error);
             // Don't fail workflow execution if work item creation fails
         }
     }
+    /**
+     * Update work items entity reference after entity is created.
+     */
+    async updateWorkItemsEntityRef(instanceId, entityRefId, entityRefType) {
+        try {
+            console.log(`[AXCWorkflowEngine] 🔄 Updating work items entity reference:`, {
+                instanceId,
+                entityRefId,
+                entityRefType,
+            });
+            // Query all work items for this instance
+            const workItems = await this.entityStorageService.query('WorkflowManagement.WorkItem', {
+                skip: 0,
+                take: 1000,
+                filter: {
+                    logic: 'and',
+                    filters: [
+                        {
+                            field: 'instanceId',
+                            operator: { type: 'equal' },
+                            value: instanceId,
+                        },
+                    ],
+                },
+            });
+            console.log(`[AXCWorkflowEngine] 📦 Found ${workItems.items?.length || 0} work items to update`);
+            // Update each work item
+            for (const workItem of workItems.items || []) {
+                if (!workItem.entityRefId || !workItem.entityRefType) {
+                    const updatedWorkItem = {
+                        ...workItem,
+                        entityRefId,
+                        entityRefType,
+                        updatedAt: new Date().toISOString(),
+                    };
+                    await this.entityStorageService.updateOne('WorkflowManagement.WorkItem', workItem.id, updatedWorkItem);
+                    console.log(`[AXCWorkflowEngine] ✅ Updated work item ${workItem.id} with entity reference:`, {
+                        workItemId: workItem.id,
+                        entityRefId,
+                        entityRefType,
+                    });
+                    // Also try to set assignee from entity data
+                    // COMMENTED FOR TESTING: Allow all tasks to appear in task board
+                    // if (!workItem.assignedUserId) {
+                    //   try {
+                    //     await this.updateWorkItemAssigneeFromEntity(workItem.id, entityRefType, entityRefId);
+                    //   } catch (error) {
+                    //     console.warn(`[AXCWorkflowEngine] ⚠️ Failed to set assignee for work item ${workItem.id}:`, error);
+                    //   }
+                    // }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`[AXCWorkflowEngine] ❌ Failed to update work items entity reference:`, error);
+            // Don't fail workflow execution if update fails
+        }
+    }
+    /**
+     * Update work item assignee from entity data (e.g., employee.manager.userId for leave requests).
+     */
+    async updateWorkItemAssigneeFromEntity(workItemId, entityRefType, entityRefId) {
+        try {
+            console.log(`[AXCWorkflowEngine] 👤 Setting assignee from entity data:`, {
+                workItemId,
+                entityRefType,
+                entityRefId,
+            });
+            // Load entity data
+            const entityData = await this.entityStorageService.getOne(entityRefType, entityRefId);
+            if (!entityData) {
+                console.warn(`[AXCWorkflowEngine] ⚠️ Entity data not found: ${entityRefType}:${entityRefId}`);
+                return;
+            }
+            // Extract assignee based on entity type
+            let assignedUserId = null;
+            // For leave requests: use employee.manager.userId
+            if (entityRefType === 'HumanCapitalManagement.LeaveRequest') {
+                assignedUserId = entityData.employee?.manager?.userId || entityData.employeeId || null;
+                console.log(`[AXCWorkflowEngine] 📋 Leave request assignee:`, {
+                    employeeId: entityData.employeeId,
+                    managerUserId: entityData.employee?.manager?.userId,
+                    assignedUserId,
+                });
+            }
+            // Update work item if assignee found
+            if (assignedUserId) {
+                const workItem = await this.entityStorageService.getOne('WorkflowManagement.WorkItem', workItemId);
+                if (workItem) {
+                    const updatedWorkItem = {
+                        ...workItem,
+                        assignedUserId,
+                        assignedAt: new Date().toISOString(),
+                        updatedAt: new Date().toISOString(),
+                    };
+                    await this.entityStorageService.updateOne('WorkflowManagement.WorkItem', workItemId, updatedWorkItem);
+                    console.log(`[AXCWorkflowEngine] ✅ Updated work item assignee:`, {
+                        workItemId,
+                        assignedUserId,
+                    });
+                }
+            }
+            else {
+                console.log(`[AXCWorkflowEngine] ℹ️ No assignee found for entity ${entityRefType}:${entityRefId}`);
+            }
+        }
+        catch (error) {
+            console.warn(`[AXCWorkflowEngine] ⚠️ Failed to set assignee from entity data:`, error);
+            // Don't fail if assignee update fails
+        }
+    }
     /**
      * Consume (mark as consumed) a bookmark for a workflow instance.
      *
@@ -13051,7 +13283,12 @@ class AXCWorkflowEngine {
         }
         // Extract state from workflowState (ERD: WORKFLOW_INSTANCE_STATE)
         // Properties map to variables
-        const variables = state.properties || {};
+        const properties = (state.properties || {});
+        const { __activityOutputs, __lastActivityOutput, ...variables } = properties;
+        const activityOutputs = __activityOutputs && typeof __activityOutputs === 'object'
+            ? __activityOutputs
+            : {};
+        const lastActivityOutput = __lastActivityOutput;
         const input = state.input || {};
         const output = state.output || {};
         // Normalize dates (instance.updatedAt is always string in AXPWorkflowInstance)
@@ -13064,6 +13301,8 @@ class AXCWorkflowEngine {
             status,
             currentStepId,
             variables,
+            activityOutputs,
+            lastActivityOutput,
             input,
             output,
             lastUpdated
@@ -13119,7 +13358,11 @@ class AXCWorkflowEngine {
         instance.workflowState.subStatus = subStatus;
         instance.workflowState.input = instanceState.input || {};
         instance.workflowState.output = instanceState.output || {};
-        instance.workflowState.properties = instanceState.variables || {};
+        instance.workflowState.properties = {
+            ...(instanceState.variables || {}),
+            __activityOutputs: instanceState.activityOutputs || {},
+            __lastActivityOutput: instanceState.lastActivityOutput,
+        };
         instance.workflowState.updatedAt = now;
         if (instanceState.status === 'completed' || instanceState.status === 'error') {
             instance.workflowState.finishedAt = now;
@@ -13261,6 +13504,12 @@ class AXCWorkflowEngine {
             const connections = workflow.graph.connections || [];
             // Apply frontend output to workflow state
             const output = request.output || {};
+            let activityOutputs = { ...(state.activityOutputs || {}) };
+            let lastActivityOutput = output;
+            activityOutputs = {
+                ...activityOutputs,
+                [request.activityNode]: output,
+            };
             state = {
                 ...state,
                 variables: {
@@ -13268,8 +13517,43 @@ class AXCWorkflowEngine {
                     ...output, // Merge frontend output into variables
                     [`${request.activityNode}_outcome`]: request.outcome, // Keep outcome for reference
                 },
+                activityOutputs,
+                lastActivityOutput,
                 lastUpdated: new Date(),
             };
+            // 🎯 Update entityRefId and entityRefType if entity was created
+            // Check if this activity created an entity (workflow-activity:create-entity)
+            const completedActivity = this.findActivityInGraph(workflow.graph, request.activityNode);
+            if (completedActivity?.name === 'workflow-activity:create-entity' && output['id']) {
+                // Extract entity type from activity inputs
+                const entityModule = completedActivity.inputs?.module || '';
+                const entityName = completedActivity.inputs?.entity || '';
+                const entityType = entityModule && entityName ? `${entityModule}.${entityName}` : null;
+                const entityId = output['id'];
+                console.log(`[AXCWorkflowEngine] 🔗 Entity created in workflow:`, {
+                    activityNode: request.activityNode,
+                    entityId,
+                    entityType,
+                    entityModule,
+                    entityName,
+                });
+                if (entityId && entityType) {
+                    // Update workflow instance with entity reference
+                    const instance = await this.db.instances.get(request.instanceId);
+                    if (instance) {
+                        instance.entityRefId = entityId;
+                        instance.entityRefType = entityType;
+                        await this.db.instances.put(instance, instance.id);
+                        console.log(`[AXCWorkflowEngine] ✅ Updated workflow instance with entity reference:`, {
+                            instanceId: request.instanceId,
+                            entityRefId: entityId,
+                            entityRefType: entityType,
+                        });
+                        // Update all work items for this instance with entity reference
+                        await this.updateWorkItemsEntityRef(request.instanceId, entityId, entityType);
+                    }
+                }
+            }
             // Find next activity based on outcome from frontend
             const nextConnection = connections.find((conn) => conn.source.activtyName === request.activityNode &&
                 (conn.source.port === request.outcome || (!conn.source.port && request.outcome === 'Done')));
@@ -13304,7 +13588,7 @@ class AXCWorkflowEngine {
                 await this.updateInstanceFromState(request.instanceId, state);
                 throw new Error(`Next activity '${nextConnection.target.activtyName}' not found in workflow graph`);
             }
-            let lastActivityOutput = undefined;
+            // `activityOutputs` and `lastActivityOutput` are tracked and persisted in `state`.
             while (currentActivity && executionCount < maxExecutions) {
                 executionCount++;
                 // Map activity name (registry key) to activity type
@@ -13332,6 +13616,8 @@ class AXCWorkflowEngine {
                     // Update state (suspended for human-task, running for ui-activity)
                     state = {
                         ...state,
+                        activityOutputs,
+                        lastActivityOutput,
                         status: pendingTask.taskType === 'human-task' ? 'suspended' : 'running',
                         currentStepId: currentActivity.id,
                     };
@@ -13348,6 +13634,10 @@ class AXCWorkflowEngine {
                 console.log(`[AXCWorkflowEngine] ⚙️ Executing backend activity '${currentActivity.name || currentActivity.id}' (${activityType})`);
                 const executionResult = await this.executeBackendActivityLocally(currentActivity, { ...state.variables, ...state.input }, state);
                 lastActivityOutput = executionResult.output;
+                activityOutputs = {
+                    ...activityOutputs,
+                    [currentActivity.id]: executionResult.output,
+                };
                 // Update variables with output
                 state = {
                     ...state,
@@ -13355,6 +13645,8 @@ class AXCWorkflowEngine {
                         ...state.variables,
                         ...executionResult.output,
                     },
+                    activityOutputs,
+                    lastActivityOutput,
                     currentStepId: currentActivity.id,
                     lastUpdated: new Date(),
                 };
@@ -13370,6 +13662,8 @@ class AXCWorkflowEngine {
                         status: 'completed',
                         currentStepId: undefined,
                         output: state.variables,
+                        activityOutputs,
+                        lastActivityOutput,
                     };
                     await this.updateInstanceFromState(request.instanceId, state);
                     return {
@@ -13410,6 +13704,8 @@ class AXCWorkflowEngine {
                 status: 'completed',
                 currentStepId: undefined,
                 output: state.variables,
+                activityOutputs,
+                lastActivityOutput,
             };
             await this.updateInstanceFromState(request.instanceId, state);
             return {