@webiny/api-workflows 0.0.0-unstable.61c048f412

package/graphql/validation/storeWorkflow.d.ts

@@ -0,0 +1,107 @@
+import zod from "zod";
+export declare const storeWorkflowValidation: zod.ZodObject<{
+    app: zod.ZodString;
+    id: zod.ZodString;
+    data: zod.ZodObject<{
+        name: zod.ZodString;
+        steps: zod.ZodEffects<zod.ZodArray<zod.ZodObject<{
+            id: zod.ZodString;
+            title: zod.ZodString;
+            color: zod.ZodString;
+            description: zod.ZodEffects<zod.ZodOptional<zod.ZodOptional<zod.ZodNullable<zod.ZodString>>>, string | undefined, string | null | undefined>;
+            teams: zod.ZodEffects<zod.ZodArray<zod.ZodObject<{
+                id: zod.ZodString;
+            }, "strip", zod.ZodTypeAny, {
+                id: string;
+            }, {
+                id: string;
+            }>, "many">, import("@webiny/api/types.js").NonEmptyArray<import("../../domain/workflow/abstractions.js").IWorkflowStepTeam>, {
+                id: string;
+            }[]>;
+            notifications: zod.ZodEffects<zod.ZodOptional<zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
+                id: zod.ZodString;
+            }, "strip", zod.ZodTypeAny, {
+                id: string;
+            }, {
+                id: string;
+            }>, "many">>>>, {
+                id: string;
+            }[] | undefined, {
+                id: string;
+            }[] | null | undefined>;
+        }, "strip", zod.ZodTypeAny, {
+            id: string;
+            title: string;
+            color: string;
+            teams: import("@webiny/api/types.js").NonEmptyArray<import("../../domain/workflow/abstractions.js").IWorkflowStepTeam>;
+            description?: string | undefined;
+            notifications?: {
+                id: string;
+            }[] | undefined;
+        }, {
+            id: string;
+            title: string;
+            color: string;
+            teams: {
+                id: string;
+            }[];
+            description?: string | null | undefined;
+            notifications?: {
+                id: string;
+            }[] | null | undefined;
+        }>, "many">, import("@webiny/api/types.js").NonEmptyArray<import("../../domain/workflow/abstractions.js").IWorkflowStep>, {
+            id: string;
+            title: string;
+            color: string;
+            teams: {
+                id: string;
+            }[];
+            description?: string | null | undefined;
+            notifications?: {
+                id: string;
+            }[] | null | undefined;
+        }[]>;
+    }, "strip", zod.ZodTypeAny, {
+        name: string;
+        steps: import("@webiny/api/types.js").NonEmptyArray<import("../../domain/workflow/abstractions.js").IWorkflowStep>;
+    }, {
+        name: string;
+        steps: {
+            id: string;
+            title: string;
+            color: string;
+            teams: {
+                id: string;
+            }[];
+            description?: string | null | undefined;
+            notifications?: {
+                id: string;
+            }[] | null | undefined;
+        }[];
+    }>;
+}, "strip", zod.ZodTypeAny, {
+    app: string;
+    id: string;
+    data: {
+        name: string;
+        steps: import("@webiny/api/types.js").NonEmptyArray<import("../../domain/workflow/abstractions.js").IWorkflowStep>;
+    };
+}, {
+    app: string;
+    id: string;
+    data: {
+        name: string;
+        steps: {
+            id: string;
+            title: string;
+            color: string;
+            teams: {
+                id: string;
+            }[];
+            description?: string | null | undefined;
+            notifications?: {
+                id: string;
+            }[] | null | undefined;
+        }[];
+    };
+}>;

package/graphql/validation/storeWorkflow.js

@@ -0,0 +1,9 @@
+import zod from "zod";
+import { workflowValidation } from "./workflow.js";
+export const storeWorkflowValidation = zod.object({
+  app: zod.string().min(1, "App is required."),
+  id: zod.string().min(1, "ID is required."),
+  data: workflowValidation
+});
+
+//# sourceMappingURL=storeWorkflow.js.map

