@rytass/bpm-core-client 0.5.0 → 0.6.0

package/src/lib/workflow/workflow-api.js

@@ -0,0 +1,1068 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listApprovalInstances = listApprovalInstances;
+exports.listApprovalInstancesPage = listApprovalInstancesPage;
+exports.readLaunchContext = readLaunchContext;
+exports.listLaunchableTemplates = listLaunchableTemplates;
+exports.readApprovalInstance = readApprovalInstance;
+exports.listInboxTasks = listInboxTasks;
+exports.listApprovalHistoryTasks = listApprovalHistoryTasks;
+exports.readWorkflowDashboardSummary = readWorkflowDashboardSummary;
+exports.listTaskDecisions = listTaskDecisions;
+exports.listAttachments = listAttachments;
+exports.uploadAttachment = uploadAttachment;
+exports.readAttachmentDownloadUrl = readAttachmentDownloadUrl;
+exports.readAttachmentPreviewUrl = readAttachmentPreviewUrl;
+exports.readInstanceSignatures = readInstanceSignatures;
+exports.resolveMemberProfiles = resolveMemberProfiles;
+exports.searchMembers = searchMembers;
+exports.listMemberDirectoryPage = listMemberDirectoryPage;
+exports.listDelegationRules = listDelegationRules;
+exports.listDelegationRulesPage = listDelegationRulesPage;
+exports.createDelegationRule = createDelegationRule;
+exports.revokeDelegationRule = revokeDelegationRule;
+exports.listNotifications = listNotifications;
+exports.readUnreadNotificationCount = readUnreadNotificationCount;
+exports.markNotificationRead = markNotificationRead;
+exports.markAllNotificationsRead = markAllNotificationsRead;
+exports.readNotificationPreference = readNotificationPreference;
+exports.updateNotificationPreference = updateNotificationPreference;
+exports.submitApprovalInstance = submitApprovalInstance;
+exports.decideTask = decideTask;
+exports.cancelApprovalInstance = cancelApprovalInstance;
+exports.resubmitApprovalInstance = resubmitApprovalInstance;
+exports.requestAdhocCountersign = requestAdhocCountersign;
+exports.requestAdhocPreApproval = requestAdhocPreApproval;
+exports.configureAdhocStageNotification = configureAdhocStageNotification;
+exports.configureAdhocCompletionNotification = configureAdhocCompletionNotification;
+exports.cancelAdhocDirective = cancelAdhocDirective;
+exports.listAdhocDirectives = listAdhocDirectives;
+exports.readApprovalInstanceCaseTitle = readApprovalInstanceCaseTitle;
+exports.readFormDataCaseTitle = readFormDataCaseTitle;
+const graphql_client_1 = require("../graphql-client");
+async function listApprovalInstances() {
+    const data = await (0, graphql_client_1.requestGraphQl)(`query ApprovalInstances {
+      approvalInstances {
+        completedAt
+        formDataJson
+        formDefinitionSnapshotJson
+        id
+        initiatorMemberId
+        startedAt
+        state
+        templateId
+        templateVersionId
+        title
+        workflowSnapshotJson
+      }
+    }`);
+    return data.approvalInstances.map(parseInstanceJson);
+}
+async function listApprovalInstancesPage({ page, pageSize, searchText, state, templateId, view, }) {
+    const variables = {
+        page,
+        pageSize,
+        searchText: searchText?.trim() || null,
+        state: state ? [state] : null,
+        templateId: templateId?.trim() || null,
+        view,
+    };
+    const [pageData, pageInfoData] = await Promise.all([
+        (0, graphql_client_1.requestGraphQl)(`query ApprovalInstancesPage(
+        $view: ApprovalInstanceListView
+        $searchText: String
+        $state: [ApprovalInstanceState!]
+        $templateId: String
+        $page: Int
+        $pageSize: Int
+      ) {
+        approvalInstances(
+          view: $view
+          searchText: $searchText
+          state: $state
+          templateId: $templateId
+          page: $page
+          pageSize: $pageSize
+        ) {
+          completedAt
+          formDataJson
+          formDefinitionSnapshotJson
+          id
+          initiatorMemberId
+          startedAt
+          state
+          templateId
+          templateVersionId
+          title
+          workflowSnapshotJson
+        }
+      }`, variables),
+        (0, graphql_client_1.requestGraphQl)(`query ApprovalInstancePageInfo(
+        $view: ApprovalInstanceListView
+        $searchText: String
+        $state: [ApprovalInstanceState!]
+        $templateId: String
+        $page: Int
+        $pageSize: Int
+      ) {
+        approvalInstancePageInfo(
+          view: $view
+          searchText: $searchText
+          state: $state
+          templateId: $templateId
+          page: $page
+          pageSize: $pageSize
+        ) {
+          hasNextPage
+          hasPreviousPage
+          page
+          pageSize
+          totalCount
+          totalPages
+        }
+      }`, variables),
+    ]);
+    const pageInfo = pageInfoData.approvalInstancePageInfo;
+    return {
+        instances: pageData.approvalInstances.map(parseInstanceJson),
+        pageInfo,
+        totalCount: pageInfo.totalCount,
+    };
+}
+async function readLaunchContext(templateId) {
+    const templateData = await (0, graphql_client_1.requestGraphQl)(`query LaunchTemplate($id: String!) {
+      approvalTemplate(id: $id) {
+        currentVersionId
+        id
+        name
+      }
+      approvalTemplateVersions(templateId: $id) {
+        formDefinitionVersionId
+        id
+        status
+        version
+      }
+      launchableApprovalTemplates {
+        currentVersionId
+        id
+        name
+        updatedAt
+      }
+    }`, { id: templateId });
+    const templateVersion = templateData.approvalTemplateVersions.find((version) => version.id === templateData.approvalTemplate.currentVersionId);
+    if (!templateVersion || templateVersion.status !== 'PUBLISHED') {
+        throw new Error('模板尚未發布，無法發起簽核。');
+    }
+    if (!templateVersion.formDefinitionVersionId) {
+        throw new Error('模板尚未綁定表單版本，無法發起簽核。');
+    }
+    const launchableApprovalTemplates = templateData.launchableApprovalTemplates ?? [templateData.approvalTemplate];
+    if (!launchableApprovalTemplates.some((template) => template.id === templateId)) {
+        throw new Error('目前登入者沒有此模板的發起權限。');
+    }
+    const formData = await (0, graphql_client_1.requestGraphQl)(`query LaunchFormVersion($id: String!) {
+      formDefinitionVersion(id: $id) {
+        id
+        schemaJson
+        uiSchemaJson
+        version
+      }
+    }`, { id: templateVersion.formDefinitionVersionId });
+    return {
+        formVersion: {
+            id: formData.formDefinitionVersion.id,
+            schema: JSON.parse(formData.formDefinitionVersion.schemaJson),
+            uiSchema: JSON.parse(formData.formDefinitionVersion.uiSchemaJson),
+            version: formData.formDefinitionVersion.version,
+        },
+        template: templateData.approvalTemplate,
+        templateVersion,
+    };
+}
+async function listLaunchableTemplates() {
+    const templateData = await (0, graphql_client_1.requestGraphQl)(`query ApprovalTemplates {
+      launchableApprovalTemplates {
+        currentVersionId
+        id
+        name
+        updatedAt
+      }
+    }`);
+    const launchableApprovalTemplates = templateData.launchableApprovalTemplates ??
+        templateData.approvalTemplates ??
+        [];
+    const versionLists = await Promise.all(launchableApprovalTemplates.map((template) => (0, graphql_client_1.requestGraphQl)(`query LaunchTemplateVersions($templateId: String!) {
+          approvalTemplateVersions(templateId: $templateId) {
+            formDefinitionVersionId
+            id
+            status
+            version
+          }
+        }`, { templateId: template.id })));
+    return launchableApprovalTemplates.flatMap((template, index) => {
+        const currentVersion = versionLists[index]?.approvalTemplateVersions.find((version) => version.id === template.currentVersionId);
+        return currentVersion?.status === 'PUBLISHED' &&
+            currentVersion.formDefinitionVersionId
+            ? [
+                {
+                    currentVersionId: currentVersion.id,
+                    formDefinitionVersionId: currentVersion.formDefinitionVersionId,
+                    id: template.id,
+                    name: template.name,
+                    updatedAt: template.updatedAt,
+                    version: currentVersion.version,
+                },
+            ]
+            : [];
+    });
+}
+async function readApprovalInstance(instanceId) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`query ApprovalInstance($id: String!) {
+      approvalInstance(id: $id) {
+        completedAt
+        formDataJson
+        formDefinitionSnapshotJson
+        id
+        initiatorMemberId
+        startedAt
+        state
+        templateId
+        templateVersionId
+        title
+        workflowSnapshotJson
+      }
+      tasks(instanceId: $id) {
+        adhocDirectiveId
+        adhocOriginTaskId
+        adhocType
+        assigneeMemberId
+        assignmentType
+        candidateMemberIds
+        completedAt
+        createdAt
+        decisionPolicySnapshotJson
+        delegationChainJson
+        id
+        instanceId
+        isAdhoc
+        nodeId
+        openedAt
+        originalAssigneeMemberId
+        slaDueAt
+        status
+        tokenId
+      }
+      workflowTokens(instanceId: $id) {
+        consumedAt
+        createdAt
+        currentNodeId
+        id
+        instanceId
+        parentTokenId
+        status
+      }
+      activityLogs(instanceId: $id) {
+        actorMemberId
+        createdAt
+        eventType
+        id
+        nodeId
+        payloadJson
+        taskId
+      }
+    }`, { id: instanceId });
+    return {
+        activityLogs: data.activityLogs,
+        instance: parseInstanceJson(data.approvalInstance),
+        tasks: normalizeTaskRecords(data.tasks),
+        workflowTokens: data.workflowTokens,
+    };
+}
+async function listInboxTasks(assigneeMemberId) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`query InboxTasks($assigneeMemberId: String!) {
+      inboxTasks(assigneeMemberId: $assigneeMemberId) {
+        adhocDirectiveId
+        adhocOriginTaskId
+        adhocType
+        assigneeMemberId
+        assignmentType
+        candidateMemberIds
+        completedAt
+        createdAt
+        decisionPolicySnapshotJson
+        delegationChainJson
+        id
+        instanceId
+        isAdhoc
+        nodeId
+        openedAt
+        originalAssigneeMemberId
+        slaDueAt
+        status
+        tokenId
+      }
+    }`, { assigneeMemberId });
+    return normalizeTaskRecords(data.inboxTasks);
+}
+async function listApprovalHistoryTasks(assigneeMemberId) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`query ApprovalHistoryTasks($assigneeMemberId: String!) {
+      approvalHistoryTasks(assigneeMemberId: $assigneeMemberId) {
+        adhocDirectiveId
+        adhocOriginTaskId
+        adhocType
+        assigneeMemberId
+        assignmentType
+        candidateMemberIds
+        completedAt
+        createdAt
+        decisionPolicySnapshotJson
+        delegationChainJson
+        id
+        instanceId
+        isAdhoc
+        nodeId
+        openedAt
+        originalAssigneeMemberId
+        slaDueAt
+        status
+        tokenId
+      }
+    }`, { assigneeMemberId });
+    return normalizeTaskRecords(data.approvalHistoryTasks);
+}
+async function readWorkflowDashboardSummary({ currentMemberId, from, to, }) {
+    const [summaryData, notificationResult] = await Promise.all([
+        (0, graphql_client_1.requestGraphQl)(`query WorkflowDashboardSummary($from: DateTime, $to: DateTime) {
+        workflowDashboardSummary(from: $from, to: $to) {
+          activeInstanceCount
+          completedInstanceCount
+          overdueTaskCount
+          pendingTaskCount
+          rejectedInstanceCount
+          totalInstanceCount
+        }
+      }`, { from, to }),
+        listNotifications({
+            includeRead: true,
+            page: 1,
+            pageSize: 1,
+            recipientMemberId: currentMemberId,
+        }),
+    ]);
+    return {
+        ...summaryData.workflowDashboardSummary,
+        unreadNotificationCount: notificationResult.unreadCount,
+    };
+}
+function normalizeTaskRecords(tasks) {
+    return tasks.map((task) => ({
+        ...task,
+        adhocDirectiveId: task.adhocDirectiveId ?? null,
+        adhocOriginTaskId: task.adhocOriginTaskId ?? null,
+        adhocType: task.adhocType ?? null,
+        assignmentType: task.assignmentType ?? 'DIRECT_MEMBER',
+        candidateMemberIds: task.candidateMemberIds ?? [],
+        decisionPolicySnapshotJson: task.decisionPolicySnapshotJson ?? JSON.stringify({ type: 'SINGLE' }),
+        isAdhoc: task.isAdhoc ?? false,
+    }));
+}
+async function listTaskDecisions(taskId) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`query TaskDecisions($taskId: String!) {
+      taskDecisions(taskId: $taskId) {
+        action
+        comment
+        decidedAt
+        decidedByMemberId
+        id
+        returnToNodeId
+        signatureId
+        taskId
+        transferToMemberId
+      }
+    }`, { taskId });
+    return data.taskDecisions;
+}
+async function listAttachments(instanceId) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`query InstanceAttachments($instanceId: String!) {
+      attachments(instanceId: $instanceId) {
+        checksumSha256
+        createdAt
+        filename
+        formFieldPath
+        id
+        instanceId
+        mimeType
+        sizeBytes
+        storageKey
+        storageProvider
+        taskId
+        uploaderMemberId
+      }
+    }`, { instanceId });
+    return data.attachments ?? [];
+}
+async function uploadAttachment({ file, formFieldPath, }) {
+    const contentBase64 = await readFileBase64(file);
+    const checksumSha256 = await hashFileSha256(file);
+    const data = await (0, graphql_client_1.requestGraphQl)(`mutation UploadAttachment($input: UploadAttachmentInput!) {
+      uploadAttachment(input: $input) {
+        checksumSha256
+        createdAt
+        filename
+        formFieldPath
+        id
+        instanceId
+        mimeType
+        sizeBytes
+        storageKey
+        storageProvider
+        taskId
+        uploaderMemberId
+      }
+    }`, {
+        input: {
+            checksumSha256,
+            contentBase64,
+            filename: file.name,
+            formFieldPath,
+            instanceId: null,
+            mimeType: file.type || 'application/octet-stream',
+            sizeBytes: file.size,
+            taskId: null,
+        },
+    });
+    return data.uploadAttachment;
+}
+async function readAttachmentDownloadUrl({ id, }) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`query AttachmentDownloadUrl($id: String!) {
+      attachmentDownloadUrl(id: $id)
+    }`, { id });
+    return data.attachmentDownloadUrl;
+}
+async function readAttachmentPreviewUrl({ id, }) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`query AttachmentPreviewUrl($id: String!) {
+      attachmentPreviewUrl(id: $id)
+    }`, { id });
+    return data.attachmentPreviewUrl;
+}
+async function readInstanceSignatures(instanceId) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`query InstanceSignatures($instanceId: String!) {
+      signatures(instanceId: $instanceId) {
+        algorithm
+        id
+        instanceId
+        keyVersion
+        previousSignatureHash
+        signature
+        signedAt
+        signedPayloadHash
+        signedPayloadJson
+        signerMemberId
+        taskId
+        timestampTokenBase64
+      }
+      verifySignatureChain(instanceId: $instanceId) {
+        checkedCount
+        errors
+        instanceId
+        valid
+      }
+    }`, { instanceId });
+    return {
+        signatures: data.signatures ?? [],
+        verification: data.verifySignatureChain ?? {
+            checkedCount: 0,
+            errors: [],
+            instanceId,
+            valid: true,
+        },
+    };
+}
+async function resolveMemberProfiles(memberIds) {
+    if (memberIds.length === 0) {
+        return [];
+    }
+    const data = await (0, graphql_client_1.requestGraphQl)(`query InstanceMembers($memberIds: [String!]!) {
+      members(memberIds: $memberIds) {
+        email
+        memberId
+        name
+      }
+    }`, { memberIds });
+    return data.members;
+}
+async function searchMembers(searchText) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`query SearchMembers($searchText: String!) {
+      searchMembers(searchText: $searchText) {
+        email
+        memberId
+        name
+      }
+    }`, { searchText });
+    return data.searchMembers;
+}
+async function listMemberDirectoryPage({ page, pageSize, searchText = '', }) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`query MemberDirectoryPage($page: Int, $pageSize: Int, $searchText: String!) {
+      searchMembers(page: $page, pageSize: $pageSize, searchText: $searchText) {
+        email
+        memberId
+        name
+      }
+      memberCount(searchText: $searchText)
+    }`, { page, pageSize, searchText });
+    return {
+        members: data.searchMembers,
+        totalCount: data.memberCount,
+    };
+}
+async function listDelegationRules({ includeInactive = true, principalMemberId = null, } = {}) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`query DelegationRules($includeInactive: Boolean, $principalMemberId: String) {
+      delegationRules(
+        includeInactive: $includeInactive
+        principalMemberId: $principalMemberId
+      ) {
+        agentMemberId
+        createdAt
+        createdByMemberId
+        endAt
+        id
+        principalMemberId
+        priority
+        requiresConfirmation
+        revokedAt
+        revokedByMemberId
+        scopeConditionCel
+        scopeTemplateIds
+        scopeType
+        startAt
+        status
+        updatedAt
+      }
+    }`, { includeInactive, principalMemberId });
+    return data.delegationRules;
+}
+async function listDelegationRulesPage({ agentMemberId = null, includeInactive = true, page = 1, pageSize = 10, principalMemberId = null, scopeType = null, status = null, } = {}) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`query DelegationRulesPage(
+      $includeInactive: Boolean
+      $page: Int
+      $pageSize: Int
+      $principalMemberId: String
+      $agentMemberId: String
+      $scopeType: DelegationScopeType
+      $status: DelegationRuleStatus
+    ) {
+      delegationRules(
+        agentMemberId: $agentMemberId
+        includeInactive: $includeInactive
+        page: $page
+        pageSize: $pageSize
+        principalMemberId: $principalMemberId
+        scopeType: $scopeType
+        status: $status
+      ) {
+        agentMemberId
+        createdAt
+        createdByMemberId
+        endAt
+        id
+        principalMemberId
+        priority
+        requiresConfirmation
+        revokedAt
+        revokedByMemberId
+        scopeConditionCel
+        scopeTemplateIds
+        scopeType
+        startAt
+        status
+        updatedAt
+      }
+      delegationRuleCount(
+        agentMemberId: $agentMemberId
+        includeInactive: $includeInactive
+        principalMemberId: $principalMemberId
+        scopeType: $scopeType
+        status: $status
+      )
+    }`, {
+        agentMemberId,
+        includeInactive,
+        page,
+        pageSize,
+        principalMemberId,
+        scopeType,
+        status,
+    });
+    return {
+        rules: data.delegationRules,
+        totalCount: data.delegationRuleCount,
+    };
+}
+async function createDelegationRule(input) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`mutation CreateDelegationRule($input: CreateDelegationRuleInput!) {
+      createDelegationRule(input: $input) {
+        agentMemberId
+        createdAt
+        createdByMemberId
+        endAt
+        id
+        principalMemberId
+        priority
+        requiresConfirmation
+        revokedAt
+        revokedByMemberId
+        scopeConditionCel
+        scopeTemplateIds
+        scopeType
+        startAt
+        status
+        updatedAt
+      }
+    }`, { input });
+    return data.createDelegationRule;
+}
+async function revokeDelegationRule({ id, revokedByMemberId, }) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`mutation RevokeDelegationRule($id: String!, $revokedByMemberId: String) {
+      revokeDelegationRule(id: $id, revokedByMemberId: $revokedByMemberId) {
+        agentMemberId
+        createdAt
+        createdByMemberId
+        endAt
+        id
+        principalMemberId
+        priority
+        requiresConfirmation
+        revokedAt
+        revokedByMemberId
+        scopeConditionCel
+        scopeTemplateIds
+        scopeType
+        startAt
+        status
+        updatedAt
+      }
+    }`, { id, revokedByMemberId });
+    return data.revokeDelegationRule;
+}
+async function listNotifications({ includeRead = true, page = 1, pageSize = 10, recipientMemberId, }) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`query Notifications(
+      $recipientMemberId: String!
+      $includeRead: Boolean
+      $page: Int
+      $pageSize: Int
+    ) {
+      notifications(
+        includeRead: $includeRead
+        page: $page
+        pageSize: $pageSize
+        recipientMemberId: $recipientMemberId
+      ) {
+        actionable
+        attemptCount
+        body
+        channel
+        createdAt
+        deliveredAt
+        deliveryError
+        deliveryTarget
+        id
+        instanceId
+        lastAttemptAt
+        nextRetryAt
+        payloadJson
+        readAt
+        recipientMemberId
+        resolution
+        resolvedAt
+        sentAt
+        status
+        taskId
+        title
+        type
+      }
+      notificationCount(
+        includeRead: $includeRead
+        recipientMemberId: $recipientMemberId
+      )
+      unreadNotificationCount(recipientMemberId: $recipientMemberId)
+    }`, { includeRead, page, pageSize, recipientMemberId });
+    return {
+        notifications: data.notifications,
+        totalCount: data.notificationCount,
+        unreadCount: data.unreadNotificationCount,
+    };
+}
+async function readUnreadNotificationCount(recipientMemberId) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`query UnreadNotificationCount($recipientMemberId: String!) {
+      unreadNotificationCount(recipientMemberId: $recipientMemberId)
+    }`, { recipientMemberId });
+    return data.unreadNotificationCount;
+}
+async function markNotificationRead({ id, readerMemberId, }) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`mutation MarkNotificationRead($id: String!, $readerMemberId: String) {
+      markNotificationRead(id: $id, readerMemberId: $readerMemberId) {
+        id
+        readAt
+        status
+      }
+    }`, { id, readerMemberId });
+    return data.markNotificationRead;
+}
+async function markAllNotificationsRead({ recipientMemberId, }) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`mutation MarkAllNotificationsRead($recipientMemberId: String) {
+      markAllNotificationsRead(recipientMemberId: $recipientMemberId)
+    }`, { recipientMemberId });
+    return data.markAllNotificationsRead;
+}
+async function readNotificationPreference(memberId) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`query NotificationPreference($memberId: String!) {
+      notificationPreference(memberId: $memberId) {
+        emailDigestMode
+        emailEnabled
+        inAppEnabled
+        memberId
+        quietHoursEnd
+        quietHoursStart
+        updatedAt
+      }
+    }`, { memberId });
+    return data.notificationPreference;
+}
+async function updateNotificationPreference(input) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`mutation UpdateNotificationPreference($input: UpdateNotificationPreferenceInput!) {
+        updateNotificationPreference(input: $input) {
+          emailDigestMode
+          emailEnabled
+          inAppEnabled
+          memberId
+          quietHoursEnd
+          quietHoursStart
+          updatedAt
+        }
+      }`, { input });
+    return data.updateNotificationPreference;
+}
+async function submitApprovalInstance({ formData, initiatorMemberId, templateId, title, }) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`mutation SubmitApprovalInstance($input: SubmitApprovalInstanceInput!) {
+      submitApprovalInstance(input: $input) {
+        id
+      }
+    }`, {
+        input: {
+            formDataJson: JSON.stringify(formData),
+            initiatorMemberId,
+            initiatorMetadataSnapshotJson: null,
+            templateId,
+            title,
+        },
+    });
+    return data.submitApprovalInstance.id;
+}
+async function decideTask({ action, comment, decidedByMemberId, returnToNodeId = null, taskId, transferToMemberId = null, }) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`mutation DecideTask($input: DecideTaskInput!) {
+      decideTask(input: $input) {
+        action
+        comment
+        decidedAt
+        decidedByMemberId
+        id
+        returnToNodeId
+        signatureId
+        taskId
+        transferToMemberId
+      }
+    }`, {
+        input: {
+            action,
+            comment,
+            decidedByMemberId,
+            returnToNodeId,
+            taskId,
+            transferToMemberId,
+        },
+    });
+    return data.decideTask;
+}
+async function cancelApprovalInstance({ cancelledByMemberId, comment, instanceId, }) {
+    await (0, graphql_client_1.requestGraphQl)(`mutation CancelApprovalInstance($input: CancelApprovalInstanceInput!) {
+      cancelApprovalInstance(input: $input) {
+        id
+        state
+      }
+    }`, {
+        input: {
+            cancelledByMemberId,
+            comment,
+            instanceId,
+        },
+    });
+}
+async function resubmitApprovalInstance({ formData, initiatorMemberId, instanceId, title, }) {
+    await (0, graphql_client_1.requestGraphQl)(`mutation ResubmitApprovalInstance($input: ResubmitApprovalInstanceInput!) {
+      resubmitApprovalInstance(input: $input) {
+        id
+        state
+      }
+    }`, {
+        input: {
+            formDataJson: JSON.stringify(formData),
+            initiatorMemberId,
+            instanceId,
+            title,
+        },
+    });
+}
+const ADHOC_DIRECTIVE_FIELDS = `
+  channels
+  comment
+  consumedAt
+  createdAt
+  createdByMemberId
+  id
+  instanceId
+  onReject
+  originNodeId
+  originTaskId
+  status
+  targetKind
+  targetValueJson
+  type
+`;
+const ADHOC_TASK_FIELDS = `
+  adhocDirectiveId
+  adhocOriginTaskId
+  adhocType
+  assigneeMemberId
+  assignmentType
+  candidateMemberIds
+  completedAt
+  createdAt
+  decisionPolicySnapshotJson
+  delegationChainJson
+  id
+  instanceId
+  isAdhoc
+  nodeId
+  openedAt
+  originalAssigneeMemberId
+  slaDueAt
+  status
+  tokenId
+`;
+function buildAdhocTargetInput(target) {
+    return {
+        includeDescendants: target.includeDescendants ?? null,
+        kind: target.kind,
+        memberIds: target.memberIds ? [...target.memberIds] : null,
+        orgUnitId: target.orgUnitId ?? null,
+        positionId: target.positionId ?? null,
+        webhookHeadersJson: target.webhookHeaders
+            ? JSON.stringify(target.webhookHeaders)
+            : null,
+        webhookUrl: target.webhookUrl ?? null,
+    };
+}
+/**
+ * Ad-hoc countersign (臨時會簽): asks the given target to co-sign the NEXT
+ * stage of this instance. When the next user task is created, a parallel
+ * ad-hoc task is spawned for the target, and the flow only advances past
+ * that stage once BOTH the original task and every countersign task are
+ * approved. A countersigner's rejection rejects the whole instance.
+ *
+ * Only the current task's assignee/candidate may call this, and only on
+ * nodes whose template sets `allowAddSigner: true`. Returns the recorded
+ * directive (`PENDING` until the next user task consumes it; withdrawable
+ * via {@link cancelAdhocDirective} while pending). Never alters the
+ * workflow template.
+ */
+async function requestAdhocCountersign({ comment = null, target, taskId, }) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`mutation RequestAdhocCountersign($taskId: ID!, $target: AdhocTargetInput!, $comment: String) {
+      requestAdhocCountersign(taskId: $taskId, target: $target, comment: $comment) {
+        ${ADHOC_DIRECTIVE_FIELDS}
+      }
+    }`, { comment, target: buildAdhocTargetInput(target), taskId });
+    return data.requestAdhocCountersign;
+}
+/**
+ * Ad-hoc pre-approval (臨時加簽): immediately spawns a blocking ad-hoc task
+ * for the given target on the CURRENT stage. Even after the original
+ * approver approves, the flow stays on this stage until the pre-approver
+ * also approves. `onReject` decides what happens when the pre-approver
+ * rejects: `REJECT_INSTANCE` rejects the whole instance;
+ * `RETURN_TO_ORIGIN` hands the decision back to the original approver
+ * (re-opening their task if they had already approved).
+ *
+ * Only the current task's assignee/candidate may call this, and only on
+ * nodes whose template sets `allowAddSigner: true`. Returns the spawned
+ * ad-hoc task. Never alters the workflow template.
+ */
+async function requestAdhocPreApproval({ comment = null, onReject, target, taskId, }) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`mutation RequestAdhocPreApproval($taskId: ID!, $target: AdhocTargetInput!, $onReject: AdhocPreApprovalRejectBehavior!, $comment: String) {
+      requestAdhocPreApproval(taskId: $taskId, target: $target, onReject: $onReject, comment: $comment) {
+        ${ADHOC_TASK_FIELDS}
+      }
+    }`, {
+        comment,
+        onReject,
+        target: buildAdhocTargetInput(target),
+        taskId,
+    });
+    return data.requestAdhocPreApproval;
+}
+/**
+ * Ad-hoc stage notification (臨時階段通知): notifies the target once the
+ * CURRENT stage ends — regardless of outcome (approved, rejected, or
+ * returned). Targets may be members, a position, an org unit, or a webhook
+ * URL. `channels` defaults to in-app notification.
+ *
+ * Available to the current task's assignee/candidate on any user-task node
+ * (no `allowAddSigner` requirement). Returns the recorded directive
+ * (withdrawable via {@link cancelAdhocDirective} while pending). Never
+ * alters the workflow template.
+ */
+async function configureAdhocStageNotification({ channels = null, target, taskId, }) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`mutation ConfigureAdhocStageNotification($taskId: ID!, $input: AdhocNotificationInput!) {
+        configureAdhocStageNotification(taskId: $taskId, input: $input) {
+          ${ADHOC_DIRECTIVE_FIELDS}
+        }
+      }`, {
+        input: {
+            channels: channels ? [...channels] : null,
+            target: buildAdhocTargetInput(target),
+        },
+        taskId,
+    });
+    return data.configureAdhocStageNotification;
+}
+/**
+ * Ad-hoc completion notification (臨時完成通知): notifies the target once
+ * the WHOLE instance reaches a terminal state (`APPROVED`, `REJECTED`, or
+ * `CANCELLED`). Targets may be members, a position, an org unit, or a
+ * webhook URL. `channels` defaults to in-app notification.
+ *
+ * Available to the current task's assignee/candidate on any user-task node
+ * (no `allowAddSigner` requirement). Returns the recorded directive
+ * (withdrawable via {@link cancelAdhocDirective} while pending). Never
+ * alters the workflow template.
+ */
+async function configureAdhocCompletionNotification({ channels = null, target, taskId, }) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`mutation ConfigureAdhocCompletionNotification($taskId: ID!, $input: AdhocNotificationInput!) {
+        configureAdhocCompletionNotification(taskId: $taskId, input: $input) {
+          ${ADHOC_DIRECTIVE_FIELDS}
+        }
+      }`, {
+        input: {
+            channels: channels ? [...channels] : null,
+            target: buildAdhocTargetInput(target),
+        },
+        taskId,
+    });
+    return data.configureAdhocCompletionNotification;
+}
+/**
+ * Withdraws a still-`PENDING` ad-hoc directive (countersign / stage-notify /
+ * completion-notify) before it takes effect. Only the directive's creator
+ * may withdraw it; pre-approval directives are consumed immediately on
+ * creation and therefore cannot be withdrawn.
+ */
+async function cancelAdhocDirective(directiveId) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`mutation CancelAdhocDirective($directiveId: ID!) {
+      cancelAdhocDirective(directiveId: $directiveId) {
+        ${ADHOC_DIRECTIVE_FIELDS}
+      }
+    }`, { directiveId });
+    return data.cancelAdhocDirective;
+}
+/**
+ * Lists every ad-hoc directive recorded on one approval instance, ordered by
+ * creation time. Use the `status` field to find directives that are still
+ * pending (withdrawable) versus already consumed or cancelled.
+ */
+async function listAdhocDirectives(instanceId) {
+    const data = await (0, graphql_client_1.requestGraphQl)(`query AdhocDirectives($instanceId: String!) {
+      adhocDirectives(instanceId: $instanceId) {
+        ${ADHOC_DIRECTIVE_FIELDS}
+      }
+    }`, { instanceId });
+    // Tolerate hosts (and test mocks) whose GraphQL layer does not answer the
+    // adhocDirectives query yet.
+    return data.adhocDirectives ?? [];
+}
+function readApprovalInstanceCaseTitle(instance) {
+    return readFormDataCaseTitle({
+        fallbackTitle: instance.title || instance.id,
+        formData: instance.formData,
+        schema: instance.formDefinitionSnapshot.schema ?? null,
+        uiSchema: instance.formDefinitionSnapshot.uiSchema ?? null,
+    });
+}
+function readFormDataCaseTitle({ fallbackTitle, formData, schema, uiSchema, }) {
+    const firstField = readFirstCaseTitleField(schema, uiSchema);
+    if (!firstField) {
+        return fallbackTitle;
+    }
+    const valueLabel = readFieldValueLabel(firstField, formData[firstField.fieldKey]);
+    return valueLabel ? `${firstField.label}：${valueLabel}` : fallbackTitle;
+}
+function parseInstanceJson(record) {
+    return {
+        ...record,
+        formData: JSON.parse(record.formDataJson),
+        formDefinitionSnapshot: JSON.parse(record.formDefinitionSnapshotJson),
+        workflowSnapshot: JSON.parse(record.workflowSnapshotJson),
+    };
+}
+async function readFileBase64(file) {
+    const buffer = await file.arrayBuffer();
+    const bytes = new Uint8Array(buffer);
+    const chunkSize = 0x8000;
+    const chunks = Array.from({ length: Math.ceil(bytes.length / chunkSize) }, (_, index) => String.fromCharCode(...bytes.slice(index * chunkSize, (index + 1) * chunkSize)));
+    return btoa(chunks.join(''));
+}
+async function hashFileSha256(file) {
+    const digest = await crypto.subtle.digest('SHA-256', await file.arrayBuffer());
+    const bytes = Array.from(new Uint8Array(digest));
+    return bytes.map((byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+function readFirstCaseTitleField(schema, uiSchema) {
+    if (!schema?.fields.length) {
+        return null;
+    }
+    const fieldsByKey = new Map(schema.fields.map((field) => [field.fieldKey, field]));
+    const firstLayoutField = uiSchema?.layout
+        .map((layoutItem) => fieldsByKey.get(layoutItem.fieldKey) ?? null)
+        .find((field) => Boolean(field));
+    return firstLayoutField ?? schema.fields[0] ?? null;
+}
+function readFieldValueLabel(field, value) {
+    if (typeof value === 'undefined' || value === null) {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        return readArrayFieldValueLabel(field, value);
+    }
+    if (field.type === 'boolean') {
+        return value === true ? '是' : '否';
+    }
+    if (isSelectFieldDefinition(field) && typeof value === 'string') {
+        return readSelectOptionLabel(field, value);
+    }
+    const valueLabel = String(value).trim();
+    return valueLabel || null;
+}
+function readArrayFieldValueLabel(field, value) {
+    const labels = isSelectFieldDefinition(field)
+        ? value.map((item) => readSelectOptionLabel(field, item))
+        : value;
+    const label = labels.filter((item) => item.trim()).join('、');
+    return label || null;
+}
+function readSelectOptionLabel(field, value) {
+    return (field.options.find((option) => option.value === value)?.label ?? value).trim();
+}
+function isSelectFieldDefinition(field) {
+    return (field.type === 'select' ||
+        field.type === 'radio' ||
+        field.type === 'checkbox');
+}
+//# sourceMappingURL=workflow-api.js.map