Database.Persist.MongoDB

Use persistent-mongodb the same way you would use other persistent libraries and refer to the general persistent documentation. There are some new MongoDB specific filters under the filters section. These help extend your query into a nested document.

However, at some point you will find the normal Persistent APIs lacking. and want lower level-level MongoDB access. There are functions available to make working with the raw driver easier: they are under the Entity conversion section. You should still use the same connection pool that you are using for Persistent.

MongoDB is a schema-less database. The MongoDB Persistent backend does not help perform migrations. Unlike SQL backends, uniqueness constraints cannot be created for you. You must place a unique index on unique fields.

Entity conversion

collectionName :: (PersistEntity record, PersistEntityBackend record ~ MongoContext) => record -> Text

docToEntityEither :: forall record. PersistEntity record => Document -> Either Text (Entity record)

docToEntityThrow :: forall m record. (MonadIO m, PersistEntity record, PersistEntityBackend record ~ MongoContext) => Document -> m (Entity record)

entityToDocument :: (PersistEntity record, PersistEntityBackend record ~ MongoContext) => record -> Document

Deprecated: use recordToDocument

recordToDocument :: (PersistEntity record, PersistEntityBackend record ~ MongoContext) => record -> Document

convert a PersistEntity into document fields. unlike toInsertDoc, nulls are included.

documentFromEntity :: (PersistEntity record, PersistEntityBackend record ~ MongoContext) => Entity record -> Document

toInsertDoc :: forall record. (PersistEntity record, PersistEntityBackend record ~ MongoContext) => record -> Document

convert a PersistEntity into document fields. for inserts only: nulls are ignored so they will be unset in the document. entityToDocument includes nulls

entityToInsertDoc :: forall record. (PersistEntity record, PersistEntityBackend record ~ MongoContext) => Entity record -> Document

updatesToDoc :: (PersistEntity record, PersistEntityBackend record ~ MongoContext) => [Update record] -> Document

filtersToDoc :: (PersistEntity record, PersistEntityBackend record ~ MongoContext) => [Filter record] -> Document

toUniquesDoc :: forall record. PersistEntity record => Unique record -> [Field]

convert a unique key into a MongoDB document

MongoDB specific queries

(->.) :: forall record emb typ. PersistEntity emb => EntityField record [emb] -> EntityField emb typ -> NestedField record typ infixr 6

Point to an array field with an embedded object and give a deeper query into the embedded object. Use with nestEq.

(~>.) :: forall record typ emb. PersistEntity emb => EntityField record [emb] -> NestedField emb typ -> NestedField record typ infixr 5

Point to an array field with an embedded object and give a deeper query into the embedded object. This level of nesting is not the final level. Use ->. or &->. to point to the final level.

(?&->.) :: forall record typ nest. PersistEntity nest => EntityField record (Maybe nest) -> EntityField nest typ -> NestedField record typ infixr 6

Same as &->., but Works against a Maybe type

(?&~>.) :: forall val nes nes1. PersistEntity nes1 => EntityField val (Maybe nes1) -> NestedField nes1 nes -> NestedField val nes infixr 5

Same as &~>., but works against a Maybe type

(&->.) :: forall record typ nest. PersistEntity nest => EntityField record nest -> EntityField nest typ -> NestedField record typ infixr 6

Point to a nested field to query. This field is not an array type. Use with nestEq.

(&~>.) :: forall val nes nes1. PersistEntity nes1 => EntityField val nes1 -> NestedField nes1 nes -> NestedField val nes infixr 5

Point to a nested field to query. This field is not an array type. This level of nesting is not the final level. Use ->. or &>. to point to the final level.

Filters

You can find example usage for all of Persistent in our test cases: https://github.com/yesodweb/persistent/blob/master/persistent-test/EmbedTest.hs#L144

These filters create a query that reaches deeper into a document with nested fields.

nestEq :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => NestedField record typ -> typ -> Filter record infixr 4

The normal Persistent equality test ==. is not generic enough. Instead use this with the drill-down arrow operaters such as ->.

using this as the only query filter is similar to the following in the mongoDB shell

db.Collection.find({"object.field": item})

nestNe :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => NestedField record typ -> typ -> Filter record infixr 4

The normal Persistent equality test ==. is not generic enough. Instead use this with the drill-down arrow operaters such as ->.

using this as the only query filter is similar to the following in the mongoDB shell

