@rytass/bpm-core-nestjs-module 0.18.0 → 0.18.1

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

@@ -18,6 +18,7 @@ const form_definition_version_entity_1 = require("../form/form-definition-versio
 const form_enums_1 = require("../form/form.enums");
 const form_data_source_errors_1 = require("../form-data-source/form-data-source.errors");
 const form_member_value_validator_1 = require("../form/form-member-value.validator");
+const form_org_unit_value_validator_1 = require("../form/form-org-unit-value.validator");
 const form_data_source_types_1 = require("../form-data-source/form-data-source.types");
 const sla_schedule_service_1 = require("../calendar/sla-schedule.service");
 const notification_service_1 = require("../notification/notification.service");
@@ -682,6 +683,9 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
                     decisionId: decision.id,
                     signatureId: signature.id,
                     signedPayloadHash: signature.signedPayloadHash,
+                    // Absent for a person's decision, so "who actually signed" can
+                    // tell the engine's own timeout approvals apart.
+                    ...(options.automatic ? { automatic: options.automatic } : {}),
                     // Keys only: this payload is forwarded to hosts, and the values
                     // can be tax IDs or amounts.
                     ...(changedFieldKeys.length > 0 ? { changedFieldKeys } : {}),
@@ -1826,6 +1830,16 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
     resolveDryRunAssignment(input, node) {
         const resolver = node.data.approverResolver;
         const excludeInitiator = node.data.excludeInitiator;
+        const unsupportedType = (0, workflow_1.readUnsupportedApproverResolverType)(resolver);
+        // A source from a newer engine cannot be simulated. Say so and end the
+        // branch instead of showing its type name as if it were a person.
+        if (unsupportedType !== null) {
+            return {
+                assigneeMemberId: null,
+                message: `簽核節點「${readDryRunNodeName(node)}」此引擎版本不支援簽核人來源「${unsupportedType}」，請升級 BPMCore 後再試`,
+                outcome: 'STOPPED',
+            };
+        }
         const memberIds = this.readDryRunMemberIds(input, resolver, `workflow.nodes.${node.id}.data.approverResolver`);
         if (memberIds === null) {
             return {
@@ -1911,6 +1925,8 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
                 ? managerMemberIds
                 : readDryRunFallbackMemberIds(input, resolver.fallback);
         }
+        // The form pick, the unit's rules and an earlier node's outcome are not
+        // known before the instance runs: these stand in as placeholders.
         return null;
     }
     async getApprovalInstance(id, scope) {
@@ -3906,31 +3922,175 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
             : null;
     }
     async resolveApproverResolver(manager, instance, resolver, label, subject = '簽核人', skippedChainMemberIds = []) {
+        const memberIds = await this.resolveApproverMemberIds(manager, instance, resolver, label, subject, skippedChainMemberIds);
+        return memberIds.map((memberId) => ({
+            memberId,
+            sourceType: resolver.type,
+        }));
+    }
+    /** The member ids `resolver` routes to; every source type, one branch each. */
+    async resolveApproverMemberIds(manager, instance, resolver, label, subject, skippedChainMemberIds) {
         if (resolver.type === 'DIRECT') {
-            return readMemberIdsFromValue(resolver.memberIds, label, subject).map((memberId) => ({ memberId, sourceType: resolver.type }));
+            return readMemberIdsFromValue(resolver.memberIds, label, subject);
         }
         if (resolver.type === 'DYNAMIC_FORM') {
-            return readMemberIdsFromValue(readValueAtPath(instance.formData, resolver.formPath), label, subject, `依表單欄位「${resolver.formPath}」`).map((memberId) => ({ memberId, sourceType: resolver.type }));
+            return readMemberIdsFromValue(readValueAtPath(instance.formData, resolver.formPath), label, subject, `依表單欄位「${resolver.formPath}」`);
         }
         if (resolver.type === 'EXPRESSION') {
-            return readMemberIdsFromValue(this.conditionService.evaluateValue(resolver.expression, buildWorkflowExpressionContext(instance), `${label}.expression`), label, subject, '依運算式').map((memberId) => ({ memberId, sourceType: resolver.type }));
+            return readMemberIdsFromValue(this.conditionService.evaluateValue(resolver.expression, buildWorkflowExpressionContext(instance), `${label}.expression`), label, subject, '依運算式');
         }
         if (resolver.type === 'POSITION') {
-            return this.resolvePositionCandidates(manager, resolver.positionId, label, subject).then((memberIds) => memberIds.map((memberId) => ({ memberId, sourceType: resolver.type })));
+            return this.resolvePositionCandidates(manager, resolver.positionId, label, subject);
         }
         if (resolver.type === 'ORG_UNIT_MEMBER') {
-            return this.resolveOrgUnitMemberCandidates(manager, resolver.orgUnitId, Boolean(resolver.includeDescendants), label, subject).then((memberIds) => memberIds.map((memberId) => ({ memberId, sourceType: resolver.type })));
+            return this.resolveOrgUnitMemberCandidates(manager, resolver.orgUnitId, Boolean(resolver.includeDescendants), label, subject);
         }
         if (resolver.type === 'ORG_UNIT_POSITION') {
-            return this.resolveOrgUnitPositionCandidates(manager, resolver.orgUnitId, resolver.positionId, Boolean(resolver.includeDescendants), label, subject).then((memberIds) => memberIds.map((memberId) => ({ memberId, sourceType: resolver.type })));
+            return this.resolveOrgUnitPositionCandidates(manager, resolver.orgUnitId, resolver.positionId, Boolean(resolver.includeDescendants), label, subject);
         }
         if (resolver.type === 'ORG_UNIT_MANAGER') {
-            return this.resolveOrgUnitManagerCandidates(manager, instance, resolver.orgUnitId, resolver.fallback, label, resolver.preferClosestOrgUnit === true, subject).then((memberIds) => memberIds.map((memberId) => ({ memberId, sourceType: resolver.type })));
+            return this.resolveOrgUnitManagerCandidates(manager, instance, resolver.orgUnitId, resolver.fallback, label, resolver.preferClosestOrgUnit === true, subject);
         }
         if (resolver.type === 'ORG_MANAGER_CHAIN') {
-            return this.resolveOrgManagerChainCandidates(manager, instance, resolver.minPositionLevel, resolver.fallback, label, subject, skippedChainMemberIds).then((memberIds) => memberIds.map((memberId) => ({ memberId, sourceType: resolver.type })));
+            return this.resolveOrgManagerChainCandidates(manager, instance, resolver.minPositionLevel, resolver.fallback, label, subject, skippedChainMemberIds);
+        }
+        if (resolver.type === 'ORG_MANAGER') {
+            return this.resolveInitiatorManagerCandidates(manager, instance, resolver.levelsUp, resolver.fallback, label, resolver.preferClosestOrgUnit === true, subject);
+        }
+        if (resolver.type === 'FORM_MEMBER_MANAGER') {
+            return this.resolveFormMemberManagerCandidates(manager, instance, resolver, label, subject);
+        }
+        if (resolver.type === 'FORM_ORG_UNIT_MANAGER') {
+            return this.resolveFormOrgUnitManagerCandidates(manager, instance, resolver, label, subject);
+        }
+        if (resolver.type === 'NODE_ACTOR') {
+            return this.resolveNodeActorCandidates(manager, instance, resolver, label, subject);
+        }
+        if (resolver.type === 'NODE_ACTOR_MANAGER') {
+            return this.resolveNodeActorManagerCandidates(manager, instance, resolver, label, subject);
+        }
+        // A template saved by a newer engine can carry an approver source this
+        // engine does not know. Refuse it by name instead of quietly resolving it
+        // as the initiator's manager, which would route the task to the wrong
+        // person. That holds as well for a source a newer shared package knows
+        // and this engine does not route yet, so the type is named either way.
+        const unresolvedType = resolver.type;
+        throw new common_1.ConflictException(`${label} 無法建立${subject === '通知對象' ? '通知' : '待簽任務'}：此引擎版本不支援簽核人來源「${unresolvedType}」。請升級 BPMCore 後再發佈或執行此流程。`);
+    }
+    /**
+     * FORM_MEMBER_MANAGER: the manager of the one person picked on the form.
+     * The picked person is the starting point and is kept out of every level's
+     * result, so a unit head who is picked is handed to the tier above instead
+     * of coming back as his own manager.
+     */
+    async resolveFormMemberManagerCandidates(manager, instance, resolver, label, subject) {
+        const source = `依表單欄位「${resolver.formPath}」`;
+        const pickedMemberIds = readMemberIdsFromValue(readValueAtPath(instance.formData, resolver.formPath), label, subject, source);
+        // Picking one silently would route the document by accident.
+        if (pickedMemberIds.length > 1) {
+            throw new common_1.ConflictException(`${label} ${source}只能選一位人員`);
+        }
+        const levelsUp = readManagerLevelsUp(resolver.levelsUp);
+        const managerMemberIds = await this.resolveManagerMemberIdsExcludingSubject(manager, pickedMemberIds[0], levelsUp, resolver.preferClosestOrgUnit === true);
+        if (managerMemberIds.length > 0) {
+            return managerMemberIds;
+        }
+        return this.resolveFallbackAssignees(manager, instance, resolver.fallback, label, subject, `找不到表單欄位「${resolver.formPath}」所選人員的第 ${levelsUp} 層主管`);
+    }
+    /**
+     * FORM_ORG_UNIT_MANAGER: the manager of the organisation unit picked on the
+     * form, through the same rules as a fixed ORG_UNIT_MANAGER. A deleted unit
+     * resolves to nobody and takes the "no manager" path.
+     */
+    async resolveFormOrgUnitManagerCandidates(manager, instance, resolver, label, subject) {
+        const orgUnitValue = readValueAtPath(instance.formData, resolver.formPath);
+        // A value that is not a uuid would reach the uuid column of the org unit
+        // lookup and surface as a database error instead of this refusal.
+        if (typeof orgUnitValue !== 'string' ||
+            !(0, form_org_unit_value_validator_1.isSubmittableOrgUnitValue)(orgUnitValue)) {
+            throw new common_1.ConflictException(`${label} 依表單欄位「${resolver.formPath}」找不到所選組織`);
+        }
+        return this.resolveOrgUnitManagerCandidates(manager, instance, orgUnitValue.trim(), resolver.fallback, label, resolver.preferClosestOrgUnit === true, subject);
+    }
+    /**
+     * NODE_ACTOR: the people who actually approved the listed earlier nodes.
+     * A node nobody approved (never ran, cancelled, or approved only by the SLA
+     * timeout) is an error rather than an empty list: handing the task to
+     * nobody would stall the instance without saying why.
+     */
+    async resolveNodeActorCandidates(manager, instance, resolver, label, subject) {
+        const actorMemberIds = await this.readNodeActorMemberIds(manager, instance, resolver.nodeIds);
+        if (actorMemberIds.length === 0) {
+            throw new common_1.ConflictException(`${label} 找不到${subject}：${readNodeActorNodeNames(instance, resolver.nodeIds)}沒有實際同意的簽核紀錄`);
+        }
+        return actorMemberIds;
+    }
+    /**
+     * NODE_ACTOR_MANAGER: the managers `levelsUp` tiers above each person who
+     * actually approved the listed nodes, as one set. An approver without a
+     * manager is skipped; the fallback runs only when nobody is left.
+     */
+    async resolveNodeActorManagerCandidates(manager, instance, resolver, label, subject) {
+        const levelsUp = readManagerLevelsUp(resolver.levelsUp);
+        const actorMemberIds = await this.readNodeActorMemberIds(manager, instance, resolver.nodeIds);
+        const managerGroups = await Promise.all(actorMemberIds.map((actorMemberId) => this.resolveManagerMemberIdsExcludingSubject(manager, actorMemberId, levelsUp, resolver.preferClosestOrgUnit === true)));
+        const managerMemberIds = uniqueTexts(managerGroups.flat());
+        if (managerMemberIds.length > 0) {
+            return managerMemberIds;
+        }
+        return this.resolveFallbackAssignees(manager, instance, resolver.fallback, label, subject, actorMemberIds.length === 0
+            ? `${readNodeActorNodeNames(instance, resolver.nodeIds)}沒有實際同意的簽核紀錄`
+            : `找不到前面關卡實際簽核人的第 ${levelsUp} 層主管`);
+    }
+    /**
+     * The people who approved the most recent batch of tasks among `nodeIds`,
+     * earliest decision first, each once. Read through `manager` so an approval
+     * written earlier in the same transaction (the one that is advancing the
+     * instance right now) is visible.
+     *
+     * A batch is the non-ad-hoc tasks of one node on one token: a token never
+     * passes a node twice (a return opens a new token, a transfer's replacement
+     * task keeps the token), so a later round is a later batch. Tasks created in
+     * the same transaction share a `created_at`, so every (node, token) tied for
+     * newest counts as one batch. An older batch is never used in place of a
+     * newest one nobody approved. Ad-hoc approvals, approvals on cancelled
+     * tasks and approvals the SLA timeout made do not count.
+     */
+    async readNodeActorMemberIds(manager, instance, nodeIds) {
+        const tasks = await manager.getRepository(task_entity_1.TaskEntity).find({
+            where: { instanceId: instance.id, isAdhoc: false, nodeId: (0, typeorm_2.In)([...nodeIds]) },
+        });
+        if (tasks.length === 0) {
+            return [];
         }
-        return this.resolveInitiatorManagerCandidates(manager, instance, resolver.levelsUp, resolver.fallback, label, resolver.preferClosestOrgUnit === true, subject).then((memberIds) => memberIds.map((memberId) => ({ memberId, sourceType: resolver.type })));
+        const newestCreatedAt = Math.max(...tasks.map((task) => task.createdAt.getTime()));
+        const newestTasks = tasks.filter((task) => task.createdAt.getTime() === newestCreatedAt);
+        const batchTaskIds = tasks
+            .filter((task) => task.status !== workflow_engine_enums_1.TaskStatusEnum.CANCELLED &&
+            newestTasks.some((newest) => newest.nodeId === task.nodeId && newest.tokenId === task.tokenId))
+            .map((task) => task.id);
+        if (batchTaskIds.length === 0) {
+            return [];
+        }
+        const [decisions, decidedLogs] = await Promise.all([
+            manager.getRepository(task_decision_entity_1.TaskDecisionEntity).find({
+                where: { action: workflow_engine_enums_1.TaskDecisionActionEnum.APPROVED, taskId: (0, typeorm_2.In)(batchTaskIds) },
+            }),
+            manager.getRepository(activity_log_entity_1.ActivityLogEntity).find({
+                where: {
+                    eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TASK_DECIDED,
+                    instanceId: instance.id,
+                    taskId: (0, typeorm_2.In)(batchTaskIds),
+                },
+            }),
+        ]);
+        const automaticDecisionIds = new Set(decidedLogs
+            .filter((log) => log.payload['automatic'] === SLA_AUTO_APPROVE_MARK)
+            .map((log) => log.payload['decisionId']));
+        return uniqueTexts([...decisions]
+            .filter((decision) => !automaticDecisionIds.has(decision.id))
+            .sort((first, second) => first.decidedAt.getTime() - second.decidedAt.getTime())
+            .map((decision) => decision.decidedByMemberId));
     }
     async resolvePositionCandidates(manager, positionId, label, subject) {
         const memberIds = await this.readActivePositionMemberIds(manager, positionId);
@@ -4115,6 +4275,29 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
         const nextLevelGroups = await Promise.all(directManagerMemberIds.map((managerMemberId) => this.resolveManagerMemberIdsAtLevel(manager, managerMemberId, date, remainingLevels - 1, preferClosestOrgUnit)));
         return uniqueTexts(nextLevelGroups.flat());
     }
+    /**
+     * The managers `levelsUp` tiers above `startMemberId`. Every tier is looked
+     * up with the person it starts from excluded (as the manager chain does), so
+     * a unit head falls through to the tier above, and anyone already walked
+     * past — the starting person included — counts as nobody, so a pair of
+     * mutual managers cannot loop back. Nobody at any tier returns `[]`; the
+     * caller applies its own fallback.
+     */
+    async resolveManagerMemberIdsExcludingSubject(manager, startMemberId, levelsUp, preferClosestOrgUnit) {
+        const date = this.readOrganizationToday();
+        let walkedMemberIds = [startMemberId];
+        let currentMemberIds = [startMemberId];
+        for (let level = 0; level < levelsUp; level += 1) {
+            const managerGroups = await Promise.all(currentMemberIds.map((memberId) => this.resolveDirectManagerMemberIds(manager, memberId, date, preferClosestOrgUnit, [memberId])));
+            const nextMemberIds = uniqueTexts(managerGroups.flat()).filter((memberId) => !walkedMemberIds.includes(memberId));
+            if (nextMemberIds.length === 0) {
+                return [];
+            }
+            walkedMemberIds = [...walkedMemberIds, ...nextMemberIds];
+            currentMemberIds = nextMemberIds;
+        }
+        return currentMemberIds;
+    }
     async resolveDirectManagerMemberIds(manager, memberId, date, preferClosestOrgUnit, excludedManagerMemberIds = []) {
         const memberships = await manager.getRepository(membership_entity_1.MembershipEntity).find({
             where: { memberId },
@@ -4338,6 +4521,14 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
             await this.advanceTokenToOutgoingNodes(manager, updatedInstance, token, node);
             return;
         }
+        // The sources that read the form or an earlier node's outcome are not
+        // offered to a notify node (the publish lint refuses them); a definition
+        // that reaches here with one anyway is refused by name. A type this
+        // engine does not know is left to the resolver's own refusal below.
+        if ((0, workflow_1.readUnsupportedApproverResolverType)(action.recipients) === null &&
+            !(0, workflow_1.isNotifyRecipientResolverType)(action.recipients.type)) {
+            throw new common_1.ConflictException(`知會節點「${node.data.label}」不能使用簽核人來源「${action.recipients.type}」當收件人，請改用指定人員、職位、組織或主管`);
+        }
         // 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.
@@ -4983,6 +5174,17 @@ function readWorkflowNodeLabel(workflow, nodeId) {
         ?.data.label;
     return typeof label === 'string' && label.trim() ? label : null;
 }
+/** A stored `levelsUp` as a whole number of tiers, at least one. */
+function readManagerLevelsUp(levelsUp) {
+    return Number.isFinite(levelsUp) ? Math.max(Math.trunc(levelsUp), 1) : 1;
+}
+const SLA_AUTO_APPROVE_MARK = 'SLA_AUTO_APPROVE';
+/** 關卡「名稱」(、關卡「名稱」…) for an error line; a missing node shows its id. */
+function readNodeActorNodeNames(instance, nodeIds) {
+    return nodeIds
+        .map((nodeId) => `關卡「${readWorkflowNodeLabel(instance.workflowSnapshot, nodeId) ?? nodeId}」`)
+        .join('、');
+}
 function readWorkflowNodeOrThrow(workflow, nodeId) {
     const node = workflow.nodes.find((candidate) => candidate.id === nodeId);
     if (!node) {
@@ -5683,8 +5885,9 @@ function readCandidateStatusForClosedTask(taskStatus) {
 /**
  * `deferredFieldKeys` are fields an approver fills in later: they are checked
  * for shape (a table is an array of well-formed rows, a member value is a
- * member id) but never for being present, so an empty one cannot block a
- * submission that has nobody to fill it yet.
+ * member id, an org unit value is an organization unit id) but never for
+ * being present, so an empty one cannot block a submission that has nobody to
+ * fill it yet.
  */
 function validateSubmittedFormData(schema, formData, options = {}) {
     const deferredFieldKeys = options.deferredFieldKeys ?? new Set();
@@ -5724,6 +5927,10 @@ function validateSubmittedFormData(schema, formData, options = {}) {
         // above.
         readMemberErrors: () => (0, form_member_value_validator_1.readSubmittedMemberValueErrors)(schema.fields.filter((field) => visibleFields.includes(field) ||
             isSubmittedFieldValuePresent(formData[field.fieldKey])), formData),
+        // A `FORM_ORG_UNIT_MANAGER` resolver reads the unit whether or not its
+        // field is visible, so a hidden field still holding a value is checked too.
+        readOrgUnitErrors: () => (0, form_org_unit_value_validator_1.readSubmittedOrgUnitValueErrors)(schema.fields.filter((field) => visibleFields.includes(field) ||
+            isSubmittedFieldValuePresent(formData[field.fieldKey])), formData),
         readTableErrors: () => [
             ...visibleFields
                 .filter(form_1.isTableFieldDefinition)
@@ -5741,7 +5948,8 @@ function validateSubmittedFormData(schema, formData, options = {}) {
 /**
  * What an approval at a node has to leave behind: every field the node lets the
  * approver fill in is well-formed (a table is an array of well-formed rows with
- * its required columns and minimum rows, a member value is a member id) and
+ * its required columns and minimum rows, a member value is a member id, an
+ * org unit value is an organization unit id) and
  * every one the node marks `required` is present. The messages are the submit
  * ones: a host tells the two entry points apart by which call it made.
  */
@@ -5757,6 +5965,7 @@ function validateFilledFormFields(schema, formData, fieldKeys, requiredFieldKeys
             (0, bpm_core_shared_1.isFormDataValueEmpty)(readRowCellValue(formData, field.fieldKey))),
         readTextErrors: () => fields.flatMap((field) => readSubmittedTextValueErrors(field, readRowCellValue(formData, field.fieldKey), { testPattern })),
         readMemberErrors: () => (0, form_member_value_validator_1.readSubmittedMemberValueErrors)(fields, formData),
+        readOrgUnitErrors: () => (0, form_org_unit_value_validator_1.readSubmittedOrgUnitValueErrors)(fields, formData),
         readTableErrors: () => fields
             .filter(form_1.isTableFieldDefinition)
             .flatMap((field) => validateSubmittedTableValue(field, readRowCellValue(formData, field.fieldKey), requiredFieldKeys.has(field.fieldKey), testPattern)),
@@ -5765,10 +5974,11 @@ function validateFilledFormFields(schema, formData, fieldKeys, requiredFieldKeys
 /**
  * The shared tail of submit and approver-fill validation: a missing required
  * field wins over a text value breaking its length or format rule, which wins
- * over a malformed member value, which wins over a table problem, and the
- * later checks are only evaluated when the earlier ones pass.
+ * over a malformed member value, which wins over a malformed org unit value,
+ * which wins over a table problem, and the later checks are only evaluated
+ * when the earlier ones pass.
  */
-function throwFirstFormDataFieldError({ missingFields, readMemberErrors, readTableErrors, readTextErrors, }) {
+function throwFirstFormDataFieldError({ missingFields, readMemberErrors, readOrgUnitErrors, readTableErrors, readTextErrors, }) {
     if (missingFields.length > 0) {
         throw new common_1.BadRequestException(`Form data is missing required fields: ${missingFields
             .map((field) => field.label || field.fieldKey)
@@ -5782,6 +5992,10 @@ function throwFirstFormDataFieldError({ missingFields, readMemberErrors, readTab
     if (memberErrors.length > 0) {
         throw new common_1.BadRequestException(memberErrors.join('; '));
     }
+    const orgUnitErrors = readOrgUnitErrors();
+    if (orgUnitErrors.length > 0) {
+        throw new common_1.BadRequestException(orgUnitErrors.join('; '));
+    }
     const tableErrors = readTableErrors();
     if (tableErrors.length > 0) {
         throw new common_1.BadRequestException(tableErrors.join('; '));
@@ -6134,6 +6348,18 @@ function readDryRunPlaceholderAssignee(resolver) {
     if (resolver.type === 'ORG_UNIT_MANAGER') {
         return `orgUnitManager:${resolver.orgUnitId}`;
     }
+    if (resolver.type === 'FORM_MEMBER_MANAGER') {
+        return `formMemberManager:${resolver.formPath}:${resolver.levelsUp}`;
+    }
+    if (resolver.type === 'FORM_ORG_UNIT_MANAGER') {
+        return `formOrgUnitManager:${resolver.formPath}`;
+    }
+    if (resolver.type === 'NODE_ACTOR') {
+        return `nodeActor:${resolver.nodeIds.join(',')}`;
+    }
+    if (resolver.type === 'NODE_ACTOR_MANAGER') {
+        return `nodeActorManager:${resolver.nodeIds.join(',')}:${resolver.levelsUp}`;
+    }
     return resolver.type === 'ORG_MANAGER_CHAIN'
         ? `orgManagerChain:${resolver.minPositionLevel}`
         : resolver.type;