@rytass/bpm-core-nestjs-module 0.21.3 → 0.22.0

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

@@ -210,6 +210,8 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
         this.formDataSourceValueResolver = formDataSourceValueResolver;
         this.webhookDeliveryService = webhookDeliveryService;
         this.logger = new common_1.Logger(WorkflowEngineService_1.name);
+        /** In-flight inbox reads by member; see `readSharedOpenInboxTasks`. */
+        this.openInboxReadsInFlight = new Map();
         this.approvalInstanceFieldFilterCompiler = new approval_instance_field_filter_compiler_1.ApprovalInstanceFieldFilterCompiler();
         this.approvalInstanceFilterableFieldPolicy = new approval_instance_filterable_field_policy_1.ApprovalInstanceFilterableFieldPolicy();
         /** Webhooks each open engine transaction will send once it has committed. */
@@ -2500,37 +2502,86 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
             memberId,
             submission: null,
         });
-        return templates.filter((template) => {
-            const currentVersion = template.currentVersionId
-                ? (versionById.get(template.currentVersionId) ?? null)
-                : null;
-            if (!currentVersion?.formDefinitionVersionId) {
-                return false;
-            }
-            // A policy in a dialect this version does not know cannot be evaluated,
-            // so the template is not launchable (fail closed), but only that one:
-            // publishing does not check the field yet (Phase 23 P2), and one such
-            // version must not break the list for every member.
-            if (hasExpressionText(currentVersion.initiatorPolicyCel) &&
-                !isReadableExpressionDialect(currentVersion.workflowDefinition)) {
-                this.logger.warn(`template=${template.id} version=${currentVersion.id} left out of launchable templates: unknown expression dialect`);
-                return false;
-            }
-            // Each template is its own operation, so one slow template cannot use
-            // up the allowance of the rest of the list. A policy that throws (for
-            // example a missing `initiator.customFields.*` key, because the resolver
-            // did not return it, or failed and the list fell back to `{}`) is also
-            // only that template's problem: it is left out, and the error code is
-            // logged, never the values.
-            try {
-                return (0, expression_budget_1.runExpressionOperation)(() => this.conditionService.evaluateBoolean(currentVersion.initiatorPolicyCel, buildInitiatorPolicyContext(initiatorMetadataSnapshot), 'initiatorPolicyCel', readExpressionDialectOptions(currentVersion.initiatorPolicyCel, currentVersion.workflowDefinition)));
-            }
-            catch (error) {
-                const reason = error instanceof expression_errors_1.ExpressionRuntimeError ? error.code : 'UNEXPECTED';
-                this.logger.warn(`template=${template.id} version=${currentVersion.id} left out of launchable templates: initiatorPolicyCel failed (${reason})`);
-                return false;
-            }
+        return templates.filter((template) => this.isInitiatorPolicyMet(template, template.currentVersionId
+            ? (versionById.get(template.currentVersionId) ?? null)
+            : null, initiatorMetadataSnapshot, 'launchable templates'));
+    }
+    /**
+     * The published version whose form `memberId` may read data-source options
+     * for when starting `templateId`, or `null` when they may not.
+     *
+     * It applies the same checks as {@link listLaunchableApprovalTemplates} to
+     * that one template, but asks the host's initiator `customFields` resolver
+     * with `purpose: 'FORM_OPTIONS'` and the template and version ids. A host can
+     * therefore open a template's options to members who may not submit it
+     * themselves — a template only the host's backend submits — without the
+     * template appearing in their launchable list. The snapshot is used for this
+     * judgement only and is never stored. A resolver failure judges against
+     * `customFields: {}`, as the list does, so a policy that reads
+     * `initiator.customFields` then fails closed.
+     */
+    async readFormOptionsTemplateVersion(templateId, memberId, authContext) {
+        const template = await this.approvalTemplateRepository.findOne({
+            where: { id: templateId, isActive: true },
+        });
+        if (!template?.currentVersionId) {
+            return null;
+        }
+        const currentVersion = await this.approvalTemplateVersionRepository.findOne({
+            where: {
+                id: template.currentVersionId,
+                status: template_enums_1.ApprovalTemplateVersionStatusEnum.PUBLISHED,
+            },
+        });
+        if (!currentVersion?.formDefinitionVersionId) {
+            return null;
+        }
+        const initiatorMetadataSnapshot = await this.buildInitiatorMetadataSnapshot({
+            authContext: authContext ?? createWorkflowAuthContext(memberId),
+            formOptions: {
+                templateId: template.id,
+                templateVersionId: currentVersion.id,
+            },
+            memberId,
+            submission: null,
         });
+        return this.isInitiatorPolicyMet(template, currentVersion, initiatorMetadataSnapshot, 'form options')
+            ? currentVersion
+            : null;
+    }
+    /**
+     * Whether `template`'s current published version lets the member described
+     * by `initiatorMetadataSnapshot` start it: the launchable list and the form
+     * options check share this, so the two cannot drift apart. `scope` only
+     * names the caller in the log.
+     */
+    isInitiatorPolicyMet(template, currentVersion, initiatorMetadataSnapshot, scope) {
+        if (!currentVersion?.formDefinitionVersionId) {
+            return false;
+        }
+        // A policy in a dialect this version does not know cannot be evaluated,
+        // so the template is not launchable (fail closed), but only that one:
+        // publishing does not check the field yet (Phase 23 P2), and one such
+        // version must not break the list for every member.
+        if (hasExpressionText(currentVersion.initiatorPolicyCel) &&
+            !isReadableExpressionDialect(currentVersion.workflowDefinition)) {
+            this.logger.warn(`template=${template.id} version=${currentVersion.id} left out of ${scope}: unknown expression dialect`);
+            return false;
+        }
+        // Each template is its own operation, so one slow template cannot use
+        // up the allowance of the rest of the list. A policy that throws (for
+        // example a missing `initiator.customFields.*` key, because the resolver
+        // did not return it, or failed and the list fell back to `{}`) is also
+        // only that template's problem: it is left out, and the error code is
+        // logged, never the values.
+        try {
+            return (0, expression_budget_1.runExpressionOperation)(() => this.conditionService.evaluateBoolean(currentVersion.initiatorPolicyCel, buildInitiatorPolicyContext(initiatorMetadataSnapshot), 'initiatorPolicyCel', readExpressionDialectOptions(currentVersion.initiatorPolicyCel, currentVersion.workflowDefinition)));
+        }
+        catch (error) {
+            const reason = error instanceof expression_errors_1.ExpressionRuntimeError ? error.code : 'UNEXPECTED';
+            this.logger.warn(`template=${template.id} version=${currentVersion.id} left out of ${scope}: initiatorPolicyCel failed (${reason})`);
+            return false;
+        }
     }
     async listWorkflowTokens(instanceId, scope) {
         await this.getApprovalInstance(instanceId, scope);
@@ -2546,8 +2597,43 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
             where: { instanceId },
         }));
     }