db.Collection.find({"object.field": item})

nestGe :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => NestedField record typ -> typ -> Filter record infixr 4

The normal Persistent equality test ==. is not generic enough. Instead use this with the drill-down arrow operaters such as ->.

using this as the only query filter is similar to the following in the mongoDB shell

db.Collection.find({"object.field": item})

nestLe :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => NestedField record typ -> typ -> Filter record infixr 4

The normal Persistent equality test ==. is not generic enough. Instead use this with the drill-down arrow operaters such as ->.

using this as the only query filter is similar to the following in the mongoDB shell

db.Collection.find({"object.field": item})

nestIn :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => NestedField record typ -> typ -> Filter record infixr 4

The normal Persistent equality test ==. is not generic enough. Instead use this with the drill-down arrow operaters such as ->.

using this as the only query filter is similar to the following in the mongoDB shell

db.Collection.find({"object.field": item})

nestNotIn :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => NestedField record typ -> typ -> Filter record infixr 4

The normal Persistent equality test ==. is not generic enough. Instead use this with the drill-down arrow operaters such as ->.

using this as the only query filter is similar to the following in the mongoDB shell

db.Collection.find({"object.field": item})

anyEq :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => EntityField record [typ] -> typ -> Filter record infixr 4

Like '(==.)' but for an embedded list. Checks to see if the list contains an item.

In Haskell we need different equality functions for embedded fields that are lists or non-lists to keep things type-safe.

using this as the only query filter is similar to the following in the mongoDB shell

db.Collection.find({arrayField: arrayItem})

nestAnyEq :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => NestedField record [typ] -> typ -> Filter record infixr 4

Like nestEq, but for an embedded list. Checks to see if the nested list contains an item.

nestBsonEq :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => NestedField record typ -> Value -> Filter record infixr 4

same as nestEq, but give a BSON Value

anyBsonEq :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => EntityField record [typ] -> Value -> Filter record infixr 4

same as anyEq, but give a BSON Value

multiBsonEq :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => EntityField record [typ] -> Value -> Filter record infixr 4

Deprecated: Please use anyBsonEq instead

inList :: PersistField typ => EntityField v [typ] -> [typ] -> Filter v infix 4

Intersection of lists: if any value in the field is found in the list.

ninList :: PersistField typ => EntityField v [typ] -> [typ] -> Filter v infix 4

No intersection of lists: if no value in the field is found in the list.

(=~.) :: forall record searchable. (MongoRegexSearchable searchable, PersistEntity record, PersistEntityBackend record ~ MongoContext) => EntityField record searchable -> MongoRegex -> Filter record infixr 4

Filter using a Regular expression.

data NestedField record typ

Constructors

PersistEntity emb => (EntityField record [emb]) `LastEmbFld` (EntityField emb typ)

PersistEntity emb => (EntityField record [emb]) `MidEmbFld` (NestedField emb typ)

PersistEntity nest => (EntityField record nest) `MidNestFlds` (NestedField nest typ)

PersistEntity nest => (EntityField record (Maybe nest)) `MidNestFldsNullable` (NestedField nest typ)

PersistEntity nest => (EntityField record nest) `LastNestFld` (EntityField nest typ)

PersistEntity nest => (EntityField record (Maybe nest)) `LastNestFldNullable` (EntityField nest typ)

class PersistField typ => MongoRegexSearchable typ

Mark the subset of PersistFields that can be searched by a mongoDB regex Anything stored as PersistText or an array of PersistText would be valid

Instances

MongoRegexSearchable Text

MongoRegexSearchable rs => MongoRegexSearchable [rs]

MongoRegexSearchable rs => MongoRegexSearchable (Maybe rs)

type MongoRegex = (Text, Text)

A MongoRegex represents a Regular expression. It is a tuple of the expression and the options for the regular expression, respectively Options are listed here: http://docs.mongodb.org/manual/reference/operator/query/regex/ If you use the same options you may want to define a helper such as r t = (t, "ims")

Updates

nestSet :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => NestedField record typ -> typ -> Update record infixr 4

nestInc :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => NestedField record typ -> typ -> Update record

nestDec :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => NestedField record typ -> typ -> Update record

nestMul :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => NestedField record typ -> typ -> Update record

push :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => EntityField record [typ] -> typ -> Update record infixr 4

