{-# LANGUAGE OverloadedStrings, RecordWildCards, TupleSections #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE TypeFamilies #-}


{- |
= Database

-}


module CDP.Domains.Database (module CDP.Domains.Database) where

import           Control.Applicative  ((<$>))
import           Control.Monad
import           Control.Monad.Loops
import           Control.Monad.Trans  (liftIO)
import qualified Data.Map             as M
import           Data.Maybe          
import Data.Functor.Identity
import Data.String
import qualified Data.Text as T
import qualified Data.List as List
import qualified Data.Text.IO         as TI
import qualified Data.Vector          as V
import Data.Aeson.Types (Parser(..))
import           Data.Aeson           (FromJSON (..), ToJSON (..), (.:), (.:?), (.=), (.!=), (.:!))
import qualified Data.Aeson           as A
import qualified Network.HTTP.Simple as Http
import qualified Network.URI          as Uri
import qualified Network.WebSockets as WS
import Control.Concurrent
import qualified Data.ByteString.Lazy as BS
import qualified Data.Map as Map
import Data.Proxy
import System.Random
import GHC.Generics
import Data.Char
import Data.Default

import CDP.Internal.Utils




-- | Type 'Database.DatabaseId'.
--   Unique identifier of Database object.
type DatabaseDatabaseId = T.Text

-- | Type 'Database.Database'.
--   Database object.
data DatabaseDatabase = DatabaseDatabase
  {
    -- | Database ID.
    DatabaseDatabase -> DatabaseDatabaseId
databaseDatabaseId :: DatabaseDatabaseId,
    -- | Database domain.
    DatabaseDatabase -> DatabaseDatabaseId
databaseDatabaseDomain :: T.Text,
    -- | Database name.
    DatabaseDatabase -> DatabaseDatabaseId
databaseDatabaseName :: T.Text,
    -- | Database version.
    DatabaseDatabase -> DatabaseDatabaseId
databaseDatabaseVersion :: T.Text
  }
  deriving (DatabaseDatabase -> DatabaseDatabase -> Bool
(DatabaseDatabase -> DatabaseDatabase -> Bool)
-> (DatabaseDatabase -> DatabaseDatabase -> Bool)
-> Eq DatabaseDatabase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DatabaseDatabase -> DatabaseDatabase -> Bool
$c/= :: DatabaseDatabase -> DatabaseDatabase -> Bool
== :: DatabaseDatabase -> DatabaseDatabase -> Bool
$c== :: DatabaseDatabase -> DatabaseDatabase -> Bool
Eq, Int -> DatabaseDatabase -> ShowS
[DatabaseDatabase] -> ShowS
DatabaseDatabase -> String
(Int -> DatabaseDatabase -> ShowS)
-> (DatabaseDatabase -> String)
-> ([DatabaseDatabase] -> ShowS)
-> Show DatabaseDatabase
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DatabaseDatabase] -> ShowS
$cshowList :: [DatabaseDatabase] -> ShowS
show :: DatabaseDatabase -> String
$cshow :: DatabaseDatabase -> String
showsPrec :: Int -> DatabaseDatabase -> ShowS
$cshowsPrec :: Int -> DatabaseDatabase -> ShowS
Show)
instance FromJSON DatabaseDatabase where
  parseJSON :: Value -> Parser DatabaseDatabase
parseJSON = String
-> (Object -> Parser DatabaseDatabase)
-> Value
-> Parser DatabaseDatabase
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"DatabaseDatabase" ((Object -> Parser DatabaseDatabase)
 -> Value -> Parser DatabaseDatabase)
-> (Object -> Parser DatabaseDatabase)
-> Value
-> Parser DatabaseDatabase
forall a b. (a -> b) -> a -> b
$ \Object
o -> DatabaseDatabaseId
-> DatabaseDatabaseId
-> DatabaseDatabaseId
-> DatabaseDatabaseId
-> DatabaseDatabase
DatabaseDatabase
    (DatabaseDatabaseId
 -> DatabaseDatabaseId
 -> DatabaseDatabaseId
 -> DatabaseDatabaseId
 -> DatabaseDatabase)
-> Parser DatabaseDatabaseId
-> Parser
     (DatabaseDatabaseId
      -> DatabaseDatabaseId -> DatabaseDatabaseId -> DatabaseDatabase)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> DatabaseDatabaseId -> Parser DatabaseDatabaseId
