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

package/src/lib/workflow-engine/workflow-engine.service.d.ts

@@ -50,9 +50,18 @@ type SubmitApprovalInstanceCommand = SubmitApprovalInstanceInput & {
      * the initiator submitted the document themselves.
      */
     readonly submittedByMemberId?: string | null;
+    /**
+     * Set only by the GraphQL mutation, never by the DTO, so an end user cannot
+     * bring it along. The service then keeps the fields an approver fills in
+     * out of the submission; a host calling the service directly leaves it
+     * unset and may prefill them.
+     */
+    readonly endUserSubmission?: boolean;
 };
 type ResubmitApprovalInstanceCommand = ResubmitApprovalInstanceInput & {
     readonly initiatorMemberId: string;
+    /** See `SubmitApprovalInstanceCommand.endUserSubmission`. */
+    readonly endUserSubmission?: boolean;
 };
 export declare const MAX_APPROVAL_INSTANCE_BUSINESS_KEY_LENGTH = 200;
 /**
@@ -300,16 +309,19 @@ export declare class WorkflowEngineService {
     listTaskCandidates(taskId: string, scope?: WorkflowReadScope): Promise<readonly TaskCandidateEntity[]>;
     private attachTaskCandidateSummaries;
     /**
-     * The display names of the nodes a page of tasks sits on, keyed by
+     * The display names of the nodes a page of tasks sits on, and whether each
+     * is a user task that lets its approver fill in fields, keyed by
      * {@link readNodeLabelKey}. One query for the whole page, and Postgres picks
      * the labels out of the snapshots: a workflow snapshot is a whole workflow
      * definition, and every inbox, history and instance task list runs this, so
      * shipping the snapshots to the app just to read one string each would cost
      * page size × snapshot size on every refresh. A missing instance or node, a
      * snapshot without a `nodes` array, and a blank or non-string label all
-     * leave the task without a label, as `readWorkflowNodeLabel` does.
+     * leave the task without a label, as `readWorkflowNodeLabel` does. Only the
+     * node's `fieldAccess` leaves the database for the fill flag, which
+     * `readNodeFillableFieldKeys` then reads as tolerantly as the engine does.
      */
-    private readTaskNodeLabels;
+    private readTaskNodeSummaries;
     private readDefaultInitiatorMetadataSnapshot;
     listActivityLogs(instanceId: string, scope?: WorkflowReadScope): Promise<readonly ActivityLogEntity[]>;
     private assertTaskReadable;

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowEngineService = exports.ADMIN_REASSIGN_DELEGATION_REASON = exports.MANUAL_TRANSFER_DELEGATION_REASON = exports.MAX_APPROVAL_INSTANCE_BUSINESS_KEY_LENGTH = void 0;
 const tslib_1 = require("tslib");
 const class_validator_1 = require("class-validator");
+const bpm_core_shared_1 = require("@rytass/bpm-core-shared");
 const form_1 = require("@rytass/bpm-core-shared/form");
 const workflow_1 = require("@rytass/bpm-core-shared/workflow");
 const workflow_graph_1 = require("@rytass/bpm-core-shared/workflow-graph");
@@ -37,6 +38,7 @@ const activity_log_entity_1 = require("./activity-log.entity");
 const adhoc_directive_entity_1 = require("./adhoc-directive.entity");
 const adhoc_enums_1 = require("./adhoc.enums");
 const approval_instance_entity_1 = require("./approval-instance.entity");
+const form_data_fingerprint_1 = require("./form-data-fingerprint");
 const instance_submitter_1 = require("./instance-submitter");
 const task_decision_entity_1 = require("./task-decision.entity");
 const task_candidate_entity_1 = require("./task-candidate.entity");
@@ -171,7 +173,7 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
                 input.submittedByMemberId.trim() === '')) {
             throw new common_1.BadRequestException('submittedByMemberId must be a non-empty string');
         }
-        const formData = parseJsonObject(input.formDataJson, 'formDataJson');
+        const submittedFormData = parseJsonObject(input.formDataJson, 'formDataJson');
         const businessKey = normalizeBusinessKey(input.businessKey);
         const submittedByMemberId = input.submittedByMemberId ?? input.initiatorMemberId;
         const template = await this.getTemplateOrThrow(input.templateId);