pull :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => EntityField record [typ] -> typ -> Update record infixr 4

pullAll :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => EntityField record [typ] -> [typ] -> Update record infixr 4

addToSet :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => EntityField record [typ] -> typ -> Update record infixr 4

eachOp :: forall record typ. (PersistField typ, PersistEntityBackend record ~ MongoContext) => (EntityField record [typ] -> typ -> Update record) -> EntityField record [typ] -> [typ] -> Update record

equivalent to $each

eachOp push field []

eachOp pull will get translated to $pullAll

Key conversion helpers

data family BackendKey backend :: *

Instances

data BackendKey MongoContext

data BackendKey MongoContext = MongoKey {

• unMongoKey :: ObjectId

}

data BackendKey SqlBackend

data BackendKey SqlBackend = SqlBackendKey {

• unSqlBackendKey :: Int64

}

data BackendKey SqlReadBackend

data BackendKey SqlReadBackend = SqlReadBackendKey {

• unSqlReadBackendKey :: Int64

}

data BackendKey SqlWriteBackend

data BackendKey SqlWriteBackend = SqlWriteBackendKey {

• unSqlWriteBackendKey :: Int64

}

keyToOid :: ToBackendKey MongoContext record => Key record -> ObjectId

oidToKey :: ToBackendKey MongoContext record => ObjectId -> Key record

recordTypeFromKey :: Key record -> record

readMayObjectId :: Text -> Maybe ObjectId

readMayMongoKey :: Text -> Maybe (BackendKey MongoContext)

Convert a Text to a Key

keyToText :: BackendKey MongoContext -> Text

PersistField conversion

fieldName :: forall record typ. PersistEntity record => EntityField record typ -> Label

using connections

withConnection :: (MonadIO m, Applicative m) => MongoConf -> (ConnectionPool -> m b) -> m b

withMongoPool :: (MonadIO m, Applicative m) => MongoConf -> (ConnectionPool -> m b) -> m b

withMongoDBConn :: (MonadIO m, Applicative m) => Database -> HostName -> PortID -> Maybe MongoAuth -> NominalDiffTime -> (ConnectionPool -> m b) -> m b

withMongoDBPool :: (MonadIO m, Applicative m) => Database -> HostName -> PortID -> Maybe MongoAuth -> Int -> Int -> NominalDiffTime -> (ConnectionPool -> m b) -> m b

createMongoDBPool

Arguments

:: (MonadIO m, Applicative m)

=> Database

-> HostName

-> PortID

-> Maybe MongoAuth

-> Int

pool size (number of stripes)

-> Int

stripe size (number of connections per stripe)

-> NominalDiffTime

time a connection is left idle before closing

-> m ConnectionPool

runMongoDBPool :: (MonadIO m, MonadBaseControl IO m) => AccessMode -> Action m a -> ConnectionPool -> m a

runMongoDBPoolDef :: (MonadIO m, MonadBaseControl IO m) => Action m a -> ConnectionPool -> m a

use default AccessMode

type ConnectionPool = Pool Connection

data Connection

data MongoAuth

Constructors

MongoAuth Username Password

Instances

Show MongoAuth

Methods

showsPrec :: Int -> MongoAuth -> ShowS

show :: MongoAuth -> String

showList :: [MongoAuth] -> ShowS

Connection configuration

data MongoConf

Information required to connect to a mongo database

Constructors

MongoConf

Fields

• mgDatabase :: Text
• mgHost :: Text
• mgPort :: PortID
• mgAuth :: Maybe MongoAuth
• mgAccessMode :: AccessMode
• mgPoolStripes :: Int
• mgStripeConnections :: Int
• mgConnectionIdleTime :: NominalDiffTime
• mgReplicaSetConfig :: Maybe ReplicaSetConfig

  YAML fields for this are rsName and rsSecondaries mgHost is assumed to be the primary

Instances

Show MongoConf

Methods

showsPrec :: Int -> MongoConf -> ShowS

show :: MongoConf -> String

showList :: [MongoConf] -> ShowS

FromJSON MongoConf

Methods

parseJSON :: Value -> Parser MongoConf

parseJSONList :: Value -> Parser [MongoConf]

PersistConfig MongoConf

Associated Types

type PersistConfigBackend MongoConf :: (* -> *) -> * -> *

type PersistConfigPool MongoConf :: *

Methods

loadConfig :: Value -> Parser MongoConf

