Applying gzip on JSON server response

plutus-chain-index-core/plutus-chain-index-core.cabal

@@ -139,6 +139,7 @@ library
     , text-class
     , unordered-containers
     , warp
+    , wai-extra
 
 test-suite plutus-chain-index-test
   import:         lang

plutus-chain-index-core/src/Plutus/ChainIndex/Server.hs

@@ -14,13 +14,15 @@ import Control.Monad.Freer (Eff, Member, type (~>))
 import Control.Monad.Freer.Error (Error, runError, throwError)
 import Control.Monad.Freer.Extras.Modify (raiseEnd)
 import Control.Monad.IO.Class (MonadIO (liftIO))
+import Data.Monoid (Endo (Endo, appEndo))
 import Data.ByteString.Lazy qualified as BSL
 import Data.Default (Default (def))
 import Data.Maybe (fromMaybe)
 import Data.Proxy (Proxy (..))
 import Data.Text qualified as Text
 import Data.Text.Encoding qualified as Text
 import Network.Wai.Handler.Warp qualified as Warp
+import Network.Wai.Middleware.Gzip qualified as Gzip
 import Plutus.ChainIndex (RunRequirements, runChainIndexEffects)
 import Plutus.ChainIndex.Api (API, FromHashAPI, FullAPI, QueryAtAddressRequest (QueryAtAddressRequest),
                               TxoAtAddressRequest (TxoAtAddressRequest), UtxoAtAddressRequest (UtxoAtAddressRequest),
@@ -37,7 +39,10 @@ serveChainIndexQueryServer ::
     -> IO ()
 serveChainIndexQueryServer port runReq = do
     let server = hoistServer (Proxy @API) (runChainIndexQuery runReq) serveChainIndex
-    Warp.run port (serve (Proxy @FullAPI) (server :<|> swagger))
+    Warp.run port $ middleware (serve (Proxy @FullAPI) (server :<|> swagger))
+
+  where gzipMiddleware = Gzip.gzip def { Gzip.gzipSizeThreshold = 1024 }
+        middleware = appEndo $ foldMap Endo [gzipMiddleware]
 
 runChainIndexQuery ::
     RunRequirements

plutus-pab/plutus-pab.cabal

@@ -217,6 +217,7 @@ library
     , uuid
     , wai
     , wai-cors
+    , wai-extra
     , warp
     , websockets
     , yaml

plutus-pab/src/Plutus/PAB/Webserver/Server.hs

@@ -28,13 +28,15 @@ import Control.Monad.IO.Class (liftIO)
 import Data.Aeson (FromJSON, ToJSON)
 import Data.Bifunctor (first)
 import Data.ByteString.Lazy.Char8 qualified as LBS
+import Data.Default (def)
 import Data.Function ((&))
 import Data.Monoid (Endo (Endo, appEndo))
 import Data.OpenApi.Schema qualified as OpenApi
 import Data.Proxy (Proxy (Proxy))
 import Network.Wai (Middleware)
 import Network.Wai.Handler.Warp qualified as Warp
 import Network.Wai.Middleware.Cors qualified as Cors
+import Network.Wai.Middleware.Gzip qualified as Gzip
 import Network.Wai.Middleware.Servant.Options qualified as Cors
 import Plutus.PAB.Core (PABAction, PABRunner (PABRunner, runPABAction))
 import Plutus.PAB.Core qualified as Core
@@ -110,14 +112,15 @@ startServer WebserverConfig{baseUrl, staticDir, permissiveCorsPolicy, endpointTi
       logWarn @(LM.PABMultiAgentMsg t) (LM.UserLog "Warning: Using a very permissive CORS policy! *Any* website serving JavaScript can interact with these endpoints.")
     startServer' middlewares (baseUrlPort baseUrl) staticDir availability (timeout endpointTimeout)
       where
-        middlewares = if permissiveCorsPolicy then corsMiddlewares else []
+        middlewares = if permissiveCorsPolicy then gzipMiddleware : corsMiddlewares else [gzipMiddleware]
         corsMiddlewares =
             [ -- a custom CORS policy since 'simpleCors' doesn't support "content-type" header by default
             let policy = Cors.simpleCorsResourcePolicy { Cors.corsRequestHeaders = [ "content-type" ] }
             in Cors.cors (const $ Just policy)
             -- this middleware handles preflight OPTIONS browser requests
             , Cors.provideOptions (Proxy @(API (Contract.ContractDef t) Integer))
             ]
+        gzipMiddleware = Gzip.gzip def { Gzip.gzipSizeThreshold = 1024 }
         -- By default we use the normal request timeout: 30 seconds. But if
         -- someone has asked for a longer endpoint timeout, we need to set
         -- that to be the webserver timeout as well.