package/graphql/validation/storeWorkflow.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["zod","workflowValidation","storeWorkflowValidation","object","app","string","min","id","data"],"sources":["storeWorkflow.ts"],"sourcesContent":["import zod from \"zod\";\nimport { workflowValidation } from \"./workflow.js\";\n\nexport const storeWorkflowValidation = zod.object({\n    app: zod.string().min(1, \"App is required.\"),\n    id: zod.string().min(1, \"ID is required.\"),\n    data: workflowValidation\n});\n"],"mappings":"AAAA,OAAOA,GAAG,MAAM,KAAK;AACrB,SAASC,kBAAkB;AAE3B,OAAO,MAAMC,uBAAuB,GAAGF,GAAG,CAACG,MAAM,CAAC;EAC9CC,GAAG,EAAEJ,GAAG,CAACK,MAAM,CAAC,CAAC,CAACC,GAAG,CAAC,CAAC,EAAE,kBAAkB,CAAC;EAC5CC,EAAE,EAAEP,GAAG,CAACK,MAAM,CAAC,CAAC,CAACC,GAAG,CAAC,CAAC,EAAE,iBAAiB,CAAC;EAC1CE,IAAI,EAAEP;AACV,CAAC,CAAC","ignoreList":[]}

package/graphql/validation/takeOverWorkflowStateStep.d.ts

@@ -0,0 +1,8 @@
+import zod from "zod";
+export declare const takeOverWorkflowStateStepValidation: zod.ZodObject<{
+    id: zod.ZodString;
+}, "strip", zod.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;

package/graphql/validation/takeOverWorkflowStateStep.js

@@ -0,0 +1,6 @@
+import zod from "zod";
+export const takeOverWorkflowStateStepValidation = zod.object({
+  id: zod.string().min(1, "ID is required.")
+});
+
+//# sourceMappingURL=takeOverWorkflowStateStep.js.map

package/graphql/validation/takeOverWorkflowStateStep.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["zod","takeOverWorkflowStateStepValidation","object","id","string","min"],"sources":["takeOverWorkflowStateStep.ts"],"sourcesContent":["import zod from \"zod\";\n\nexport const takeOverWorkflowStateStepValidation = zod.object({\n    id: zod.string().min(1, \"ID is required.\")\n});\n"],"mappings":"AAAA,OAAOA,GAAG,MAAM,KAAK;AAErB,OAAO,MAAMC,mCAAmC,GAAGD,GAAG,CAACE,MAAM,CAAC;EAC1DC,EAAE,EAAEH,GAAG,CAACI,MAAM,CAAC,CAAC,CAACC,GAAG,CAAC,CAAC,EAAE,iBAAiB;AAC7C,CAAC,CAAC","ignoreList":[]}

package/graphql/validation/workflow.d.ts

@@ -0,0 +1,80 @@
+import zod from "zod";
+import type { NonEmptyArray } from "@webiny/api/types.js";
+import type { IWorkflowStep } from "../../domain/workflow/abstractions.js";
+export declare const workflowValidation: zod.ZodObject<{
+    name: zod.ZodString;
+    steps: zod.ZodEffects<zod.ZodArray<zod.ZodObject<{
+        id: zod.ZodString;
+        title: zod.ZodString;
+        color: zod.ZodString;
+        description: zod.ZodEffects<zod.ZodOptional<zod.ZodOptional<zod.ZodNullable<zod.ZodString>>>, string | undefined, string | null | undefined>;
+        teams: zod.ZodEffects<zod.ZodArray<zod.ZodObject<{
+            id: zod.ZodString;
+        }, "strip", zod.ZodTypeAny, {
+            id: string;
+        }, {
+            id: string;
+        }>, "many">, NonEmptyArray<import("~/domain/workflow/abstractions.js").IWorkflowStepTeam>, {
+            id: string;
+        }[]>;
+        notifications: zod.ZodEffects<zod.ZodOptional<zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
+            id: zod.ZodString;
+        }, "strip", zod.ZodTypeAny, {
+            id: string;
+        }, {
+            id: string;
+        }>, "many">>>>, {
+            id: string;
+        }[] | undefined, {
+            id: string;
+        }[] | null | undefined>;
+    }, "strip", zod.ZodTypeAny, {
+        id: string;
+        title: string;
+        color: string;
+        teams: NonEmptyArray<import("~/domain/workflow/abstractions.js").IWorkflowStepTeam>;
+        description?: string | undefined;
+        notifications?: {
+            id: string;
+        }[] | undefined;
+    }, {
+        id: string;
+        title: string;
+        color: string;
+        teams: {
+            id: string;
+        }[];
+        description?: string | null | undefined;
+        notifications?: {
+            id: string;
+        }[] | null | undefined;
+    }>, "many">, NonEmptyArray<IWorkflowStep>, {
+        id: string;
+        title: string;
+        color: string;
+        teams: {
+            id: string;
+        }[];
+        description?: string | null | undefined;
+        notifications?: {
+            id: string;
+        }[] | null | undefined;
+    }[]>;
+}, "strip", zod.ZodTypeAny, {
+    name: string;
+    steps: NonEmptyArray<IWorkflowStep>;
+}, {
+    name: string;
+    steps: {
+        id: string;
+        title: string;
+        color: string;
+        teams: {
+            id: string;
+        }[];
+        description?: string | null | undefined;
+        notifications?: {
+            id: string;
+        }[] | null | undefined;
+    }[];
+}>;

