r3x-haskell-sdk (empty) → 0.1.0.0

raw patch · 13 files changed

+727/−0 lines, 13 filesdep +aesondep +basedep +blaze-htmlsetup-changed

Dependencies added: aeson, base, blaze-html, bytestring, case-insensitive, containers, cookie, http-types, mtl, r3x-haskell-sdk, regex-pcre, text, transformers, wai, warp

Files

• ChangeLog.md +3/−0
• LICENSE +201/−0
• README.md +35/−0
• Setup.hs +2/−0
• app/Main.hs +28/−0
• r3x-haskell-sdk.cabal +106/−0
• src/RubiX/RubixHandler.hs +17/−0
• src/RubiX/RubixRequest.hs +101/−0
• src/RubiX/RubixResponse.hs +66/−0
• src/RubiX/Types.hs +42/−0
• src/RubiX/Utils.hs +53/−0
• src/Rubix.hs +71/−0
• test/Spec.hs +2/−0

@@ -0,0 +1,3 @@+# Changelog for r3x-haskell-sdk++## Unreleased changes

@@ -0,0 +1,201 @@+                                Apache License+                           Version 2.0, January 2004+                        http://www.apache.org/licenses/++   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION++   1. Definitions.++      "License" shall mean the terms and conditions for use, reproduction,+      and distribution as defined by Sections 1 through 9 of this document.++      "Licensor" shall mean the copyright owner or entity authorized by+      the copyright owner that is granting the License.++      "Legal Entity" shall mean the union of the acting entity and all+      other entities that control, are controlled by, or are under common+      control with that entity. For the purposes of this definition,+      "control" means (i) the power, direct or indirect, to cause the+      direction or management of such entity, whether by contract or+      otherwise, or (ii) ownership of fifty percent (50%) or more of the+      outstanding shares, or (iii) beneficial ownership of such entity.++      "You" (or "Your") shall mean an individual or Legal Entity+      exercising permissions granted by this License.++      "Source" form shall mean the preferred form for making modifications,+      including but not limited to software source code, documentation+      source, and configuration files.++      "Object" form shall mean any form resulting from mechanical+      transformation or translation of a Source form, including but+      not limited to compiled object code, generated documentation,+      and conversions to other media types.++      "Work" shall mean the work of authorship, whether in Source or+      Object form, made available under the License, as indicated by a+      copyright notice that is included in or attached to the work+      (an example is provided in the Appendix below).++      "Derivative Works" shall mean any work, whether in Source or Object+      form, that is based on (or derived from) the Work and for which the+      editorial revisions, annotations, elaborations, or other modifications+      represent, as a whole, an original work of authorship. For the purposes+      of this License, Derivative Works shall not include works that remain+      separable from, or merely link (or bind by name) to the interfaces of,+      the Work and Derivative Works thereof.++      "Contribution" shall mean any work of authorship, including+      the original version of the Work and any modifications or additions+      to that Work or Derivative Works thereof, that is intentionally+      submitted to Licensor for inclusion in the Work by the copyright owner+      or by an individual or Legal Entity authorized to submit on behalf of+      the copyright owner. For the purposes of this definition, "submitted"+      means any form of electronic, verbal, or written communication sent+      to the Licensor or its representatives, including but not limited to+      communication on electronic mailing lists, source code control systems,+      and issue tracking systems that are managed by, or on behalf of, the+      Licensor for the purpose of discussing and improving the Work, but+      excluding communication that is conspicuously marked or otherwise+      designated in writing by the copyright owner as "Not a Contribution."++      "Contributor" shall mean Licensor and any individual or Legal Entity+      on behalf of whom a Contribution has been received by Licensor and+      subsequently incorporated within the Work.++   2. Grant of Copyright License. Subject to the terms and conditions of+      this License, each Contributor hereby grants to You a perpetual,+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable+      copyright license to reproduce, prepare Derivative Works of,+      publicly display, publicly perform, sublicense, and distribute the+      Work and such Derivative Works in Source or Object form.++   3. Grant of Patent License. Subject to the terms and conditions of+      this License, each Contributor hereby grants to You a perpetual,+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable+      (except as stated in this section) patent license to make, have made,+      use, offer to sell, sell, import, and otherwise transfer the Work,+      where such license applies only to those patent claims licensable+      by such Contributor that are necessarily infringed by their+      Contribution(s) alone or by combination of their Contribution(s)+      with the Work to which such Contribution(s) was submitted. If You+      institute patent litigation against any entity (including a+      cross-claim or counterclaim in a lawsuit) alleging that the Work+      or a Contribution incorporated within the Work constitutes direct+      or contributory patent infringement, then any patent licenses+      granted to You under this License for that Work shall terminate+      as of the date such litigation is filed.++   4. Redistribution. You may reproduce and distribute copies of the+      Work or Derivative Works thereof in any medium, with or without+      modifications, and in Source or Object form, provided that You+      meet the following conditions:++      (a) You must give any other recipients of the Work or+          Derivative Works a copy of this License; and++      (b) You must cause any modified files to carry prominent notices+          stating that You changed the files; and++      (c) You must retain, in the Source form of any Derivative Works+          that You distribute, all copyright, patent, trademark, and+          attribution notices from the Source form of the Work,+          excluding those notices that do not pertain to any part of+          the Derivative Works; and++      (d) If the Work includes a "NOTICE" text file as part of its+          distribution, then any Derivative Works that You distribute must+          include a readable copy of the attribution notices contained+          within such NOTICE file, excluding those notices that do not+          pertain to any part of the Derivative Works, in at least one+          of the following places: within a NOTICE text file distributed+          as part of the Derivative Works; within the Source form or+          documentation, if provided along with the Derivative Works; or,+          within a display generated by the Derivative Works, if and+          wherever such third-party notices normally appear. The contents+          of the NOTICE file are for informational purposes only and+          do not modify the License. You may add Your own attribution+          notices within Derivative Works that You distribute, alongside+          or as an addendum to the NOTICE text from the Work, provided+          that such additional attribution notices cannot be construed+          as modifying the License.++      You may add Your own copyright statement to Your modifications and+      may provide additional or different license terms and conditions+      for use, reproduction, or distribution of Your modifications, or+      for any such Derivative Works as a whole, provided Your use,+      reproduction, and distribution of the Work otherwise complies with+      the conditions stated in this License.++   5. Submission of Contributions. Unless You explicitly state otherwise,+      any Contribution intentionally submitted for inclusion in the Work+      by You to the Licensor shall be under the terms and conditions of+      this License, without any additional terms or conditions.+      Notwithstanding the above, nothing herein shall supersede or modify+      the terms of any separate license agreement you may have executed+      with Licensor regarding such Contributions.++   6. Trademarks. This License does not grant permission to use the trade+      names, trademarks, service marks, or product names of the Licensor,+      except as required for reasonable and customary use in describing the+      origin of the Work and reproducing the content of the NOTICE file.++   7. Disclaimer of Warranty. Unless required by applicable law or+      agreed to in writing, Licensor provides the Work (and each+      Contributor provides its Contributions) on an "AS IS" BASIS,+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or+      implied, including, without limitation, any warranties or conditions+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A+      PARTICULAR PURPOSE. You are solely responsible for determining the+      appropriateness of using or redistributing the Work and assume any+      risks associated with Your exercise of permissions under this License.++   8. Limitation of Liability. In no event and under no legal theory,+      whether in tort (including negligence), contract, or otherwise,+      unless required by applicable law (such as deliberate and grossly+      negligent acts) or agreed to in writing, shall any Contributor be+      liable to You for damages, including any direct, indirect, special,+      incidental, or consequential damages of any character arising as a+      result of this License or out of the use or inability to use the+      Work (including but not limited to damages for loss of goodwill,+      work stoppage, computer failure or malfunction, or any and all+      other commercial damages or losses), even if such Contributor+      has been advised of the possibility of such damages.++   9. Accepting Warranty or Additional Liability. While redistributing+      the Work or Derivative Works thereof, You may choose to offer,+      and charge a fee for, acceptance of support, warranty, indemnity,+      or other liability obligations and/or rights consistent with this+      License. However, in accepting such obligations, You may act only+      on Your own behalf and on Your sole responsibility, not on behalf+      of any other Contributor, and only if You agree to indemnify,+      defend, and hold each Contributor harmless for any liability+      incurred by, or claims asserted against, such Contributor by reason+      of your accepting any such warranty or additional liability.++   END OF TERMS AND CONDITIONS++   APPENDIX: How to apply the Apache License to your work.++      To apply the Apache License to your work, attach the following+      boilerplate notice, with the fields enclosed by brackets "[]"+      replaced with your own identifying information. (Don't include+      the brackets!)  The text should be enclosed in the appropriate+      comment syntax for the file format. We also recommend that a+      file or class name and description of purpose be included on the+      same "printed page" as the copyright notice for easier+      identification within third-party archives.++   Copyright [2018] [RubixFunctions]++   Licensed under the Apache License, Version 2.0 (the "License");+   you may not use this file except in compliance with the License.+   You may obtain a copy of the License at++       http://www.apache.org/licenses/LICENSE-2.0++   Unless required by applicable law or agreed to in writing, software+   distributed under the License is distributed on an "AS IS" BASIS,+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+   See the License for the specific language governing permissions and+   limitations under the License.

