Data.JsonSchema.Draft4

Draft 4 Schema

data SchemaWithURI schema

Constructors

SchemaWithURI

Fields

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

  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 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 (getting references over HTTP)

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

Fetch recursively referenced schemas over HTTP, check that both the original and referenced schemas are valid, and then validate data.

data HTTPValidationFailure

Constructors

HVRequest HTTPFailure

HVSchema InvalidSchema

HVData Invalid

Instances

Show HTTPValidationFailure

Methods

showsPrec :: Int -> HTTPValidationFailure -> ShowS

show :: HTTPValidationFailure -> String

showList :: [HTTPValidationFailure] -> ShowS

data HTTPFailure

Constructors

HTTPParseFailure Text

HTTPRequestFailure HttpException

Instances

Show HTTPFailure

Methods

showsPrec :: Int -> HTTPFailure -> ShowS

show :: HTTPFailure -> String

showList :: [HTTPFailure] -> ShowS

type InvalidSchema = NonEmpty (Maybe Text, Failure)

A description of why a schema (or one of its reference) is itself invalid.

Nothing indicates the starting schema. Just indicates a referenced schema -- the contents of the Just is the schema's URI.

NOTE: 'HashMap (Maybe Text) Invalid' would be a nicer way of defining this, but then we lose the guarantee that there's at least one key.

One-step validation (getting references from the filesystem)

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

Fetch recursively referenced schemas from the filesystem, check that both the original and referenced schemas are valid, and then validate data.

data FilesystemValidationFailure

Constructors

FVRead FilesystemFailure

FVSchema InvalidSchema

FVData Invalid

Instances

Eq FilesystemValidationFailure

Methods

(==) :: FilesystemValidationFailure -> FilesystemValidationFailure -> Bool

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

Show FilesystemValidationFailure

Methods

showsPrec :: Int -> FilesystemValidationFailure -> ShowS

show :: FilesystemValidationFailure -> String

showList :: [FilesystemValidationFailure] -> ShowS

data FilesystemFailure

Constructors

FSParseFailure Text

FSReadFailure IOError

Instances

Eq FilesystemFailure

Methods

(==) :: FilesystemFailure -> FilesystemFailure -> Bool

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

Show FilesystemFailure

Methods

showsPrec :: Int -> FilesystemFailure -> ShowS

show :: FilesystemFailure -> String

showList :: [FilesystemFailure] -> ShowS

Validation failure

type Invalid = NonEmpty Failure

type Failure = Fail ValidatorChain

data Fail 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).

Because of this we make Fail a higher order type, so each validator can return a sum type describing only the failures that can occur in that validator (or '()' if that validator can only fail in one way).

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 Fail with that sum type as its type argument.

The slightly weird naming (Fail and Failure) is so that we can define a 'type Failure = Fail SchemaErrorType' for each of our schemas, and export it along with 'Fail(..)'. This way the users of the library only use Failure, not Fail.

Constructors

Failure

Fields

• _failureValidatorsCalled :: !err

  E.g. Items UniqueItems during draft 4 validation.

• _failureFinalValidator :: !Value

  The value of the validator that raised the error (e.g. the value of "uniqueItems" in the above example.

• _failureOffendingPointer :: !Pointer

  A pointer to the part of the data that caused invalidation.

• _failureOffendingData :: !Value

  The part of the data that caused invalidation. Usually this is identical to the result of resolving _invalidOffendingPointer against the starting data, but not always (e.g. in the case of additionalItems where _invalidOffendingData will be the items in the array that were not allowed, instead of the entire array).

Instances

Functor Fail

Methods

fmap :: (a -> b) -> Fail a -> Fail b

(<$) :: a -> Fail b -> Fail a

Eq err => Eq (Fail err)

Methods

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

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

Show err => Show (Fail err)

Methods

showsPrec :: Int -> Fail err -> ShowS

show :: Fail err -> String

showList :: [Fail err] -> ShowS

data ValidatorChain

Distinguish all the different possible causes of failure for Draft 4 validation.

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.

RefLoop

Ref ValidatorChain

Enum

TypeValidator

AllOf ValidatorChain

AnyOf ValidatorChain

OneOfTooManySuccesses

OneOfNoSuccesses ValidatorChain

NotValidator

Instances

Eq ValidatorChain

Methods

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

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

Show ValidatorChain

Methods

showsPrec :: Int -> ValidatorChain -> ShowS

show :: ValidatorChain -> String

showList :: [ValidatorChain] -> ShowS

Fetching tools

data ReferencedSchemas schema

Constructors

ReferencedSchemas

Fields

• _rsStarting :: !schema

  Used to resolve relative references when we don't know what the scope of the current schema is. This only happens with starting schemas because if we're using a remote schema we had to know its URI in order to fetch it.

  Tracking the starting schema (instead of just resolving the reference to the current schema being used for validation) is necessary for cases where schemas are embedded inside one another. For instance in this case not distinguishing the starting and "foo" schemas sends the code into an infinite loop:

  { "additionalProperties": false, "properties": { "foo": { "$ref": "#" } } }

• _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

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

Fetch the schemas recursively referenced by a starting schema over HTTP.

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

Fetch the schemas recursively referenced by a starting schema from the filesystem.

Other Draft 4 things exported just in case

metaSchema :: Schema

metaSchemaBytes :: ByteString

schemaValidity :: Schema -> [Failure]

Check that a schema itself is valid (if so the returned list will be empty).

referencesValidity

Arguments

:: URISchemaMap Schema

-> [(Text, Failure)]

The first value in the tuple is the URI of a referenced schema.

Check that a set of referenced schemas are valid (if so the returned list will be empty).

checkSchema :: URISchemaMap Schema -> SchemaWithURI Schema -> Either InvalidSchema (Value -> [Failure])

A helper function.

Checks if a schema and a set of referenced schemas are valid.

Return a function to validate data.

draft4FetchInfo :: FetchInfo Schema

An instance of FetchInfo specialized for JSON Schema Draft 4.