{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeOperators #-}
-- FIXME
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -ddump-splices #-}

module PersistentTestModels where

import Data.Aeson hiding (Key)

import qualified Data.List.NonEmpty as NEL
import Data.Proxy
import Data.Text (append)
import Database.Persist.Sql
import Database.Persist.TH
import Init
import PersistTestPetCollarType
import PersistTestPetType
import Test.QuickCheck

-- just need to ensure this compiles
import PersistentTestModelsImports ()

share
    [mkPersist persistSettings{mpsGeneric = True}, mkMigrate "testMigrate"]
    [persistUpperCase|

-- Dedented comment
  -- Header-level comment
    -- Indented comment
  Person json
    name Text
    age Int some="ignored -- \" attribute"
    color Text Maybe -- this is a comment sql=foobarbaz
    PersonNameKey name -- this is a comment sql=foobarbaz
    deriving Show Eq
  Person1
-- Dedented comment
  -- Header-level comment
    -- Indented comment
    name Text
    age Int
    deriving Show Eq
  PersonMaybeAge
    name Text
    age Int Maybe
  PersonMay json
    name Text Maybe
    color Text Maybe
    deriving Show Eq
  Pet
    ownerId PersonId
    name Text
    -- deriving Show Eq
-- Dedented comment
  -- Header-level comment
    -- Indented comment
    type PetType
  MaybeOwnedPet
    ownerId PersonId Maybe
    name Text
    type PetType
-- Dedented comment
  -- Header-level comment
    -- Indented comment
  NeedsPet
    petKey PetId
  OutdoorPet
    ownerId PersonId
    collar PetCollar
    type PetType

  -- From the scaffold
  UserPT
    ident Text
    password Text Maybe
    UniqueUserPT ident
  EmailPT
    email Text
    user UserPTId Maybe
    verkey Text Maybe
    UniqueEmailPT email

  Upsert
    email Text
    attr Text
    extra Text
    age Int
    UniqueUpsert email
    deriving Eq Show

  UpsertBy
    email Text
    city Text
    attr Text
    UniqueUpsertBy email
    UniqueUpsertByCity city
    deriving Eq Show

  Strict
    !yes Int
    ~no Int
    def Int

  DudeWeirdColumns
    name Text
    foo  Int     Maybe MigrationOnly
    bar  Double  SafeToRemove
    UniqueName name
    deriving Eq Show

  -- | This is a doc comment for a relationship.
  -- Only the first line requires a pipe.
  -- | Pipes are optional on subsequent lines.
  Relationship
      -- | Fields should be documentable.
      name String
      parent RelationshipId Maybe

  MutA
    mutB    MutBId

  MutB
    mutA    MutAId

|]

deriving instance (Show (BackendKey backend)) => Show (PetGeneric backend)
deriving instance (Eq (BackendKey backend)) => Eq (PetGeneric backend)

deriving instance
    (Show (BackendKey backend)) => Show (RelationshipGeneric backend)
deriving instance (Eq (BackendKey backend)) => Eq (RelationshipGeneric backend)

share
    [ mkPersist
        persistSettings
            { mpsPrefixFields = False
            , mpsFieldLabelModifier = \_ _ -> "" -- this field is ignored when mpsPrefixFields == False
            , mpsConstraintLabelModifier = \_ _ -> "" -- this field is ignored when mpsPrefixFields == False
            , mpsGeneric = True
            }
    , mkMigrate "noPrefixMigrate"
    ]
    [persistLowerCase|
NoPrefix1
    someFieldName Int
NoPrefix2
    someOtherFieldName Int
    unprefixedRef NoPrefix1Id
+NoPrefixSum
    unprefixedLeft Int
    unprefixedRight String
    deriving Show Eq

|]

deriving instance (Show (BackendKey backend)) => Show (NoPrefix1Generic backend)
deriving instance (Eq (BackendKey backend)) => Eq (NoPrefix1Generic backend)

deriving instance (Show (BackendKey backend)) => Show (NoPrefix2Generic backend)
deriving instance (Eq (BackendKey backend)) => Eq (NoPrefix2Generic backend)

share
    [ mkPersist
        persistSettings
            { mpsFieldLabelModifier = \entity field -> case entity of
                "CustomPrefix1" -> append "_cp1" field
                "CustomPrefix2" -> append "_cp2" field
                _ -> error "should not be called"
            , mpsConstraintLabelModifier = \entity field -> case entity of
                "CustomPrefix1" -> append "CP1" field
                "CustomPrefix2" -> append "CP2" field
                "CustomPrefixSum" -> append "CP" field
                _ -> error "should not be called"
            , mpsGeneric = True
            }
    , mkMigrate "customPrefixMigrate"
    ]
    [persistLowerCase|
CustomPrefix1
    customFieldName Int
CustomPrefix2
    otherCustomFieldName Int
    customPrefixedRef CustomPrefix1Id
+CustomPrefixSum
    customPrefixedLeft Int
    customPrefixedRight String
    deriving Show Eq
|]

deriving instance
    (Show (BackendKey backend)) => Show (CustomPrefix1Generic backend)
deriving instance (Eq (BackendKey backend)) => Eq (CustomPrefix1Generic backend)

deriving instance
    (Show (BackendKey backend)) => Show (CustomPrefix2Generic backend)
deriving instance (Eq (BackendKey backend)) => Eq (CustomPrefix2Generic backend)

share
    [ mkPersist persistSettings{mpsPrefixFields = False, mpsGeneric = False}
    , mkMigrate "treeMigrate"
    ]
    [persistLowerCase|

Tree sql=trees
  name String
  parent String Maybe
  Primary name
  Foreign Tree fkparent parent
|]

-- | Reverses the order of the fields of an entity.  Used to test
-- @??@ placeholders of 'rawSql'.
newtype ReverseFieldOrder a = RFO {forall a. ReverseFieldOrder a -> a
unRFO :: a} deriving (ReverseFieldOrder a -> ReverseFieldOrder a -> Bool
(ReverseFieldOrder a -> ReverseFieldOrder a -> Bool)
-> (ReverseFieldOrder a -> ReverseFieldOrder a -> Bool)
-> Eq (ReverseFieldOrder a)
forall a.
Eq a =>
ReverseFieldOrder a -> ReverseFieldOrder a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a.
Eq a =>
ReverseFieldOrder a -> ReverseFieldOrder a -> Bool
== :: ReverseFieldOrder a -> ReverseFieldOrder a -> Bool
$c/= :: forall a.
Eq a =>
ReverseFieldOrder a -> ReverseFieldOrder a -> Bool
/= :: ReverseFieldOrder a -> ReverseFieldOrder a -> Bool
Eq, Int -> ReverseFieldOrder a -> ShowS
[ReverseFieldOrder a] -> ShowS
ReverseFieldOrder a -> String
(Int -> ReverseFieldOrder a -> ShowS)
-> (ReverseFieldOrder a -> String)
-> ([ReverseFieldOrder a] -> ShowS)
-> Show (ReverseFieldOrder a)
forall a. Show a => Int -> ReverseFieldOrder a -> ShowS
forall a. Show a => [ReverseFieldOrder a] -> ShowS
forall a. Show a => ReverseFieldOrder a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> ReverseFieldOrder a -> ShowS
showsPrec :: Int -> ReverseFieldOrder a -> ShowS
$cshow :: forall a. Show a => ReverseFieldOrder a -> String
show :: ReverseFieldOrder a -> String
$cshowList :: forall a. Show a => [ReverseFieldOrder a] -> ShowS
showList :: [ReverseFieldOrder a] -> ShowS
Show)

instance ToJSON (Key (ReverseFieldOrder a)) where
    toJSON :: Key (ReverseFieldOrder a) -> Value
toJSON = String -> Key (ReverseFieldOrder a) -> Value
forall a. HasCallStack => String -> a
error String
"ReverseFieldOrder"
instance FromJSON (Key (ReverseFieldOrder a)) where
    parseJSON :: Value -> Parser (Key (ReverseFieldOrder a))
parseJSON = String -> Value -> Parser (Key (ReverseFieldOrder a))
forall a. HasCallStack => String -> a
error String
"ReverseFieldOrder"
instance (PersistEntity a) => PersistEntity (ReverseFieldOrder a) where
    type PersistEntityBackend (ReverseFieldOrder a) = PersistEntityBackend a

    newtype Key (ReverseFieldOrder a) = RFOKey {forall a. Key (ReverseFieldOrder a) -> BackendKey SqlBackend
unRFOKey :: BackendKey SqlBackend}
        deriving (Int -> Key (ReverseFieldOrder a) -> ShowS
[Key (ReverseFieldOrder a)] -> ShowS
Key (ReverseFieldOrder a) -> String
(Int -> Key (ReverseFieldOrder a) -> ShowS)
-> (Key (ReverseFieldOrder a) -> String)
-> ([Key (ReverseFieldOrder a)] -> ShowS)
-> Show (Key (ReverseFieldOrder a))
forall a. Int -> Key (ReverseFieldOrder a) -> ShowS
forall a. [Key (ReverseFieldOrder a)] -> ShowS
forall a. Key (ReverseFieldOrder a) -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Int -> Key (ReverseFieldOrder a) -> ShowS
showsPrec :: Int -> Key (ReverseFieldOrder a) -> ShowS
$cshow :: forall a. Key (ReverseFieldOrder a) -> String
show :: Key (ReverseFieldOrder a) -> String
$cshowList :: forall a. [Key (ReverseFieldOrder a)] -> ShowS
showList :: [Key (ReverseFieldOrder a)] -> ShowS
Show, ReadPrec [Key (ReverseFieldOrder a)]
ReadPrec (Key (ReverseFieldOrder a))
Int -> ReadS (Key (ReverseFieldOrder a))
ReadS [Key (ReverseFieldOrder a)]
(Int -> ReadS (Key (ReverseFieldOrder a)))
-> ReadS [Key (ReverseFieldOrder a)]
-> ReadPrec (Key (ReverseFieldOrder a))
-> ReadPrec [Key (ReverseFieldOrder a)]
-> Read (Key (ReverseFieldOrder a))
forall a. ReadPrec [Key (ReverseFieldOrder a)]
forall a. ReadPrec (Key (ReverseFieldOrder a))
forall a. Int -> ReadS (Key (ReverseFieldOrder a))
forall a. ReadS [Key (ReverseFieldOrder a)]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Int -> ReadS (Key (ReverseFieldOrder a))
readsPrec :: Int -> ReadS (Key (ReverseFieldOrder a))
$creadList :: forall a. ReadS [Key (ReverseFieldOrder a)]
readList :: ReadS [Key (ReverseFieldOrder a)]
$creadPrec :: forall a. ReadPrec (Key (ReverseFieldOrder a))
readPrec :: ReadPrec (Key (ReverseFieldOrder a))
$creadListPrec :: forall a. ReadPrec [Key (ReverseFieldOrder a)]
readListPrec :: ReadPrec [Key (ReverseFieldOrder a)]
Read, Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool
(Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool)
-> (Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool)
-> Eq (Key (ReverseFieldOrder a))
forall a.
Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a.
Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool
== :: Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool
$c/= :: forall a.
Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool
/= :: Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool
Eq, Eq (Key (ReverseFieldOrder a))
Eq (Key (ReverseFieldOrder a)) =>
(Key (ReverseFieldOrder a)
 -> Key (ReverseFieldOrder a) -> Ordering)
-> (Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool)
-> (Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool)
-> (Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool)
-> (Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool)
-> (Key (ReverseFieldOrder a)
    -> Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a))
-> (Key (ReverseFieldOrder a)
    -> Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a))