forall a. FromJSON a => Object -> DatabaseDatabaseId -> Parser a
A..: DatabaseDatabaseId
"id"
    Parser
  (DatabaseDatabaseId
   -> DatabaseDatabaseId -> DatabaseDatabaseId -> DatabaseDatabase)
-> Parser DatabaseDatabaseId
-> Parser
     (DatabaseDatabaseId -> DatabaseDatabaseId -> DatabaseDatabase)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> DatabaseDatabaseId -> Parser DatabaseDatabaseId
forall a. FromJSON a => Object -> DatabaseDatabaseId -> Parser a
A..: DatabaseDatabaseId
"domain"
    Parser
  (DatabaseDatabaseId -> DatabaseDatabaseId -> DatabaseDatabase)
-> Parser DatabaseDatabaseId
-> Parser (DatabaseDatabaseId -> DatabaseDatabase)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> DatabaseDatabaseId -> Parser DatabaseDatabaseId
forall a. FromJSON a => Object -> DatabaseDatabaseId -> Parser a
A..: DatabaseDatabaseId
"name"
    Parser (DatabaseDatabaseId -> DatabaseDatabase)
-> Parser DatabaseDatabaseId -> Parser DatabaseDatabase
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> DatabaseDatabaseId -> Parser DatabaseDatabaseId
forall a. FromJSON a => Object -> DatabaseDatabaseId -> Parser a
A..: DatabaseDatabaseId
"version"
instance ToJSON DatabaseDatabase where
  toJSON :: DatabaseDatabase -> Value
toJSON DatabaseDatabase
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (DatabaseDatabaseId
"id" DatabaseDatabaseId -> DatabaseDatabaseId -> Pair
forall kv v.
(KeyValue kv, ToJSON v) =>
DatabaseDatabaseId -> v -> kv
A..=) (DatabaseDatabaseId -> Pair)
-> Maybe DatabaseDatabaseId -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DatabaseDatabaseId -> Maybe DatabaseDatabaseId
forall a. a -> Maybe a
Just (DatabaseDatabase -> DatabaseDatabaseId
databaseDatabaseId DatabaseDatabase
p),
    (DatabaseDatabaseId
"domain" DatabaseDatabaseId -> DatabaseDatabaseId -> Pair
forall kv v.
(KeyValue kv, ToJSON v) =>
DatabaseDatabaseId -> v -> kv
A..=) (DatabaseDatabaseId -> Pair)
-> Maybe DatabaseDatabaseId -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DatabaseDatabaseId -> Maybe DatabaseDatabaseId
forall a. a -> Maybe a
Just (DatabaseDatabase -> DatabaseDatabaseId
databaseDatabaseDomain DatabaseDatabase
p),
    (DatabaseDatabaseId
"name" DatabaseDatabaseId -> DatabaseDatabaseId -> Pair
forall kv v.
(KeyValue kv, ToJSON v) =>
DatabaseDatabaseId -> v -> kv
A..=) (DatabaseDatabaseId -> Pair)
-> Maybe DatabaseDatabaseId -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DatabaseDatabaseId -> Maybe DatabaseDatabaseId
forall a. a -> Maybe a
Just (DatabaseDatabase -> DatabaseDatabaseId
databaseDatabaseName DatabaseDatabase
p),
    (DatabaseDatabaseId
"version" DatabaseDatabaseId -> DatabaseDatabaseId -> Pair
forall kv v.
(KeyValue kv, ToJSON v) =>
DatabaseDatabaseId -> v -> kv
A..=) (DatabaseDatabaseId -> Pair)
-> Maybe DatabaseDatabaseId -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DatabaseDatabaseId -> Maybe DatabaseDatabaseId
forall a. a -> Maybe a
Just (DatabaseDatabase -> DatabaseDatabaseId
databaseDatabaseVersion DatabaseDatabase
p)
    ]

