@rytass/bpm-core-nestjs-module 0.17.8 → 0.17.9

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

@@ -113,6 +113,15 @@ class TaskReassignmentRejectedError extends Error {
         this.errorCode = errorCode;
     }
 }
+/** The administrator screens are in Traditional Chinese: names sort by stroke count. */
+const INACTIVE_MEMBER_NAME_LOCALE = 'zh-Hant-TW';
+/**
+ * How many deactivated members have their open tasks counted at once. Each
+ * count is a few queries, so an unbounded fan-out would put one query in
+ * flight per member, and claim that many pool connections at the same time, on
+ * every load of the member screen.
+ */
+const INACTIVE_MEMBER_COUNT_CONCURRENCY = 5;
 const WORKFLOW_READ_ALL_PERMISSIONS = new Set([
     'bpm:*',
     'bpm.workflow.read_all',
@@ -908,6 +917,7 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
                 instanceId: instance.id,
                 nodeId: null,
                 payload: {
+                    comment: input.comment?.trim() || null,
                     resubmitStrategy: returnedContext?.resubmitStrategy ?? 'RESTART',
                 },
                 taskId: null,
@@ -3340,6 +3350,97 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
             };
         });
     }
+    /**
+     * Deactivated members who still hold open tasks, so an administrator can find
+     * them: a deactivated member no longer shows up in the member search.
+     *
+     * BPM cannot tell a deactivated member from an id it never knew, so the host
+     * names them: `resolveInactiveMembers` gets every member id that holds an open
+     * seat and returns the ones it knows but has deactivated. The count per member
+     * is the {@link listMemberOpenTasks} count, and members left with none are
+     * dropped.
+     */
+    async listInactiveMembersWithOpenTasks(resolveInactiveMembers) {
+        const holderIds = await this.readOpenSeatHolderMemberIds();
+        if (!holderIds.length) {
+            return [];
+        }
+        const holderIdSet = new Set(holderIds);
+        // Only the ids it was asked about are counted, each once: a member the
+        // host adds would only cost task queries before the count dropped it.
+        const inactiveMembers = [
+            ...new Map((await resolveInactiveMembers(holderIds))
+                .filter((member) => holderIdSet.has(member.memberId))
+                .map((member) => [member.memberId, member])).values(),
+        ];
+        const counted = await chunkArray(inactiveMembers, INACTIVE_MEMBER_COUNT_CONCURRENCY).reduce(async (previous, batch) => [
+            ...(await previous),
+            ...(await Promise.all(batch.map(async (member) => ({
+                email: member.email,
+                memberId: member.memberId,
+                name: member.name,
+                openTaskCount: (await this.readRunningMemberTasks(member.memberId))
+                    .length,
+            })))),
+        ], Promise.resolve([]));
+        return counted
+            .filter((record) => record.openTaskCount > 0)
+            .sort((left, right) => left.name.localeCompare(right.name, INACTIVE_MEMBER_NAME_LOCALE) ||
+            // Namesakes are common; the id keeps their order stable.
+            (left.memberId < right.memberId
+                ? -1
+                : left.memberId > right.memberId
+                    ? 1
+                    : 0));
+    }
+    /**
+     * Every member id that may hold an open seat on a RUNNING instance: the
+     * assignee of an open task, or an open candidate row on one. Still a
+     * superset (a countersign voter who already decided stays the assignee);
+     * callers count with {@link readRunningMemberTasks}, which drops those.
+     *
+     * One query that returns only the distinct holder ids, never a row per
+     * task or seat: the member screen loads it every time.
+     */
+    async readOpenSeatHolderMemberIds() {
+        const taskTable = this.readQualifiedTableName(this.taskRepository);
+        const candidateTable = this.readQualifiedTableName(this.taskCandidateRepository);
+        const instanceTable = this.readQualifiedTableName(this.approvalInstanceRepository);
+        const rows = await this.approvalInstanceRepository.query(`SELECT holder.member_id AS "memberId"
+         FROM (
+               SELECT task.assignee_member_id AS member_id
+                 FROM ${taskTable} AS task
+                 JOIN ${instanceTable} AS instance
+                   ON instance.id = task.instance_id
+                WHERE task.status = ANY($1::text[])
+                  AND task.assignee_member_id IS NOT NULL
+                  AND instance.state = $2
+               UNION
+               SELECT candidate.member_id
+                 FROM ${candidateTable} AS candidate
+                 JOIN ${taskTable} AS task ON task.id = candidate.task_id
+                 JOIN ${instanceTable} AS instance
+                   ON instance.id = task.instance_id
+                WHERE candidate.status = ANY($3::text[])
+                  AND task.status = ANY($1::text[])
+                  AND instance.state = $2
+              ) AS holder`, [
+            [workflow_engine_enums_1.TaskStatusEnum.PENDING, workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS],
+            workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING,
+            [...OPEN_SEAT_STATUSES],
+        ]);
+        // Sorted here, not in SQL: the default JS order (UTF-16 code units),
+        // whatever the DB collation.
+        return rows.map((row) => row.memberId).sort();
+    }
+    /** `schema.table` of a repository's entity, escaped for raw SQL. */
+    readQualifiedTableName(repository) {
+        const { driver } = this.approvalInstanceRepository.manager.connection;
+        return [repository.metadata.schema, repository.metadata.tableName]
+            .filter((part) => Boolean(part))
+            .map((part) => driver.escape(part))
+            .join('.');
+    }
     /**
      * The open tasks `memberId` holds on RUNNING instances, with the instance
      * each belongs to. The instance filter is applied here, not only in the query.
@@ -5081,6 +5182,10 @@ function capDecisionPolicyToCandidateCount(policy, candidateCount) {
         ? { ...policy, threshold: Math.max(candidateCount, 1) }
         : policy;
 }
+/** Splits `items` into consecutive runs of at most `size`. */
+function chunkArray(items, size) {
+    return Array.from({ length: Math.ceil(items.length / size) }, (_, index) => items.slice(index * size, (index + 1) * size));
+}
 function uniqueTasksById(tasks) {
     const seen = new Set();
     return tasks.filter((task) => {