GraphQL error handling.

src/Squidex.Domain.Apps.Entities/Contents/ContentGrain.cs

@@ -118,7 +118,7 @@ namespace Squidex.Domain.Apps.Entities.Contents
                 case PatchContent patchContent:
                     return UpdateReturnAsync(patchContent, async c =>
                     {
-                        var isProposal = c.AsDraft && Snapshot.Status == Status.Published;
+                        var isProposal = IsProposal(c);
 
                         await GuardContent.CanPatch(Snapshot, contentWorkflow, c, isProposal);
 
@@ -130,7 +130,7 @@ namespace Squidex.Domain.Apps.Entities.Contents
                     {
                         try
                         {
-                            var isChangeConfirm = Snapshot.IsPending && Snapshot.Status == Status.Published && c.Status == Status.Published;
+                            var isChangeConfirm = IsConfirm(c);
 
                             var ctx = await CreateContext(Snapshot.AppId.Id, Snapshot.SchemaId.Id, c, () => "Failed to change content.");
 
@@ -148,31 +148,18 @@ namespace Squidex.Domain.Apps.Entities.Contents
                                 }
                                 else
                                 {
-                                    StatusChange reason;
+                                    var change = GetChange(c);
-
-                                    if (c.Status == Status.Published)
-                                    {
-                                        reason = StatusChange.Published;
-                                    }
-                                    else if (Snapshot.Status == Status.Published)
-                                    {
-                                        reason = StatusChange.Unpublished;
-                                    }
-                                    else
-                                    {
-                                        reason = StatusChange.Change;
-                                    }
 
                                     await ctx.ExecuteScriptAsync(s => s.Change,
                                         new ScriptContext
                                         {
-                                            Operation = reason.ToString(),
+                                            Operation = change.ToString(),
                                             Data = Snapshot.Data,
                                             Status = c.Status,
                                             StatusOld = Snapshot.Status
                                         });
 
-                                    ChangeStatus(c, reason);
+                                    ChangeStatus(c, change);
                                 }
                             }
                         }
@@ -335,6 +322,32 @@ namespace Squidex.Domain.Apps.Entities.Contents
             RaiseEvent(Envelope.Create(@event));
         }
 
+        private bool IsConfirm(ChangeContentStatus command)
+        {
+            return Snapshot.IsPending && Snapshot.Status == Status.Published && command.Status == Status.Published;
+        }
+
+        private bool IsProposal(PatchContent command)
+        {
+            return Snapshot.Status == Status.Published && command.AsDraft;
+        }
+
+        private StatusChange GetChange(ChangeContentStatus command)
+        {
+            var change = StatusChange.Change;
+
+            if (command.Status == Status.Published)
+            {
+                change = StatusChange.Published;
+            }
+            else if (Snapshot.Status == Status.Published)
+            {
+                change = StatusChange.Unpublished;
+            }
+
+            return change;
+        }
+
         private void VerifyNotDeleted()
         {
             if (Snapshot.IsDeleted)

src/Squidex.Domain.Apps.Entities/Contents/GraphQL/GraphQLExecutionContext.cs

@@ -45,10 +45,9 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
         {
             var loader = resolver.Resolve<DataLoaderDocumentListener>();
 
-            var logger = LoggingMiddleware.Create(resolver.Resolve<ISemanticLog>());
-
             execution.Listeners.Add(loader);
-            execution.FieldMiddleware.Use(logger);
+            execution.FieldMiddleware.Use(Middlewares.Logging(resolver.Resolve<ISemanticLog>()));
+            execution.FieldMiddleware.Use(Middlewares.Errors());
 
             execution.UserContext = this;
         }

src/Squidex.Domain.Apps.Entities/Contents/GraphQL/LoggingMiddleware.cs → src/Squidex.Domain.Apps.Entities/Contents/GraphQL/Middlewares.cs

@@ -6,15 +6,16 @@
 // ==========================================================================
 
 using System;
+using GraphQL;
 using GraphQL.Instrumentation;
 using Squidex.Infrastructure;
 using Squidex.Infrastructure.Log;
 
 namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
 {
-    public static class LoggingMiddleware
+    public static class Middlewares
     {
-        public static Func<FieldMiddlewareDelegate, FieldMiddlewareDelegate> Create(ISemanticLog log)
+        public static Func<FieldMiddlewareDelegate, FieldMiddlewareDelegate> Logging(ISemanticLog log)
         {
             Guard.NotNull(log, nameof(log));
 
@@ -38,5 +39,23 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
                 };
             });
         }
+
+        public static Func<FieldMiddlewareDelegate, FieldMiddlewareDelegate> Errors()
+        {
+            return new Func<FieldMiddlewareDelegate, FieldMiddlewareDelegate>(next =>
+            {
+                return async context =>
+                {
+                    try
+                    {
+                        return await next(context);
+                    }
+                    catch (DomainException ex)
+                    {
+                        throw new ExecutionError(ex.Message);
+                    }
+                };
+            });
+        }
     }
 }