-> Ord (Key (ReverseFieldOrder a))
Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool
Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Ordering
Key (ReverseFieldOrder a)
-> Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a)
forall a. Eq (Key (ReverseFieldOrder a))
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a.
Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool
forall a.
Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Ordering
forall a.
Key (ReverseFieldOrder a)
-> Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a)
$ccompare :: forall a.
Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Ordering
compare :: Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Ordering
$c< :: forall a.
Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool
< :: Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool
$c<= :: forall a.
Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool
<= :: Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool
$c> :: forall a.
Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool
> :: Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool
$c>= :: forall a.
Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool
>= :: Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a) -> Bool
$cmax :: forall a.
Key (ReverseFieldOrder a)
-> Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a)
max :: Key (ReverseFieldOrder a)
-> Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a)
$cmin :: forall a.
Key (ReverseFieldOrder a)
-> Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a)
min :: Key (ReverseFieldOrder a)
-> Key (ReverseFieldOrder a) -> Key (ReverseFieldOrder a)
Ord, PersistValue -> Either Text (Key (ReverseFieldOrder a))
Key (ReverseFieldOrder a) -> PersistValue
(Key (ReverseFieldOrder a) -> PersistValue)
-> (PersistValue -> Either Text (Key (ReverseFieldOrder a)))
-> PersistField (Key (ReverseFieldOrder a))
forall a. PersistValue -> Either Text (Key (ReverseFieldOrder a))
forall a. Key (ReverseFieldOrder a) -> PersistValue
forall a.
(a -> PersistValue)
-> (PersistValue -> Either Text a) -> PersistField a
$ctoPersistValue :: forall a. Key (ReverseFieldOrder a) -> PersistValue
toPersistValue :: Key (ReverseFieldOrder a) -> PersistValue
$cfromPersistValue :: forall a. PersistValue -> Either Text (Key (ReverseFieldOrder a))
fromPersistValue :: PersistValue -> Either Text (Key (ReverseFieldOrder a))
PersistField, PersistField (Key (ReverseFieldOrder a))
Proxy (Key (ReverseFieldOrder a)) -> SqlType
PersistField (Key (ReverseFieldOrder a)) =>
(Proxy (Key (ReverseFieldOrder a)) -> SqlType)
-> PersistFieldSql (Key (ReverseFieldOrder a))
forall a. PersistField (Key (ReverseFieldOrder a))
forall a. Proxy (Key (ReverseFieldOrder a)) -> SqlType
forall a.
PersistField a =>
(Proxy a -> SqlType) -> PersistFieldSql a
$csqlType :: forall a. Proxy (Key (ReverseFieldOrder a)) -> SqlType
sqlType :: Proxy (Key (ReverseFieldOrder a)) -> SqlType
PersistFieldSql)
    keyFromValues :: [PersistValue] -> Either Text (Key (ReverseFieldOrder a))
