@rytass/bpm-core-nestjs-module 0.13.2 → 0.13.4

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

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowEngineService = exports.MANUAL_TRANSFER_DELEGATION_REASON = void 0;
 const tslib_1 = require("tslib");
 const form_1 = require("@rytass/bpm-core-shared/form");
+const workflow_graph_1 = require("@rytass/bpm-core-shared/workflow-graph");
+const workflow_webhook_delivery_service_1 = require("../workflow-webhook/workflow-webhook-delivery.service");
 const common_1 = require("@nestjs/common");
 const typeorm_1 = require("@nestjs/typeorm");
 const typeorm_2 = require("typeorm");
@@ -37,6 +39,7 @@ const workflow_condition_evaluator_1 = require("./workflow-condition-evaluator")
 const workflow_dry_run_object_1 = require("./workflow-dry-run.object");
 const workflow_service_task_dispatcher_token_1 = require("./workflow-service-task-dispatcher.token");
 const workflow_token_entity_1 = require("./workflow-token.entity");
+const bpm_root_options_1 = require("../bpm/bpm-root-options");
 const MAX_PROCESSING_STEPS = 500;
 const DEFAULT_APPROVAL_HISTORY_TASK_LIMIT = 50;
 const SYSTEM_DRY_RUN_INSTANCE_ID = 'dry-run-instance';
