mirror of
https://github.com/hasura/graphql-engine.git
synced 2024-12-17 12:31:52 +03:00
cdac24c79f
What is the `Cacheable` type class about? ```haskell class Eq a => Cacheable a where unchanged :: Accesses -> a -> a -> Bool default unchanged :: (Generic a, GCacheable (Rep a)) => Accesses -> a -> a -> Bool unchanged accesses a b = gunchanged (from a) (from b) accesses ``` Its only method is an alternative to `(==)`. The added value of `unchanged` (and the additional `Accesses` argument) arises _only_ for one type, namely `Dependency`. Indeed, the `Cacheable (Dependency a)` instance is non-trivial, whereas every other `Cacheable` instance is completely boilerplate (and indeed either generated from `Generic`, or simply `unchanged _ = (==)`). The `Cacheable (Dependency a)` instance is the only one where the `Accesses` argument is not just passed onwards. The only callsite of the `unchanged` method is in the `ArrowCache (Rule m)` method. That is to say that the `Cacheable` type class is used to decide when we can re-use parts of the schema cache between Metadata operations. So what is the `Cacheable (Dependency a)` instance about? Normally, the output of a `Rule m a b` is re-used when the new input (of type `a`) is equal to the old one. But sometimes, that's too coarse: it might be that a certain `Rule m a b` only depends on a small part of its input of type `a`. A `Dependency` allows us to spell out what parts of `a` are being depended on, and these parts are recorded as values of types `Access a` in the state `Accesses`. If the input `a` changes, but not in a way that touches the recorded `Accesses`, then the output `b` of that rule can be re-used without recomputing. So now you understand _why_ we're passing `Accesses` to the `unchanged` method: `unchanged` is an equality check in disguise that just needs some additional context. But we don't need to pass `Accesses` as a function argument. We can use the `reflection` package to pass it as type-level context. So the core of this PR is that we change the instance declaration from ```haskell instance (Cacheable a) => Cacheable (Dependency a) where ``` to ```haskell instance (Given Accesses, Eq a) => Eq (Dependency a) where ``` and use `(==)` instead of `unchanged`. If you haven't seen `reflection` before: it's like a `MonadReader`, but it doesn't require a `Monad`. In order to pass the current `Accesses` value, instead of simply passing the `Accesses` as a function argument, we need to instantiate the `Given Accesses` context. We use the `give` method from the `reflection` package for that. ```haskell give :: forall r. Accesses -> (Given Accesses => r) -> r unchanged :: (Given Accesses => Eq a) => Accesses -> a -> a -> Bool unchanged accesses a b = give accesses (a == b) ``` With these three components in place, we can delete the `Cacheable` type class entirely. The remainder of this PR is just to remove the `Cacheable` type class and its instances. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/6877 GitOrigin-RevId: 7125f5e11d856e7672ab810a23d5bf5ad176e77f
73 lines
2.4 KiB
Haskell
73 lines
2.4 KiB
Haskell
module Hasura.RQL.DDL.Headers
|
|
( HeaderConf (..),
|
|
HeaderValue (HVEnv, HVValue),
|
|
makeHeadersFromConf,
|
|
toHeadersConf,
|
|
)
|
|
where
|
|
|
|
import Data.Aeson
|
|
import Data.CaseInsensitive qualified as CI
|
|
import Data.Environment qualified as Env
|
|
import Data.Text qualified as T
|
|
import Hasura.Base.Error
|
|
import Hasura.Base.Instances ()
|
|
import Hasura.Prelude
|
|
import Network.HTTP.Types qualified as HTTP
|
|
|
|
data HeaderConf = HeaderConf HeaderName HeaderValue
|
|
deriving (Show, Eq, Generic)
|
|
|
|
instance NFData HeaderConf
|
|
|
|
instance Hashable HeaderConf
|
|
|
|
type HeaderName = Text
|
|
|
|
data HeaderValue = HVValue Text | HVEnv Text
|
|
deriving (Show, Eq, Generic)
|
|
|
|
instance NFData HeaderValue
|
|
|
|
instance Hashable HeaderValue
|
|
|
|
instance FromJSON HeaderConf where
|
|
parseJSON (Object o) = do
|
|
name <- o .: "name"
|
|
value <- o .:? "value"
|
|
valueFromEnv <- o .:? "value_from_env"
|
|
case (value, valueFromEnv) of
|
|
(Nothing, Nothing) -> fail "expecting value or value_from_env keys"
|
|
(Just val, Nothing) -> return $ HeaderConf name (HVValue val)
|
|
(Nothing, Just val) -> do
|
|
when (T.isPrefixOf "HASURA_GRAPHQL_" val) $
|
|
fail $
|
|
"env variables starting with \"HASURA_GRAPHQL_\" are not allowed in value_from_env: " <> T.unpack val
|
|
return $ HeaderConf name (HVEnv val)
|
|
(Just _, Just _) -> fail "expecting only one of value or value_from_env keys"
|
|
parseJSON _ = fail "expecting object for headers"
|
|
|
|
instance ToJSON HeaderConf where
|
|
toJSON (HeaderConf name (HVValue val)) = object ["name" .= name, "value" .= val]
|
|
toJSON (HeaderConf name (HVEnv val)) = object ["name" .= name, "value_from_env" .= val]
|
|
|
|
-- | Resolve configuration headers
|
|
makeHeadersFromConf ::
|
|
MonadError QErr m => Env.Environment -> [HeaderConf] -> m [HTTP.Header]
|
|
makeHeadersFromConf env = mapM getHeader
|
|
where
|
|
getHeader hconf =
|
|
((CI.mk . txtToBs) *** txtToBs)
|
|
<$> case hconf of
|
|
(HeaderConf name (HVValue val)) -> return (name, val)
|
|
(HeaderConf name (HVEnv val)) -> do
|
|
let mEnv = Env.lookupEnv env (T.unpack val)
|
|
case mEnv of
|
|
Nothing -> throw400 NotFound $ "environment variable '" <> val <> "' not set"
|
|
Just envval -> pure (name, T.pack envval)
|
|
|
|
-- | Encode headers to HeaderConf
|
|
toHeadersConf :: [HTTP.Header] -> [HeaderConf]
|
|
toHeadersConf =
|
|
map (uncurry HeaderConf . ((bsToTxt . CI.original) *** (HVValue . bsToTxt)))
|