-- | Type 'Database.Error'.
--   Database error.
data DatabaseError = DatabaseError
  {
    -- | Error message.
    DatabaseError -> DatabaseDatabaseId
databaseErrorMessage :: T.Text,
    -- | Error code.
    DatabaseError -> Int
databaseErrorCode :: Int
  }
  deriving (DatabaseError -> DatabaseError -> Bool
(DatabaseError -> DatabaseError -> Bool)
-> (DatabaseError -> DatabaseError -> Bool) -> Eq DatabaseError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DatabaseError -> DatabaseError -> Bool
$c/= :: DatabaseError -> DatabaseError -> Bool
== :: DatabaseError -> DatabaseError -> Bool
$c== :: DatabaseError -> DatabaseError -> Bool
Eq, Int -> DatabaseError -> ShowS
[DatabaseError] -> ShowS
DatabaseError -> String
(Int -> DatabaseError -> ShowS)
-> (DatabaseError -> String)
-> ([DatabaseError] -> ShowS)
-> Show DatabaseError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DatabaseError] -> ShowS
$cshowList :: [DatabaseError] -> ShowS
show :: DatabaseError -> String
$cshow :: DatabaseError -> String
showsPrec :: Int -> DatabaseError -> ShowS
$cshowsPrec :: Int -> DatabaseError -> ShowS
Show)
instance FromJSON DatabaseError where
  parseJSON :: Value -> Parser DatabaseError
parseJSON = String
-> (Object -> Parser DatabaseError)
-> Value
-> Parser DatabaseError
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"DatabaseError" ((Object -> Parser DatabaseError) -> Value -> Parser DatabaseError)
-> (Object -> Parser DatabaseError)
-> Value
-> Parser DatabaseError
forall a b. (a -> b) -> a -> b
$ \Object
o -> DatabaseDatabaseId -> Int -> DatabaseError
DatabaseError
    (DatabaseDatabaseId -> Int -> DatabaseError)
-> Parser DatabaseDatabaseId -> Parser (Int -> DatabaseError)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> DatabaseDatabaseId -> Parser DatabaseDatabaseId
forall a. FromJSON a => Object -> DatabaseDatabaseId -> Parser a
A..: DatabaseDatabaseId
"message"
    Parser (Int -> DatabaseError) -> Parser Int -> Parser DatabaseError
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> DatabaseDatabaseId -> Parser Int
forall a. FromJSON a => Object -> DatabaseDatabaseId -> Parser a
A..: DatabaseDatabaseId
"code"
instance ToJSON DatabaseError where
  toJSON :: DatabaseError -> Value
toJSON DatabaseError
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (DatabaseDatabaseId
"message" DatabaseDatabaseId -> DatabaseDatabaseId -> Pair
forall kv v.
(KeyValue kv, ToJSON v) =>
DatabaseDatabaseId -> v -> kv
A..=) (DatabaseDatabaseId -> Pair)
-> Maybe DatabaseDatabaseId -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DatabaseDatabaseId -> Maybe DatabaseDatabaseId
forall a. a -> Maybe a
Just (DatabaseError -> DatabaseDatabaseId
databaseErrorMessage DatabaseError
p),
    (DatabaseDatabaseId
"code" DatabaseDatabaseId -> Int -> Pair
forall kv v.
(KeyValue kv, ToJSON v) =>
DatabaseDatabaseId -> v -> kv
A..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Maybe Int
forall a. a -> Maybe a
Just (DatabaseError -> Int
databaseErrorCode DatabaseError
p)
    ]

-- | Type of the 'Database.addDatabase' event.
data DatabaseAddDatabase = DatabaseAddDatabase
  {
    DatabaseAddDatabase -> DatabaseDatabase
databaseAddDatabaseDatabase :: DatabaseDatabase
  }
  deriving (DatabaseAddDatabase -> DatabaseAddDatabase -> Bool
(DatabaseAddDatabase -> DatabaseAddDatabase -> Bool)
-> (DatabaseAddDatabase -> DatabaseAddDatabase -> Bool)
-> Eq DatabaseAddDatabase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DatabaseAddDatabase -> DatabaseAddDatabase -> Bool
$c/= :: DatabaseAddDatabase -> DatabaseAddDatabase -> Bool
== :: DatabaseAddDatabase -> DatabaseAddDatabase -> Bool
$c== :: DatabaseAddDatabase -> DatabaseAddDatabase -> Bool
Eq, Int -> DatabaseAddDatabase -> ShowS
[DatabaseAddDatabase] -> ShowS
DatabaseAddDatabase -> String
(Int -> DatabaseAddDatabase -> ShowS)
-> (DatabaseAddDatabase -> String)
-> ([DatabaseAddDatabase] -> ShowS)
-> Show DatabaseAddDatabase
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DatabaseAddDatabase] -> ShowS
$cshowList :: [DatabaseAddDatabase] -> ShowS
show :: DatabaseAddDatabase -> String
$cshow :: DatabaseAddDatabase -> String
showsPrec :: Int -> DatabaseAddDatabase -> ShowS
$cshowsPrec :: Int -> DatabaseAddDatabase -> ShowS
Show)
instance FromJSON DatabaseAddDatabase where
  parseJSON :: Value -> Parser DatabaseAddDatabase
