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


-- | A simple interface for generating persistent data and linking its dependencies
--   
--   Please see README.md
@package graphula
@version 2.0.2.2


-- | Internal type class(es) for Graphula-related behaviors
module Graphula.Class
type MonadGraphula m = (Monad m, MonadIO m, MonadGraphulaBackend m, MonadGraphulaFrontend m)
class MonadGraphulaFrontend m
insert :: (MonadGraphulaFrontend m, PersistEntityBackend a ~ SqlBackend, PersistEntity a, Monad m, GraphulaSafeToInsert a) => Maybe (Key a) -> a -> m (Maybe (Entity a))
remove :: (MonadGraphulaFrontend m, PersistEntityBackend a ~ SqlBackend, PersistEntity a, Monad m) => Key a -> m ()
class MonadGraphulaBackend m where {
    type Logging m :: Type -> Constraint;
}
askGen :: MonadGraphulaBackend m => m (IORef QCGen)
logNode :: (MonadGraphulaBackend m, Logging m a) => a -> m ()

-- | A class that provides backwards compatibility with
--   <tt>persistent-2.14</tt>
--   
--   If you are using that version or above, then this is a class alias for
--   <a>SafeToInsert</a>. Otherwise, it is an identity alias.
class (SafeToInsert a) => GraphulaSafeToInsert a
instance Database.Persist.Class.PersistEntity.SafeToInsert a => Graphula.Class.GraphulaSafeToInsert a


-- | <tt>Arbitrary</tt> operations that respect Graphula's seed
module Graphula.Arbitrary

-- | Run a generator
--   
--   This is akin to <a>generate</a>, but utilizing graphula's generation.
--   The size passed to the generator is always 30; if you want another
--   size then you should explicitly use <a>resize</a>.
generate :: (MonadIO m, MonadGraphulaBackend m) => Gen a -> m a


