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

Show Schema

Arbitrary Schema

ToJSON Schema

FromJSON Schema

emptySchema :: Schema

One-step validation

data HTTPValidationFailure

Constructors

HVRequest HTTPFailure

HVSchema (NonEmpty Invalid)

HVData (NonEmpty Invalid)

Instances

Show HTTPValidationFailure

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

data FilesystemValidationFailure

Constructors

FVRead FilesystemFailure

FVSchema (NonEmpty Invalid)

FVData (NonEmpty Invalid)

Instances

Show FilesystemValidationFailure

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)

Show schema => Show (SchemaWithURI schema)

data ReferencedSchemas schema

Constructors

ReferencedSchemas

Fields

_rsStarting :: !schema

Used to resolve relative references.

_rsSchemaMap :: !(URISchemaMap schema)

Instances

Eq schema => Eq (ReferencedSchemas schema)

Show schema => Show (ReferencedSchemas schema)

data HTTPFailure

Constructors

HTTPParseFailure Text

HTTPRequestFailure HttpException

Instances

Show HTTPFailure

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

data FilesystemFailure

Constructors

FSParseFailure Text

FSReadFailure IOError

Instances

Show FilesystemFailure

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)

Show err => Show (Failure err)

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

Show ValidatorChain

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