parseJSON = String
-> (Object -> Parser DatabaseAddDatabase)
-> Value
-> Parser DatabaseAddDatabase
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"DatabaseAddDatabase" ((Object -> Parser DatabaseAddDatabase)
 -> Value -> Parser DatabaseAddDatabase)
-> (Object -> Parser DatabaseAddDatabase)
-> Value
-> Parser DatabaseAddDatabase
forall a b. (a -> b) -> a -> b
$ \Object
o -> DatabaseDatabase -> DatabaseAddDatabase
DatabaseAddDatabase
    (DatabaseDatabase -> DatabaseAddDatabase)
-> Parser DatabaseDatabase -> Parser DatabaseAddDatabase
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> DatabaseDatabaseId -> Parser DatabaseDatabase
forall a. FromJSON a => Object -> DatabaseDatabaseId -> Parser a
A..: DatabaseDatabaseId
"database"
instance Event DatabaseAddDatabase where
  eventName :: Proxy DatabaseAddDatabase -> String
eventName Proxy DatabaseAddDatabase
_ = String
"Database.addDatabase"

-- | Disables database tracking, prevents database events from being sent to the client.

-- | Parameters of the 'Database.disable' command.
data PDatabaseDisable = PDatabaseDisable
  deriving (PDatabaseDisable -> PDatabaseDisable -> Bool
(PDatabaseDisable -> PDatabaseDisable -> Bool)
-> (PDatabaseDisable -> PDatabaseDisable -> Bool)
-> Eq PDatabaseDisable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PDatabaseDisable -> PDatabaseDisable -> Bool
$c/= :: PDatabaseDisable -> PDatabaseDisable -> Bool
== :: PDatabaseDisable -> PDatabaseDisable -> Bool
$c== :: PDatabaseDisable -> PDatabaseDisable -> Bool
Eq, Int -> PDatabaseDisable -> ShowS
[PDatabaseDisable] -> ShowS
PDatabaseDisable -> String
(Int -> PDatabaseDisable -> ShowS)
-> (PDatabaseDisable -> String)
-> ([PDatabaseDisable] -> ShowS)
-> Show PDatabaseDisable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PDatabaseDisable] -> ShowS
$cshowList :: [PDatabaseDisable] -> ShowS
show :: PDatabaseDisable -> String
$cshow :: PDatabaseDisable -> String
showsPrec :: Int -> PDatabaseDisable -> ShowS
$cshowsPrec :: Int -> PDatabaseDisable -> ShowS
Show)
pDatabaseDisable
  :: PDatabaseDisable
pDatabaseDisable :: PDatabaseDisable
pDatabaseDisable
  = PDatabaseDisable
PDatabaseDisable
instance ToJSON PDatabaseDisable where
  toJSON :: PDatabaseDisable -> Value
toJSON PDatabaseDisable
_ = Value
A.Null
instance Command PDatabaseDisable where
  type CommandResponse PDatabaseDisable = ()
  commandName :: Proxy PDatabaseDisable -> String
commandName Proxy PDatabaseDisable
_ = String
"Database.disable"
  fromJSON :: Proxy PDatabaseDisable
-> Value -> Result (CommandResponse PDatabaseDisable)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PDatabaseDisable -> Result ())
-> Proxy PDatabaseDisable
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PDatabaseDisable -> ())
-> Proxy PDatabaseDisable
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PDatabaseDisable -> ()
forall a b. a -> b -> a
const ()

-- | Enables database tracking, database events will now be delivered to the client.