@@ -0,0 +1,35 @@+# RubiX Haskell SDK++[![CircleCI](https://circleci.com/gh/rubixFunctions/r3x-haskell-sdk.svg?style=svg)](https://circleci.com/gh/rubixFunctions/r3x-haskell-sdk)+[![License](https://img.shields.io/badge/-Apache%202.0-blue.svg)](https://opensource.org/s/Apache-2.0)++## Prerequisites+Stack is needed to build and execute SDK, it can be downloaded from [here](https://www.haskell.org/downloads/)++## Usage+To build the SDK run :+```+$ stack build+```+To execute SDK run :+```+$ stack exec r3x-haskell-sdk-exe+```+alternatively you can run the script `run.sh`:+```+$ ./run.sh+```++## Verify+To quickly verify the SDK you can use the pre build example image by:+```+$ docker run -p 8080:8080 quay.io/rubixfunctions/haskell-sdk+$ curl localhost:8080+    {"message":"Hello RubiX!!!"}%+```++## Documentation+For full information on how to use the SDK and deploy a function to Knative, refer to our [Documentation here.](https://github.com/rubixFunctions/r3x-docs/blob/master/README.md)++## License+This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details

@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain

@@ -0,0 +1,28 @@+{-# language OverloadedStrings #-}+{-# language DeriveAnyClass #-}+{-# language DeriveGeneric #-}+module Main where++import Rubix+import Data.Aeson (ToJSON, FromJSON)+import GHC.Generics (Generic)+import qualified Data.Text as DT+import qualified Network.Wai as NW++data Message = Message +  {+    message :: DT.Text+  } deriving (Generic, ToJSON, FromJSON)++rubixMessage :: Message+rubixMessage = Message{message="Hello RubiX!!!"}++-- Define a response handler+rubixHandler :: Handler NW.Response+rubixHandler = do+  let res = toResponse $ Json rubixMessage+  return res++-- Start the server+main :: IO ()+main = execute rubixHandler

@@ -0,0 +1,106 @@+cabal-version: 1.12++-- This file has been generated from package.yaml by hpack version 0.31.1.+--+-- see: https://github.com/sol/hpack+--+-- hash: 63ec36141b4ba25539fe2fbbd0602a6ff2d6cc3f8ea86e26a909ac4b3a53abf5++name:           r3x-haskell-sdk+version:        0.1.0.0+description:    Please see the README on GitHub at <https://github.com/rubixfunctions/r3x-haskell-sdk#readme>+homepage:       https://github.com/rubixfunctions/r3x-haskell-sdk#readme+bug-reports:    https://github.com/rubixfunctions/r3x-haskell-sdk/issues+author:         RubiXFunctions+maintainer:     r3xfunctions@gmail.com+copyright:      2019 RubiXFunctions+license:        BSD3+license-file:   LICENSE+build-type:     Simple+extra-source-files:+    README.md+    ChangeLog.md++source-repository head+  type: git+  location: https://github.com/rubixfunctions/r3x-haskell-sdk++library+  exposed-modules:+      Rubix+      RubiX.RubixHandler+      RubiX.RubixRequest+      RubiX.RubixResponse+      RubiX.Types+      RubiX.Utils+  other-modules:+      Paths_r3x_haskell_sdk+  hs-source-dirs:+      src+  build-depends:+      aeson+    , base >=4.7 && <5+    , blaze-html+    , bytestring+    , case-insensitive+    , containers+    , cookie+    , http-types+    , mtl+    , regex-pcre+    , text+    , transformers+    , wai+    , warp+  default-language: Haskell2010++executable r3x-haskell-sdk-exe+  main-is: Main.hs+  other-modules:+      Paths_r3x_haskell_sdk+  hs-source-dirs:+      app+  ghc-options: -threaded -rtsopts -with-rtsopts=-N+  build-depends:+      aeson+    , base >=4.7 && <5+    , blaze-html+    , bytestring+    , case-insensitive+    , containers+    , cookie+    , http-types+    , mtl+    , r3x-haskell-sdk+    , regex-pcre+    , text+    , transformers+    , wai+    , warp+  default-language: Haskell2010++test-suite r3x-haskell-sdk-test+  type: exitcode-stdio-1.0+  main-is: Spec.hs+  other-modules:+      Paths_r3x_haskell_sdk+  hs-source-dirs:+      test+  ghc-options: -threaded -rtsopts -with-rtsopts=-N+  build-depends:+      aeson+    , base >=4.7 && <5+    , blaze-html+    , bytestring+    , case-insensitive+    , containers+    , cookie+    , http-types+    , mtl+    , r3x-haskell-sdk+    , regex-pcre+    , text+    , transformers+    , wai+    , warp+  default-language: Haskell2010

@@ -0,0 +1,17 @@+{-# language OverloadedStrings #-}+{-# language FlexibleContexts #-}+module RubiX.RubixHandler+  ( route+  ) where++import RubiX.Types+import RubiX.RubixRequest+import RubiX.RubixResponse+import Control.Monad++-- Run a handler to match declared routes+route :: ToResponse a => Pattern -> Handler a -> App ()+route routePath handler = do+  doesPathMatch <- matchPaths routePath+  when doesPathMatch $ respondWith handler+

@@ -0,0 +1,101 @@+{-# language OverloadedStrings #-}+{-# language FlexibleContexts #-}+{-# language ConstraintKinds #-} +{-# language ViewPatterns #-}+module RubiX.RubixRequest+  ( getPath+  , getPathInfo+  , getMethod+  , getQueryString+  , getQueries+  , getQueriesMulti+  , getQuery+  , getQueryMulti+  , getHeader+  , getHeaderMulti+  , getHeaders+  , getBody+  , checkSecure+  , waiRequest+  , matchPaths+  ) where++import Control.Monad.Reader+import Data.Maybe+import Data.Bifunctor+import qualified Data.Text as DT+import qualified Data.Map as DM+import qualified Data.CaseInsensitive as DCI+import Text.Regex.PCRE+import qualified Network.Wai as NW++import RubiX.Utils+import RubiX.Types++type ReqReader b = MonadReader ReqContext b++fromReq :: ReqReader b => (NW.Request -> a) -> b a+fromReq getter = asks (getter . request)++-- Gets the headers of the request+getHeader :: ReqReader b => DT.Text -> b (Maybe DT.Text)+getHeader key = listToMaybe <$> getHeaderMulti key++-- Gets the headers of the request+getHeaderMulti :: ReqReader b => DT.Text -> b [DT.Text]+getHeaderMulti key = fromMaybe [] . DM.lookup (DCI.mk key) <$> getHeaders++-- Gets the headers of the request+getHeaders :: ReqReader b => b HeaderMap+getHeaders = convertHeaders <$> fromReq NW.requestHeaders++-- Gets path and returns the full path of the current request+getPath :: ReqReader b => b DT.Text+getPath = fromByteString <$> fromReq NW.rawPathInfo++-- Gets the HTTP method of the current request+getMethod :: ReqReader b => b DT.Text+getMethod = fromByteString <$> fromReq NW.requestMethod++-- Gets query string and returns the full path of the current request +getQueryString :: ReqReader b => b DT.Text+getQueryString = fromByteString <$> fromReq NW.rawQueryString++-- Gets full body of the request+getBody  :: ReqReader b => b DT.Text+getBody = asks requestBody++-- Calls through to 'Wai.isSecure'+checkSecure :: ReqReader b => b Bool+checkSecure = fromReq NW.isSecure++-- Returns the path's individual '/' separated chunks.+getPathInfo :: ReqReader b => b [DT.Text]+getPathInfo = fromReq NW.pathInfo++-- Exposes the underlying 'Wai.Request'.+waiRequest :: ReqReader b =>  b NW.Request+waiRequest = asks request++-- Gets all key/values from the query string+getQueriesMulti :: ReqReader b => b MultiQueryMap+getQueriesMulti = convertQueries <$> fromReq NW.queryString++-- Get the last set value for each query+getQueries :: ReqReader b => b QueryMap+getQueries = simpleQuery <$> fromReq NW.queryString++-- Gets all values provided for a given query key+getQueryMulti :: ReqReader b => DT.Text -> b [DT.Text]+getQueryMulti key = fromMaybe [] . DM.lookup key <$> getQueriesMulti++-- Get the value for a given query+getQuery :: ReqReader b => DT.Text -> b (Maybe DT.Text)+getQuery key = DM.lookup key <$> getQueries++-- | Determine whether a route matches a pattern+matchPaths :: ReqReader b => Pattern -> b Bool+matchPaths pattern = checkMatch pattern <$> getPath +  where+    checkMatch :: Pattern -> Route -> Bool+    checkMatch (DT.unpack -> pat) (DT.unpack -> rt) = rt =~ ("^" ++ pat ++ "$")

@@ -0,0 +1,66 @@+{-# language FlexibleInstances #-}+{-# language OverloadedStrings #-}+module RubiX.RubixResponse+  ( ToResponse(..)+  , Json(..)+  , respond+  , respondWith+  ) where++import Data.Function ((&))+import Control.Monad.Except+import qualified Data.Text as DT+import qualified Data.Text.Lazy as DTL+import Data.Aeson as Aeson++import Network.Wai as NW+import Network.HTTP.Types.Status++import Text.Blaze.Html (Html)+import Text.Blaze.Html.Renderer.Text (renderHtml)++import RubiX.Utils+import RubiX.Types++-- values should be JSON encoded sent with the "application/json"+newtype Json a = Json a+  deriving Show++-- This class represents all types which can be converted into a valid Response+class ToResponse c where+  toResponse :: c -> NW.Response++-- The following functions were inspried by Happstack server response+instance ToResponse Aeson.Value where+    toResponse = makeResponse ok200 "application/json" . fromLazyByteString . encode+  +instance ToResponse String where+  toResponse = makeResponse ok200 "text/plain" . DT.pack++instance ToResponse DT.Text where+  toResponse = makeResponse ok200 "text/plain"++instance (ToJSON a) => ToResponse (Json a) where+  toResponse (Json obj) = toResponse (toJSON obj)++instance ToResponse NW.Response where+  toResponse = id++instance (ToResponse b) => ToResponse (b, Status) where+  toResponse (b, status) = toResponse (b, status, mempty :: HeaderMap)++instance (ToResponse b) => ToResponse (b, Status, HeaderMap) where+  toResponse (b, status, hm) =+        toResponse b+      & mapResponseStatus (const status)+      & mapResponseHeaders (++ fromHeaderMap hm)++makeResponse :: Status -> ContentType -> DT.Text -> NW.Response+makeResponse status contentType body =+  NW.responseLBS status [makeHeader "Content-Type" contentType] (toLazyByteString body)++respond :: ToResponse a => a -> App ()+respond =  throwError . toResponse++respondWith :: ToResponse a => Handler a -> App ()+respondWith handler = runHandler handler >>= respond

@@ -0,0 +1,42 @@+module RubiX.Types where++import Control.Monad.Reader+import Control.Monad.Except+import qualified Network.Wai as W+import qualified Data.Text as T+import qualified Data.Map as M+import qualified Data.CaseInsensitive as CI++-- The main application definition monad+type App a = ReaderT ReqContext (ExceptT W.Response IO) a++-- Handler is an alias for App type+type Handler a = ReaderT ReqContext IO  a++-- Context provided when handling any request+data ReqContext = ReqContext+  { requestBody :: T.Text+  , request :: W.Request+  }++-- Runs a handler within an App WITHOUT rendering the response+runHandler :: Handler r -> App r+runHandler handler = ask >>= liftIO . runReaderT handler++-- A map of case insensitive header names to all provided values for that header.+type HeaderMap = M.Map (CI.CI T.Text) [T.Text]++-- A map of query parameter names to all values provided for that parameter+type MultiQueryMap = M.Map T.Text [T.Text]++-- A map of query parameter names to the last-provided value for that parameter+type QueryMap = M.Map T.Text T.Text++-- A request or response's Content-Type value+type ContentType = T.Text++-- A regex pattern for route matching.+type Pattern = T.Text++-- A route as Text+type Route = T.Text

@@ -0,0 +1,53 @@+{-# language OverloadedStrings #-}+module RubiX.Utils where++import Data.Bifunctor+import Data.Maybe+import qualified Data.Map as DM+import qualified Data.ByteString as BS+import qualified Data.ByteString.Lazy as LBS+import qualified Data.Text.Lazy as LT+import qualified Data.Text.Lazy.Encoding as LT+import qualified Data.Text as T+import qualified Data.Text.Encoding as T+import qualified Data.CaseInsensitive as CI++import qualified Network.HTTP.Types.Header as HTTP+import Network.HTTP.Types.URI++import RubiX.Types++toByteString :: T.Text -> BS.ByteString+toByteString = T.encodeUtf8++toLazyByteString :: T.Text -> LBS.ByteString+toLazyByteString = LT.encodeUtf8 . LT.fromStrict++fromByteString :: BS.ByteString -> T.Text+fromByteString = T.decodeUtf8++fromLazyByteString :: LBS.ByteString -> T.Text+fromLazyByteString = LT.toStrict . LT.decodeUtf8++makeHeader :: T.Text -> T.Text -> HTTP.Header+makeHeader headerName headerVal = (CI.mk (toByteString headerName), toByteString headerVal)++fromHeaderMap :: HeaderMap -> HTTP.ResponseHeaders+fromHeaderMap hm = do+  (headerName, values) <- DM.toList hm+  [(CI.map toByteString headerName, toByteString value) | value <- values]++convertHeaders :: HTTP.RequestHeaders -> HeaderMap+convertHeaders = DM.fromListWith mappend . fmap (bimap mapName mapVal)+    where+        mapName = CI.map fromByteString+        mapVal val = [fromByteString val]++convertQueries :: Query -> MultiQueryMap+convertQueries = DM.fromListWith (flip mappend) . fmap (second maybeToList) . queriesToList++simpleQuery :: Query -> QueryMap+simpleQuery = DM.fromListWith (flip const) . fmap (second (fromMaybe "")) . queriesToList++queriesToList :: Query -> [(T.Text, Maybe T.Text)]+queriesToList = fmap $ bimap fromByteString $ fmap fromByteString

@@ -0,0 +1,71 @@+{-# language OverloadedStrings #-}+module Rubix +    ( +    execute,+    App,+    Handler,+    HeaderMap,+    route,+    runHandler,+    getPath,+    getPathInfo,+    getMethod,+    getQueryString,+    getQueries,+    getQueriesMulti,+    getQuery,+    getQueryMulti,+    getHeaders,+    getBody,+    checkSecure,+    waiRequest,+    matchPaths,+    ToResponse(..),+    respond,+    respondWith,+    Json(..)+    ) where++import qualified Network.Wai.Handler.Warp as NW+import qualified Network.Wai as NW+import Network.HTTP.Types.Status+import qualified Data.Text as T++import Control.Monad.Reader+import Control.Monad.Except++import RubiX.Types+import RubiX.Utils+import RubiX.RubixRequest+import RubiX.RubixHandler+import RubiX.RubixResponse++-- Start server+execute :: ToResponse a => Handler a -> IO()+execute rubixHandler = do +  putStrLn $ "RubiX Server starting to listen on port 8080"+  run 8080 $ rubixApp rubixHandler++-- Set Route and Handler+rubixApp :: ToResponse a => Handler a -> App()+rubixApp rubixHandler = do+  route "/" rubixHandler++-- Execute the app monad+run:: NW.Port -> App() -> IO ()+run port app = NW.run port warpApp+      where+        warpApp :: NW.Request -> (NW.Response -> IO NW.ResponseReceived) -> IO NW.ResponseReceived+        warpApp req res = runRubix app req >>= res++-- Run the app monad on a wai request to obtain a wai response+runRubix :: App () -> NW.Request -> IO NW.Response+runRubix app req = either id (const notFoundResp) <$> runExceptT unpackApp+        where +          unpackApp = do+            reqBody <- fmap fromLazyByteString . liftIO $ NW.strictRequestBody req+            runReaderT app ReqContext{request = req, requestBody = reqBody}++-- Default 404 response+notFoundResp :: NW.Response+notFoundResp = undefined

@@ -0,0 +1,2 @@+main :: IO ()+main = putStrLn "Test suite not yet implemented"