-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Derive a postgres client to database API specified by servant-db
--   
--   Derive a postgres client to database API specified by servant-db
@package servant-db-postgresql
@version 0.2.0.1


module Servant.DB.PostgreSQL.Default

-- | Wrapper around <a>Maybe</a> to distinguish default arguments from
--   nullable ones
newtype Default a
Default :: Maybe a -> Default a
[unDefault] :: Default a -> Maybe a
instance GHC.Generics.Generic (Servant.DB.PostgreSQL.Default.Default a)
instance GHC.Read.Read a => GHC.Read.Read (Servant.DB.PostgreSQL.Default.Default a)
instance GHC.Show.Show a => GHC.Show.Show (Servant.DB.PostgreSQL.Default.Default a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Servant.DB.PostgreSQL.Default.Default a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Servant.DB.PostgreSQL.Default.Default a)

module Servant.DB.PostgreSQL.Variadic
newtype Variadic a
Variadic :: PGArray a -> Variadic a
[unVariadic] :: Variadic a -> PGArray a
newtype PGArray a :: * -> *
PGArray :: [a] -> PGArray a
[fromPGArray] :: PGArray a -> [a]
instance GHC.Show.Show a => GHC.Show.Show (Servant.DB.PostgreSQL.Variadic.Variadic a)
instance GHC.Read.Read a => GHC.Read.Read (Servant.DB.PostgreSQL.Variadic.Variadic a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Servant.DB.PostgreSQL.Variadic.Variadic a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Servant.DB.PostgreSQL.Variadic.Variadic a)
instance GHC.Base.Functor Servant.DB.PostgreSQL.Variadic.Variadic


module Servant.DB.PostgreSQL.Context

-- | Captures special cases of stored function arguments
data Argument a

-- | Variadic argument has uncommon call syntax
ArgVariadic :: (Variadic a) -> Argument a

-- | Default keyword
ArgDefault :: (Maybe a) -> Argument a

-- | Common case
ArgSimple :: a -> Argument a

-- | Encapsulated argument that can be serialized into field or type
--   checked
--   
--   The type parameter can be <a>ToField</a> for query generation or
--   <tt>Typeable</tt> for type checking of DB signature.
data QueryArg (r :: * -> Constraint)
QueryArg :: (Argument a) -> QueryArg

-- | Catches intermediate parameters for query
data QueryContext (r :: * -> Constraint)
QueryContext :: !(Seq (Maybe Text, QueryArg r)) -> !(Maybe Text) -> !Bool -> QueryContext

-- | List of named and positional arguments
[queryArguments] :: QueryContext -> !(Seq (Maybe Text, QueryArg r))

-- | Schema name
[querySchema] :: QueryContext -> !(Maybe Text)

-- | Whether the query returns void
[queryVoid] :: QueryContext -> !Bool

-- | New empty query context
newQueryContext :: QueryContext r

-- | Add new argument to query context
addQueryArgument :: r a => Maybe Text -> Argument a -> QueryContext r -> QueryContext r

-- | Construct query that calls DB stored function
queryStoredFunction :: forall r. r ~ ToField => Text -> QueryContext r -> SqlBuilder
instance GHC.Show.Show a => GHC.Show.Show (Servant.DB.PostgreSQL.Context.Argument a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Servant.DB.PostgreSQL.Context.Argument a)
instance GHC.Generics.Generic (Servant.DB.PostgreSQL.Context.Argument a)


module Servant.DB.PostgreSQL.HasDB

-- | Derive DB client from API
deriveDB :: HasDB layout m => Proxy layout -> Proxy m -> DB layout m

-- | Derive DB client from API
class HasDB layout (m :: * -> *) where type DB layout m :: * where {
    type family DB layout m :: *;
}