-- | Parameters of the 'Database.enable' command.
data PDatabaseEnable = PDatabaseEnable
  deriving (PDatabaseEnable -> PDatabaseEnable -> Bool
(PDatabaseEnable -> PDatabaseEnable -> Bool)
-> (PDatabaseEnable -> PDatabaseEnable -> Bool)
-> Eq PDatabaseEnable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PDatabaseEnable -> PDatabaseEnable -> Bool
$c/= :: PDatabaseEnable -> PDatabaseEnable -> Bool
== :: PDatabaseEnable -> PDatabaseEnable -> Bool
$c== :: PDatabaseEnable -> PDatabaseEnable -> Bool
Eq, Int -> PDatabaseEnable -> ShowS
[PDatabaseEnable] -> ShowS
PDatabaseEnable -> String
(Int -> PDatabaseEnable -> ShowS)
-> (PDatabaseEnable -> String)
-> ([PDatabaseEnable] -> ShowS)
-> Show PDatabaseEnable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PDatabaseEnable] -> ShowS
$cshowList :: [PDatabaseEnable] -> ShowS
show :: PDatabaseEnable -> String
$cshow :: PDatabaseEnable -> String
showsPrec :: Int -> PDatabaseEnable -> ShowS
$cshowsPrec :: Int -> PDatabaseEnable -> ShowS
Show)
pDatabaseEnable
  :: PDatabaseEnable
pDatabaseEnable :: PDatabaseEnable
pDatabaseEnable
  = PDatabaseEnable
PDatabaseEnable
instance ToJSON PDatabaseEnable where
  toJSON :: PDatabaseEnable -> Value
toJSON PDatabaseEnable
_ = Value
A.Null
instance Command PDatabaseEnable where
  type CommandResponse PDatabaseEnable = ()
  commandName :: Proxy PDatabaseEnable -> String
commandName Proxy PDatabaseEnable
_ = String
"Database.enable"
  fromJSON :: Proxy PDatabaseEnable
-> Value -> Result (CommandResponse PDatabaseEnable)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PDatabaseEnable -> Result ())
-> Proxy PDatabaseEnable
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PDatabaseEnable -> ())
-> Proxy PDatabaseEnable
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PDatabaseEnable -> ()
forall a b. a -> b -> a
const ()


-- | Parameters of the 'Database.executeSQL' command.
data PDatabaseExecuteSQL = PDatabaseExecuteSQL
  {
    PDatabaseExecuteSQL -> DatabaseDatabaseId
pDatabaseExecuteSQLDatabaseId :: DatabaseDatabaseId,
    PDatabaseExecuteSQL -> DatabaseDatabaseId
pDatabaseExecuteSQLQuery :: T.Text
  }
  deriving (PDatabaseExecuteSQL -> PDatabaseExecuteSQL -> Bool
(PDatabaseExecuteSQL -> PDatabaseExecuteSQL -> Bool)
-> (PDatabaseExecuteSQL -> PDatabaseExecuteSQL -> Bool)
-> Eq PDatabaseExecuteSQL
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PDatabaseExecuteSQL -> PDatabaseExecuteSQL -> Bool
$c/= :: PDatabaseExecuteSQL -> PDatabaseExecuteSQL -> Bool
== :: PDatabaseExecuteSQL -> PDatabaseExecuteSQL -> Bool
$c== :: PDatabaseExecuteSQL -> PDatabaseExecuteSQL -> Bool
Eq, Int -> PDatabaseExecuteSQL -> ShowS
[PDatabaseExecuteSQL] -> ShowS
PDatabaseExecuteSQL -> String
(Int -> PDatabaseExecuteSQL -> ShowS)
-> (PDatabaseExecuteSQL -> String)
-> ([PDatabaseExecuteSQL] -> ShowS)
-> Show PDatabaseExecuteSQL
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PDatabaseExecuteSQL] -> ShowS
$cshowList :: [PDatabaseExecuteSQL] -> ShowS
show :: PDatabaseExecuteSQL -> String
$cshow :: PDatabaseExecuteSQL -> String
showsPrec :: Int -> PDatabaseExecuteSQL -> ShowS
$cshowsPrec :: Int -> PDatabaseExecuteSQL -> ShowS
Show)
pDatabaseExecuteSQL
  :: DatabaseDatabaseId
  -> T.Text
  -> PDatabaseExecuteSQL
pDatabaseExecuteSQL :: DatabaseDatabaseId -> DatabaseDatabaseId -> PDatabaseExecuteSQL
pDatabaseExecuteSQL
  DatabaseDatabaseId
arg_pDatabaseExecuteSQLDatabaseId
  DatabaseDatabaseId
arg_pDatabaseExecuteSQLQuery
  = DatabaseDatabaseId -> DatabaseDatabaseId -> PDatabaseExecuteSQL
PDatabaseExecuteSQL
    DatabaseDatabaseId
arg_pDatabaseExecuteSQLDatabaseId
    DatabaseDatabaseId