package/graphql/validation/workflow.js

@@ -0,0 +1,10 @@
+import zod from "zod";
+import { stepValidation } from "./step.js";
+export const workflowValidation = zod.object({
+  name: zod.string().min(1, "Name is required."),
+  steps: zod.array(stepValidation).min(1, "You must add at least one step.").transform(value => {
+    return value;
+  })
+});
+
+//# sourceMappingURL=workflow.js.map

package/graphql/validation/workflow.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["zod","stepValidation","workflowValidation","object","name","string","min","steps","array","transform","value"],"sources":["workflow.ts"],"sourcesContent":["import zod from \"zod\";\nimport type { NonEmptyArray } from \"@webiny/api/types.js\";\nimport { stepValidation } from \"./step.js\";\nimport type { IWorkflowStep } from \"~/domain/workflow/abstractions.js\";\n\nexport const workflowValidation = zod.object({\n    name: zod.string().min(1, \"Name is required.\"),\n    steps: zod\n        .array(stepValidation)\n        .min(1, \"You must add at least one step.\")\n        .transform(value => {\n            return value as NonEmptyArray<IWorkflowStep>;\n        })\n});\n"],"mappings":"AAAA,OAAOA,GAAG,MAAM,KAAK;AAErB,SAASC,cAAc;AAGvB,OAAO,MAAMC,kBAAkB,GAAGF,GAAG,CAACG,MAAM,CAAC;EACzCC,IAAI,EAAEJ,GAAG,CAACK,MAAM,CAAC,CAAC,CAACC,GAAG,CAAC,CAAC,EAAE,mBAAmB,CAAC;EAC9CC,KAAK,EAAEP,GAAG,CACLQ,KAAK,CAACP,cAAc,CAAC,CACrBK,GAAG,CAAC,CAAC,EAAE,iCAAiC,CAAC,CACzCG,SAAS,CAACC,KAAK,IAAI;IAChB,OAAOA,KAAK;EAChB,CAAC;AACT,CAAC,CAAC","ignoreList":[]}

package/graphql/workflowState.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLSchemaPlugin } from "@webiny/handler-graphql";
+export declare const createWorkflowStateSchema: () => GraphQLSchemaPlugin<import("@webiny/api/types.js").Context>;

package/graphql/workflowState.js

