Data.Aeson.Schema.Internal

Internal definitions for declaring JSON schemas.

Documentation

newtype Object (schema :: Schema)

The object containing JSON data and its schema.

Has a FromJSON instance, so you can use the usual Data.Aeson decoding functions.

obj = decode "{\"a\": 1}" :: Maybe (Object [schema| { a: Int } |])

Constructors

UnsafeObject (HashMap Text Dynamic)

Instances

IsSchema schema => Eq (Object schema)

Defined in Data.Aeson.Schema.Internal

Methods

(==) :: Object schema -> Object schema -> Bool

(/=) :: Object schema -> Object schema -> Bool

IsSchema schema => Show (Object schema)

Defined in Data.Aeson.Schema.Internal

Methods

showsPrec :: Int -> Object schema -> ShowS

show :: Object schema -> String

showList :: [Object schema] -> ShowS

IsSchema schema => ToJSON (Object schema)

Defined in Data.Aeson.Schema.Internal

Methods

toJSON :: Object schema -> Value

toEncoding :: Object schema -> Encoding

toJSONList :: [Object schema] -> Value

toEncodingList :: [Object schema] -> Encoding

IsSchema schema => FromJSON (Object schema)

Defined in Data.Aeson.Schema.Internal

Methods

parseJSON :: Value -> Parser (Object schema)

parseJSONList :: Value -> Parser [Object schema]

toMap :: IsSchema (Schema schema) => Object (Schema schema) -> Object

Convert an Object into a HashMap, losing the type information in the schema.

Since: 1.3.0

type IsSchema (schema :: Schema) = (HasSchemaResult (ToSchemaObject schema), All HasSchemaResultPair (FromSchema schema), IsSchemaObjectMap (FromSchema schema), SchemaResult (ToSchemaObject schema) ~ Object schema)

The constraint for most operations involving Object schema. If you're writing functions on general Objects, you should use this constraint. e.g.

logObject :: (MonadLogger m, IsSchema schema) => Object schema -> m ()
logObject = logInfoN . Text.pack . show

Since: 1.3.0

showSchema :: forall (schema :: Schema). IsSchema schema => String

Show the given schema.

Usage:

type MySchema = [schema| { a: Int } |]
showSchema @MySchema

showSchemaType :: forall (schemaType :: SchemaType). HasSchemaResult schemaType => String

type family SchemaResult (schema :: SchemaType) where ...

A type family mapping SchemaType to the corresponding Haskell type.

Equations

SchemaResult (SchemaScalar inner) = inner

SchemaResult (SchemaMaybe inner) = Maybe (SchemaResult inner)

SchemaResult (SchemaTry inner) = Maybe (SchemaResult inner)

SchemaResult (SchemaList inner) = [SchemaResult inner]

SchemaResult (SchemaUnion schemas) = SumType (SchemaResultList schemas)

SchemaResult (SchemaObject inner) = Object (Schema inner)

SchemaResult (SchemaInclude (Right schema)) = SchemaResult (ToSchemaObject schema)

type family SchemaResultList (xs :: [SchemaType]) where ...

Equations

SchemaResultList '[] = '[]