arg_pDatabaseExecuteSQLQuery
instance ToJSON PDatabaseExecuteSQL where
  toJSON :: PDatabaseExecuteSQL -> Value
toJSON PDatabaseExecuteSQL
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (DatabaseDatabaseId
"databaseId" DatabaseDatabaseId -> DatabaseDatabaseId -> Pair
forall kv v.
(KeyValue kv, ToJSON v) =>
DatabaseDatabaseId -> v -> kv
A..=) (DatabaseDatabaseId -> Pair)
-> Maybe DatabaseDatabaseId -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DatabaseDatabaseId -> Maybe DatabaseDatabaseId
forall a. a -> Maybe a
Just (PDatabaseExecuteSQL -> DatabaseDatabaseId
pDatabaseExecuteSQLDatabaseId PDatabaseExecuteSQL
p),
    (DatabaseDatabaseId
"query" DatabaseDatabaseId -> DatabaseDatabaseId -> Pair
forall kv v.
(KeyValue kv, ToJSON v) =>
DatabaseDatabaseId -> v -> kv
A..=) (DatabaseDatabaseId -> Pair)
-> Maybe DatabaseDatabaseId -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DatabaseDatabaseId -> Maybe DatabaseDatabaseId
forall a. a -> Maybe a
Just (PDatabaseExecuteSQL -> DatabaseDatabaseId
pDatabaseExecuteSQLQuery PDatabaseExecuteSQL
p)
    ]
data DatabaseExecuteSQL = DatabaseExecuteSQL
  {
    DatabaseExecuteSQL -> Maybe [DatabaseDatabaseId]
databaseExecuteSQLColumnNames :: Maybe [T.Text],
    DatabaseExecuteSQL -> Maybe [Value]
databaseExecuteSQLValues :: Maybe [A.Value],
    DatabaseExecuteSQL -> Maybe DatabaseError
databaseExecuteSQLSqlError :: Maybe DatabaseError
  }
  deriving (DatabaseExecuteSQL -> DatabaseExecuteSQL -> Bool
(DatabaseExecuteSQL -> DatabaseExecuteSQL -> Bool)
-> (DatabaseExecuteSQL -> DatabaseExecuteSQL -> Bool)
-> Eq DatabaseExecuteSQL
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DatabaseExecuteSQL -> DatabaseExecuteSQL -> Bool
$c/= :: DatabaseExecuteSQL -> DatabaseExecuteSQL -> Bool
== :: DatabaseExecuteSQL -> DatabaseExecuteSQL -> Bool
$c== :: DatabaseExecuteSQL -> DatabaseExecuteSQL -> Bool
Eq, Int -> DatabaseExecuteSQL -> ShowS
[DatabaseExecuteSQL] -> ShowS
DatabaseExecuteSQL -> String
(Int -> DatabaseExecuteSQL -> ShowS)
-> (DatabaseExecuteSQL -> String)
-> ([DatabaseExecuteSQL] -> ShowS)
-> Show DatabaseExecuteSQL
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DatabaseExecuteSQL] -> ShowS
$cshowList :: [DatabaseExecuteSQL] -> ShowS
show :: DatabaseExecuteSQL -> String
$cshow :: DatabaseExecuteSQL -> String
showsPrec :: Int -> DatabaseExecuteSQL -> ShowS
$cshowsPrec :: Int -> DatabaseExecuteSQL -> ShowS
Show)
instance FromJSON DatabaseExecuteSQL where
  parseJSON :: Value -> Parser DatabaseExecuteSQL
parseJSON = String
-> (Object -> Parser DatabaseExecuteSQL)
-> Value
-> Parser DatabaseExecuteSQL
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"DatabaseExecuteSQL" ((Object -> Parser DatabaseExecuteSQL)
 -> Value -> Parser DatabaseExecuteSQL)
-> (Object -> Parser DatabaseExecuteSQL)
-> Value
-> Parser DatabaseExecuteSQL
forall a b. (a -> b) -> a -> b
$ \Object
o -> Maybe [DatabaseDatabaseId]
-> Maybe [Value] -> Maybe DatabaseError -> DatabaseExecuteSQL
DatabaseExecuteSQL
    (Maybe [DatabaseDatabaseId]
 -> Maybe [Value] -> Maybe DatabaseError -> DatabaseExecuteSQL)