@@ -183,7 +185,20 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
         }
         const templateVersion = await this.getPublishedTemplateVersionOrThrow(template.currentVersionId);
         const formDefinitionVersion = await this.getPublishedFormVersionOrThrow(templateVersion.formDefinitionVersionId);
-        validateSubmittedFormData(formDefinitionVersion.schema, formData);
+        // The fields an approver fills in belong to the approval, not the
+        // application: an end user's value for one is dropped (it would otherwise
+        // be an unreviewed value the approver has to overwrite), while a host
+        // calling the service directly may prefill them. They are only shape
+        // checked here; required and row minimums wait for the node that fills
+        // them. Read off the version the instance is bound to, not the template's
+        // latest, so a publish in between cannot change what is stripped.
+        const deferredFieldKeys = (0, bpm_core_shared_1.readApproverFilledFieldKeys)(templateVersion.workflowDefinition);
+        const formData = input.endUserSubmission === true
+            ? (0, bpm_core_shared_1.omitFormDataKeys)(submittedFormData, deferredFieldKeys)
+            : submittedFormData;
+        validateSubmittedFormData(formDefinitionVersion.schema, formData, {
+            deferredFieldKeys,
+        });
         const formDataOptionSnapshot = await this.resolveFormDataOptionSnapshots({
             authContext: authContext ?? createWorkflowAuthContext(input.initiatorMemberId),
             formData,
@@ -308,7 +323,7 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
             schema,
         });
     }
