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.

  TODO: This field is the source of most of the complication in this module and needs to be removed. It should be doable, though it will involve some modification to the fetching code.

• _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 (Set Text)
• _schemaDependencies :: Maybe (HashMap Text (Dependency Schema))
• _schemaProperties :: Maybe (HashMap Text Schema)
• _schemaPatternProperties :: Maybe (HashMap Text Schema)
• _schemaAdditionalProperties :: Maybe (AdditionalProperties Schema)
• _schemaEnum :: Maybe (NonEmpty Value)
• _schemaType :: Maybe TypeValidator
• _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

toJSONList :: [Schema] -> Value

toEncodingList :: [Schema] -> Encoding

FromJSON Schema

Methods

parseJSON :: Value -> Parser Schema

parseJSONList :: 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, then validate then data.

data HTTPValidationFailure

Constructors

HVRequest HTTPFailure

HVSchema SchemaInvalid

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

newtype SchemaInvalid

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.

Constructors

SchemaInvalid

Fields

• _unSchemaInvalid :: NonEmpty (Maybe Text, NonEmpty ValidatorFailure)

Instances

Eq SchemaInvalid

Methods

(==) :: SchemaInvalid -> SchemaInvalid -> Bool

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

Show SchemaInvalid

Methods

showsPrec :: Int -> SchemaInvalid -> ShowS

show :: SchemaInvalid -> String

showList :: [SchemaInvalid] -> ShowS

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, then validate the data.

data FilesystemValidationFailure

Constructors

FVRead FilesystemFailure

FVSchema SchemaInvalid

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 IOException

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

data Invalid

Used to report an entire instance being invalidated, as opposed to the failure of a single validator.

Constructors

Invalid

Fields

• _invalidSchema :: Schema
• _invalidInstance :: Value
• _invalidFailures :: NonEmpty ValidatorFailure

Instances

Eq Invalid

Methods

(==) :: Invalid -> Invalid -> Bool

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

Show Invalid

Methods

showsPrec :: Int -> Invalid -> ShowS

show :: Invalid -> String

showList :: [Invalid] -> ShowS

data ValidatorFailure

Constructors

FailureMultipleOf MultipleOfInvalid

FailureMaximum MaximumInvalid

FailureMinimum MinimumInvalid

FailureMaxLength MaxLengthInvalid

FailureMinLength MinLengthInvalid

FailurePattern PatternInvalid

FailureMaxItems MaxItemsInvalid

FailureMinItems MinItemsInvalid

FailureUniqueItems UniqueItemsInvalid

FailureItems (ItemsInvalid ValidatorFailure)

FailureAdditionalItems (AdditionalItemsInvalid ValidatorFailure)

FailureMaxProperties MaxPropertiesInvalid

FailureMinProperties MinPropertiesInvalid

FailureRequired RequiredInvalid

FailureDependencies (DependenciesInvalid ValidatorFailure)

FailurePropertiesRelated (PropertiesRelatedInvalid ValidatorFailure)

FailureRef (RefInvalid ValidatorFailure)

FailureEnum EnumInvalid

FailureType TypeValidatorInvalid

FailureAllOf (AllOfInvalid ValidatorFailure)

FailureAnyOf (AnyOfInvalid ValidatorFailure)

FailureOneOf (OneOfInvalid ValidatorFailure)

FailureNot NotValidatorInvalid

Instances

Eq ValidatorFailure

Methods

(==) :: ValidatorFailure -> ValidatorFailure -> Bool

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

Show ValidatorFailure

Methods

showsPrec :: Int -> ValidatorFailure -> ShowS

show :: ValidatorFailure -> String

showList :: [ValidatorFailure] -> 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 :: !(HashMap Text schema)

  Map of URIs to schemas.

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

newtype URISchemaMap schema

Keys are URIs (without URI fragments).

Constructors

URISchemaMap

Fields

• _unURISchemaMap :: HashMap Text schema

Instances

Eq schema => Eq (URISchemaMap schema)

Methods

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

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

Show schema => Show (URISchemaMap schema)

Methods

showsPrec :: Int -> URISchemaMap schema -> ShowS

show :: URISchemaMap schema -> String

showList :: [URISchemaMap 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 -> [ValidatorFailure]

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

referencesValidity

Arguments

:: URISchemaMap Schema

-> [(Text, NonEmpty ValidatorFailure)]

The first item of the tuple is the URI of a schema, the second is that schema's validation errors.

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

checkSchema :: URISchemaMap Schema -> SchemaWithURI Schema -> Either SchemaInvalid (Value -> [ValidatorFailure])

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.