keyFromValues = (BackendKey SqlBackend -> Key (ReverseFieldOrder a))
-> Either Text (BackendKey SqlBackend)
-> Either Text (Key (ReverseFieldOrder a))
forall a b. (a -> b) -> Either Text a -> Either Text b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap BackendKey SqlBackend -> Key (ReverseFieldOrder a)
forall a. BackendKey SqlBackend -> Key (ReverseFieldOrder a)
RFOKey (Either Text (BackendKey SqlBackend)
 -> Either Text (Key (ReverseFieldOrder a)))
-> ([PersistValue] -> Either Text (BackendKey SqlBackend))
-> [PersistValue]
-> Either Text (Key (ReverseFieldOrder a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PersistValue -> Either Text (BackendKey SqlBackend)
forall a. PersistField a => PersistValue -> Either Text a
fromPersistValue (PersistValue -> Either Text (BackendKey SqlBackend))
-> ([PersistValue] -> PersistValue)
-> [PersistValue]
-> Either Text (BackendKey SqlBackend)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [PersistValue] -> PersistValue
forall a. HasCallStack => [a] -> a
head
    keyToValues :: Key (ReverseFieldOrder a) -> [PersistValue]
keyToValues = (PersistValue -> [PersistValue] -> [PersistValue]
forall a. a -> [a] -> [a]
: []) (PersistValue -> [PersistValue])
-> (Key (ReverseFieldOrder a) -> PersistValue)
-> Key (ReverseFieldOrder a)
-> [PersistValue]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BackendKey SqlBackend -> PersistValue
forall a. PersistField a => a -> PersistValue
toPersistValue (BackendKey SqlBackend -> PersistValue)
-> (Key (ReverseFieldOrder a) -> BackendKey SqlBackend)
-> Key (ReverseFieldOrder a)
-> PersistValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Key (ReverseFieldOrder a) -> BackendKey SqlBackend
forall a. Key (ReverseFieldOrder a) -> BackendKey SqlBackend
unRFOKey

    entityDef :: forall (proxy :: * -> *). proxy (ReverseFieldOrder a) -> EntityDef
entityDef = EntityDef -> EntityDef
revFields (EntityDef -> EntityDef)
-> (proxy (ReverseFieldOrder a) -> EntityDef)
-> proxy (ReverseFieldOrder a)
-> EntityDef
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy a -> EntityDef
forall record (proxy :: * -> *).
PersistEntity record =>
proxy record -> EntityDef
forall (proxy :: * -> *). proxy a -> EntityDef
entityDef (Proxy a -> EntityDef)
-> (proxy (ReverseFieldOrder a) -> Proxy a)
-> proxy (ReverseFieldOrder a)
-> EntityDef
forall b c a. (b -> c) -> (a -> b) -> a -> c
. proxy (ReverseFieldOrder a) -> Proxy a
forall (proxy :: * -> *) a. proxy (ReverseFieldOrder a) -> Proxy a
unRfoProxy
      where
        unRfoProxy :: proxy (ReverseFieldOrder a) -> Proxy a
        unRfoProxy :: forall (proxy :: * -> *) a. proxy (ReverseFieldOrder a) -> Proxy a
unRfoProxy proxy (ReverseFieldOrder a)
_ = Proxy a
forall {k} (t :: k). Proxy t
Proxy
        revFields :: EntityDef -> EntityDef
revFields = ([FieldDef] -> [FieldDef]) -> EntityDef -> EntityDef
overEntityFields [FieldDef] -> [FieldDef]
forall a. [a] -> [a]
reverse

    toPersistFields :: ReverseFieldOrder a -> [PersistValue]
toPersistFields = [PersistValue] -> [PersistValue]
forall a. [a] -> [a]
reverse ([PersistValue] -> [PersistValue])
-> (ReverseFieldOrder a -> [PersistValue])
-> ReverseFieldOrder a
-> [PersistValue]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [PersistValue]
forall record. PersistEntity record => record -> [PersistValue]
toPersistFields (a -> [PersistValue])
-> (ReverseFieldOrder a -> a)
-> ReverseFieldOrder a
-> [PersistValue]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReverseFieldOrder a -> a
forall a. ReverseFieldOrder a -> a
unRFO
    newtype EntityField (ReverseFieldOrder a) b = EFRFO {forall a b. EntityField (ReverseFieldOrder a) b -> EntityField a b
unEFRFO :: EntityField a b}
    persistFieldDef :: forall typ. EntityField (ReverseFieldOrder a) typ -> FieldDef
persistFieldDef = EntityField a typ -> FieldDef
forall record typ.
PersistEntity record =>
EntityField record typ -> FieldDef
forall typ. EntityField a typ -> FieldDef
persistFieldDef (EntityField a typ -> FieldDef)
-> (EntityField (ReverseFieldOrder a) typ -> EntityField a typ)
-> EntityField (ReverseFieldOrder a) typ
-> FieldDef
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EntityField (ReverseFieldOrder a) typ -> EntityField a typ
forall a b. EntityField (ReverseFieldOrder a) b -> EntityField a b
unEFRFO
    fromPersistValues :: [PersistValue] -> Either Text (ReverseFieldOrder a)
fromPersistValues = (a -> ReverseFieldOrder a)
-> Either Text a -> Either Text (ReverseFieldOrder a)
forall a b. (a -> b) -> Either Text a -> Either Text b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> ReverseFieldOrder a
forall a. a -> ReverseFieldOrder a
RFO (Either Text a -> Either Text (ReverseFieldOrder a))
-> ([PersistValue] -> Either Text a)
-> [PersistValue]
-> Either Text (ReverseFieldOrder a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [PersistValue] -> Either Text a
forall record.
PersistEntity record =>
[PersistValue] -> Either Text record
fromPersistValues ([PersistValue] -> Either Text a)
-> ([PersistValue] -> [PersistValue])
-> [PersistValue]
-> Either Text a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [PersistValue] -> [PersistValue]
forall a. [a] -> [a]
reverse

    newtype Unique (ReverseFieldOrder a) = URFO {forall a. Unique (ReverseFieldOrder a) -> Unique a
unURFO :: Unique a}
    persistUniqueToFieldNames :: Unique (ReverseFieldOrder a) -> NonEmpty (FieldNameHS, FieldNameDB)
persistUniqueToFieldNames = NonEmpty (FieldNameHS, FieldNameDB)
-> NonEmpty (FieldNameHS, FieldNameDB)
forall a. NonEmpty a -> NonEmpty a
NEL.reverse (NonEmpty (FieldNameHS, FieldNameDB)
 -> NonEmpty (FieldNameHS, FieldNameDB))
-> (Unique (ReverseFieldOrder a)
    -> NonEmpty (FieldNameHS, FieldNameDB))
-> Unique (ReverseFieldOrder a)
-> NonEmpty (FieldNameHS, FieldNameDB)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Unique a -> NonEmpty (FieldNameHS, FieldNameDB)
forall record.
PersistEntity record =>
Unique record -> NonEmpty (FieldNameHS, FieldNameDB)
persistUniqueToFieldNames (Unique a -> NonEmpty (FieldNameHS, FieldNameDB))
-> (Unique (ReverseFieldOrder a) -> Unique a)
-> Unique (ReverseFieldOrder a)
-> NonEmpty (FieldNameHS, FieldNameDB)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Unique (ReverseFieldOrder a) -> Unique a
forall a. Unique (ReverseFieldOrder a) -> Unique a
unURFO
    persistUniqueToValues :: Unique (ReverseFieldOrder a) -> [PersistValue]
persistUniqueToValues = [PersistValue] -> [PersistValue]
forall a. [a] -> [a]
reverse ([PersistValue] -> [PersistValue])
-> (Unique (ReverseFieldOrder a) -> [PersistValue])
-> Unique (ReverseFieldOrder a)
-> [PersistValue]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Unique a -> [PersistValue]
forall record.
PersistEntity record =>
Unique record -> [PersistValue]
persistUniqueToValues (Unique a -> [PersistValue])
-> (Unique (ReverseFieldOrder a) -> Unique a)
-> Unique (ReverseFieldOrder a)
-> [PersistValue]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Unique (ReverseFieldOrder a) -> Unique a
forall a. Unique (ReverseFieldOrder a) -> Unique a
unURFO
    persistUniqueKeys :: ReverseFieldOrder a -> [Unique (ReverseFieldOrder a)]
persistUniqueKeys = (Unique a -> Unique (ReverseFieldOrder a))
-> [Unique a] -> [Unique (ReverseFieldOrder a)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Unique a -> Unique (ReverseFieldOrder a)
forall a. Unique a -> Unique (ReverseFieldOrder a)
URFO ([Unique a] -> [Unique (ReverseFieldOrder a)])
-> (ReverseFieldOrder a -> [Unique a])
-> ReverseFieldOrder a
-> [Unique (ReverseFieldOrder a)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Unique a] -> [Unique a]
forall a. [a] -> [a]
reverse ([Unique a] -> [Unique a])
-> (ReverseFieldOrder a -> [Unique a])
-> ReverseFieldOrder a
-> [Unique a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [Unique a]
forall record. PersistEntity record => record -> [Unique record]
persistUniqueKeys (a -> [Unique a])
-> (ReverseFieldOrder a -> a) -> ReverseFieldOrder a -> [Unique a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReverseFieldOrder a -> a
forall a. ReverseFieldOrder a -> a
unRFO

    persistIdField :: EntityField (ReverseFieldOrder a) (Key (ReverseFieldOrder a))
persistIdField = String
-> EntityField (ReverseFieldOrder a) (Key (ReverseFieldOrder a))
forall a. HasCallStack => String -> a
error String
"ReverseFieldOrder.persistIdField"
    fieldLens :: forall field.
EntityField (ReverseFieldOrder a) field
-> forall (f :: * -> *).
   Functor f =>
   (field -> f field)
   -> Entity (ReverseFieldOrder a) -> f (Entity (ReverseFieldOrder a))
fieldLens EntityField (ReverseFieldOrder a) field
x = String
-> (field -> f field)
-> Entity (ReverseFieldOrder a)
-> f (Entity (ReverseFieldOrder a))
forall a. HasCallStack => String -> a
error String
"ReverseFieldOrder.fieldLens"

cleanDB
    :: (MonadIO m, PersistQuery backend, PersistStoreWrite (BaseBackend backend))
    => ReaderT backend m ()
cleanDB :: forall (m :: * -> *) backend.
(MonadIO m, PersistQuery backend,
 PersistStoreWrite (BaseBackend backend)) =>
ReaderT backend m ()
cleanDB = do
    [Filter (PersonGeneric (BaseBackend backend))]
-> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (PersonGeneric backend)])
    [Filter (Person1Generic (BaseBackend backend))]
-> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (Person1Generic backend)])
    [Filter (PetGeneric (BaseBackend backend))] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (PetGeneric backend)])
    [Filter (MaybeOwnedPetGeneric (BaseBackend backend))]
-> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (MaybeOwnedPetGeneric backend)])
    [Filter (NeedsPetGeneric (BaseBackend backend))]
-> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (NeedsPetGeneric backend)])
    [Filter (OutdoorPetGeneric (BaseBackend backend))]
-> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (OutdoorPetGeneric backend)])
    [Filter (UserPTGeneric (BaseBackend backend))]
-> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (UserPTGeneric backend)])
    [Filter (EmailPTGeneric (BaseBackend backend))]
-> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (EmailPTGeneric backend)])
    [Filter (UpsertGeneric (BaseBackend backend))]
-> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (UpsertGeneric backend)])
    [Filter (UpsertByGeneric (BaseBackend backend))]
-> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (UpsertByGeneric backend)])