-> Parser (Maybe [DatabaseDatabaseId])
-> Parser
     (Maybe [Value] -> Maybe DatabaseError -> DatabaseExecuteSQL)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> DatabaseDatabaseId -> Parser (Maybe [DatabaseDatabaseId])
forall a.
FromJSON a =>
Object -> DatabaseDatabaseId -> Parser (Maybe a)
A..:? DatabaseDatabaseId
"columnNames"
    Parser (Maybe [Value] -> Maybe DatabaseError -> DatabaseExecuteSQL)
-> Parser (Maybe [Value])
-> Parser (Maybe DatabaseError -> DatabaseExecuteSQL)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> DatabaseDatabaseId -> Parser (Maybe [Value])
forall a.
FromJSON a =>
Object -> DatabaseDatabaseId -> Parser (Maybe a)
A..:? DatabaseDatabaseId
"values"
    Parser (Maybe DatabaseError -> DatabaseExecuteSQL)
-> Parser (Maybe DatabaseError) -> Parser DatabaseExecuteSQL
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> DatabaseDatabaseId -> Parser (Maybe DatabaseError)
forall a.
FromJSON a =>
Object -> DatabaseDatabaseId -> Parser (Maybe a)
A..:? DatabaseDatabaseId
"sqlError"
instance Command PDatabaseExecuteSQL where
  type CommandResponse PDatabaseExecuteSQL = DatabaseExecuteSQL
  commandName :: Proxy PDatabaseExecuteSQL -> String
commandName Proxy PDatabaseExecuteSQL
_ = String
"Database.executeSQL"


-- | Parameters of the 'Database.getDatabaseTableNames' command.
data PDatabaseGetDatabaseTableNames = PDatabaseGetDatabaseTableNames
  {
    PDatabaseGetDatabaseTableNames -> DatabaseDatabaseId
pDatabaseGetDatabaseTableNamesDatabaseId :: DatabaseDatabaseId
  }
  deriving (PDatabaseGetDatabaseTableNames
-> PDatabaseGetDatabaseTableNames -> Bool
(PDatabaseGetDatabaseTableNames
 -> PDatabaseGetDatabaseTableNames -> Bool)
-> (PDatabaseGetDatabaseTableNames
    -> PDatabaseGetDatabaseTableNames -> Bool)
-> Eq PDatabaseGetDatabaseTableNames
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PDatabaseGetDatabaseTableNames
-> PDatabaseGetDatabaseTableNames -> Bool
$c/= :: PDatabaseGetDatabaseTableNames
-> PDatabaseGetDatabaseTableNames -> Bool
== :: PDatabaseGetDatabaseTableNames
-> PDatabaseGetDatabaseTableNames -> Bool
$c== :: PDatabaseGetDatabaseTableNames
-> PDatabaseGetDatabaseTableNames -> Bool
Eq, Int -> PDatabaseGetDatabaseTableNames -> ShowS
[PDatabaseGetDatabaseTableNames] -> ShowS
PDatabaseGetDatabaseTableNames -> String
(Int -> PDatabaseGetDatabaseTableNames -> ShowS)
-> (PDatabaseGetDatabaseTableNames -> String)
-> ([PDatabaseGetDatabaseTableNames] -> ShowS)
-> Show PDatabaseGetDatabaseTableNames
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PDatabaseGetDatabaseTableNames] -> ShowS
$cshowList :: [PDatabaseGetDatabaseTableNames] -> ShowS
show :: PDatabaseGetDatabaseTableNames -> String
$cshow :: PDatabaseGetDatabaseTableNames -> String
showsPrec :: Int -> PDatabaseGetDatabaseTableNames -> ShowS
$cshowsPrec :: Int -> PDatabaseGetDatabaseTableNames -> ShowS
Show)
pDatabaseGetDatabaseTableNames
  :: DatabaseDatabaseId
  -> PDatabaseGetDatabaseTableNames
pDatabaseGetDatabaseTableNames :: DatabaseDatabaseId -> PDatabaseGetDatabaseTableNames
pDatabaseGetDatabaseTableNames
  DatabaseDatabaseId
arg_pDatabaseGetDatabaseTableNamesDatabaseId
  = DatabaseDatabaseId -> PDatabaseGetDatabaseTableNames
PDatabaseGetDatabaseTableNames
    DatabaseDatabaseId
arg_pDatabaseGetDatabaseTableNamesDatabaseId
instance ToJSON PDatabaseGetDatabaseTableNames where
  toJSON :: PDatabaseGetDatabaseTableNames -> Value
