Data.JsonSchema.Draft4

Documentation

data Schema

Constructors

Schema

Fields

• _schemaVersion :: Maybe Text
• _schemaId :: Maybe Text
• _schemaRef :: Maybe Text
• _schemaDefinitions :: Maybe (HashMap Text Schema)

  A standardized location for embedding schemas to be referenced from elsewhere in the document.

• _schemaOther :: HashMap Text Value

  Since the JSON document this Schema was built from could contain schemas anywhere (not just in "definitions" or any of the other official keys) we save any leftover key/value pairs not covered by them here.

• _schemaMultipleOf :: Maybe Scientific
• _schemaMaximum :: Maybe Scientific
• _schemaExclusiveMaximum :: Maybe Bool
• _schemaMinimum :: Maybe Scientific
• _schemaExclusiveMinimum :: Maybe Bool
• _schemaMaxLength :: Maybe Int
• _schemaMinLength :: Maybe Int
• _schemaPattern :: Maybe Text
• _schemaMaxItems :: Maybe Int
• _schemaMinItems :: Maybe Int
• _schemaUniqueItems :: Maybe Bool
• _schemaItems :: Maybe (Items Schema)
• _schemaAdditionalItems :: Maybe (AdditionalItems Schema)
• _schemaMaxProperties :: Maybe Int
• _schemaMinProperties :: Maybe Int
• _schemaRequired :: Maybe Required
• _schemaDependencies :: Maybe (HashMap Text (Dependency Schema))
• _schemaProperties :: Maybe (HashMap Text Schema)
• _schemaPatternProperties :: Maybe (HashMap Text Schema)
• _schemaAdditionalProperties :: Maybe (AdditionalProperties Schema)
• _schemaEnum :: Maybe EnumVal
• _schemaType :: Maybe TypeVal
• _schemaAllOf :: Maybe (NonEmpty Schema)
• _schemaAnyOf :: Maybe (NonEmpty Schema)
• _schemaOneOf :: Maybe (NonEmpty Schema)
• _schemaNot :: Maybe Schema

Instances

Eq Schema

Methods

(==) :: Schema -> Schema -> Bool

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

Show Schema

Methods

showsPrec :: Int -> Schema -> ShowS

show :: Schema -> String

showList :: [Schema] -> ShowS

Arbitrary Schema

Methods

arbitrary :: Gen Schema

shrink :: Schema -> [Schema]

ToJSON Schema

Methods

toJSON :: Schema -> Value

toEncoding :: Schema -> Encoding

FromJSON Schema

Methods

parseJSON :: Value -> Parser Schema

emptySchema :: Schema

One-step validation

data HTTPValidationFailure

Constructors

HVRequest HTTPFailure

HVSchema (NonEmpty Invalid)

HVData (NonEmpty Invalid)

Instances

Show HTTPValidationFailure

Methods

showsPrec :: Int -> HTTPValidationFailure -> ShowS

show :: HTTPValidationFailure -> String

showList :: [HTTPValidationFailure] -> ShowS

fetchHTTPAndValidate :: SchemaWithURI Schema -> Value -> IO (Either HTTPValidationFailure ())

data FilesystemValidationFailure

Constructors

FVRead FilesystemFailure

FVSchema (NonEmpty Invalid)

FVData (NonEmpty Invalid)

Instances

Show FilesystemValidationFailure

Methods

showsPrec :: Int -> FilesystemValidationFailure -> ShowS

show :: FilesystemValidationFailure -> String

showList :: [FilesystemValidationFailure] -> ShowS

fetchFilesystemAndValidate :: SchemaWithURI Schema -> Value -> IO (Either FilesystemValidationFailure ())

Fetching tools

data SchemaWithURI schema

Constructors

SchemaWithURI

Fields

• _swSchema :: !schema
• _swURI :: !(Maybe Text)

  Must not include a URI fragment, e.g. use "http://example.com/foo" not "http://example.com/foo#bar".

  This is the URI identifying the document containing the schema. It's different than the schema's "id" field, which controls scope when resolving references contained in the schema.

Instances

Eq schema => Eq (SchemaWithURI schema)

Methods

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

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

Show schema => Show (SchemaWithURI schema)

Methods

showsPrec :: Int -> SchemaWithURI schema -> ShowS

show :: SchemaWithURI schema -> String