-    async prepareResubmitFormDataOptions(input, formData, authContext) {
+    async prepareResubmitFormDataOptions(input, submittedFormData, authContext) {
         const instance = await this.approvalInstanceRepository.findOne({
             where: { id: input.instanceId },
         });
@@ -326,7 +341,13 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
             throw new common_1.ConflictException('Approval template is deactivated');
         }
         const schema = readFormDefinitionSnapshotSchema(instance.formDefinitionSnapshot);
-        validateSubmittedFormData(schema, formData);
+        const deferredFieldKeys = (0, bpm_core_shared_1.readApproverFilledFieldKeys)(instance.workflowSnapshot);
+        // Same overlay as inside the lock, so the options resolved here are for
+        // the form data that is actually saved.
+        const formData = input.endUserSubmission === true
+            ? (0, bpm_core_shared_1.overlayStoredFormDataKeys)(submittedFormData, instance.formData, deferredFieldKeys)
+            : submittedFormData;
+        validateSubmittedFormData(schema, formData, { deferredFieldKeys });
         const formDataOptionSnapshot = await this.resolveFormDataOptionSnapshots({
             authContext,
             formData,
@@ -371,15 +392,24 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
             const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
             const tokenRepository = manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity);
             const instanceRepository = manager.getRepository(approval_instance_entity_1.ApprovalInstanceEntity);
-            const task = await taskRepository.findOne({
+            const taskBeforeLock = await taskRepository.findOne({
                 where: { id: input.taskId },
             });
-            if (!task) {
+            if (!taskBeforeLock) {
                 throw new common_1.NotFoundException(`Task ${input.taskId} was not found`);
             }
             await manager.query('SELECT pg_advisory_xact_lock(hashtext($1))', [
-                task.instanceId,
+                taskBeforeLock.instanceId,
             ]);
+            // Read again now that the lock is ours: a decision that held it first
+            // may have completed this task since the read above, and everything
+            // below must judge the task as it is now, not as it was.
+            const task = await taskRepository.findOne({
+                where: { id: input.taskId },
+            });
+            if (!task) {
+                throw new common_1.NotFoundException(`Task ${input.taskId} was not found`);
+            }
             if (task.status !== workflow_engine_enums_1.TaskStatusEnum.PENDING &&
                 task.status !== workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS) {
                 throw new common_1.ConflictException(`Task ${task.id} is not pending`);
@@ -405,6 +435,15 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
                 transferToMemberId === input.decidedByMemberId) {
                 throw new common_1.ConflictException('Transfer target must be a different member');
             }
+            // "Sent" means not null and not undefined, so '{}' counts.
+            const sentFormDataJson = input.formDataJson ?? null;
+            if (sentFormDataJson !== null &&
+                input.action !== workflow_engine_enums_1.TaskDecisionActionEnum.APPROVED) {
+                throw new common_1.BadRequestException('formDataJson can only be sent with an APPROVED decision');
+            }
+            const filledFormData = sentFormDataJson === null
+                ? null
+                : parseJsonObject(sentFormDataJson, 'formDataJson');
             const instance = await instanceRepository.findOne({
                 where: { id: task.instanceId },
             });
@@ -485,6 +524,53 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
                 isReturnCommentRequired(instance.workflowSnapshot, task.nodeId)) {
                 throw new common_1.BadRequestException(`Return decision comment is required by workflow node ${task.nodeId}`);
             }
+            if (filledFormData !== null && task.isAdhoc) {
+                throw new common_1.ForbiddenException(`Ad-hoc task ${task.id} cannot fill in form fields`);
+            }
+            if (filledFormData !== null) {
+                const fillableFieldKeys = (0, bpm_core_shared_1.readNodeFillableFieldKeys)(taskNode);
+                const refusedFieldKeys = Object.keys(filledFormData).filter((fieldKey) => !fillableFieldKeys.has(fieldKey));
+                if (refusedFieldKeys.length > 0) {
+                    throw new common_1.ForbiddenException(`Workflow node ${task.nodeId} does not let approvers fill in: ${refusedFieldKeys.join(', ')}`);
+                }
+            }
+            const expectedFormDataFingerprint = input.expectedFormDataFingerprint ?? null;
+            if (expectedFormDataFingerprint !== null &&
+                expectedFormDataFingerprint !==
+                    (0, form_data_fingerprint_1.computeFormDataFingerprint)(instance.formData)) {
+                throw new common_1.ConflictException(`Approval instance ${instance.id} form data changed; refresh and retry`);
+            }
+            // Only keys whose value really changes are written and reported. A key
+            // the form data does not have yet counts as changed even when the new
+            // value is null.
+            const changedFieldKeys = filledFormData === null
+                ? []
+                : Object.keys(filledFormData)
+                    .filter((fieldKey) => !Object.prototype.hasOwnProperty.call(instance.formData, fieldKey) ||
+                    (0, form_data_fingerprint_1.computeStableValueFingerprint)(filledFormData[fieldKey]) !==
+                        (0, form_data_fingerprint_1.computeStableValueFingerprint)(instance.formData[fieldKey]))
+                    .sort();
+            const mergedFormData = { ...instance.formData, ...filledFormData };
+            // Every approval at a node that lets its approver fill in fields is
+            // held to those fields, whether or not this request sent any: the host
+            // may have pre-filled a table the approver then leaves as is.
+            if (input.action === workflow_engine_enums_1.TaskDecisionActionEnum.APPROVED && !task.isAdhoc) {
+                const nodeFillableFieldKeys = (0, bpm_core_shared_1.readNodeFillableFieldKeys)(taskNode);
+                if (nodeFillableFieldKeys.size > 0) {
+                    validateFilledFormFields(readFormDefinitionSnapshotSchema(instance.formDefinitionSnapshot), mergedFormData, nodeFillableFieldKeys, (0, bpm_core_shared_1.readNodeRequiredFieldKeys)(taskNode));
+                }
+            }
+            if (filledFormData !== null && changedFieldKeys.length > 0) {
+                // Merged into the shared `instance` before it is signed and before
+                // the token moves on: the signature must cover the filled values, a
+                // gateway after this node must route on them, and an end node saves
+                // this same object, which would write the old values back.
+                const savedInstance = await instanceRepository.save({
+                    ...instance,
+                    formData: mergedFormData,
+                });
+                Object.assign(instance, savedInstance);
+            }
             const decidedAt = new Date();
             const claimedTask = await taskRepository.save({
                 ...task,
@@ -586,6 +672,9 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
                     decisionId: decision.id,
                     signatureId: signature.id,
                     signedPayloadHash: signature.signedPayloadHash,
+                    // Keys only: this payload is forwarded to hosts, and the values
+                    // can be tax IDs or amounts.
+                    ...(changedFieldKeys.length > 0 ? { changedFieldKeys } : {}),
                 },
                 taskId: completedTask.id,
             }));
@@ -750,9 +839,9 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
         return closedInstance;
     }
     async resubmitApprovalInstance(input, authContext) {
-        const formData = parseJsonObject(input.formDataJson, 'formDataJson');
+        const submittedFormData = parseJsonObject(input.formDataJson, 'formDataJson');
         const preparation = this.formDataSourceValueResolver
-            ? await this.prepareResubmitFormDataOptions(input, formData, authContext ?? createWorkflowAuthContext(input.initiatorMemberId))
+            ? await this.prepareResubmitFormDataOptions(input, submittedFormData, authContext ?? createWorkflowAuthContext(input.initiatorMemberId))
             : null;
         return this.approvalInstanceRepository.manager.transaction(async (manager) => {
             await manager.query('SELECT pg_advisory_xact_lock(hashtext($1))', [
@@ -780,7 +869,16 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
                 throw new common_1.ConflictException('Approval instance changed while options were resolving; refresh and retry');
             }
             const resubmitSchema = readFormDefinitionSnapshotSchema(instance.formDefinitionSnapshot);
-            validateSubmittedFormData(resubmitSchema, formData);
+            const deferredFieldKeys = (0, bpm_core_shared_1.readApproverFilledFieldKeys)(instance.workflowSnapshot);
+            // An end user gets back the value an approver already filled in, and
+            // loses a key the stored data never had: the renderer seeds `false`,
+            // `[]` and empty rows for every field, none of which an approver wrote.
+            const formData = input.endUserSubmission === true
+                ? (0, bpm_core_shared_1.overlayStoredFormDataKeys)(submittedFormData, instance.formData, deferredFieldKeys)
+                : submittedFormData;
+            validateSubmittedFormData(resubmitSchema, formData, {
+                deferredFieldKeys,
+            });
             if (!preparation) {
                 assertNoUnresolvableDynamicValues(resubmitSchema, formData);
             }
@@ -2159,25 +2257,31 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
             ]);
             return nextMap;
         }, new Map());
-        const nodeLabels = await this.readTaskNodeLabels(tasks);
-        return tasks.map((task) => Object.assign(new task_entity_1.TaskEntity(), task, {
-            candidateMemberIds: candidatesByTaskId.get(task.id) ?? [],
-            nodeLabel: nodeLabels.get(readNodeLabelKey(task.instanceId, task.nodeId)) ??
-                null,
-            openCandidateMemberIds: openCandidatesByTaskId.get(task.id) ?? [],
-        }));
+        const nodeSummaries = await this.readTaskNodeSummaries(tasks);
+        return tasks.map((task) => {
+            const nodeSummary = nodeSummaries.get(readNodeLabelKey(task.instanceId, task.nodeId));
+            return Object.assign(new task_entity_1.TaskEntity(), task, {
+                candidateMemberIds: candidatesByTaskId.get(task.id) ?? [],
+                hasFillableFields: !task.isAdhoc && (nodeSummary?.hasFillableFields ?? false),
+                nodeLabel: nodeSummary?.label ?? null,
+                openCandidateMemberIds: openCandidatesByTaskId.get(task.id) ?? [],
+            });
+        });
     }
     /**
-     * The display names of the nodes a page of tasks sits on, keyed by
+     * The display names of the nodes a page of tasks sits on, and whether each
+     * is a user task that lets its approver fill in fields, keyed by
      * {@link readNodeLabelKey}. One query for the whole page, and Postgres picks
      * the labels out of the snapshots: a workflow snapshot is a whole workflow
      * definition, and every inbox, history and instance task list runs this, so
      * shipping the snapshots to the app just to read one string each would cost
      * page size × snapshot size on every refresh. A missing instance or node, a
      * snapshot without a `nodes` array, and a blank or non-string label all
-     * leave the task without a label, as `readWorkflowNodeLabel` does.
+     * leave the task without a label, as `readWorkflowNodeLabel` does. Only the
+     * node's `fieldAccess` leaves the database for the fill flag, which
+     * `readNodeFillableFieldKeys` then reads as tolerantly as the engine does.
      */