toJSON PDatabaseGetDatabaseTableNames
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (DatabaseDatabaseId
"databaseId" DatabaseDatabaseId -> DatabaseDatabaseId -> Pair
forall kv v.
(KeyValue kv, ToJSON v) =>
DatabaseDatabaseId -> v -> kv
A..=) (DatabaseDatabaseId -> Pair)
-> Maybe DatabaseDatabaseId -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DatabaseDatabaseId -> Maybe DatabaseDatabaseId
forall a. a -> Maybe a
Just (PDatabaseGetDatabaseTableNames -> DatabaseDatabaseId
pDatabaseGetDatabaseTableNamesDatabaseId PDatabaseGetDatabaseTableNames
p)
    ]
data DatabaseGetDatabaseTableNames = DatabaseGetDatabaseTableNames
  {
    DatabaseGetDatabaseTableNames -> [DatabaseDatabaseId]
databaseGetDatabaseTableNamesTableNames :: [T.Text]
  }
  deriving (DatabaseGetDatabaseTableNames
-> DatabaseGetDatabaseTableNames -> Bool
(DatabaseGetDatabaseTableNames
 -> DatabaseGetDatabaseTableNames -> Bool)
-> (DatabaseGetDatabaseTableNames
    -> DatabaseGetDatabaseTableNames -> Bool)
-> Eq DatabaseGetDatabaseTableNames
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DatabaseGetDatabaseTableNames
-> DatabaseGetDatabaseTableNames -> Bool
$c/= :: DatabaseGetDatabaseTableNames
-> DatabaseGetDatabaseTableNames -> Bool
== :: DatabaseGetDatabaseTableNames
-> DatabaseGetDatabaseTableNames -> Bool
$c== :: DatabaseGetDatabaseTableNames
-> DatabaseGetDatabaseTableNames -> Bool
Eq, Int -> DatabaseGetDatabaseTableNames -> ShowS
[DatabaseGetDatabaseTableNames] -> ShowS
DatabaseGetDatabaseTableNames -> String
(Int -> DatabaseGetDatabaseTableNames -> ShowS)
-> (DatabaseGetDatabaseTableNames -> String)
-> ([DatabaseGetDatabaseTableNames] -> ShowS)
-> Show DatabaseGetDatabaseTableNames
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DatabaseGetDatabaseTableNames] -> ShowS
$cshowList :: [DatabaseGetDatabaseTableNames] -> ShowS
show :: DatabaseGetDatabaseTableNames -> String
$cshow :: DatabaseGetDatabaseTableNames -> String
showsPrec :: Int -> DatabaseGetDatabaseTableNames -> ShowS
$cshowsPrec :: Int -> DatabaseGetDatabaseTableNames -> ShowS
Show)
instance FromJSON DatabaseGetDatabaseTableNames where
  parseJSON :: Value -> Parser DatabaseGetDatabaseTableNames
parseJSON = String
-> (Object -> Parser DatabaseGetDatabaseTableNames)
-> Value
-> Parser DatabaseGetDatabaseTableNames
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"DatabaseGetDatabaseTableNames" ((Object -> Parser DatabaseGetDatabaseTableNames)
 -> Value -> Parser DatabaseGetDatabaseTableNames)
-> (Object -> Parser DatabaseGetDatabaseTableNames)
-> Value
-> Parser DatabaseGetDatabaseTableNames
forall a b. (a -> b) -> a -> b
$ \Object
o -> [DatabaseDatabaseId] -> DatabaseGetDatabaseTableNames
DatabaseGetDatabaseTableNames
    ([DatabaseDatabaseId] -> DatabaseGetDatabaseTableNames)
-> Parser [DatabaseDatabaseId]
-> Parser DatabaseGetDatabaseTableNames
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> DatabaseDatabaseId -> Parser [DatabaseDatabaseId]
forall a. FromJSON a => Object -> DatabaseDatabaseId -> Parser a
A..: DatabaseDatabaseId
"tableNames"
instance Command PDatabaseGetDatabaseTableNames where
  type CommandResponse PDatabaseGetDatabaseTableNames = DatabaseGetDatabaseTableNames
  commandName :: Proxy PDatabaseGetDatabaseTableNames -> String
commandName Proxy PDatabaseGetDatabaseTableNames
_ = String
"Database.getDatabaseTableNames"