Add NodeParentDoesNotExist constructor to NodeLookupFailed

src/Gargantext/API/Errors.hs

@@ -113,6 +113,8 @@ nodeErrorToFrontendError ne = case ne of
     -> case reason of
          NodeDoesNotExist nid
            -> mkFrontendErrShow $ FE_node_lookup_failed_not_found nid
+         NodeParentDoesNotExist nid
+           -> mkFrontendErrShow $ FE_node_lookup_failed_parent_not_found nid
          UserDoesNotExist uid
            -> mkFrontendErrShow $ FE_node_lookup_failed_user_not_found uid
          UserNameDoesNotExist uname

src/Gargantext/API/Errors/Types.hs

@@ -192,6 +192,10 @@ newtype instance ToFrontendErrorData 'EC_404__node_lookup_failed_not_found =
   FE_node_lookup_failed_not_found { nenf_node_id :: NodeId }
   deriving (Show, Eq, Generic)
 
+newtype instance ToFrontendErrorData 'EC_404__node_lookup_failed_parent_not_found =
+  FE_node_lookup_failed_parent_not_found { nepnf_node_id :: NodeId }
+  deriving (Show, Eq, Generic)
+
 newtype instance ToFrontendErrorData 'EC_404__node_lookup_failed_user_not_found =
   FE_node_lookup_failed_user_not_found { nenf_user_id :: UserId }
   deriving (Show, Eq, Generic)
@@ -352,6 +356,14 @@ instance FromJSON (ToFrontendErrorData 'EC_404__node_lookup_failed_not_found) wh
     nenf_node_id <- o .: "node_id"
     pure FE_node_lookup_failed_not_found{..}
 
+instance ToJSON (ToFrontendErrorData 'EC_404__node_lookup_failed_parent_not_found) where
+  toJSON (FE_node_lookup_failed_parent_not_found nodeId) = object [ "node_id" .= toJSON nodeId ]
+
+instance FromJSON (ToFrontendErrorData 'EC_404__node_lookup_failed_parent_not_found) where
+  parseJSON = withObject "FE_node_lookup_failed_parent_not_found" $ \o -> do
+    nepnf_node_id <- o .: "node_id"
+    pure FE_node_lookup_failed_parent_not_found{..}
+
 instance ToJSON (ToFrontendErrorData 'EC_404__node_lookup_failed_user_not_found) where
   toJSON (FE_node_lookup_failed_user_not_found userId) = object [ "user_id" .= toJSON userId ]
 
@@ -581,6 +593,9 @@ genFrontendErr be = do
     EC_404__node_lookup_failed_not_found
       -> do nodeId <- arbitrary
             pure $ mkFrontendErr' txt (FE_node_lookup_failed_not_found nodeId)
+    EC_404__node_lookup_failed_parent_not_found
+      -> do nodeId <- arbitrary
+            pure $ mkFrontendErr' txt (FE_node_lookup_failed_parent_not_found nodeId)
     EC_404__node_lookup_failed_user_not_found
       -> do userId <- arbitrary
             pure $ mkFrontendErr' txt (FE_node_lookup_failed_user_not_found userId)
@@ -693,6 +708,9 @@ instance FromJSON FrontendError where
       EC_404__node_lookup_failed_not_found -> do
         (fe_data :: ToFrontendErrorData 'EC_404__node_lookup_failed_not_found) <- o .: "data"
         pure FrontendError{..}
+      EC_404__node_lookup_failed_parent_not_found -> do
+        (fe_data :: ToFrontendErrorData 'EC_404__node_lookup_failed_parent_not_found) <- o .: "data"
+        pure FrontendError{..}
       EC_404__node_lookup_failed_user_not_found -> do
         (fe_data :: ToFrontendErrorData 'EC_404__node_lookup_failed_user_not_found) <- o .: "data"
         pure FrontendError{..}

src/Gargantext/API/Errors/Types/Backend.hs

@@ -19,6 +19,7 @@ data BackendErrorCode
     EC_404__node_list_not_found
   | EC_404__node_root_not_found
   | EC_404__node_lookup_failed_not_found
+  | EC_404__node_lookup_failed_parent_not_found
   | EC_400__node_lookup_failed_user_too_many_roots
   | EC_404__node_lookup_failed_user_not_found
   | EC_404__node_lookup_failed_username_not_found

src/Gargantext/Database/Query/Table/Node/Error.hs

@@ -9,7 +9,22 @@ Stability   : experimental
 Portability : POSIX
 -}
 
-module Gargantext.Database.Query.Table.Node.Error where
+module Gargantext.Database.Query.Table.Node.Error (
+  -- * Types
+    NodeError(..)
+  , NodeCreationError(..)
+  , NodeLookupError(..)
+
+  -- * Classes
+  , HasNodeError(..)
+
+  -- * Functions
+  , errorWith
+  , nodeError
+  , nodeCreationError
+  , nodeLookupError
+  , catchNodeError
+  ) where
 
 import Control.Lens (Prism', (#), (^?))
 import Data.Aeson
@@ -37,13 +52,15 @@ renderNodeCreationFailed = \case
 
 data NodeLookupError
   = NodeDoesNotExist     NodeId
+  | NodeParentDoesNotExist NodeId
   | UserDoesNotExist     UserId
   | UserNameDoesNotExist Username
   | UserHasTooManyRoots UserId [NodeId]
 
 renderNodeLookupFailed :: NodeLookupError -> T.Text
 renderNodeLookupFailed = \case
-  NodeDoesNotExist nid -> "node with id " <> T.pack (show nid) <> " couldn't be found."
+  NodeDoesNotExist nid   -> "node with id " <> T.pack (show nid) <> " couldn't be found."
+  NodeParentDoesNotExist nid -> "no parent for node with id " <> T.pack (show nid) <> "."
   UserDoesNotExist uid -> "user with id " <> T.pack (show uid) <> " couldn't be found."
   UserNameDoesNotExist uname -> "user with username '" <> uname <> " couldn't be found."
   UserHasTooManyRoots uid roots -> "user with id " <> T.pack (show uid) <> " has too many roots: [" <> T.intercalate "," (map (T.pack . show) roots)
@@ -97,5 +114,15 @@ nodeError :: ( MonadError e m
           => NodeError -> m a
 nodeError ne = throwError $ _NodeError # ne
 
+nodeCreationError :: ( MonadError e m, HasNodeError e)
+                  => NodeCreationError
+                  -> m a
+nodeCreationError ne = throwError $ _NodeError # NodeCreationFailed ne
+
+nodeLookupError :: ( MonadError e m, HasNodeError e)
+                => NodeLookupError
+                -> m a
+nodeLookupError ne = throwError $ _NodeError # NodeLookupFailed ne
+
 catchNodeError :: (MonadError e m, HasNodeError e) => m a -> (NodeError -> m a) -> m a
 catchNodeError f g = catchError f (\e -> maybe (throwError e) g (e ^? _NodeError))