@acorex-platform/framework-server 0.0.56 → 0.0.58

package/workflow/src/lib/runtime/workflow-engine.service.js

@@ -10,6 +10,8 @@ const uuid_util_1 = require("../utils/uuid.util");
 const workflow_management_const_1 = require("./workflow-management.const");
 const workflow_engine_errors_1 = require("./workflow-engine.errors");
 const workflow_activity_definition_service_1 = require("./workflow-activity-definition.service");
+const workflow_definition_runtime_cache_1 = require("./workflow-definition-runtime-cache");
+const workflow_local_dismiss_1 = require("./workflow-local-dismiss");
 const workflow_activity_registry_1 = require("../activities/workflow-activity.registry");
 const workflow_expression_evaluator_service_1 = require("./workflow-expression-evaluator.service");
 const workflow_expression_scope_service_1 = require("./workflow-expression-scope.service");
@@ -26,7 +28,7 @@ const AXP_WORKFLOW_TASK_CONTEXT_TITLE_PARTS_KEY = '_taskTitleParts';
  */
 let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class BackendWorkflowEngineService {
     //#region ----   Services & Dependencies   ----
-    constructor(store, entityStorageService, activityDefinitionService, expressionScopeService, expressionEvaluator, sessionService, activityRegistry) {
+    constructor(store, entityStorageService, activityDefinitionService, expressionScopeService, expressionEvaluator, sessionService, activityRegistry, definitionCache) {
         this.store = store;
         this.entityStorageService = entityStorageService;
         this.activityDefinitionService = activityDefinitionService;
@@ -34,6 +36,7 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
         this.expressionEvaluator = expressionEvaluator;
         this.sessionService = sessionService;
         this.activityRegistry = activityRegistry;
+        this.definitionCache = definitionCache;
         //#endregion
         //#region ----   Task Token Management   ----
         /**
@@ -86,9 +89,10 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
      * Load workflow definition by name from entity storage.
      */
     async getDefinition(workflowId) {
-        console.log(`[BackendWorkflowRuntime] 🔍 Loading workflow definition: ${workflowId}`);
-        // Query entity storage by name field (not id)
-        console.log(`[BackendWorkflowRuntime] 🔄 Fallback: Querying entity storage by name field: ${workflowId}`);
+        const cached = this.definitionCache.get(workflowId);
+        if (cached) {
+            return cached;
+        }
         try {
             const result = await this.entityStorageService.query('WorkflowManagement.WorkflowDefinition', {
                 skip: 0,
@@ -99,16 +103,18 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
                     value: workflowId,
                 },
             });
-            if (result.items && result.items.length > 0) {
-                const entity = result.items[0];
-                console.log(`[BackendWorkflowRuntime] ✅ Found definition via entity storage: ${workflowId}`);
-                return entity;
+            const entity = result.items?.[0];
+            if (entity) {
+                const definition = entity;
+                this.definitionCache.set(workflowId, definition);
+                return definition;
             }
         }
         catch (error) {
-            console.error(`[BackendWorkflowRuntime] ❌ Error querying entity storage:`, error);
+            console.error(`[BackendWorkflowRuntime] Error querying workflow definition "${workflowId}":`, error);
+            return null;
         }
-        console.error(`[BackendWorkflowRuntime] ❌ Workflow definition not found: ${workflowId}`);
+        console.error(`[BackendWorkflowRuntime] Workflow definition not found: ${workflowId}`);
         return null;
     }
     /**
@@ -333,6 +339,7 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
             entityRefType: entityRefType || null,
         };
         let stored = false;
+        let keepInstanceInMemory = false;
         try {
             return await (0, workflow_trigger_guard_1.runInsideWorkflowEngine)(() => this.store.runWithoutPersist(async () => {
                 await this.store.addInstance(instance);
@@ -395,6 +402,11 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
                     if (effectiveExecutionMode === 'frontend' ||
                         effectiveExecutionMode === 'both') {
                         const pendingTask = await this.createTaskFromActivity(currentActivity, state);
+                        const localDismiss = (0, workflow_local_dismiss_1.resolveWorkflowLocalDismiss)(workflow, currentActivity.id);
+                        if (localDismiss) {
+                            pendingTask.localDismiss = localDismiss;
+                            keepInstanceInMemory = true;
+                        }
                         // Use local taskType (may be forced to human-task for workflow-activity:human-task) so bookmark and UI see correct type
                         const resolvedTaskTypeForBookmark = taskType === 'human-task' || pendingTask.taskType === 'human-task'
                             ? 'human-task'
@@ -581,7 +593,7 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
             }));
         }
         finally {
-            if (stored) {
+            if (stored && !keepInstanceInMemory) {
                 const current = await this.store.getInstance(instanceId);
                 if (current) {
                     await this.writeInstanceProjection(current, workflow, true);
@@ -2050,6 +2062,42 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
             };
         }
     }
+    /**
+     * The task row was just created with this user and the same display name.
+     * Skip the follow-up read and update.
+     */
+    linkedTaskAssigneeAlreadyStamped(instance, assignUserFields) {
+        const userId = assignUserFields.assignUser?.id?.trim();
+        const displayName = assignUserFields.assignUserRef?.displayName?.trim();
+        if (!userId || !displayName) {
+            return false;
+        }
+        const variables = instance.workflowState
+            ?.variables ?? {};
+        const stamped = variables['assigneeUserId'];
+        if (stamped == null || String(stamped).trim() !== userId) {
+            return false;
+        }
+        return this.readWorkflowAssigneeDisplayName(variables) === displayName;
+    }
+    readWorkflowAssigneeDisplayName(variables) {
+        const user = variables['assigneeUser'];
+        if (user && typeof user === 'object' && 'displayName' in user) {
+            const name = String(user.displayName ?? '').trim();
+            if (name) {
+                return name;
+            }
+        }
+        const employee = variables['assigneeEmployee'];
+        if (employee && typeof employee === 'object' && 'person' in employee) {
+            const person = employee.person;
+            const name = String(person?.fullName ?? '').trim();
+            if (name) {
+                return name;
+            }
+        }
+        return undefined;
+    }
     /**
      * Mirror the current workflow human-task assignee onto the linked Task row
      * so entity lists (e.g. project Tasks) match the task board popover.
@@ -2209,39 +2257,65 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
      */
     async writeInstanceProjection(instance, definition, insert) {
         if (insert) {
-            await this.saveInstanceToEntityService(instance, definition);
+            await this.saveInstanceToEntityService(instance, definition, { assumeNew: true });
             return;
         }
         await this.updateInstanceInEntityService(instance, definition);
     }
+    /**
+     * Bookmark body is stored once. Readers accept payloadJson without a second parsed copy.
+     */
+    persistedBookmarks(bookmarks) {
+        return bookmarks.map((bookmark) => ({
+            id: bookmark.id,
+            activityId: bookmark.activityId,
+            activityInstanceId: bookmark.activityId,
+            type: bookmark.type,
+            payloadJson: bookmark.payloadJson,
+            consumed: bookmark.isConsumed,
+            isConsumed: bookmark.isConsumed,
+            createdAt: bookmark.createdAt,
+        }));
+    }
+    async resolveProjectionAssignUserFields(instance, activeBookmarks) {
+        const fromVariables = this.assignUserFieldsFromVariables(instance);
+        if (fromVariables) {
+            return fromVariables;
+        }
+        return this.resolveAssignUserLookupFields(this.resolvePrimaryAssignUserId(instance, activeBookmarks));
+    }
+    assignUserFieldsFromVariables(instance) {
+        const properties = (instance.workflowState?.properties ?? {});
+        const userId = typeof properties['assigneeUserId'] === 'string' ? properties['assigneeUserId'].trim() : '';
+        const displayName = this.readWorkflowAssigneeDisplayName(properties);
+        if (!userId || !displayName) {
+            return undefined;
+        }
+        return {
+            assignUser: { id: userId },
+            assignUserRef: { id: userId, displayName },
+        };
+    }
     /**
      * Save workflow instance to entity service for entity-based access.
      */
-    async saveInstanceToEntityService(instance, predefined) {
+    async saveInstanceToEntityService(instance, predefined, options) {
         try {
             // Get active bookmarks for this instance to include in entity model
             const activeBookmarks = await this.getActiveBookmarks(instance.id);
             // Add bookmarks to instance for entity storage access
             const instanceWithBookmarks = {
                 ...instance,
-                bookmarks: activeBookmarks.map((b) => ({
-                    id: b.id,
-                    activityId: b.activityId,
-                    activityInstanceId: b.activityId, // For compatibility
-                    type: b.type,
-                    payload: b.payloadJson ? JSON.parse(b.payloadJson) : null,
-                    payloadJson: b.payloadJson,
-                    consumed: b.isConsumed,
-                    isConsumed: b.isConsumed,
-                    createdAt: b.createdAt,
-                })),
+                bookmarks: this.persistedBookmarks(activeBookmarks),
             };
             const definition = predefined ?? (await this.getDefinition(instance.definitionId));
             const overview = this.computeOverviewDisplayFields(instance, definition);
             const runtimeDetails = this.computeRuntimeDetails(instance, definition, activeBookmarks);
             const workflowVariablesTable = this.computeWorkflowVariablesTable(instance, definition);
-            const assignUserFields = await this.resolveAssignUserLookupFields(this.resolvePrimaryAssignUserId(instance, activeBookmarks));
-            await this.syncLinkedTaskAssignee(instance, assignUserFields);
+            const assignUserFields = await this.resolveProjectionAssignUserFields(instance, activeBookmarks);
+            if (!this.linkedTaskAssigneeAlreadyStamped(instance, assignUserFields)) {
+                await this.syncLinkedTaskAssignee(instance, assignUserFields);
+            }
             const scopeInfo = this.getSessionScopeInfo();
             const entityModel = {
                 id: instance.id,
@@ -2271,19 +2345,19 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
                 ...(scopeInfo ? { scopeInfo } : {}),
             };
             const entityName = 'WorkflowManagement.WorkflowInstance';
-            // Check if instance already exists
-            try {
-                const existing = await this.entityStorageService.getOneAsEngine(entityName, entityModel.id);
-                if (existing) {
-                    // Already exists - don't insert again, will be updated later
-                    console.log('[AXCWorkflowExecutionService] ℹ️ Instance already exists in entity service, will be updated later', {
-                        instanceId: instance.id,
-                    });
-                    return;
+            if (!options?.assumeNew) {
+                try {
+                    const existing = await this.entityStorageService.getOneAsEngine(entityName, entityModel.id);
+                    if (existing) {
+                        console.log('[AXCWorkflowExecutionService] ℹ️ Instance already exists in entity service, will be updated later', {
+                            instanceId: instance.id,
+                        });
+                        return;
+                    }
+                }
+                catch {
+                    // Instance doesn't exist - proceed with insert
                 }
-            }
-            catch (getError) {
-                // Instance doesn't exist - proceed with insert
             }
             // Insert new instance
             await this.entityStorageService.insertOneAsEngine(entityName, entityModel);
@@ -2309,24 +2383,16 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
             // Add bookmarks to instance for entity storage access
             const instanceWithBookmarks = {
                 ...instance,
-                bookmarks: activeBookmarks.map((b) => ({
-                    id: b.id,
-                    activityId: b.activityId,
-                    activityInstanceId: b.activityId, // For compatibility
-                    type: b.type,
-                    payload: b.payloadJson ? JSON.parse(b.payloadJson) : null,
-                    payloadJson: b.payloadJson,
-                    consumed: b.isConsumed,
-                    isConsumed: b.isConsumed,
-                    createdAt: b.createdAt,
-                })),
+                bookmarks: this.persistedBookmarks(activeBookmarks),
             };
             const definition = predefined ?? (await this.getDefinition(instance.definitionId));
             const overview = this.computeOverviewDisplayFields(instance, definition);
             const runtimeDetails = this.computeRuntimeDetails(instance, definition, activeBookmarks);
             const workflowVariablesTable = this.computeWorkflowVariablesTable(instance, definition);
-            const assignUserFields = await this.resolveAssignUserLookupFields(this.resolvePrimaryAssignUserId(instance, activeBookmarks));
-            await this.syncLinkedTaskAssignee(instance, assignUserFields);
+            const assignUserFields = await this.resolveProjectionAssignUserFields(instance, activeBookmarks);
+            if (!this.linkedTaskAssigneeAlreadyStamped(instance, assignUserFields)) {
+                await this.syncLinkedTaskAssignee(instance, assignUserFields);
+            }
             const scopeInfo = this.getSessionScopeInfo();
             const entityModel = {
                 id: instance.id,
@@ -3422,6 +3488,7 @@ exports.BackendWorkflowEngineService = BackendWorkflowEngineService = BackendWor
         workflow_expression_scope_service_1.WorkflowExpressionScopeService,
         workflow_expression_evaluator_service_1.WorkflowExpressionEvaluatorService,
         workflow_request_session_adapter_1.WorkflowRequestSessionAdapter,
-        workflow_activity_registry_1.WorkflowActivityRegistryService])
+        workflow_activity_registry_1.WorkflowActivityRegistryService,
+        workflow_definition_runtime_cache_1.WorkflowDefinitionRuntimeCache])
 ], BackendWorkflowEngineService);
 //# sourceMappingURL=workflow-engine.service.js.map