showList :: [SchemaWithURI schema] -> ShowS

data ReferencedSchemas schema

Constructors

ReferencedSchemas

Fields

• _rsStarting :: !schema

  Used to resolve relative references.

• _rsSchemaMap :: !(URISchemaMap schema)

Instances

Eq schema => Eq (ReferencedSchemas schema)

Methods

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

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

Show schema => Show (ReferencedSchemas schema)

Methods

showsPrec :: Int -> ReferencedSchemas schema -> ShowS

show :: ReferencedSchemas schema -> String

showList :: [ReferencedSchemas schema] -> ShowS

data HTTPFailure

Constructors

HTTPParseFailure Text

HTTPRequestFailure HttpException

Instances

Show HTTPFailure

Methods

showsPrec :: Int -> HTTPFailure -> ShowS

show :: HTTPFailure -> String

showList :: [HTTPFailure] -> ShowS

referencesViaHTTP :: SchemaWithURI Schema -> IO (Either HTTPFailure (ReferencedSchemas Schema))

data FilesystemFailure

Constructors

FSParseFailure Text

FSReadFailure IOError

Instances

Show FilesystemFailure

Methods

showsPrec :: Int -> FilesystemFailure -> ShowS

show :: FilesystemFailure -> String

showList :: [FilesystemFailure] -> ShowS

referencesViaFilesystem :: SchemaWithURI Schema -> IO (Either FilesystemFailure (ReferencedSchemas Schema))

Failure

type Invalid = Failure ValidatorChain

data Failure err

Validators shouldn't know more about the schema they're going to be used with than necessary. If a validator throws errors using the error sum type of a particular schema, then it can't be used with other schemas later that have different error sum types (at least not without writing partial functions).

Thus validators that can only fail in one way return FailureInfos. Validators that can fail in multiple ways return ValidationFailures along with an custom error sum type for that particular validator.

It's the job of a schema's validate function to unify the errors produced by the validators it uses into a single error sum type for that schema. The schema's validate function will return a ValidationFailure with that sum type as its type argument.

Constructors

Invalid

Fields

• _invalidValidatorsCalled :: !err
• _invalidFinalValidator :: !Value
• _invalidOffendingData :: !Pointer

Instances

Eq err => Eq (Failure err)

Methods

(==) :: Failure err -> Failure err -> Bool

(/=) :: Failure err -> Failure err -> Bool

Show err => Show (Failure err)

Methods

showsPrec :: Int -> Failure err -> ShowS

show :: Failure err -> String

showList :: [Failure err] -> ShowS

data ValidatorChain

Constructors

MultipleOf

Maximum

ExclusiveMaximum

Minimum

ExclusiveMinimum

MaxLength

MinLength

PatternValidator

MaxItems

MinItems

UniqueItems

Items ValidatorChain

AdditionalItemsBool

AdditionalItemsObject ValidatorChain

MaxProperties

MinProperties

Required

SchemaDependency ValidatorChain

PropertyDependency

Properties ValidatorChain

PatternProperties ValidatorChain

AdditionalPropertiesBool

AdditionalPropertiesObject ValidatorChain

RefResolution

Indicates a reference that failed to resolve.

NOTE: The language agnostic test suite doesn't specify if this should cause a validation error or should allow data to pass. We choose to return a validation error.

Also note that ideally we would enforce in the type system that any failing references be dealt with before valididation. Then this could be removed entirely.

Ref ValidatorChain

Enum

TypeValidator

AllOf ValidatorChain

AnyOf

OneOf

NotValidator

Instances

Eq ValidatorChain

Methods

(==) :: ValidatorChain -> ValidatorChain -> Bool

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

Show ValidatorChain

Methods

showsPrec :: Int -> ValidatorChain -> ShowS

show :: ValidatorChain -> String

showList :: [ValidatorChain] -> ShowS

Other Draft 4 things exported just in case

checkSchema :: ReferencedSchemas Schema -> SchemaWithURI Schema -> Either (NonEmpty Invalid) (Value -> [Invalid])

Check the that a schema itself is valid.

Return a function to validate data.

schemaValidity :: Schema -> [Invalid]

Check that a schema itself is valid.

runValidate :: ReferencedSchemas Schema -> SchemaWithURI Schema -> Value -> [Invalid]

draft4Spec :: Spec Schema