Safe Haskell | None |
---|---|
Language | Haskell2010 |
- type NamedSchema = (Maybe Text, Schema)
- type Definitions = HashMap Text Schema
- unnamed :: Schema -> NamedSchema
- named :: Text -> Schema -> NamedSchema
- plain :: Schema -> Declare Definitions NamedSchema
- unname :: NamedSchema -> NamedSchema
- rename :: Maybe Text -> NamedSchema -> NamedSchema
- class ToSchema a where
- declareNamedSchema :: proxy a -> Declare Definitions NamedSchema
- declareSchema :: ToSchema a => proxy a -> Declare Definitions Schema
- toNamedSchema :: ToSchema a => proxy a -> NamedSchema
- schemaName :: ToSchema a => proxy a -> Maybe Text
- toSchema :: ToSchema a => proxy a -> Schema
- toSchemaRef :: ToSchema a => proxy a -> Referenced Schema
- declareSchemaRef :: ToSchema a => proxy a -> Declare Definitions (Referenced Schema)
- inlineSchemasWhen :: Data s => (Text -> Bool) -> Definitions -> s -> s
- inlineSchemas :: Data s => [Text] -> Definitions -> s -> s
- inlineAllSchemas :: Data s => Definitions -> s -> s
- toInlinedSchema :: ToSchema a => proxy a -> Schema
- inlineNonRecursiveSchemas :: Data s => Definitions -> s -> s
- class GToSchema f where
- gdeclareNamedSchema :: SchemaOptions -> proxy f -> Schema -> Declare Definitions NamedSchema
- timeSchema :: Text -> Schema
- toSchemaBoundedIntegral :: forall a proxy. (Bounded a, Integral a) => proxy a -> Schema
- genericToNamedSchemaBoundedIntegral :: forall a d f proxy. (Bounded a, Integral a, Generic a, Rep a ~ D1 d f, Datatype d) => SchemaOptions -> proxy a -> NamedSchema
- genericDeclareSchema :: (Generic a, GToSchema (Rep a)) => SchemaOptions -> proxy a -> Declare Definitions Schema
- genericDeclareNamedSchema :: forall a proxy. (Generic a, GToSchema (Rep a)) => SchemaOptions -> proxy a -> Declare Definitions NamedSchema
- gdatatypeSchemaName :: forall proxy d. Datatype d => SchemaOptions -> proxy d -> Maybe Text
- paramSchemaToNamedSchema :: forall a d f proxy. (ToParamSchema a, Generic a, Rep a ~ D1 d f, Datatype d) => SchemaOptions -> proxy a -> NamedSchema
- paramSchemaToSchema :: forall a proxy. ToParamSchema a => proxy a -> Schema
- nullarySchema :: Schema
- gtoNamedSchema :: GToSchema f => SchemaOptions -> proxy f -> NamedSchema
- gdeclareSchema :: GToSchema f => SchemaOptions -> proxy f -> Declare Definitions Schema
- gdeclareSchemaRef :: GToSchema a => SchemaOptions -> proxy a -> Declare Definitions (Referenced Schema)
- appendItem :: Referenced Schema -> Maybe (SwaggerItems Schema) -> Maybe (SwaggerItems Schema)
- withFieldSchema :: forall proxy s f. (Selector s, GToSchema f) => SchemaOptions -> proxy s f -> Bool -> Schema -> Declare Definitions Schema
- gdeclareNamedSumSchema :: GSumToSchema f => SchemaOptions -> proxy f -> Schema -> Declare Definitions NamedSchema
- type AllNullary = All
- class GSumToSchema f where
- gsumToSchema :: SchemaOptions -> proxy f -> Schema -> WriterT AllNullary (Declare Definitions) Schema
- gsumConToSchema :: forall c f proxy. (GToSchema (C1 c f), Constructor c) => SchemaOptions -> proxy (C1 c f) -> Schema -> Declare Definitions Schema
- data Proxy2 a b = Proxy2
- data Proxy3 a b c = Proxy3
Documentation
type NamedSchema = (Maybe Text, Schema) Source
A
with an optional name.
This name can be used in references.Schema
type Definitions = HashMap Text Schema Source
Schema definitions, a mapping from schema name to
.Schema
unnamed :: Schema -> NamedSchema Source
named :: Text -> Schema -> NamedSchema Source
unname :: NamedSchema -> NamedSchema Source
rename :: Maybe Text -> NamedSchema -> NamedSchema Source
Convert a type into
.Schema
An example type and instance:
{-# LANGUAGE OverloadedStrings #-} -- allows to writeText
literals {-# LANGUAGE OverloadedLists #-} -- allows to writeMap
andHashMap
as lists import Control.Lens data Coord = Coord { x :: Double, y :: Double } instance ToSchema Coord where declareNamedSchema = pure (Just "Coord", schema) where schema = mempty & schemaType .~ SwaggerObject & schemaProperties .~ [ ("x", toSchemaRef (Proxy :: Proxy Double)) , ("y", toSchemaRef (Proxy :: Proxy Double)) ] & schemaRequired .~ [ "x", "y" ]
Instead of manually writing your
instance you can
use a default generic implementation of ToSchema
.declareNamedSchema
To do that, simply add deriving
clause to your datatype
and declare a Generic
instance for your datatype without
giving definition for ToSchema
.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
Nothing
declareNamedSchema :: proxy a -> Declare Definitions NamedSchema Source
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).
declareSchema :: ToSchema a => proxy a -> Declare Definitions Schema Source
Convert a type into a schema and declare all used schema definitions.
toNamedSchema :: ToSchema a => proxy a -> NamedSchema Source
Convert a type into an optionally named schema.
>>>
encode <$> toNamedSchema (Proxy :: Proxy String)
(Nothing,"{\"type\":\"string\"}")
>>>
encode <$> toNamedSchema (Proxy :: Proxy Day)
(Just "Day","{\"format\":\"date\",\"type\":\"string\"}")
schemaName :: ToSchema a => proxy a -> Maybe Text Source
Get type's schema name according to its
instance.ToSchema
>>>
schemaName (Proxy :: Proxy Int)
Nothing
>>>
schemaName (Proxy :: Proxy UTCTime)
Just "UTCTime"
toSchema :: ToSchema a => proxy a -> Schema Source
Convert a type into a schema.
>>>
encode $ toSchema (Proxy :: Proxy Int8)
"{\"maximum\":127,\"minimum\":-128,\"type\":\"integer\"}"
>>>
encode $ toSchema (Proxy :: Proxy [Day])
"{\"items\":{\"$ref\":\"#/definitions/Day\"},\"type\":\"array\"}"
toSchemaRef :: ToSchema a => proxy a -> Referenced Schema Source
Convert a type into a referenced schema if possible. Only named schemas can be referenced, nameless schemas are inlined.
>>>
encode $ toSchemaRef (Proxy :: Proxy Integer)
"{\"type\":\"integer\"}"
>>>
encode $ toSchemaRef (Proxy :: Proxy Day)
"{\"$ref\":\"#/definitions/Day\"}"
declareSchemaRef :: ToSchema a => proxy a -> Declare Definitions (Referenced Schema) Source
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
returns a reference, a corresponding schema
will be declared (regardless of whether it is recusive or not).declareSchemaRef
inlineSchemasWhen :: Data s => (Text -> Bool) -> Definitions -> s -> s Source
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:
will produce infinite schemas
when inlining recursive schemas.inlineSchemasWhen
inlineSchemas :: Data s => [Text] -> Definitions -> s -> s Source
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:
will produce infinite schemas
when inlining recursive schemas.inlineSchemas
inlineAllSchemas :: Data s => Definitions -> s -> s Source
Inline all schema references for which the definition
can be found in
.Definitions
WARNING:
will produce infinite schemas
when inlining recursive schemas.inlineAllSchemas
toInlinedSchema :: ToSchema a => proxy a -> Schema Source
Convert a type into a schema without references.
>>>
encode $ toInlinedSchema (Proxy :: Proxy [Day])
"{\"items\":{\"format\":\"date\",\"type\":\"string\"},\"type\":\"array\"}"
WARNING:
will produce infinite schema
when inlining recursive schemas.toInlinedSchema
inlineNonRecursiveSchemas :: Data s => Definitions -> s -> s Source
Inline all non-recursive schemas for which the definition
can be found in
.Definitions
class GToSchema f where Source
gdeclareNamedSchema :: SchemaOptions -> proxy f -> Schema -> Declare Definitions NamedSchema Source
ToSchema c => GToSchema (K1 i c) Source | |
ToSchema c => GToSchema (K1 i (Maybe c)) Source | |
(GSumToSchema (* -> *) f, GSumToSchema (* -> *) g) => GToSchema ((:+:) f g) Source | |
(GToSchema f, GToSchema g) => GToSchema ((:*:) f g) Source | |
(Datatype d, GToSchema f) => GToSchema (D1 d f) Source | |
(Selector s, GToSchema f) => GToSchema (C1 c (S1 s f)) Source | Single field constructor. |
Constructor c => GToSchema (C1 c U1) Source | |
GToSchema f => GToSchema (C1 c f) Source | |
(Selector s, GToSchema f) => GToSchema (S1 s f) Source | Record fields. |
(Selector s, ToSchema c) => GToSchema (S1 s (K1 i (Maybe c))) Source | Optional record fields. |
timeSchema :: Text -> Schema Source
toSchemaBoundedIntegral :: forall a proxy. (Bounded a, Integral a) => proxy a -> Schema Source
genericToNamedSchemaBoundedIntegral :: forall a d f proxy. (Bounded a, Integral a, Generic a, Rep a ~ D1 d f, Datatype d) => SchemaOptions -> proxy a -> NamedSchema Source
genericDeclareSchema :: (Generic a, GToSchema (Rep a)) => SchemaOptions -> proxy a -> Declare Definitions Schema Source
A configurable generic
creator.Schema
genericDeclareNamedSchema :: forall a proxy. (Generic a, GToSchema (Rep a)) => SchemaOptions -> proxy a -> Declare Definitions NamedSchema Source
A configurable generic
creator.
This function applied to NamedSchema
is used as the default for defaultSchemaOptions
when the type is an instance of declareNamedSchema
.Generic
gdatatypeSchemaName :: forall proxy d. Datatype d => SchemaOptions -> proxy d -> Maybe Text Source
paramSchemaToNamedSchema :: forall a d f proxy. (ToParamSchema a, Generic a, Rep a ~ D1 d f, Datatype d) => SchemaOptions -> proxy a -> NamedSchema Source
Lift a plain
into a model ParamSchema
.NamedSchema
paramSchemaToSchema :: forall a proxy. ToParamSchema a => proxy a -> Schema Source
Lift a plain
into a model ParamSchema
.Schema
gtoNamedSchema :: GToSchema f => SchemaOptions -> proxy f -> NamedSchema Source
gdeclareSchema :: GToSchema f => SchemaOptions -> proxy f -> Declare Definitions Schema Source
gdeclareSchemaRef :: GToSchema a => SchemaOptions -> proxy a -> Declare Definitions (Referenced Schema) Source
appendItem :: Referenced Schema -> Maybe (SwaggerItems Schema) -> Maybe (SwaggerItems Schema) Source
withFieldSchema :: forall proxy s f. (Selector s, GToSchema f) => SchemaOptions -> proxy s f -> Bool -> Schema -> Declare Definitions Schema Source
gdeclareNamedSumSchema :: GSumToSchema f => SchemaOptions -> proxy f -> Schema -> Declare Definitions NamedSchema Source
type AllNullary = All Source
class GSumToSchema f where Source
gsumToSchema :: SchemaOptions -> proxy f -> Schema -> WriterT AllNullary (Declare Definitions) Schema Source
(GSumToSchema (* -> *) f, GSumToSchema (* -> *) g) => GSumToSchema (* -> *) ((:+:) f g) Source | |
Constructor c => GSumToSchema (* -> *) (C1 c U1) Source | |
(Constructor c, Selector s, GToSchema f) => GSumToSchema (* -> *) (C1 c (S1 s f)) Source | |
(Constructor c, GToSchema f) => GSumToSchema (* -> *) (C1 c f) Source |
gsumConToSchema :: forall c f proxy. (GToSchema (C1 c f), Constructor c) => SchemaOptions -> proxy (C1 c f) -> Schema -> Declare Definitions Schema Source