-- | Derive DB client from API layout
deriveDBWithCtx :: HasDB layout m => Proxy layout -> Proxy m -> QueryContext ToField -> DB layout m
instance (Servant.DB.PostgreSQL.HasDB.HasDB api1 m, Servant.DB.PostgreSQL.HasDB.HasDB api2 m) => Servant.DB.PostgreSQL.HasDB.HasDB (api1 Servant.API.Alternative.:<|> api2) m
instance (GHC.TypeLits.KnownSymbol n, Servant.DB.PostgreSQL.HasDB.HasDB api m) => Servant.DB.PostgreSQL.HasDB.HasDB (n Servant.API.Sub.:> api) m
instance (GHC.TypeLits.KnownSymbol n, Database.PostgreSQL.Simple.ToField.ToField a, Servant.DB.PostgreSQL.HasDB.HasDB api m) => Servant.DB.PostgreSQL.HasDB.HasDB (Servant.API.DB.Argument.ArgNamed n a Servant.API.Sub.:> api) m
instance (GHC.TypeLits.KnownSymbol n, Database.PostgreSQL.Simple.ToField.ToField a, Servant.DB.PostgreSQL.HasDB.HasDB api m) => Servant.DB.PostgreSQL.HasDB.HasDB (Servant.API.DB.Argument.ArgNamed n (Servant.DB.PostgreSQL.Variadic.Variadic a) Servant.API.Sub.:> api) m
instance (GHC.TypeLits.KnownSymbol n, Database.PostgreSQL.Simple.ToField.ToField a, Servant.DB.PostgreSQL.HasDB.HasDB api m) => Servant.DB.PostgreSQL.HasDB.HasDB (Servant.API.DB.Argument.ArgNamed n (Servant.DB.PostgreSQL.Default.Default a) Servant.API.Sub.:> api) m
instance (Database.PostgreSQL.Simple.ToField.ToField a, Servant.DB.PostgreSQL.HasDB.HasDB api m) => Servant.DB.PostgreSQL.HasDB.HasDB (Servant.API.DB.Argument.ArgPos a Servant.API.Sub.:> api) m
instance (Database.PostgreSQL.Simple.ToField.ToField a, Servant.DB.PostgreSQL.HasDB.HasDB api m) => Servant.DB.PostgreSQL.HasDB.HasDB (Servant.API.DB.Argument.ArgPos (Servant.DB.PostgreSQL.Variadic.Variadic a) Servant.API.Sub.:> api) m
instance (Database.PostgreSQL.Simple.ToField.ToField a, Servant.DB.PostgreSQL.HasDB.HasDB api m) => Servant.DB.PostgreSQL.HasDB.HasDB (Servant.API.DB.Argument.ArgPos (Servant.DB.PostgreSQL.Default.Default a) Servant.API.Sub.:> api) m
instance (GHC.TypeLits.KnownSymbol n, Database.PostgreSQL.Query.Types.MonadPostgres m) => Servant.DB.PostgreSQL.HasDB.HasDB (Servant.API.DB.Procedure.Procedure n ()) m
instance (GHC.TypeLits.KnownSymbol n, Database.PostgreSQL.Simple.FromRow.FromRow a, Database.PostgreSQL.Query.Types.MonadPostgres m) => Servant.DB.PostgreSQL.HasDB.HasDB (Servant.API.DB.Procedure.Procedure n [a]) m
instance Database.PostgreSQL.Simple.FromRow.FromRow a => Database.PostgreSQL.Simple.FromRow.FromRow (GHC.Base.Maybe a)
instance (GHC.TypeLits.KnownSymbol n, Database.PostgreSQL.Simple.FromRow.FromRow a, Database.PostgreSQL.Query.Types.MonadPostgres m) => Servant.DB.PostgreSQL.HasDB.HasDB (Servant.API.DB.Procedure.Procedure n (GHC.Base.Maybe a)) m
instance (GHC.TypeLits.KnownSymbol n, Database.PostgreSQL.Simple.FromRow.FromRow a, Database.PostgreSQL.Query.Types.MonadPostgres m) => Servant.DB.PostgreSQL.HasDB.HasDB (Servant.API.DB.Procedure.Procedure n a) m


module Servant.DB.PostgreSQL.Composite