-    async readTaskNodeLabels(tasks) {
+    async readTaskNodeSummaries(tasks) {
         // The table as the entity reads it, so a configured `schema` is honoured
         // here exactly as it is by every repository read of the instance.
         const { metadata } = this.approvalInstanceRepository;
@@ -2188,6 +2292,8 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
             .join('.');
         const rows = await this.approvalInstanceRepository.query(`SELECT instance.id AS "instanceId",
               node->>'id' AS "nodeId",
+              node->>'type' AS "nodeType",
+              node->'data'->'fieldAccess' AS "fieldAccess",
               CASE WHEN jsonb_typeof(node->'data'->'label') = 'string'
                    THEN node->'data'->>'label' END AS "label"
          FROM ${instanceTable} AS instance
@@ -2195,15 +2301,27 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
               CASE WHEN jsonb_typeof(instance.workflow_snapshot->'nodes') = 'array'
                    THEN instance.workflow_snapshot->'nodes'
                    ELSE '[]'::jsonb END
-            ) AS node
+            ) WITH ORDINALITY AS entry(node, position)
         WHERE instance.id = ANY($1::uuid[])
-          AND node->>'id' = ANY($2::text[])`, [
+          AND node->>'id' = ANY($2::text[])
+        ORDER BY entry.position DESC`, [
             [...new Set(tasks.map((task) => task.instanceId))],
             [...new Set(tasks.map((task) => task.nodeId))],
         ]);
-        return new Map(rows.flatMap((row) => typeof row.label === 'string' && row.label.trim()
-            ? [[readNodeLabelKey(row.instanceId, row.nodeId), row.label]]
-            : []));
+        // Rows come last node first, so the first node with a given id wins, as
+        // `find` does everywhere else that reads a snapshot node by id.
+        return new Map(rows.map((row) => [
+            readNodeLabelKey(row.instanceId, row.nodeId),
+            {
+                hasFillableFields: row.nodeType === 'userTask' &&
+                    (0, bpm_core_shared_1.readNodeFillableFieldKeys)({
+                        data: { fieldAccess: row.fieldAccess },
+                    }).size > 0,
+                label: typeof row.label === 'string' && row.label.trim()
+                    ? row.label
+                    : null,
+            },
+        ]));
     }
     async readDefaultInitiatorMetadataSnapshot(memberId) {
         const today = this.readOrganizationToday();
@@ -2734,6 +2852,7 @@ let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineServic
         const singleCandidate = savedCandidates.length === 1 ? savedCandidates[0] : null;
         const openCandidates = savedCandidates.filter((candidate) => candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING);
         task.openCandidateMemberIds = openCandidates.map((candidate) => candidate.memberId);
+        task.hasFillableFields = (0, bpm_core_shared_1.readNodeFillableFieldKeys)(node).size > 0;
         await tokenRepository.save({
             ...token,
             status: workflow_engine_enums_1.WorkflowTokenStatusEnum.WAITING,
@@ -5418,39 +5537,82 @@ function readCandidateStatusForClosedTask(taskStatus) {
     }
     return workflow_engine_enums_1.TaskCandidateStatusEnum.CANCELLED;
 }
-function validateSubmittedFormData(schema, formData) {
+/**
+ * `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.
+ */
+function validateSubmittedFormData(schema, formData, options = {}) {
+    const deferredFieldKeys = options.deferredFieldKeys ?? new Set();
     const visibleFields = schema.fields.filter((field) => isSubmittedFormFieldVisible(field, schema.fields, formData));
     // Tables answer "is this filled?" by row count and report per-row problems
     // with an instance path, so they get their own pass instead of the flat
     // "missing required fields" list (ADR 16 §3.7).
     const missingFields = visibleFields.filter((field) => !(0, form_1.isTableFieldDefinition)(field) &&
+        !deferredFieldKeys.has(field.fieldKey) &&
         isSubmittedFormFieldRequired(field, schema.fields, formData) &&
         !isSubmittedFieldValuePresent(formData[field.fieldKey]));
+    throwFirstFormDataFieldError({
+        missingFields,
+        // A `DYNAMIC_FORM` resolver reads a member value whether or not its field
+        // is visible, so a hidden field still holding a value must be well-formed
+        // too. Whether a hidden field is *required* stays a visibility question
+        // above.
+        readMemberErrors: () => (0, form_member_value_validator_1.readSubmittedMemberValueErrors)(schema.fields.filter((field) => visibleFields.includes(field) ||
+            isSubmittedFieldValuePresent(formData[field.fieldKey])), formData),
+        readTableErrors: () => [
+            ...visibleFields
+                .filter(form_1.isTableFieldDefinition)
+                .flatMap((field) => validateSubmittedTableValue(field, formData[field.fieldKey], isSubmittedFormFieldRequired(field, schema.fields, formData), deferredFieldKeys.has(field.fieldKey))),
+            // A hidden table is not "visible", but its stored value still has to be
+            // a well-formed table under the row cap: only the required / minimum
+            // checks are skipped, since nobody can fill the table in.
+            ...schema.fields
+                .filter(form_1.isTableFieldDefinition)
+                .filter((field) => field.hidden === true)
+                .flatMap((field) => validateSubmittedTableValue(field, formData[field.fieldKey], false, true)),
+        ],
+    });
+}
+/**
+ * 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
+ * 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.
+ */
+function validateFilledFormFields(schema, formData, fieldKeys, requiredFieldKeys) {
+    const fields = schema.fields.filter((field) => fieldKeys.has(field.fieldKey));
+    // `readRowCellValue` is used below as an own-property reader for top-level
+    // form keys: a key like `constructor` must not read off the prototype chain.
+    throwFirstFormDataFieldError({
+        // Tables answer by row count, so like submit they stay out of this list.
+        missingFields: fields.filter((field) => !(0, form_1.isTableFieldDefinition)(field) &&
+            requiredFieldKeys.has(field.fieldKey) &&
+            (0, bpm_core_shared_1.isFormDataValueEmpty)(readRowCellValue(formData, field.fieldKey))),
+        readMemberErrors: () => (0, form_member_value_validator_1.readSubmittedMemberValueErrors)(fields, formData),
+        readTableErrors: () => fields
+            .filter(form_1.isTableFieldDefinition)
+            .flatMap((field) => validateSubmittedTableValue(field, readRowCellValue(formData, field.fieldKey), requiredFieldKeys.has(field.fieldKey))),
+    });
+}
+/**
+ * The shared tail of submit and approver-fill validation: a missing required
+ * field wins over a malformed member value, which wins over a table problem,
+ * and the later checks are only evaluated when the earlier ones pass.
+ */
+function throwFirstFormDataFieldError({ missingFields, readMemberErrors, readTableErrors, }) {
     if (missingFields.length > 0) {
         throw new common_1.BadRequestException(`Form data is missing required fields: ${missingFields
             .map((field) => field.label || field.fieldKey)
             .join(', ')}`);
     }
-    // A `DYNAMIC_FORM` resolver reads a member value whether or not its field is
-    // visible, so a hidden field still holding a value must be well-formed too.
-    // Whether a hidden field is *required* stays a visibility question above.
-    const memberErrors = (0, form_member_value_validator_1.readSubmittedMemberValueErrors)(schema.fields.filter((field) => visibleFields.includes(field) ||
-        isSubmittedFieldValuePresent(formData[field.fieldKey])), formData);
+    const memberErrors = readMemberErrors();
     if (memberErrors.length > 0) {
         throw new common_1.BadRequestException(memberErrors.join('; '));
     }
-    const tableErrors = [
-        ...visibleFields
-            .filter(form_1.isTableFieldDefinition)
-            .flatMap((field) => validateSubmittedTableValue(field, formData[field.fieldKey], isSubmittedFormFieldRequired(field, schema.fields, formData))),
-        // A hidden table is not "visible", but its stored value still has to be a
-        // well-formed table under the row cap: only the required / minimum checks
-        // are skipped, since nobody can fill the table in.
-        ...schema.fields
-            .filter(form_1.isTableFieldDefinition)
-            .filter((field) => field.hidden === true)
-            .flatMap((field) => validateSubmittedTableValue(field, formData[field.fieldKey], false, true)),
-    ];
+    const tableErrors = readTableErrors();
     if (tableErrors.length > 0) {
         throw new common_1.BadRequestException(tableErrors.join('; '));
     }
@@ -5676,16 +5838,7 @@ function parseFormConditionLiteral(value) {
     return trimmedValue;
 }
 function isSubmittedFieldValuePresent(value) {
-    if (typeof value === 'undefined' || value === null) {
-        return false;
-    }
-    if (typeof value === 'string') {
-        return value.trim().length > 0;
-    }
-    if (Array.isArray(value)) {
-        return value.length > 0;
-    }
-    return true;
+    return !(0, bpm_core_shared_1.isFormDataValueEmpty)(value);
 }
 function isNumberFormField(field) {
     return field.type === 'number' || field.type === 'money';