Data.OpenApi.Internal.Schema

Documentation

unnamed :: Schema -> NamedSchema

named :: Text -> Schema -> NamedSchema

plain :: Schema -> Declare (Definitions Schema) NamedSchema

unname :: NamedSchema -> NamedSchema

rename :: Maybe Text -> NamedSchema -> NamedSchema

>>> import Data.Aeson.Types (toJSONKeyText)
>>> import qualified Data.ByteString.Lazy.Char8 as BSL
>>> import Data.OpenApi.Internal
>>> import Data.OpenApi.Internal.Utils (encodePretty)
>>> import Data.OpenApi.Lens (name, schema)

class Typeable a => ToSchema a where

Convert a type into Schema.

An example type and instance:

{-# LANGUAGE OverloadedStrings #-}   -- allows to write Text literals
{-# LANGUAGE OverloadedLists #-}     -- allows to write Map and HashMap as lists

import Control.Lens
import Data.Proxy
import Data.OpenApi

data Coord = Coord { x :: Double, y :: Double }

instance ToSchema Coord where
  declareNamedSchema _ = do
    doubleSchema <- declareSchemaRef (Proxy :: Proxy Double)
    return $ NamedSchema (Just "Coord") $ mempty
      & type_ ?~ OpenApiObject
      & properties .~
          [ ("x", doubleSchema)
          , ("y", doubleSchema)
          ]
      & required .~ [ "x", "y" ]

Instead of manually writing your ToSchema instance you can use a default generic implementation of declareNamedSchema.

To do that, simply add deriving Generic clause to your datatype and declare a ToSchema instance for your datatype without giving definition for declareNamedSchema.

For instance, the previous example can be simplified into this:

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics (Generic)

data Coord = Coord { x :: Double, y :: Double } deriving Generic

instance ToSchema Coord

Minimal complete definition

Nothing

Methods

declareNamedSchema :: Proxy a -> Declare (Definitions Schema) NamedSchema

Convert a type into an optionally named schema together with all used definitions. Note that the schema itself is included in definitions only if it is recursive (and thus needs its definition in scope).

default declareNamedSchema :: (Generic a, GToSchema (Rep a)) => Proxy a -> Declare (Definitions Schema) NamedSchema

Instances

ToSchema Object

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Object -> Declare (Definitions Schema) NamedSchema

ToSchema All

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy All -> Declare (Definitions Schema) NamedSchema

ToSchema Any

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Any -> Declare (Definitions Schema) NamedSchema

ToSchema Version

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Version -> Declare (Definitions Schema) NamedSchema

ToSchema Int16

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Int16 -> Declare (Definitions Schema) NamedSchema

ToSchema Int32

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Int32 -> Declare (Definitions Schema) NamedSchema

ToSchema Int64

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Int64 -> Declare (Definitions Schema) NamedSchema

ToSchema Int8

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Int8 -> Declare (Definitions Schema) NamedSchema

ToSchema Word16

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Word16 -> Declare (Definitions Schema) NamedSchema

ToSchema Word32

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Word32 -> Declare (Definitions Schema) NamedSchema

ToSchema Word64

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Word64 -> Declare (Definitions Schema) NamedSchema

ToSchema Word8

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Word8 -> Declare (Definitions Schema) NamedSchema

(ToSchemaByteStringError ByteString :: Constraint) => ToSchema ByteString

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy ByteString -> Declare (Definitions Schema) NamedSchema

(ToSchemaByteStringError ByteString :: Constraint) => ToSchema ByteString

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy ByteString -> Declare (Definitions Schema) NamedSchema

ToSchema IntSet

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy IntSet -> Declare (Definitions Schema) NamedSchema

ToSchema Scientific

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Scientific -> Declare (Definitions Schema) NamedSchema

ToSchema Text

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Text -> Declare (Definitions Schema) NamedSchema

ToSchema Text

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Text -> Declare (Definitions Schema) NamedSchema

ToSchema Day

Format "date" corresponds to yyyy-mm-dd format.

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Day -> Declare (Definitions Schema) NamedSchema

ToSchema NominalDiffTime

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy NominalDiffTime -> Declare (Definitions Schema) NamedSchema

ToSchema UTCTime

>>> toSchema (Proxy :: Proxy UTCTime) ^. format
Just "yyyy-mm-ddThh:MM:ssZ"

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy UTCTime -> Declare (Definitions Schema) NamedSchema

ToSchema LocalTime

>>> toSchema (Proxy :: Proxy LocalTime) ^. format
Just "yyyy-mm-ddThh:MM:ss"

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy LocalTime -> Declare (Definitions Schema) NamedSchema

ToSchema TimeOfDay

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy TimeOfDay -> Declare (Definitions Schema) NamedSchema

ToSchema ZonedTime

Format "date-time" corresponds to yyyy-mm-ddThh:MM:ss(Z|+hh:MM) format.

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy ZonedTime -> Declare (Definitions Schema) NamedSchema

ToSchema UUID

For ToJSON instance, see uuid-aeson package.

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy UUID -> Declare (Definitions Schema) NamedSchema

ToSchema String

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy String -> Declare (Definitions Schema) NamedSchema

ToSchema Integer

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Integer -> Declare (Definitions Schema) NamedSchema

ToSchema Natural

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Natural -> Declare (Definitions Schema) NamedSchema

ToSchema ()

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy () -> Declare (Definitions Schema) NamedSchema

ToSchema Bool

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Bool -> Declare (Definitions Schema) NamedSchema

ToSchema Char

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Char -> Declare (Definitions Schema) NamedSchema

ToSchema Double

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Double -> Declare (Definitions Schema) NamedSchema

ToSchema Float

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Float -> Declare (Definitions Schema) NamedSchema

ToSchema Int

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Int -> Declare (Definitions Schema) NamedSchema

ToSchema Word

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy Word -> Declare (Definitions Schema) NamedSchema

ToSchema a => ToSchema (Identity a)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (Identity a) -> Declare (Definitions Schema) NamedSchema

ToSchema a => ToSchema (First a)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (First a) -> Declare (Definitions Schema) NamedSchema

ToSchema a => ToSchema (Last a)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (Last a) -> Declare (Definitions Schema) NamedSchema

ToSchema a => ToSchema (Dual a)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (Dual a) -> Declare (Definitions Schema) NamedSchema

ToSchema a => ToSchema (Product a)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (Product a) -> Declare (Definitions Schema) NamedSchema

ToSchema a => ToSchema (Sum a)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (Sum a) -> Declare (Definitions Schema) NamedSchema

ToSchema a => ToSchema (IntMap a)

NOTE: This schema does not account for the uniqueness of keys.

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (IntMap a) -> Declare (Definitions Schema) NamedSchema

ToSchema a => ToSchema (Set a)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (Set a) -> Declare (Definitions Schema) NamedSchema

ToSchema a => ToSchema (HashSet a)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (HashSet a) -> Declare (Definitions Schema) NamedSchema

ToSchema a => ToSchema (Vector a)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (Vector a) -> Declare (Definitions Schema) NamedSchema

ToSchema a => ToSchema (Vector a)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (Vector a) -> Declare (Definitions Schema) NamedSchema

ToSchema a => ToSchema (Vector a)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (Vector a) -> Declare (Definitions Schema) NamedSchema

ToSchema a => ToSchema (Vector a)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (Vector a) -> Declare (Definitions Schema) NamedSchema

ToSchema a => ToSchema (NonEmpty a)

Since: 2.2.1

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (NonEmpty a) -> Declare (Definitions Schema) NamedSchema

ToSchema a => ToSchema (Maybe a)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (Maybe a) -> Declare (Definitions Schema) NamedSchema

ToSchema a => ToSchema [a]

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy [a] -> Declare (Definitions Schema) NamedSchema

(ToSchema a, ToSchema b) => ToSchema (Either a b)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (Either a b) -> Declare (Definitions Schema) NamedSchema

(Typeable (Fixed a), HasResolution a) => ToSchema (Fixed a)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (Fixed a) -> Declare (Definitions Schema) NamedSchema

(ToJSONKey k, ToSchema k, ToSchema v) => ToSchema (Map k v)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (Map k v) -> Declare (Definitions Schema) NamedSchema

(ToJSONKey k, ToSchema k, ToSchema v) => ToSchema (HashMap k v)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (HashMap k v) -> Declare (Definitions Schema) NamedSchema

(ToSchema a, ToSchema b) => ToSchema (a, b)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (a, b) -> Declare (Definitions Schema) NamedSchema

(ToSchema a, ToSchema b, ToSchema c) => ToSchema (a, b, c)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (a, b, c) -> Declare (Definitions Schema) NamedSchema

(ToSchema a, ToSchema b, ToSchema c, ToSchema d) => ToSchema (a, b, c, d)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (a, b, c, d) -> Declare (Definitions Schema) NamedSchema

(ToSchema a, ToSchema b, ToSchema c, ToSchema d, ToSchema e) => ToSchema (a, b, c, d, e)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (a, b, c, d, e) -> Declare (Definitions Schema) NamedSchema

(ToSchema a, ToSchema b, ToSchema c, ToSchema d, ToSchema e, ToSchema f) => ToSchema (a, b, c, d, e, f)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (a, b, c, d, e, f) -> Declare (Definitions Schema) NamedSchema

(ToSchema a, ToSchema b, ToSchema c, ToSchema d, ToSchema e, ToSchema f, ToSchema g) => ToSchema (a, b, c, d, e, f, g)

Defined in Data.OpenApi.Internal.Schema

Methods

declareNamedSchema :: Proxy (a, b, c, d, e, f, g) -> Declare (Definitions Schema) NamedSchema

declareSchema :: ToSchema a => Proxy a -> Declare (Definitions Schema) Schema

Convert a type into a schema and declare all used schema definitions.

toNamedSchema :: ToSchema a => Proxy a -> NamedSchema

Convert a type into an optionally named schema.

>>> toNamedSchema (Proxy :: Proxy String) ^. name
Nothing
>>> BSL.putStrLn $ encodePretty (toNamedSchema (Proxy :: Proxy String) ^. schema)
{
    "type": "string"
}

>>> toNamedSchema (Proxy :: Proxy Day) ^. name
Just "Day"
>>> BSL.putStrLn $ encodePretty (toNamedSchema (Proxy :: Proxy Day) ^. schema)
{
    "example": "2016-07-22",
    "format": "date",
    "type": "string"
}

schemaName :: ToSchema a => Proxy a -> Maybe Text

Get type's schema name according to its ToSchema instance.

>>> schemaName (Proxy :: Proxy Int)
Nothing

>>> schemaName (Proxy :: Proxy UTCTime)
Just "UTCTime"

toSchema :: ToSchema a => Proxy a -> Schema

Convert a type into a schema.

>>> BSL.putStrLn $ encodePretty $ toSchema (Proxy :: Proxy Int8)
{
    "maximum": 127,
    "minimum": -128,
    "type": "integer"
}

>>> BSL.putStrLn $ encodePretty $ toSchema (Proxy :: Proxy [Day])
{
    "items": {
        "$ref": "#/components/schemas/Day"
    },
    "type": "array"
}

toSchemaRef :: ToSchema a => Proxy a -> Referenced Schema

Convert a type into a referenced schema if possible. Only named schemas can be referenced, nameless schemas are inlined.

>>> BSL.putStrLn $ encodePretty $ toSchemaRef (Proxy :: Proxy Integer)
{
    "type": "integer"
}

>>> BSL.putStrLn $ encodePretty $ toSchemaRef (Proxy :: Proxy Day)
{
    "$ref": "#/components/schemas/Day"
}

declareSchemaRef :: ToSchema a => Proxy a -> Declare (Definitions Schema) (Referenced Schema)

Convert a type into a referenced schema if possible and declare all used schema definitions. Only named schemas can be referenced, nameless schemas are inlined.

Schema definitions are typically declared for every referenced schema. If declareSchemaRef returns a reference, a corresponding schema will be declared (regardless of whether it is recusive or not).

inlineSchemasWhen :: Data s => (Text -> Bool) -> Definitions Schema -> s -> s

Inline any referenced schema if its name satisfies given predicate.

NOTE: if a referenced schema is not found in definitions the predicate is ignored and schema stays referenced.

WARNING: inlineSchemasWhen will produce infinite schemas when inlining recursive schemas.

inlineSchemas :: Data s => [Text] -> Definitions Schema -> s -> s

Inline any referenced schema if its name is in the given list.

NOTE: if a referenced schema is not found in definitions it stays referenced even if it appears in the list of names.

WARNING: inlineSchemas will produce infinite schemas when inlining recursive schemas.

inlineAllSchemas :: Data s => Definitions Schema -> s -> s

Inline all schema references for which the definition can be found in Definitions.

WARNING: inlineAllSchemas will produce infinite schemas when inlining recursive schemas.

toInlinedSchema :: ToSchema a => Proxy a -> Schema

Convert a type into a schema without references.

>>> BSL.putStrLn $ encodePretty $ toInlinedSchema (Proxy :: Proxy [Day])
{
    "items": {
        "example": "2016-07-22",
        "format": "date",
        "type": "string"
    },
    "type": "array"
}

WARNING: toInlinedSchema will produce infinite schema when inlining recursive schemas.

inlineNonRecursiveSchemas :: Data s => Definitions Schema -> s -> s

Inline all non-recursive schemas for which the definition can be found in Definitions.

sketchSchema :: ToJSON a => a -> Schema

Make an unrestrictive sketch of a Schema based on a ToJSON instance. Produced schema can be used for further refinement.

>>> BSL.putStrLn $ encodePretty $ sketchSchema "hello"
{
    "example": "hello",
    "type": "string"
}

>>> BSL.putStrLn $ encodePretty $ sketchSchema (1, 2, 3)
{
    "example": [
        1,
        2,
        3
    ],
    "items": {
        "type": "number"
    },
    "type": "array"
}

>>> BSL.putStrLn $ encodePretty $ sketchSchema ("Jack", 25)
{
    "example": [
        "Jack",
        25
    ],
    "items": [
        {
            "type": "string"
        },
        {
            "type": "number"
        }
    ],
    "type": "array"
}

>>> data Person = Person { name :: String, age :: Int } deriving (Generic)
>>> instance ToJSON Person
>>> BSL.putStrLn $ encodePretty $ sketchSchema (Person "Jack" 25)
{
    "example": {
        "age": 25,
        "name": "Jack"
    },
    "properties": {
        "age": {
            "type": "number"
        },
        "name": {
            "type": "string"
        }
    },
    "required": [
        "age",
        "name"
    ],
    "type": "object"
}

sketchStrictSchema :: ToJSON a => a -> Schema

Make a restrictive sketch of a Schema based on a ToJSON instance. Produced schema uses as much constraints as possible.

>>> BSL.putStrLn $ encodePretty $ sketchStrictSchema "hello"
{
    "enum": [
        "hello"
    ],
    "maxLength": 5,
    "minLength": 5,
    "pattern": "hello",
    "type": "string"
}

>>> BSL.putStrLn $ encodePretty $ sketchStrictSchema (1, 2, 3)
{
    "enum": [
        [
            1,
            2,
            3
        ]
    ],
    "items": [
        {
            "enum": [
                1
            ],
            "maximum": 1,
            "minimum": 1,
            "multipleOf": 1,
            "type": "number"
        },
        {
            "enum": [
                2
            ],
            "maximum": 2,
            "minimum": 2,
            "multipleOf": 2,
            "type": "number"
        },
        {
            "enum": [
                3
            ],
            "maximum": 3,
            "minimum": 3,
            "multipleOf": 3,
            "type": "number"
        }
    ],
    "maxItems": 3,
    "minItems": 3,
    "type": "array",
    "uniqueItems": true
}

>>> BSL.putStrLn $ encodePretty $ sketchStrictSchema ("Jack", 25)
{
    "enum": [
        [
            "Jack",
            25
        ]
    ],
    "items": [
        {
            "enum": [
                "Jack"
            ],
            "maxLength": 4,
            "minLength": 4,
            "pattern": "Jack",
            "type": "string"
        },
        {
            "enum": [
                25
            ],
            "maximum": 25,
            "minimum": 25,
            "multipleOf": 25,
            "type": "number"
        }
    ],
    "maxItems": 2,
    "minItems": 2,
    "type": "array",
    "uniqueItems": true
}

>>> data Person = Person { name :: String, age :: Int } deriving (Generic)
>>> instance ToJSON Person
>>> BSL.putStrLn $ encodePretty $ sketchStrictSchema (Person "Jack" 25)
{
    "enum": [
        {
            "age": 25,
            "name": "Jack"
        }
    ],
    "maxProperties": 2,
    "minProperties": 2,
    "properties": {
        "age": {
            "enum": [
                25
            ],
            "maximum": 25,
            "minimum": 25,
            "multipleOf": 25,
            "type": "number"
        },
        "name": {
            "enum": [
                "Jack"
            ],
            "maxLength": 4,
            "minLength": 4,
            "pattern": "Jack",
            "type": "string"
        }
    },
    "required": [
        "age",
        "name"
    ],
    "type": "object"
}

class GToSchema (f :: * -> *) where

Methods

gdeclareNamedSchema :: SchemaOptions -> Proxy f -> Schema -> Declare (Definitions Schema) NamedSchema

Instances

(GToSchema f, GToSchema g) => GToSchema (f :*: g)

Defined in Data.OpenApi.Internal.Schema

Methods

gdeclareNamedSchema :: SchemaOptions -> Proxy (f :*: g) -> Schema -> Declare (Definitions Schema) NamedSchema

(GSumToSchema f, GSumToSchema g) => GToSchema (f :+: g)

Defined in Data.OpenApi.Internal.Schema

Methods

gdeclareNamedSchema :: SchemaOptions -> Proxy (f :+: g) -> Schema -> Declare (Definitions Schema) NamedSchema

(Selector s, GToSchema f, GToSchema (S1 s f)) => GToSchema (C1 c (S1 s f))

Single field constructor.

Defined in Data.OpenApi.Internal.Schema

Methods

gdeclareNamedSchema :: SchemaOptions -> Proxy (C1 c (S1 s f)) -> Schema -> Declare (Definitions Schema) NamedSchema

Constructor c => GToSchema (C1 c (U1 :: Type -> Type))

Defined in Data.OpenApi.Internal.Schema

Methods

gdeclareNamedSchema :: SchemaOptions -> Proxy (C1 c U1) -> Schema -> Declare (Definitions Schema) NamedSchema

GToSchema f => GToSchema (C1 c f)

Defined in Data.OpenApi.Internal.Schema

Methods

gdeclareNamedSchema :: SchemaOptions -> Proxy (C1 c f) -> Schema -> Declare (Definitions Schema) NamedSchema

(Datatype d, GToSchema f) => GToSchema (D1 d f)

Defined in Data.OpenApi.Internal.Schema

Methods

gdeclareNamedSchema :: SchemaOptions -> Proxy (D1 d f) -> Schema -> Declare (Definitions Schema) NamedSchema

ToSchema c => GToSchema (K1 i (Maybe c) :: Type -> Type)

Defined in Data.OpenApi.Internal.Schema

Methods

gdeclareNamedSchema :: SchemaOptions -> Proxy (K1 i (Maybe c)) -> Schema -> Declare (Definitions Schema) NamedSchema

ToSchema c => GToSchema (K1 i c :: Type -> Type)

Defined in Data.OpenApi.Internal.Schema

Methods

gdeclareNamedSchema :: SchemaOptions -> Proxy (K1 i c) -> Schema -> Declare (Definitions Schema) NamedSchema

(Selector s, ToSchema c) => GToSchema (S1 s (K1 i (Maybe c) :: Type -> Type))

Optional record fields.

Defined in Data.OpenApi.Internal.Schema

Methods

gdeclareNamedSchema :: SchemaOptions -> Proxy (S1 s (K1 i (Maybe c))) -> Schema -> Declare (Definitions Schema) NamedSchema

(Selector s, GToSchema f) => GToSchema (S1 s f)

Record fields.

Defined in Data.OpenApi.Internal.Schema

Methods

gdeclareNamedSchema :: SchemaOptions -> Proxy (S1 s f) -> Schema -> Declare (Definitions Schema) NamedSchema

timeSchema :: Text -> Schema

type family ToSchemaByteStringError bs where ...

Equations

ToSchemaByteStringError bs = TypeError ((((Text "Impossible to have an instance " :<>: ShowType (ToSchema bs)) :<>: Text ".") :$$: ((Text "Please, use a newtype wrapper around " :<>: ShowType bs) :<>: Text " instead.")) :$$: Text "Consider using byteSchema or binarySchema templates.")

toSchemaBoundedIntegral :: forall a. (Bounded a, Integral a) => Proxy a -> Schema

Default schema for Bounded, Integral types.

>>> BSL.putStrLn $ encodePretty $ toSchemaBoundedIntegral (Proxy :: Proxy Int16)
{
    "maximum": 32767,
    "minimum": -32768,
    "type": "integer"
}

genericToNamedSchemaBoundedIntegral :: forall a d f. (Bounded a, Integral a, Generic a, Rep a ~ D1 d f, Datatype d) => SchemaOptions -> Proxy a -> NamedSchema

Default generic named schema for Bounded, Integral types.

genericDeclareNamedSchemaNewtype

Arguments

:: forall a d c s i inner. (Generic a, Datatype d, Rep a ~ D1 d (C1 c (S1 s (K1 i inner))))

=> SchemaOptions

How to derive the name.

-> (Proxy inner -> Declare (Definitions Schema) Schema)

How to create a schema for the wrapped type.

-> Proxy a

-> Declare (Definitions Schema) NamedSchema

Declare a named schema for a newtype wrapper.

declareSchemaBoundedEnumKeyMapping :: forall map key value. (Bounded key, Enum key, ToJSONKey key, ToSchema key, ToSchema value) => Proxy (map key value) -> Declare (Definitions Schema) Schema

Declare Schema for a mapping with Bounded Enum keys. This makes a much more useful schema when there aren't many options for key values.

>>> data ButtonState = Neutral | Focus | Active | Hover | Disabled deriving (Show, Bounded, Enum, Generic)
>>> instance ToJSON ButtonState
>>> instance ToSchema ButtonState
>>> instance ToJSONKey ButtonState where toJSONKey = toJSONKeyText (T.pack . show)
>>> type ImageUrl = T.Text
>>> BSL.putStrLn $ encodePretty $ toSchemaBoundedEnumKeyMapping (Proxy :: Proxy (Map ButtonState ImageUrl))
{
    "properties": {
        "Active": {
            "type": "string"
        },
        "Disabled": {
            "type": "string"
        },
        "Focus": {
            "type": "string"
        },
        "Hover": {
            "type": "string"
        },
        "Neutral": {
            "type": "string"
        }
    },
    "type": "object"
}

Note: this is only useful when key is encoded with ToJSONKeyText. If it is encoded with ToJSONKeyValue then a regular schema for [(key, value)] is used.

toSchemaBoundedEnumKeyMapping :: forall map key value. (Bounded key, Enum key, ToJSONKey key, ToSchema key, ToSchema value) => Proxy (map key value) -> Schema

A Schema for a mapping with Bounded Enum keys. This makes a much more useful schema when there aren't many options for key values.

>>> data ButtonState = Neutral | Focus | Active | Hover | Disabled deriving (Show, Bounded, Enum, Generic)
>>> instance ToJSON ButtonState
>>> instance ToSchema ButtonState
>>> instance ToJSONKey ButtonState where toJSONKey = toJSONKeyText (T.pack . show)
>>> type ImageUrl = T.Text
>>> BSL.putStrLn $ encodePretty $ toSchemaBoundedEnumKeyMapping (Proxy :: Proxy (Map ButtonState ImageUrl))
{
    "properties": {
        "Active": {
            "type": "string"
        },
        "Disabled": {
            "type": "string"
        },
        "Focus": {
            "type": "string"
        },
        "Hover": {
            "type": "string"
        },
        "Neutral": {
            "type": "string"
        }
    },
    "type": "object"
}

Note: this is only useful when key is encoded with ToJSONKeyText. If it is encoded with ToJSONKeyValue then a regular schema for [(key, value)] is used.

genericDeclareSchema :: (Generic a, GToSchema (Rep a), Typeable a) => SchemaOptions -> Proxy a -> Declare (Definitions Schema) Schema

A configurable generic Schema creator.

genericDeclareNamedSchema :: forall a. (Generic a, GToSchema (Rep a), Typeable a) => SchemaOptions -> Proxy a -> Declare (Definitions Schema) NamedSchema

A configurable generic NamedSchema creator. This function applied to defaultSchemaOptions is used as the default for declareNamedSchema when the type is an instance of Generic.

Default implementation will use the name from Typeable instance, including concrete instantioations of type variables.

For example:

>>> _namedSchemaName $ undeclare $ genericDeclareNamedSchema defaultSchemaOptions (Proxy :: Proxy (Either Int Bool))
Just "Either_Int_Bool"

genericNameSchema :: forall a d f. (Generic a, Rep a ~ D1 d f, Datatype d) => SchemaOptions -> Proxy a -> Schema -> NamedSchema

Derive a Generic-based name for a datatype and assign it to a given Schema.

gdatatypeSchemaName :: forall d. Datatype d => SchemaOptions -> Proxy d -> Maybe Text

paramSchemaToNamedSchema :: (ToParamSchema a, Generic a, Rep a ~ D1 d f, Datatype d) => SchemaOptions -> Proxy a -> NamedSchema

Construct NamedSchema usinng ToParamSchema.

paramSchemaToSchema :: ToParamSchema a => Proxy a -> Schema

Construct Schema usinng ToParamSchema.

nullarySchema :: Schema

gtoNamedSchema :: GToSchema f => SchemaOptions -> Proxy f -> NamedSchema

gdeclareSchema :: GToSchema f => SchemaOptions -> Proxy f -> Declare (Definitions Schema) Schema

gdeclareSchemaRef :: GToSchema a => SchemaOptions -> Proxy a -> Declare (Definitions Schema) (Referenced Schema)

appendItem :: Referenced Schema -> Maybe OpenApiItems -> Maybe OpenApiItems

withFieldSchema :: forall proxy s f. (Selector s, GToSchema f) => SchemaOptions -> proxy s f -> Bool -> Schema -> Declare (Definitions Schema) Schema

gdeclareNamedSumSchema :: GSumToSchema f => SchemaOptions -> Proxy f -> Schema -> Declare (Definitions Schema) NamedSchema

type AllNullary = All

class GSumToSchema (f :: * -> *) where

Methods

gsumToSchema :: SchemaOptions -> Proxy f -> WriterT AllNullary (Declare (Definitions Schema)) [(Text, Referenced Schema)]

Instances

(GSumToSchema f, GSumToSchema g) => GSumToSchema (f :+: g)

Defined in Data.OpenApi.Internal.Schema

Methods

gsumToSchema :: SchemaOptions -> Proxy (f :+: g) -> WriterT AllNullary (Declare (Definitions Schema)) [(Text, Referenced Schema)]

(Constructor c, Selector s, GToSchema f) => GSumToSchema (C1 c (S1 s f))

Defined in Data.OpenApi.Internal.Schema

Methods

gsumToSchema :: SchemaOptions -> Proxy (C1 c (S1 s f)) -> WriterT AllNullary (Declare (Definitions Schema)) [(Text, Referenced Schema)]

Constructor c => GSumToSchema (C1 c (U1 :: Type -> Type))

Defined in Data.OpenApi.Internal.Schema

Methods

gsumToSchema :: SchemaOptions -> Proxy (C1 c U1) -> WriterT AllNullary (Declare (Definitions Schema)) [(Text, Referenced Schema)]

(Constructor c, GToSchema f) => GSumToSchema (C1 c f)

Defined in Data.OpenApi.Internal.Schema

Methods

gsumToSchema :: SchemaOptions -> Proxy (C1 c f) -> WriterT AllNullary (Declare (Definitions Schema)) [(Text, Referenced Schema)]

gsumConToSchemaWith :: forall c f. (GToSchema (C1 c f), Constructor c) => Maybe (Referenced Schema) -> SchemaOptions -> Proxy (C1 c f) -> (Text, Referenced Schema)

Convert one component of the sum to schema, to be later combined with oneOf.

gsumConToSchema :: (GToSchema (C1 c f), Constructor c) => SchemaOptions -> Proxy (C1 c f) -> Declare (Definitions Schema) [(Text, Referenced Schema)]

data Proxy2 a b

Constructors

Proxy2

data Proxy3 a b c

Constructors

Proxy3

>>> import Data.OpenApi
>>> import Data.Aeson (encode)
>>> import Data.Aeson.Types (toJSONKeyText)
>>> import Data.OpenApi.Internal.Utils
>>> :set -XScopedTypeVariables
>>> :set -XDeriveAnyClass
>>> :set -XStandaloneDeriving
>>> :set -XTypeApplications