@webiny/api-workflows 0.0.0-unstable.6844005670 → 0.0.0-unstable.7be00a75a9

package/graphql/validation/storeWorkflow.d.ts

@@ -4,104 +4,32 @@ export declare const storeWorkflowValidation: zod.ZodObject<{
     id: zod.ZodString;
     data: zod.ZodObject<{
         name: zod.ZodString;
-        steps: zod.ZodEffects<zod.ZodArray<zod.ZodObject<{
+        steps: zod.ZodPipe<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<{
+            description: zod.ZodPipe<zod.ZodOptional<zod.ZodOptional<zod.ZodNullable<zod.ZodString>>>, zod.ZodTransform<string | undefined, string | null | undefined>>;
+            teams: zod.ZodPipe<zod.ZodArray<zod.ZodObject<{
                 id: zod.ZodString;
-            }, "strip", zod.ZodTypeAny, {
+            }, zod.core.$strip>>, zod.ZodTransform<import("@webiny/api/types.js").NonEmptyArray<import("../../domain/workflow/abstractions.js").IWorkflowStepTeam>, {
                 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<{
+            }[]>>;
+            notifications: zod.ZodPipe<zod.ZodOptional<zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                 id: zod.ZodString;
-            }, "strip", zod.ZodTypeAny, {
-                id: string;
-            }, {
-                id: string;
-            }>, "many">>>>, {
+            }, zod.core.$strip>>>>>, zod.ZodTransform<{
                 id: string;
             }[] | undefined, {
                 id: string;
-            }[] | null | undefined>;
-        }, "strip", zod.ZodTypeAny, {
+            }[] | null | undefined>>;
+        }, zod.core.$strip>>, zod.ZodTransform<import("@webiny/api/types.js").NonEmptyArray<import("../../domain/workflow/abstractions.js").IWorkflowStep>, {
             id: string;
             title: string;
             color: string;
+            description: string | undefined;
             teams: import("@webiny/api/types.js").NonEmptyArray<import("../../domain/workflow/abstractions.js").IWorkflowStepTeam>;
-            description?: string | undefined;
-            notifications?: {
+            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;
-        }[];
-    };
-}>;
+        }[]>>;
+    }, zod.core.$strip>;
+}, zod.core.$strip>;

package/graphql/validation/storeWorkflow.js

@@ -1,9 +1,10 @@
 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
+const storeWorkflowValidation = zod.object({
+    app: zod.string().min(1, "App is required."),
+    id: zod.string().min(1, "ID is required."),
+    data: workflowValidation
 });
+export { storeWorkflowValidation };
 
 //# sourceMappingURL=storeWorkflow.js.map

package/graphql/validation/storeWorkflow.js.map

@@ -1 +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":[]}
+{"version":3,"file":"graphql/validation/storeWorkflow.js","sources":["../../../src/graphql/validation/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"],"names":["storeWorkflowValidation","zod","workflowValidation"],"mappings":";;AAGO,MAAMA,0BAA0BC,IAAI,MAAM,CAAC;IAC9C,KAAKA,IAAI,MAAM,GAAG,GAAG,CAAC,GAAG;IACzB,IAAIA,IAAI,MAAM,GAAG,GAAG,CAAC,GAAG;IACxB,MAAMC;AACV"}

package/graphql/validation/takeOverWorkflowStateStep.d.ts

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

package/graphql/validation/takeOverWorkflowStateStep.js

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

package/graphql/validation/takeOverWorkflowStateStep.js.map

@@ -1 +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":[]}
+{"version":3,"file":"graphql/validation/takeOverWorkflowStateStep.js","sources":["../../../src/graphql/validation/takeOverWorkflowStateStep.ts"],"sourcesContent":["import zod from \"zod\";\n\nexport const takeOverWorkflowStateStepValidation = zod.object({\n    id: zod.string().min(1, \"ID is required.\")\n});\n"],"names":["takeOverWorkflowStateStepValidation","zod"],"mappings":";AAEO,MAAMA,sCAAsCC,IAAI,MAAM,CAAC;IAC1D,IAAIA,IAAI,MAAM,GAAG,GAAG,CAAC,GAAG;AAC5B"}

package/graphql/validation/workflow.d.ts

@@ -3,78 +3,31 @@ 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<{
+    steps: zod.ZodPipe<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<{
+        description: zod.ZodPipe<zod.ZodOptional<zod.ZodOptional<zod.ZodNullable<zod.ZodString>>>, zod.ZodTransform<string | undefined, string | null | undefined>>;
+        teams: zod.ZodPipe<zod.ZodArray<zod.ZodObject<{
             id: zod.ZodString;
-        }, "strip", zod.ZodTypeAny, {
+        }, zod.core.$strip>>, zod.ZodTransform<NonEmptyArray<import("~/domain/workflow/abstractions.js").IWorkflowStepTeam>, {
             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<{
+        }[]>>;
+        notifications: zod.ZodPipe<zod.ZodOptional<zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
             id: zod.ZodString;
-        }, "strip", zod.ZodTypeAny, {
-            id: string;
-        }, {
-            id: string;
-        }>, "many">>>>, {
+        }, zod.core.$strip>>>>>, zod.ZodTransform<{
             id: string;
         }[] | undefined, {
             id: string;
-        }[] | null | undefined>;
-    }, "strip", zod.ZodTypeAny, {
+        }[] | null | undefined>>;
+    }, zod.core.$strip>>, zod.ZodTransform<NonEmptyArray<IWorkflowStep>, {
         id: string;
         title: string;
         color: string;
+        description: string | undefined;
         teams: NonEmptyArray<import("~/domain/workflow/abstractions.js").IWorkflowStepTeam>;
-        description?: string | undefined;
-        notifications?: {
+        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;
-    }[];
-}>;
+    }[]>>;
+}, zod.core.$strip>;

package/graphql/validation/workflow.js

@@ -1,10 +1,9 @@
 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;
-  })
+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)=>value)
 });
+export { workflowValidation };
 
 //# sourceMappingURL=workflow.js.map

package/graphql/validation/workflow.js.map

@@ -1 +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":[]}
+{"version":3,"file":"graphql/validation/workflow.js","sources":["../../../src/graphql/validation/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"],"names":["workflowValidation","zod","stepValidation","value"],"mappings":";;AAKO,MAAMA,qBAAqBC,IAAI,MAAM,CAAC;IACzC,MAAMA,IAAI,MAAM,GAAG,GAAG,CAAC,GAAG;IAC1B,OAAOA,IAAAA,KACG,CAACC,gBACN,GAAG,CAAC,GAAG,mCACP,SAAS,CAACC,CAAAA,QACAA;AAEnB"}

package/graphql/workflowState.js

@@ -21,9 +21,8 @@ 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";
-export const createWorkflowStateSchema = () => {
-  return new GraphQLSchemaPlugin({
-    typeDefs: /* GraphQL */`
+const createWorkflowStateSchema = ()=>new GraphQLSchemaPlugin({
+        typeDefs: `
             enum CmsEntryStateValue {
                 pending
                 inReview
@@ -222,206 +221,137 @@ export const createWorkflowStateSchema = () => {
                 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;
+        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
+                                }
+                            }
+                        });
+                        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;
+                    }),
+                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;
+                    })
+            },
+            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;
+                    });
+                },
+                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;
+                    })
             }
-            return takeOverResult.value;
-          });
         }
-      }
-    }
-  });
-};
+    });
+export { createWorkflowStateSchema };
 
 //# sourceMappingURL=workflowState.js.map