applyEnv :: MongoConf -> IO MongoConf

createPoolConfig :: MongoConf -> IO (PersistConfigPool MongoConf)

runPool :: (MonadBaseControl IO m, MonadIO m) => MongoConf -> PersistConfigBackend MongoConf m a -> PersistConfigPool MongoConf -> m a

type PersistConfigPool MongoConf

type PersistConfigPool MongoConf = ConnectionPool

type PersistConfigBackend MongoConf

type PersistConfigBackend MongoConf = Action

defaultMongoConf :: Text -> MongoConf

defaultHost :: Text

defaultAccessMode :: AccessMode

defaultPoolStripes :: Int

defaultConnectionIdleTime :: NominalDiffTime

defaultStripeConnections :: Int

applyDockerEnv :: MongoConf -> IO MongoConf

docker integration: change the host to the mongodb link

using raw MongoDB pipes

type PipePool = Pool Pipe

createMongoDBPipePool

Arguments

:: (MonadIO m, Applicative m)

=> HostName

-> PortID

-> Int

pool size (number of stripes)

-> Int

stripe size (number of connections per stripe)

-> NominalDiffTime

time a connection is left idle before closing

-> m PipePool

A pool of plain MongoDB pipes. The database parameter has not yet been applied yet. This is useful for switching between databases (on the same host and port) Unlike the normal pool, no authentication is available

runMongoDBPipePool :: (MonadIO m, MonadBaseControl IO m) => AccessMode -> Database -> Action m a -> PipePool -> m a

run a pool created with createMongoDBPipePool

network type

type HostName = String

Either a host name e.g., "haskell.org" or a numeric host address string consisting of a dotted decimal IPv4 address or an IPv6 address e.g., "192.168.0.1".

data PortID :: *

Instances

Eq PortID

Methods

(==) :: PortID -> PortID -> Bool

(/=) :: PortID -> PortID -> Bool

Show PortID

Methods

showsPrec :: Int -> PortID -> ShowS

show :: PortID -> String

showList :: [PortID] -> ShowS

MongoDB driver types

type Database = Text

type Action = ReaderT * MongoContext

A monad on top of m (which must be a MonadIO) that may access the database and may fail with a DB Failure

data AccessMode :: *

Type of reads and writes to perform

Constructors

ReadStaleOk

Read-only action, reading stale data from a slave is OK.

UnconfirmedWrites

Read-write action, slave not OK, every write is fire & forget.

ConfirmWrites GetLastError

Read-write action, slave not OK, every write is confirmed with getLastError.

Instances

Show AccessMode

Methods

showsPrec :: Int -> AccessMode -> ShowS

show :: AccessMode -> String

showList :: [AccessMode] -> ShowS

master :: AccessMode

Same as ConfirmWrites []

slaveOk :: AccessMode

Same as ReadStaleOk

(=:) :: Val v => Label -> v -> Field infix 0

Field with given label and typed value

data ObjectId :: *

A BSON ObjectID is a 12-byte value consisting of a 4-byte timestamp (seconds since epoch), a 3-byte machine id, a 2-byte process id, and a 3-byte counter. Note that the timestamp and counter fields must be stored big endian unlike the rest of BSON. This is because they are compared byte-by-byte and we want to ensure a mostly increasing order.

Instances

Eq ObjectId

Methods

(==) :: ObjectId -> ObjectId -> Bool

(/=) :: ObjectId -> ObjectId -> Bool

Ord ObjectId

Methods

compare :: ObjectId -> ObjectId -> Ordering

(<) :: ObjectId -> ObjectId -> Bool

(<=) :: ObjectId -> ObjectId -> Bool

(>) :: ObjectId -> ObjectId -> Bool

(>=) :: ObjectId -> ObjectId -> Bool

max :: ObjectId -> ObjectId -> ObjectId

min :: ObjectId -> ObjectId -> ObjectId

Read ObjectId

Methods

readsPrec :: Int -> ReadS ObjectId

readList :: ReadS [ObjectId]

readPrec :: ReadPrec ObjectId

readListPrec :: ReadPrec [ObjectId]

Show ObjectId

Methods

showsPrec :: Int -> ObjectId -> ShowS

show :: ObjectId -> String

showList :: [ObjectId] -> ShowS

Val ObjectId

Methods

val :: ObjectId -> Value

valList :: [ObjectId] -> Value

