refactor: add plan module

* rename/add plan dirs
* add read plan func/data
* add call plan func/data
* add mutate plan func/data

src/PostgREST/Plan/CallPlan.hs

@@ -0,0 +1,25 @@
+module PostgREST.Plan.CallPlan
+  ( CallPlan(..)
+  , CallParams(..)
+  )
+where
+
+import qualified Data.ByteString.Lazy              as LBS
+import           PostgREST.DbStructure.Identifiers (FieldName,
+                                                    QualifiedIdentifier)
+import           PostgREST.DbStructure.Proc        (ProcParam (..))
+
+import Protolude
+
+data CallPlan = FunctionCall
+  { funCQi           :: QualifiedIdentifier
+  , funCParams       :: CallParams
+  , funCArgs         :: Maybe LBS.ByteString
+  , funCScalar       :: Bool
+  , funCMultipleCall :: Bool
+  , funCReturning    :: [FieldName]
+  }
+
+data CallParams
+  = KeyParams [ProcParam] -- ^ Call with key params: func(a := val1, b:= val2)
+  | OnePosParam ProcParam -- ^ Call with positional params(only one supported): func(val)

src/PostgREST/Plan/MutatePlan.hs

@@ -0,0 +1,41 @@
+module PostgREST.Plan.MutatePlan
+  ( MutatePlan(..)
+  )
+where
+
+import qualified Data.ByteString.Lazy as LBS
+import qualified Data.Set             as S
+
+import PostgREST.DbStructure.Identifiers (FieldName,
+                                          QualifiedIdentifier)
+import PostgREST.RangeQuery              (NonnegRange)
+import PostgREST.Request.Preferences     (PreferResolution)
+import PostgREST.Request.Types           (LogicTree, OrderTerm)
+
+import Protolude
+
+data MutatePlan
+  = Insert
+      { in_        :: QualifiedIdentifier
+      , insCols    :: S.Set FieldName
+      , insBody    :: Maybe LBS.ByteString
+      , onConflict :: Maybe (PreferResolution, [FieldName])
+      , where_     :: [LogicTree]
+      , returning  :: [FieldName]
+      }
+  | Update
+      { in_       :: QualifiedIdentifier
+      , updCols   :: S.Set FieldName
+      , updBody   :: Maybe LBS.ByteString
+      , where_    :: [LogicTree]
+      , mutRange  :: NonnegRange
+      , mutOrder  :: [OrderTerm]
+      , returning :: [FieldName]
+      }
+  | Delete
+      { in_       :: QualifiedIdentifier
+      , where_    :: [LogicTree]
+      , mutRange  :: NonnegRange
+      , mutOrder  :: [OrderTerm]
+      , returning :: [FieldName]
+      }

src/PostgREST/Plan/ReadPlan.hs

@@ -0,0 +1,45 @@
+{-# LANGUAGE NamedFieldPuns #-}
+module PostgREST.Plan.ReadPlan
+  ( ReadPlanTree
+  , ReadPlan(..)
+  , fstFieldNames
+  ) where
+
+import Data.Tree (Tree (..))
+
+import PostgREST.DbStructure.Identifiers  (FieldName,
+                                           QualifiedIdentifier)
+import PostgREST.DbStructure.Relationship (Relationship)
+import PostgREST.RangeQuery               (NonnegRange)
+import PostgREST.Request.Types            (Alias, Depth, Hint,
+                                           JoinCondition, JoinType,
+                                           LogicTree, NodeName,
+                                           OrderTerm, SelectItem)
+
+
+import Protolude
+
+type ReadPlanTree = Tree ReadPlan
+
+data ReadPlan = ReadPlan
+  { select         :: [SelectItem]
+  , from           :: QualifiedIdentifier
+  , fromAlias      :: Maybe Alias
+  -- ^ A table alias is used in case of self joins
+  , where_         :: [LogicTree]
+  , joinConditions :: [JoinCondition]
+  , order          :: [OrderTerm]
+  , range_         :: NonnegRange
+  , nodeName       :: NodeName
+  , nodeRel        :: Maybe Relationship
+  , nodeAlias      :: Maybe Alias
+  , nodeHint       :: Maybe Hint
+  , nodeJoinType   :: Maybe JoinType
+  , nodeDepth      :: Depth
+  }
+  deriving (Eq)
+
+-- First level FieldNames(e.g get a,b from /table?select=a,b,other(c,d))
+fstFieldNames :: ReadPlanTree -> [FieldName]
+fstFieldNames (Node ReadPlan{select} _) =
+  fst . (\(f, _, _, _, _) -> f) <$> select