diff --git a/LICENSE b/LICENSE deleted file mode 100644 --- a/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -The MIT License (MIT) - -Copyright (c) 2015 Jon Schoning - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -76,6 +76,7 @@ | generateModelConstructors | Generate smart constructors (only supply required fields) for models | true | true | | modelDeriving | Additional classes to include in the deriving() clause of Models | | | | strictFields | Add strictness annotations to all model fields | true | true | +| useMonadLogger | Use the monad-logger package to provide logging (if instead false, use the katip logging package) | false | false | [1]: https://www.stackage.org/haddock/lts-9.0/iso8601-time-0.1.4/Data-Time-ISO8601.html#v:formatISO8601Millis @@ -115,6 +116,7 @@ | SwaggerPetstore.Model | describes models | | SwaggerPetstore.MimeTypes | encoding/decoding MIME types (content-types/accept) | | SwaggerPetstore.Lens | lenses for model fields | +| SwaggerPetstore.Logging | logging functions and utils | This library adds type safety around what swagger specifies as Produces and Consumes for each Operation (e.g. the list of MIME types an diff --git a/lib/SwaggerPetstore.hs b/lib/SwaggerPetstore.hs --- a/lib/SwaggerPetstore.hs +++ b/lib/SwaggerPetstore.hs @@ -8,6 +8,7 @@ , module SwaggerPetstore.Model , module SwaggerPetstore.MimeTypes , module SwaggerPetstore.Lens + , module SwaggerPetstore.Logging ) where import SwaggerPetstore.API @@ -15,3 +16,4 @@ import SwaggerPetstore.Model import SwaggerPetstore.MimeTypes import SwaggerPetstore.Lens +import SwaggerPetstore.Logging diff --git a/lib/SwaggerPetstore/API.hs b/lib/SwaggerPetstore/API.hs --- a/lib/SwaggerPetstore/API.hs +++ b/lib/SwaggerPetstore/API.hs @@ -22,14 +22,11 @@ import SwaggerPetstore.Lens import qualified Data.Aeson as A -import Data.Aeson (Value) import qualified Data.Time as TI -import Data.Time (UTCTime) import qualified Data.ByteString as B import qualified Data.ByteString.Lazy as BL -import Data.ByteString.Lazy (ByteString) import qualified Data.ByteString.Builder as BB import qualified Data.ByteString.Char8 as BC import qualified Data.ByteString.Lazy.Char8 as BCL @@ -45,6 +42,7 @@ import qualified Data.Data as P (Typeable) import qualified Data.Foldable as P import qualified Data.Map as Map +import qualified Data.Set as Set import qualified Data.Maybe as P import qualified Data.Proxy as P (Proxy(..)) import qualified Data.Text as T @@ -58,7 +56,6 @@ import Data.Monoid ((<>)) import Data.Function ((&)) -import Data.Set (Set) import Data.Text (Text) import GHC.Base ((<|>)) @@ -68,6 +65,352 @@ -- * Operations +-- ** AnotherFake + +-- *** testSpecialTags + +-- | @PATCH \/another-fake\/dummy@ +-- +-- To test special tags +-- +-- To test special tags +-- +testSpecialTags + :: (Consumes TestSpecialTags contentType, MimeRender contentType Client) + => contentType -- ^ request content-type ('MimeType') + -> Client -- ^ "body" - client model + -> SwaggerPetstoreRequest TestSpecialTags contentType Client +testSpecialTags _ body = + _mkRequest "PATCH" ["/another-fake/dummy"] + `setBodyParam` body + +data TestSpecialTags + +-- | /Body Param/ "body" - client model +instance HasBodyParam TestSpecialTags Client + +-- | @application/json@ +instance Consumes TestSpecialTags MimeJSON + +-- | @application/json@ +instance Produces TestSpecialTags MimeJSON + + +-- ** Fake + +-- *** fakeOuterBooleanSerialize + +-- | @POST \/fake\/outer\/boolean@ +-- +-- Test serialization of outer boolean types +-- +fakeOuterBooleanSerialize + :: (Consumes FakeOuterBooleanSerialize contentType) + => contentType -- ^ request content-type ('MimeType') + -> SwaggerPetstoreRequest FakeOuterBooleanSerialize contentType OuterBoolean +fakeOuterBooleanSerialize _ = + _mkRequest "POST" ["/fake/outer/boolean"] + +data FakeOuterBooleanSerialize + +-- | /Body Param/ "body" - Input boolean as post body +instance HasBodyParam FakeOuterBooleanSerialize OuterBoolean + +-- *** fakeOuterCompositeSerialize + +-- | @POST \/fake\/outer\/composite@ +-- +-- Test serialization of object with outer number type +-- +fakeOuterCompositeSerialize + :: (Consumes FakeOuterCompositeSerialize contentType) + => contentType -- ^ request content-type ('MimeType') + -> SwaggerPetstoreRequest FakeOuterCompositeSerialize contentType OuterComposite +fakeOuterCompositeSerialize _ = + _mkRequest "POST" ["/fake/outer/composite"] + +data FakeOuterCompositeSerialize + +-- | /Body Param/ "body" - Input composite as post body +instance HasBodyParam FakeOuterCompositeSerialize OuterComposite + +-- *** fakeOuterNumberSerialize + +-- | @POST \/fake\/outer\/number@ +-- +-- Test serialization of outer number types +-- +fakeOuterNumberSerialize + :: (Consumes FakeOuterNumberSerialize contentType) + => contentType -- ^ request content-type ('MimeType') + -> SwaggerPetstoreRequest FakeOuterNumberSerialize contentType OuterNumber +fakeOuterNumberSerialize _ = + _mkRequest "POST" ["/fake/outer/number"] + +data FakeOuterNumberSerialize + +-- | /Body Param/ "body" - Input number as post body +instance HasBodyParam FakeOuterNumberSerialize OuterNumber + +-- *** fakeOuterStringSerialize + +-- | @POST \/fake\/outer\/string@ +-- +-- Test serialization of outer string types +-- +fakeOuterStringSerialize + :: (Consumes FakeOuterStringSerialize contentType) + => contentType -- ^ request content-type ('MimeType') + -> SwaggerPetstoreRequest FakeOuterStringSerialize contentType OuterString +fakeOuterStringSerialize _ = + _mkRequest "POST" ["/fake/outer/string"] + +data FakeOuterStringSerialize + +-- | /Body Param/ "body" - Input string as post body +instance HasBodyParam FakeOuterStringSerialize OuterString + +-- *** testClientModel + +-- | @PATCH \/fake@ +-- +-- To test \"client\" model +-- +-- To test \"client\" model +-- +testClientModel + :: (Consumes TestClientModel contentType, MimeRender contentType Client) + => contentType -- ^ request content-type ('MimeType') + -> Client -- ^ "body" - client model + -> SwaggerPetstoreRequest TestClientModel contentType Client +testClientModel _ body = + _mkRequest "PATCH" ["/fake"] + `setBodyParam` body + +data TestClientModel + +-- | /Body Param/ "body" - client model +instance HasBodyParam TestClientModel Client + +-- | @application/json@ +instance Consumes TestClientModel MimeJSON + +-- | @application/json@ +instance Produces TestClientModel MimeJSON + + +-- *** testEndpointParameters + +-- | @POST \/fake@ +-- +-- Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 +-- +-- Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 +-- +-- AuthMethod: http_basic_test +-- +-- Note: Has 'Produces' instances, but no response schema +-- +testEndpointParameters + :: (Consumes TestEndpointParameters contentType) + => contentType -- ^ request content-type ('MimeType') + -> Double -- ^ "number" - None + -> Double -- ^ "double" - None + -> Text -- ^ "patternWithoutDelimiter" - None + -> ByteArray -- ^ "byte" - None + -> SwaggerPetstoreRequest TestEndpointParameters contentType res +testEndpointParameters _ number double patternWithoutDelimiter byte = + _mkRequest "POST" ["/fake"] + `_addForm` toForm ("number", number) + `_addForm` toForm ("double", double) + `_addForm` toForm ("pattern_without_delimiter", patternWithoutDelimiter) + `_addForm` toForm ("byte", byte) + +data TestEndpointParameters + +-- | /Optional Param/ "integer" - None +instance HasOptionalParam TestEndpointParameters ParamInteger where + applyOptionalParam req (ParamInteger xs) = + req `_addForm` toForm ("integer", xs) + +-- | /Optional Param/ "int32" - None +instance HasOptionalParam TestEndpointParameters Int32 where + applyOptionalParam req (Int32 xs) = + req `_addForm` toForm ("int32", xs) + +-- | /Optional Param/ "int64" - None +instance HasOptionalParam TestEndpointParameters Int64 where + applyOptionalParam req (Int64 xs) = + req `_addForm` toForm ("int64", xs) + +-- | /Optional Param/ "float" - None +instance HasOptionalParam TestEndpointParameters ParamFloat where + applyOptionalParam req (ParamFloat xs) = + req `_addForm` toForm ("float", xs) + +-- | /Optional Param/ "string" - None +instance HasOptionalParam TestEndpointParameters ParamString where + applyOptionalParam req (ParamString xs) = + req `_addForm` toForm ("string", xs) + +-- | /Optional Param/ "binary" - None +instance HasOptionalParam TestEndpointParameters ParamBinary where + applyOptionalParam req (ParamBinary xs) = + req `_addForm` toForm ("binary", xs) + +-- | /Optional Param/ "date" - None +instance HasOptionalParam TestEndpointParameters ParamDate where + applyOptionalParam req (ParamDate xs) = + req `_addForm` toForm ("date", xs) + +-- | /Optional Param/ "dateTime" - None +instance HasOptionalParam TestEndpointParameters ParamDateTime where + applyOptionalParam req (ParamDateTime xs) = + req `_addForm` toForm ("dateTime", xs) + +-- | /Optional Param/ "password" - None +instance HasOptionalParam TestEndpointParameters Password where + applyOptionalParam req (Password xs) = + req `_addForm` toForm ("password", xs) + +-- | /Optional Param/ "callback" - None +instance HasOptionalParam TestEndpointParameters Callback where + applyOptionalParam req (Callback xs) = + req `_addForm` toForm ("callback", xs) + +-- | @application/xml; charset=utf-8@ +instance Consumes TestEndpointParameters MimeXmlCharsetutf8 +-- | @application/json; charset=utf-8@ +instance Consumes TestEndpointParameters MimeJsonCharsetutf8 + +-- | @application/xml; charset=utf-8@ +instance Produces TestEndpointParameters MimeXmlCharsetutf8 +-- | @application/json; charset=utf-8@ +instance Produces TestEndpointParameters MimeJsonCharsetutf8 + + +-- *** testEnumParameters + +-- | @GET \/fake@ +-- +-- To test enum parameters +-- +-- To test enum parameters +-- +-- Note: Has 'Produces' instances, but no response schema +-- +testEnumParameters + :: (Consumes TestEnumParameters contentType) + => contentType -- ^ request content-type ('MimeType') + -> SwaggerPetstoreRequest TestEnumParameters contentType res +testEnumParameters _ = + _mkRequest "GET" ["/fake"] + +data TestEnumParameters + +-- | /Optional Param/ "enum_form_string_array" - Form parameter enum test (string array) +instance HasOptionalParam TestEnumParameters EnumFormStringArray where + applyOptionalParam req (EnumFormStringArray xs) = + req `_addForm` toFormColl CommaSeparated ("enum_form_string_array", xs) + +-- | /Optional Param/ "enum_form_string" - Form parameter enum test (string) +instance HasOptionalParam TestEnumParameters EnumFormString where + applyOptionalParam req (EnumFormString xs) = + req `_addForm` toForm ("enum_form_string", xs) + +-- | /Optional Param/ "enum_header_string_array" - Header parameter enum test (string array) +instance HasOptionalParam TestEnumParameters EnumHeaderStringArray where + applyOptionalParam req (EnumHeaderStringArray xs) = + req `setHeader` toHeaderColl CommaSeparated ("enum_header_string_array", xs) + +-- | /Optional Param/ "enum_header_string" - Header parameter enum test (string) +instance HasOptionalParam TestEnumParameters EnumHeaderString where + applyOptionalParam req (EnumHeaderString xs) = + req `setHeader` toHeader ("enum_header_string", xs) + +-- | /Optional Param/ "enum_query_string_array" - Query parameter enum test (string array) +instance HasOptionalParam TestEnumParameters EnumQueryStringArray where + applyOptionalParam req (EnumQueryStringArray xs) = + req `_setQuery` toQueryColl CommaSeparated ("enum_query_string_array", Just xs) + +-- | /Optional Param/ "enum_query_string" - Query parameter enum test (string) +instance HasOptionalParam TestEnumParameters EnumQueryString where + applyOptionalParam req (EnumQueryString xs) = + req `_setQuery` toQuery ("enum_query_string", Just xs) + +-- | /Optional Param/ "enum_query_integer" - Query parameter enum test (double) +instance HasOptionalParam TestEnumParameters EnumQueryInteger where + applyOptionalParam req (EnumQueryInteger xs) = + req `_setQuery` toQuery ("enum_query_integer", Just xs) + +-- | /Optional Param/ "enum_query_double" - Query parameter enum test (double) +instance HasOptionalParam TestEnumParameters EnumQueryDouble where + applyOptionalParam req (EnumQueryDouble xs) = + req `_addForm` toForm ("enum_query_double", xs) + +-- | @*/*@ +instance Consumes TestEnumParameters MimeAny + +-- | @*/*@ +instance Produces TestEnumParameters MimeAny + + +-- *** testJsonFormData + +-- | @GET \/fake\/jsonFormData@ +-- +-- test json serialization of form data +-- +-- +-- +testJsonFormData + :: (Consumes TestJsonFormData contentType) + => contentType -- ^ request content-type ('MimeType') + -> Text -- ^ "param" - field1 + -> Text -- ^ "param2" - field2 + -> SwaggerPetstoreRequest TestJsonFormData contentType NoContent +testJsonFormData _ param param2 = + _mkRequest "GET" ["/fake/jsonFormData"] + `_addForm` toForm ("param", param) + `_addForm` toForm ("param2", param2) + +data TestJsonFormData + +-- | @application/json@ +instance Consumes TestJsonFormData MimeJSON + + +-- ** FakeClassnameTags123 + +-- *** testClassname + +-- | @PATCH \/fake_classname_test@ +-- +-- To test class name in snake case +-- +-- AuthMethod: api_key_query +-- +testClassname + :: (Consumes TestClassname contentType, MimeRender contentType Client) + => contentType -- ^ request content-type ('MimeType') + -> Client -- ^ "body" - client model + -> SwaggerPetstoreRequest TestClassname contentType Client +testClassname _ body = + _mkRequest "PATCH" ["/fake_classname_test"] + `setBodyParam` body + +data TestClassname + +-- | /Body Param/ "body" - client model +instance HasBodyParam TestClassname Client + +-- | @application/json@ +instance Consumes TestClassname MimeJSON + +-- | @application/json@ +instance Produces TestClassname MimeJSON + + -- ** Pet -- *** addPet @@ -127,8 +470,8 @@ data DeletePet -instance HasOptionalParam DeletePet ApiUnderscorekey where - applyOptionalParam req (ApiUnderscorekey xs) = +instance HasOptionalParam DeletePet ApiKey where + applyOptionalParam req (ApiKey xs) = req `setHeader` toHeader ("api_key", xs) -- | @application/xml@ instance Produces DeletePet MimeXML @@ -271,8 +614,8 @@ data UpdatePetWithForm -- | /Optional Param/ "name" - Updated name of the pet -instance HasOptionalParam UpdatePetWithForm Name where - applyOptionalParam req (Name xs) = +instance HasOptionalParam UpdatePetWithForm Name2 where + applyOptionalParam req (Name2 xs) = req `_addForm` toForm ("name", xs) -- | /Optional Param/ "status" - Updated status of the pet @@ -331,7 +674,7 @@ -- *** deleteOrder --- | @DELETE \/store\/order\/{orderId}@ +-- | @DELETE \/store\/order\/{order_id}@ -- -- Delete purchase order by ID -- @@ -364,7 +707,7 @@ -- AuthMethod: api_key -- getInventory - :: SwaggerPetstoreRequest GetInventory MimeNoContent (Map.Map String Int) + :: SwaggerPetstoreRequest GetInventory MimeNoContent ((Map.Map String Int)) getInventory = _mkRequest "GET" ["/store/inventory"] @@ -375,7 +718,7 @@ -- *** getOrderById --- | @GET \/store\/order\/{orderId}@ +-- | @GET \/store\/order\/{order_id}@ -- -- Find purchase order by ID -- @@ -664,9 +1007,53 @@ -- * Optional Request Parameter Types -newtype ApiUnderscorekey = ApiUnderscorekey { unApiUnderscorekey :: Text } deriving (P.Eq, P.Show) +newtype BodyOuterBoolean = BodyOuterBoolean { unBodyOuterBoolean :: OuterBoolean } deriving (P.Eq, P.Show) -newtype Name = Name { unName :: Text } deriving (P.Eq, P.Show) +newtype BodyOuterComposite = BodyOuterComposite { unBodyOuterComposite :: OuterComposite } deriving (P.Eq, P.Show) + +newtype Body = Body { unBody :: OuterNumber } deriving (P.Eq, P.Show) + +newtype BodyOuterString = BodyOuterString { unBodyOuterString :: OuterString } deriving (P.Eq, P.Show) + +newtype ParamInteger = ParamInteger { unParamInteger :: Int } deriving (P.Eq, P.Show) + +newtype Int32 = Int32 { unInt32 :: Int } deriving (P.Eq, P.Show) + +newtype Int64 = Int64 { unInt64 :: Integer } deriving (P.Eq, P.Show) + +newtype ParamFloat = ParamFloat { unParamFloat :: Float } deriving (P.Eq, P.Show) + +newtype ParamString = ParamString { unParamString :: Text } deriving (P.Eq, P.Show) + +newtype ParamBinary = ParamBinary { unParamBinary :: Binary } deriving (P.Eq, P.Show) + +newtype ParamDate = ParamDate { unParamDate :: Date } deriving (P.Eq, P.Show) + +newtype ParamDateTime = ParamDateTime { unParamDateTime :: DateTime } deriving (P.Eq, P.Show) + +newtype Password = Password { unPassword :: Text } deriving (P.Eq, P.Show) + +newtype Callback = Callback { unCallback :: Text } deriving (P.Eq, P.Show) + +newtype EnumFormStringArray = EnumFormStringArray { unEnumFormStringArray :: [Text] } deriving (P.Eq, P.Show) + +newtype EnumFormString = EnumFormString { unEnumFormString :: Text } deriving (P.Eq, P.Show) + +newtype EnumHeaderStringArray = EnumHeaderStringArray { unEnumHeaderStringArray :: [Text] } deriving (P.Eq, P.Show) + +newtype EnumHeaderString = EnumHeaderString { unEnumHeaderString :: Text } deriving (P.Eq, P.Show) + +newtype EnumQueryStringArray = EnumQueryStringArray { unEnumQueryStringArray :: [Text] } deriving (P.Eq, P.Show) + +newtype EnumQueryString = EnumQueryString { unEnumQueryString :: Text } deriving (P.Eq, P.Show) + +newtype EnumQueryInteger = EnumQueryInteger { unEnumQueryInteger :: Int } deriving (P.Eq, P.Show) + +newtype EnumQueryDouble = EnumQueryDouble { unEnumQueryDouble :: Double } deriving (P.Eq, P.Show) + +newtype ApiKey = ApiKey { unApiKey :: Text } deriving (P.Eq, P.Show) + +newtype Name2 = Name2 { unName2 :: Text } deriving (P.Eq, P.Show) newtype Status = Status { unStatus :: Text } deriving (P.Eq, P.Show) diff --git a/lib/SwaggerPetstore/Client.hs b/lib/SwaggerPetstore/Client.hs --- a/lib/SwaggerPetstore/Client.hs +++ b/lib/SwaggerPetstore/Client.hs @@ -17,6 +17,7 @@ import SwaggerPetstore.Model import SwaggerPetstore.API import SwaggerPetstore.MimeTypes +import SwaggerPetstore.Logging import qualified Control.Monad.IO.Class as P import qualified Data.Aeson as A @@ -30,8 +31,6 @@ import Web.HttpApiData as WH import Control.Monad.Catch (MonadThrow) -import qualified Control.Monad.Logger as LG - import qualified Data.Time as TI import qualified Data.Map as Map import qualified Data.Text as T @@ -57,8 +56,8 @@ data SwaggerPetstoreConfig = SwaggerPetstoreConfig { configHost :: BCL.ByteString -- ^ host supplied in the Request , configUserAgent :: Text -- ^ user-agent supplied in the Request - , configExecLoggingT :: ExecLoggingT -- ^ Run a block using a MonadLogger instance - , configLoggingFilter :: LG.LogSource -> LG.LogLevel -> Bool -- ^ Only log messages passing the given predicate function. + , configLogExecWithContext :: LogExecWithContext -- ^ Run a block using a Logger instance + , configLogContext :: LogContext -- ^ Configures the logger } -- | display the config @@ -73,35 +72,35 @@ -- -- configHost: -- --- @http://petstore.swagger.io/v2@ +-- @http://petstore.swagger.io:80/v2@ -- -- configUserAgent: -- -- @"swagger-haskell-http-client/1.0.0"@ -- --- configExecLoggingT: 'runNullLoggingT' --- --- configLoggingFilter: 'infoLevelFilter' -newConfig :: SwaggerPetstoreConfig -newConfig = - SwaggerPetstoreConfig - { configHost = "http://petstore.swagger.io/v2" - , configUserAgent = "swagger-haskell-http-client/1.0.0" - , configExecLoggingT = runNullLoggingT - , configLoggingFilter = infoLevelFilter - } +newConfig :: IO SwaggerPetstoreConfig +newConfig = do + logCxt <- initLogContext + return $ SwaggerPetstoreConfig + { configHost = "http://petstore.swagger.io:80/v2" + , configUserAgent = "swagger-haskell-http-client/1.0.0" + , configLogExecWithContext = runDefaultLogExecWithContext + , configLogContext = logCxt + } --- | updates the config to use a MonadLogger instance which prints to stdout. -withStdoutLogging :: SwaggerPetstoreConfig -> SwaggerPetstoreConfig -withStdoutLogging p = p { configExecLoggingT = LG.runStdoutLoggingT} +withStdoutLogging :: SwaggerPetstoreConfig -> IO SwaggerPetstoreConfig +withStdoutLogging p = do + logCxt <- stdoutLoggingContext (configLogContext p) + return $ p { configLogExecWithContext = stdoutLoggingExec, configLogContext = logCxt } --- | updates the config to use a MonadLogger instance which prints to stderr. -withStderrLogging :: SwaggerPetstoreConfig -> SwaggerPetstoreConfig -withStderrLogging p = p { configExecLoggingT = LG.runStderrLoggingT} +withStderrLogging :: SwaggerPetstoreConfig -> IO SwaggerPetstoreConfig +withStderrLogging p = do + logCxt <- stderrLoggingContext (configLogContext p) + return $ p { configLogExecWithContext = stderrLoggingExec, configLogContext = logCxt } -- | updates the config to disable logging withNoLogging :: SwaggerPetstoreConfig -> SwaggerPetstoreConfig -withNoLogging p = p { configExecLoggingT = runNullLoggingT} +withNoLogging p = p { configLogExecWithContext = runNullLogExec} -- * Dispatch @@ -146,10 +145,10 @@ dispatchMime manager config request accept = do httpResponse <- dispatchLbs manager config request accept parsedResult <- - runExceptionLoggingT "Client" config $ + runConfigLogWithExceptions "Client" config $ do case mimeUnrender' accept (NH.responseBody httpResponse) of Left s -> do - logNST LG.LevelError "Client" (T.pack s) + _log "Client" levelError (T.pack s) pure (Left (MimeError s httpResponse)) Right r -> pure (Right r) return (MimeResult parsedResult httpResponse) @@ -187,15 +186,15 @@ -> InitRequest req contentType res accept -- ^ init request -> IO (NH.Response BCL.ByteString) -- ^ response dispatchInitUnsafe manager config (InitRequest req) = do - runExceptionLoggingT logSrc config $ - do logNST LG.LevelInfo logSrc requestLogMsg - logNST LG.LevelDebug logSrc requestDbgLogMsg + runConfigLogWithExceptions src config $ + do _log src levelInfo requestLogMsg + _log src levelDebug requestDbgLogMsg res <- P.liftIO $ NH.httpLbs req manager - logNST LG.LevelInfo logSrc (responseLogMsg res) - logNST LG.LevelDebug logSrc ((T.pack . show) res) + _log src levelInfo (responseLogMsg res) + _log src levelDebug ((T.pack . show) res) return res where - logSrc = "Client" + src = "Client" endpoint = T.pack $ BC.unpack $ @@ -250,68 +249,16 @@ modifyInitRequestM :: Monad m => InitRequest req contentType res accept -> (NH.Request -> m NH.Request) -> m (InitRequest req contentType res accept) modifyInitRequestM (InitRequest req) f = fmap InitRequest (f req) --- * Logging - --- | A block using a MonadLogger instance -type ExecLoggingT = forall m. P.MonadIO m => - forall a. LG.LoggingT m a -> m a - --- ** Null Logger - --- | a logger which disables logging -nullLogger :: LG.Loc -> LG.LogSource -> LG.LogLevel -> LG.LogStr -> IO () -nullLogger _ _ _ _ = return () - --- | run the monad transformer that disables logging -runNullLoggingT :: LG.LoggingT m a -> m a -runNullLoggingT = (`LG.runLoggingT` nullLogger) - --- ** Logging Filters - --- | a log filter that uses 'LevelError' as the minimum logging level -errorLevelFilter :: LG.LogSource -> LG.LogLevel -> Bool -errorLevelFilter = minLevelFilter LG.LevelError - --- | a log filter that uses 'LevelInfo' as the minimum logging level -infoLevelFilter :: LG.LogSource -> LG.LogLevel -> Bool -infoLevelFilter = minLevelFilter LG.LevelInfo - --- | a log filter that uses 'LevelDebug' as the minimum logging level -debugLevelFilter :: LG.LogSource -> LG.LogLevel -> Bool -debugLevelFilter = minLevelFilter LG.LevelDebug - -minLevelFilter :: LG.LogLevel -> LG.LogSource -> LG.LogLevel -> Bool -minLevelFilter l _ l' = l' >= l - -- ** Logging --- | Log a message using the current time -logNST :: (P.MonadIO m, LG.MonadLogger m) => LG.LogLevel -> Text -> Text -> m () -logNST level src msg = do - now <- P.liftIO (formatTimeLog <$> TI.getCurrentTime) - LG.logOtherNS sourceLog level (now <> " " <> msg) - where - sourceLog = "SwaggerPetstore/" <> src - formatTimeLog = - T.pack . TI.formatTime TI.defaultTimeLocale "%Y-%m-%dT%H:%M:%S%Z" - --- | re-throws exceptions after logging them -logExceptions - :: (LG.MonadLogger m, E.MonadCatch m, P.MonadIO m) - => Text -> m a -> m a -logExceptions src = - E.handle - (\(e :: E.SomeException) -> do - logNST LG.LevelError src ((T.pack . show) e) - E.throw e) - --- | Run a block using the configured MonadLogger instance -runLoggingT :: SwaggerPetstoreConfig -> ExecLoggingT -runLoggingT config = - configExecLoggingT config . LG.filterLogger (configLoggingFilter config) +-- | Run a block using the configured logger instance +runConfigLog + :: P.MonadIO m + => SwaggerPetstoreConfig -> LogExec m +runConfigLog config = configLogExecWithContext config (configLogContext config) --- | Run a block using the configured MonadLogger instance (logs exceptions) -runExceptionLoggingT +-- | Run a block using the configured logger instance (logs exceptions) +runConfigLogWithExceptions :: (E.MonadCatch m, P.MonadIO m) - => T.Text -> SwaggerPetstoreConfig -> LG.LoggingT m a -> m a -runExceptionLoggingT logSrc config = runLoggingT config . logExceptions logSrc + => T.Text -> SwaggerPetstoreConfig -> LogExec m +runConfigLogWithExceptions src config = runConfigLog config . logExceptions src diff --git a/lib/SwaggerPetstore/Lens.hs b/lib/SwaggerPetstore/Lens.hs --- a/lib/SwaggerPetstore/Lens.hs +++ b/lib/SwaggerPetstore/Lens.hs @@ -10,18 +10,15 @@ module SwaggerPetstore.Lens where -import Data.Text (Text) - import qualified Data.Aeson as A -import Data.Aeson (Value) -import qualified Data.ByteString as B -import Data.ByteString.Lazy (ByteString) +import qualified Data.ByteString.Lazy as BL import qualified Data.Data as P (Data, Typeable) import qualified Data.Map as Map - +import qualified Data.Set as Set import qualified Data.Time as TI -import Data.Time (UTCTime) +import Data.Text (Text) + import Prelude (($), (.),(<$>),(<*>),(=<<),Maybe(..),Bool(..),Char,Double,FilePath,Float,Int,Integer,String,fmap,undefined,mempty,maybe,pure,Monad,Applicative,Functor) import qualified Prelude as P @@ -33,6 +30,38 @@ type Lens_ s t a b = forall (f :: * -> *). Functor f => (a -> f b) -> s -> f t +-- * AdditionalPropertiesClass + +-- | 'additionalPropertiesClassMapProperty' Lens +additionalPropertiesClassMapPropertyL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String Text)) +additionalPropertiesClassMapPropertyL f AdditionalPropertiesClass{..} = (\additionalPropertiesClassMapProperty -> AdditionalPropertiesClass { additionalPropertiesClassMapProperty, ..} ) <$> f additionalPropertiesClassMapProperty +{-# INLINE additionalPropertiesClassMapPropertyL #-} + +-- | 'additionalPropertiesClassMapOfMapProperty' Lens +additionalPropertiesClassMapOfMapPropertyL :: Lens_' AdditionalPropertiesClass (Maybe (Map.Map String (Map.Map String Text))) +additionalPropertiesClassMapOfMapPropertyL f AdditionalPropertiesClass{..} = (\additionalPropertiesClassMapOfMapProperty -> AdditionalPropertiesClass { additionalPropertiesClassMapOfMapProperty, ..} ) <$> f additionalPropertiesClassMapOfMapProperty +{-# INLINE additionalPropertiesClassMapOfMapPropertyL #-} + + + +-- * Animal + +-- | 'animalClassName' Lens +animalClassNameL :: Lens_' Animal (Text) +animalClassNameL f Animal{..} = (\animalClassName -> Animal { animalClassName, ..} ) <$> f animalClassName +{-# INLINE animalClassNameL #-} + +-- | 'animalColor' Lens +animalColorL :: Lens_' Animal (Maybe Text) +animalColorL f Animal{..} = (\animalColor -> Animal { animalColor, ..} ) <$> f animalColor +{-# INLINE animalColorL #-} + + + +-- * AnimalFarm + + + -- * ApiResponse -- | 'apiResponseCode' Lens @@ -52,6 +81,77 @@ +-- * ArrayOfArrayOfNumberOnly + +-- | 'arrayOfArrayOfNumberOnlyArrayArrayNumber' Lens +arrayOfArrayOfNumberOnlyArrayArrayNumberL :: Lens_' ArrayOfArrayOfNumberOnly (Maybe [[Double]]) +arrayOfArrayOfNumberOnlyArrayArrayNumberL f ArrayOfArrayOfNumberOnly{..} = (\arrayOfArrayOfNumberOnlyArrayArrayNumber -> ArrayOfArrayOfNumberOnly { arrayOfArrayOfNumberOnlyArrayArrayNumber, ..} ) <$> f arrayOfArrayOfNumberOnlyArrayArrayNumber +{-# INLINE arrayOfArrayOfNumberOnlyArrayArrayNumberL #-} + + + +-- * ArrayOfNumberOnly + +-- | 'arrayOfNumberOnlyArrayNumber' Lens +arrayOfNumberOnlyArrayNumberL :: Lens_' ArrayOfNumberOnly (Maybe [Double]) +arrayOfNumberOnlyArrayNumberL f ArrayOfNumberOnly{..} = (\arrayOfNumberOnlyArrayNumber -> ArrayOfNumberOnly { arrayOfNumberOnlyArrayNumber, ..} ) <$> f arrayOfNumberOnlyArrayNumber +{-# INLINE arrayOfNumberOnlyArrayNumberL #-} + + + +-- * ArrayTest + +-- | 'arrayTestArrayOfString' Lens +arrayTestArrayOfStringL :: Lens_' ArrayTest (Maybe [Text]) +arrayTestArrayOfStringL f ArrayTest{..} = (\arrayTestArrayOfString -> ArrayTest { arrayTestArrayOfString, ..} ) <$> f arrayTestArrayOfString +{-# INLINE arrayTestArrayOfStringL #-} + +-- | 'arrayTestArrayArrayOfInteger' Lens +arrayTestArrayArrayOfIntegerL :: Lens_' ArrayTest (Maybe [[Integer]]) +arrayTestArrayArrayOfIntegerL f ArrayTest{..} = (\arrayTestArrayArrayOfInteger -> ArrayTest { arrayTestArrayArrayOfInteger, ..} ) <$> f arrayTestArrayArrayOfInteger +{-# INLINE arrayTestArrayArrayOfIntegerL #-} + +-- | 'arrayTestArrayArrayOfModel' Lens +arrayTestArrayArrayOfModelL :: Lens_' ArrayTest (Maybe [[ReadOnlyFirst]]) +arrayTestArrayArrayOfModelL f ArrayTest{..} = (\arrayTestArrayArrayOfModel -> ArrayTest { arrayTestArrayArrayOfModel, ..} ) <$> f arrayTestArrayArrayOfModel +{-# INLINE arrayTestArrayArrayOfModelL #-} + + + +-- * Capitalization + +-- | 'capitalizationSmallCamel' Lens +capitalizationSmallCamelL :: Lens_' Capitalization (Maybe Text) +capitalizationSmallCamelL f Capitalization{..} = (\capitalizationSmallCamel -> Capitalization { capitalizationSmallCamel, ..} ) <$> f capitalizationSmallCamel +{-# INLINE capitalizationSmallCamelL #-} + +-- | 'capitalizationCapitalCamel' Lens +capitalizationCapitalCamelL :: Lens_' Capitalization (Maybe Text) +capitalizationCapitalCamelL f Capitalization{..} = (\capitalizationCapitalCamel -> Capitalization { capitalizationCapitalCamel, ..} ) <$> f capitalizationCapitalCamel +{-# INLINE capitalizationCapitalCamelL #-} + +-- | 'capitalizationSmallSnake' Lens +capitalizationSmallSnakeL :: Lens_' Capitalization (Maybe Text) +capitalizationSmallSnakeL f Capitalization{..} = (\capitalizationSmallSnake -> Capitalization { capitalizationSmallSnake, ..} ) <$> f capitalizationSmallSnake +{-# INLINE capitalizationSmallSnakeL #-} + +-- | 'capitalizationCapitalSnake' Lens +capitalizationCapitalSnakeL :: Lens_' Capitalization (Maybe Text) +capitalizationCapitalSnakeL f Capitalization{..} = (\capitalizationCapitalSnake -> Capitalization { capitalizationCapitalSnake, ..} ) <$> f capitalizationCapitalSnake +{-# INLINE capitalizationCapitalSnakeL #-} + +-- | 'capitalizationScaEthFlowPoints' Lens +capitalizationScaEthFlowPointsL :: Lens_' Capitalization (Maybe Text) +capitalizationScaEthFlowPointsL f Capitalization{..} = (\capitalizationScaEthFlowPoints -> Capitalization { capitalizationScaEthFlowPoints, ..} ) <$> f capitalizationScaEthFlowPoints +{-# INLINE capitalizationScaEthFlowPointsL #-} + +-- | 'capitalizationAttName' Lens +capitalizationAttNameL :: Lens_' Capitalization (Maybe Text) +capitalizationAttNameL f Capitalization{..} = (\capitalizationAttName -> Capitalization { capitalizationAttName, ..} ) <$> f capitalizationAttName +{-# INLINE capitalizationAttNameL #-} + + + -- * Category -- | 'categoryId' Lens @@ -66,6 +166,247 @@ +-- * ClassModel + +-- | 'classModelClass' Lens +classModelClassL :: Lens_' ClassModel (Maybe Text) +classModelClassL f ClassModel{..} = (\classModelClass -> ClassModel { classModelClass, ..} ) <$> f classModelClass +{-# INLINE classModelClassL #-} + + + +-- * Client + +-- | 'clientClient' Lens +clientClientL :: Lens_' Client (Maybe Text) +clientClientL f Client{..} = (\clientClient -> Client { clientClient, ..} ) <$> f clientClient +{-# INLINE clientClientL #-} + + + +-- * EnumArrays + +-- | 'enumArraysJustSymbol' Lens +enumArraysJustSymbolL :: Lens_' EnumArrays (Maybe Text) +enumArraysJustSymbolL f EnumArrays{..} = (\enumArraysJustSymbol -> EnumArrays { enumArraysJustSymbol, ..} ) <$> f enumArraysJustSymbol +{-# INLINE enumArraysJustSymbolL #-} + +-- | 'enumArraysArrayEnum' Lens +enumArraysArrayEnumL :: Lens_' EnumArrays (Maybe [Text]) +enumArraysArrayEnumL f EnumArrays{..} = (\enumArraysArrayEnum -> EnumArrays { enumArraysArrayEnum, ..} ) <$> f enumArraysArrayEnum +{-# INLINE enumArraysArrayEnumL #-} + + + +-- * EnumClass + + + +-- * EnumTest + +-- | 'enumTestEnumString' Lens +enumTestEnumStringL :: Lens_' EnumTest (Maybe Text) +enumTestEnumStringL f EnumTest{..} = (\enumTestEnumString -> EnumTest { enumTestEnumString, ..} ) <$> f enumTestEnumString +{-# INLINE enumTestEnumStringL #-} + +-- | 'enumTestEnumInteger' Lens +enumTestEnumIntegerL :: Lens_' EnumTest (Maybe Int) +enumTestEnumIntegerL f EnumTest{..} = (\enumTestEnumInteger -> EnumTest { enumTestEnumInteger, ..} ) <$> f enumTestEnumInteger +{-# INLINE enumTestEnumIntegerL #-} + +-- | 'enumTestEnumNumber' Lens +enumTestEnumNumberL :: Lens_' EnumTest (Maybe Double) +enumTestEnumNumberL f EnumTest{..} = (\enumTestEnumNumber -> EnumTest { enumTestEnumNumber, ..} ) <$> f enumTestEnumNumber +{-# INLINE enumTestEnumNumberL #-} + +-- | 'enumTestOuterEnum' Lens +enumTestOuterEnumL :: Lens_' EnumTest (Maybe OuterEnum) +enumTestOuterEnumL f EnumTest{..} = (\enumTestOuterEnum -> EnumTest { enumTestOuterEnum, ..} ) <$> f enumTestOuterEnum +{-# INLINE enumTestOuterEnumL #-} + + + +-- * FormatTest + +-- | 'formatTestInteger' Lens +formatTestIntegerL :: Lens_' FormatTest (Maybe Int) +formatTestIntegerL f FormatTest{..} = (\formatTestInteger -> FormatTest { formatTestInteger, ..} ) <$> f formatTestInteger +{-# INLINE formatTestIntegerL #-} + +-- | 'formatTestInt32' Lens +formatTestInt32L :: Lens_' FormatTest (Maybe Int) +formatTestInt32L f FormatTest{..} = (\formatTestInt32 -> FormatTest { formatTestInt32, ..} ) <$> f formatTestInt32 +{-# INLINE formatTestInt32L #-} + +-- | 'formatTestInt64' Lens +formatTestInt64L :: Lens_' FormatTest (Maybe Integer) +formatTestInt64L f FormatTest{..} = (\formatTestInt64 -> FormatTest { formatTestInt64, ..} ) <$> f formatTestInt64 +{-# INLINE formatTestInt64L #-} + +-- | 'formatTestNumber' Lens +formatTestNumberL :: Lens_' FormatTest (Double) +formatTestNumberL f FormatTest{..} = (\formatTestNumber -> FormatTest { formatTestNumber, ..} ) <$> f formatTestNumber +{-# INLINE formatTestNumberL #-} + +-- | 'formatTestFloat' Lens +formatTestFloatL :: Lens_' FormatTest (Maybe Float) +formatTestFloatL f FormatTest{..} = (\formatTestFloat -> FormatTest { formatTestFloat, ..} ) <$> f formatTestFloat +{-# INLINE formatTestFloatL #-} + +-- | 'formatTestDouble' Lens +formatTestDoubleL :: Lens_' FormatTest (Maybe Double) +formatTestDoubleL f FormatTest{..} = (\formatTestDouble -> FormatTest { formatTestDouble, ..} ) <$> f formatTestDouble +{-# INLINE formatTestDoubleL #-} + +-- | 'formatTestString' Lens +formatTestStringL :: Lens_' FormatTest (Maybe Text) +formatTestStringL f FormatTest{..} = (\formatTestString -> FormatTest { formatTestString, ..} ) <$> f formatTestString +{-# INLINE formatTestStringL #-} + +-- | 'formatTestByte' Lens +formatTestByteL :: Lens_' FormatTest (ByteArray) +formatTestByteL f FormatTest{..} = (\formatTestByte -> FormatTest { formatTestByte, ..} ) <$> f formatTestByte +{-# INLINE formatTestByteL #-} + +-- | 'formatTestBinary' Lens +formatTestBinaryL :: Lens_' FormatTest (Maybe Binary) +formatTestBinaryL f FormatTest{..} = (\formatTestBinary -> FormatTest { formatTestBinary, ..} ) <$> f formatTestBinary +{-# INLINE formatTestBinaryL #-} + +-- | 'formatTestDate' Lens +formatTestDateL :: Lens_' FormatTest (Date) +formatTestDateL f FormatTest{..} = (\formatTestDate -> FormatTest { formatTestDate, ..} ) <$> f formatTestDate +{-# INLINE formatTestDateL #-} + +-- | 'formatTestDateTime' Lens +formatTestDateTimeL :: Lens_' FormatTest (Maybe DateTime) +formatTestDateTimeL f FormatTest{..} = (\formatTestDateTime -> FormatTest { formatTestDateTime, ..} ) <$> f formatTestDateTime +{-# INLINE formatTestDateTimeL #-} + +-- | 'formatTestUuid' Lens +formatTestUuidL :: Lens_' FormatTest (Maybe Text) +formatTestUuidL f FormatTest{..} = (\formatTestUuid -> FormatTest { formatTestUuid, ..} ) <$> f formatTestUuid +{-# INLINE formatTestUuidL #-} + +-- | 'formatTestPassword' Lens +formatTestPasswordL :: Lens_' FormatTest (Text) +formatTestPasswordL f FormatTest{..} = (\formatTestPassword -> FormatTest { formatTestPassword, ..} ) <$> f formatTestPassword +{-# INLINE formatTestPasswordL #-} + + + +-- * HasOnlyReadOnly + +-- | 'hasOnlyReadOnlyBar' Lens +hasOnlyReadOnlyBarL :: Lens_' HasOnlyReadOnly (Maybe Text) +hasOnlyReadOnlyBarL f HasOnlyReadOnly{..} = (\hasOnlyReadOnlyBar -> HasOnlyReadOnly { hasOnlyReadOnlyBar, ..} ) <$> f hasOnlyReadOnlyBar +{-# INLINE hasOnlyReadOnlyBarL #-} + +-- | 'hasOnlyReadOnlyFoo' Lens +hasOnlyReadOnlyFooL :: Lens_' HasOnlyReadOnly (Maybe Text) +hasOnlyReadOnlyFooL f HasOnlyReadOnly{..} = (\hasOnlyReadOnlyFoo -> HasOnlyReadOnly { hasOnlyReadOnlyFoo, ..} ) <$> f hasOnlyReadOnlyFoo +{-# INLINE hasOnlyReadOnlyFooL #-} + + + +-- * MapTest + +-- | 'mapTestMapMapOfString' Lens +mapTestMapMapOfStringL :: Lens_' MapTest (Maybe (Map.Map String (Map.Map String Text))) +mapTestMapMapOfStringL f MapTest{..} = (\mapTestMapMapOfString -> MapTest { mapTestMapMapOfString, ..} ) <$> f mapTestMapMapOfString +{-# INLINE mapTestMapMapOfStringL #-} + +-- | 'mapTestMapOfEnumString' Lens +mapTestMapOfEnumStringL :: Lens_' MapTest (Maybe (Map.Map String Text)) +mapTestMapOfEnumStringL f MapTest{..} = (\mapTestMapOfEnumString -> MapTest { mapTestMapOfEnumString, ..} ) <$> f mapTestMapOfEnumString +{-# INLINE mapTestMapOfEnumStringL #-} + + + +-- * MixedPropertiesAndAdditionalPropertiesClass + +-- | 'mixedPropertiesAndAdditionalPropertiesClassUuid' Lens +mixedPropertiesAndAdditionalPropertiesClassUuidL :: Lens_' MixedPropertiesAndAdditionalPropertiesClass (Maybe Text) +mixedPropertiesAndAdditionalPropertiesClassUuidL f MixedPropertiesAndAdditionalPropertiesClass{..} = (\mixedPropertiesAndAdditionalPropertiesClassUuid -> MixedPropertiesAndAdditionalPropertiesClass { mixedPropertiesAndAdditionalPropertiesClassUuid, ..} ) <$> f mixedPropertiesAndAdditionalPropertiesClassUuid +{-# INLINE mixedPropertiesAndAdditionalPropertiesClassUuidL #-} + +-- | 'mixedPropertiesAndAdditionalPropertiesClassDateTime' Lens +mixedPropertiesAndAdditionalPropertiesClassDateTimeL :: Lens_' MixedPropertiesAndAdditionalPropertiesClass (Maybe DateTime) +mixedPropertiesAndAdditionalPropertiesClassDateTimeL f MixedPropertiesAndAdditionalPropertiesClass{..} = (\mixedPropertiesAndAdditionalPropertiesClassDateTime -> MixedPropertiesAndAdditionalPropertiesClass { mixedPropertiesAndAdditionalPropertiesClassDateTime, ..} ) <$> f mixedPropertiesAndAdditionalPropertiesClassDateTime +{-# INLINE mixedPropertiesAndAdditionalPropertiesClassDateTimeL #-} + +-- | 'mixedPropertiesAndAdditionalPropertiesClassMap' Lens +mixedPropertiesAndAdditionalPropertiesClassMapL :: Lens_' MixedPropertiesAndAdditionalPropertiesClass (Maybe (Map.Map String Animal)) +mixedPropertiesAndAdditionalPropertiesClassMapL f MixedPropertiesAndAdditionalPropertiesClass{..} = (\mixedPropertiesAndAdditionalPropertiesClassMap -> MixedPropertiesAndAdditionalPropertiesClass { mixedPropertiesAndAdditionalPropertiesClassMap, ..} ) <$> f mixedPropertiesAndAdditionalPropertiesClassMap +{-# INLINE mixedPropertiesAndAdditionalPropertiesClassMapL #-} + + + +-- * Model200Response + +-- | 'model200ResponseName' Lens +model200ResponseNameL :: Lens_' Model200Response (Maybe Int) +model200ResponseNameL f Model200Response{..} = (\model200ResponseName -> Model200Response { model200ResponseName, ..} ) <$> f model200ResponseName +{-# INLINE model200ResponseNameL #-} + +-- | 'model200ResponseClass' Lens +model200ResponseClassL :: Lens_' Model200Response (Maybe Text) +model200ResponseClassL f Model200Response{..} = (\model200ResponseClass -> Model200Response { model200ResponseClass, ..} ) <$> f model200ResponseClass +{-# INLINE model200ResponseClassL #-} + + + +-- * ModelList + +-- | 'modelList123List' Lens +modelList123ListL :: Lens_' ModelList (Maybe Text) +modelList123ListL f ModelList{..} = (\modelList123List -> ModelList { modelList123List, ..} ) <$> f modelList123List +{-# INLINE modelList123ListL #-} + + + +-- * ModelReturn + +-- | 'modelReturnReturn' Lens +modelReturnReturnL :: Lens_' ModelReturn (Maybe Int) +modelReturnReturnL f ModelReturn{..} = (\modelReturnReturn -> ModelReturn { modelReturnReturn, ..} ) <$> f modelReturnReturn +{-# INLINE modelReturnReturnL #-} + + + +-- * Name + +-- | 'nameName' Lens +nameNameL :: Lens_' Name (Int) +nameNameL f Name{..} = (\nameName -> Name { nameName, ..} ) <$> f nameName +{-# INLINE nameNameL #-} + +-- | 'nameSnakeCase' Lens +nameSnakeCaseL :: Lens_' Name (Maybe Int) +nameSnakeCaseL f Name{..} = (\nameSnakeCase -> Name { nameSnakeCase, ..} ) <$> f nameSnakeCase +{-# INLINE nameSnakeCaseL #-} + +-- | 'nameProperty' Lens +namePropertyL :: Lens_' Name (Maybe Text) +namePropertyL f Name{..} = (\nameProperty -> Name { nameProperty, ..} ) <$> f nameProperty +{-# INLINE namePropertyL #-} + +-- | 'name123Number' Lens +name123NumberL :: Lens_' Name (Maybe Int) +name123NumberL f Name{..} = (\name123Number -> Name { name123Number, ..} ) <$> f name123Number +{-# INLINE name123NumberL #-} + + + +-- * NumberOnly + +-- | 'numberOnlyJustNumber' Lens +numberOnlyJustNumberL :: Lens_' NumberOnly (Maybe Double) +numberOnlyJustNumberL f NumberOnly{..} = (\numberOnlyJustNumber -> NumberOnly { numberOnlyJustNumber, ..} ) <$> f numberOnlyJustNumber +{-# INLINE numberOnlyJustNumberL #-} + + + -- * Order -- | 'orderId' Lens @@ -84,7 +425,7 @@ {-# INLINE orderQuantityL #-} -- | 'orderShipDate' Lens -orderShipDateL :: Lens_' Order (Maybe UTCTime) +orderShipDateL :: Lens_' Order (Maybe DateTime) orderShipDateL f Order{..} = (\orderShipDate -> Order { orderShipDate, ..} ) <$> f orderShipDate {-# INLINE orderShipDateL #-} @@ -100,6 +441,41 @@ +-- * OuterBoolean + + + +-- * OuterComposite + +-- | 'outerCompositeMyNumber' Lens +outerCompositeMyNumberL :: Lens_' OuterComposite (Maybe OuterNumber) +outerCompositeMyNumberL f OuterComposite{..} = (\outerCompositeMyNumber -> OuterComposite { outerCompositeMyNumber, ..} ) <$> f outerCompositeMyNumber +{-# INLINE outerCompositeMyNumberL #-} + +-- | 'outerCompositeMyString' Lens +outerCompositeMyStringL :: Lens_' OuterComposite (Maybe OuterString) +outerCompositeMyStringL f OuterComposite{..} = (\outerCompositeMyString -> OuterComposite { outerCompositeMyString, ..} ) <$> f outerCompositeMyString +{-# INLINE outerCompositeMyStringL #-} + +-- | 'outerCompositeMyBoolean' Lens +outerCompositeMyBooleanL :: Lens_' OuterComposite (Maybe OuterBoolean) +outerCompositeMyBooleanL f OuterComposite{..} = (\outerCompositeMyBoolean -> OuterComposite { outerCompositeMyBoolean, ..} ) <$> f outerCompositeMyBoolean +{-# INLINE outerCompositeMyBooleanL #-} + + + +-- * OuterEnum + + + +-- * OuterNumber + + + +-- * OuterString + + + -- * Pet -- | 'petId' Lens @@ -134,6 +510,29 @@ +-- * ReadOnlyFirst + +-- | 'readOnlyFirstBar' Lens +readOnlyFirstBarL :: Lens_' ReadOnlyFirst (Maybe Text) +readOnlyFirstBarL f ReadOnlyFirst{..} = (\readOnlyFirstBar -> ReadOnlyFirst { readOnlyFirstBar, ..} ) <$> f readOnlyFirstBar +{-# INLINE readOnlyFirstBarL #-} + +-- | 'readOnlyFirstBaz' Lens +readOnlyFirstBazL :: Lens_' ReadOnlyFirst (Maybe Text) +readOnlyFirstBazL f ReadOnlyFirst{..} = (\readOnlyFirstBaz -> ReadOnlyFirst { readOnlyFirstBaz, ..} ) <$> f readOnlyFirstBaz +{-# INLINE readOnlyFirstBazL #-} + + + +-- * SpecialModelName + +-- | 'specialModelNameSpecialPropertyName' Lens +specialModelNameSpecialPropertyNameL :: Lens_' SpecialModelName (Maybe Integer) +specialModelNameSpecialPropertyNameL f SpecialModelName{..} = (\specialModelNameSpecialPropertyName -> SpecialModelName { specialModelNameSpecialPropertyName, ..} ) <$> f specialModelNameSpecialPropertyName +{-# INLINE specialModelNameSpecialPropertyNameL #-} + + + -- * Tag -- | 'tagId' Lens @@ -189,5 +588,43 @@ userUserStatusL :: Lens_' User (Maybe Int) userUserStatusL f User{..} = (\userUserStatus -> User { userUserStatus, ..} ) <$> f userUserStatus {-# INLINE userUserStatusL #-} + + + +-- * Cat + +-- | 'catClassName' Lens +catClassNameL :: Lens_' Cat (Text) +catClassNameL f Cat{..} = (\catClassName -> Cat { catClassName, ..} ) <$> f catClassName +{-# INLINE catClassNameL #-} + +-- | 'catColor' Lens +catColorL :: Lens_' Cat (Maybe Text) +catColorL f Cat{..} = (\catColor -> Cat { catColor, ..} ) <$> f catColor +{-# INLINE catColorL #-} + +-- | 'catDeclawed' Lens +catDeclawedL :: Lens_' Cat (Maybe Bool) +catDeclawedL f Cat{..} = (\catDeclawed -> Cat { catDeclawed, ..} ) <$> f catDeclawed +{-# INLINE catDeclawedL #-} + + + +-- * Dog + +-- | 'dogClassName' Lens +dogClassNameL :: Lens_' Dog (Text) +dogClassNameL f Dog{..} = (\dogClassName -> Dog { dogClassName, ..} ) <$> f dogClassName +{-# INLINE dogClassNameL #-} + +-- | 'dogColor' Lens +dogColorL :: Lens_' Dog (Maybe Text) +dogColorL f Dog{..} = (\dogColor -> Dog { dogColor, ..} ) <$> f dogColor +{-# INLINE dogColorL #-} + +-- | 'dogBreed' Lens +dogBreedL :: Lens_' Dog (Maybe Text) +dogBreedL f Dog{..} = (\dogBreed -> Dog { dogBreed, ..} ) <$> f dogBreed +{-# INLINE dogBreedL #-} diff --git a/lib/SwaggerPetstore/Logging.hs b/lib/SwaggerPetstore/Logging.hs new file mode 100644 --- /dev/null +++ b/lib/SwaggerPetstore/Logging.hs @@ -0,0 +1,108 @@ +{-| +Module : SwaggerPetstore.Logging +Katip Logging functions +-} + +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE ScopedTypeVariables #-} + +module SwaggerPetstore.Logging where + +import Data.Text (Text) +import GHC.Exts (IsString(..)) + +import qualified Control.Exception.Safe as E +import qualified Control.Monad.IO.Class as P +import qualified Control.Monad.Trans.Reader as P +import qualified Data.Text as T +import qualified Lens.Micro as L +import qualified System.IO as IO + +import qualified Katip as LG + +-- * Type Aliases (for compatability) + +-- | Runs a Katip logging block with the Log environment +type LogExecWithContext = forall m. P.MonadIO m => + LogContext -> LogExec m + +-- | A Katip logging block +type LogExec m = forall a. LG.KatipT m a -> m a + +-- | A Katip Log environment +type LogContext = LG.LogEnv + +-- | A Katip Log severity +type LogLevel = LG.Severity + +-- * default logger + +-- | the default log environment +initLogContext :: IO LogContext +initLogContext = LG.initLogEnv "SwaggerPetstore" "dev" + +-- | Runs a Katip logging block with the Log environment +runDefaultLogExecWithContext :: LogExecWithContext +runDefaultLogExecWithContext = LG.runKatipT + +-- * stdout logger + +-- | Runs a Katip logging block with the Log environment +stdoutLoggingExec :: LogExecWithContext +stdoutLoggingExec = runDefaultLogExecWithContext + +-- | A Katip Log environment which targets stdout +stdoutLoggingContext :: LogContext -> IO LogContext +stdoutLoggingContext cxt = do + handleScribe <- LG.mkHandleScribe LG.ColorIfTerminal IO.stdout LG.InfoS LG.V2 + LG.registerScribe "stdout" handleScribe LG.defaultScribeSettings cxt + +-- * stderr logger + +-- | Runs a Katip logging block with the Log environment +stderrLoggingExec :: LogExecWithContext +stderrLoggingExec = runDefaultLogExecWithContext + +-- | A Katip Log environment which targets stderr +stderrLoggingContext :: LogContext -> IO LogContext +stderrLoggingContext cxt = do + handleScribe <- LG.mkHandleScribe LG.ColorIfTerminal IO.stderr LG.InfoS LG.V2 + LG.registerScribe "stderr" handleScribe LG.defaultScribeSettings cxt + +-- * Null logger + +-- | Disables Katip logging +runNullLogExec :: LogExecWithContext +runNullLogExec le (LG.KatipT f) = P.runReaderT f (L.set LG.logEnvScribes mempty le) + +-- * Log Msg + +-- | Log a katip message +_log :: (Applicative m, LG.Katip m) => Text -> LogLevel -> Text -> m () +_log src level msg = do + LG.logMsg (fromString $ T.unpack src) level (LG.logStr msg) + +-- * Log Exceptions + +-- | re-throws exceptions after logging them +logExceptions + :: (LG.Katip m, E.MonadCatch m, Applicative m) + => Text -> m a -> m a +logExceptions src = + E.handle + (\(e :: E.SomeException) -> do + _log src LG.ErrorS ((T.pack . show) e) + E.throw e) + +-- * Log Level + +levelInfo :: LogLevel +levelInfo = LG.InfoS + +levelError :: LogLevel +levelError = LG.ErrorS + +levelDebug :: LogLevel +levelDebug = LG.DebugS + diff --git a/lib/SwaggerPetstore/MimeTypes.hs b/lib/SwaggerPetstore/MimeTypes.hs --- a/lib/SwaggerPetstore/MimeTypes.hs +++ b/lib/SwaggerPetstore/MimeTypes.hs @@ -13,6 +13,7 @@ module SwaggerPetstore.MimeTypes where +import SwaggerPetstore.Model as M import qualified Data.Aeson as A @@ -22,13 +23,16 @@ import qualified Data.ByteString.Char8 as BC import qualified Data.ByteString.Lazy.Char8 as BCL + import qualified Network.HTTP.Media as ME import qualified Web.FormUrlEncoded as WH +import qualified Web.HttpApiData as WH import qualified Data.Data as P (Typeable) import qualified Data.Proxy as P (Proxy(..)) import qualified Data.Text as T +import qualified Data.String as P import qualified Data.Text.Encoding as T import qualified Control.Arrow as P (left) @@ -50,7 +54,10 @@ data MimeMultipartFormData = MimeMultipartFormData deriving (P.Typeable) data MimeOctetStream = MimeOctetStream deriving (P.Typeable) data MimeNoContent = MimeNoContent deriving (P.Typeable) +data MimeAny = MimeAny deriving (P.Typeable) +data MimeXmlCharsetutf8 = MimeXmlCharsetutf8 deriving (P.Typeable) +data MimeJsonCharsetutf8 = MimeJsonCharsetutf8 deriving (P.Typeable) -- ** MimeType Class @@ -76,34 +83,41 @@ -- ** MimeType Instances --- | @application/json@ +-- | @application/json; charset=utf-8@ instance MimeType MimeJSON where - mimeTypes _ = - [ "application" ME.// "json" ME./: ("charset", "utf-8") - , "application" ME.// "json" - ] - --- | @application/xml@ + mimeType _ = Just $ P.fromString "application/json" +-- | @application/xml; charset=utf-8@ instance MimeType MimeXML where - mimeType _ = Just $ "application" ME.// "xml" - + mimeType _ = Just $ P.fromString "application/xml" -- | @application/x-www-form-urlencoded@ instance MimeType MimeFormUrlEncoded where - mimeType _ = Just $ "application" ME.// "x-www-form-urlencoded" - + mimeType _ = Just $ P.fromString "application/x-www-form-urlencoded" -- | @multipart/form-data@ instance MimeType MimeMultipartFormData where - mimeType _ = Just $ "multipart" ME.// "form-data" - --- | @text/plain;charset=utf-8@ + mimeType _ = Just $ P.fromString "multipart/form-data" +-- | @text/plain; charset=utf-8@ instance MimeType MimePlainText where - mimeType _ = Just $ "text" ME.// "plain" ME./: ("charset", "utf-8") + mimeType _ = Just $ P.fromString "text/plain" +-- | @application/octet-stream@ instance MimeType MimeOctetStream where - mimeType _ = Just $ "application" ME.// "octet-stream" + mimeType _ = Just $ P.fromString "application/octet-stream" +-- | @"*/*"@ +instance MimeType MimeAny where + mimeType _ = Just $ P.fromString "*/*" instance MimeType MimeNoContent where mimeType _ = Nothing +-- | @application/xml; charset=utf-8@ +instance MimeType MimeXmlCharsetutf8 where + mimeType _ = Just $ P.fromString "application/xml; charset=utf-8" +-- | @application/json; charset=utf-8@ +instance MimeType MimeJsonCharsetutf8 where + mimeType _ = Just $ P.fromString "application/json; charset=utf-8" +instance A.ToJSON a => MimeRender MimeJsonCharsetutf8 a where mimeRender _ = A.encode +instance A.FromJSON a => MimeUnrender MimeJsonCharsetutf8 a where mimeUnrender _ = A.eitherDecode + + -- ** MimeRender Class class MimeType mtype => MimeRender mtype x where @@ -133,13 +147,24 @@ -- | @BCL.pack@ instance MimeRender MimeOctetStream String where mimeRender _ = BCL.pack --- | @P.id@ instance MimeRender MimeMultipartFormData BL.ByteString where mimeRender _ = P.id --- | @BL.fromStrict . T.encodeUtf8@ -instance MimeRender MimeMultipartFormData T.Text where mimeRender _ = BL.fromStrict . T.encodeUtf8 --- | @BCL.pack@ -instance MimeRender MimeMultipartFormData String where mimeRender _ = BCL.pack +instance MimeRender MimeMultipartFormData Binary where mimeRender _ = unBinary +instance MimeRender MimeMultipartFormData ByteArray where mimeRender _ = mimeRenderDefaultMultipartFormData +instance MimeRender MimeMultipartFormData Bool where mimeRender _ = mimeRenderDefaultMultipartFormData +instance MimeRender MimeMultipartFormData Char where mimeRender _ = mimeRenderDefaultMultipartFormData +instance MimeRender MimeMultipartFormData Date where mimeRender _ = mimeRenderDefaultMultipartFormData +instance MimeRender MimeMultipartFormData DateTime where mimeRender _ = mimeRenderDefaultMultipartFormData +instance MimeRender MimeMultipartFormData Double where mimeRender _ = mimeRenderDefaultMultipartFormData +instance MimeRender MimeMultipartFormData Float where mimeRender _ = mimeRenderDefaultMultipartFormData +instance MimeRender MimeMultipartFormData Int where mimeRender _ = mimeRenderDefaultMultipartFormData +instance MimeRender MimeMultipartFormData Integer where mimeRender _ = mimeRenderDefaultMultipartFormData +instance MimeRender MimeMultipartFormData String where mimeRender _ = mimeRenderDefaultMultipartFormData +instance MimeRender MimeMultipartFormData T.Text where mimeRender _ = mimeRenderDefaultMultipartFormData + +mimeRenderDefaultMultipartFormData :: WH.ToHttpApiData a => a -> BL.ByteString +mimeRenderDefaultMultipartFormData = BL.fromStrict . T.encodeUtf8 . WH.toQueryParam + -- | @P.Right . P.const NoContent@ instance MimeRender MimeNoContent NoContent where mimeRender _ = P.const BCL.empty @@ -148,6 +173,8 @@ -- instance MimeRender MimeOctetStream Int where mimeRender _ = BB.toLazyByteString . BB.intDec -- instance MimeRender MimeOctetStream Integer where mimeRender _ = BB.toLazyByteString . BB.integerDec +-- instance MimeRender MimeXmlCharsetutf8 T.Text where mimeRender _ = undefined +-- instance MimeRender MimeJsonCharsetutf8 T.Text where mimeRender _ = undefined -- ** MimeUnrender Class @@ -180,6 +207,8 @@ -- | @P.Right . P.const NoContent@ instance MimeUnrender MimeNoContent NoContent where mimeUnrender _ = P.Right . P.const NoContent +-- instance MimeUnrender MimeXmlCharsetutf8 T.Text where mimeUnrender _ = undefined +-- instance MimeUnrender MimeJsonCharsetutf8 T.Text where mimeUnrender _ = undefined -- ** Request Consumes diff --git a/lib/SwaggerPetstore/Model.hs b/lib/SwaggerPetstore/Model.hs --- a/lib/SwaggerPetstore/Model.hs +++ b/lib/SwaggerPetstore/Model.hs @@ -17,361 +17,1400 @@ module SwaggerPetstore.Model where import Data.Aeson ((.:),(.:!),(.:?),(.=)) -import Data.Text (Text) - -import Data.Aeson (Value) -import Data.ByteString.Lazy (ByteString) - -import qualified Data.Aeson as A -import qualified Data.ByteString as B -import qualified Data.Data as P (Data, Typeable) -import qualified Data.HashMap.Lazy as HM -import qualified Data.Map as Map -import qualified Data.Maybe as P -import qualified Data.Foldable as P -import qualified Web.FormUrlEncoded as WH -import qualified Web.HttpApiData as WH - -import qualified Data.Time as TI -import qualified Data.Time.ISO8601 as TI -import Data.Time (UTCTime) - -import Control.Applicative ((<|>)) -import Control.Applicative (Alternative) -import Prelude (($), (.),(<$>),(<*>),(>>=),Maybe(..),Bool(..),Char,Double,FilePath,Float,Int,Integer,String,fmap,undefined,mempty,maybe,pure,Monad,Applicative,Functor) -import qualified Prelude as P - - - --- * Models - - --- ** ApiResponse --- | --- An uploaded response --- --- Describes the result of uploading an image resource -data ApiResponse = ApiResponse - { apiResponseCode :: !(Maybe Int) -- ^ "code" - , apiResponseType :: !(Maybe Text) -- ^ "type" - , apiResponseMessage :: !(Maybe Text) -- ^ "message" - } deriving (P.Show,P.Eq,P.Typeable) - -instance A.FromJSON ApiResponse where - parseJSON = A.withObject "ApiResponse" $ \o -> - ApiResponse - <$> (o .:? "code") - <*> (o .:? "type") - <*> (o .:? "message") - -instance A.ToJSON ApiResponse where - toJSON ApiResponse {..} = - _omitNulls - [ "code" .= apiResponseCode - , "type" .= apiResponseType - , "message" .= apiResponseMessage - ] - - --- | Construct a value of type 'ApiResponse' (by applying it's required fields, if any) -mkApiResponse - :: ApiResponse -mkApiResponse = - ApiResponse - { apiResponseCode = Nothing - , apiResponseType = Nothing - , apiResponseMessage = Nothing - } - - - --- ** Category --- | --- Pet catehgry --- --- A category for a pet -data Category = Category - { categoryId :: !(Maybe Integer) -- ^ "id" - , categoryName :: !(Maybe Text) -- ^ "name" - } deriving (P.Show,P.Eq,P.Typeable) - -instance A.FromJSON Category where - parseJSON = A.withObject "Category" $ \o -> - Category - <$> (o .:? "id") - <*> (o .:? "name") - -instance A.ToJSON Category where - toJSON Category {..} = - _omitNulls - [ "id" .= categoryId - , "name" .= categoryName - ] - - --- | Construct a value of type 'Category' (by applying it's required fields, if any) -mkCategory - :: Category -mkCategory = - Category - { categoryId = Nothing - , categoryName = Nothing - } - - - --- ** Order --- | --- Pet Order --- --- An order for a pets from the pet store -data Order = Order - { orderId :: !(Maybe Integer) -- ^ "id" - , orderPetId :: !(Maybe Integer) -- ^ "petId" - , orderQuantity :: !(Maybe Int) -- ^ "quantity" - , orderShipDate :: !(Maybe UTCTime) -- ^ "shipDate" - , orderStatus :: !(Maybe Text) -- ^ "status" - Order Status - , orderComplete :: !(Maybe Bool) -- ^ "complete" - } deriving (P.Show,P.Eq,P.Typeable) - -instance A.FromJSON Order where - parseJSON = A.withObject "Order" $ \o -> - Order - <$> (o .:? "id") - <*> (o .:? "petId") - <*> (o .:? "quantity") - <*> (o .:? "shipDate" >>= P.mapM _readDateTime) - <*> (o .:? "status") - <*> (o .:? "complete") - -instance A.ToJSON Order where - toJSON Order {..} = - _omitNulls - [ "id" .= orderId - , "petId" .= orderPetId - , "quantity" .= orderQuantity - , "shipDate" .= P.fmap _showDateTime orderShipDate - , "status" .= orderStatus - , "complete" .= orderComplete - ] - - --- | Construct a value of type 'Order' (by applying it's required fields, if any) -mkOrder - :: Order -mkOrder = - Order - { orderId = Nothing - , orderPetId = Nothing - , orderQuantity = Nothing - , orderShipDate = Nothing - , orderStatus = Nothing - , orderComplete = Nothing - } - - - --- ** Pet --- | --- a Pet --- --- A pet for sale in the pet store -data Pet = Pet - { petId :: !(Maybe Integer) -- ^ "id" - , petCategory :: !(Maybe Category) -- ^ "category" - , petName :: !(Text) -- ^ /Required/ "name" - , petPhotoUrls :: !([Text]) -- ^ /Required/ "photoUrls" - , petTags :: !(Maybe [Tag]) -- ^ "tags" - , petStatus :: !(Maybe Text) -- ^ "status" - pet status in the store - } deriving (P.Show,P.Eq,P.Typeable) - -instance A.FromJSON Pet where - parseJSON = A.withObject "Pet" $ \o -> - Pet - <$> (o .:? "id") - <*> (o .:? "category") - <*> (o .: "name") - <*> (o .: "photoUrls") - <*> (o .:? "tags") - <*> (o .:? "status") - -instance A.ToJSON Pet where - toJSON Pet {..} = - _omitNulls - [ "id" .= petId - , "category" .= petCategory - , "name" .= petName - , "photoUrls" .= petPhotoUrls - , "tags" .= petTags - , "status" .= petStatus - ] - - --- | Construct a value of type 'Pet' (by applying it's required fields, if any) -mkPet - :: Text -- ^ 'petName' - -> [Text] -- ^ 'petPhotoUrls' - -> Pet -mkPet petName petPhotoUrls = - Pet - { petId = Nothing - , petCategory = Nothing - , petName - , petPhotoUrls - , petTags = Nothing - , petStatus = Nothing - } - - - --- ** Tag --- | --- Pet Tag --- --- A tag for a pet -data Tag = Tag - { tagId :: !(Maybe Integer) -- ^ "id" - , tagName :: !(Maybe Text) -- ^ "name" - } deriving (P.Show,P.Eq,P.Typeable) - -instance A.FromJSON Tag where - parseJSON = A.withObject "Tag" $ \o -> - Tag - <$> (o .:? "id") - <*> (o .:? "name") - -instance A.ToJSON Tag where - toJSON Tag {..} = - _omitNulls - [ "id" .= tagId - , "name" .= tagName - ] - - --- | Construct a value of type 'Tag' (by applying it's required fields, if any) -mkTag - :: Tag -mkTag = - Tag - { tagId = Nothing - , tagName = Nothing - } - - - --- ** User --- | --- a User --- --- A User who is purchasing from the pet store -data User = User - { userId :: !(Maybe Integer) -- ^ "id" - , userUsername :: !(Maybe Text) -- ^ "username" - , userFirstName :: !(Maybe Text) -- ^ "firstName" - , userLastName :: !(Maybe Text) -- ^ "lastName" - , userEmail :: !(Maybe Text) -- ^ "email" - , userPassword :: !(Maybe Text) -- ^ "password" - , userPhone :: !(Maybe Text) -- ^ "phone" - , userUserStatus :: !(Maybe Int) -- ^ "userStatus" - User Status - } deriving (P.Show,P.Eq,P.Typeable) - -instance A.FromJSON User where - parseJSON = A.withObject "User" $ \o -> - User - <$> (o .:? "id") - <*> (o .:? "username") - <*> (o .:? "firstName") - <*> (o .:? "lastName") - <*> (o .:? "email") - <*> (o .:? "password") - <*> (o .:? "phone") - <*> (o .:? "userStatus") - -instance A.ToJSON User where - toJSON User {..} = - _omitNulls - [ "id" .= userId - , "username" .= userUsername - , "firstName" .= userFirstName - , "lastName" .= userLastName - , "email" .= userEmail - , "password" .= userPassword - , "phone" .= userPhone - , "userStatus" .= userUserStatus - ] - - --- | Construct a value of type 'User' (by applying it's required fields, if any) -mkUser - :: User -mkUser = - User - { userId = Nothing - , userUsername = Nothing - , userFirstName = Nothing - , userLastName = Nothing - , userEmail = Nothing - , userPassword = Nothing - , userPhone = Nothing - , userUserStatus = Nothing - } - - - --- * Utils - --- | Removes Null fields. (OpenAPI-Specification 2.0 does not allow Null in JSON) - -_omitNulls :: [(Text, A.Value)] -> A.Value -_omitNulls = A.object . P.filter notNull - where - notNull (_, A.Null) = False - notNull _ = True - -_toFormItem :: (WH.ToHttpApiData a, Functor f) => t -> f a -> f (t, [Text]) -_toFormItem name x = (name,) . (:[]) . WH.toQueryParam <$> x - -_emptyToNothing :: Maybe String -> Maybe String -_emptyToNothing (Just "") = Nothing -_emptyToNothing x = x -{-# INLINE _emptyToNothing #-} - -_memptyToNothing :: (P.Monoid a, P.Eq a) => Maybe a -> Maybe a -_memptyToNothing (Just x) | x P.== P.mempty = Nothing -_memptyToNothing x = x -{-# INLINE _memptyToNothing #-} - --- * DateTime Formatting - --- | @_parseISO8601@ -_readDateTime :: (TI.ParseTime t, Monad m, Alternative m) => String -> m t -_readDateTime = - _parseISO8601 -{-# INLINE _readDateTime #-} - --- | @TI.formatISO8601Millis@ -_showDateTime :: (t ~ UTCTime, TI.FormatTime t) => t -> String -_showDateTime = - TI.formatISO8601Millis -{-# INLINE _showDateTime #-} - -_parseISO8601 :: (TI.ParseTime t, Monad m, Alternative m) => String -> m t -_parseISO8601 t = - P.asum $ - P.flip (TI.parseTimeM True TI.defaultTimeLocale) t <$> - ["%FT%T%QZ", "%FT%T%Q%z", "%FT%T%Q%Z"] -{-# INLINE _parseISO8601 #-} - --- * Date Formatting - --- | @TI.parseTimeM True TI.defaultTimeLocale "%Y-%m-%d"@ -_readDate :: (TI.ParseTime t, Monad m) => String -> m t -_readDate = - TI.parseTimeM True TI.defaultTimeLocale "%Y-%m-%d" -{-# INLINE _readDate #-} - --- | @TI.formatTime TI.defaultTimeLocale "%Y-%m-%d"@ -_showDate :: TI.FormatTime t => t -> String -_showDate = - TI.formatTime TI.defaultTimeLocale "%Y-%m-%d" -{-# INLINE _showDate #-} + +import qualified Data.Aeson as A +import qualified Data.ByteString as B +import qualified Data.ByteString.Lazy as BL +import qualified Data.ByteString.Base64.Lazy as BL64 +import qualified Data.Data as P (Data, Typeable) +import qualified Data.HashMap.Lazy as HM +import qualified Data.Map as Map +import qualified Data.Set as Set +import qualified Data.Maybe as P +import qualified Data.Foldable as P +import qualified Web.FormUrlEncoded as WH +import qualified Web.HttpApiData as WH +import qualified Control.DeepSeq as NF +import qualified Data.Ix as P +import qualified Data.Text as T +import qualified Data.Text.Encoding as T +import qualified Control.Arrow as P (left) +import Data.Text (Text) + +import qualified Data.Time as TI +import qualified Data.Time.ISO8601 as TI + +import Control.Applicative ((<|>)) +import Control.Applicative (Alternative) +import Prelude (($), (.),(<$>),(<*>),(>>=),Maybe(..),Bool(..),Char,Double,FilePath,Float,Int,Integer,String,fmap,undefined,mempty,maybe,pure,Monad,Applicative,Functor) +import qualified Prelude as P + + + +-- * Models + + +-- ** AdditionalPropertiesClass +-- | +data AdditionalPropertiesClass = AdditionalPropertiesClass + { additionalPropertiesClassMapProperty :: !(Maybe (Map.Map String Text)) -- ^ "map_property" + , additionalPropertiesClassMapOfMapProperty :: !(Maybe (Map.Map String (Map.Map String Text))) -- ^ "map_of_map_property" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON AdditionalPropertiesClass where + parseJSON = A.withObject "AdditionalPropertiesClass" $ \o -> + AdditionalPropertiesClass + <$> (o .:? "map_property") + <*> (o .:? "map_of_map_property") + +instance A.ToJSON AdditionalPropertiesClass where + toJSON AdditionalPropertiesClass {..} = + _omitNulls + [ "map_property" .= additionalPropertiesClassMapProperty + , "map_of_map_property" .= additionalPropertiesClassMapOfMapProperty + ] + + +-- | Construct a value of type 'AdditionalPropertiesClass' (by applying it's required fields, if any) +mkAdditionalPropertiesClass + :: AdditionalPropertiesClass +mkAdditionalPropertiesClass = + AdditionalPropertiesClass + { additionalPropertiesClassMapProperty = Nothing + , additionalPropertiesClassMapOfMapProperty = Nothing + } + + +-- ** Animal +-- | +data Animal = Animal + { animalClassName :: !(Text) -- ^ /Required/ "className" + , animalColor :: !(Maybe Text) -- ^ "color" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON Animal where + parseJSON = A.withObject "Animal" $ \o -> + Animal + <$> (o .: "className") + <*> (o .:? "color") + +instance A.ToJSON Animal where + toJSON Animal {..} = + _omitNulls + [ "className" .= animalClassName + , "color" .= animalColor + ] + + +-- | Construct a value of type 'Animal' (by applying it's required fields, if any) +mkAnimal + :: Text -- ^ 'animalClassName' + -> Animal +mkAnimal animalClassName = + Animal + { animalClassName + , animalColor = Nothing + } + + +-- ** AnimalFarm +-- | +data AnimalFarm = AnimalFarm + { + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON AnimalFarm where + parseJSON = A.withObject "AnimalFarm" $ \o -> + pure AnimalFarm + + +instance A.ToJSON AnimalFarm where + toJSON AnimalFarm = + _omitNulls + [ + ] + + +-- | Construct a value of type 'AnimalFarm' (by applying it's required fields, if any) +mkAnimalFarm + :: AnimalFarm +mkAnimalFarm = + AnimalFarm + { + } + + +-- ** ApiResponse +-- | +data ApiResponse = ApiResponse + { apiResponseCode :: !(Maybe Int) -- ^ "code" + , apiResponseType :: !(Maybe Text) -- ^ "type" + , apiResponseMessage :: !(Maybe Text) -- ^ "message" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON ApiResponse where + parseJSON = A.withObject "ApiResponse" $ \o -> + ApiResponse + <$> (o .:? "code") + <*> (o .:? "type") + <*> (o .:? "message") + +instance A.ToJSON ApiResponse where + toJSON ApiResponse {..} = + _omitNulls + [ "code" .= apiResponseCode + , "type" .= apiResponseType + , "message" .= apiResponseMessage + ] + + +-- | Construct a value of type 'ApiResponse' (by applying it's required fields, if any) +mkApiResponse + :: ApiResponse +mkApiResponse = + ApiResponse + { apiResponseCode = Nothing + , apiResponseType = Nothing + , apiResponseMessage = Nothing + } + + +-- ** ArrayOfArrayOfNumberOnly +-- | +data ArrayOfArrayOfNumberOnly = ArrayOfArrayOfNumberOnly + { arrayOfArrayOfNumberOnlyArrayArrayNumber :: !(Maybe [[Double]]) -- ^ "ArrayArrayNumber" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON ArrayOfArrayOfNumberOnly where + parseJSON = A.withObject "ArrayOfArrayOfNumberOnly" $ \o -> + ArrayOfArrayOfNumberOnly + <$> (o .:? "ArrayArrayNumber") + +instance A.ToJSON ArrayOfArrayOfNumberOnly where + toJSON ArrayOfArrayOfNumberOnly {..} = + _omitNulls + [ "ArrayArrayNumber" .= arrayOfArrayOfNumberOnlyArrayArrayNumber + ] + + +-- | Construct a value of type 'ArrayOfArrayOfNumberOnly' (by applying it's required fields, if any) +mkArrayOfArrayOfNumberOnly + :: ArrayOfArrayOfNumberOnly +mkArrayOfArrayOfNumberOnly = + ArrayOfArrayOfNumberOnly + { arrayOfArrayOfNumberOnlyArrayArrayNumber = Nothing + } + + +-- ** ArrayOfNumberOnly +-- | +data ArrayOfNumberOnly = ArrayOfNumberOnly + { arrayOfNumberOnlyArrayNumber :: !(Maybe [Double]) -- ^ "ArrayNumber" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON ArrayOfNumberOnly where + parseJSON = A.withObject "ArrayOfNumberOnly" $ \o -> + ArrayOfNumberOnly + <$> (o .:? "ArrayNumber") + +instance A.ToJSON ArrayOfNumberOnly where + toJSON ArrayOfNumberOnly {..} = + _omitNulls + [ "ArrayNumber" .= arrayOfNumberOnlyArrayNumber + ] + + +-- | Construct a value of type 'ArrayOfNumberOnly' (by applying it's required fields, if any) +mkArrayOfNumberOnly + :: ArrayOfNumberOnly +mkArrayOfNumberOnly = + ArrayOfNumberOnly + { arrayOfNumberOnlyArrayNumber = Nothing + } + + +-- ** ArrayTest +-- | +data ArrayTest = ArrayTest + { arrayTestArrayOfString :: !(Maybe [Text]) -- ^ "array_of_string" + , arrayTestArrayArrayOfInteger :: !(Maybe [[Integer]]) -- ^ "array_array_of_integer" + , arrayTestArrayArrayOfModel :: !(Maybe [[ReadOnlyFirst]]) -- ^ "array_array_of_model" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON ArrayTest where + parseJSON = A.withObject "ArrayTest" $ \o -> + ArrayTest + <$> (o .:? "array_of_string") + <*> (o .:? "array_array_of_integer") + <*> (o .:? "array_array_of_model") + +instance A.ToJSON ArrayTest where + toJSON ArrayTest {..} = + _omitNulls + [ "array_of_string" .= arrayTestArrayOfString + , "array_array_of_integer" .= arrayTestArrayArrayOfInteger + , "array_array_of_model" .= arrayTestArrayArrayOfModel + ] + + +-- | Construct a value of type 'ArrayTest' (by applying it's required fields, if any) +mkArrayTest + :: ArrayTest +mkArrayTest = + ArrayTest + { arrayTestArrayOfString = Nothing + , arrayTestArrayArrayOfInteger = Nothing + , arrayTestArrayArrayOfModel = Nothing + } + + +-- ** Capitalization +-- | +data Capitalization = Capitalization + { capitalizationSmallCamel :: !(Maybe Text) -- ^ "smallCamel" + , capitalizationCapitalCamel :: !(Maybe Text) -- ^ "CapitalCamel" + , capitalizationSmallSnake :: !(Maybe Text) -- ^ "small_Snake" + , capitalizationCapitalSnake :: !(Maybe Text) -- ^ "Capital_Snake" + , capitalizationScaEthFlowPoints :: !(Maybe Text) -- ^ "SCA_ETH_Flow_Points" + , capitalizationAttName :: !(Maybe Text) -- ^ "ATT_NAME" - Name of the pet + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON Capitalization where + parseJSON = A.withObject "Capitalization" $ \o -> + Capitalization + <$> (o .:? "smallCamel") + <*> (o .:? "CapitalCamel") + <*> (o .:? "small_Snake") + <*> (o .:? "Capital_Snake") + <*> (o .:? "SCA_ETH_Flow_Points") + <*> (o .:? "ATT_NAME") + +instance A.ToJSON Capitalization where + toJSON Capitalization {..} = + _omitNulls + [ "smallCamel" .= capitalizationSmallCamel + , "CapitalCamel" .= capitalizationCapitalCamel + , "small_Snake" .= capitalizationSmallSnake + , "Capital_Snake" .= capitalizationCapitalSnake + , "SCA_ETH_Flow_Points" .= capitalizationScaEthFlowPoints + , "ATT_NAME" .= capitalizationAttName + ] + + +-- | Construct a value of type 'Capitalization' (by applying it's required fields, if any) +mkCapitalization + :: Capitalization +mkCapitalization = + Capitalization + { capitalizationSmallCamel = Nothing + , capitalizationCapitalCamel = Nothing + , capitalizationSmallSnake = Nothing + , capitalizationCapitalSnake = Nothing + , capitalizationScaEthFlowPoints = Nothing + , capitalizationAttName = Nothing + } + + +-- ** Category +-- | +data Category = Category + { categoryId :: !(Maybe Integer) -- ^ "id" + , categoryName :: !(Maybe Text) -- ^ "name" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON Category where + parseJSON = A.withObject "Category" $ \o -> + Category + <$> (o .:? "id") + <*> (o .:? "name") + +instance A.ToJSON Category where + toJSON Category {..} = + _omitNulls + [ "id" .= categoryId + , "name" .= categoryName + ] + + +-- | Construct a value of type 'Category' (by applying it's required fields, if any) +mkCategory + :: Category +mkCategory = + Category + { categoryId = Nothing + , categoryName = Nothing + } + + +-- ** ClassModel +-- | +-- Model for testing model with \"_class\" property +data ClassModel = ClassModel + { classModelClass :: !(Maybe Text) -- ^ "_class" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON ClassModel where + parseJSON = A.withObject "ClassModel" $ \o -> + ClassModel + <$> (o .:? "_class") + +instance A.ToJSON ClassModel where + toJSON ClassModel {..} = + _omitNulls + [ "_class" .= classModelClass + ] + + +-- | Construct a value of type 'ClassModel' (by applying it's required fields, if any) +mkClassModel + :: ClassModel +mkClassModel = + ClassModel + { classModelClass = Nothing + } + + +-- ** Client +-- | +data Client = Client + { clientClient :: !(Maybe Text) -- ^ "client" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON Client where + parseJSON = A.withObject "Client" $ \o -> + Client + <$> (o .:? "client") + +instance A.ToJSON Client where + toJSON Client {..} = + _omitNulls + [ "client" .= clientClient + ] + + +-- | Construct a value of type 'Client' (by applying it's required fields, if any) +mkClient + :: Client +mkClient = + Client + { clientClient = Nothing + } + + +-- ** EnumArrays +-- | +data EnumArrays = EnumArrays + { enumArraysJustSymbol :: !(Maybe Text) -- ^ "just_symbol" + , enumArraysArrayEnum :: !(Maybe [Text]) -- ^ "array_enum" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON EnumArrays where + parseJSON = A.withObject "EnumArrays" $ \o -> + EnumArrays + <$> (o .:? "just_symbol") + <*> (o .:? "array_enum") + +instance A.ToJSON EnumArrays where + toJSON EnumArrays {..} = + _omitNulls + [ "just_symbol" .= enumArraysJustSymbol + , "array_enum" .= enumArraysArrayEnum + ] + + +-- | Construct a value of type 'EnumArrays' (by applying it's required fields, if any) +mkEnumArrays + :: EnumArrays +mkEnumArrays = + EnumArrays + { enumArraysJustSymbol = Nothing + , enumArraysArrayEnum = Nothing + } + + +-- ** EnumClass +-- | +data EnumClass = EnumClass + { + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON EnumClass where + parseJSON = A.withObject "EnumClass" $ \o -> + pure EnumClass + + +instance A.ToJSON EnumClass where + toJSON EnumClass = + _omitNulls + [ + ] + + +-- | Construct a value of type 'EnumClass' (by applying it's required fields, if any) +mkEnumClass + :: EnumClass +mkEnumClass = + EnumClass + { + } + + +-- ** EnumTest +-- | +data EnumTest = EnumTest + { enumTestEnumString :: !(Maybe Text) -- ^ "enum_string" + , enumTestEnumInteger :: !(Maybe Int) -- ^ "enum_integer" + , enumTestEnumNumber :: !(Maybe Double) -- ^ "enum_number" + , enumTestOuterEnum :: !(Maybe OuterEnum) -- ^ "outerEnum" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON EnumTest where + parseJSON = A.withObject "EnumTest" $ \o -> + EnumTest + <$> (o .:? "enum_string") + <*> (o .:? "enum_integer") + <*> (o .:? "enum_number") + <*> (o .:? "outerEnum") + +instance A.ToJSON EnumTest where + toJSON EnumTest {..} = + _omitNulls + [ "enum_string" .= enumTestEnumString + , "enum_integer" .= enumTestEnumInteger + , "enum_number" .= enumTestEnumNumber + , "outerEnum" .= enumTestOuterEnum + ] + + +-- | Construct a value of type 'EnumTest' (by applying it's required fields, if any) +mkEnumTest + :: EnumTest +mkEnumTest = + EnumTest + { enumTestEnumString = Nothing + , enumTestEnumInteger = Nothing + , enumTestEnumNumber = Nothing + , enumTestOuterEnum = Nothing + } + + +-- ** FormatTest +-- | +data FormatTest = FormatTest + { formatTestInteger :: !(Maybe Int) -- ^ "integer" + , formatTestInt32 :: !(Maybe Int) -- ^ "int32" + , formatTestInt64 :: !(Maybe Integer) -- ^ "int64" + , formatTestNumber :: !(Double) -- ^ /Required/ "number" + , formatTestFloat :: !(Maybe Float) -- ^ "float" + , formatTestDouble :: !(Maybe Double) -- ^ "double" + , formatTestString :: !(Maybe Text) -- ^ "string" + , formatTestByte :: !(ByteArray) -- ^ /Required/ "byte" + , formatTestBinary :: !(Maybe Binary) -- ^ "binary" + , formatTestDate :: !(Date) -- ^ /Required/ "date" + , formatTestDateTime :: !(Maybe DateTime) -- ^ "dateTime" + , formatTestUuid :: !(Maybe Text) -- ^ "uuid" + , formatTestPassword :: !(Text) -- ^ /Required/ "password" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON FormatTest where + parseJSON = A.withObject "FormatTest" $ \o -> + FormatTest + <$> (o .:? "integer") + <*> (o .:? "int32") + <*> (o .:? "int64") + <*> (o .: "number") + <*> (o .:? "float") + <*> (o .:? "double") + <*> (o .:? "string") + <*> (o .: "byte") + <*> (o .:? "binary") + <*> (o .: "date") + <*> (o .:? "dateTime") + <*> (o .:? "uuid") + <*> (o .: "password") + +instance A.ToJSON FormatTest where + toJSON FormatTest {..} = + _omitNulls + [ "integer" .= formatTestInteger + , "int32" .= formatTestInt32 + , "int64" .= formatTestInt64 + , "number" .= formatTestNumber + , "float" .= formatTestFloat + , "double" .= formatTestDouble + , "string" .= formatTestString + , "byte" .= formatTestByte + , "binary" .= formatTestBinary + , "date" .= formatTestDate + , "dateTime" .= formatTestDateTime + , "uuid" .= formatTestUuid + , "password" .= formatTestPassword + ] + + +-- | Construct a value of type 'FormatTest' (by applying it's required fields, if any) +mkFormatTest + :: Double -- ^ 'formatTestNumber' + -> ByteArray -- ^ 'formatTestByte' + -> Date -- ^ 'formatTestDate' + -> Text -- ^ 'formatTestPassword' + -> FormatTest +mkFormatTest formatTestNumber formatTestByte formatTestDate formatTestPassword = + FormatTest + { formatTestInteger = Nothing + , formatTestInt32 = Nothing + , formatTestInt64 = Nothing + , formatTestNumber + , formatTestFloat = Nothing + , formatTestDouble = Nothing + , formatTestString = Nothing + , formatTestByte + , formatTestBinary = Nothing + , formatTestDate + , formatTestDateTime = Nothing + , formatTestUuid = Nothing + , formatTestPassword + } + + +-- ** HasOnlyReadOnly +-- | +data HasOnlyReadOnly = HasOnlyReadOnly + { hasOnlyReadOnlyBar :: !(Maybe Text) -- ^ "bar" + , hasOnlyReadOnlyFoo :: !(Maybe Text) -- ^ "foo" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON HasOnlyReadOnly where + parseJSON = A.withObject "HasOnlyReadOnly" $ \o -> + HasOnlyReadOnly + <$> (o .:? "bar") + <*> (o .:? "foo") + +instance A.ToJSON HasOnlyReadOnly where + toJSON HasOnlyReadOnly {..} = + _omitNulls + [ "bar" .= hasOnlyReadOnlyBar + , "foo" .= hasOnlyReadOnlyFoo + ] + + +-- | Construct a value of type 'HasOnlyReadOnly' (by applying it's required fields, if any) +mkHasOnlyReadOnly + :: HasOnlyReadOnly +mkHasOnlyReadOnly = + HasOnlyReadOnly + { hasOnlyReadOnlyBar = Nothing + , hasOnlyReadOnlyFoo = Nothing + } + + +-- ** MapTest +-- | +data MapTest = MapTest + { mapTestMapMapOfString :: !(Maybe (Map.Map String (Map.Map String Text))) -- ^ "map_map_of_string" + , mapTestMapOfEnumString :: !(Maybe (Map.Map String Text)) -- ^ "map_of_enum_string" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON MapTest where + parseJSON = A.withObject "MapTest" $ \o -> + MapTest + <$> (o .:? "map_map_of_string") + <*> (o .:? "map_of_enum_string") + +instance A.ToJSON MapTest where + toJSON MapTest {..} = + _omitNulls + [ "map_map_of_string" .= mapTestMapMapOfString + , "map_of_enum_string" .= mapTestMapOfEnumString + ] + + +-- | Construct a value of type 'MapTest' (by applying it's required fields, if any) +mkMapTest + :: MapTest +mkMapTest = + MapTest + { mapTestMapMapOfString = Nothing + , mapTestMapOfEnumString = Nothing + } + + +-- ** MixedPropertiesAndAdditionalPropertiesClass +-- | +data MixedPropertiesAndAdditionalPropertiesClass = MixedPropertiesAndAdditionalPropertiesClass + { mixedPropertiesAndAdditionalPropertiesClassUuid :: !(Maybe Text) -- ^ "uuid" + , mixedPropertiesAndAdditionalPropertiesClassDateTime :: !(Maybe DateTime) -- ^ "dateTime" + , mixedPropertiesAndAdditionalPropertiesClassMap :: !(Maybe (Map.Map String Animal)) -- ^ "map" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON MixedPropertiesAndAdditionalPropertiesClass where + parseJSON = A.withObject "MixedPropertiesAndAdditionalPropertiesClass" $ \o -> + MixedPropertiesAndAdditionalPropertiesClass + <$> (o .:? "uuid") + <*> (o .:? "dateTime") + <*> (o .:? "map") + +instance A.ToJSON MixedPropertiesAndAdditionalPropertiesClass where + toJSON MixedPropertiesAndAdditionalPropertiesClass {..} = + _omitNulls + [ "uuid" .= mixedPropertiesAndAdditionalPropertiesClassUuid + , "dateTime" .= mixedPropertiesAndAdditionalPropertiesClassDateTime + , "map" .= mixedPropertiesAndAdditionalPropertiesClassMap + ] + + +-- | Construct a value of type 'MixedPropertiesAndAdditionalPropertiesClass' (by applying it's required fields, if any) +mkMixedPropertiesAndAdditionalPropertiesClass + :: MixedPropertiesAndAdditionalPropertiesClass +mkMixedPropertiesAndAdditionalPropertiesClass = + MixedPropertiesAndAdditionalPropertiesClass + { mixedPropertiesAndAdditionalPropertiesClassUuid = Nothing + , mixedPropertiesAndAdditionalPropertiesClassDateTime = Nothing + , mixedPropertiesAndAdditionalPropertiesClassMap = Nothing + } + + +-- ** Model200Response +-- | +-- Model for testing model name starting with number +data Model200Response = Model200Response + { model200ResponseName :: !(Maybe Int) -- ^ "name" + , model200ResponseClass :: !(Maybe Text) -- ^ "class" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON Model200Response where + parseJSON = A.withObject "Model200Response" $ \o -> + Model200Response + <$> (o .:? "name") + <*> (o .:? "class") + +instance A.ToJSON Model200Response where + toJSON Model200Response {..} = + _omitNulls + [ "name" .= model200ResponseName + , "class" .= model200ResponseClass + ] + + +-- | Construct a value of type 'Model200Response' (by applying it's required fields, if any) +mkModel200Response + :: Model200Response +mkModel200Response = + Model200Response + { model200ResponseName = Nothing + , model200ResponseClass = Nothing + } + + +-- ** ModelList +-- | +data ModelList = ModelList + { modelList123List :: !(Maybe Text) -- ^ "123-list" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON ModelList where + parseJSON = A.withObject "ModelList" $ \o -> + ModelList + <$> (o .:? "123-list") + +instance A.ToJSON ModelList where + toJSON ModelList {..} = + _omitNulls + [ "123-list" .= modelList123List + ] + + +-- | Construct a value of type 'ModelList' (by applying it's required fields, if any) +mkModelList + :: ModelList +mkModelList = + ModelList + { modelList123List = Nothing + } + + +-- ** ModelReturn +-- | +-- Model for testing reserved words +data ModelReturn = ModelReturn + { modelReturnReturn :: !(Maybe Int) -- ^ "return" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON ModelReturn where + parseJSON = A.withObject "ModelReturn" $ \o -> + ModelReturn + <$> (o .:? "return") + +instance A.ToJSON ModelReturn where + toJSON ModelReturn {..} = + _omitNulls + [ "return" .= modelReturnReturn + ] + + +-- | Construct a value of type 'ModelReturn' (by applying it's required fields, if any) +mkModelReturn + :: ModelReturn +mkModelReturn = + ModelReturn + { modelReturnReturn = Nothing + } + + +-- ** Name +-- | +-- Model for testing model name same as property name +data Name = Name + { nameName :: !(Int) -- ^ /Required/ "name" + , nameSnakeCase :: !(Maybe Int) -- ^ "snake_case" + , nameProperty :: !(Maybe Text) -- ^ "property" + , name123Number :: !(Maybe Int) -- ^ "123Number" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON Name where + parseJSON = A.withObject "Name" $ \o -> + Name + <$> (o .: "name") + <*> (o .:? "snake_case") + <*> (o .:? "property") + <*> (o .:? "123Number") + +instance A.ToJSON Name where + toJSON Name {..} = + _omitNulls + [ "name" .= nameName + , "snake_case" .= nameSnakeCase + , "property" .= nameProperty + , "123Number" .= name123Number + ] + + +-- | Construct a value of type 'Name' (by applying it's required fields, if any) +mkName + :: Int -- ^ 'nameName' + -> Name +mkName nameName = + Name + { nameName + , nameSnakeCase = Nothing + , nameProperty = Nothing + , name123Number = Nothing + } + + +-- ** NumberOnly +-- | +data NumberOnly = NumberOnly + { numberOnlyJustNumber :: !(Maybe Double) -- ^ "JustNumber" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON NumberOnly where + parseJSON = A.withObject "NumberOnly" $ \o -> + NumberOnly + <$> (o .:? "JustNumber") + +instance A.ToJSON NumberOnly where + toJSON NumberOnly {..} = + _omitNulls + [ "JustNumber" .= numberOnlyJustNumber + ] + + +-- | Construct a value of type 'NumberOnly' (by applying it's required fields, if any) +mkNumberOnly + :: NumberOnly +mkNumberOnly = + NumberOnly + { numberOnlyJustNumber = Nothing + } + + +-- ** Order +-- | +data Order = Order + { orderId :: !(Maybe Integer) -- ^ "id" + , orderPetId :: !(Maybe Integer) -- ^ "petId" + , orderQuantity :: !(Maybe Int) -- ^ "quantity" + , orderShipDate :: !(Maybe DateTime) -- ^ "shipDate" + , orderStatus :: !(Maybe Text) -- ^ "status" - Order Status + , orderComplete :: !(Maybe Bool) -- ^ "complete" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON Order where + parseJSON = A.withObject "Order" $ \o -> + Order + <$> (o .:? "id") + <*> (o .:? "petId") + <*> (o .:? "quantity") + <*> (o .:? "shipDate") + <*> (o .:? "status") + <*> (o .:? "complete") + +instance A.ToJSON Order where + toJSON Order {..} = + _omitNulls + [ "id" .= orderId + , "petId" .= orderPetId + , "quantity" .= orderQuantity + , "shipDate" .= orderShipDate + , "status" .= orderStatus + , "complete" .= orderComplete + ] + + +-- | Construct a value of type 'Order' (by applying it's required fields, if any) +mkOrder + :: Order +mkOrder = + Order + { orderId = Nothing + , orderPetId = Nothing + , orderQuantity = Nothing + , orderShipDate = Nothing + , orderStatus = Nothing + , orderComplete = Nothing + } + + +-- ** OuterBoolean +-- | +data OuterBoolean = OuterBoolean + { + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON OuterBoolean where + parseJSON = A.withObject "OuterBoolean" $ \o -> + pure OuterBoolean + + +instance A.ToJSON OuterBoolean where + toJSON OuterBoolean = + _omitNulls + [ + ] + + +-- | Construct a value of type 'OuterBoolean' (by applying it's required fields, if any) +mkOuterBoolean + :: OuterBoolean +mkOuterBoolean = + OuterBoolean + { + } + + +-- ** OuterComposite +-- | +data OuterComposite = OuterComposite + { outerCompositeMyNumber :: !(Maybe OuterNumber) -- ^ "my_number" + , outerCompositeMyString :: !(Maybe OuterString) -- ^ "my_string" + , outerCompositeMyBoolean :: !(Maybe OuterBoolean) -- ^ "my_boolean" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON OuterComposite where + parseJSON = A.withObject "OuterComposite" $ \o -> + OuterComposite + <$> (o .:? "my_number") + <*> (o .:? "my_string") + <*> (o .:? "my_boolean") + +instance A.ToJSON OuterComposite where + toJSON OuterComposite {..} = + _omitNulls + [ "my_number" .= outerCompositeMyNumber + , "my_string" .= outerCompositeMyString + , "my_boolean" .= outerCompositeMyBoolean + ] + + +-- | Construct a value of type 'OuterComposite' (by applying it's required fields, if any) +mkOuterComposite + :: OuterComposite +mkOuterComposite = + OuterComposite + { outerCompositeMyNumber = Nothing + , outerCompositeMyString = Nothing + , outerCompositeMyBoolean = Nothing + } + + +-- ** OuterEnum +-- | +data OuterEnum = OuterEnum + { + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON OuterEnum where + parseJSON = A.withObject "OuterEnum" $ \o -> + pure OuterEnum + + +instance A.ToJSON OuterEnum where + toJSON OuterEnum = + _omitNulls + [ + ] + + +-- | Construct a value of type 'OuterEnum' (by applying it's required fields, if any) +mkOuterEnum + :: OuterEnum +mkOuterEnum = + OuterEnum + { + } + + +-- ** OuterNumber +-- | +data OuterNumber = OuterNumber + { + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON OuterNumber where + parseJSON = A.withObject "OuterNumber" $ \o -> + pure OuterNumber + + +instance A.ToJSON OuterNumber where + toJSON OuterNumber = + _omitNulls + [ + ] + + +-- | Construct a value of type 'OuterNumber' (by applying it's required fields, if any) +mkOuterNumber + :: OuterNumber +mkOuterNumber = + OuterNumber + { + } + + +-- ** OuterString +-- | +data OuterString = OuterString + { + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON OuterString where + parseJSON = A.withObject "OuterString" $ \o -> + pure OuterString + + +instance A.ToJSON OuterString where + toJSON OuterString = + _omitNulls + [ + ] + + +-- | Construct a value of type 'OuterString' (by applying it's required fields, if any) +mkOuterString + :: OuterString +mkOuterString = + OuterString + { + } + + +-- ** Pet +-- | +data Pet = Pet + { petId :: !(Maybe Integer) -- ^ "id" + , petCategory :: !(Maybe Category) -- ^ "category" + , petName :: !(Text) -- ^ /Required/ "name" + , petPhotoUrls :: !([Text]) -- ^ /Required/ "photoUrls" + , petTags :: !(Maybe [Tag]) -- ^ "tags" + , petStatus :: !(Maybe Text) -- ^ "status" - pet status in the store + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON Pet where + parseJSON = A.withObject "Pet" $ \o -> + Pet + <$> (o .:? "id") + <*> (o .:? "category") + <*> (o .: "name") + <*> (o .: "photoUrls") + <*> (o .:? "tags") + <*> (o .:? "status") + +instance A.ToJSON Pet where + toJSON Pet {..} = + _omitNulls + [ "id" .= petId + , "category" .= petCategory + , "name" .= petName + , "photoUrls" .= petPhotoUrls + , "tags" .= petTags + , "status" .= petStatus + ] + + +-- | Construct a value of type 'Pet' (by applying it's required fields, if any) +mkPet + :: Text -- ^ 'petName' + -> [Text] -- ^ 'petPhotoUrls' + -> Pet +mkPet petName petPhotoUrls = + Pet + { petId = Nothing + , petCategory = Nothing + , petName + , petPhotoUrls + , petTags = Nothing + , petStatus = Nothing + } + + +-- ** ReadOnlyFirst +-- | +data ReadOnlyFirst = ReadOnlyFirst + { readOnlyFirstBar :: !(Maybe Text) -- ^ "bar" + , readOnlyFirstBaz :: !(Maybe Text) -- ^ "baz" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON ReadOnlyFirst where + parseJSON = A.withObject "ReadOnlyFirst" $ \o -> + ReadOnlyFirst + <$> (o .:? "bar") + <*> (o .:? "baz") + +instance A.ToJSON ReadOnlyFirst where + toJSON ReadOnlyFirst {..} = + _omitNulls + [ "bar" .= readOnlyFirstBar + , "baz" .= readOnlyFirstBaz + ] + + +-- | Construct a value of type 'ReadOnlyFirst' (by applying it's required fields, if any) +mkReadOnlyFirst + :: ReadOnlyFirst +mkReadOnlyFirst = + ReadOnlyFirst + { readOnlyFirstBar = Nothing + , readOnlyFirstBaz = Nothing + } + + +-- ** SpecialModelName +-- | +data SpecialModelName = SpecialModelName + { specialModelNameSpecialPropertyName :: !(Maybe Integer) -- ^ "$special[property.name]" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON SpecialModelName where + parseJSON = A.withObject "SpecialModelName" $ \o -> + SpecialModelName + <$> (o .:? "$special[property.name]") + +instance A.ToJSON SpecialModelName where + toJSON SpecialModelName {..} = + _omitNulls + [ "$special[property.name]" .= specialModelNameSpecialPropertyName + ] + + +-- | Construct a value of type 'SpecialModelName' (by applying it's required fields, if any) +mkSpecialModelName + :: SpecialModelName +mkSpecialModelName = + SpecialModelName + { specialModelNameSpecialPropertyName = Nothing + } + + +-- ** Tag +-- | +data Tag = Tag + { tagId :: !(Maybe Integer) -- ^ "id" + , tagName :: !(Maybe Text) -- ^ "name" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON Tag where + parseJSON = A.withObject "Tag" $ \o -> + Tag + <$> (o .:? "id") + <*> (o .:? "name") + +instance A.ToJSON Tag where + toJSON Tag {..} = + _omitNulls + [ "id" .= tagId + , "name" .= tagName + ] + + +-- | Construct a value of type 'Tag' (by applying it's required fields, if any) +mkTag + :: Tag +mkTag = + Tag + { tagId = Nothing + , tagName = Nothing + } + + +-- ** User +-- | +data User = User + { userId :: !(Maybe Integer) -- ^ "id" + , userUsername :: !(Maybe Text) -- ^ "username" + , userFirstName :: !(Maybe Text) -- ^ "firstName" + , userLastName :: !(Maybe Text) -- ^ "lastName" + , userEmail :: !(Maybe Text) -- ^ "email" + , userPassword :: !(Maybe Text) -- ^ "password" + , userPhone :: !(Maybe Text) -- ^ "phone" + , userUserStatus :: !(Maybe Int) -- ^ "userStatus" - User Status + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON User where + parseJSON = A.withObject "User" $ \o -> + User + <$> (o .:? "id") + <*> (o .:? "username") + <*> (o .:? "firstName") + <*> (o .:? "lastName") + <*> (o .:? "email") + <*> (o .:? "password") + <*> (o .:? "phone") + <*> (o .:? "userStatus") + +instance A.ToJSON User where + toJSON User {..} = + _omitNulls + [ "id" .= userId + , "username" .= userUsername + , "firstName" .= userFirstName + , "lastName" .= userLastName + , "email" .= userEmail + , "password" .= userPassword + , "phone" .= userPhone + , "userStatus" .= userUserStatus + ] + + +-- | Construct a value of type 'User' (by applying it's required fields, if any) +mkUser + :: User +mkUser = + User + { userId = Nothing + , userUsername = Nothing + , userFirstName = Nothing + , userLastName = Nothing + , userEmail = Nothing + , userPassword = Nothing + , userPhone = Nothing + , userUserStatus = Nothing + } + + +-- ** Cat +-- | +data Cat = Cat + { catClassName :: !(Text) -- ^ /Required/ "className" + , catColor :: !(Maybe Text) -- ^ "color" + , catDeclawed :: !(Maybe Bool) -- ^ "declawed" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON Cat where + parseJSON = A.withObject "Cat" $ \o -> + Cat + <$> (o .: "className") + <*> (o .:? "color") + <*> (o .:? "declawed") + +instance A.ToJSON Cat where + toJSON Cat {..} = + _omitNulls + [ "className" .= catClassName + , "color" .= catColor + , "declawed" .= catDeclawed + ] + + +-- | Construct a value of type 'Cat' (by applying it's required fields, if any) +mkCat + :: Text -- ^ 'catClassName' + -> Cat +mkCat catClassName = + Cat + { catClassName + , catColor = Nothing + , catDeclawed = Nothing + } + + +-- ** Dog +-- | +data Dog = Dog + { dogClassName :: !(Text) -- ^ /Required/ "className" + , dogColor :: !(Maybe Text) -- ^ "color" + , dogBreed :: !(Maybe Text) -- ^ "breed" + } deriving (P.Show,P.Eq,P.Typeable) + +instance A.FromJSON Dog where + parseJSON = A.withObject "Dog" $ \o -> + Dog + <$> (o .: "className") + <*> (o .:? "color") + <*> (o .:? "breed") + +instance A.ToJSON Dog where + toJSON Dog {..} = + _omitNulls + [ "className" .= dogClassName + , "color" .= dogColor + , "breed" .= dogBreed + ] + + +-- | Construct a value of type 'Dog' (by applying it's required fields, if any) +mkDog + :: Text -- ^ 'dogClassName' + -> Dog +mkDog dogClassName = + Dog + { dogClassName + , dogColor = Nothing + , dogBreed = Nothing + } + + +-- * Utils + +-- | Removes Null fields. (OpenAPI-Specification 2.0 does not allow Null in JSON) + +_omitNulls :: [(Text, A.Value)] -> A.Value +_omitNulls = A.object . P.filter notNull + where + notNull (_, A.Null) = False + notNull _ = True + +_toFormItem :: (WH.ToHttpApiData a, Functor f) => t -> f a -> f (t, [Text]) +_toFormItem name x = (name,) . (:[]) . WH.toQueryParam <$> x + +_emptyToNothing :: Maybe String -> Maybe String +_emptyToNothing (Just "") = Nothing +_emptyToNothing x = x +{-# INLINE _emptyToNothing #-} + +_memptyToNothing :: (P.Monoid a, P.Eq a) => Maybe a -> Maybe a +_memptyToNothing (Just x) | x P.== P.mempty = Nothing +_memptyToNothing x = x +{-# INLINE _memptyToNothing #-} + +-- * DateTime Formatting + +newtype DateTime = DateTime { unDateTime :: TI.UTCTime } + deriving (P.Eq,P.Data,P.Ord,P.Typeable,NF.NFData,TI.ParseTime,TI.FormatTime) +instance A.FromJSON DateTime where + parseJSON = A.withText "DateTime" (_readDateTime . T.unpack) +instance A.ToJSON DateTime where + toJSON (DateTime t) = A.toJSON (_showDateTime t) +instance WH.FromHttpApiData DateTime where + parseUrlPiece = P.left T.pack . _readDateTime . T.unpack +instance WH.ToHttpApiData DateTime where + toUrlPiece (DateTime t) = T.pack (_showDateTime t) +instance P.Show DateTime where + show (DateTime t) = _showDateTime t + +-- | @_parseISO8601@ +_readDateTime :: (TI.ParseTime t, Monad m, Alternative m) => String -> m t +_readDateTime = + _parseISO8601 +{-# INLINE _readDateTime #-} + +-- | @TI.formatISO8601Millis@ +_showDateTime :: (t ~ TI.UTCTime, TI.FormatTime t) => t -> String +_showDateTime = + TI.formatISO8601Millis +{-# INLINE _showDateTime #-} + +_parseISO8601 :: (TI.ParseTime t, Monad m, Alternative m) => String -> m t +_parseISO8601 t = + P.asum $ + P.flip (TI.parseTimeM True TI.defaultTimeLocale) t <$> + ["%FT%T%QZ", "%FT%T%Q%z", "%FT%T%Q%Z"] +{-# INLINE _parseISO8601 #-} + +-- * Date Formatting + +newtype Date = Date { unDate :: TI.Day } + deriving (P.Enum,P.Eq,P.Data,P.Ord,P.Ix,NF.NFData,TI.ParseTime,TI.FormatTime) +instance A.FromJSON Date where + parseJSON = A.withText "Date" (_readDate . T.unpack) +instance A.ToJSON Date where + toJSON (Date t) = A.toJSON (_showDate t) +instance WH.FromHttpApiData Date where + parseUrlPiece = P.left T.pack . _readDate . T.unpack +instance WH.ToHttpApiData Date where + toUrlPiece (Date t) = T.pack (_showDate t) +instance P.Show Date where + show (Date t) = _showDate t + +-- | @TI.parseTimeM True TI.defaultTimeLocale "%Y-%m-%d"@ +_readDate :: (TI.ParseTime t, Monad m) => String -> m t +_readDate = + TI.parseTimeM True TI.defaultTimeLocale "%Y-%m-%d" +{-# INLINE _readDate #-} + +-- | @TI.formatTime TI.defaultTimeLocale "%Y-%m-%d"@ +_showDate :: TI.FormatTime t => t -> String +_showDate = + TI.formatTime TI.defaultTimeLocale "%Y-%m-%d" +{-# INLINE _showDate #-} + +-- * Byte/Binary Formatting + + +-- | base64 encoded characters +newtype ByteArray = ByteArray { unByteArray :: BL.ByteString } + deriving (P.Eq,P.Data,P.Ord,P.Typeable,NF.NFData) + +instance A.FromJSON ByteArray where + parseJSON = A.withText "ByteArray" _readByteArray +instance A.ToJSON ByteArray where + toJSON = A.toJSON . _showByteArray +instance WH.FromHttpApiData ByteArray where + parseUrlPiece = P.left T.pack . _readByteArray +instance WH.ToHttpApiData ByteArray where + toUrlPiece = _showByteArray +instance P.Show ByteArray where + show = T.unpack . _showByteArray + +-- | read base64 encoded characters +_readByteArray :: Monad m => Text -> m ByteArray +_readByteArray = P.either P.fail (pure . ByteArray) . BL64.decode . BL.fromStrict . T.encodeUtf8 +{-# INLINE _readByteArray #-} + +-- | show base64 encoded characters +_showByteArray :: ByteArray -> Text +_showByteArray = T.decodeUtf8 . BL.toStrict . BL64.encode . unByteArray +{-# INLINE _showByteArray #-} + +-- | any sequence of octets +newtype Binary = Binary { unBinary :: BL.ByteString } + deriving (P.Eq,P.Data,P.Ord,P.Typeable,NF.NFData) + +instance A.FromJSON Binary where + parseJSON = A.withText "Binary" _readBinaryBase64 +instance A.ToJSON Binary where + toJSON = A.toJSON . _showBinaryBase64 +instance WH.FromHttpApiData Binary where + parseUrlPiece = P.left T.pack . _readBinaryBase64 +instance WH.ToHttpApiData Binary where + toUrlPiece = _showBinaryBase64 +instance P.Show Binary where + show = T.unpack . _showBinaryBase64 + +_readBinaryBase64 :: Monad m => Text -> m Binary +_readBinaryBase64 = P.either P.fail (pure . Binary) . BL64.decode . BL.fromStrict . T.encodeUtf8 +{-# INLINE _readBinaryBase64 #-} + +_showBinaryBase64 :: Binary -> Text +_showBinaryBase64 = T.decodeUtf8 . BL.toStrict . BL64.encode . unBinary +{-# INLINE _showBinaryBase64 #-} diff --git a/swagger-petstore.cabal b/swagger-petstore.cabal --- a/swagger-petstore.cabal +++ b/swagger-petstore.cabal @@ -3,26 +3,27 @@ -- see: https://github.com/sol/hpack name: swagger-petstore -version: 0.0.1.1 +version: 0.0.1.2 synopsis: Auto-generated swagger-petstore API Client description: . Client library for calling the swagger-petstore API based on http-client. - host: petstore.swagger.io . - base path: http://petstore.swagger.io/v2 + host: petstore.swagger.io:80 . + base path: http://petstore.swagger.io:80/v2 + . apiVersion: 0.0.1 . swagger version: 2.0 . - OpenAPI-Specification: https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md + OpenAPI-Specification: https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md + . category: Web homepage: https://github.com/swagger-api/swagger-codegen#readme -author: Jon Schoning -maintainer: jonschoning@gmail.com -copyright: Copyright (c) 2015 Jon Schoning +author: Author Name Here +maintainer: author.name@email.com +copyright: YEAR - AUTHOR license: MIT -license-file: LICENSE build-type: Simple cabal-version: >= 1.10 @@ -41,6 +42,7 @@ , unordered-containers , aeson >=1.0 && <2.0 , bytestring >=0.10.0 && <0.11 + , base64-bytestring >1.0 && <2.0 , containers >=0.5.0.0 && <0.6 , http-types >=0.8 && <0.10 , http-client >=0.5 && <0.6 @@ -54,10 +56,11 @@ , network >=2.6.2 && <2.7 , random >=1.1 , exceptions >= 0.4 - , monad-logger >=0.3 && <0.4 + , katip >=0.4 && < 0.6 , safe-exceptions <0.2 , case-insensitive , microlens >= 0.4.3 && <0.5 + , deepseq >= 1.4 && <1.6 exposed-modules: SwaggerPetstore SwaggerPetstore.API @@ -65,6 +68,7 @@ SwaggerPetstore.Model SwaggerPetstore.MimeTypes SwaggerPetstore.Lens + SwaggerPetstore.Logging other-modules: Paths_swagger_petstore default-language: Haskell2010 diff --git a/swagger.json b/swagger.json --- a/swagger.json +++ b/swagger.json @@ -1,7 +1,7 @@ { "swagger" : "2.0", "info" : { - "description" : "This is a sample server Petstore server. You can find out more about Swagger at [http://swagger.io](http://swagger.io) or on [irc.freenode.net, #swagger](http://swagger.io/irc/). For this sample, you can use the api key `special-key` to test the authorization filters.", + "description" : "This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\", "version" : "1.0.0", "title" : "Swagger Petstore", "termsOfService" : "http://swagger.io/terms/", @@ -13,7 +13,7 @@ "url" : "http://www.apache.org/licenses/LICENSE-2.0.html" } }, - "host" : "petstore.swagger.io", + "host" : "petstore.swagger.io:80", "basePath" : "/v2", "tags" : [ { "name" : "pet", @@ -363,7 +363,7 @@ } } }, - "/store/order/{orderId}" : { + "/store/order/{order_id}" : { "get" : { "tags" : [ "store" ], "summary" : "Find purchase order by ID", @@ -371,7 +371,7 @@ "operationId" : "getOrderById", "produces" : [ "application/xml", "application/json" ], "parameters" : [ { - "name" : "orderId", + "name" : "order_id", "in" : "path", "description" : "ID of pet that needs to be fetched", "required" : true, @@ -402,7 +402,7 @@ "operationId" : "deleteOrder", "produces" : [ "application/xml", "application/json" ], "parameters" : [ { - "name" : "orderId", + "name" : "order_id", "in" : "path", "description" : "ID of the order that needs to be deleted", "required" : true, @@ -634,6 +634,428 @@ } } } + }, + "/fake_classname_test" : { + "patch" : { + "tags" : [ "fake_classname_tags 123#$%^" ], + "summary" : "To test class name in snake case", + "operationId" : "testClassname", + "consumes" : [ "application/json" ], + "produces" : [ "application/json" ], + "parameters" : [ { + "in" : "body", + "name" : "body", + "description" : "client model", + "required" : true, + "schema" : { + "$ref" : "#/definitions/Client" + } + } ], + "responses" : { + "200" : { + "description" : "successful operation", + "schema" : { + "$ref" : "#/definitions/Client" + } + } + }, + "security" : [ { + "api_key_query" : [ ] + } ] + } + }, + "/fake" : { + "get" : { + "tags" : [ "fake" ], + "summary" : "To test enum parameters", + "description" : "To test enum parameters", + "operationId" : "testEnumParameters", + "consumes" : [ "*/*" ], + "produces" : [ "*/*" ], + "parameters" : [ { + "name" : "enum_form_string_array", + "in" : "formData", + "description" : "Form parameter enum test (string array)", + "required" : false, + "type" : "array", + "items" : { + "type" : "string", + "enum" : [ ">", "$" ], + "default" : "$" + } + }, { + "name" : "enum_form_string", + "in" : "formData", + "description" : "Form parameter enum test (string)", + "required" : false, + "type" : "string", + "default" : "-efg", + "enum" : [ "_abc", "-efg", "(xyz)" ] + }, { + "name" : "enum_header_string_array", + "in" : "header", + "description" : "Header parameter enum test (string array)", + "required" : false, + "type" : "array", + "items" : { + "type" : "string", + "enum" : [ ">", "$" ], + "default" : "$" + } + }, { + "name" : "enum_header_string", + "in" : "header", + "description" : "Header parameter enum test (string)", + "required" : false, + "type" : "string", + "default" : "-efg", + "enum" : [ "_abc", "-efg", "(xyz)" ] + }, { + "name" : "enum_query_string_array", + "in" : "query", + "description" : "Query parameter enum test (string array)", + "required" : false, + "type" : "array", + "items" : { + "type" : "string", + "enum" : [ ">", "$" ], + "default" : "$" + } + }, { + "name" : "enum_query_string", + "in" : "query", + "description" : "Query parameter enum test (string)", + "required" : false, + "type" : "string", + "default" : "-efg", + "enum" : [ "_abc", "-efg", "(xyz)" ] + }, { + "name" : "enum_query_integer", + "in" : "query", + "description" : "Query parameter enum test (double)", + "required" : false, + "type" : "integer", + "format" : "int32", + "enum" : [ 1, -2 ] + }, { + "name" : "enum_query_double", + "in" : "formData", + "description" : "Query parameter enum test (double)", + "required" : false, + "type" : "number", + "format" : "double", + "enum" : [ 1.1, -1.2 ] + } ], + "responses" : { + "400" : { + "description" : "Invalid request" + }, + "404" : { + "description" : "Not found" + } + } + }, + "post" : { + "tags" : [ "fake" ], + "summary" : "Fake endpoint for testing various parameters\n假端點\n偽のエンドポイント\n가짜 엔드 포인트\n", + "description" : "Fake endpoint for testing various parameters\n假端點\n偽のエンドポイント\n가짜 엔드 포인트\n", + "operationId" : "testEndpointParameters", + "consumes" : [ "application/xml; charset=utf-8", "application/json; charset=utf-8" ], + "produces" : [ "application/xml; charset=utf-8", "application/json; charset=utf-8" ], + "parameters" : [ { + "name" : "integer", + "in" : "formData", + "description" : "None", + "required" : false, + "type" : "integer", + "maximum" : 100, + "minimum" : 10 + }, { + "name" : "int32", + "in" : "formData", + "description" : "None", + "required" : false, + "type" : "integer", + "maximum" : 200, + "minimum" : 20, + "format" : "int32" + }, { + "name" : "int64", + "in" : "formData", + "description" : "None", + "required" : false, + "type" : "integer", + "format" : "int64" + }, { + "name" : "number", + "in" : "formData", + "description" : "None", + "required" : true, + "type" : "number", + "maximum" : 543.2, + "minimum" : 32.1 + }, { + "name" : "float", + "in" : "formData", + "description" : "None", + "required" : false, + "type" : "number", + "maximum" : 987.6, + "format" : "float" + }, { + "name" : "double", + "in" : "formData", + "description" : "None", + "required" : true, + "type" : "number", + "maximum" : 123.4, + "minimum" : 67.8, + "format" : "double" + }, { + "name" : "string", + "in" : "formData", + "description" : "None", + "required" : false, + "type" : "string", + "pattern" : "/[a-z]/i" + }, { + "name" : "pattern_without_delimiter", + "in" : "formData", + "description" : "None", + "required" : true, + "type" : "string", + "pattern" : "^[A-Z].*" + }, { + "name" : "byte", + "in" : "formData", + "description" : "None", + "required" : true, + "type" : "string", + "format" : "byte" + }, { + "name" : "binary", + "in" : "formData", + "description" : "None", + "required" : false, + "type" : "string", + "format" : "binary" + }, { + "name" : "date", + "in" : "formData", + "description" : "None", + "required" : false, + "type" : "string", + "format" : "date" + }, { + "name" : "dateTime", + "in" : "formData", + "description" : "None", + "required" : false, + "type" : "string", + "format" : "date-time" + }, { + "name" : "password", + "in" : "formData", + "description" : "None", + "required" : false, + "type" : "string", + "maxLength" : 64, + "minLength" : 10, + "format" : "password" + }, { + "name" : "callback", + "in" : "formData", + "description" : "None", + "required" : false, + "type" : "string" + } ], + "responses" : { + "400" : { + "description" : "Invalid username supplied" + }, + "404" : { + "description" : "User not found" + } + }, + "security" : [ { + "http_basic_test" : [ ] + } ] + }, + "patch" : { + "tags" : [ "fake" ], + "summary" : "To test \"client\" model", + "description" : "To test \"client\" model", + "operationId" : "testClientModel", + "consumes" : [ "application/json" ], + "produces" : [ "application/json" ], + "parameters" : [ { + "in" : "body", + "name" : "body", + "description" : "client model", + "required" : true, + "schema" : { + "$ref" : "#/definitions/Client" + } + } ], + "responses" : { + "200" : { + "description" : "successful operation", + "schema" : { + "$ref" : "#/definitions/Client" + } + } + } + } + }, + "/fake/outer/number" : { + "post" : { + "tags" : [ "fake" ], + "description" : "Test serialization of outer number types", + "operationId" : "fakeOuterNumberSerialize", + "parameters" : [ { + "in" : "body", + "name" : "body", + "description" : "Input number as post body", + "required" : false, + "schema" : { + "$ref" : "#/definitions/OuterNumber" + } + } ], + "responses" : { + "200" : { + "description" : "Output number", + "schema" : { + "$ref" : "#/definitions/OuterNumber" + } + } + } + } + }, + "/fake/outer/string" : { + "post" : { + "tags" : [ "fake" ], + "description" : "Test serialization of outer string types", + "operationId" : "fakeOuterStringSerialize", + "parameters" : [ { + "in" : "body", + "name" : "body", + "description" : "Input string as post body", + "required" : false, + "schema" : { + "$ref" : "#/definitions/OuterString" + } + } ], + "responses" : { + "200" : { + "description" : "Output string", + "schema" : { + "$ref" : "#/definitions/OuterString" + } + } + } + } + }, + "/fake/outer/boolean" : { + "post" : { + "tags" : [ "fake" ], + "description" : "Test serialization of outer boolean types", + "operationId" : "fakeOuterBooleanSerialize", + "parameters" : [ { + "in" : "body", + "name" : "body", + "description" : "Input boolean as post body", + "required" : false, + "schema" : { + "$ref" : "#/definitions/OuterBoolean" + } + } ], + "responses" : { + "200" : { + "description" : "Output boolean", + "schema" : { + "$ref" : "#/definitions/OuterBoolean" + } + } + } + } + }, + "/fake/outer/composite" : { + "post" : { + "tags" : [ "fake" ], + "description" : "Test serialization of object with outer number type", + "operationId" : "fakeOuterCompositeSerialize", + "parameters" : [ { + "in" : "body", + "name" : "body", + "description" : "Input composite as post body", + "required" : false, + "schema" : { + "$ref" : "#/definitions/OuterComposite" + } + } ], + "responses" : { + "200" : { + "description" : "Output composite", + "schema" : { + "$ref" : "#/definitions/OuterComposite" + } + } + } + } + }, + "/fake/jsonFormData" : { + "get" : { + "tags" : [ "fake" ], + "summary" : "test json serialization of form data", + "description" : "", + "operationId" : "testJsonFormData", + "consumes" : [ "application/json" ], + "parameters" : [ { + "name" : "param", + "in" : "formData", + "description" : "field1", + "required" : true, + "type" : "string" + }, { + "name" : "param2", + "in" : "formData", + "description" : "field2", + "required" : true, + "type" : "string" + } ], + "responses" : { + "200" : { + "description" : "successful operation" + } + } + } + }, + "/another-fake/dummy" : { + "patch" : { + "tags" : [ "$another-fake?" ], + "summary" : "To test special tags", + "description" : "To test special tags", + "operationId" : "test_special_tags", + "consumes" : [ "application/json" ], + "produces" : [ "application/json" ], + "parameters" : [ { + "in" : "body", + "name" : "body", + "description" : "client model", + "required" : true, + "schema" : { + "$ref" : "#/definitions/Client" + } + } ], + "responses" : { + "200" : { + "description" : "successful operation", + "schema" : { + "$ref" : "#/definitions/Client" + } + } + } + } } }, "securityDefinitions" : { @@ -650,6 +1072,14 @@ "type" : "apiKey", "name" : "api_key", "in" : "header" + }, + "api_key_query" : { + "type" : "apiKey", + "name" : "api_key_query", + "in" : "query" + }, + "http_basic_test" : { + "type" : "basic" } }, "definitions" : { @@ -682,8 +1112,6 @@ "default" : false } }, - "title" : "Pet Order", - "description" : "An order for a pets from the pet store", "xml" : { "name" : "Order" } @@ -699,8 +1127,6 @@ "type" : "string" } }, - "title" : "Pet catehgry", - "description" : "A category for a pet", "xml" : { "name" : "Category" } @@ -710,7 +1136,8 @@ "properties" : { "id" : { "type" : "integer", - "format" : "int64" + "format" : "int64", + "x-is-unique" : true }, "username" : { "type" : "string" @@ -736,8 +1163,6 @@ "description" : "User Status" } }, - "title" : "a User", - "description" : "A User who is purchasing from the pet store", "xml" : { "name" : "User" } @@ -753,8 +1178,6 @@ "type" : "string" } }, - "title" : "Pet Tag", - "description" : "A tag for a pet", "xml" : { "name" : "Tag" } @@ -765,7 +1188,8 @@ "properties" : { "id" : { "type" : "integer", - "format" : "int64" + "format" : "int64", + "x-is-unique" : true }, "category" : { "$ref" : "#/definitions/Category" @@ -800,8 +1224,6 @@ "enum" : [ "available", "pending", "sold" ] } }, - "title" : "a Pet", - "description" : "A pet for sale in the pet store", "xml" : { "name" : "Pet" } @@ -819,9 +1241,449 @@ "message" : { "type" : "string" } + } + }, + "$special[model.name]" : { + "properties" : { + "$special[property.name]" : { + "type" : "integer", + "format" : "int64" + } }, - "title" : "An uploaded response", - "description" : "Describes the result of uploading an image resource" + "xml" : { + "name" : "$special[model.name]" + } + }, + "Return" : { + "properties" : { + "return" : { + "type" : "integer", + "format" : "int32" + } + }, + "description" : "Model for testing reserved words", + "xml" : { + "name" : "Return" + } + }, + "Name" : { + "required" : [ "name" ], + "properties" : { + "name" : { + "type" : "integer", + "format" : "int32" + }, + "snake_case" : { + "type" : "integer", + "format" : "int32", + "readOnly" : true + }, + "property" : { + "type" : "string" + }, + "123Number" : { + "type" : "integer", + "readOnly" : true + } + }, + "description" : "Model for testing model name same as property name", + "xml" : { + "name" : "Name" + } + }, + "200_response" : { + "properties" : { + "name" : { + "type" : "integer", + "format" : "int32" + }, + "class" : { + "type" : "string" + } + }, + "description" : "Model for testing model name starting with number", + "xml" : { + "name" : "Name" + } + }, + "ClassModel" : { + "properties" : { + "_class" : { + "type" : "string" + } + }, + "description" : "Model for testing model with \"_class\" property" + }, + "Dog" : { + "allOf" : [ { + "$ref" : "#/definitions/Animal" + }, { + "type" : "object", + "properties" : { + "breed" : { + "type" : "string" + } + } + } ] + }, + "Cat" : { + "allOf" : [ { + "$ref" : "#/definitions/Animal" + }, { + "type" : "object", + "properties" : { + "declawed" : { + "type" : "boolean" + } + } + } ] + }, + "Animal" : { + "type" : "object", + "required" : [ "className" ], + "discriminator" : "className", + "properties" : { + "className" : { + "type" : "string" + }, + "color" : { + "type" : "string", + "default" : "red" + } + } + }, + "AnimalFarm" : { + "type" : "array", + "items" : { + "$ref" : "#/definitions/Animal" + } + }, + "format_test" : { + "type" : "object", + "required" : [ "byte", "date", "number", "password" ], + "properties" : { + "integer" : { + "type" : "integer", + "minimum" : 10, + "maximum" : 100 + }, + "int32" : { + "type" : "integer", + "format" : "int32", + "minimum" : 20, + "maximum" : 200 + }, + "int64" : { + "type" : "integer", + "format" : "int64" + }, + "number" : { + "type" : "number", + "minimum" : 32.1, + "maximum" : 543.2 + }, + "float" : { + "type" : "number", + "format" : "float", + "minimum" : 54.3, + "maximum" : 987.6 + }, + "double" : { + "type" : "number", + "format" : "double", + "minimum" : 67.8, + "maximum" : 123.4 + }, + "string" : { + "type" : "string", + "pattern" : "/[a-z]/i" + }, + "byte" : { + "type" : "string", + "format" : "byte", + "pattern" : "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$" + }, + "binary" : { + "type" : "string", + "format" : "binary" + }, + "date" : { + "type" : "string", + "format" : "date" + }, + "dateTime" : { + "type" : "string", + "format" : "date-time" + }, + "uuid" : { + "type" : "string", + "format" : "uuid" + }, + "password" : { + "type" : "string", + "format" : "password", + "minLength" : 10, + "maxLength" : 64 + } + } + }, + "EnumClass" : { + "type" : "string", + "enum" : [ "_abc", "-efg", "(xyz)" ], + "default" : "-efg" + }, + "Enum_Test" : { + "type" : "object", + "properties" : { + "enum_string" : { + "type" : "string", + "enum" : [ "UPPER", "lower", "" ] + }, + "enum_integer" : { + "type" : "integer", + "format" : "int32", + "enum" : [ 1, -1 ] + }, + "enum_number" : { + "type" : "number", + "format" : "double", + "enum" : [ 1.1, -1.2 ] + }, + "outerEnum" : { + "$ref" : "#/definitions/OuterEnum" + } + } + }, + "AdditionalPropertiesClass" : { + "type" : "object", + "properties" : { + "map_property" : { + "type" : "object", + "additionalProperties" : { + "type" : "string" + } + }, + "map_of_map_property" : { + "type" : "object", + "additionalProperties" : { + "type" : "object", + "additionalProperties" : { + "type" : "string" + } + } + } + } + }, + "MixedPropertiesAndAdditionalPropertiesClass" : { + "type" : "object", + "properties" : { + "uuid" : { + "type" : "string", + "format" : "uuid" + }, + "dateTime" : { + "type" : "string", + "format" : "date-time" + }, + "map" : { + "type" : "object", + "additionalProperties" : { + "$ref" : "#/definitions/Animal" + } + } + } + }, + "List" : { + "type" : "object", + "properties" : { + "123-list" : { + "type" : "string" + } + } + }, + "Client" : { + "type" : "object", + "properties" : { + "client" : { + "type" : "string" + } + } + }, + "ReadOnlyFirst" : { + "type" : "object", + "properties" : { + "bar" : { + "type" : "string", + "readOnly" : true + }, + "baz" : { + "type" : "string" + } + } + }, + "hasOnlyReadOnly" : { + "type" : "object", + "properties" : { + "bar" : { + "type" : "string", + "readOnly" : true + }, + "foo" : { + "type" : "string", + "readOnly" : true + } + } + }, + "Capitalization" : { + "type" : "object", + "properties" : { + "smallCamel" : { + "type" : "string" + }, + "CapitalCamel" : { + "type" : "string" + }, + "small_Snake" : { + "type" : "string" + }, + "Capital_Snake" : { + "type" : "string" + }, + "SCA_ETH_Flow_Points" : { + "type" : "string" + }, + "ATT_NAME" : { + "type" : "string", + "description" : "Name of the pet\n" + } + } + }, + "MapTest" : { + "type" : "object", + "properties" : { + "map_map_of_string" : { + "type" : "object", + "additionalProperties" : { + "type" : "object", + "additionalProperties" : { + "type" : "string" + } + } + }, + "map_of_enum_string" : { + "type" : "object", + "additionalProperties" : { + "type" : "string", + "enum" : [ "UPPER", "lower" ] + } + } + } + }, + "ArrayTest" : { + "type" : "object", + "properties" : { + "array_of_string" : { + "type" : "array", + "items" : { + "type" : "string" + } + }, + "array_array_of_integer" : { + "type" : "array", + "items" : { + "type" : "array", + "items" : { + "type" : "integer", + "format" : "int64" + } + } + }, + "array_array_of_model" : { + "type" : "array", + "items" : { + "type" : "array", + "items" : { + "$ref" : "#/definitions/ReadOnlyFirst" + } + } + } + } + }, + "NumberOnly" : { + "type" : "object", + "properties" : { + "JustNumber" : { + "type" : "number" + } + } + }, + "ArrayOfNumberOnly" : { + "type" : "object", + "properties" : { + "ArrayNumber" : { + "type" : "array", + "items" : { + "type" : "number" + } + } + } + }, + "ArrayOfArrayOfNumberOnly" : { + "type" : "object", + "properties" : { + "ArrayArrayNumber" : { + "type" : "array", + "items" : { + "type" : "array", + "items" : { + "type" : "number" + } + } + } + } + }, + "EnumArrays" : { + "type" : "object", + "properties" : { + "just_symbol" : { + "type" : "string", + "enum" : [ ">=", "$" ] + }, + "array_enum" : { + "type" : "array", + "items" : { + "type" : "string", + "enum" : [ "fish", "crab" ] + } + } + } + }, + "OuterEnum" : { + "type" : "string", + "enum" : [ "placed", "approved", "delivered" ] + }, + "OuterNumber" : { + "type" : "number" + }, + "OuterString" : { + "type" : "string" + }, + "OuterBoolean" : { + "type" : "boolean" + }, + "OuterComposite" : { + "type" : "object", + "properties" : { + "my_number" : { + "$ref" : "#/definitions/OuterNumber" + }, + "my_string" : { + "$ref" : "#/definitions/OuterString" + }, + "my_boolean" : { + "$ref" : "#/definitions/OuterBoolean" + } + } } }, "externalDocs" : { diff --git a/tests/Instances.hs b/tests/Instances.hs --- a/tests/Instances.hs +++ b/tests/Instances.hs @@ -5,11 +5,11 @@ import Data.Text (Text, pack) import Data.Char (isSpace) import Data.List (sort) -import Data.Time.Calendar (Day(..)) -import Data.Time.Clock (UTCTime(..), secondsToDiffTime) +import qualified Data.Time as TI import Test.QuickCheck import qualified Data.HashMap.Strict as HM import qualified Data.Set as Set +import qualified Data.ByteString.Lazy as BL import ApproxEq import SwaggerPetstore.Model @@ -17,14 +17,34 @@ instance Arbitrary Text where arbitrary = pack <$> arbitrary -instance Arbitrary Day where - arbitrary = ModifiedJulianDay . (2000 +) <$> arbitrary - shrink = (ModifiedJulianDay <$>) . shrink . toModifiedJulianDay +instance Arbitrary TI.Day where + arbitrary = TI.ModifiedJulianDay . (2000 +) <$> arbitrary + shrink = (TI.ModifiedJulianDay <$>) . shrink . TI.toModifiedJulianDay -instance Arbitrary UTCTime where +instance Arbitrary TI.UTCTime where arbitrary = - UTCTime <$> arbitrary <*> (secondsToDiffTime <$> choose (0, 86401)) + TI.UTCTime <$> arbitrary <*> (TI.secondsToDiffTime <$> choose (0, 86401)) +instance Arbitrary BL.ByteString where + arbitrary = BL.pack <$> arbitrary + shrink xs = BL.pack <$> shrink (BL.unpack xs) + +instance Arbitrary ByteArray where + arbitrary = ByteArray <$> arbitrary + shrink (ByteArray xs) = ByteArray <$> shrink xs + +instance Arbitrary Binary where + arbitrary = Binary <$> arbitrary + shrink (Binary xs) = Binary <$> shrink xs + +instance Arbitrary DateTime where + arbitrary = DateTime <$> arbitrary + shrink (DateTime xs) = DateTime <$> shrink xs + +instance Arbitrary Date where + arbitrary = Date <$> arbitrary + shrink (Date xs) = Date <$> shrink xs + -- | Checks if a given list has no duplicates in _O(n log n)_. hasNoDups :: (Ord a) @@ -37,66 +57,280 @@ , Set.size s' > Set.size s = go s' xs | otherwise = False -instance ApproxEq Day where +instance ApproxEq TI.Day where (=~) = (==) -- * Models +instance Arbitrary AdditionalPropertiesClass where + arbitrary = + AdditionalPropertiesClass + <$> arbitrary -- additionalPropertiesClassMapProperty :: Maybe (Map.Map String Text) + <*> arbitrary -- additionalPropertiesClassMapOfMapProperty :: Maybe (Map.Map String (Map.Map String Text)) + + +instance Arbitrary Animal where + arbitrary = + Animal + <$> arbitrary -- animalClassName :: Text + <*> arbitrary -- animalColor :: Maybe Text + + +instance Arbitrary AnimalFarm where + arbitrary = + pure AnimalFarm + + instance Arbitrary ApiResponse where arbitrary = ApiResponse - <$> arbitrary -- apiResponseCode :: Maybe Int - <*> arbitrary -- apiResponseType :: Maybe Text - <*> arbitrary -- apiResponseMessage :: Maybe Text + <$> arbitrary -- apiResponseCode :: Maybe Int + <*> arbitrary -- apiResponseType :: Maybe Text + <*> arbitrary -- apiResponseMessage :: Maybe Text +instance Arbitrary ArrayOfArrayOfNumberOnly where + arbitrary = + ArrayOfArrayOfNumberOnly + <$> arbitrary -- arrayOfArrayOfNumberOnlyArrayArrayNumber :: Maybe [[Double]] + + +instance Arbitrary ArrayOfNumberOnly where + arbitrary = + ArrayOfNumberOnly + <$> arbitrary -- arrayOfNumberOnlyArrayNumber :: Maybe [Double] + + +instance Arbitrary ArrayTest where + arbitrary = + ArrayTest + <$> arbitrary -- arrayTestArrayOfString :: Maybe [Text] + <*> arbitrary -- arrayTestArrayArrayOfInteger :: Maybe [[Integer]] + <*> arbitrary -- arrayTestArrayArrayOfModel :: Maybe [[ReadOnlyFirst]] + + +instance Arbitrary Capitalization where + arbitrary = + Capitalization + <$> arbitrary -- capitalizationSmallCamel :: Maybe Text + <*> arbitrary -- capitalizationCapitalCamel :: Maybe Text + <*> arbitrary -- capitalizationSmallSnake :: Maybe Text + <*> arbitrary -- capitalizationCapitalSnake :: Maybe Text + <*> arbitrary -- capitalizationScaEthFlowPoints :: Maybe Text + <*> arbitrary -- capitalizationAttName :: Maybe Text + + instance Arbitrary Category where arbitrary = Category - <$> arbitrary -- categoryId :: Maybe Integer - <*> arbitrary -- categoryName :: Maybe Text + <$> arbitrary -- categoryId :: Maybe Integer + <*> arbitrary -- categoryName :: Maybe Text +instance Arbitrary ClassModel where + arbitrary = + ClassModel + <$> arbitrary -- classModelClass :: Maybe Text + + +instance Arbitrary Client where + arbitrary = + Client + <$> arbitrary -- clientClient :: Maybe Text + + +instance Arbitrary EnumArrays where + arbitrary = + EnumArrays + <$> arbitrary -- enumArraysJustSymbol :: Maybe Text + <*> arbitrary -- enumArraysArrayEnum :: Maybe [Text] + + +instance Arbitrary EnumClass where + arbitrary = + pure EnumClass + + +instance Arbitrary EnumTest where + arbitrary = + EnumTest + <$> arbitrary -- enumTestEnumString :: Maybe Text + <*> arbitrary -- enumTestEnumInteger :: Maybe Int + <*> arbitrary -- enumTestEnumNumber :: Maybe Double + <*> arbitrary -- enumTestOuterEnum :: Maybe OuterEnum + + +instance Arbitrary FormatTest where + arbitrary = + FormatTest + <$> arbitrary -- formatTestInteger :: Maybe Int + <*> arbitrary -- formatTestInt32 :: Maybe Int + <*> arbitrary -- formatTestInt64 :: Maybe Integer + <*> arbitrary -- formatTestNumber :: Double + <*> arbitrary -- formatTestFloat :: Maybe Float + <*> arbitrary -- formatTestDouble :: Maybe Double + <*> arbitrary -- formatTestString :: Maybe Text + <*> arbitrary -- formatTestByte :: ByteArray + <*> arbitrary -- formatTestBinary :: Maybe Binary + <*> arbitrary -- formatTestDate :: Date + <*> arbitrary -- formatTestDateTime :: Maybe DateTime + <*> arbitrary -- formatTestUuid :: Maybe Text + <*> arbitrary -- formatTestPassword :: Text + + +instance Arbitrary HasOnlyReadOnly where + arbitrary = + HasOnlyReadOnly + <$> arbitrary -- hasOnlyReadOnlyBar :: Maybe Text + <*> arbitrary -- hasOnlyReadOnlyFoo :: Maybe Text + + +instance Arbitrary MapTest where + arbitrary = + MapTest + <$> arbitrary -- mapTestMapMapOfString :: Maybe (Map.Map String (Map.Map String Text)) + <*> arbitrary -- mapTestMapOfEnumString :: Maybe (Map.Map String Text) + + +instance Arbitrary MixedPropertiesAndAdditionalPropertiesClass where + arbitrary = + MixedPropertiesAndAdditionalPropertiesClass + <$> arbitrary -- mixedPropertiesAndAdditionalPropertiesClassUuid :: Maybe Text + <*> arbitrary -- mixedPropertiesAndAdditionalPropertiesClassDateTime :: Maybe DateTime + <*> arbitrary -- mixedPropertiesAndAdditionalPropertiesClassMap :: Maybe (Map.Map String Animal) + + +instance Arbitrary Model200Response where + arbitrary = + Model200Response + <$> arbitrary -- model200ResponseName :: Maybe Int + <*> arbitrary -- model200ResponseClass :: Maybe Text + + +instance Arbitrary ModelList where + arbitrary = + ModelList + <$> arbitrary -- modelList123List :: Maybe Text + + +instance Arbitrary ModelReturn where + arbitrary = + ModelReturn + <$> arbitrary -- modelReturnReturn :: Maybe Int + + +instance Arbitrary Name where + arbitrary = + Name + <$> arbitrary -- nameName :: Int + <*> arbitrary -- nameSnakeCase :: Maybe Int + <*> arbitrary -- nameProperty :: Maybe Text + <*> arbitrary -- name123Number :: Maybe Int + + +instance Arbitrary NumberOnly where + arbitrary = + NumberOnly + <$> arbitrary -- numberOnlyJustNumber :: Maybe Double + + instance Arbitrary Order where arbitrary = Order - <$> arbitrary -- orderId :: Maybe Integer - <*> arbitrary -- orderPetId :: Maybe Integer - <*> arbitrary -- orderQuantity :: Maybe Int - <*> arbitrary -- orderShipDate :: Maybe UTCTime - <*> arbitrary -- orderStatus :: Maybe Text - <*> arbitrary -- orderComplete :: Maybe Bool + <$> arbitrary -- orderId :: Maybe Integer + <*> arbitrary -- orderPetId :: Maybe Integer + <*> arbitrary -- orderQuantity :: Maybe Int + <*> arbitrary -- orderShipDate :: Maybe DateTime + <*> arbitrary -- orderStatus :: Maybe Text + <*> arbitrary -- orderComplete :: Maybe Bool +instance Arbitrary OuterBoolean where + arbitrary = + pure OuterBoolean + + +instance Arbitrary OuterComposite where + arbitrary = + OuterComposite + <$> arbitrary -- outerCompositeMyNumber :: Maybe OuterNumber + <*> arbitrary -- outerCompositeMyString :: Maybe OuterString + <*> arbitrary -- outerCompositeMyBoolean :: Maybe OuterBoolean + + +instance Arbitrary OuterEnum where + arbitrary = + pure OuterEnum + + +instance Arbitrary OuterNumber where + arbitrary = + pure OuterNumber + + +instance Arbitrary OuterString where + arbitrary = + pure OuterString + + instance Arbitrary Pet where arbitrary = Pet - <$> arbitrary -- petId :: Maybe Integer - <*> arbitrary -- petCategory :: Maybe Category - <*> arbitrary -- petName :: Text - <*> arbitrary -- petPhotoUrls :: [Text] - <*> arbitrary -- petTags :: Maybe [Tag] - <*> arbitrary -- petStatus :: Maybe Text + <$> arbitrary -- petId :: Maybe Integer + <*> arbitrary -- petCategory :: Maybe Category + <*> arbitrary -- petName :: Text + <*> arbitrary -- petPhotoUrls :: [Text] + <*> arbitrary -- petTags :: Maybe [Tag] + <*> arbitrary -- petStatus :: Maybe Text +instance Arbitrary ReadOnlyFirst where + arbitrary = + ReadOnlyFirst + <$> arbitrary -- readOnlyFirstBar :: Maybe Text + <*> arbitrary -- readOnlyFirstBaz :: Maybe Text + + +instance Arbitrary SpecialModelName where + arbitrary = + SpecialModelName + <$> arbitrary -- specialModelNameSpecialPropertyName :: Maybe Integer + + instance Arbitrary Tag where arbitrary = Tag - <$> arbitrary -- tagId :: Maybe Integer - <*> arbitrary -- tagName :: Maybe Text + <$> arbitrary -- tagId :: Maybe Integer + <*> arbitrary -- tagName :: Maybe Text instance Arbitrary User where arbitrary = User - <$> arbitrary -- userId :: Maybe Integer - <*> arbitrary -- userUsername :: Maybe Text - <*> arbitrary -- userFirstName :: Maybe Text - <*> arbitrary -- userLastName :: Maybe Text - <*> arbitrary -- userEmail :: Maybe Text - <*> arbitrary -- userPassword :: Maybe Text - <*> arbitrary -- userPhone :: Maybe Text - <*> arbitrary -- userUserStatus :: Maybe Int + <$> arbitrary -- userId :: Maybe Integer + <*> arbitrary -- userUsername :: Maybe Text + <*> arbitrary -- userFirstName :: Maybe Text + <*> arbitrary -- userLastName :: Maybe Text + <*> arbitrary -- userEmail :: Maybe Text + <*> arbitrary -- userPassword :: Maybe Text + <*> arbitrary -- userPhone :: Maybe Text + <*> arbitrary -- userUserStatus :: Maybe Int + + +instance Arbitrary Cat where + arbitrary = + Cat + <$> arbitrary -- catClassName :: Text + <*> arbitrary -- catColor :: Maybe Text + <*> arbitrary -- catDeclawed :: Maybe Bool + + +instance Arbitrary Dog where + arbitrary = + Dog + <$> arbitrary -- dogClassName :: Text + <*> arbitrary -- dogColor :: Maybe Text + <*> arbitrary -- dogBreed :: Maybe Text diff --git a/tests/Test.hs b/tests/Test.hs --- a/tests/Test.hs +++ b/tests/Test.hs @@ -19,10 +19,40 @@ main = hspec $ modifyMaxSize (const 10) $ do describe "JSON instances" $ - do propMimeEq MimeJSON (Proxy :: Proxy ApiResponse) + do propMimeEq MimeJSON (Proxy :: Proxy AdditionalPropertiesClass) + propMimeEq MimeJSON (Proxy :: Proxy Animal) + propMimeEq MimeJSON (Proxy :: Proxy AnimalFarm) + propMimeEq MimeJSON (Proxy :: Proxy ApiResponse) + propMimeEq MimeJSON (Proxy :: Proxy ArrayOfArrayOfNumberOnly) + propMimeEq MimeJSON (Proxy :: Proxy ArrayOfNumberOnly) + propMimeEq MimeJSON (Proxy :: Proxy ArrayTest) + propMimeEq MimeJSON (Proxy :: Proxy Capitalization) propMimeEq MimeJSON (Proxy :: Proxy Category) + propMimeEq MimeJSON (Proxy :: Proxy ClassModel) + propMimeEq MimeJSON (Proxy :: Proxy Client) + propMimeEq MimeJSON (Proxy :: Proxy EnumArrays) + propMimeEq MimeJSON (Proxy :: Proxy EnumClass) + propMimeEq MimeJSON (Proxy :: Proxy EnumTest) + propMimeEq MimeJSON (Proxy :: Proxy FormatTest) + propMimeEq MimeJSON (Proxy :: Proxy HasOnlyReadOnly) + propMimeEq MimeJSON (Proxy :: Proxy MapTest) + propMimeEq MimeJSON (Proxy :: Proxy MixedPropertiesAndAdditionalPropertiesClass) + propMimeEq MimeJSON (Proxy :: Proxy Model200Response) + propMimeEq MimeJSON (Proxy :: Proxy ModelList) + propMimeEq MimeJSON (Proxy :: Proxy ModelReturn) + propMimeEq MimeJSON (Proxy :: Proxy Name) + propMimeEq MimeJSON (Proxy :: Proxy NumberOnly) propMimeEq MimeJSON (Proxy :: Proxy Order) + propMimeEq MimeJSON (Proxy :: Proxy OuterBoolean) + propMimeEq MimeJSON (Proxy :: Proxy OuterComposite) + propMimeEq MimeJSON (Proxy :: Proxy OuterEnum) + propMimeEq MimeJSON (Proxy :: Proxy OuterNumber) + propMimeEq MimeJSON (Proxy :: Proxy OuterString) propMimeEq MimeJSON (Proxy :: Proxy Pet) + propMimeEq MimeJSON (Proxy :: Proxy ReadOnlyFirst) + propMimeEq MimeJSON (Proxy :: Proxy SpecialModelName) propMimeEq MimeJSON (Proxy :: Proxy Tag) propMimeEq MimeJSON (Proxy :: Proxy User) + propMimeEq MimeJSON (Proxy :: Proxy Cat) + propMimeEq MimeJSON (Proxy :: Proxy Dog)