valMaybe :: Maybe ObjectId -> Value

cast' :: Value -> Maybe ObjectId

cast'List :: Value -> Maybe [ObjectId]

cast'Maybe :: Value -> Maybe (Maybe ObjectId)

data MongoContext :: *

Values needed when executing a db operation

Instances

HasMongoContext MongoContext

Methods

mongoContext :: MongoContext -> MongoContext

type BaseBackend MongoContext

type BaseBackend MongoContext = MongoContext

data BackendKey MongoContext

data BackendKey MongoContext = MongoKey {

• unMongoKey :: ObjectId

}

type BackendSpecificUpdate MongoContext record

type BackendSpecificUpdate MongoContext record

type BackendSpecificFilter MongoContext record

type BackendSpecificFilter MongoContext record

Database.Persist

module Database.Persist

Orphan instances

Val PersistValue

Methods

val :: PersistValue -> Value

valList :: [PersistValue] -> Value

valMaybe :: Maybe PersistValue -> Value

cast' :: Value -> Maybe PersistValue

cast'List :: Value -> Maybe [PersistValue]

cast'Maybe :: Value -> Maybe (Maybe PersistValue)

Serialize ObjectId

Methods

put :: Putter ObjectId

get :: Get ObjectId

PersistFieldSql ObjectId

Methods

sqlType :: Proxy * ObjectId -> SqlType

PersistUniqueRead MongoContext

Methods

getBy :: (MonadIO m, PersistRecordBackend record MongoContext) => Unique record -> ReaderT * MongoContext m (Maybe (Entity record))

PersistUniqueWrite MongoContext

Methods

deleteBy :: (MonadIO m, PersistRecordBackend record MongoContext) => Unique record -> ReaderT * MongoContext m ()

insertUnique :: (MonadIO m, PersistRecordBackend record MongoContext) => record -> ReaderT * MongoContext m (Maybe (Key record))

upsert :: (MonadIO m, PersistRecordBackend record MongoContext) => record -> [Update record] -> ReaderT * MongoContext m (Entity record)

upsertBy :: (MonadIO m, PersistRecordBackend record MongoContext) => Unique record -> record -> [Update record] -> ReaderT * MongoContext m (Entity record)

PersistQueryRead MongoContext

Methods

selectSourceRes :: (PersistRecordBackend record MongoContext, MonadIO m1, MonadIO m2) => [Filter record] -> [SelectOpt record] -> ReaderT * MongoContext m1 (Acquire (Source m2 (Entity record)))

selectFirst :: (MonadIO m, PersistRecordBackend record MongoContext) => [Filter record] -> [SelectOpt record] -> ReaderT * MongoContext m (Maybe (Entity record))

selectKeysRes :: (MonadIO m1, MonadIO m2, PersistRecordBackend record MongoContext) => [Filter record] -> [SelectOpt record] -> ReaderT * MongoContext m1 (Acquire (Source m2 (Key record)))

count :: (MonadIO m, PersistRecordBackend record MongoContext) => [Filter record] -> ReaderT * MongoContext m Int

PersistQueryWrite MongoContext

Methods

updateWhere :: (MonadIO m, PersistRecordBackend record MongoContext) => [Filter record] -> [Update record] -> ReaderT * MongoContext m ()

deleteWhere :: (MonadIO m, PersistRecordBackend record MongoContext) => [Filter record] -> ReaderT * MongoContext m ()

HasPersistBackend MongoContext

Associated Types

type BaseBackend MongoContext :: *

Methods

persistBackend :: MongoContext -> BaseBackend MongoContext

PersistCore MongoContext

older versions versions of haddock (like that on hackage) do not show that this defines BackendKey DB.MongoContext = MongoKey { unMongoKey :: DB.ObjectId }

Associated Types

data BackendKey MongoContext :: *

PersistStoreRead MongoContext

Methods

get :: (MonadIO m, PersistRecordBackend record MongoContext) => Key record -> ReaderT * MongoContext m (Maybe record)

PersistStoreWrite MongoContext

Methods

insert :: (MonadIO m, PersistRecordBackend record MongoContext) => record -> ReaderT * MongoContext m (Key record)

insert_ :: (MonadIO m, PersistRecordBackend record MongoContext) => record -> ReaderT * MongoContext m ()

insertMany :: (MonadIO m, PersistRecordBackend record MongoContext) => [record] -> ReaderT * MongoContext m [Key record]