SchemaResultList (x ': xs) = SchemaResult x ': SchemaResultList xs

class IsSchemaType schema => HasSchemaResult (schema :: SchemaType) where

A type-class for types that can be parsed from JSON for an associated schema type.

Minimal complete definition

Nothing

Methods

parseValue :: [Text] -> Value -> Parser (SchemaResult schema)

parseValue :: FromJSON (SchemaResult schema) => [Text] -> Value -> Parser (SchemaResult schema)

toValue :: SchemaResult schema -> Value

toValue :: ToJSON (SchemaResult schema) => SchemaResult schema -> Value

showValue :: SchemaResult schema -> ShowS

showValue :: Show (SchemaResult schema) => SchemaResult schema -> ShowS

Instances

(Show inner, Typeable inner, FromJSON inner, ToJSON inner) => HasSchemaResult (SchemaScalar inner :: SchemaType' Symbol Type)

Defined in Data.Aeson.Schema.Internal

Methods

parseValue :: [Text] -> Value -> Parser (SchemaResult (SchemaScalar inner))

toValue :: SchemaResult (SchemaScalar inner) -> Value

showValue :: SchemaResult (SchemaScalar inner) -> ShowS

(HasSchemaResult inner, Show (SchemaResult inner), ToJSON (SchemaResult inner)) => HasSchemaResult (SchemaMaybe inner)

Defined in Data.Aeson.Schema.Internal

Methods

parseValue :: [Text] -> Value -> Parser (SchemaResult (SchemaMaybe inner))

toValue :: SchemaResult (SchemaMaybe inner) -> Value

showValue :: SchemaResult (SchemaMaybe inner) -> ShowS

(HasSchemaResult inner, Show (SchemaResult inner), ToJSON (SchemaResult inner)) => HasSchemaResult (SchemaTry inner)

Defined in Data.Aeson.Schema.Internal

Methods

parseValue :: [Text] -> Value -> Parser (SchemaResult (SchemaTry inner))

toValue :: SchemaResult (SchemaTry inner) -> Value

showValue :: SchemaResult (SchemaTry inner) -> ShowS

(HasSchemaResult inner, Show (SchemaResult inner), ToJSON (SchemaResult inner)) => HasSchemaResult (SchemaList inner)

Defined in Data.Aeson.Schema.Internal

Methods

parseValue :: [Text] -> Value -> Parser (SchemaResult (SchemaList inner))

toValue :: SchemaResult (SchemaList inner) -> Value

showValue :: SchemaResult (SchemaList inner) -> ShowS

(All HasSchemaResult schemas, All IsSchemaType schemas, Show (SchemaResult (SchemaUnion schemas)), FromJSON (SchemaResult (SchemaUnion schemas)), ToJSON (SchemaResult (SchemaUnion schemas)), ParseSumType schemas) => HasSchemaResult (SchemaUnion schemas)

Defined in Data.Aeson.Schema.Internal

Methods

parseValue :: [Text] -> Value -> Parser (SchemaResult (SchemaUnion schemas))

toValue :: SchemaResult (SchemaUnion schemas) -> Value

showValue :: SchemaResult (SchemaUnion schemas) -> ShowS

(All HasSchemaResultPair pairs, IsSchemaObjectMap pairs) => HasSchemaResult (SchemaObject pairs)

Defined in Data.Aeson.Schema.Internal

Methods

parseValue :: [Text] -> Value -> Parser (SchemaResult (SchemaObject pairs))

toValue :: SchemaResult (SchemaObject pairs) -> Value

showValue :: SchemaResult (SchemaObject pairs) -> ShowS

IsSchema schema => HasSchemaResult (SchemaInclude (Right schema :: Either Type Schema))

Defined in Data.Aeson.Schema.Internal

Methods

parseValue :: [Text] -> Value -> Parser (SchemaResult (SchemaInclude (Right schema)))

toValue :: SchemaResult (SchemaInclude (Right schema)) -> Value

showValue :: SchemaResult (SchemaInclude (Right schema)) -> ShowS

class ParseSumType xs where

Methods

parseSumType :: [Text] -> Value -> Parser (SumType (SchemaResultList xs))

Instances

ParseSumType ([] :: [SchemaType])

Defined in Data.Aeson.Schema.Internal

Methods

parseSumType :: [Text] -> Value -> Parser (SumType (SchemaResultList []))

(HasSchemaResult schema, ParseSumType schemas) => ParseSumType (schema ': schemas)

Defined in Data.Aeson.Schema.Internal

Methods

parseSumType :: [Text] -> Value -> Parser (SumType (SchemaResultList (schema ': schemas)))

toValueMap :: forall pairs. All HasSchemaResultPair pairs => Object (Schema pairs) -> Object

class HasSchemaResultPair (a :: (SchemaKey, SchemaType)) where

Methods

parseValuePair :: Proxy a -> [Text] -> Object -> Parser (Text, Dynamic)

toValuePair :: Proxy a -> Object schema -> Object

showValuePair :: Proxy a -> Object schema -> (String, ShowS)

Instances

(IsSchemaKey key, HasSchemaResult inner, Typeable (SchemaResult inner)) => HasSchemaResultPair ((,) key inner)

Defined in Data.Aeson.Schema.Internal

Methods

parseValuePair :: Proxy (key, inner) -> [Text] -> Object -> Parser (Text, Dynamic)

toValuePair :: Proxy (key, inner) -> Object schema -> Object

showValuePair :: Proxy (key, inner) -> Object schema -> (String, ShowS)

parseFail :: forall (schema :: SchemaType) m a. (MonadFail m, HasSchemaResult schema) => [Text] -> Value -> m a

A helper for creating fail messages when parsing a schema.

data UnSchemaKey :: SchemaKey -> Exp Symbol

Instances

type Eval (UnSchemaKey (NormalKey key) :: Symbol -> Type)

Defined in Data.Aeson.Schema.Internal

type Eval (UnSchemaKey (NormalKey key) :: Symbol -> Type) = Eval (Pure key)

type Eval (UnSchemaKey (PhantomKey key) :: Symbol -> Type)

Defined in Data.Aeson.Schema.Internal

type Eval (UnSchemaKey (PhantomKey key) :: Symbol -> Type) = Eval (Pure key)

type Lookup a = Map Snd <=< Find (TyEq a <=< Fst)

type family LookupSchema (key :: Symbol) (schema :: Schema) :: SchemaType where ...

The type-level function that return the schema of the given key in a SchemaObject.

Equations

LookupSchema key (Schema schema) = Eval (FromMaybe (TypeError (((Text "Key '" :<>: Text key) :<>: Text "' does not exist in the following schema:") :$$: ShowType schema)) =<< (Lookup key =<< Map (Bimap UnSchemaKey Pure) schema))

getKey :: forall (key :: Symbol) (schema :: Schema) (endSchema :: SchemaType) result. (endSchema ~ LookupSchema key schema, result ~ SchemaResult endSchema, KnownSymbol key, Typeable result, Typeable endSchema) => Proxy key -> Object schema -> result

Get a key from the given Object, returned as the type encoded in its schema.

let o = .. :: Object
            ( 'SchemaObject
               '[ '("foo", 'SchemaInt)
                , '("bar", 'SchemaObject
                     '[ '("name", 'SchemaText)
                      ]
                , '("baz", 'SchemaMaybe 'SchemaBool)
                ]
            )

getKey (Proxy @"foo") o                  :: Bool
getKey (Proxy @"bar") o                  :: Object ('SchemaObject '[ '("name", 'SchemaText) ])
getKey (Proxy @"name") $ getKey @"bar" o :: Text
getKey (Proxy @"baz") o                  :: Maybe Bool

unsafeGetKey :: forall (endSchema :: SchemaType) (key :: Symbol) (schema :: Schema). (KnownSymbol key, Typeable (SchemaResult endSchema)) => Proxy key -> Object schema -> SchemaResult endSchema