@webiny/api-workflows 6.4.5 → 6.6.0-alpha.0

package/graphql/workflowState.js

@@ -1,4 +1,4 @@
-import { GraphQLSchemaPlugin, resolve, resolveList } from "@webiny/handler-graphql";
+import { resolve, resolveList } from "@webiny/api-graphql";
 import { createZodError } from "@webiny/utils";
 import { listWorkflowStatesValidation } from "./validation/listWorkflowStates.js";
 import { startWorkflowStateValidation } from "./validation/startWorkflowState.js";
@@ -21,337 +21,409 @@ import { RejectWorkflowStateStepUseCase } from "../features/workflowState/Reject
 import { CancelWorkflowStateUseCase } from "../features/workflowState/CancelWorkflowState/index.js";
 import { TakeOverWorkflowStateStepUseCase } from "../features/workflowState/TakeOverWorkflowStateStep/index.js";
 import { WorkflowStateNotFoundError } from "../domain/workflowState/errors.js";
-const createWorkflowStateSchema = ()=>new GraphQLSchemaPlugin({
-        typeDefs: `
-            enum CmsEntryStateValue {
-                pending
-                inReview
-                approved
-                rejected
-            }
+const addWorkflowStateSchema = (builder)=>{
+    builder.addTypeDefs(`
+        enum CmsEntryStateValue {
+            pending
+            inReview
+            approved
+            rejected
+        }
 
-            type CmsEntrySystemWorkflow {
-                workflowId: String
-                stepId: ID
-                stepName: String
-                state: CmsEntryStateValue
-            }
+        type CmsEntrySystemWorkflow {
+            workflowId: String
+            stepId: ID
+            stepName: String
+            state: CmsEntryStateValue
+        }
 
-            extend type CmsEntrySystem {
-                workflow: CmsEntrySystemWorkflow
-            }
+        extend type CmsEntrySystem {
+            workflow: CmsEntrySystemWorkflow
+        }
 
-            input ListWhereInputCmsEntrySystemWorkflowStateInput {
-                workflowId: String
-                stepId: ID
-                stepName: String
-                state: CmsEntryStateValue
-            }
+        input ListWhereInputCmsEntrySystemWorkflowStateInput {
+            workflowId: String
+            stepId: ID
+            stepName: String
+            state: CmsEntryStateValue
+        }
 
-            input ListWhereInputCmsEntrySystemWorkflowInput {
-                workflowId: String
-                stepId: ID
-                state: ListWhereInputCmsEntrySystemWorkflowStateInput
-                stepName: String
-            }
+        input ListWhereInputCmsEntrySystemWorkflowInput {
+            workflowId: String
+            stepId: ID
+            state: ListWhereInputCmsEntrySystemWorkflowStateInput
+            stepName: String
+        }
 
-            extend input ListWhereInputCmsEntrySystem {
-                workflow: ListWhereInputCmsEntrySystemWorkflowInput
-            }
+        extend input ListWhereInputCmsEntrySystem {
+            workflow: ListWhereInputCmsEntrySystemWorkflowInput
+        }
 
-            type WorkflowStateIdentity {
-                id: String!
-                displayName: String
-                type: String
-            }
+        type WorkflowStateIdentity {
+            id: String!
+            displayName: String
+            type: String
+        }
 
-            type WorkflowStateStepNotification {
-                id: String!
-            }
+        type WorkflowStateStepNotification {
+            id: String!
+        }
 
-            type WorkflowStateStepTeam {
-                id: String!
-            }
+        type WorkflowStateStepTeam {
+            id: String!
+        }
 
-            type WorkflowStateStep {
-                # workflow related
-                id: String!
-                title: String!
-                color: String!
-                description: String
-                teams: [WorkflowStateStepTeam!]!
-                notifications: [WorkflowStateStepNotification!]
-                # state related
-                state: CmsEntryStateValue!
-                comment: String
-                savedBy: WorkflowStateIdentity
-                # current user can take action on this step?
-                canReview: Boolean!
-                # is current user an owner of the step?
-                isOwner: Boolean!
-                # can current user take over this step?
-                canTakeOver: Boolean!
-            }
+        type WorkflowStateStep {
+            # workflow related
+            id: String!
+            title: String!
+            color: String!
+            description: String
+            teams: [WorkflowStateStepTeam!]!
+            notifications: [WorkflowStateStepNotification!]
+            # state related
+            state: CmsEntryStateValue!
+            comment: String
+            savedBy: WorkflowStateIdentity
+            # current user can take action on this step?
+            canReview: Boolean!
+            # is current user an owner of the step?
+            isOwner: Boolean!
+            # can current user take over this step?
+            canTakeOver: Boolean!
+        }
 
-            type WorkflowState {
-                id: String!
-                app: String!
-                title: String!
-                isActive: Boolean!
-                done: Boolean!
-                workflowId: String!
-                targetId: String!
-                targetRevisionId: String!
-                comment: String
-                state: CmsEntryStateValue!
-                steps: [WorkflowStateStep!]
-                createdOn: DateTime!
-                savedOn: DateTime!
-                createdBy: WorkflowStateIdentity!
-                savedBy: WorkflowStateIdentity!
-                currentStep: WorkflowStateStep!
-                nextStep: WorkflowStateStep
-                previousStep: WorkflowStateStep
-            }
+        type WorkflowState {
+            id: String!
+            app: String!
+            title: String!
+            isActive: Boolean!
+            done: Boolean!
+            workflowId: String!
+            targetId: String!
+            targetRevisionId: String!
+            comment: String
+            state: CmsEntryStateValue!
+            steps: [WorkflowStateStep!]
+            createdOn: DateTime!
+            savedOn: DateTime!
+            createdBy: WorkflowStateIdentity!
+            savedBy: WorkflowStateIdentity!
+            currentStep: WorkflowStateStep!
+            nextStep: WorkflowStateStep
+            previousStep: WorkflowStateStep
+            targetContext: JSON
+        }
 
-            type ListWorkflowStatesResponse {
-                data: [WorkflowState!]
-                error: WorkflowError
-                meta: ListWorkflowsMeta
-            }
+        type ListWorkflowStatesResponse {
+            data: [WorkflowState!]
+            error: WorkflowError
+            meta: ListWorkflowsMeta
+        }
 
-            enum ListWorkflowStatesSort {
-                createdOn_ASC
-                createdOn_DESC
-                savedOn_ASC
-                savedOn_DESC
-            }
+        enum ListWorkflowStatesSort {
+            createdOn_ASC
+            createdOn_DESC
+            savedOn_ASC
+            savedOn_DESC
+        }
 
-            input ListWorkflowStatesWhereStepsInput {
-                id: String
-                id_in: [String!]
-                state: CmsEntryStateValue
-                state_in: [CmsEntryStateValue!]
-                savedBy: String
-                savedBy_in: [String!]
-            }
+        input ListWorkflowStatesWhereStepsInput {
+            id: String
+            id_in: [String!]
+            state: CmsEntryStateValue
+            state_in: [CmsEntryStateValue!]
+            savedBy: String
+            savedBy_in: [String!]
+        }
 
-            input ListWorkflowStatesWhereTeamsInput {
-                id: String
-                id_in: [String!]
-            }
+        input ListWorkflowStatesWhereTeamsInput {
+            id: String
+            id_in: [String!]
+        }
 
-            input ListWorkflowStatesWhereNotificationsInput {
-                id: String
-                id_in: [String!]
-            }
+        input ListWorkflowStatesWhereNotificationsInput {
+            id: String
+            id_in: [String!]
+        }
 
-            input ListWorkflowStatesWhereInput {
-                app: String
-                app_in: [String!]
-                workflowId: String
-                workflowId_in: [String!]
-                targetId: String
-                targetId_in: [String!]
-                targetRevisionId: String
-                targetRevisionId_in: [String!]
-                state: CmsEntryStateValue
-                state_in: [CmsEntryStateValue!]
-                createdOn_gte: DateTime
-                createdOn_lte: DateTime
-                savedOn_gte: DateTime
-                savedOn_lte: DateTime
-                createdBy: String
-                savedBy: String
-                isActive: Boolean
-                steps: ListWorkflowStatesWhereStepsInput
-                teams: ListWorkflowStatesWhereTeamsInput
-                notifications: ListWorkflowStatesWhereNotificationsInput
-            }
+        input ListWorkflowStatesWhereInput {
+            app: String
+            app_in: [String!]
+            workflowId: String
+            workflowId_in: [String!]
+            targetId: String
+            targetId_in: [String!]
+            targetRevisionId: String
+            targetRevisionId_in: [String!]
+            state: CmsEntryStateValue
+            state_in: [CmsEntryStateValue!]
+            createdOn_gte: DateTime
+            createdOn_lte: DateTime
+            savedOn_gte: DateTime
+            savedOn_lte: DateTime
+            createdBy: String
+            savedBy: String
+            isActive: Boolean
+            steps: ListWorkflowStatesWhereStepsInput
+            teams: ListWorkflowStatesWhereTeamsInput
+            notifications: ListWorkflowStatesWhereNotificationsInput
+        }
 
-            type WorkflowStateResponse {
-                data: WorkflowState
-                error: WorkflowError
-            }
+        type WorkflowStateResponse {
+            data: WorkflowState
+            error: WorkflowError
+        }
 
-            type CancelWorkflowStateResponse {
-                data: Boolean
-                error: WorkflowError
-            }
+        type CancelWorkflowStateResponse {
+            data: Boolean
+            error: WorkflowError
+        }
 
-            type TakeOverWorkflowStateStepResponse {
-                data: WorkflowState
-                error: WorkflowError
-            }
+        type TakeOverWorkflowStateStepResponse {
+            data: WorkflowState
+            error: WorkflowError
+        }
 
-            extend type WorkflowsQuery {
-                getWorkflowState(id: ID!): WorkflowStateResponse!
-                # always returns active workflow state for the given targetRevisionId - or null
-                getTargetWorkflowState(app: String!, targetRevisionId: ID!): WorkflowStateResponse!
-                listWorkflowStates(
-                    where: ListWorkflowStatesWhereInput
-                    sort: [ListWorkflowStatesSort!]
-                    limit: Int
-                    after: String
-                ): ListWorkflowStatesResponse!
-                listOwnWorkflowStates(
-                    where: ListWorkflowStatesWhereInput
-                    sort: [ListWorkflowStatesSort!]
-                    limit: Int
-                    after: String
-                ): ListWorkflowStatesResponse!
-                listRequestedWorkflowStates(
-                    where: ListWorkflowStatesWhereInput
-                    sort: [ListWorkflowStatesSort!]
-                    limit: Int
-                    after: String
-                ): ListWorkflowStatesResponse!
-            }
+        extend type WorkflowsQuery {
+            getWorkflowState(id: ID!): WorkflowStateResponse!
+            # always returns active workflow state for the given targetRevisionId - or null
+            getTargetWorkflowState(app: String!, targetRevisionId: ID!): WorkflowStateResponse!
+            listWorkflowStates(
+                where: ListWorkflowStatesWhereInput
+                sort: [ListWorkflowStatesSort!]
+                limit: Int
+                after: String
+            ): ListWorkflowStatesResponse!
+            listOwnWorkflowStates(
+                where: ListWorkflowStatesWhereInput
+                sort: [ListWorkflowStatesSort!]
+                limit: Int
+                after: String
+            ): ListWorkflowStatesResponse!
+            listRequestedWorkflowStates(
+                where: ListWorkflowStatesWhereInput
+                sort: [ListWorkflowStatesSort!]
+                limit: Int
+                after: String
+            ): ListWorkflowStatesResponse!
+        }
 
-            extend type WorkflowsMutation {
-                createWorkflowState(
-                    app: String!
-                    targetRevisionId: ID!
-                    title: String!
-                ): WorkflowStateResponse!
-                startWorkflowStateStep(id: ID!): WorkflowStateResponse!
-                approveWorkflowStateStep(id: ID!, comment: String): WorkflowStateResponse!
-                rejectWorkflowStateStep(id: ID!, comment: String!): WorkflowStateResponse!
-                cancelWorkflowState(id: ID!): CancelWorkflowStateResponse!
-                takeOverWorkflowStateStep(id: ID!): TakeOverWorkflowStateStepResponse!
-            }
-        `,
-        resolvers: {
-            WorkflowState: {
-                isActive: (parent)=>parent.isActive || false
-            },
-            WorkflowsQuery: {
-                getWorkflowState: async (_, args, context)=>resolve(async ()=>{
-                        const result = await getWorkflowStateValidation.safeParseAsync(args);
-                        if (!result.success) throw createZodError(result.error);
-                        const getWorkflowState = context.container.resolve(GetWorkflowStateUseCase);
-                        const stateResult = await getWorkflowState.execute(result.data.id);
-                        if (stateResult.isFail()) throw stateResult.error;
-                        return stateResult.value;
-                    }),
-                getTargetWorkflowState: async (_, args, context)=>resolve(async ()=>{
-                        const result = await getTargetWorkflowStateValidation.safeParseAsync(args);
-                        if (!result.success) throw createZodError(result.error);
-                        const getTargetWorkflowState = context.container.resolve(GetTargetWorkflowStateUseCase);
-                        const stateResult = await getTargetWorkflowState.execute({
-                            app: result.data.app,
-                            targetRevisionId: result.data.targetRevisionId
-                        });
-                        if (stateResult.isFail()) {
-                            if (stateResult.error instanceof WorkflowStateNotFoundError) return null;
-                            throw stateResult.error;
-                        }
-                        return stateResult.value;
-                    }),
-                listWorkflowStates: async (_, args, context)=>resolveList(async ()=>{
-                        const result = await listWorkflowStatesValidation.safeParseAsync(args);
-                        if (!result.success) throw createZodError(result.error);
-                        const listWorkflowStates = context.container.resolve(ListWorkflowStatesUseCase);
-                        const listResult = await listWorkflowStates.execute({
-                            ...result.data,
-                            where: {
-                                values: {
-                                    ...result.data?.where
-                                }
+        extend type WorkflowsMutation {
+            createWorkflowState(
+                app: String!
+                targetRevisionId: ID!
+                title: String!
+            ): WorkflowStateResponse!
+            startWorkflowStateStep(id: ID!): WorkflowStateResponse!
+            approveWorkflowStateStep(id: ID!, comment: String): WorkflowStateResponse!
+            rejectWorkflowStateStep(id: ID!, comment: String!): WorkflowStateResponse!
+            cancelWorkflowState(id: ID!): CancelWorkflowStateResponse!
+            takeOverWorkflowStateStep(id: ID!): TakeOverWorkflowStateStepResponse!
+        }
+    `);
+    builder.addResolver({
+        path: "WorkflowState.isActive",
+        dependencies: [],
+        resolver: ()=>({ parent })=>parent.isActive || false
+    });
+    builder.addResolver({
+        path: "WorkflowsQuery.getWorkflowState",
+        dependencies: [
+            GetWorkflowStateUseCase
+        ],
+        resolver (getWorkflowState) {
+            return ({ args })=>resolve(async ()=>{
+                    const result = await getWorkflowStateValidation.safeParseAsync(args);
+                    if (!result.success) throw createZodError(result.error);
+                    const stateResult = await getWorkflowState.execute(result.data.id);
+                    if (stateResult.isFail()) throw stateResult.error;
+                    return stateResult.value;
+                });
+        }
+    });
+    builder.addResolver({
+        path: "WorkflowsQuery.getTargetWorkflowState",
+        dependencies: [
+            GetTargetWorkflowStateUseCase
+        ],
+        resolver (getTargetWorkflowState) {
+            return ({ args })=>resolve(async ()=>{
+                    const result = await getTargetWorkflowStateValidation.safeParseAsync(args);
+                    if (!result.success) throw createZodError(result.error);
+                    const stateResult = await getTargetWorkflowState.execute({
+                        app: result.data.app,
+                        targetRevisionId: result.data.targetRevisionId
+                    });
+                    if (stateResult.isFail()) {
+                        if (stateResult.error instanceof WorkflowStateNotFoundError) return null;
+                        throw stateResult.error;
+                    }
+                    return stateResult.value;
+                });
+        }
+    });
+    builder.addResolver({
+        path: "WorkflowsQuery.listWorkflowStates",
+        dependencies: [
+            ListWorkflowStatesUseCase
+        ],
+        resolver (listWorkflowStates) {
+            return ({ args })=>resolveList(async ()=>{
+                    const result = await listWorkflowStatesValidation.safeParseAsync(args);
+                    if (!result.success) throw createZodError(result.error);
+                    const listResult = await listWorkflowStates.execute({
+                        ...result.data,
+                        where: {
+                            values: {
+                                ...result.data?.where
                             }
-                        });
-                        if (listResult.isFail()) throw listResult.error;
-                        return listResult.value;
-                    }),
-                listOwnWorkflowStates: async (_, args, context)=>resolveList(async ()=>{
-                        const result = await listWorkflowStatesValidation.safeParseAsync(args);
-                        if (!result.success) throw createZodError(result.error);
-                        const listOwnWorkflowStates = context.container.resolve(ListOwnWorkflowStatesUseCase);
-                        const listResult = await listOwnWorkflowStates.execute({
-                            ...result.data,
-                            where: {
-                                values: {
-                                    ...result.data?.where
-                                }
+                        }
+                    });
+                    if (listResult.isFail()) throw listResult.error;
+                    return listResult.value;
+                });
+        }
+    });
+    builder.addResolver({
+        path: "WorkflowsQuery.listOwnWorkflowStates",
+        dependencies: [
+            ListOwnWorkflowStatesUseCase
+        ],
+        resolver (listOwnWorkflowStates) {
+            return ({ args })=>resolveList(async ()=>{
+                    const result = await listWorkflowStatesValidation.safeParseAsync(args);
+                    if (!result.success) throw createZodError(result.error);
+                    const listResult = await listOwnWorkflowStates.execute({
+                        ...result.data,
+                        where: {
+                            values: {
+                                ...result.data?.where
                             }
-                        });
-                        if (listResult.isFail()) throw listResult.error;
-                        return listResult.value;
-                    }),
-                listRequestedWorkflowStates: async (_, args, context)=>resolveList(async ()=>{
-                        const result = await listWorkflowStatesValidation.safeParseAsync(args);
-                        if (!result.success) throw createZodError(result.error);
-                        const listRequestedWorkflowStates = context.container.resolve(ListRequestedWorkflowStatesUseCase);
-                        const listResult = await listRequestedWorkflowStates.execute({
-                            ...result.data,
-                            where: {
-                                values: {
-                                    ...result.data?.where
-                                }
+                        }
+                    });
+                    if (listResult.isFail()) throw listResult.error;
+                    return listResult.value;
+                });
+        }
+    });
+    builder.addResolver({
+        path: "WorkflowsQuery.listRequestedWorkflowStates",
+        dependencies: [
+            ListRequestedWorkflowStatesUseCase
+        ],
+        resolver (listRequestedWorkflowStates) {
+            return ({ args })=>resolveList(async ()=>{
+                    const result = await listWorkflowStatesValidation.safeParseAsync(args);
+                    if (!result.success) throw createZodError(result.error);
+                    const listResult = await listRequestedWorkflowStates.execute({
+                        ...result.data,
+                        where: {
+                            values: {
+                                ...result.data?.where
                             }
-                        });
-                        if (listResult.isFail()) throw listResult.error;
-                        return listResult.value;
-                    })
-            },
-            WorkflowsMutation: {
-                createWorkflowState: async (_, args, context)=>resolve(async ()=>{
-                        const result = await createWorkflowStateValidation.safeParseAsync(args);
-                        if (!result.success) throw createZodError(result.error);
-                        const createWorkflowState = context.container.resolve(CreateWorkflowStateUseCase);
-                        const createResult = await createWorkflowState.execute({
-                            app: result.data.app,
-                            targetRevisionId: result.data.targetRevisionId,
-                            title: result.data.title
-                        });
-                        if (createResult.isFail()) throw createResult.error;
-                        return createResult.value;
-                    }),
-                startWorkflowStateStep (_, args, context) {
-                    return resolve(async ()=>{
-                        const result = await startWorkflowStateValidation.safeParseAsync(args);
-                        if (!result.success) throw createZodError(result.error);
-                        const startWorkflowStateStep = context.container.resolve(StartWorkflowStateStepUseCase);
-                        const startResult = await startWorkflowStateStep.execute(result.data.id);
-                        if (startResult.isFail()) throw startResult.error;
-                        return startResult.value;
+                        }
+                    });
+                    if (listResult.isFail()) throw listResult.error;
+                    return listResult.value;
+                });
+        }
+    });
+    builder.addResolver({
+        path: "WorkflowsMutation.createWorkflowState",
+        dependencies: [
+            CreateWorkflowStateUseCase
+        ],
+        resolver (createWorkflowState) {
+            return ({ args })=>resolve(async ()=>{
+                    const result = await createWorkflowStateValidation.safeParseAsync(args);
+                    if (!result.success) throw createZodError(result.error);
+                    const createResult = await createWorkflowState.execute({
+                        app: result.data.app,
+                        targetRevisionId: result.data.targetRevisionId,
+                        title: result.data.title
                     });
-                },
-                approveWorkflowStateStep: (_, args, context)=>resolve(async ()=>{
-                        const result = await approveWorkflowStateValidation.safeParseAsync(args);
-                        if (!result.success) throw createZodError(result.error);
-                        const approveWorkflowStateStep = context.container.resolve(ApproveWorkflowStateStepUseCase);
-                        const approveResult = await approveWorkflowStateStep.execute(result.data.id, result.data.comment);
-                        if (approveResult.isFail()) throw approveResult.error;
-                        return approveResult.value;
-                    }),
-                rejectWorkflowStateStep: (_, args, context)=>resolve(async ()=>{
-                        const result = await rejectWorkflowStateValidation.safeParseAsync(args);
-                        if (!result.success) throw createZodError(result.error);
-                        const rejectWorkflowStateStep = context.container.resolve(RejectWorkflowStateStepUseCase);
-                        const rejectResult = await rejectWorkflowStateStep.execute(result.data.id, result.data.comment);
-                        if (rejectResult.isFail()) throw rejectResult.error;
-                        return rejectResult.value;
-                    }),
-                cancelWorkflowState: (_, args, context)=>resolve(async ()=>{
-                        const result = await cancelWorkflowStateValidation.safeParseAsync(args);
-                        if (!result.success) throw createZodError(result.error);
-                        const cancelWorkflowState = context.container.resolve(CancelWorkflowStateUseCase);
-                        const cancelResult = await cancelWorkflowState.execute(result.data.id);
-                        if (cancelResult.isFail()) throw cancelResult.error;
-                        return true;
-                    }),
-                takeOverWorkflowStateStep: (_, args, context)=>resolve(async ()=>{
-                        const result = await takeOverWorkflowStateStepValidation.safeParseAsync(args);
-                        if (!result.success) throw createZodError(result.error);
-                        const takeOverWorkflowStateStep = context.container.resolve(TakeOverWorkflowStateStepUseCase);
-                        const takeOverResult = await takeOverWorkflowStateStep.execute(result.data.id);
-                        if (takeOverResult.isFail()) throw takeOverResult.error;
-                        return takeOverResult.value;
-                    })
-            }
+                    if (createResult.isFail()) throw createResult.error;
+                    return createResult.value;
+                });
+        }
+    });
+    builder.addResolver({
+        path: "WorkflowsMutation.startWorkflowStateStep",
+        dependencies: [
+            StartWorkflowStateStepUseCase
+        ],
+        resolver (startWorkflowStateStep) {
+            return ({ args })=>resolve(async ()=>{
+                    const result = await startWorkflowStateValidation.safeParseAsync(args);
+                    if (!result.success) throw createZodError(result.error);
+                    const startResult = await startWorkflowStateStep.execute(result.data.id);
+                    if (startResult.isFail()) throw startResult.error;
+                    return startResult.value;
+                });
+        }
+    });
+    builder.addResolver({
+        path: "WorkflowsMutation.approveWorkflowStateStep",
+        dependencies: [
+            ApproveWorkflowStateStepUseCase
+        ],
+        resolver (approveWorkflowStateStep) {
+            return ({ args })=>resolve(async ()=>{
+                    const result = await approveWorkflowStateValidation.safeParseAsync(args);
+                    if (!result.success) throw createZodError(result.error);
+                    const approveResult = await approveWorkflowStateStep.execute(result.data.id, result.data.comment);
+                    if (approveResult.isFail()) throw approveResult.error;
+                    return approveResult.value;
+                });
+        }
+    });
+    builder.addResolver({
+        path: "WorkflowsMutation.rejectWorkflowStateStep",
+        dependencies: [
+            RejectWorkflowStateStepUseCase
+        ],
+        resolver (rejectWorkflowStateStep) {
+            return ({ args })=>resolve(async ()=>{
+                    const result = await rejectWorkflowStateValidation.safeParseAsync(args);
+                    if (!result.success) throw createZodError(result.error);
+                    const rejectResult = await rejectWorkflowStateStep.execute(result.data.id, result.data.comment);
+                    if (rejectResult.isFail()) throw rejectResult.error;
+                    return rejectResult.value;
+                });
+        }
+    });
+    builder.addResolver({
+        path: "WorkflowsMutation.cancelWorkflowState",
+        dependencies: [
+            CancelWorkflowStateUseCase
+        ],
+        resolver (cancelWorkflowState) {
+            return ({ args })=>resolve(async ()=>{
+                    const result = await cancelWorkflowStateValidation.safeParseAsync(args);
+                    if (!result.success) throw createZodError(result.error);
+                    const cancelResult = await cancelWorkflowState.execute(result.data.id);
+                    if (cancelResult.isFail()) throw cancelResult.error;
+                    return true;
+                });
+        }
+    });
+    builder.addResolver({
+        path: "WorkflowsMutation.takeOverWorkflowStateStep",
+        dependencies: [
+            TakeOverWorkflowStateStepUseCase
+        ],
+        resolver (takeOverWorkflowStateStep) {
+            return ({ args })=>resolve(async ()=>{
+                    const result = await takeOverWorkflowStateStepValidation.safeParseAsync(args);
+                    if (!result.success) throw createZodError(result.error);
+                    const takeOverResult = await takeOverWorkflowStateStep.execute(result.data.id);
+                    if (takeOverResult.isFail()) throw takeOverResult.error;
+                    return takeOverResult.value;
+                });
         }
     });
-export { createWorkflowStateSchema };
+};
+export { addWorkflowStateSchema };
 
 //# sourceMappingURL=workflowState.js.map