|
| 1 | +{-# LANGUAGE DataKinds #-} |
| 2 | +{-# LANGUAGE FlexibleContexts #-} |
| 3 | +{-# LANGUAGE FlexibleInstances #-} |
| 4 | +{-# LANGUAGE GeneralizedNewtypeDeriving #-} |
| 5 | +{-# LANGUAGE KindSignatures #-} |
| 6 | +{-# LANGUAGE LambdaCase #-} |
| 7 | +{-# LANGUAGE MultiParamTypeClasses #-} |
| 8 | +{-# LANGUAGE OverloadedStrings #-} |
| 9 | +{-# LANGUAGE ScopedTypeVariables #-} |
| 10 | +{-# LANGUAGE TypeOperators #-} |
| 11 | +{-# LANGUAGE TypeFamilies #-} |
| 12 | +{-# LANGUAGE DefaultSignatures #-} |
| 13 | +{-# LANGUAGE StandaloneDeriving #-} |
| 14 | +{-# LANGUAGE NamedFieldPuns #-} |
| 15 | +module Solga.Core |
| 16 | + ( -- * Path components |
| 17 | + type (:>), type (/>) |
| 18 | + , Get |
| 19 | + , Post |
| 20 | + , JSON(..) |
| 21 | + , Raw(..) |
| 22 | + , RawResponse(..) |
| 23 | + , End(..) |
| 24 | + , WithIO(..) |
| 25 | + , Seg(..) |
| 26 | + , OneOfSegs(..) |
| 27 | + , Capture(..) |
| 28 | + , Method(..) |
| 29 | + , ExtraHeaders(..) |
| 30 | + , NoCache(..) |
| 31 | + , ReqBodyJSON(..) |
| 32 | + , MultiPartParam |
| 33 | + , MultiPartFile |
| 34 | + , MultiPartFileInfo(..) |
| 35 | + , MultiPartData |
| 36 | + , ReqBodyMultipart(..) |
| 37 | + , Endpoint |
| 38 | + , (:<|>)(..) |
| 39 | + ) where |
| 40 | + |
| 41 | +import qualified Data.Text as Text |
| 42 | +import GHC.TypeLits |
| 43 | +import qualified Network.HTTP.Types as HTTP |
| 44 | +import Data.ByteString (ByteString) |
| 45 | + |
| 46 | +--------------------------------------------------- |
| 47 | + |
| 48 | +-- | Compose routers. This is just type application, |
| 49 | +-- ie.: @Foo :> Bar :> Baz == Foo (Bar Baz)@ |
| 50 | +type f :> g = f g |
| 51 | +infixr 2 :> |
| 52 | + |
| 53 | +-- | Serve a given WAI `Wai.Application`. |
| 54 | +newtype Raw a = Raw { rawApp :: a } |
| 55 | + |
| 56 | +-- | Serve a given WAI `Wai.Response`. |
| 57 | +newtype RawResponse a = RawResponse { rawResponse :: a } |
| 58 | + |
| 59 | +-- | Only accept the end of a path. |
| 60 | +newtype End next = End { endNext :: next } |
| 61 | + |
| 62 | +-- | Match a constant directory in the path. |
| 63 | +-- |
| 64 | +-- When specifying APIs, use the `/>` combinator to specify sub-paths: |
| 65 | +-- @"foo" `/>` `JSON` Bar@ |
| 66 | +newtype Seg (seg :: Symbol) next = Seg { segNext :: next } |
| 67 | + deriving (Eq, Ord, Show) |
| 68 | + |
| 69 | +-- | Match a path, segment, e.g @"foo" `/>` `JSON` Bar@ |
| 70 | +type seg /> g = Seg seg :> g |
| 71 | +infixr 2 /> |
| 72 | + |
| 73 | +-- | Try to route with @left@, or try to route with @right@. |
| 74 | +data left :<|> right = (:<|>) { altLeft :: left, altRight :: right } |
| 75 | + deriving (Eq, Ord, Show) |
| 76 | + |
| 77 | +infixr 1 :<|> |
| 78 | + |
| 79 | +-- | Match any of a set of path segments. |
| 80 | +data OneOfSegs (segs :: [ Symbol ]) next = OneOfSegs { oneOfSegsNext :: next } |
| 81 | + |
| 82 | +-- | The class of types that can be parsed from a path segment. |
| 83 | +class FromSegment a where |
| 84 | + fromSegment :: Text.Text -> Maybe a |
| 85 | + |
| 86 | +instance FromSegment Text.Text where |
| 87 | + fromSegment = Just |
| 88 | + |
| 89 | +-- | Capture a path segment and pass it on. |
| 90 | +newtype Capture a next = Capture { captureNext :: a -> next } |
| 91 | + |
| 92 | +-- | Accepts requests with a certain method. |
| 93 | +newtype Method (method :: Symbol) next = Method { methodNext :: next } |
| 94 | + deriving (Eq, Ord, Show) |
| 95 | + |
| 96 | +-- | Return a given JSON object |
| 97 | +newtype JSON a = JSON { jsonResponse :: a } |
| 98 | + deriving (Eq, Ord, Show) |
| 99 | + |
| 100 | +-- | Set extra headers on responses. |
| 101 | +-- Existing headers will be overriden if specified here. |
| 102 | +data ExtraHeaders next = ExtraHeaders |
| 103 | + { extraHeaders :: HTTP.ResponseHeaders |
| 104 | + , extraHeadersNext :: next |
| 105 | + } |
| 106 | + |
| 107 | +-- | Prevent caching for sub-routers. |
| 108 | +newtype NoCache next = NoCache { noCacheNext :: next } |
| 109 | + |
| 110 | +-- | Parse a JSON request body. |
| 111 | +newtype ReqBodyJSON a next = ReqBodyJSON { reqBodyJSONNext :: a -> next } |
| 112 | + |
| 113 | +-- | Produce a response with `IO`. |
| 114 | +newtype WithIO next = WithIO { withIONext :: IO next } |
| 115 | + |
| 116 | +type MultiPartParam = (ByteString, ByteString) |
| 117 | +type MultiPartFile y = (ByteString, MultiPartFileInfo y) |
| 118 | + |
| 119 | +data MultiPartFileInfo c = MultiPartFileInfo |
| 120 | + { mpfiName :: ByteString |
| 121 | + , mpfiContentType :: ByteString |
| 122 | + , mpfiContent :: FilePath |
| 123 | + } |
| 124 | + |
| 125 | +-- | A parsed "multipart/form-data" request. |
| 126 | +type MultiPartData y = ([MultiPartParam], [MultiPartFile y]) |
| 127 | + |
| 128 | +-- | Accept a "multipart/form-data" request. |
| 129 | +-- Files will be stored in a temporary directory and will be deleted |
| 130 | +-- automatically after the request is processed. |
| 131 | +data ReqBodyMultipart y a next = ReqBodyMultipart |
| 132 | + { reqMultiPartParse :: MultiPartData y -> Either String a |
| 133 | + , reqMultiPartNext :: a -> next |
| 134 | + } |
| 135 | + |
| 136 | +-- | Useful synonym for dynamic endpoints: accept requests with a given method, compute a JSON response in `IO` and don't cache. |
| 137 | +type Endpoint method a = End :> NoCache :> Method method :> WithIO :> a |
| 138 | + |
| 139 | +-- | Handle a "GET" request and produce a "JSON" response, with `IO`. |
| 140 | +type Get a = Endpoint "GET" (JSON a) |
| 141 | +-- | Handle a "POST" request and produce a "JSON" response, with `IO`. |
| 142 | +type Post a = Endpoint "POST" (JSON a) |
| 143 | + |
0 commit comments