@@ -0,0 +1,398 @@
+import { GraphQLSchemaPlugin, resolve, resolveList } from "@webiny/handler-graphql";
+import { createZodError } from "@webiny/utils";
+import { listWorkflowStatesValidation } from "./validation/listWorkflowStates.js";
+import { startWorkflowStateValidation } from "./validation/startWorkflowState.js";
+import { approveWorkflowStateValidation } from "./validation/approveWorkflowState.js";
+import { rejectWorkflowStateValidation } from "./validation/rejectWorkflowState.js";
+import { cancelWorkflowStateValidation } from "./validation/cancelWorkflowState.js";
+import { createWorkflowStateValidation } from "./validation/createWorkflowState.js";
+import { getTargetWorkflowStateValidation } from "./validation/getTargetWorkflowState.js";
+import { getWorkflowStateValidation } from "./validation/getWorkflowState.js";
+import { takeOverWorkflowStateStepValidation } from "./validation/takeOverWorkflowStateStep.js";
+import { GetWorkflowStateUseCase } from "../features/workflowState/GetWorkflowState/index.js";
+import { GetTargetWorkflowStateUseCase } from "../features/workflowState/GetTargetWorkflowState/index.js";
+import { ListWorkflowStatesUseCase } from "../features/workflowState/ListWorkflowStates/index.js";
+import { ListOwnWorkflowStatesUseCase } from "../features/workflowState/ListOwnWorkflowStates/index.js";
+import { ListRequestedWorkflowStatesUseCase } from "../features/workflowState/ListRequestedWorkflowStates/index.js";
+import { CreateWorkflowStateUseCase } from "../features/workflowState/CreateWorkflowState/index.js";
+import { StartWorkflowStateStepUseCase } from "../features/workflowState/StartWorkflowStateStep/index.js";
+import { ApproveWorkflowStateStepUseCase } from "../features/workflowState/ApproveWorkflowStateStep/index.js";
+import { RejectWorkflowStateStepUseCase } from "../features/workflowState/RejectWorkflowStateStep/index.js";
+import { CancelWorkflowStateUseCase } from "../features/workflowState/CancelWorkflowState/index.js";
+import { TakeOverWorkflowStateStepUseCase } from "../features/workflowState/TakeOverWorkflowStateStep/index.js";
+import { WorkflowStateNotFoundError } from "../domain/workflowState/errors.js";
+export const createWorkflowStateSchema = () => {
+  return new GraphQLSchemaPlugin({
+    typeDefs: /* GraphQL */`
+            enum WorkflowStateStateValue {
+                pending
+                inReview
+                approved
+                rejected
+            }
+
+            type WorkflowStateIdentity {
+                id: String!
+                displayName: String
+                type: String
+            }
+
+            type WorkflowStateStepNotification {
+                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: WorkflowStateStateValue!
+                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: WorkflowStateStateValue!
+                steps: [WorkflowStateStep!]
+                createdOn: DateTime!
+                savedOn: DateTime!
+                createdBy: WorkflowStateIdentity!
+                savedBy: WorkflowStateIdentity!
+                currentStep: WorkflowStateStep!
+                nextStep: WorkflowStateStep
+                previousStep: WorkflowStateStep
+            }
+
+            type ListWorkflowStatesResponse {
+                data: [WorkflowState!]
+                error: WorkflowError
+                meta: ListWorkflowsMeta
+            }
+
+            enum ListWorkflowStatesSort {
+                createdOn_ASC
+                createdOn_DESC
+                savedOn_ASC
+                savedOn_DESC
+            }
+
+            input ListWorkflowStatesWhereStepsInput {
+                id: String
+                id_in: [String!]
+                state: WorkflowStateStateValue
+                state_in: [WorkflowStateStateValue!]
+                savedBy: String
+                savedBy_in: [String!]
+            }
+
+            input ListWorkflowStatesWhereTeamsInput {
+                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: WorkflowStateStateValue
+                state_in: [WorkflowStateStateValue!]
+                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 CancelWorkflowStateResponse {
+                data: Boolean
+                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 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 => {
+          return parent.isActive || false;
+        }
+      },
+      WorkflowsQuery: {
+        getWorkflowState: async (_, args, context) => {
+          return 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) => {
+          return 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
+            });
+            /**
+             * TODO determine if we want to throw error or return null when not found.
+             */
+            if (stateResult.isFail()) {
+              if (stateResult.error instanceof WorkflowStateNotFoundError) {
+                return null;
+              }
+              throw stateResult.error;
+            }
+            return stateResult.value;
+          });
+        },
+        listWorkflowStates: async (_, args, context) => {
+          return 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
+                }
+              }
+            });
+            if (listResult.isFail()) {
+              throw listResult.error;
+            }
+            return listResult.value;
+          });
+        },
+        listOwnWorkflowStates: async (_, args, context) => {
+          return 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;
+          });
+        },
+        listRequestedWorkflowStates: async (_, args, context) => {
+          return 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;
+          });
+        }
+      },
+      WorkflowsMutation: {
+        createWorkflowState: async (_, args, context) => {
+          return 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;
+          });
+        },
+        approveWorkflowStateStep: (_, args, context) => {
+          return 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) => {
+          return 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) => {
+          return 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) => {
+          return 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;
+          });
+        }
+      }
+    }
+  });
+};
+
+//# sourceMappingURL=workflowState.js.map