-    async listInboxTasks(assigneeMemberId) {
-        return this.attachTaskCandidateSummaries(await this.readOpenInboxTasks(assigneeMemberId));
+    /**
+     * The member's open tasks, newest first. Without `page` / `pageSize` every
+     * one is returned, as before paging existed. The page is cut from the same
+     * {@link readOpenInboxTasks} result the dashboard counters read, so the list,
+     * {@link countInboxTasks} and the counters cannot disagree; only the page is
+     * given its candidate summaries.
+     */
+    async listInboxTasks(assigneeMemberId, options = {}) {
+        const openTasks = await this.readSharedOpenInboxTasks(assigneeMemberId);
+        if (!isTaskListPaged(options)) {
+            return this.attachTaskCandidateSummaries(openTasks);
+        }
+        const offset = readPageOffset(options.page, options.pageSize);
+        return this.attachTaskCandidateSummaries(openTasks.slice(offset, offset + normalizePageSize(options.pageSize)));
+    }
+    /** How many tasks {@link listInboxTasks} pages through. */
+    async countInboxTasks(assigneeMemberId) {
+        return (await this.readSharedOpenInboxTasks(assigneeMemberId)).length;
+    }
+    /**
+     * {@link readOpenInboxTasks} for the inbox list and its count, joining a
+     * read for the same member that is still in flight. The client asks for
+     * `inboxTasks` and `inboxTaskCount` in one request and GraphQL resolves the
+     * two side by side, so this turns two identical reads into one. An entry
+     * lives only until its read settles: nothing is cached across requests, and
+     * a read that started earlier is never served once it has finished.
+     */
+    readSharedOpenInboxTasks(assigneeMemberId) {
+        const inFlight = this.openInboxReadsInFlight.get(assigneeMemberId);
+        if (inFlight) {
+            return inFlight;
+        }
+        const read = this.readOpenInboxTasks(assigneeMemberId).finally(() => {
+            this.openInboxReadsInFlight.delete(assigneeMemberId);
+        });
+        this.openInboxReadsInFlight.set(assigneeMemberId, read);
+        return read;
     }
     /**
      * The open tasks that are this member's own to act on — the single
@@ -2609,33 +2695,86 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
         const settledTaskIds = new Set(settledCandidateRows.map((candidate) => candidate.taskId));
         return openTasks.filter((task) => !settledTaskIds.has(task.id));
     }
-    async listApprovalHistoryTasks(assigneeMemberId) {
-        const directTasks = await this.taskRepository.find({
-            order: { completedAt: 'DESC', createdAt: 'DESC' },
-            take: DEFAULT_APPROVAL_HISTORY_TASK_LIMIT,
-            where: { assigneeMemberId, status: workflow_engine_enums_1.TaskStatusEnum.COMPLETED },
-        });
-        const candidateRows = await this.taskCandidateRepository.find({
-            where: {
-                memberId: assigneeMemberId,
-                status: workflow_engine_enums_1.TaskCandidateStatusEnum.COMPLETED,
-            },
+    /**
+     * The tasks this member has acted on, most recently acted on first: tasks
+     * assigned to them that are COMPLETED, and tasks on which their own
+     * candidate row is COMPLETED. The latter needs no status on the task: a
+     * countersign still waiting on somebody else already carries their vote, and
+     * the inbox has stopped showing it to them.
+     *
+     * "Acted on" is their candidate row's `decided_at`, else the task's
+     * `completed_at`, else its `created_at`; ties fall back to the task id so no
+     * row moves between pages. Paged in SQL. Without `page` / `pageSize` the
+     * latest {@link DEFAULT_APPROVAL_HISTORY_TASK_LIMIT} are returned, as before
+     * paging existed. `instanceState` keeps only tasks of instances in that
+     * state (RUNNING for "acted on, not finished").
+     */
+    async listApprovalHistoryTasks(assigneeMemberId, options = {}) {
+        const paged = isTaskListPaged(options);
+        const tasks = await this.createApprovalHistoryTaskQuery(assigneeMemberId, options.instanceState)
+            .orderBy(this.readApprovalHistoryActedAtExpression(), 'DESC')
+            .addOrderBy('"task"."id"', 'DESC')
+            .offset(paged ? readPageOffset(options.page, options.pageSize) : 0)
+            .limit(paged
+            ? normalizePageSize(options.pageSize)
+            : DEFAULT_APPROVAL_HISTORY_TASK_LIMIT)
+            .getMany();
+        return this.attachTaskCandidateSummaries(tasks);
+    }
+    /** How many tasks {@link listApprovalHistoryTasks} pages through. */
+    async countApprovalHistoryTasks(assigneeMemberId, options = {}) {
+        return this.createApprovalHistoryTaskQuery(assigneeMemberId, options.instanceState).getCount();
+    }
+    /** The rows of {@link listApprovalHistoryTasks}, unordered and unpaged. */
+    createApprovalHistoryTaskQuery(assigneeMemberId, instanceState) {
+        const candidateTable = this.readQualifiedTableName(this.taskCandidateRepository);
+        const queryBuilder = this.taskRepository
+            .createQueryBuilder('task')
+            .andWhere(`
+          (
+            (
+              "task"."assignee_member_id" = :historyMemberId
+              AND "task"."status" = :historyTaskStatus
+            )
+            OR EXISTS (
+              SELECT 1
+              FROM ${candidateTable} "historyCandidate"
+              WHERE "historyCandidate"."task_id" = "task"."id"
+                AND "historyCandidate"."member_id" = :historyMemberId
+                AND "historyCandidate"."status" = :historyCandidateStatus
+            )
+          )
+        `, {
+            historyCandidateStatus: workflow_engine_enums_1.TaskCandidateStatusEnum.COMPLETED,
+            historyMemberId: assigneeMemberId,
+            historyTaskStatus: workflow_engine_enums_1.TaskStatusEnum.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)),
-                },
-            })
-            : [];
-        return this.attachTaskCandidateSummaries(uniqueTasksById([...directTasks, ...candidateTasks]));
+        if (instanceState) {
+            queryBuilder.andWhere(`
+          EXISTS (
+            SELECT 1
+            FROM ${this.readQualifiedTableName(this.approvalInstanceRepository)} "historyInstance"
+            WHERE "historyInstance"."id" = "task"."instance_id"
+              AND "historyInstance"."state" = :historyInstanceState
+          )
+        `, { historyInstanceState: instanceState });
+        }
+        return queryBuilder;
+    }
+    /** When the member acted on a history task; see {@link listApprovalHistoryTasks}. */
+    readApprovalHistoryActedAtExpression() {
+        const candidateTable = this.readQualifiedTableName(this.taskCandidateRepository);
+        return `COALESCE(
+      (
+        SELECT MAX("actedCandidate"."decided_at")
+        FROM ${candidateTable} "actedCandidate"
+        WHERE "actedCandidate"."task_id" = "task"."id"
+          AND "actedCandidate"."member_id" = :historyMemberId
+          AND "actedCandidate"."status" = :historyCandidateStatus
+      ),
+      "task"."completed_at",
+      "task"."created_at"
+    )`;
     }
     async listTaskDecisions(taskId, scope) {
         await this.assertTaskReadable(taskId, scope);
@@ -2793,26 +2932,30 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
      *   case on data the host never gave. It runs before the engine
      *   transaction, so a failure leaves nothing behind and a slow lookup holds
      *   no lock.
-     * - The list carries on with `customFields: {}` and logs a warning: one
-     *   failing lookup must not take the whole list away. That fails closed: a
+     * - The list, and the form options check, carry on with `customFields: {}`
+     *   and log a warning: one failing lookup must not take the whole list
+     *   away. That fails closed: a
      *   policy that reads `initiator.customFields` then throws on the missing key
      *   and the list's per-template catch leaves that template out, while a
      *   template whose policy does not read it is listed as usual. Submitting is
      *   still judged against the resolver's real answer.
      */
-    async buildInitiatorMetadataSnapshot({ authContext, memberId, submission, }) {
+    async buildInitiatorMetadataSnapshot({ authContext, formOptions = null, memberId, submission, }) {
         const defaultSnapshot = await this.readDefaultInitiatorMetadataSnapshot(memberId);
         if (!this.initiatorCustomFieldsResolver) {
             return defaultSnapshot;
         }
+        // The template the resolver is asked about: the one being submitted, or
+        // the one whose options are read. The list asks about none.
+        const template = submission ?? formOptions;
         const input = {
             authContext,
             defaultSnapshot: cloneJsonObject(defaultSnapshot),
             formData: submission ? cloneJsonObject(submission.formData) : null,
             memberId,
-            purpose: submission ? 'SUBMISSION' : 'LAUNCHABLE_TEMPLATES',
-            templateId: submission?.templateId ?? null,
-            templateVersionId: submission?.templateVersionId ?? null,
+            purpose: readInitiatorCustomFieldsPurpose({ formOptions, submission }),
+            templateId: template?.templateId ?? null,
+            templateVersionId: template?.templateVersionId ?? null,
         };
         if (submission) {
             return {
@@ -2827,7 +2970,9 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
             };
         }
         catch (error) {
-            this.logger.warn(`Launchable templates judged with customFields {}: the initiator customFields resolver failed (${error instanceof common_1.HttpException ? error.getStatus() : 'UNEXPECTED'})`);
+            this.logger.warn(`${formOptions
+                ? `Form options for template=${formOptions.templateId}`
+                : 'Launchable templates'} judged with customFields {}: the initiator customFields resolver failed (${error instanceof common_1.HttpException ? error.getStatus() : 'UNEXPECTED'})`);
             return defaultSnapshot;
         }
     }
@@ -2848,9 +2993,9 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
      * unhandled.
      */
     async resolveInitiatorCustomFields(resolver, input) {
-        const subject = input.purpose === 'SUBMISSION'
-            ? `template=${input.templateId} version=${input.templateVersionId}`
-            : 'launchable templates';
+        const subject = input.purpose === 'LAUNCHABLE_TEMPLATES'
+            ? 'launchable templates'
+            : `${input.purpose === 'FORM_OPTIONS' ? 'form options ' : ''}template=${input.templateId} version=${input.templateVersionId}`;
         const outcome = await settleWithin(new Promise((resolve) => {
             resolve(resolver.resolveCustomFields(input));
         }), INITIATOR_CUSTOM_FIELDS_RESOLVER_TIMEOUT_MS, (late) => {
@@ -5635,6 +5780,13 @@ function readDefaultInitiatorMetadataSnapshot(memberId) {
 function cloneJsonObject(value) {
     return JSON.parse(JSON.stringify(value));
 }
+/** Which caller is building an initiator snapshot, as the resolver is told. */
+function readInitiatorCustomFieldsPurpose({ formOptions, submission, }) {
+    if (submission) {
+        return 'SUBMISSION';
+    }
+    return formOptions ? 'FORM_OPTIONS' : 'LAUNCHABLE_TEMPLATES';
+}
 /**
  * What a host's initiator `customFields` resolver returned, as the object the
  * snapshot keeps: a plain object that survives JSON, which is also how it is
@@ -6376,6 +6528,9 @@ function readPageOffset(page, pageSize) {
     const normalizedPageSize = normalizePageSize(pageSize);
     return (normalizePage(page) - 1) * normalizedPageSize;
 }
+function isTaskListPaged(options) {
+    return options.page !== undefined || options.pageSize !== undefined;
+}
 function shouldPaginateList(options) {
     return (typeof options.page !== 'undefined' ||
         typeof options.pageSize !== 'undefined');