Converts a quasi-quoted syntax into a list of entity definitions, to be used as input to the template haskell generation code (mkPersist).

Apply persistWith to upperCaseSettings.

Apply persistWith to lowerCaseSettings.

Same as persistWith, but uses an external file instead of a quasiquotation. The recommended file extension is .persistentmodels.

Same as persistFileWith, but uses several external files instead of one. Splitting your Persistent definitions into multiple modules can potentially dramatically speed up compile times.

The recommended file extension is .persistentmodels.

Examples

-- Model1.hs
share
    [mkPersist sqlSettings]
    $(persistFileWith lowerCaseSettings "models1")

-- Model2.hs
share
    [mkPersist sqlSettings]
    $(persistFileWith lowerCaseSettings "models2")

-- Migrate.hs
share
    [mkMigrate "migrateAll"]
    $(persistManyFileWith lowerCaseSettings ["models1.persistentmodels","models2.persistentmodels"])

Since: 2.5.4

Create data types and appropriate PersistEntity instances for the given EntityDefs. Works well with the persist quasi-quoter.

Settings to be passed to the mkPersist function.

Which database backend we're using.

When generating data types, each type is given a generic version- which works with any backend- and a type synonym for the commonly used backend. This is where you specify that commonly used backend.

Create generic types that can be used with multiple backends. Good for reusable code, but makes error messages harder to understand. Default: False.

Prefix field names with the model name. Default: True.

Generate ToJSON/FromJSON instances for each model types. If it's Nothing, no instances will be generated. Default:

 Just EntityJSON
     { entityToJSON = 'keyValueEntityToJSON
     , entityFromJSON = 'keyValueEntityFromJSON
     }

Instead of generating normal field accessors, generator lens-style accessors.

Default: False

Since: 1.3.1

Create an MkPersistSettings with default values.

Use the SqlPersist backend.

Creates a single function to perform all migrations for the entities defined here. One thing to be aware of is dependencies: if you have entities with foreign references, make sure to place those definitions after the entities they reference.

Save the EntityDefs passed in under the given name.

Generate a DeleteCascade instance for the given EntityDefs.

Apply the given list of functions to the same EntityDefs.

This function is useful for cases such as:

>>> share [mkSave "myDefs", mkPersist sqlSettings] [persistLowerCase|...|]

Automatically creates a valid PersistField instance for any datatype that has valid Show and Read instances. Can be very convenient for Enum types.

Automatically creates a valid PersistField instance for any datatype that has valid ToJSON and FromJSON instances. For a datatype T it generates instances similar to these:

   instance PersistField T where
       toPersistValue = PersistByteString . L.toStrict . encode
       fromPersistValue = (left T.pack) . eitherDecodeStrict' <=< fromPersistValue
   instance PersistFieldSql T where
       sqlType _ = SqlString

produce code similar to the following:

  instance PersistEntity e => PersistField e where
     toPersistValue = PersistMap $ zip columNames (map toPersistValue . toPersistFields)
     fromPersistValue (PersistMap o) =
         let columns = HM.fromList o
         in fromPersistValues $ map (name ->
           case HM.lookup name columns of
             Just v -> v
             Nothing -> PersistNull
     fromPersistValue x = Left $ "Expected PersistMap, received: " ++ show x
     sqlType _ = SqlString

Since: 2.5.3

This class is used to ensure that functions requring at least one unique key are not called with records that have 0 unique keys. The quasiquoter automatically writes working instances for appropriate entities, and generates TypeError instances for records that have 0 unique keys.

Since: persistent-2.10.0

This class is used to ensure that upsert is only called on records that have a single Unique key. The quasiquoter automatically generates working instances for appropriate records, and generates TypeError instances for records that have 0 or multiple unique keys.

Since: persistent-2.10.0