@@ -52,7 +55,7 @@ const WORKFLOW_READ_ALL_PERMISSIONS = new Set([
     'workflow.read_all',
 ]);
 let WorkflowEngineService = class WorkflowEngineService {
-    constructor(approvalInstanceRepository, workflowTokenRepository, taskRepository, taskCandidateRepository, taskDecisionRepository, notificationRepository, activityLogRepository, adhocDirectiveRepository, approvalTemplateRepository, approvalTemplateVersionRepository, formDefinitionVersionRepository, attachmentService, conditionService, delegationService, notificationService, signatureService, slaScheduleService, serviceTaskDispatcher = new workflow_service_task_dispatcher_token_1.DefaultWorkflowServiceTaskDispatcher(), formDataSourceValueResolver) {
+    constructor(approvalInstanceRepository, workflowTokenRepository, taskRepository, taskCandidateRepository, taskDecisionRepository, notificationRepository, activityLogRepository, adhocDirectiveRepository, approvalTemplateRepository, approvalTemplateVersionRepository, formDefinitionVersionRepository, attachmentService, conditionService, delegationService, notificationService, signatureService, slaScheduleService, injectedServiceTaskDispatcher, formDataSourceValueResolver, rootOptions, webhookDeliveryService) {
         this.approvalInstanceRepository = approvalInstanceRepository;
         this.workflowTokenRepository = workflowTokenRepository;
         this.taskRepository = taskRepository;
@@ -70,8 +73,22 @@ let WorkflowEngineService = class WorkflowEngineService {
         this.notificationService = notificationService;
         this.signatureService = signatureService;
         this.slaScheduleService = slaScheduleService;
-        this.serviceTaskDispatcher = serviceTaskDispatcher;
         this.formDataSourceValueResolver = formDataSourceValueResolver;
+        this.webhookDeliveryService = webhookDeliveryService;
+        // A binding under the token wins: that is either the host's own provider
+        // or `workflowServiceTaskDispatcherProvider`, both of them deliberate. The
+        // runtime instance from `BPMRootModule`'s async factory comes next.
+        //
+        // Resolving it here rather than registering a default provider is what
+        // keeps a host that binds the token from its own global module working —
+        // a module-local default would shadow that binding, silently sending
+        // WEBHOOK service tasks through the built-in `fetch` dispatcher instead of
+        // the host's signing or queueing one. It also reaches every copy of this
+        // service, which a provider registered on one module does not.
+        this.serviceTaskDispatcher =
+            injectedServiceTaskDispatcher ??
+                rootOptions?.workflowServiceTaskDispatcher ??
+                new workflow_service_task_dispatcher_token_1.DefaultWorkflowServiceTaskDispatcher();
     }
     async submitApprovalInstance(input, authContext) {
         const formData = parseJsonObject(input.formDataJson, 'formDataJson');
@@ -472,11 +489,13 @@ let WorkflowEngineService = class WorkflowEngineService {
                 instanceId: instance.id,
                 manager,
             });
-            const cancelledInstance = await instanceRepository.save({
-                ...instance,
+            // Same prototype-preserving reason as `cancelAdhocDirective`: this
+            // entity is returned to the resolver and `ApprovalInstance` exposes
+            // five getter-backed JSON fields.
+            const cancelledInstance = await instanceRepository.save(Object.assign(new approval_instance_entity_1.ApprovalInstanceEntity(), instance, {
                 completedAt: cancelledAt,
                 state: workflow_engine_enums_1.ApprovalInstanceStateEnum.CANCELLED,
-            });
+            }));
             await this.dispatchAdhocCompletionNotifications(manager, cancelledInstance, workflow_engine_enums_1.ApprovalInstanceStateEnum.CANCELLED);
             await this.cancelPendingAdhocDirectives(manager, instance.id, null);
             await manager.getRepository(activity_log_entity_1.ActivityLogEntity).save(manager.getRepository(activity_log_entity_1.ActivityLogEntity).create({
@@ -660,10 +679,14 @@ let WorkflowEngineService = class WorkflowEngineService {
             if (directive.status !== adhoc_enums_1.AdhocDirectiveStatusEnum.PENDING) {
                 throw new common_1.ConflictException(`Ad-hoc directive ${directive.id} is not pending`);
             }
-            const cancelledDirective = await directiveRepository.save({
-                ...directive,
+            // Assigning onto a fresh entity keeps the prototype, so the row handed
+            // back to the resolver still carries the getters the GraphQL schema
+            // exposes (e.g. `targetValueJson`). Spreading it into a plain object
+            // drops them, and the mutation then fails with an opaque
+            // INTERNAL_SERVER_ERROR *after* the cancellation has been committed.
+            const cancelledDirective = await directiveRepository.save(Object.assign(new adhoc_directive_entity_1.AdhocDirectiveEntity(), directive, {
                 status: adhoc_enums_1.AdhocDirectiveStatusEnum.CANCELLED,
-            });
+            }));
             await this.recordAdhocDirectiveActivity(manager, cancelledDirective, workflow_engine_enums_1.ActivityLogEventTypeEnum.ADHOC_DIRECTIVE_CANCELLED, cancelledByMemberId);
             return cancelledDirective;
         });
@@ -764,7 +787,18 @@ let WorkflowEngineService = class WorkflowEngineService {
                 : workflow_engine_enums_1.TaskAssignmentTypeEnum.CANDIDATE_GROUP,
             completedAt: null,
             createdAt: now,
-            decisionPolicySnapshot: { type: 'SINGLE' },
+            // One resolved person is `SINGLE`, which is what this has always been.
+            // Several mean a countersign in the sense the UI promises — 下一層需
+            // 所有人都完成才會繼續 — so every candidate has to decide before the
+            // task closes. Until now a multi-person target produced a single
+            // `SINGLE` task, and whoever opened it first decided for the whole
+            // group while the task vanished from everybody else's inbox.
+            // Rejection is unaffected: `shouldCompleteTaskAfterDecision` closes
+            // the task on any non-approval whatever the policy, and that rejection
+            // then rejects the instance.
+            decisionPolicySnapshot: candidates.length === 1
+                ? { type: 'SINGLE' }
+                : { type: 'PARALLEL_ALL' },
             delegationChain: candidates.length === 1 ? primaryCandidate.delegationChain : [],
             instanceId: instance.id,
             isAdhoc: true,
@@ -1220,6 +1254,12 @@ let WorkflowEngineService = class WorkflowEngineService {
                 stepIndex: input.steps.length,
             }),
         ];
+        // A NOTIFY node is an asynchronous branch: at runtime it consumes its
+        // token and never advances, so its branch ends here rather than failing
+        // for want of an outgoing edge it is not allowed to have.
+        if ((0, workflow_graph_1.isAsyncNotifyServiceTask)(node)) {
+            return nextSteps;
+        }
         if (!entryConditionMet || node.type === 'endEvent') {
             if (node.type === 'endEvent') {
                 return nextSteps;
@@ -1525,7 +1565,29 @@ let WorkflowEngineService = class WorkflowEngineService {
                 },
             })
             : [];
-        return this.attachTaskCandidateSummaries(uniqueTasksById([...directTasks, ...candidateTasks]));
+        const openTasks = uniqueTasksById([...directTasks, ...candidateTasks]);
+        // Deciding on a group task writes the decider into `assigneeMemberId`, so
+        // a task that stays open for the others — a `PARALLEL_ALL` countersign —
+        // keeps matching `directTasks` for somebody who has already voted. Their
+        // own candidate row is the authority: once it is COMPLETED the task is no
+        // longer theirs to act on, and opening it again only raises "was already
+        // decided by this member".
+        //
+        // Scoped to the tasks already in hand: unscoped it would load every row
+        // this member has ever settled, on every inbox load. TRANSFERRED is not
+        // among the statuses because transferring sets the task itself to
+        // TRANSFERRED, which both queries above already exclude.
+        const settledCandidateRows = openTasks.length
+            ? await this.taskCandidateRepository.find({
+                where: {
+                    memberId: assigneeMemberId,
+                    status: workflow_engine_enums_1.TaskCandidateStatusEnum.COMPLETED,
+                    taskId: (0, typeorm_2.In)(openTasks.map((task) => task.id)),
+                },
+            })
+            : [];
+        const settledTaskIds = new Set(settledCandidateRows.map((candidate) => candidate.taskId));
+        return this.attachTaskCandidateSummaries(openTasks.filter((task) => !settledTaskIds.has(task.id)));
     }
     async listApprovalHistoryTasks(assigneeMemberId) {
         const directTasks = await this.taskRepository.find({
@@ -1539,13 +1601,17 @@ let WorkflowEngineService = class WorkflowEngineService {
                 status: workflow_engine_enums_1.TaskCandidateStatusEnum.COMPLETED,
             },
         });
+        // No status filter on this branch: the candidate row is already COMPLETED,
+        // which means this member has cast their decision. Requiring the task
+        // itself to be COMPLETED hid their own vote for as long as a multi-person
+        // countersign waited on somebody else — and the inbox has, correctly,
+        // stopped showing it to them by then, so it appeared nowhere at all.
         const candidateTasks = candidateRows.length
             ? await this.taskRepository.find({
                 order: { completedAt: 'DESC', createdAt: 'DESC' },
                 take: DEFAULT_APPROVAL_HISTORY_TASK_LIMIT,
                 where: {
                     id: (0, typeorm_2.In)(candidateRows.map((candidate) => candidate.taskId)),
-                    status: workflow_engine_enums_1.TaskStatusEnum.COMPLETED,
                 },
             })
             : [];
@@ -1709,25 +1775,39 @@ let WorkflowEngineService = class WorkflowEngineService {
         if (instance.state !== workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING) {
             return;
         }
-        const waitingTokens = await manager
-            .getRepository(workflow_token_entity_1.WorkflowTokenEntity)
-            .find({
+        // Both open statuses, not just WAITING. Today this is reached only from
+        // `processRunningInstance`, whose loop has already established that no
+        // ACTIVE token remains, so the extra status changes no current behaviour —
+        // but nothing enforces that invariant, and a second caller arriving
+        // without it would complete a case while somebody still had a task open.
+        const openTokens = await manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity).find({
             where: {
                 instanceId: instance.id,
-                status: workflow_engine_enums_1.WorkflowTokenStatusEnum.WAITING,
+                status: (0, typeorm_2.In)([
+                    workflow_engine_enums_1.WorkflowTokenStatusEnum.ACTIVE,
+                    workflow_engine_enums_1.WorkflowTokenStatusEnum.WAITING,
+                ]),
             },
         });
-        if (waitingTokens.length > 0) {
+        if (openTokens.length > 0) {
             return;
         }
         const completedAt = new Date();
+        // Update the tracked entity in place instead of saving a copy of it. The
+        // caller still holds this object and may return it — `submitApprovalInstance`
+        // hands it straight back to the resolver — so writing a copy left the
+        // mutation reporting `RUNNING` with a null `completedAt` on a case the same
+        // transaction had already committed as `APPROVED`. Assigning in place also
+        // preserves whatever the caller handed in, so an entity stays an entity
+        // and its getter-backed `*Json` fields survive. It cannot upgrade a plain
+        // object, and the resubmit and return paths do pass a plain copy of their
+        // own — a separate problem this does not fix.
         const completedInstance = await manager
             .getRepository(approval_instance_entity_1.ApprovalInstanceEntity)
-            .save({
-            ...instance,
+            .save(Object.assign(instance, {
             completedAt,
             state: workflow_engine_enums_1.ApprovalInstanceStateEnum.APPROVED,
-        });
+        }));
         await this.notificationService.createInstanceCompletedNotification({
             instance: completedInstance,
             manager,
@@ -1957,11 +2037,14 @@ let WorkflowEngineService = class WorkflowEngineService {
             (candidate.status === workflow_engine_enums_1.WorkflowTokenStatusEnum.ACTIVE ||
                 candidate.status === workflow_engine_enums_1.WorkflowTokenStatusEnum.WAITING));
         if (!hasOpenToken) {
-            const completedInstance = await instanceRepository.save({
-                ...instance,
-                completedAt,
-                state: instanceState,
-            });
+            // Update the tracked entity in place. Saving a copy left the caller's
+            // `instance.state` on `RUNNING`, so the `state !== RUNNING` guard in
+            // `completeInstanceIfNoOpenRuntimeState` did not short-circuit and a
+            // *second* completion ran on the way out of `processRunningInstance`:
+            // a duplicate completion notification on every approved case, and — far
+            // worse — an `endState: 'REJECTED'` row overwritten with `APPROVED`
+            // immediately after it had been committed.
+            const completedInstance = await instanceRepository.save(Object.assign(instance, { completedAt, state: instanceState }));
             if (instanceState === workflow_engine_enums_1.ApprovalInstanceStateEnum.APPROVED) {
                 await this.notificationService.createInstanceCompletedNotification({
                     instance: completedInstance,
@@ -2533,7 +2616,13 @@ let WorkflowEngineService = class WorkflowEngineService {
             await this.advanceTokenToOutgoingNodes(manager, updatedInstance, token, node);
             return;
         }
-        const recipients = await this.resolveApproverResolver(manager, instance, action.recipients, `知會節點「${node.data.label}」`);
+        // A webhook-only NOTIFY node names nobody. Resolving its empty DIRECT
+        // resolver would throw and roll back the submit or decision that reached
+        // it, so skip member resolution; webhooks are delivered separately.
+        const recipients = (0, workflow_graph_1.isNotifyRecipientsEmpty)(action.recipients) &&
+            (0, workflow_graph_1.readNotifyWebhookTargets)(action).length > 0
+            ? []
+            : await this.resolveApproverResolver(manager, instance, action.recipients, `知會節點「${node.data.label}」`);
         const recipientMemberIds = uniqueTexts(recipients.map((recipient) => recipient.memberId));
         await this.notificationService.createServiceTaskNotifications({
             instance,
@@ -2541,6 +2630,26 @@ let WorkflowEngineService = class WorkflowEngineService {
             node,
             recipientMemberIds,
         });
+        // Queued in this transaction and sent only after it commits (ADR 18
+        // §3.5). Without the webhook module there is nothing to queue into; the
+        // publish lint already refuses a template that references an endpoint
+        // in that case.
+        const webhookDeliveryIds = this.webhookDeliveryService &&
+            (0, workflow_graph_1.readNotifyWebhookTargets)(action).length > 0
+            ? await this.webhookDeliveryService.enqueueNotifyWebhooks(manager, {
+                instance: {
+                    formData: instance.formData,
+                    id: instance.id,
+                    initiatorMemberId: instance.initiatorMemberId,
+                    templateId: instance.templateId,
+                    templateVersionId: instance.templateVersionId,
+                    title: instance.title,
+                },
+                node: { id: node.id, label: node.data.label },
+                occurredAt: new Date(),
+                tokenId: token.id,
+            }, action.webhooks)
+            : [];
         await manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity).save({
             ...token,
             consumedAt: new Date(),
@@ -2555,6 +2664,7 @@ let WorkflowEngineService = class WorkflowEngineService {
                 action: 'NOTIFY',
                 recipientMemberIds,
                 tokenId: token.id,
+                ...(webhookDeliveryIds.length ? { webhookDeliveryIds } : {}),
             },
             taskId: null,
         }));
@@ -2844,6 +2954,9 @@ exports.WorkflowEngineService = WorkflowEngineService = tslib_1.__decorate([
     tslib_1.__param(17, (0, common_1.Inject)(workflow_service_task_dispatcher_token_1.BPM_WORKFLOW_SERVICE_TASK_DISPATCHER)),
     tslib_1.__param(18, (0, common_1.Optional)()),
     tslib_1.__param(18, (0, common_1.Inject)(form_data_source_types_1.BPM_FORM_DATA_SOURCE_VALUE_RESOLVER)),
+    tslib_1.__param(19, (0, common_1.Optional)()),
+    tslib_1.__param(19, (0, common_1.Inject)(bpm_root_options_1.BPM_ROOT_OPTIONS)),
+    tslib_1.__param(20, (0, common_1.Optional)()),
     tslib_1.__metadata("design:paramtypes", [typeorm_2.Repository,
         typeorm_2.Repository,
         typeorm_2.Repository,
@@ -2860,7 +2973,7 @@ exports.WorkflowEngineService = WorkflowEngineService = tslib_1.__decorate([
         delegation_service_1.DelegationService,
         notification_service_1.NotificationService,
         signature_service_1.SignatureService,
-        sla_schedule_service_1.BPMSlaScheduleService, Object, Object])
+        sla_schedule_service_1.BPMSlaScheduleService, Object, Object, Object, workflow_webhook_delivery_service_1.WorkflowWebhookDeliveryService])
 ], WorkflowEngineService);
 function parseJsonObject(value, label) {
     try {
@@ -3936,6 +4049,9 @@ function readDryRunStepMessage(node, entryConditionMet) {
     if (node.type === 'endEvent') {
         return `流程結束：${node.data.endState ?? 'APPROVED'}`;
     }
+    if ((0, workflow_graph_1.isAsyncNotifyServiceTask)(node)) {
+        return '將發送知會，此分支不會繼續往下。';
+    }
     return '節點條件通過。';
 }
 function mapDecisionToResolution(action) {