-- | Machinery for the <tt>Generic</tt>-based <tt>HasDependencies</tt>
--   instance
module Graphula.Dependencies.Generic
class GHasDependencies nodeTyProxy depsTyProxy node deps
genericDependsOn :: GHasDependencies nodeTyProxy depsTyProxy node deps => nodeTyProxy -> depsTyProxy -> node -> deps -> node
instance (Graphula.Dependencies.Generic.FindMatches nodeTy depsTy node deps GHC.Types.~ fields, Graphula.Dependencies.Generic.GHasDependenciesRecursive (Data.Proxy.Proxy fields) node deps) => Graphula.Dependencies.Generic.GHasDependencies (Data.Proxy.Proxy nodeTy) (Data.Proxy.Proxy depsTy) (Data.Either.Either node Data.Void.Void) (Data.Either.Either deps Data.Void.Void)
instance (a GHC.Types.~ dep, Graphula.Dependencies.Generic.GHasDependenciesRecursive (Data.Proxy.Proxy fields) as deps) => Graphula.Dependencies.Generic.GHasDependenciesRecursive (Data.Proxy.Proxy ('Graphula.Dependencies.Generic.Match a : fields)) (a, as) (dep, deps)
instance Graphula.Dependencies.Generic.GHasDependenciesRecursive (Data.Proxy.Proxy fields) as deps => Graphula.Dependencies.Generic.GHasDependenciesRecursive (Data.Proxy.Proxy ('Graphula.Dependencies.Generic.NoMatch a : fields)) (a, as) deps
instance Graphula.Dependencies.Generic.GHasDependenciesRecursive (Data.Proxy.Proxy '[]) () ()
instance Graphula.Dependencies.Generic.GHasDependencies (Data.Proxy.Proxy nodeTy) (Data.Proxy.Proxy depsTy) Data.Void.Void (Data.Either.Either () Data.Void.Void)
instance (TypeError ...) => Graphula.Dependencies.Generic.GHasDependencies (Data.Proxy.Proxy nodeTy) (Data.Proxy.Proxy depsTy) Data.Void.Void (Data.Either.Either deps rest)
instance (TypeError ...) => Graphula.Dependencies.Generic.GHasDependencies (Data.Proxy.Proxy nodeTy) (Data.Proxy.Proxy depsTy) (Data.Either.Either left (Data.Either.Either right rest)) (Data.Either.Either deps Data.Void.Void)
instance (TypeError ...) => Graphula.Dependencies.Generic.GHasDependencies (Data.Proxy.Proxy nodeTy) (Data.Proxy.Proxy depsTy) (Data.Either.Either node Data.Void.Void) (Data.Either.Either left (Data.Either.Either right rest))
instance (TypeError ...) => Graphula.Dependencies.Generic.GHasDependencies (Data.Proxy.Proxy nodeTy) (Data.Proxy.Proxy depsTy) (Data.Either.Either left1 (Data.Either.Either right1 rest1)) (Data.Either.Either left2 (Data.Either.Either right2 rest2))
instance (TypeError ...) => Graphula.Dependencies.Generic.GHasDependencies (Data.Proxy.Proxy nodeTy) (Data.Proxy.Proxy depsTy) node Data.Void.Void


-- | A version of <tt>GraphulaT</tt> that <tt><a>remove</a></tt>s all
--   <tt><a>insert</a></tt>ed data afterward
module Graphula.Idempotent
data GraphulaIdempotentT m a
runGraphulaIdempotentT :: MonadUnliftIO m => GraphulaIdempotentT m a -> m a
instance GHC.Base.Monad m => Control.Monad.Reader.Class.MonadReader (GHC.IORef.IORef (m ())) (Graphula.Idempotent.GraphulaIdempotentT m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Graphula.Idempotent.GraphulaIdempotentT m)
instance GHC.Base.Monad m => GHC.Base.Monad (Graphula.Idempotent.GraphulaIdempotentT m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Graphula.Idempotent.GraphulaIdempotentT m)
instance GHC.Base.Functor m => GHC.Base.Functor (Graphula.Idempotent.GraphulaIdempotentT m)
instance Control.Monad.IO.Unlift.MonadUnliftIO m => Control.Monad.IO.Unlift.MonadUnliftIO (Graphula.Idempotent.GraphulaIdempotentT m)
instance Control.Monad.Trans.Class.MonadTrans Graphula.Idempotent.GraphulaIdempotentT
instance (Control.Monad.IO.Class.MonadIO m, Graphula.Class.MonadGraphulaFrontend m) => Graphula.Class.MonadGraphulaFrontend (Graphula.Idempotent.GraphulaIdempotentT m)


-- | A version of <tt>GraphulaT</tt> that logs the generated graph
module Graphula.Logged
data GraphulaLoggedT m a

-- | Run the graph while logging to a temporary file
runGraphulaLoggedT :: MonadUnliftIO m => GraphulaLoggedT m a -> m a

-- | <a>runGraphulaLoggedT</a>, but to the specified file
runGraphulaLoggedWithFileT :: MonadUnliftIO m => FilePath -> GraphulaLoggedT m a -> m a

-- | <a>runGraphulaLoggedT</a>, but using the custom action to accumulate
runGraphulaLoggedUsingT :: MonadUnliftIO m => (IORef (Seq Text) -> HUnitFailure -> m a) -> GraphulaLoggedT m a -> m a
instance GHC.Base.Monad m => Control.Monad.Reader.Class.MonadReader (GHC.IORef.IORef (Data.Sequence.Internal.Seq Data.Text.Internal.Text)) (Graphula.Logged.GraphulaLoggedT m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Graphula.Logged.GraphulaLoggedT m)
instance GHC.Base.Monad m => GHC.Base.Monad (Graphula.Logged.GraphulaLoggedT m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Graphula.Logged.GraphulaLoggedT m)
instance GHC.Base.Functor m => GHC.Base.Functor (Graphula.Logged.GraphulaLoggedT m)
instance Control.Monad.IO.Unlift.MonadUnliftIO m => Control.Monad.IO.Unlift.MonadUnliftIO (Graphula.Logged.GraphulaLoggedT m)
instance Control.Monad.Trans.Class.MonadTrans Graphula.Logged.GraphulaLoggedT
instance (Graphula.Class.MonadGraphulaBackend m, Control.Monad.IO.Class.MonadIO m) => Graphula.Class.MonadGraphulaBackend (Graphula.Logged.GraphulaLoggedT m)
instance (GHC.Base.Monad m, Graphula.Class.MonadGraphulaFrontend m) => Graphula.Class.MonadGraphulaFrontend (Graphula.Logged.GraphulaLoggedT m)


-- | An empty <tt>Constraint</tt>
--   
--   Graphula accepts constraints for various uses. Frontends do not always
--   utilize these constraints. <a>NoConstraint</a> is a universal class
--   that all types inhabit. It has no behavior and no additional
--   constraints.
module Graphula.NoConstraint
class NoConstraint a
instance Graphula.NoConstraint.NoConstraint a

module Graphula.Dependencies
class HasDependencies a where {
    
    -- | A data type declaring the model's dependencies
    --   
    --   Models with no dependencies can declare an empty instance,
    --   
    --   <pre>
    --   instance <a>HasDependencies</a> School
    --   </pre>
    --   
    --   Models with one dependency must use the <a>Only</a> 1-tuple
    --   constructor,
    --   
    --   <pre>
    --   instance <a>HasDependencies</a> Teacher where
    --     type Dependencies Teacher = Only SchoolId
    --   </pre>
    --   
    --   Models with multiple dependencies use tuple syntax,
    --   
    --   <pre>
    --   instance <a>HasDependencies</a> Course where
    --     type Dependencies Course = (SchoolId, TeacherId)
    --   </pre>
    type Dependencies a;
    
    -- | Specify the method for resolving a node's key
    --   
    --   This can be
    --   
    --   <pre>
    --   'SourceDefault   -- automatically generate keys from the database
    --   'SourceArbitrary -- automatically generate keys using <tt><a>Arbitrary</a></tt>
    --   'SourceExternal  -- explicitly pass a key using <tt><tt>nodeKeyed</tt></tt>
    --   </pre>
    --   
    --   Most types will use <a>SourceDefault</a> or <a>SourceArbitrary</a>.
    --   Only use <a>SourceExternal</a> if the key for a value is always
    --   defined externally.
    type KeySource a :: KeySourceType;
    type Dependencies _a = ();
    type KeySource _a = 'SourceDefault;
}

-- | Assign values from the <a>Dependencies</a> collection to a value
--   
--   This must be an idempotent operation. Law:
--   
--   <pre>
--   (\x d -&gt; x `dependsOn` d `dependsOn` d) = dependsOn
--   </pre>
--   
--   The default, <a>Generic</a>-based implementation will assign values by
--   the order of the fields in the model's type.
dependsOn :: HasDependencies a => a -> Dependencies a -> a

-- | Assign values from the <a>Dependencies</a> collection to a value
--   
--   This must be an idempotent operation. Law:
--   
--   <pre>
--   (\x d -&gt; x `dependsOn` d `dependsOn` d) = dependsOn
--   </pre>
--   
--   The default, <a>Generic</a>-based implementation will assign values by
--   the order of the fields in the model's type.
dependsOn :: (HasDependencies a, HasEot a, HasEot (Dependencies a), GHasDependencies (Proxy a) (Proxy (Dependencies a)) (Eot a) (Eot (Dependencies a))) => a -> Dependencies a -> a

-- | For entities that only have singular <a>Dependencies</a>
newtype Only a
Only :: a -> Only a
[fromOnly] :: Only a -> a
only :: a -> Only a
data KeySourceType

-- | Generate keys using the database's <tt>DEFAULT</tt> strategy
SourceDefault :: KeySourceType

-- | Generate keys using the <a>Arbitrary</a> instance for the <a>Key</a>
SourceArbitrary :: KeySourceType

-- | Always explicitly pass an external key
--   
--   See <tt>nodeKeyed</tt>.
SourceExternal :: KeySourceType

-- | Abstract constraint that some <tt>a</tt> can generate a key
--   
--   This is part of ensuring better error messages.
class (GenerateKeyInternal (KeySource a) a, KeyConstraint (KeySource a) a) => GenerateKey a
generateKey :: (GenerateKeyInternal s a, KeyConstraint s a) => Gen (Maybe (Key a))
instance Data.Traversable.Traversable Graphula.Dependencies.Only
instance Data.Foldable.Foldable Graphula.Dependencies.Only
instance GHC.Base.Functor Graphula.Dependencies.Only
instance GHC.Generics.Generic (Graphula.Dependencies.Only a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Graphula.Dependencies.Only a)
instance GHC.Show.Show a => GHC.Show.Show (Graphula.Dependencies.Only a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Graphula.Dependencies.Only a)
instance (TypeError ...) => Graphula.Dependencies.GenerateKeyInternal 'Graphula.Dependencies.SourceExternal a
instance (Graphula.Dependencies.GenerateKeyInternal (Graphula.Dependencies.KeySource a) a, Graphula.Dependencies.KeyConstraint (Graphula.Dependencies.KeySource a) a) => Graphula.Dependencies.GenerateKey a
instance Graphula.Dependencies.GenerateKeyInternal 'Graphula.Dependencies.SourceDefault a
instance Graphula.Dependencies.GenerateKeyInternal 'Graphula.Dependencies.SourceArbitrary a

module Graphula.Node

-- | Generate a node with a default (Database-provided) key
--   
--   <pre>
--   a &lt;- node @A () mempty
--   </pre>
node :: forall a m. (MonadGraphula m, Logging m a, Arbitrary a, HasDependencies a, GenerateKey a, PersistEntityBackend a ~ SqlBackend, PersistEntity a, Typeable a, GraphulaSafeToInsert a) => Dependencies a -> NodeOptions a -> m (Entity a)

-- | Generate a node with an explictly-given key
--   
--   <pre>
--   let someKey = UUID.fromString "..."
--   a &lt;- nodeKeyed @A someKey () mempty
--   </pre>
nodeKeyed :: forall a m. (MonadGraphula m, Logging m a, Arbitrary a, HasDependencies a, PersistEntityBackend a ~ SqlBackend, PersistEntity a, Typeable a, GraphulaSafeToInsert a) => Key a -> Dependencies a -> NodeOptions a -> m (Entity a)

-- | Options for generating an individual node
--   
--   <a>NodeOptions</a> can be created and combined with the Monoidal
--   operations <a>(&lt;&gt;)</a> and <a>mempty</a>.
--   
--   <pre>
--   a1 &lt;- node @A () mempty
--   a2 &lt;- node @A () $ edit $ \a -&gt; a { someField = True }
--   a3 &lt;- node @A () $ ensure $ (== True) . someField
--   </pre>
data NodeOptions a

-- | Modify the node after it's been generated
--   
--   <pre>
--   a &lt;- node @A () $ edit $ \a -&gt; a { someField = True }
--   </pre>
edit :: (a -> a) -> NodeOptions a

-- | Require a node to satisfy the specified predicate
--   
--   <pre>
--   a &lt;- node @A () $ ensure $ (== True) . someField
--   </pre>
--   
--   N.B. ensuring a condition that is infrequently met can be
--   innefficient.
ensure :: (a -> Bool) -> NodeOptions a
data GenerationFailure

-- | Could not satisfy constraints defined using <a>ensure</a>
GenerationFailureMaxAttemptsToConstrain :: TypeRep -> GenerationFailure

-- | Could not satisfy database constraints on <a>insert</a>
GenerationFailureMaxAttemptsToInsert :: TypeRep -> GenerationFailure
instance GHC.Generics.Generic (Graphula.Node.Kendo m a)
instance GHC.Generics.Generic (Graphula.Node.NodeOptions a)
instance GHC.Classes.Eq Graphula.Node.GenerationFailure
instance GHC.Show.Show Graphula.Node.GenerationFailure
instance GHC.Exception.Type.Exception Graphula.Node.GenerationFailure
instance GHC.Base.Semigroup (Graphula.Node.NodeOptions a)
instance GHC.Base.Monoid (Graphula.Node.NodeOptions a)
instance GHC.Base.Monad m => GHC.Base.Semigroup (Graphula.Node.Kendo m a)
instance GHC.Base.Monad m => GHC.Base.Monoid (Graphula.Node.Kendo m a)


-- | Graphula is a compact interface for generating data and linking its
--   dependencies. You can use this interface to generate fixtures for
--   automated testing.
--   
--   <pre>
--   {- config/models
--   
--   School
--     name Text
--     deriving Generic
--   
--   Teacher
--     schoolId SchoolId
--     name Text
--     deriving Generic
--   
--   Course
--     schoolId SchoolId
--     teacherId TeacherId
--     name Text
--     deriving Generic
--   
--   -}
--   
--   instance Arbitrary School where
--     -- ...
--   
--   instance Arbitrary Teacher where
--     -- ...
--   
--   instance Arbitrary Course where
--     -- ...
--   
--   instance <a>HasDependencies</a> School
--   
--   instance <a>HasDependencies</a> Teacher where
--     type Dependencies Teacher = Only SchoolId
--   
--   instance <a>HasDependencies</a> Course where
--     type Dependencies Course = (SchoolId, CourseId)
--   
--   <a>runGraphulaT</a> runDB $ do
--     school &lt;- <a>node</a> @School () mempty
--   
--     teacher &lt;- <a>node</a> @Teacher (<tt>onlyKey</tt> school)
--        $ edit
--        $ t -&gt; t { teacherName = "Alice" }
--   
--     course &lt;- <a>node</a> @Course (<tt>keys</tt> (school, teacher))
--        $ <a>ensure</a>
--        $ not . courseIsArchived
--   </pre>
module Graphula
class HasDependencies a where {
    
    -- | A data type declaring the model's dependencies
    --   
    --   Models with no dependencies can declare an empty instance,
    --   
    --   <pre>
    --   instance <a>HasDependencies</a> School
    --   </pre>
    --   
    --   Models with one dependency must use the <a>Only</a> 1-tuple
    --   constructor,
    --   
    --   <pre>
    --   instance <a>HasDependencies</a> Teacher where
    --     type Dependencies Teacher = Only SchoolId
    --   </pre>
    --   
    --   Models with multiple dependencies use tuple syntax,
    --   
    --   <pre>
    --   instance <a>HasDependencies</a> Course where
    --     type Dependencies Course = (SchoolId, TeacherId)
    --   </pre>
    type Dependencies a;
    
    -- | Specify the method for resolving a node's key
    --   
    --   This can be
    --   
    --   <pre>
    --   'SourceDefault   -- automatically generate keys from the database
    --   'SourceArbitrary -- automatically generate keys using <tt><a>Arbitrary</a></tt>
    --   'SourceExternal  -- explicitly pass a key using <tt><tt>nodeKeyed</tt></tt>
    --   </pre>
    --   
    --   Most types will use <a>SourceDefault</a> or <a>SourceArbitrary</a>.
    --   Only use <a>SourceExternal</a> if the key for a value is always
    --   defined externally.
    type KeySource a :: KeySourceType;
    type Dependencies _a = ();
    type KeySource _a = 'SourceDefault;
}

-- | Assign values from the <a>Dependencies</a> collection to a value
--   
--   This must be an idempotent operation. Law:
--   
--   <pre>
--   (\x d -&gt; x `dependsOn` d `dependsOn` d) = dependsOn
--   </pre>
--   
--   The default, <a>Generic</a>-based implementation will assign values by
--   the order of the fields in the model's type.
dependsOn :: HasDependencies a => a -> Dependencies a -> a

-- | Assign values from the <a>Dependencies</a> collection to a value
--   
--   This must be an idempotent operation. Law:
--   
--   <pre>
--   (\x d -&gt; x `dependsOn` d `dependsOn` d) = dependsOn
--   </pre>
--   
--   The default, <a>Generic</a>-based implementation will assign values by
--   the order of the fields in the model's type.
dependsOn :: (HasDependencies a, HasEot a, HasEot (Dependencies a), GHasDependencies (Proxy a) (Proxy (Dependencies a)) (Eot a) (Eot (Dependencies a))) => a -> Dependencies a -> a

-- | For entities that only have singular <a>Dependencies</a>
newtype Only a
Only :: a -> Only a
[fromOnly] :: Only a -> a
only :: a -> Only a

-- | Generate a node with a default (Database-provided) key
--   
--   <pre>
--   a &lt;- node @A () mempty
--   </pre>
node :: forall a m. (MonadGraphula m, Logging m a, Arbitrary a, HasDependencies a, GenerateKey a, PersistEntityBackend a ~ SqlBackend, PersistEntity a, Typeable a, GraphulaSafeToInsert a) => Dependencies a -> NodeOptions a -> m (Entity a)

-- | Modify the node after it's been generated
--   
--   <pre>
--   a &lt;- node @A () $ edit $ \a -&gt; a { someField = True }
--   </pre>
edit :: (a -> a) -> NodeOptions a

-- | Require a node to satisfy the specified predicate
--   
--   <pre>
--   a &lt;- node @A () $ ensure $ (== True) . someField
--   </pre>
--   
--   N.B. ensuring a condition that is infrequently met can be
--   innefficient.
ensure :: (a -> Bool) -> NodeOptions a
data GraphulaT n m a
runGraphulaT :: MonadUnliftIO m => Maybe Int -> (forall b. ReaderT SqlBackend n b -> m b) -> GraphulaT n m a -> m a
data GenerationFailure

-- | Could not satisfy constraints defined using <a>ensure</a>
GenerationFailureMaxAttemptsToConstrain :: TypeRep -> GenerationFailure

-- | Could not satisfy database constraints on <a>insert</a>
GenerationFailureMaxAttemptsToInsert :: TypeRep -> GenerationFailure
data KeySourceType

-- | Generate keys using the database's <tt>DEFAULT</tt> strategy
SourceDefault :: KeySourceType

-- | Generate keys using the <a>Arbitrary</a> instance for the <a>Key</a>
SourceArbitrary :: KeySourceType

-- | Always explicitly pass an external key
--   
--   See <tt>nodeKeyed</tt>.
SourceExternal :: KeySourceType

-- | Generate a node with an explictly-given key
--   
--   <pre>
--   let someKey = UUID.fromString "..."
--   a &lt;- nodeKeyed @A someKey () mempty
--   </pre>
nodeKeyed :: forall a m. (MonadGraphula m, Logging m a, Arbitrary a, HasDependencies a, PersistEntityBackend a ~ SqlBackend, PersistEntity a, Typeable a, GraphulaSafeToInsert a) => Key a -> Dependencies a -> NodeOptions a -> m (Entity a)
data GraphulaLoggedT m a

-- | Run the graph while logging to a temporary file
runGraphulaLoggedT :: MonadUnliftIO m => GraphulaLoggedT m a -> m a

-- | <a>runGraphulaLoggedT</a>, but to the specified file
runGraphulaLoggedWithFileT :: MonadUnliftIO m => FilePath -> GraphulaLoggedT m a -> m a
data GraphulaIdempotentT m a
runGraphulaIdempotentT :: MonadUnliftIO m => GraphulaIdempotentT m a -> m a

-- | A constraint over lists of nodes for <a>MonadGraphula</a>, and
--   <a>GraphulaNode</a>.
--   
--   Helpful for defining utility functions over many nodes.
--   
--   <pre>
--   mkABC :: (GraphulaContext m '[A, B, C]) =&gt; m (Node m C)
--   mkABC = do
--     a &lt;- node <tt>A () mempty
--     b &lt;- node </tt>B (only a) mempty
--     node @C (a, b) $ edit $ n -&gt;
--       n { cc = "spanish" }
--   </pre>
type family GraphulaContext (m :: Type -> Type) (ts :: [Type]) :: Constraint
type GraphulaNode m a = (HasDependencies a, Logging m a, PersistEntityBackend a ~ SqlBackend, PersistEntity a, Typeable a, Arbitrary a)
type MonadGraphula m = (Monad m, MonadIO m, MonadGraphulaBackend m, MonadGraphulaFrontend m)
class MonadGraphulaBackend m where {
    type Logging m :: Type -> Constraint;
}
askGen :: MonadGraphulaBackend m => m (IORef QCGen)
logNode :: (MonadGraphulaBackend m, Logging m a) => a -> m ()
class MonadGraphulaFrontend m
insert :: (MonadGraphulaFrontend m, PersistEntityBackend a ~ SqlBackend, PersistEntity a, Monad m, GraphulaSafeToInsert a) => Maybe (Key a) -> a -> m (Maybe (Entity a))
remove :: (MonadGraphulaFrontend m, PersistEntityBackend a ~ SqlBackend, PersistEntity a, Monad m) => Key a -> m ()

-- | Options for generating an individual node
--   
--   <a>NodeOptions</a> can be created and combined with the Monoidal
--   operations <a>(&lt;&gt;)</a> and <a>mempty</a>.
--   
--   <pre>
--   a1 &lt;- node @A () mempty
--   a2 &lt;- node @A () $ edit $ \a -&gt; a { someField = True }
--   a3 &lt;- node @A () $ ensure $ (== True) . someField
--   </pre>
data NodeOptions a

-- | Abstract constraint that some <tt>a</tt> can generate a key
--   
--   This is part of ensuring better error messages.
class (GenerateKeyInternal (KeySource a) a, KeyConstraint (KeySource a) a) => GenerateKey a
class NoConstraint a
instance GHC.Base.Monad m => Control.Monad.Reader.Class.MonadReader (Graphula.Args Database.Persist.SqlBackend.Internal.SqlBackend n m) (Graphula.GraphulaT n m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Graphula.GraphulaT n m)
instance GHC.Base.Monad m => GHC.Base.Monad (Graphula.GraphulaT n m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Graphula.GraphulaT n m)
instance GHC.Base.Functor m => GHC.Base.Functor (Graphula.GraphulaT n m)
instance Control.Monad.Trans.Class.MonadTrans (Graphula.GraphulaT n)
instance Control.Monad.IO.Unlift.MonadUnliftIO m => Control.Monad.IO.Unlift.MonadUnliftIO (Graphula.GraphulaT n m)
instance Control.Monad.IO.Class.MonadIO m => Graphula.Class.MonadGraphulaBackend (Graphula.GraphulaT n m)
instance (Control.Monad.IO.Class.MonadIO m, Control.Monad.IO.Class.MonadIO n) => Graphula.Class.MonadGraphulaFrontend (Graphula.GraphulaT n m)


-- | Convenience functions for working with <a>Key</a> dependencies
module Graphula.Key

-- | Equivalent to <tt><a>Only</a> . <a>entityKey</a></tt>
onlyKey :: Entity a -> Only (Key a)
keys :: EntityKeys a => a -> Keys a

-- | Type-class for turning a tuple of <a>Entity</a> into a tuple of
--   <a>Key</a>
--   
--   For example, given:
--   
--   <pre>
--   instance <tt>HasDependencies</tt> Course where
--     type Dependencies Course = (SchoolId, TeacherId)
--   </pre>
--   
--   You would have to do,
--   
--   <pre>
--   course &lt;- <tt>node</tt> @Course (entityKey school, entityKey teacher) mempty
--   </pre>
--   
--   This type-class allows you to do:
--   
--   <pre>
--   course &lt;- <tt>node</tt> @Course (<a>keys</a> (school, teacher)) mempty
--   </pre>
--   
--   The type class instances currently scale up 4-tuple
--   <tt>Dependencies</tt>.
type Keys a
instance (TypeError ...) => Graphula.Key.EntityKeys (Database.Persist.Class.PersistEntity.Entity a)
instance Graphula.Key.EntityKeys (Graphula.Dependencies.Only (Database.Persist.Class.PersistEntity.Entity a))
instance Graphula.Key.EntityKeys (Database.Persist.Class.PersistEntity.Entity a, Database.Persist.Class.PersistEntity.Entity b)
instance Graphula.Key.EntityKeys (Database.Persist.Class.PersistEntity.Entity a, Database.Persist.Class.PersistEntity.Entity b, Database.Persist.Class.PersistEntity.Entity c)
instance Graphula.Key.EntityKeys (Database.Persist.Class.PersistEntity.Entity a, Database.Persist.Class.PersistEntity.Entity b, Database.Persist.Class.PersistEntity.Entity c, Database.Persist.Class.PersistEntity.Entity d)