@kuflow/kuflow-temporal-activity-kuflow
Version:
KuFlow SDK :: Temporal activities for KuFlow.
213 lines • 10.5 kB
JavaScript
;
/**
* The MIT License
* Copyright © 2021-present KuFlow S.L.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.createKuFlowActivities = void 0;
const kuflow_activities_failure_1 = require("./kuflow-activities-failure");
const validations_1 = require("./validations");
/**
* KuFlow activities to be used in Temporal.
*/
const createKuFlowActivities = (kuFlowRestClient) => {
return {
KuFlow_Engine_retrievePrincipal: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_retrievePrincipal),
KuFlow_Engine_retrieveTenantUser: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_retrieveTenantUser),
KuFlow_Engine_findProcesses: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_findProcesses),
KuFlow_Engine_retrieveProcess: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_retrieveProcess),
KuFlow_Engine_updateProcessEntity: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_updateProcessEntity),
KuFlow_Engine_patchProcessEntity: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_patchProcessEntity),
KuFlow_Engine_updateProcessMetadata: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_updateProcessMetadata),
KuFlow_Engine_patchProcessMetadata: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_patchProcessMetadata),
KuFlow_Engine_changeProcessInitiator: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_changeProcessInitiator),
KuFlow_Engine_findProcessItems: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_findProcessItems),
KuFlow_Engine_retrieveProcessItem: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_retrieveProcessItem),
KuFlow_Engine_createProcessItem: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_createProcessItem),
KuFlow_Engine_completeProcessItemTask: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_completeProcessItemTask),
KuFlow_Engine_claimProcessItemTask: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_claimProcessItemTask),
KuFlow_Engine_assignProcessItemTask: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_assignProcessItemTask),
KuFlow_Engine_updateProcessItemTaskData: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_updateProcessItemTaskData),
KuFlow_Engine_patchProcessItemTaskData: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_patchProcessItemTaskData),
KuFlow_Engine_appendProcessItemTaskLog: (0, kuflow_activities_failure_1.catchAllErrors)(KuFlow_Engine_appendProcessItemTaskLog),
};
async function KuFlow_Engine_retrievePrincipal(request) {
(0, validations_1.validateRetrievePrincipalRequest)(request);
const principal = await kuFlowRestClient.principalOperations.retrievePrincipal(request.principalId);
return {
principal,
};
}
async function KuFlow_Engine_retrieveTenantUser(request) {
(0, validations_1.validateRetrieveTenantUserRequest)(request);
const tenantUser = await kuFlowRestClient.tenantUserOperations.retrieveTenantUser(request.tenantUserId);
return {
tenantUser,
};
}
async function KuFlow_Engine_findProcesses(request) {
const processes = await kuFlowRestClient.processOperations.findProcesses({
...request,
});
return {
processes,
};
}
async function KuFlow_Engine_retrieveProcess(request) {
(0, validations_1.validateRetrieveProcessRequest)(request);
const process = await kuFlowRestClient.processOperations.retrieveProcess(request.processId);
return {
process,
};
}
async function KuFlow_Engine_updateProcessEntity(request) {
(0, validations_1.validateProcessEntityUpdateRequest)(request);
const process = await kuFlowRestClient.processOperations.updateProcessEntity(request.processId, {
entity: request.entity,
});
return {
process,
};
}
async function KuFlow_Engine_patchProcessEntity(request) {
(0, validations_1.validateProcessEntityPatchRequest)(request);
const process = await kuFlowRestClient.processOperations.patchProcessEntity(request.processId, request.jsonPatch);
return {
process,
};
}
async function KuFlow_Engine_updateProcessMetadata(request) {
(0, validations_1.validateProcessMetadataUpdateRequest)(request);
const process = await kuFlowRestClient.processOperations.updateProcessMetadata(request.processId, {
metadata: request.metadata,
});
return {
process,
};
}
async function KuFlow_Engine_patchProcessMetadata(request) {
(0, validations_1.validateProcessMetadataPatchRequest)(request);
const process = await kuFlowRestClient.processOperations.patchProcessMetadata(request.processId, request.jsonPatch);
return {
process,
};
}
async function KuFlow_Engine_changeProcessInitiator(request) {
(0, validations_1.validateProcessInitiatorChangeRequest)(request);
const process = await kuFlowRestClient.processOperations.changeProcessInitiator(request.processId, {
initiatorId: request.initiatorId,
initiatorEmail: request.initiatorEmail,
});
return {
process,
};
}
async function KuFlow_Engine_findProcessItems(request) {
const options = {
page: request.page,
size: request.size,
sort: request.sorts,
processId: request.processIds,
type: request.types,
taskState: request.taskStates,
processItemDefinitionCode: request.processItemDefinitionCodes,
};
const processItems = await kuFlowRestClient.processItemOperations.findProcessItems(options);
return {
processItems,
};
}
async function KuFlow_Engine_retrieveProcessItem(request) {
(0, validations_1.validateProcessItemRetrieveRequest)(request);
const processItem = await kuFlowRestClient.processItemOperations.retrieveProcessItem(request.processItemId);
return {
processItem,
};
}
async function KuFlow_Engine_createProcessItem(request) {
(0, validations_1.validateProcessItemCreateRequest)(request);
const processItem = await kuFlowRestClient.processItemOperations.createProcessItem({
id: request.id,
type: request.type,
processId: request.processId,
ownerId: request.ownerId,
ownerEmail: request.ownerEmail,
processItemDefinitionCode: request.processItemDefinitionCode,
task: request.task,
message: request.message,
});
return {
processItem,
};
}
async function KuFlow_Engine_completeProcessItemTask(request) {
(0, validations_1.validateProcessItemTaskCompleteRequest)(request);
const processItem = await kuFlowRestClient.processItemOperations.completeProcessItemTask(request.processItemId);
return {
processItem,
};
}
async function KuFlow_Engine_claimProcessItemTask(request) {
(0, validations_1.validateProcessItemTaskClaimRequest)(request);
const processItem = await kuFlowRestClient.processItemOperations.claimProcessItemTask(request.processItemId);
return {
processItem,
};
}
async function KuFlow_Engine_assignProcessItemTask(request) {
(0, validations_1.validateProcessItemTaskAssignRequest)(request);
const processItem = await kuFlowRestClient.processItemOperations.assignProcessItemTask(request.processItemId, {
ownerEmail: request.ownerEmail,
ownerId: request.ownerId,
});
return {
processItem,
};
}
async function KuFlow_Engine_updateProcessItemTaskData(request) {
(0, validations_1.validateProcessItemTaskDataUpdateRequest)(request);
const processItem = await kuFlowRestClient.processItemOperations.updateProcessItemTaskData(request.processItemId, {
data: request.data,
});
return {
processItem,
};
}
async function KuFlow_Engine_patchProcessItemTaskData(request) {
(0, validations_1.validateProcessItemTaskDataPatchRequest)(request);
const processItem = await kuFlowRestClient.processItemOperations.patchProcessItemTaskData(request.processItemId, request.jsonPatch);
return {
processItem,
};
}
async function KuFlow_Engine_appendProcessItemTaskLog(request) {
(0, validations_1.validateProcessItemTaskLogAppendRequest)(request);
const processItem = await kuFlowRestClient.processItemOperations.appendProcessItemTaskLog(request.processItemId, {
level: request.level,
message: request.message,
});
return {
processItem,
};
}
};
exports.createKuFlowActivities = createKuFlowActivities;
//# sourceMappingURL=kuflow-activities.js.map