insertMany_ :: (MonadIO m, PersistRecordBackend record MongoContext) => [record] -> ReaderT * MongoContext m ()

insertEntityMany :: (MonadIO m, PersistRecordBackend record MongoContext) => [Entity record] -> ReaderT * MongoContext m ()

insertKey :: (MonadIO m, PersistRecordBackend record MongoContext) => Key record -> record -> ReaderT * MongoContext m ()

repsert :: (MonadIO m, PersistRecordBackend record MongoContext) => Key record -> record -> ReaderT * MongoContext m ()

replace :: (MonadIO m, PersistRecordBackend record MongoContext) => Key record -> record -> ReaderT * MongoContext m ()

delete :: (MonadIO m, PersistRecordBackend record MongoContext) => Key record -> ReaderT * MongoContext m ()

update :: (MonadIO m, PersistRecordBackend record MongoContext) => Key record -> [Update record] -> ReaderT * MongoContext m ()

updateGet :: (MonadIO m, PersistRecordBackend record MongoContext) => Key record -> [Update record] -> ReaderT * MongoContext m record

PersistField ObjectId

Methods

toPersistValue :: ObjectId -> PersistValue

fromPersistValue :: PersistValue -> Either Text ObjectId

Eq (BackendKey MongoContext)

Methods

(==) :: BackendKey MongoContext -> BackendKey MongoContext -> Bool

(/=) :: BackendKey MongoContext -> BackendKey MongoContext -> Bool

Ord (BackendKey MongoContext)

Methods

compare :: BackendKey MongoContext -> BackendKey MongoContext -> Ordering

(<) :: BackendKey MongoContext -> BackendKey MongoContext -> Bool

(<=) :: BackendKey MongoContext -> BackendKey MongoContext -> Bool

(>) :: BackendKey MongoContext -> BackendKey MongoContext -> Bool

(>=) :: BackendKey MongoContext -> BackendKey MongoContext -> Bool

max :: BackendKey MongoContext -> BackendKey MongoContext -> BackendKey MongoContext

min :: BackendKey MongoContext -> BackendKey MongoContext -> BackendKey MongoContext

Read (BackendKey MongoContext)

Methods

readsPrec :: Int -> ReadS (BackendKey MongoContext)

readList :: ReadS [BackendKey MongoContext]

readPrec :: ReadPrec (BackendKey MongoContext)

readListPrec :: ReadPrec [BackendKey MongoContext]

Show (BackendKey MongoContext)

Methods

showsPrec :: Int -> BackendKey MongoContext -> ShowS

show :: BackendKey MongoContext -> String

showList :: [BackendKey MongoContext] -> ShowS

FromJSON (BackendKey MongoContext)

Methods

parseJSON :: Value -> Parser (BackendKey MongoContext)

parseJSONList :: Value -> Parser [BackendKey MongoContext]

ToJSON (BackendKey MongoContext)

It would make sense to define the instance for ObjectId and then use newtype deriving however, that would create an orphan instance

Methods

toJSON :: BackendKey MongoContext -> Value

toEncoding :: BackendKey MongoContext -> Encoding

toJSONList :: [BackendKey MongoContext] -> Value

toEncodingList :: [BackendKey MongoContext] -> Encoding

ToHttpApiData (BackendKey MongoContext)

Methods

toUrlPiece :: BackendKey MongoContext -> Text

toHeader :: BackendKey MongoContext -> ByteString

toQueryParam :: BackendKey MongoContext -> Text

FromHttpApiData (BackendKey MongoContext)

Methods

parseUrlPiece :: Text -> Either Text (BackendKey MongoContext)

parseHeader :: ByteString -> Either Text (BackendKey MongoContext)

parseQueryParam :: Text -> Either Text (BackendKey MongoContext)

PathPiece (BackendKey MongoContext)

ToPathPiece is used to convert a key to/from text

Methods

fromPathPiece :: Text -> Maybe (BackendKey MongoContext)

toPathPiece :: BackendKey MongoContext -> Text

PersistFieldSql (BackendKey MongoContext)

Methods

sqlType :: Proxy * (BackendKey MongoContext) -> SqlType

PersistField (BackendKey MongoContext)

Methods

toPersistValue :: BackendKey MongoContext -> PersistValue

fromPersistValue :: PersistValue -> Either Text (BackendKey MongoContext)