-- | Wrapper around <tt>a</tt> that indicates that the type can be used as
--   composite type.
--   
--   <pre>
--   &gt;&gt;&gt; type UserAPI = Arg "u" (Composite User) :&gt; Procedure "insertUser" ()
--   </pre>
newtype Composite a
Composite :: a -> Composite a
[unComposite] :: Composite a -> a
instance GHC.Classes.Ord a => GHC.Classes.Ord (Servant.DB.PostgreSQL.Composite.Composite a)
instance GHC.Read.Read a => GHC.Read.Read (Servant.DB.PostgreSQL.Composite.Composite a)
instance GHC.Show.Show a => GHC.Show.Show (Servant.DB.PostgreSQL.Composite.Composite a)
instance GHC.Generics.Generic (Servant.DB.PostgreSQL.Composite.Composite a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Servant.DB.PostgreSQL.Composite.Composite a)
instance Database.PostgreSQL.Simple.ToRow.ToRow a => Database.PostgreSQL.Simple.ToField.ToField (Servant.DB.PostgreSQL.Composite.Composite a)


-- | <h1>Quick start</h1>
--   
--   Automatic derive of <a>typed DB API</a> based on
--   <a>postgresql-query</a> package.
--   
--   How to use:
--   
--   <ul>
--   <li>Define your instances of <tt>MonadLogger</tt> and
--   <tt>HasPostgres</tt> for your app monad:</li>
--   </ul>
--   
--   <pre>
--   newtype PostgresM a = PostgresM { runPostgresM :: PgMonadT (LoggingT IO) a }
--    deriving (Functor, HasPostgres, MonadLogger, Monad, Applicative, MonadBase IO)
--   </pre>
--   
--   <ul>
--   <li>Define type level API:</li>
--   </ul>
--   
--   <pre>
--   type UserId = Int
--   
--   data RegisterUser = RegisterUser {
--     userRegName     :: String
--   , userRegPassword :: String
--   , userRegRegTime  :: Day
--   } deriving (Eq)
--   
--   deriveToRow ''RegisterUser
--   
--   data User = User {
--     userId       :: UserId
--   , userName     :: String
--   , userPassword :: String
--   , userRegTime  :: Day
--   } deriving (Eq)
--   
--   deriveFromRow ''User
--   deriveToRow ''User
--   
--   type UserAPI =
--          ArgNamed "u" (Composite RegisterUser)
--       :&gt; Procedure "postUser" (Only Int)
--     :&lt;|&gt; ArgPos Int
--       :&gt; Procedure "getUser" (Maybe User)
--     :&lt;|&gt; ArgPos Int
--       :&gt; Procedure "deleteUser" ()
--     :&lt;|&gt; Procedure "getUsers" [User]
--   </pre>
--   
--   <ul>
--   <li>Derive client functions from the API:</li>
--   </ul>
--   
--   <pre>
--   postUser :: Composite RegisterUser -&gt; PostgresM (Only Int)
--   getUser :: Int -&gt; PostgresM (Maybe User)
--   deleteUser :: Int -&gt; PostgresM ()
--   getUsers :: PostgresM [User]
--   (      postUser
--     :&lt;|&gt; getUser
--     :&lt;|&gt; deleteUser
--     :&lt;|&gt; getUsers) = deriveDB (Proxy :: Proxy UserAPI) (Proxy :: Proxy PostgresM)
--   </pre>
--   
--   <h1>Features</h1>
--   
--   <ul>
--   <li>Call functions in schema with <tt>:&gt;</tt> operator:</li>
--   </ul>
--   
--   <pre>
--   type API = "test" :&gt; ArgPos Int :&gt; Procedure "square" (Only Int)
--   </pre>
--   
--   That will call function `test.square(int)`.
--   
--   <ul>
--   <li>Composite types are defined with `Composite a` wrapper:</li>
--   </ul>
--   
--   <pre>
--   type API = ArgNamed "u" (Composite UserCreate) :&gt; Procedure "postUser" (Only Int)
--   </pre>
--   
--   <ul>
--   <li>Support for arrays:</li>
--   </ul>
--   
--   <pre>
--   type API = ArgPos (PGArray Int) :&gt; Procedure "mleast" (Maybe (Only Int))
--   </pre>
--   
--   <ul>
--   <li>Support for variadic arguments:</li>
--   </ul>
--   
--   <pre>
--   type API = ArgPos (Variadic Int) :&gt; Procedure "mleast" (Maybe (Only Int))
--   </pre>
--   
--   <ul>
--   <li>Support for default arguments with <tt>Default</tt> wrapper:</li>
--   </ul>
--   
--   <pre>
--   type API = ArgPos (Default Int) :&gt; Procedure "foo" (Only Int)
--   </pre>
module Servant.DB.PostgreSQL