Remove ServerConfigCtx.

### Description

This PR removes `ServerConfigCtx` and `HasServerConfigCtx`. Instead, it favours different approaches:
- when the code was only using one field, it passes that field explicitly (usually `SQLGenCtx` or `CheckFeatureFlag`)
- when the code was using several fields, but in only one function, it inlines
- for the cache build, it introduces `CacheStaticConfig` and `CacheDynamicConfig`, which are subsets of `AppEnv` and `AppContext` respectively

The main goal of this is to help with the modularization of the engine: as `ServerConfigCtx` had fields whose types were imported from several unrelated parts of the engine, using it tied together parts of the engine that should not be aware of one another (such as tying together `Hasura.LogicalModel` and `Hasura.GraphQL.Schema`).

The bulk of this PR is a change to the cache build, as a follow up to #8509: instead of giving the entire `ServerConfigCtx` as a incremental rule argument, we only give the new `CacheDynamicConfig` struct, which has fewer fields. The other required fields, that were coming from the `AppEnv`, are now given via the `HasCacheStaticConfig` constraint, which is a "subset" of `HasAppEnv`.

(Some further work could include moving `StringifyNumbers` out of `GraphQL.Schema.Options`, given how it is used all across the codebase, including in `RQL.DML`.)

PR-URL: https://github.com/hasura/graphql-engine-mono/pull/8513
GitOrigin-RevId: 818cbcd71494e3cd946b06adbb02ca328a8a298e

server/graphql-engine.cabal

@@ -881,6 +881,7 @@ library
                      , Hasura.RQL.DDL.Schema
                      , Hasura.RQL.DDL.Schema.Cache
                      , Hasura.RQL.DDL.Schema.Cache.Common
+                     , Hasura.RQL.DDL.Schema.Cache.Config
                      , Hasura.RQL.DDL.Schema.Cache.Dependencies
                      , Hasura.RQL.DDL.Schema.Cache.Fields
                      , Hasura.RQL.DDL.Schema.Cache.Permission

server/src-lib/Hasura/App.hs

@@ -122,6 +122,7 @@ import Hasura.RQL.DDL.ApiLimit (MonadGetApiTimeLimit (..))
 import Hasura.RQL.DDL.EventTrigger (MonadEventLogCleanup (..))
 import Hasura.RQL.DDL.Schema.Cache
 import Hasura.RQL.DDL.Schema.Cache.Common
+import Hasura.RQL.DDL.Schema.Cache.Config
 import Hasura.RQL.DDL.Schema.Catalog
 import Hasura.RQL.Types.Allowlist
 import Hasura.RQL.Types.Backend
@@ -500,21 +501,18 @@ initialiseAppContext ::
   AppInit ->
   m (AppStateRef Hasura)
 initialiseAppContext env serveOptions@ServeOptions {..} AppInit {..} = do
-  AppEnv {..} <- askAppEnv
+  appEnv@AppEnv {..} <- askAppEnv
   let Loggers _ logger pgLogger = appEnvLoggers
       sqlGenCtx = initSQLGenCtx soExperimentalFeatures soStringifyNum soDangerousBooleanCollapse
-      serverConfigCtx =
+      cacheStaticConfig = buildCacheStaticConfig appEnv
-        ServerConfigCtx
+      cacheDynamicConfig =
+        CacheDynamicConfig
           soInferFunctionPermissions
           soEnableRemoteSchemaPermissions
           sqlGenCtx
-          soEnableMaintenanceMode
           soExperimentalFeatures
-          soEventingMode
-          soReadOnlyMode
           soDefaultNamingConvention
           soMetadataDefaults
-          (CheckFeatureFlag $ checkFeatureFlag env)
           soApolloFederationStatus
 
   -- Create the schema cache
@@ -522,10 +520,11 @@ initialiseAppContext env serveOptions@ServeOptions {..} AppInit {..} = do
     buildFirstSchemaCache
       env
       logger
-      serverConfigCtx
       (mkPgSourceResolver pgLogger)
       mkMSSQLSourceResolver
       aiMetadataWithResourceVersion
+      cacheStaticConfig
+      cacheDynamicConfig
       appEnvManager
 
   -- Build the RebuildableAppContext.
@@ -589,26 +588,28 @@ buildFirstSchemaCache ::
   (MonadIO m) =>
   Env.Environment ->
   Logger Hasura ->
-  ServerConfigCtx ->
   SourceResolver ('Postgres 'Vanilla) ->
   SourceResolver ('MSSQL) ->
   MetadataWithResourceVersion ->
+  CacheStaticConfig ->
+  CacheDynamicConfig ->
   HTTP.Manager ->
   m RebuildableSchemaCache
 buildFirstSchemaCache
   env
   logger
-  serverConfigCtx
   pgSourceResolver
   mssqlSourceResolver
   metadataWithVersion
+  cacheStaticConfig
+  cacheDynamicConfig
   httpManager = do
-    let cacheBuildParams = CacheBuildParams httpManager pgSourceResolver mssqlSourceResolver
+    let cacheBuildParams = CacheBuildParams httpManager pgSourceResolver mssqlSourceResolver cacheStaticConfig
         buildReason = CatalogSync
     result <-
       runExceptT $
         runCacheBuild cacheBuildParams $
-          buildRebuildableSchemaCacheWithReason buildReason logger env metadataWithVersion serverConfigCtx
+          buildRebuildableSchemaCacheWithReason buildReason logger env metadataWithVersion cacheDynamicConfig
     result `onLeft` \err -> do
       -- TODO: we used to bundle the first schema cache build with the catalog
       -- migration, using the same error handler for both, meaning that an
@@ -665,6 +666,14 @@ runAppM c (AppM a) = ignoreTraceT $ runReaderT a c
 instance HasAppEnv AppM where
   askAppEnv = ask
 
+instance HasFeatureFlagChecker AppM where
+  checkFlag f = AppM do
+    CheckFeatureFlag runCheckFeatureFlag <- asks appEnvCheckFeatureFlag
+    liftIO $ runCheckFeatureFlag f
+
+instance HasCacheStaticConfig AppM where
+  askCacheStaticConfig = buildCacheStaticConfig <$> askAppEnv
+
 instance MonadTrace AppM where
   newTraceWith c p n (AppM a) = AppM $ newTraceWith c p n a
   newSpanWith i n (AppM a) = AppM $ newSpanWith i n a
@@ -879,6 +888,8 @@ runHGEServer ::
     UserAuthentication m,
     HttpLog m,
     HasAppEnv m,
+    HasCacheStaticConfig m,
+    HasFeatureFlagChecker m,
     ConsoleRenderer m,
     MonadVersionAPIWithExtraData m,
     MonadMetadataApiAuthorization m,
@@ -971,6 +982,8 @@ mkHGEServer ::
     UserAuthentication m,
     HttpLog m,
     HasAppEnv m,
+    HasCacheStaticConfig m,
+    HasFeatureFlagChecker m,
     ConsoleRenderer m,
     MonadVersionAPIWithExtraData m,
     MonadMetadataApiAuthorization m,

server/src-lib/Hasura/App/State.hs

@@ -13,10 +13,11 @@ module Hasura.App.State
     -- * init functions
     buildRebuildableAppContext,
     rebuildRebuildableAppContext,
-    initSQLGenCtx,
 
-    -- * server config
+    -- * subsets
-    buildServerConfigCtx,
+    initSQLGenCtx,
+    buildCacheStaticConfig,
+    buildCacheDynamicConfig,
   )
 where
 
@@ -36,6 +37,7 @@ import Hasura.GraphQL.Schema.Options qualified as Options
 import Hasura.Incremental qualified as Inc
 import Hasura.Logging qualified as L
 import Hasura.Prelude
+import Hasura.RQL.DDL.Schema.Cache.Config
 import Hasura.RQL.Types.Common
 import Hasura.RQL.Types.Metadata
 import Hasura.RQL.Types.SchemaCache (MetadataResourceVersion)
@@ -300,6 +302,9 @@ buildAppContextRule = proc (ServeOptions {..}, env, _keys) -> do
                 | otherwise -> InternalErrorsDisabled
       returnA -< responseInternalErrorsConfig
 
+--------------------------------------------------------------------------------
+-- subsets
+
 initSQLGenCtx :: HashSet ExperimentalFeature -> Options.StringifyNumbers -> Options.DangerouslyCollapseBooleans -> SQLGenCtx
 initSQLGenCtx experimentalFeatures stringifyNum dangerousBooleanCollapse =
   let optimizePermissionFilters
@@ -311,26 +316,23 @@ initSQLGenCtx experimentalFeatures stringifyNum dangerousBooleanCollapse =
         | otherwise = Options.DisableBigQueryStringNumericInput
    in SQLGenCtx stringifyNum dangerousBooleanCollapse optimizePermissionFilters bigqueryStringNumericInput
 
---------------------------------------------------------------------------------
+buildCacheStaticConfig :: AppEnv -> CacheStaticConfig
--- server config
+buildCacheStaticConfig AppEnv {..} =
-
+  CacheStaticConfig
--- | We are trying to slowly get rid of 'HasServerConfigCtx' (and consequently
+    { _cscMaintenanceMode = appEnvEnableMaintenanceMode,
--- of 'ServercConfigtx') in favour of smaller / more specific ad-hoc
+      _cscEventingMode = appEnvEventingMode,
--- types. However, in the meantime, it is often required to builda
+      _cscReadOnlyMode = appEnvEnableReadOnlyMode,
--- 'ServerConfigCtx' at the boundary between parts of the code that use it and
+      _cscCheckFeatureFlag = appEnvCheckFeatureFlag
--- part of the code that use the new 'AppEnv' and 'AppContext'.
+    }
-buildServerConfigCtx :: AppEnv -> AppContext -> ServerConfigCtx
+
-buildServerConfigCtx AppEnv {..} AppContext {..} =
+buildCacheDynamicConfig :: AppContext -> CacheDynamicConfig
-  ServerConfigCtx
+buildCacheDynamicConfig AppContext {..} =
-    { _sccFunctionPermsCtx = acFunctionPermsCtx,
+  CacheDynamicConfig
-      _sccRemoteSchemaPermsCtx = acRemoteSchemaPermsCtx,
+    { _cdcFunctionPermsCtx = acFunctionPermsCtx,
-      _sccSQLGenCtx = acSQLGenCtx,
+      _cdcRemoteSchemaPermsCtx = acRemoteSchemaPermsCtx,
-      _sccMaintenanceMode = appEnvEnableMaintenanceMode,
+      _cdcSQLGenCtx = acSQLGenCtx,
-      _sccExperimentalFeatures = acExperimentalFeatures,
+      _cdcExperimentalFeatures = acExperimentalFeatures,
-      _sccEventingMode = appEnvEventingMode,
+      _cdcDefaultNamingConvention = acDefaultNamingConvention,
-      _sccReadOnlyMode = appEnvEnableReadOnlyMode,
+      _cdcMetadataDefaults = acMetadataDefaults,
-      _sccDefaultNamingConvention = acDefaultNamingConvention,
+      _cdcApolloFederationStatus = acApolloFederationStatus
-      _sccMetadataDefaults = acMetadataDefaults,
-      _sccCheckFeatureFlag = appEnvCheckFeatureFlag,
-      _sccApolloFederationStatus = acApolloFederationStatus
     }

server/src-lib/Hasura/Backends/MSSQL/DDL/EventTrigger.hs

@@ -214,7 +214,7 @@ dropDanglingSQLTrigger sourceConfig triggerName table ops =
 
 createTableEventTrigger ::
   MonadIO m =>
-  ServerConfigCtx ->
+  SQLGenCtx ->
   MSSQLSourceConfig ->
   TableName ->
   [ColumnInfo 'MSSQL] ->
@@ -223,7 +223,7 @@ createTableEventTrigger ::
   TriggerOpsDef 'MSSQL ->
   Maybe (PrimaryKey 'MSSQL (ColumnInfo 'MSSQL)) ->
   m (Either QErr ())
-createTableEventTrigger _serverConfigCtx sourceConfig table columns triggerName triggerOnReplication opsDefinition primaryKeyMaybe = do
+createTableEventTrigger _sqlGen sourceConfig table columns triggerName triggerOnReplication opsDefinition primaryKeyMaybe = do
   liftIO $
     runMSSQLSourceWriteTx sourceConfig $ do
       mkAllTriggersQ triggerName table triggerOnReplication columns opsDefinition primaryKeyMaybe
@@ -233,7 +233,7 @@ createMissingSQLTriggers ::
     MonadError QErr m,
     MonadBaseControl IO m
   ) =>
-  ServerConfigCtx ->
+  SQLGenCtx ->
   MSSQLSourceConfig ->
   TableName ->
   ([ColumnInfo 'MSSQL], Maybe (PrimaryKey 'MSSQL (ColumnInfo 'MSSQL))) ->

server/src-lib/Hasura/Backends/Postgres/DDL/EventTrigger.hs

@@ -205,7 +205,7 @@ createMissingSQLTriggers ::
     MonadBaseControl IO m,
     Backend ('Postgres pgKind)
   ) =>
-  ServerConfigCtx ->
+  SQLGenCtx ->
   PGSourceConfig ->
   TableName ('Postgres pgKind) ->
   ([(ColumnInfo ('Postgres pgKind))], Maybe (PrimaryKey ('Postgres pgKind) (ColumnInfo ('Postgres pgKind)))) ->
@@ -241,7 +241,7 @@ createMissingSQLTriggers serverConfigCtx sourceConfig table (allCols, _) trigger
 
 createTableEventTrigger ::
   (Backend ('Postgres pgKind), MonadIO m, MonadBaseControl IO m) =>
-  ServerConfigCtx ->
+  SQLGenCtx ->
   PGSourceConfig ->
   QualifiedTable ->
   [ColumnInfo ('Postgres pgKind)] ->
@@ -674,7 +674,7 @@ pgIdenTrigger op = QualifiedTriggerName . pgFmtIdentifier . unQualifiedTriggerNa
 -- | Define the pgSQL trigger functions on database events.
 mkTriggerFunctionQ ::
   forall pgKind m.
-  (Backend ('Postgres pgKind), MonadTx m, MonadReader ServerConfigCtx m) =>
+  (Backend ('Postgres pgKind), MonadTx m, MonadReader SQLGenCtx m) =>
   TriggerName ->
   QualifiedTable ->
   [ColumnInfo ('Postgres pgKind)] ->
@@ -682,7 +682,7 @@ mkTriggerFunctionQ ::
   SubscribeOpSpec ('Postgres pgKind) ->
   m QualifiedTriggerName
 mkTriggerFunctionQ triggerName (QualifiedObject schema table) allCols op (SubscribeOpSpec listenColumns deliveryColumns') = do
-  strfyNum <- stringifyNum . _sccSQLGenCtx <$> ask
+  strfyNum <- asks stringifyNum
   let dbQualifiedTriggerName = pgIdenTrigger op triggerName
   () <-
     liftTx $
@@ -795,7 +795,7 @@ checkIfFunctionExistsQ triggerName op = do
 
 mkTrigger ::
   forall pgKind m.
-  (Backend ('Postgres pgKind), MonadTx m, MonadReader ServerConfigCtx m) =>
+  (Backend ('Postgres pgKind), MonadTx m, MonadReader SQLGenCtx m) =>
   TriggerName ->
   QualifiedTable ->
   TriggerOnReplication ->
@@ -830,7 +830,7 @@ mkTrigger triggerName table triggerOnReplication allCols op subOpSpec = do
 
 mkAllTriggersQ ::
   forall pgKind m.
-  (Backend ('Postgres pgKind), MonadTx m, MonadReader ServerConfigCtx m) =>
+  (Backend ('Postgres pgKind), MonadTx m, MonadReader SQLGenCtx m) =>
   TriggerName ->
   QualifiedTable ->
   TriggerOnReplication ->

server/src-lib/Hasura/Backends/Postgres/DDL/RunSQL.hs

@@ -59,7 +59,6 @@ import Hasura.RQL.Types.Source
 import Hasura.RQL.Types.Table
 import Hasura.SQL.AnyBackend qualified as AB
 import Hasura.SQL.Backend
-import Hasura.Server.Types
 import Hasura.Server.Utils (quoteRegex)
 import Hasura.Session
 import Hasura.Tracing qualified as Tracing
@@ -207,7 +206,6 @@ runRunSQL ::
     FetchTableMetadata pgKind,
     FetchFunctionMetadata pgKind,
     CacheRWM m,
-    HasServerConfigCtx m,
     MetadataM m,
     MonadBaseControl IO m,
     MonadError QErr m,
@@ -215,9 +213,10 @@ runRunSQL ::
     Tracing.MonadTrace m,
     UserInfoM m
   ) =>
+  SQLGenCtx ->
   RunSQL ->
   m EncJSON
-runRunSQL q@RunSQL {..} = do
+runRunSQL sqlGen q@RunSQL {..} = do
   sourceConfig <- askSourceConfig @('Postgres pgKind) rSource
   traceCtx <- Tracing.currentContext
   userInfo <- askUserInfo
@@ -225,7 +224,7 @@ runRunSQL q@RunSQL {..} = do
   if (isSchemaCacheBuildRequiredRunSQL q)
     then do
       -- see Note [Checking metadata consistency in run_sql]
-      withMetadataCheck @pgKind rSource rCascade rTxAccessMode $
+      withMetadataCheck @pgKind sqlGen rSource rCascade rTxAccessMode $
         withTraceContext traceCtx $
           withUserInfo userInfo $
             execRawSQL rSql
@@ -250,18 +249,18 @@ withMetadataCheck ::
     FetchTableMetadata pgKind,
     FetchFunctionMetadata pgKind,
     CacheRWM m,
-    HasServerConfigCtx m,
     MetadataM m,
     MonadBaseControl IO m,
     MonadError QErr m,
     MonadIO m
   ) =>
+  SQLGenCtx ->
   SourceName ->
   Bool ->
   PG.TxAccess ->
   PG.TxET QErr m a ->
   m a
-withMetadataCheck source cascade txAccess runSQLQuery = do
+withMetadataCheck sqlGen source cascade txAccess runSQLQuery = do
   SourceInfo _ tableCache functionCache _logicalModels _customReturnTypes sourceConfig _ _ <- askSourceInfo @('Postgres pgKind) source
 
   -- Run SQL query and metadata checker in a transaction
@@ -281,14 +280,14 @@ withMetadataCheck source cascade txAccess runSQLQuery = do
     recreateEventTriggers :: PGSourceConfig -> SchemaCache -> m ()
     recreateEventTriggers sourceConfig schemaCache = do
       let tables = fromMaybe mempty $ unsafeTableCache @('Postgres pgKind) source $ scSources schemaCache
-      serverConfigCtx <- askServerConfigCtx
       liftEitherM $
         runPgSourceWriteTx sourceConfig RunSQLQuery $
           forM_ (M.elems tables) $ \(TableInfo coreInfo _ eventTriggers _) -> do
             let table = _tciName coreInfo
                 columns = getCols $ _tciFieldInfoMap coreInfo
             forM_ (M.toList eventTriggers) $ \(triggerName, EventTriggerInfo {etiOpsDef, etiTriggerOnReplication}) -> do
-              flip runReaderT serverConfigCtx $ mkAllTriggersQ triggerName table etiTriggerOnReplication columns etiOpsDef
+              flip runReaderT sqlGen $
+                mkAllTriggersQ triggerName table etiTriggerOnReplication columns etiOpsDef
 
 -- | @'runTxWithMetadataCheck source sourceConfig txAccess tableCache functionCache cascadeDependencies tx' checks for
 -- changes in GraphQL Engine metadata when a @'tx' is executed on the database alters Postgres

server/src-lib/Hasura/CustomReturnType/API.hs

@@ -42,8 +42,8 @@ import Hasura.RQL.Types.Permission (PermDef (_pdRole), SelPerm)
 import Hasura.RQL.Types.SchemaCache.Build
 import Hasura.SQL.AnyBackend qualified as AB
 import Hasura.SQL.Backend
-import Hasura.Server.Init.FeatureFlag as FF
+import Hasura.Server.Init.FeatureFlag (HasFeatureFlagChecker (..))
-import Hasura.Server.Types (HasServerConfigCtx (..), ServerConfigCtx (..))
+import Hasura.Server.Init.FeatureFlag qualified as FF
 import Hasura.Session (RoleName)
 
 -- | Default implementation of the 'track_custom_return_type' request payload.
@@ -122,8 +122,7 @@ runGetCustomReturnType ::
   forall b m.
   ( BackendMetadata b,
     MetadataM m,
-    HasServerConfigCtx m,
+    HasFeatureFlagChecker m,
-    MonadIO m,
     MonadError QErr m
   ) =>
   GetCustomReturnType b ->
@@ -151,8 +150,7 @@ runTrackCustomReturnType ::
     CacheRWM m,
     MetadataM m,
     MonadError QErr m,
-    HasServerConfigCtx m,
+    HasFeatureFlagChecker m
-    MonadIO m
   ) =>
   TrackCustomReturnType b ->
   m EncJSON
@@ -273,7 +271,7 @@ instance
 
 runCreateSelectCustomReturnTypePermission ::
   forall b m.
-  (Backend b, CacheRWM m, MetadataM m, MonadError QErr m, MonadIO m, HasServerConfigCtx m) =>
+  (Backend b, CacheRWM m, MetadataM m, MonadError QErr m, HasFeatureFlagChecker m) =>
   CreateCustomReturnTypePermission SelPerm b ->
   m EncJSON
 runCreateSelectCustomReturnTypePermission CreateCustomReturnTypePermission {..} = do
@@ -312,7 +310,7 @@ instance FromJSON (DropCustomReturnTypePermission b) where
 
 runDropSelectCustomReturnTypePermission ::
   forall b m.
-  (Backend b, CacheRWM m, MetadataM m, MonadError QErr m, MonadIO m, HasServerConfigCtx m) =>
+  (Backend b, CacheRWM m, MetadataM m, MonadError QErr m, HasFeatureFlagChecker m) =>
   DropCustomReturnTypePermission b ->
   m EncJSON
 runDropSelectCustomReturnTypePermission DropCustomReturnTypePermission {..} = do
@@ -340,14 +338,10 @@ dropCustomReturnTypeInMetadata source name = do
       %~ OMap.delete name
 
 -- | check feature flag is enabled before carrying out any actions
-throwIfFeatureDisabled :: (HasServerConfigCtx m, MonadIO m, MonadError QErr m) => m ()
+throwIfFeatureDisabled :: (HasFeatureFlagChecker m, MonadError QErr m) => m ()
 throwIfFeatureDisabled = do
-  configCtx <- askServerConfigCtx
+  enableCustomReturnTypes <- checkFlag FF.logicalModelInterface
-  let CheckFeatureFlag runCheckFeatureFlag = _sccCheckFeatureFlag configCtx
+  unless enableCustomReturnTypes $ throw500 "CustomReturnTypes is disabled!"
-
-  enableCustomReturnTypes <- liftIO (runCheckFeatureFlag FF.logicalModelInterface)
-
-  unless enableCustomReturnTypes (throw500 "CustomReturnTypes is disabled!")
 
 -- | Check whether a custom return type with the given root field name exists for
 -- the given source.

server/src-lib/Hasura/GraphQL/Schema.hs

@@ -97,7 +97,11 @@ buildGQLContext ::
   ( MonadError QErr m,
     MonadIO m
   ) =>
-  ServerConfigCtx ->
+  Options.InferFunctionPermissions ->
+  Options.RemoteSchemaPermissions ->
+  HashSet ExperimentalFeature ->
+  SQLGenCtx ->
+  ApolloFederationStatus ->
   SourceCache ->
   HashMap RemoteSchemaName (RemoteSchemaCtx, MetadataObject) ->
   ActionCache ->
@@ -114,66 +118,75 @@ buildGQLContext ::
         GQLContext
       )
     )
-buildGQLContext ServerConfigCtx {..} sources allRemoteSchemas allActions customTypes = do
+buildGQLContext
-  let remoteSchemasRoles = concatMap (Map.keys . _rscPermissions . fst . snd) $ Map.toList allRemoteSchemas
+  functionPermissions
-      actionRoles =
+  remoteSchemaPermissions
-        Set.insert adminRoleName $
+  experimentalFeatures
-          Set.fromList (allActionInfos ^.. folded . aiPermissions . to Map.keys . folded)
+  sqlGen
-            <> Set.fromList (bool mempty remoteSchemasRoles $ _sccRemoteSchemaPermsCtx == Options.EnableRemoteSchemaPermissions)
+  apolloFederationStatus
-      allActionInfos = Map.elems allActions
+  sources
-      allTableRoles = Set.fromList $ getTableRoles =<< Map.elems sources
+  allRemoteSchemas
-      allCustomReturnTypeRoles = Set.fromList $ getCustomReturnTypeRoles =<< Map.elems sources
+  allActions
-      allRoles = actionRoles <> allTableRoles <> allCustomReturnTypeRoles
+  customTypes = do
+    let remoteSchemasRoles = concatMap (Map.keys . _rscPermissions . fst . snd) $ Map.toList allRemoteSchemas
+        actionRoles =
+          Set.insert adminRoleName $
+            Set.fromList (allActionInfos ^.. folded . aiPermissions . to Map.keys . folded)
+              <> Set.fromList (bool mempty remoteSchemasRoles $ remoteSchemaPermissions == Options.EnableRemoteSchemaPermissions)
+        allActionInfos = Map.elems allActions
+        allTableRoles = Set.fromList $ getTableRoles =<< Map.elems sources
+        allCustomReturnTypeRoles = Set.fromList $ getCustomReturnTypeRoles =<< Map.elems sources
+        allRoles = actionRoles <> allTableRoles <> allCustomReturnTypeRoles
 
-  contexts <-
+    contexts <-
-    -- Buld role contexts in parallel. We'd prefer deterministic parallelism
+      -- Buld role contexts in parallel. We'd prefer deterministic parallelism
-    -- but that isn't really acheivable (see mono #3829). NOTE: the admin role
+      -- but that isn't really acheivable (see mono #3829). NOTE: the admin role
-    -- will still be a bottleneck here, even on huge_schema which has many
+      -- will still be a bottleneck here, even on huge_schema which has many
-    -- roles.
+      -- roles.
-    fmap Map.fromList $
+      fmap Map.fromList $
-      forConcurrentlyEIO 10 (Set.toList allRoles) $ \role -> do
+        forConcurrentlyEIO 10 (Set.toList allRoles) $ \role -> do
-        (role,)
+          (role,)
-          <$> concurrentlyEIO
+            <$> concurrentlyEIO
-            ( buildRoleContext
+              ( buildRoleContext
-                (_sccSQLGenCtx, _sccFunctionPermsCtx)
+                  (sqlGen, functionPermissions)
-                sources
+                  sources
-                allRemoteSchemas
+                  allRemoteSchemas
-                allActionInfos
+                  allActionInfos
-                customTypes
+                  customTypes
-                role
+                  role
-                _sccRemoteSchemaPermsCtx
+                  remoteSchemaPermissions
-                _sccExperimentalFeatures
+                  experimentalFeatures
-                _sccApolloFederationStatus
+                  apolloFederationStatus
-            )
+              )
-            ( buildRelayRoleContext
+              ( buildRelayRoleContext
-                (_sccSQLGenCtx, _sccFunctionPermsCtx)
+                  (sqlGen, functionPermissions)
-                sources
+                  sources
-                allActionInfos
+                  allActionInfos
-                customTypes
+                  customTypes
-                role
+                  role
-                _sccExperimentalFeatures
+                  experimentalFeatures
-            )
+              )
-  let hasuraContexts = fst <$> contexts
+    let hasuraContexts = fst <$> contexts
-      relayContexts = snd <$> contexts
+        relayContexts = snd <$> contexts
 
-  adminIntrospection <-
+    adminIntrospection <-
-    case Map.lookup adminRoleName hasuraContexts of
+      case Map.lookup adminRoleName hasuraContexts of
-      Just (_context, _errors, introspection) -> pure introspection
+        Just (_context, _errors, introspection) -> pure introspection
-      Nothing -> throw500 "buildGQLContext failed to build for the admin role"
+        Nothing -> throw500 "buildGQLContext failed to build for the admin role"
-  (unauthenticated, unauthenticatedRemotesErrors) <- unauthenticatedContext allRemoteSchemas _sccRemoteSchemaPermsCtx
+    (unauthenticated, unauthenticatedRemotesErrors) <- unauthenticatedContext allRemoteSchemas remoteSchemaPermissions
-  pure
+    pure
-    ( ( adminIntrospection,
+      ( ( adminIntrospection,
-        view _1 <$> hasuraContexts,
+          view _1 <$> hasuraContexts,
-        unauthenticated,
+          unauthenticated,
-        Set.unions $ unauthenticatedRemotesErrors : (view _2 <$> Map.elems hasuraContexts)
+          Set.unions $ unauthenticatedRemotesErrors : (view _2 <$> Map.elems hasuraContexts)
-      ),
+        ),
-      ( relayContexts,
+        ( relayContexts,
-        -- Currently, remote schemas are exposed through Relay, but ONLY through
+          -- Currently, remote schemas are exposed through Relay, but ONLY through
-        -- the unauthenticated role.  This is probably an oversight.  See
+          -- the unauthenticated role.  This is probably an oversight.  See
-        -- hasura/graphql-engine-mono#3883.
+          -- hasura/graphql-engine-mono#3883.
-        unauthenticated
+          unauthenticated
+        )
       )
-    )
 
 buildSchemaOptions ::
   (SQLGenCtx, Options.InferFunctionPermissions) ->

server/src-lib/Hasura/LogicalModel/API.hs

@@ -37,8 +37,8 @@ import Hasura.RQL.Types.SchemaCache.Build
 import Hasura.SQL.AnyBackend qualified as AB
 import Hasura.SQL.Backend
 import Hasura.SQL.Tag
-import Hasura.Server.Init.FeatureFlag as FF
+import Hasura.Server.Init.FeatureFlag (HasFeatureFlagChecker (..))
-import Hasura.Server.Types (HasServerConfigCtx (..), ServerConfigCtx (..))
+import Hasura.Server.Init.FeatureFlag qualified as FF
 
 -- | Default implementation of the 'track_logical_model' request payload.
 data TrackLogicalModel (b :: BackendType) = TrackLogicalModel
@@ -90,9 +90,9 @@ deriving via
 logicalModelTrackToMetadata ::
   forall b m.
   ( BackendMetadata b,
-    MetadataM m,
+    MonadError QErr m,
     MonadIO m,
-    MonadError QErr m
+    MetadataM m
   ) =>
   Env.Environment ->
   SourceConnConfiguration b ->
@@ -145,8 +145,7 @@ runGetLogicalModel ::
   forall b m.
   ( BackendMetadata b,
     MetadataM m,
-    HasServerConfigCtx m,
+    HasFeatureFlagChecker m,
-    MonadIO m,
     MonadError QErr m
   ) =>
   GetLogicalModel b ->
@@ -167,11 +166,11 @@ runGetLogicalModel q = do
 runTrackLogicalModel ::
   forall b m.
   ( BackendMetadata b,
+    MonadError QErr m,
+    MonadIO m,
     CacheRWM m,
     MetadataM m,
-    MonadError QErr m,
+    HasFeatureFlagChecker m
-    HasServerConfigCtx m,
-    MonadIO m
   ) =>
   Env.Environment ->
   TrackLogicalModel b ->
@@ -273,13 +272,9 @@ dropLogicalModelInMetadata source rootFieldName = do
       %~ OMap.delete rootFieldName
 
 -- | check feature flag is enabled before carrying out any actions
-throwIfFeatureDisabled :: (HasServerConfigCtx m, MonadIO m, MonadError QErr m) => m ()
+throwIfFeatureDisabled :: (HasFeatureFlagChecker m, MonadError QErr m) => m ()
 throwIfFeatureDisabled = do
-  configCtx <- askServerConfigCtx
+  enableLogicalModels <- checkFlag FF.logicalModelInterface
-  let CheckFeatureFlag runCheckFeatureFlag = _sccCheckFeatureFlag configCtx
-
-  enableLogicalModels <- liftIO (runCheckFeatureFlag FF.logicalModelInterface)
-
   unless enableLogicalModels (throw500 "LogicalModels is disabled!")
 
 -- | Check whether a logical model with the given root field name exists for

server/src-lib/Hasura/RQL/DDL/FeatureFlag.hs

@@ -9,7 +9,6 @@ where
 
 --------------------------------------------------------------------------------
 
---------------------------------------------------------------------------------
 import Data.Aeson (FromJSON, (.:), (.=))
 import Data.Aeson qualified as Aeson
 import Data.HashMap.Strict qualified as HashMap
@@ -31,13 +30,12 @@ instance FromJSON GetFeatureFlag where
 
 runGetFeatureFlag ::
   ( MonadError Error.QErr m,
-    Types.HasServerConfigCtx m,
     MonadIO m
   ) =>
+  Types.CheckFeatureFlag ->
   GetFeatureFlag ->
   m EncJSON
-runGetFeatureFlag GetFeatureFlag {..} = do
+runGetFeatureFlag (Types.CheckFeatureFlag getFeatureFlag) GetFeatureFlag {..} = do
-  Types.CheckFeatureFlag getFeatureFlag <- Types._sccCheckFeatureFlag <$> Types.askServerConfigCtx
   let flagM = HashMap.lookup gfgIdentifier $ FeatureFlag.getFeatureFlags $ FeatureFlag.featureFlags
   case flagM of
     Nothing -> Error.throw400 Error.NotFound $ "Feature Flag '" <> gfgIdentifier <> "' not found"

server/src-lib/Hasura/RQL/DDL/Schema/Cache.hs

@@ -61,6 +61,7 @@ import Hasura.RQL.DDL.InheritedRoles (resolveInheritedRole)
 import Hasura.RQL.DDL.RemoteRelationship (CreateRemoteSchemaRemoteRelationship (..), PartiallyResolvedSource (..), buildRemoteFieldInfo, getRemoteSchemaEntityJoinColumns)
 import Hasura.RQL.DDL.ScheduledTrigger
 import Hasura.RQL.DDL.Schema.Cache.Common
+import Hasura.RQL.DDL.Schema.Cache.Config
 import Hasura.RQL.DDL.Schema.Cache.Dependencies
 import Hasura.RQL.DDL.Schema.Cache.Fields
 import Hasura.RQL.DDL.Schema.Cache.Permission
@@ -147,7 +148,7 @@ buildRebuildableSchemaCache ::
   Logger Hasura ->
   Env.Environment ->
   MetadataWithResourceVersion ->
-  ServerConfigCtx ->
+  CacheDynamicConfig ->
   CacheBuild RebuildableSchemaCache
 buildRebuildableSchemaCache =
   buildRebuildableSchemaCacheWithReason CatalogSync
@@ -157,12 +158,12 @@ buildRebuildableSchemaCacheWithReason ::
   Logger Hasura ->
   Env.Environment ->
   MetadataWithResourceVersion ->
-  ServerConfigCtx ->
+  CacheDynamicConfig ->
   CacheBuild RebuildableSchemaCache
-buildRebuildableSchemaCacheWithReason reason logger env metadataWithVersion serverConfigCtx = do
+buildRebuildableSchemaCacheWithReason reason logger env metadataWithVersion dynamicConfig = do
   result <-
     flip runReaderT reason $
-      Inc.build (buildSchemaCacheRule logger env) (metadataWithVersion, serverConfigCtx, initialInvalidationKeys, Nothing)
+      Inc.build (buildSchemaCacheRule logger env) (metadataWithVersion, dynamicConfig, initialInvalidationKeys, Nothing)
 
   pure $ RebuildableSchemaCache (Inc.result result) initialInvalidationKeys (Inc.rebuildRule result)
 
@@ -172,11 +173,11 @@ newtype CacheRWT m a
     -- (which added Control.Monad.Trans.Writer.CPS) are leaky, and we don’t have
     -- that yet.
     --
-    -- The use of 'ReaderT ServerConfigCtx' is only here to avoid manually
+    -- The use of 'ReaderT CacheDynamicConfig' is only here to avoid manually
-    -- passing the 'ServerConfigCtx' to every function that builds the cache. It
+    -- passing the 'CacheDynamicConfig' to every function that builds the cache. It
     -- should ultimately be reduced to 'AppContext', or even better a relevant
     -- subset thereof.
-    CacheRWT (ReaderT ServerConfigCtx (StateT (RebuildableSchemaCache, CacheInvalidations) m) a)
+    CacheRWT (ReaderT CacheDynamicConfig (StateT (RebuildableSchemaCache, CacheInvalidations) m) a)
   deriving newtype
     ( Functor,
       Applicative,
@@ -188,13 +189,11 @@ newtype CacheRWT m a
       Tracing.MonadTrace,
       MonadBase b,
       MonadBaseControl b,
-      ProvidesNetwork
+      ProvidesNetwork,
+      FF.HasFeatureFlagChecker
     )
   deriving anyclass (MonadQueryTags)
 
-instance Monad m => HasServerConfigCtx (CacheRWT m) where
-  askServerConfigCtx = CacheRWT ask
-
 instance MonadReader r m => MonadReader r (CacheRWT m) where
   ask = lift ask
   local f (CacheRWT m) = CacheRWT $ mapReaderT (local f) m
@@ -209,7 +208,7 @@ instance (MonadGetApiTimeLimit m) => MonadGetApiTimeLimit (CacheRWT m) where
 
 runCacheRWT ::
   Monad m =>
-  ServerConfigCtx ->
+  CacheDynamicConfig ->
   RebuildableSchemaCache ->
   CacheRWT m a ->
   m (a, RebuildableSchemaCache, CacheInvalidations)
@@ -228,19 +227,20 @@ instance
   ( MonadIO m,
     MonadError QErr m,
     ProvidesNetwork m,
-    MonadResolveSource m
+    MonadResolveSource m,
+    HasCacheStaticConfig m
   ) =>
   CacheRWM (CacheRWT m)
   where
   buildSchemaCacheWithOptions buildReason invalidations metadata = CacheRWT do
-    serverConfigCtx <- ask
+    dynamicConfig <- ask
     (RebuildableSchemaCache lastBuiltSC invalidationKeys rule, oldInvalidations) <- get
     let metadataWithVersion = MetadataWithResourceVersion metadata $ scMetadataResourceVersion lastBuiltSC
         newInvalidationKeys = invalidateKeys invalidations invalidationKeys
     result <-
       runCacheBuildM $
         flip runReaderT buildReason $
-          Inc.build rule (metadataWithVersion, serverConfigCtx, newInvalidationKeys, Nothing)
+          Inc.build rule (metadataWithVersion, dynamicConfig, newInvalidationKeys, Nothing)
     let schemaCache = Inc.result result
         prunedInvalidationKeys = pruneInvalidationKeys schemaCache newInvalidationKeys
         !newCache = RebuildableSchemaCache schemaCache prunedInvalidationKeys (Inc.rebuildRule result)
@@ -335,19 +335,20 @@ buildSchemaCacheRule ::
     MonadError QErr m,
     MonadReader BuildReason m,
     ProvidesNetwork m,
-    MonadResolveSource m
+    MonadResolveSource m,
+    HasCacheStaticConfig m
   ) =>
   Logger Hasura ->
   Env.Environment ->
-  (MetadataWithResourceVersion, ServerConfigCtx, InvalidationKeys, Maybe StoredIntrospection) `arr` SchemaCache
+  (MetadataWithResourceVersion, CacheDynamicConfig, InvalidationKeys, Maybe StoredIntrospection) `arr` SchemaCache
-buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDefaults resourceVersion, serverConfigCtx, invalidationKeys, storedIntrospection) -> do
+buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDefaults resourceVersion, dynamicConfig, invalidationKeys, storedIntrospection) -> do
   invalidationKeysDep <- Inc.newDependency -< invalidationKeys
-  let metadataDefaults = _sccMetadataDefaults serverConfigCtx
+  let metadataDefaults = _cdcMetadataDefaults dynamicConfig
       metadata@Metadata {..} = overrideMetadataDefaults metadataNoDefaults metadataDefaults
   metadataDep <- Inc.newDependency -< metadata
 
   (inconsistentObjects, (resolvedOutputs, dependencyInconsistentObjects, resolvedDependencies), ((adminIntrospection, gqlContext, gqlContextUnauth, inconsistentRemoteSchemas), (relayContext, relayContextUnauth))) <-
-    Inc.cache buildOutputsAndSchema -< (metadataDep, serverConfigCtx, invalidationKeysDep, storedIntrospection)
+    Inc.cache buildOutputsAndSchema -< (metadataDep, dynamicConfig, invalidationKeysDep, storedIntrospection)
 
   let (resolvedEndpoints, endpointCollectedInfo) = runIdentity $ runWriterT $ buildRESTEndpoints _metaQueryCollections (OMap.elems _metaRestEndpoints)
       (cronTriggersMap, cronTriggersCollectedInfo) = runIdentity $ runWriterT $ buildCronTriggers (OMap.elems _metaCronTriggers)
@@ -442,15 +443,19 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
         }
   where
     -- See Note [Avoiding GraphQL schema rebuilds when changing irrelevant Metadata]
-    buildOutputsAndSchema = proc (metadataDep, serverConfigCtx, invalidationKeysDep, storedIntrospection) -> do
+    buildOutputsAndSchema = proc (metadataDep, dynamicConfig, invalidationKeysDep, storedIntrospection) -> do
-      (outputs, collectedInfo) <- runWriterA buildAndCollectInfo -< (serverConfigCtx, metadataDep, invalidationKeysDep, storedIntrospection)
+      (outputs, collectedInfo) <- runWriterA buildAndCollectInfo -< (dynamicConfig, metadataDep, invalidationKeysDep, storedIntrospection)
       let (inconsistentObjects, unresolvedDependencies) = partitionEithers $ toList collectedInfo
       out2@(resolvedOutputs, _dependencyInconsistentObjects, _resolvedDependencies) <- resolveDependencies -< (outputs, unresolvedDependencies)
       out3 <-
         bindA
           -< do
             buildGQLContext
-              serverConfigCtx
+              (_cdcFunctionPermsCtx dynamicConfig)
+              (_cdcRemoteSchemaPermsCtx dynamicConfig)
+              (_cdcExperimentalFeatures dynamicConfig)
+              (_cdcSQLGenCtx dynamicConfig)
+              (_cdcApolloFederationStatus dynamicConfig)
               (_boSources resolvedOutputs)
               (_boRemoteSchemas resolvedOutputs)
               (_boActions resolvedOutputs)
@@ -484,7 +489,8 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
         ArrowWriter (Seq (Either InconsistentMetadata MetadataDependency)) arr,
         MonadIO m,
         MonadBaseControl IO m,
-        ProvidesNetwork m
+        ProvidesNetwork m,
+        HasCacheStaticConfig m
       ) =>
       (Inc.Dependency (BackendMap BackendInvalidationKeysWrapper), [AB.AnyBackend BackendConfigWrapper]) `arr` BackendCache
     resolveBackendCache = proc (backendInvalidationMap, backendConfigs) -> do
@@ -586,17 +592,19 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
         MonadIO m,
         BackendMetadata b,
         MonadError QErr m,
-        MonadBaseControl IO m
+        MonadBaseControl IO m,
+        HasCacheStaticConfig m
       ) =>
-      (Proxy b, ServerConfigCtx, Bool, SourceConfig b) `arr` (RecreateEventTriggers, SourceCatalogMigrationState)
+      (Proxy b, Bool, SourceConfig b) `arr` (RecreateEventTriggers, SourceCatalogMigrationState)
-    initCatalogIfNeeded = Inc.cache proc (Proxy, serverConfigCtx, atleastOneTrigger, sourceConfig) -> do
+    initCatalogIfNeeded = Inc.cache proc (Proxy, atleastOneTrigger, sourceConfig) -> do
       bindA
         -< do
           if atleastOneTrigger
             then do
-              let maintenanceMode = _sccMaintenanceMode serverConfigCtx
+              cacheStaticConfig <- askCacheStaticConfig
-                  eventingMode = _sccEventingMode serverConfigCtx
+              let maintenanceMode = _cscMaintenanceMode cacheStaticConfig
-                  readOnlyMode = _sccReadOnlyMode serverConfigCtx
+                  eventingMode = _cscEventingMode cacheStaticConfig
+                  readOnlyMode = _cscReadOnlyMode cacheStaticConfig
 
               if
                   -- when safe mode is enabled, don't perform any migrations
@@ -632,9 +640,10 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
         MonadError QErr m,
         MonadIO m,
         BackendMetadata b,
-        GetAggregationPredicatesDeps b
+        GetAggregationPredicatesDeps b,
+        HasCacheStaticConfig m
       ) =>
-      ( ServerConfigCtx,
+      ( CacheDynamicConfig,
         HashMap SourceName (AB.AnyBackend PartiallyResolvedSource),
         SourceMetadata b,
         SourceConfig b,
@@ -646,7 +655,7 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
         OrderedRoles
       )
         `arr` (SourceInfo b)
-    buildSource = proc (serverConfigCtx, allSources, sourceMetadata, sourceConfig, tablesRawInfo, eventTriggerInfoMaps, _dbTables, dbFunctions, remoteSchemaMap, orderedRoles) -> do
+    buildSource = proc (dynamicConfig, allSources, sourceMetadata, sourceConfig, tablesRawInfo, eventTriggerInfoMaps, _dbTables, dbFunctions, remoteSchemaMap, orderedRoles) -> do
       let SourceMetadata sourceName _backendKind tables functions logicalModels customReturnTypes _ queryTagsConfig sourceCustomization _healthCheckConfig = sourceMetadata
           tablesMetadata = OMap.elems tables
           (_, nonColumnInputs, permissions) = unzip3 $ map mkTableInputs tablesMetadata
@@ -683,8 +692,8 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
 
       -- not forcing the evaluation here results in a measurable negative impact
       -- on memory residency as measured by our benchmark
-      let !defaultNC = _sccDefaultNamingConvention serverConfigCtx
+      let !defaultNC = _cdcDefaultNamingConvention dynamicConfig
-          !isNamingConventionEnabled = EFNamingConventions `elem` (_sccExperimentalFeatures serverConfigCtx)
+          !isNamingConventionEnabled = EFNamingConventions `elem` (_cdcExperimentalFeatures dynamicConfig)
       !namingConv <-
         bindA
           -<
@@ -732,7 +741,7 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
       areLogicalModelsEnabled <-
         bindA
           -< do
-            let CheckFeatureFlag checkFeatureFlag = _sccCheckFeatureFlag serverConfigCtx
+            CheckFeatureFlag checkFeatureFlag <- _cscCheckFeatureFlag <$> askCacheStaticConfig
             liftIO @m $ checkFeatureFlag FF.logicalModelInterface
 
       let mkCustomReturnTypeMetadataObject :: CustomReturnTypeMetadata b -> MetadataObject
@@ -821,10 +830,11 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
         MonadReader BuildReason m,
         MonadBaseControl IO m,
         ProvidesNetwork m,
-        MonadResolveSource m
+        MonadResolveSource m,
+        HasCacheStaticConfig m
       ) =>
-      (ServerConfigCtx, Inc.Dependency Metadata, Inc.Dependency InvalidationKeys, Maybe StoredIntrospection) `arr` BuildOutputs
+      (CacheDynamicConfig, Inc.Dependency Metadata, Inc.Dependency InvalidationKeys, Maybe StoredIntrospection) `arr` BuildOutputs
-    buildAndCollectInfo = proc (serverConfigCtx, metadataDep, invalidationKeys, storedIntrospection) -> do
+    buildAndCollectInfo = proc (dynamicConfig, metadataDep, invalidationKeys, storedIntrospection) -> do
       sources <- Inc.dependOn -< Inc.selectD #_metaSources metadataDep
       remoteSchemas <- Inc.dependOn -< Inc.selectD #_metaRemoteSchemas metadataDep
       customTypes <- Inc.dependOn -< Inc.selectD #_metaCustomTypes metadataDep
@@ -860,8 +870,8 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
       let remoteSchemaInvalidationKeys = Inc.selectD #_ikRemoteSchemas invalidationKeys
       remoteSchemaMap <- buildRemoteSchemas env -< ((remoteSchemaInvalidationKeys, orderedRoles, fmap encJToLBS . siRemotes <$> storedIntrospection), OMap.elems remoteSchemas)
       let remoteSchemaCtxMap = M.map fst remoteSchemaMap
-          !defaultNC = _sccDefaultNamingConvention serverConfigCtx
+          !defaultNC = _cdcDefaultNamingConvention dynamicConfig
-          !isNamingConventionEnabled = EFNamingConventions `elem` (_sccExperimentalFeatures serverConfigCtx)
+          !isNamingConventionEnabled = EFNamingConventions `elem` (_cdcExperimentalFeatures dynamicConfig)
 
       let backendInvalidationKeys = Inc.selectD #_ikBackends invalidationKeys
       backendCache <- resolveBackendCache -< (backendInvalidationKeys, BackendMap.elems backendConfigs)
@@ -875,7 +885,7 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
           Inc.keyed
             ( \_ exists ->
                 AB.dispatchAnyBackendArrow @BackendMetadata @BackendEventTrigger
-                  ( proc (backendInfoAndSourceMetadata :: BackendInfoAndSourceMetadata b, (serverConfigCtx, invalidationKeys, storedIntrospection, defaultNC, isNamingConventionEnabled)) -> do
+                  ( proc (backendInfoAndSourceMetadata :: BackendInfoAndSourceMetadata b, (dynamicConfig, invalidationKeys, storedIntrospection, defaultNC, isNamingConventionEnabled)) -> do
                       let sourceMetadata = _bcasmSourceMetadata backendInfoAndSourceMetadata
                           sourceName = _smName sourceMetadata
                           sourceInvalidationsKeys = Inc.selectD #_ikSources invalidationKeys
@@ -904,7 +914,7 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
                               eventTriggers = map (_tmTable &&& OMap.elems . _tmEventTriggers) tablesMetadata
                               numEventTriggers = sum $ map (length . snd) eventTriggers
 
-                          (recreateEventTriggers, sourceCatalogMigrationState) <- initCatalogIfNeeded -< (Proxy :: Proxy b, serverConfigCtx, numEventTriggers > 0, sourceConfig)
+                          (recreateEventTriggers, sourceCatalogMigrationState) <- initCatalogIfNeeded -< (Proxy :: Proxy b, numEventTriggers > 0, sourceConfig)
 
                           bindA -< unLogger logger (sourceName, sourceCatalogMigrationState)
 
@@ -915,7 +925,7 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
                             (|
                               Inc.keyed
                                 ( \_ (tableCoreInfo, (_, eventTriggerConfs)) ->
-                                    buildTableEventTriggers -< (serverConfigCtx, sourceName, sourceConfig, tableCoreInfo, eventTriggerConfs, metadataInvalidationKey, recreateEventTriggers)
+                                    buildTableEventTriggers -< (dynamicConfig, sourceName, sourceConfig, tableCoreInfo, eventTriggerConfs, metadataInvalidationKey, recreateEventTriggers)
                                 )
                               |) (tablesCoreInfo `alignTableMap` mapFromL fst eventTriggers)
 
@@ -926,7 +936,7 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
                                   PartiallyResolvedSource sourceMetadata sourceConfig source tablesCoreInfo eventTriggerInfoMaps
                   )
                   -<
-                    (exists, (serverConfigCtx, invalidationKeys, storedIntrospection, defaultNC, isNamingConventionEnabled))
+                    (exists, (dynamicConfig, invalidationKeys, storedIntrospection, defaultNC, isNamingConventionEnabled))
             )
           |) (M.fromList $ OMap.toList backendInfoAndSourceMetadata)
       let partiallyResolvedSources = catMaybes partiallyResolvedSourcesMaybes
@@ -946,7 +956,7 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
                 AB.dispatchAnyBackendArrow @BackendMetadata @GetAggregationPredicatesDeps
                   ( proc
                       ( partiallyResolvedSource :: PartiallyResolvedSource b,
-                        (serverConfigCtx, allResolvedSources, remoteSchemaCtxMap, orderedRoles)
+                        (dynamicConfig, allResolvedSources, remoteSchemaCtxMap, orderedRoles)
                         )
                     -> do
                       let PartiallyResolvedSource sourceMetadata sourceConfig introspection tablesInfo eventTriggers = partiallyResolvedSource
@@ -954,7 +964,7 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
                       so <-
                         Inc.cache buildSource
                           -<
-                            ( serverConfigCtx,
+                            ( dynamicConfig,
                               allResolvedSources,
                               sourceMetadata,
                               sourceConfig,
@@ -969,7 +979,7 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
                   )
                   -<
                     ( exists,
-                      (serverConfigCtx, partiallyResolvedSources, remoteSchemaCtxMap, orderedRoles)
+                      (dynamicConfig, partiallyResolvedSources, remoteSchemaCtxMap, orderedRoles)
                     )
             )
           |) partiallyResolvedSources
@@ -1098,7 +1108,7 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
     mkEventTriggerMetadataObject ::
       forall b a c.
       Backend b =>
-      (ServerConfigCtx, a, SourceName, c, TableName b, RecreateEventTriggers, EventTriggerConf b) ->
+      (CacheDynamicConfig, a, SourceName, c, TableName b, RecreateEventTriggers, EventTriggerConf b) ->
       MetadataObject
     mkEventTriggerMetadataObject (_, _, source, _, table, _, eventTriggerConf) =
       let objectId =
@@ -1133,9 +1143,10 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
         MonadBaseControl IO m,
         MonadReader BuildReason m,
         BackendMetadata b,
-        BackendEventTrigger b
+        BackendEventTrigger b,
+        HasCacheStaticConfig m
       ) =>
-      ( ServerConfigCtx,
+      ( CacheDynamicConfig,
         SourceName,
         SourceConfig b,
         TableCoreInfoG b (ColumnInfo b) (ColumnInfo b),
@@ -1144,15 +1155,15 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
         RecreateEventTriggers
       )
         `arr` (EventTriggerInfoMap b)
-    buildTableEventTriggers = proc (serverConfigCtx, sourceName, sourceConfig, tableInfo, eventTriggerConfs, metadataInvalidationKey, migrationRecreateEventTriggers) ->
+    buildTableEventTriggers = proc (dynamicConfig, sourceName, sourceConfig, tableInfo, eventTriggerConfs, metadataInvalidationKey, migrationRecreateEventTriggers) ->
       buildInfoMap (etcName . (^. _7)) (mkEventTriggerMetadataObject @b) buildEventTrigger
         -<
-          (tableInfo, map (serverConfigCtx,metadataInvalidationKey,sourceName,sourceConfig,_tciName tableInfo,migrationRecreateEventTriggers,) eventTriggerConfs)
+          (tableInfo, map (dynamicConfig,metadataInvalidationKey,sourceName,sourceConfig,_tciName tableInfo,migrationRecreateEventTriggers,) eventTriggerConfs)
       where
-        buildEventTrigger = proc (tableInfo, (serverConfigCtx, metadataInvalidationKey, source, sourceConfig, table, migrationRecreateEventTriggers, eventTriggerConf)) -> do
+        buildEventTrigger = proc (tableInfo, (dynamicConfig, metadataInvalidationKey, source, sourceConfig, table, migrationRecreateEventTriggers, eventTriggerConf)) -> do
           let triggerName = etcName eventTriggerConf
               triggerOnReplication = etcTriggerOnReplication eventTriggerConf
-              metadataObject = mkEventTriggerMetadataObject @b (serverConfigCtx, metadataInvalidationKey, source, sourceConfig, table, migrationRecreateEventTriggers, eventTriggerConf)
+              metadataObject = mkEventTriggerMetadataObject @b (dynamicConfig, metadataInvalidationKey, source, sourceConfig, table, migrationRecreateEventTriggers, eventTriggerConf)
               schemaObjectId =
                 SOSourceObj source $
                   AB.mkAnyBackend $
@@ -1169,13 +1180,14 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
             withRecordInconsistency
               ( do
                   (info, dependencies) <- bindErrorA -< modifyErr (addTableContext @b table . addTriggerContext) $ buildEventTriggerInfo @b env source table eventTriggerConf
+                  staticConfig <- bindA -< askCacheStaticConfig
                   let isCatalogUpdate =
                         case buildReason of
                           CatalogUpdate _ -> True
                           CatalogSync -> False
                       tableColumns = M.elems $ _tciFieldInfoMap tableInfo
-                  if ( _sccMaintenanceMode serverConfigCtx == MaintenanceModeDisabled
+                  if ( _cscMaintenanceMode staticConfig == MaintenanceModeDisabled
-                         && _sccReadOnlyMode serverConfigCtx == ReadOnlyModeDisabled
+                         && _cscReadOnlyMode staticConfig == ReadOnlyModeDisabled
                      )
                     then do
                       bindA
@@ -1187,7 +1199,7 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
                             liftEitherM $
                               createTableEventTrigger
                                 @b
-                                serverConfigCtx
+                                (_cdcSQLGenCtx dynamicConfig)
                                 sourceConfig
                                 table
                                 tableColumns
@@ -1199,7 +1211,7 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
                         then do
                           recreateTriggerIfNeeded
                             -<
-                              ( serverConfigCtx,
+                              ( dynamicConfig,
                                 table,
                                 tableColumns,
                                 triggerName,
@@ -1214,7 +1226,7 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
                           bindA
                             -<
                               createMissingSQLTriggers
-                                serverConfigCtx
+                                (_cdcSQLGenCtx dynamicConfig)
                                 sourceConfig
                                 table
                                 (tableColumns, _tciPrimaryKey tableInfo)
@@ -1234,7 +1246,7 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
           -- computation will not be done again.
           Inc.cache
             proc
-              ( serverConfigCtx,
+              ( dynamicConfig,
                 tableName,
                 tableColumns,
                 triggerName,
@@ -1248,7 +1260,7 @@ buildSchemaCacheRule logger env = proc (MetadataWithResourceVersion metadataNoDe
                 -< do
                   liftEitherM $
                     createTableEventTrigger @b
-                      serverConfigCtx
+                      (_cdcSQLGenCtx dynamicConfig)
                       sourceConfig
                       tableName
                       tableColumns

server/src-lib/Hasura/RQL/DDL/Schema/Cache/Common.hs

@@ -59,6 +59,7 @@ import Hasura.CustomReturnType.Types (CustomReturnTypeName)
 import Hasura.EncJSON
 import Hasura.Incremental qualified as Inc
 import Hasura.Prelude
+import Hasura.RQL.DDL.Schema.Cache.Config
 import Hasura.RQL.Types.Backend
 import Hasura.RQL.Types.Column
 import Hasura.RQL.Types.Common
@@ -79,7 +80,6 @@ import Hasura.SQL.AnyBackend
 import Hasura.SQL.Backend
 import Hasura.SQL.BackendMap (BackendMap)
 import Hasura.SQL.BackendMap qualified as BackendMap
-import Hasura.Server.Types
 import Hasura.Services
 import Hasura.Session
 import Network.HTTP.Client.Transformable qualified as HTTP
@@ -257,7 +257,8 @@ $(makeLenses ''BuildOutputs)
 data CacheBuildParams = CacheBuildParams
   { _cbpManager :: HTTP.Manager,
     _cbpPGSourceResolver :: SourceResolver ('Postgres 'Vanilla),
-    _cbpMSSQLSourceResolver :: SourceResolver 'MSSQL
+    _cbpMSSQLSourceResolver :: SourceResolver 'MSSQL,
+    _cbpStaticConfig :: CacheStaticConfig
   }
 
 -- | The monad in which @'RebuildableSchemaCache' is being run
@@ -273,6 +274,9 @@ newtype CacheBuild a = CacheBuild (ReaderT CacheBuildParams (ExceptT QErr IO) a)
       MonadBaseControl IO
     )
 
+instance HasCacheStaticConfig CacheBuild where
+  askCacheStaticConfig = asks _cbpStaticConfig
+
 instance ProvidesNetwork CacheBuild where
   askHTTPManager = asks _cbpManager
 
@@ -294,7 +298,8 @@ runCacheBuildM ::
   ( MonadIO m,
     MonadError QErr m,
     MonadResolveSource m,
-    ProvidesNetwork m
+    ProvidesNetwork m,
+    HasCacheStaticConfig m
   ) =>
   CacheBuild a ->
   m a
@@ -304,12 +309,13 @@ runCacheBuildM m = do
       <$> askHTTPManager
       <*> getPGSourceResolver
       <*> getMSSQLSourceResolver
+      <*> askCacheStaticConfig
   runCacheBuild params m
 
 data RebuildableSchemaCache = RebuildableSchemaCache
   { lastBuiltSchemaCache :: SchemaCache,
     _rscInvalidationMap :: InvalidationKeys,
-    _rscRebuild :: Inc.Rule (ReaderT BuildReason CacheBuild) (MetadataWithResourceVersion, ServerConfigCtx, InvalidationKeys, Maybe StoredIntrospection) SchemaCache
+    _rscRebuild :: Inc.Rule (ReaderT BuildReason CacheBuild) (MetadataWithResourceVersion, CacheDynamicConfig, InvalidationKeys, Maybe StoredIntrospection) SchemaCache
   }
 
 bindErrorA ::

server/src-lib/Hasura/RQL/DDL/Schema/Cache/Config.hs

@@ -0,0 +1,70 @@
+module Hasura.RQL.DDL.Schema.Cache.Config
+  ( -- * static config
+    CacheStaticConfig (..),
+    HasCacheStaticConfig (..),
+
+    -- * dynamic config
+    CacheDynamicConfig (..),
+  )
+where
+
+import Hasura.GraphQL.Schema.NamingCase (NamingCase)
+import Hasura.GraphQL.Schema.Options qualified as Options
+import Hasura.Prelude
+import Hasura.RQL.Types.Common (SQLGenCtx)
+import Hasura.RQL.Types.Metadata (MetadataDefaults)
+import Hasura.Server.Types
+
+--------------------------------------------------------------------------------
+-- static config
+
+-- | This type aggregates all of the "static" configuration of the cache build.
+--
+-- Static arguments are the ones that will not change during the execution of
+-- the engine. They are a subset of the environment of the engine (see 'AppEnv'
+-- and Note [Hasura Application State] for more information).
+--
+-- While 'AppEnv' has access to the union of *all* the static configuration of
+-- the engine, more specific parts of the code should avoid relying directly on
+-- it to avoid being tied to unrelated parts of the codebase. (See FIXME).
+data CacheStaticConfig = CacheStaticConfig
+  { _cscMaintenanceMode :: MaintenanceMode (),
+    _cscEventingMode :: EventingMode,
+    _cscReadOnlyMode :: ReadOnlyMode,
+    _cscCheckFeatureFlag :: CheckFeatureFlag
+  }
+
+class Monad m => HasCacheStaticConfig m where
+  askCacheStaticConfig :: m CacheStaticConfig
+
+instance HasCacheStaticConfig m => HasCacheStaticConfig (ReaderT r m) where
+  askCacheStaticConfig = lift askCacheStaticConfig
+
+instance HasCacheStaticConfig m => HasCacheStaticConfig (ExceptT e m) where
+  askCacheStaticConfig = lift askCacheStaticConfig
+
+instance HasCacheStaticConfig m => HasCacheStaticConfig (StateT s m) where
+  askCacheStaticConfig = lift askCacheStaticConfig
+
+--------------------------------------------------------------------------------
+-- dynamic config
+
+-- | This type aggregates all of the "dynamic" configuration of the cache build.
+--
+-- Dynamic arguments are the ones that might change during the execution of the
+-- engine. They are a subset of the 'AppContext' (see
+-- Note [Hasura Application State] for more information).
+--
+-- While 'AppContext' has access to the union of *all* the dynamic configuration
+-- of the engine, more specific parts of the code should avoid relying directly
+-- on it to avoid being tied to unrelated parts of the codebase. (See FIXME).
+data CacheDynamicConfig = CacheDynamicConfig
+  { _cdcFunctionPermsCtx :: Options.InferFunctionPermissions,
+    _cdcRemoteSchemaPermsCtx :: Options.RemoteSchemaPermissions,
+    _cdcSQLGenCtx :: SQLGenCtx,
+    _cdcExperimentalFeatures :: HashSet ExperimentalFeature,
+    _cdcDefaultNamingConvention :: NamingCase,
+    _cdcMetadataDefaults :: MetadataDefaults,
+    _cdcApolloFederationStatus :: ApolloFederationStatus
+  }
+  deriving (Eq)

server/src-lib/Hasura/RQL/DML/Delete.hs

@@ -29,7 +29,6 @@ import Hasura.RQL.Types.Common
 import Hasura.RQL.Types.Metadata
 import Hasura.RQL.Types.SchemaCache
 import Hasura.SQL.Backend
-import Hasura.Server.Types
 import Hasura.Session
 import Hasura.Tracing qualified as Tracing
 
@@ -109,17 +108,17 @@ runDelete ::
   ( QErrM m,
     UserInfoM m,
     CacheRM m,
-    HasServerConfigCtx m,
     MonadIO m,
     Tracing.MonadTrace m,
     MonadBaseControl IO m,
     MetadataM m
   ) =>
+  SQLGenCtx ->
   DeleteQuery ->
   m EncJSON
-runDelete q = do
+runDelete sqlGen q = do
   sourceConfig <- askSourceConfig @('Postgres 'Vanilla) (doSource q)
-  strfyNum <- stringifyNum . _sccSQLGenCtx <$> askServerConfigCtx
+  let strfyNum = stringifyNum sqlGen
   userInfo <- askUserInfo
   validateDeleteQ q
     >>= runTxWithCtx (_pscExecCtx sourceConfig) (Tx PG.ReadWrite Nothing) LegacyRQLQuery

server/src-lib/Hasura/RQL/DML/Insert.hs

@@ -29,7 +29,6 @@ import Hasura.RQL.Types.Metadata
 import Hasura.RQL.Types.SchemaCache
 import Hasura.RQL.Types.Table
 import Hasura.SQL.Backend
-import Hasura.Server.Types
 import Hasura.Session
 import Hasura.Tracing qualified as Tracing
 
@@ -243,19 +242,19 @@ runInsert ::
   ( QErrM m,
     UserInfoM m,
     CacheRM m,
-    HasServerConfigCtx m,
     MonadIO m,
     Tracing.MonadTrace m,
     MonadBaseControl IO m,
     MetadataM m
   ) =>
+  SQLGenCtx ->
   InsertQuery ->
   m EncJSON
-runInsert q = do
+runInsert sqlGen q = do
   sourceConfig <- askSourceConfig @('Postgres 'Vanilla) (iqSource q)
   userInfo <- askUserInfo
   res <- convInsQ q
-  strfyNum <- stringifyNum . _sccSQLGenCtx <$> askServerConfigCtx
+  let strfyNum = stringifyNum sqlGen
   runTxWithCtx (_pscExecCtx sourceConfig) (Tx PG.ReadWrite Nothing) LegacyRQLQuery $
     flip runReaderT emptyQueryTagsComment $
       execInsertQuery strfyNum Nothing userInfo res

server/src-lib/Hasura/RQL/DML/Internal.hs

@@ -55,7 +55,6 @@ import Hasura.RQL.Types.SchemaCache
 import Hasura.RQL.Types.Table
 import Hasura.SQL.Backend
 import Hasura.SQL.Types
-import Hasura.Server.Types
 import Hasura.Session
 
 newtype DMLP1T m a = DMLP1T {unDMLP1T :: StateT (DS.Seq PG.PrepArg) m a}
@@ -69,8 +68,7 @@ newtype DMLP1T m a = DMLP1T {unDMLP1T :: StateT (DS.Seq PG.PrepArg) m a}
       TableCoreInfoRM b,
       TableInfoRM b,
       CacheRM,
-      UserInfoM,
+      UserInfoM
-      HasServerConfigCtx
     )
 
 runDMLP1T :: DMLP1T m a -> m (a, DS.Seq PG.PrepArg)

server/src-lib/Hasura/RQL/DML/Select.hs

@@ -31,7 +31,6 @@ import Hasura.RQL.Types.Relationships.Local
 import Hasura.RQL.Types.SchemaCache
 import Hasura.RQL.Types.Table
 import Hasura.SQL.Backend
-import Hasura.Server.Types
 import Hasura.Session
 import Hasura.Tracing qualified as Tracing
 
@@ -174,9 +173,9 @@ convOrderByElem sessVarBldr (flds, spi) = \case
 convSelectQ ::
   ( UserInfoM m,
     QErrM m,
-    TableInfoRM ('Postgres 'Vanilla) m,
+    TableInfoRM ('Postgres 'Vanilla) m
-    HasServerConfigCtx m
   ) =>
+  SQLGenCtx ->
   TableName ('Postgres 'Vanilla) ->
   FieldInfoMap (FieldInfo ('Postgres 'Vanilla)) -> -- Table information of current table
   SelPermInfo ('Postgres 'Vanilla) -> -- Additional select permission info
@@ -184,7 +183,7 @@ convSelectQ ::
   SessionVariableBuilder m ->
   ValueParser ('Postgres 'Vanilla) m S.SQLExp ->
   m (AnnSimpleSelect ('Postgres 'Vanilla))
-convSelectQ table fieldInfoMap selPermInfo selQ sessVarBldr prepValBldr = do
+convSelectQ sqlGen table fieldInfoMap selPermInfo selQ sessVarBldr prepValBldr = do
   -- Convert where clause
   wClause <- forM (sqWhere selQ) $ \boolExp ->
     withPathK "where" $
@@ -200,6 +199,7 @@ convSelectQ table fieldInfoMap selPermInfo selQ sessVarBldr prepValBldr = do
       (ECRel relName mAlias relSelQ) -> do
         annRel <-
           convExtRel
+            sqlGen
             fieldInfoMap
             relName
             mAlias
@@ -230,8 +230,7 @@ convSelectQ table fieldInfoMap selPermInfo selQ sessVarBldr prepValBldr = do
   let tabFrom = FromTable table
       tabPerm = TablePerm resolvedSelFltr mPermLimit
       tabArgs = SelectArgs wClause annOrdByM mQueryLimit (fromIntegral <$> mQueryOffset) Nothing
-
+      strfyNum = stringifyNum sqlGen
-  strfyNum <- stringifyNum . _sccSQLGenCtx <$> askServerConfigCtx
   pure $ AnnSelectG annFlds tabFrom tabPerm tabArgs strfyNum Nothing
   where
     mQueryOffset = sqOffset selQ
@@ -254,9 +253,9 @@ convExtSimple fieldInfoMap selPermInfo pgCol = do
 convExtRel ::
   ( UserInfoM m,
     QErrM m,
-    TableInfoRM ('Postgres 'Vanilla) m,
+    TableInfoRM ('Postgres 'Vanilla) m
-    HasServerConfigCtx m
   ) =>
+  SQLGenCtx ->
   FieldInfoMap (FieldInfo ('Postgres 'Vanilla)) ->
   RelName ->
   Maybe RelName ->
@@ -264,14 +263,14 @@ convExtRel ::
   SessionVariableBuilder m ->
   ValueParser ('Postgres 'Vanilla) m S.SQLExp ->
   m (Either (ObjectRelationSelect ('Postgres 'Vanilla)) (ArraySelect ('Postgres 'Vanilla)))
-convExtRel fieldInfoMap relName mAlias selQ sessVarBldr prepValBldr = do
+convExtRel sqlGen fieldInfoMap relName mAlias selQ sessVarBldr prepValBldr = do
   -- Point to the name key
   relInfo <-
     withPathK "name" $
       askRelType fieldInfoMap relName pgWhenRelErr
   let (RelInfo _ relTy colMapping relTab _ _) = relInfo
   (relCIM, relSPI) <- fetchRelDet relName relTab
-  annSel <- convSelectQ relTab relCIM relSPI selQ sessVarBldr prepValBldr
+  annSel <- convSelectQ sqlGen relTab relCIM relSPI selQ sessVarBldr prepValBldr
   case relTy of
     ObjRel -> do
       when misused $ throw400 UnexpectedPayload objRelMisuseMsg
@@ -304,20 +303,20 @@ convExtRel fieldInfoMap relName mAlias selQ sessVarBldr prepValBldr = do
 convSelectQuery ::
   ( UserInfoM m,
     QErrM m,
-    TableInfoRM ('Postgres 'Vanilla) m,
+    TableInfoRM ('Postgres 'Vanilla) m
-    HasServerConfigCtx m
   ) =>
+  SQLGenCtx ->
   SessionVariableBuilder m ->
   ValueParser ('Postgres 'Vanilla) m S.SQLExp ->
   SelectQuery ->
   m (AnnSimpleSelect ('Postgres 'Vanilla))
-convSelectQuery sessVarBldr prepArgBuilder (DMLQuery _ qt selQ) = do
+convSelectQuery sqlGen sessVarBldr prepArgBuilder (DMLQuery _ qt selQ) = do
   tabInfo <- withPathK "table" $ askTableInfoSource qt
   selPermInfo <- askSelPermInfo tabInfo
   let fieldInfo = _tciFieldInfoMap $ _tiCoreInfo tabInfo
   extSelQ <- resolveStar fieldInfo selPermInfo selQ
   validateHeaders $ spiRequiredHeaders selPermInfo
-  convSelectQ qt fieldInfo selPermInfo extSelQ sessVarBldr prepArgBuilder
+  convSelectQ sqlGen qt fieldInfo selPermInfo extSelQ sessVarBldr prepArgBuilder
 
 selectP2 :: JsonAggSelect -> (AnnSimpleSelect ('Postgres 'Vanilla), DS.Seq PG.PrepArg) -> PG.TxE QErr EncJSON
 selectP2 jsonAggSelect (sel, p) =
@@ -330,15 +329,16 @@ selectP2 jsonAggSelect (sel, p) =
           mkSQLSelect jsonAggSelect sel
 
 phaseOne ::
-  (QErrM m, UserInfoM m, CacheRM m, HasServerConfigCtx m) =>
+  (QErrM m, UserInfoM m, CacheRM m) =>
+  SQLGenCtx ->
   SelectQuery ->
   m (AnnSimpleSelect ('Postgres 'Vanilla), DS.Seq PG.PrepArg)
-phaseOne query = do
+phaseOne sqlGen query = do
   let sourceName = getSourceDMLQuery query
   tableCache :: TableCache ('Postgres 'Vanilla) <- fold <$> askTableCache sourceName
   flip runTableCacheRT tableCache $
     runDMLP1T $
-      convSelectQuery sessVarFromCurrentSetting (valueParserWithCollectableType binRHSBuilder) query
+      convSelectQuery sqlGen sessVarFromCurrentSetting (valueParserWithCollectableType binRHSBuilder) query
 
 phaseTwo :: (MonadTx m) => (AnnSimpleSelect ('Postgres 'Vanilla), DS.Seq PG.PrepArg) -> m EncJSON
 phaseTwo =
@@ -348,14 +348,14 @@ runSelect ::
   ( QErrM m,
     UserInfoM m,
     CacheRM m,
-    HasServerConfigCtx m,
     MonadIO m,
     MonadBaseControl IO m,
     Tracing.MonadTrace m,
     MetadataM m
   ) =>
+  SQLGenCtx ->
   SelectQuery ->
   m EncJSON
-runSelect q = do
+runSelect sqlGen q = do
   sourceConfig <- askSourceConfig @('Postgres 'Vanilla) (getSourceDMLQuery q)
-  phaseOne q >>= runTxWithCtx (_pscExecCtx sourceConfig) (Tx PG.ReadOnly Nothing) LegacyRQLQuery . phaseTwo
+  phaseOne sqlGen q >>= runTxWithCtx (_pscExecCtx sourceConfig) (Tx PG.ReadOnly Nothing) LegacyRQLQuery . phaseTwo

server/src-lib/Hasura/RQL/DML/Update.hs

@@ -34,7 +34,6 @@ import Hasura.RQL.Types.SchemaCache
 import Hasura.RQL.Types.Table
 import Hasura.SQL.Backend
 import Hasura.SQL.Types
-import Hasura.Server.Types
 import Hasura.Session
 import Hasura.Tracing qualified as Tracing
 
@@ -224,18 +223,18 @@ runUpdate ::
   ( QErrM m,
     UserInfoM m,
     CacheRM m,
-    HasServerConfigCtx m,
     MonadBaseControl IO m,
     MonadIO m,
     Tracing.MonadTrace m,
     MetadataM m
   ) =>
+  SQLGenCtx ->
   UpdateQuery ->
   m EncJSON
-runUpdate q = do
+runUpdate sqlGen q = do
   sourceConfig <- askSourceConfig @('Postgres 'Vanilla) (uqSource q)
   userInfo <- askUserInfo
-  strfyNum <- stringifyNum . _sccSQLGenCtx <$> askServerConfigCtx
+  let strfyNum = stringifyNum sqlGen
   validateUpdateQuery q
     >>= runTxWithCtx (_pscExecCtx sourceConfig) (Tx PG.ReadWrite Nothing) LegacyRQLQuery
       . flip runReaderT emptyQueryTagsComment

server/src-lib/Hasura/RQL/Types/Eventing/Backend.hs

@@ -19,7 +19,7 @@ import Hasura.RQL.Types.Eventing
 import Hasura.RQL.Types.Source
 import Hasura.RQL.Types.Table (PrimaryKey)
 import Hasura.SQL.Backend
-import Hasura.Server.Types (MaintenanceMode, ServerConfigCtx)
+import Hasura.Server.Types (MaintenanceMode)
 import Hasura.Session (UserInfo)
 import Hasura.Tracing qualified as Tracing
 
@@ -188,7 +188,7 @@ class Backend b => BackendEventTrigger (b :: BackendType) where
   --   exist then it will create it.
   createMissingSQLTriggers ::
     (MonadIO m, MonadError QErr m, MonadBaseControl IO m, Backend b) =>
-    ServerConfigCtx ->
+    SQLGenCtx ->
     SourceConfig b ->
     TableName b ->
     ([ColumnInfo b], Maybe (PrimaryKey b (ColumnInfo b))) ->
@@ -199,7 +199,7 @@ class Backend b => BackendEventTrigger (b :: BackendType) where
 
   createTableEventTrigger ::
     (MonadBaseControl IO m, MonadIO m, MonadError QErr m) =>
-    ServerConfigCtx ->
+    SQLGenCtx ->
     SourceConfig b ->
     TableName b ->
     [ColumnInfo b] ->

server/src-lib/Hasura/RQL/Types/SchemaCache.hs

@@ -161,7 +161,6 @@ import Hasura.SQL.Backend
 import Hasura.SQL.BackendMap (BackendMap)
 import Hasura.SQL.BackendMap qualified as BackendMap
 import Hasura.SQL.Tag (HasTag (backendTag), reify)
-import Hasura.Server.Types
 import Hasura.Session
 import Hasura.Tracing (TraceT)
 import Language.GraphQL.Draft.Syntax qualified as G
@@ -651,7 +650,7 @@ instance (TableInfoRM b m) => TableInfoRM b (TraceT m) where
 
 newtype TableCacheRT b m a = TableCacheRT {runTableCacheRT :: TableCache b -> m a}
   deriving
-    (Functor, Applicative, Monad, MonadIO, MonadError e, MonadState s, MonadWriter w, Postgres.MonadTx, UserInfoM, HasServerConfigCtx)
+    (Functor, Applicative, Monad, MonadIO, MonadError e, MonadState s, MonadWriter w, Postgres.MonadTx, UserInfoM)
     via (ReaderT (TableCache b) m)
   deriving (MonadTrans) via (ReaderT (TableCache b))
 

server/src-lib/Hasura/RQL/Types/SchemaCache/Build.hs

@@ -59,7 +59,7 @@ import Hasura.RQL.Types.Metadata.Object
 import Hasura.RQL.Types.QueryCollection
 import Hasura.RQL.Types.SchemaCache
 import Hasura.RemoteSchema.Metadata (RemoteSchemaName)
-import Hasura.Server.Types
+import Hasura.Server.Init.FeatureFlag (HasFeatureFlagChecker)
 import Hasura.Services.Network
 import Hasura.Session
 import Hasura.Tracing (TraceT)
@@ -239,7 +239,8 @@ newtype MetadataT m a = MetadataT {unMetadataT :: StateT Metadata m a}
       Tracing.MonadTrace,
       MonadBase b,
       MonadBaseControl b,
-      ProvidesNetwork
+      ProvidesNetwork,
+      HasFeatureFlagChecker
     )
   deriving anyclass (MonadQueryTags)
 
@@ -250,9 +251,6 @@ instance (Monad m) => MetadataM (MetadataT m) where
 instance (UserInfoM m) => UserInfoM (MetadataT m) where
   askUserInfo = lift askUserInfo
 
-instance HasServerConfigCtx m => HasServerConfigCtx (MetadataT m) where
-  askServerConfigCtx = lift askServerConfigCtx
-
 -- | @runMetadataT@ puts a stateful metadata in scope. @MetadataDefaults@ is
 -- provided so that it can be considered from the --metadataDefaults arguments.
 runMetadataT :: Metadata -> MetadataDefaults -> MetadataT m a -> m (a, Metadata)

server/src-lib/Hasura/RemoteSchema/MetadataAPI/Permission.hs

@@ -23,7 +23,6 @@ import Hasura.RQL.Types.SchemaCache
 import Hasura.RQL.Types.SchemaCache.Build
 import Hasura.RemoteSchema.Metadata
 import Hasura.RemoteSchema.SchemaCache.Permission
-import Hasura.Server.Types
 import Hasura.Session
 
 data AddRemoteSchemaPermission = AddRemoteSchemaPermission
@@ -51,14 +50,13 @@ $(J.deriveJSON hasuraJSON ''DropRemoteSchemaPermissions)
 runAddRemoteSchemaPermissions ::
   ( QErrM m,
     CacheRWM m,
-    HasServerConfigCtx m,
     MetadataM m
   ) =>
+  Options.RemoteSchemaPermissions ->
   AddRemoteSchemaPermission ->
   m EncJSON
-runAddRemoteSchemaPermissions q = do
+runAddRemoteSchemaPermissions remoteSchemaPermsCtx q = do
   metadata <- getMetadata
-  remoteSchemaPermsCtx <- _sccRemoteSchemaPermsCtx <$> askServerConfigCtx
   unless (remoteSchemaPermsCtx == Options.EnableRemoteSchemaPermissions) $ do
     throw400 ConstraintViolation $
       "remote schema permissions can only be added when "

server/src-lib/Hasura/Server/API/Metadata.hs

@@ -23,6 +23,7 @@ import Hasura.Base.Error
 import Hasura.CustomReturnType.API qualified as CustomReturnType
 import Hasura.EncJSON
 import Hasura.Function.API qualified as Functions
+import Hasura.GraphQL.Schema.Options qualified as Options
 import Hasura.Logging qualified as L
 import Hasura.LogicalModel.API qualified as LogicalModels
 import Hasura.Metadata.Class
@@ -50,6 +51,7 @@ import Hasura.RQL.DDL.Relationship.Suggest
 import Hasura.RQL.DDL.RemoteRelationship
 import Hasura.RQL.DDL.ScheduledTrigger
 import Hasura.RQL.DDL.Schema
+import Hasura.RQL.DDL.Schema.Cache.Config
 import Hasura.RQL.DDL.Schema.Source
 import Hasura.RQL.DDL.SourceKinds
 import Hasura.RQL.DDL.Webhook.Transform.Validation
@@ -79,6 +81,7 @@ import Hasura.SQL.AnyBackend
 import Hasura.SQL.Backend
 import Hasura.Server.API.Backend
 import Hasura.Server.API.Instances ()
+import Hasura.Server.Init.FeatureFlag (HasFeatureFlagChecker)
 import Hasura.Server.Logging (SchemaSyncLog (..), SchemaSyncThreadType (TTMetadataApi))
 import Hasura.Server.Types
 import Hasura.Server.Utils (APIVersion (..))
@@ -388,6 +391,8 @@ runMetadataQuery ::
     MonadError QErr m,
     MonadBaseControl IO m,
     HasAppEnv m,
+    HasCacheStaticConfig m,
+    HasFeatureFlagChecker m,
     Tracing.MonadTrace m,
     MonadMetadataStorage m,
     MonadResolveSource m,
@@ -401,7 +406,7 @@ runMetadataQuery ::
   RQLMetadata ->
   m (EncJSON, RebuildableSchemaCache)
 runMetadataQuery appContext schemaCache RQLMetadata {..} = do
-  appEnv@AppEnv {..} <- askAppEnv
+  AppEnv {..} <- askAppEnv
   let logger = _lsLogger appEnvLoggers
   MetadataWithResourceVersion metadata currentResourceVersion <- Tracing.newSpan "fetchMetadata" $ liftEitherM fetchMetadata
   let exportsMetadata = \case
@@ -427,13 +432,18 @@ runMetadataQuery appContext schemaCache RQLMetadata {..} = do
         if (exportsMetadata _rqlMetadata || queryModifiesMetadata _rqlMetadata)
           then emptyMetadataDefaults
           else acMetadataDefaults appContext
-      serverConfigCtx = buildServerConfigCtx appEnv appContext
+      dynamicConfig = buildCacheDynamicConfig appContext
   ((r, modMetadata), modSchemaCache, cacheInvalidations) <-
-    runMetadataQueryM (acEnvironment appContext) currentResourceVersion _rqlMetadata
+    runMetadataQueryM
+      (acEnvironment appContext)
+      appEnvCheckFeatureFlag
+      (acRemoteSchemaPermsCtx appContext)
+      currentResourceVersion
+      _rqlMetadata
       -- TODO: remove this straight runReaderT that provides no actual new info
       & flip runReaderT logger
       & runMetadataT metadata metadataDefaults
-      & runCacheRWT serverConfigCtx schemaCache
+      & runCacheRWT dynamicConfig schemaCache
   -- set modified metadata in storage
   if queryModifiesMetadata _rqlMetadata
     then case (appEnvEnableMaintenanceMode, appEnvEnableReadOnlyMode) of
@@ -464,7 +474,7 @@ runMetadataQuery appContext schemaCache RQLMetadata {..} = do
         (_, modSchemaCache', _) <-
           Tracing.newSpan "setMetadataResourceVersionInSchemaCache" $
             setMetadataResourceVersionInSchemaCache newResourceVersion
-              & runCacheRWT serverConfigCtx modSchemaCache
+              & runCacheRWT dynamicConfig modSchemaCache
 
         pure (r, modSchemaCache')
       (MaintenanceModeEnabled (), ReadOnlyModeDisabled) ->
@@ -607,25 +617,27 @@ runMetadataQueryM ::
     UserInfoM m,
     MetadataM m,
     MonadMetadataStorage m,
-    HasServerConfigCtx m,
     MonadReader r m,
     Has (L.Logger L.Hasura) r,
     MonadError QErr m,
     MonadEventLogCleanup m,
     ProvidesHasuraServices m,
-    MonadGetApiTimeLimit m
+    MonadGetApiTimeLimit m,
+    HasFeatureFlagChecker m
   ) =>
   Env.Environment ->
+  CheckFeatureFlag ->
+  Options.RemoteSchemaPermissions ->
   MetadataResourceVersion ->
   RQLMetadataRequest ->
   m EncJSON
-runMetadataQueryM env currentResourceVersion =
+runMetadataQueryM env checkFeatureFlag remoteSchemaPerms currentResourceVersion =
   withPathK "args" . \case
     -- NOTE: This is a good place to install tracing, since it's involved in
     -- the recursive case via "bulk":
     RMV1 q ->
       Tracing.newSpan ("v1 " <> T.pack (constrName q)) $
-        runMetadataQueryV1M env currentResourceVersion q
+        runMetadataQueryV1M env checkFeatureFlag remoteSchemaPerms currentResourceVersion q
     RMV2 q ->
       Tracing.newSpan ("v2 " <> T.pack (constrName q)) $
         runMetadataQueryV2M currentResourceVersion q
@@ -639,19 +651,21 @@ runMetadataQueryV1M ::
     UserInfoM m,
     MetadataM m,
     MonadMetadataStorage m,
-    HasServerConfigCtx m,
     MonadReader r m,
     Has (L.Logger L.Hasura) r,
     MonadError QErr m,
     MonadEventLogCleanup m,
     ProvidesHasuraServices m,
-    MonadGetApiTimeLimit m
+    MonadGetApiTimeLimit m,
+    HasFeatureFlagChecker m
   ) =>
   Env.Environment ->
+  CheckFeatureFlag ->
+  Options.RemoteSchemaPermissions ->
   MetadataResourceVersion ->
   RQLMetadataV1 ->
   m EncJSON
-runMetadataQueryV1M env currentResourceVersion = \case
+runMetadataQueryV1M env checkFeatureFlag remoteSchemaPerms currentResourceVersion = \case
   RMAddSource q -> dispatchMetadata (runAddSource env) q
   RMDropSource q -> runDropSource q
   RMRenameSource q -> runRenameSource q
@@ -718,7 +732,7 @@ runMetadataQueryV1M env currentResourceVersion = \case
   RMRemoveRemoteSchema q -> runRemoveRemoteSchema q
   RMReloadRemoteSchema q -> runReloadRemoteSchema q
   RMIntrospectRemoteSchema q -> runIntrospectRemoteSchema q
-  RMAddRemoteSchemaPermissions q -> runAddRemoteSchemaPermissions q
+  RMAddRemoteSchemaPermissions q -> runAddRemoteSchemaPermissions remoteSchemaPerms q
   RMDropRemoteSchemaPermissions q -> runDropRemoteSchemaPermissions q
   RMCreateRemoteSchemaRemoteRelationship q -> runCreateRemoteSchemaRemoteRelationship q
   RMUpdateRemoteSchemaRemoteRelationship q -> runUpdateRemoteSchemaRemoteRelationship q
@@ -790,8 +804,8 @@ runMetadataQueryV1M env currentResourceVersion = \case
   RMSetQueryTagsConfig q -> runSetQueryTagsConfig q
   RMSetOpenTelemetryConfig q -> runSetOpenTelemetryConfig q
   RMSetOpenTelemetryStatus q -> runSetOpenTelemetryStatus q
-  RMGetFeatureFlag q -> runGetFeatureFlag q
+  RMGetFeatureFlag q -> runGetFeatureFlag checkFeatureFlag q
-  RMBulk q -> encJFromList <$> indexedMapM (runMetadataQueryM env currentResourceVersion) q
+  RMBulk q -> encJFromList <$> indexedMapM (runMetadataQueryM env checkFeatureFlag remoteSchemaPerms currentResourceVersion) q
   where
     dispatch ::
       (forall b. Backend b => i b -> a) ->

server/src-lib/Hasura/Server/API/Query.hs

@@ -38,6 +38,7 @@ import Hasura.RQL.DDL.Relationship.Rename
 import Hasura.RQL.DDL.RemoteRelationship
 import Hasura.RQL.DDL.ScheduledTrigger
 import Hasura.RQL.DDL.Schema
+import Hasura.RQL.DDL.Schema.Cache.Config
 import Hasura.RQL.DML.Count
 import Hasura.RQL.DML.Delete
 import Hasura.RQL.DML.Insert
@@ -180,6 +181,7 @@ runQuery ::
   ( MonadIO m,
     MonadError QErr m,
     HasAppEnv m,
+    HasCacheStaticConfig m,
     Tracing.MonadTrace m,
     MonadBaseControl IO m,
     MonadMetadataStorage m,
@@ -195,7 +197,7 @@ runQuery ::
   RQLQuery ->
   m (EncJSON, RebuildableSchemaCache)
 runQuery appContext sc query = do
-  appEnv@AppEnv {..} <- askAppEnv
+  AppEnv {..} <- askAppEnv
   let logger = _lsLogger appEnvLoggers
   when ((appEnvEnableReadOnlyMode == ReadOnlyModeEnabled) && queryModifiesUserDB query) $
     throw400 NotSupported "Cannot run write queries when read-only mode is enabled"
@@ -207,15 +209,15 @@ runQuery appContext sc query = do
         if (exportsMetadata query)
           then emptyMetadataDefaults
           else acMetadataDefaults appContext
-      serverConfigCtx = buildServerConfigCtx appEnv appContext
+      dynamicConfig = buildCacheDynamicConfig appContext
 
   MetadataWithResourceVersion metadata currentResourceVersion <- liftEitherM fetchMetadata
   ((result, updatedMetadata), updatedCache, invalidations) <-
-    runQueryM (acEnvironment appContext) query
+    runQueryM (acEnvironment appContext) (acSQLGenCtx appContext) query
       -- TODO: remove this straight runReaderT that provides no actual new info
       & flip runReaderT logger
       & runMetadataT metadata metadataDefaults
-      & runCacheRWT serverConfigCtx sc
+      & runCacheRWT dynamicConfig sc
   when (queryModifiesSchemaCache query) $ do
     case appEnvEnableMaintenanceMode of
       MaintenanceModeDisabled -> do
@@ -391,7 +393,6 @@ runQueryM ::
     UserInfoM m,
     MonadBaseControl IO m,
     MonadIO m,
-    HasServerConfigCtx m,
     Tracing.MonadTrace m,
     MetadataM m,
     MonadMetadataStorage m,
@@ -404,9 +405,10 @@ runQueryM ::
     MonadGetApiTimeLimit m
   ) =>
   Env.Environment ->
+  SQLGenCtx ->
   RQLQuery ->
   m EncJSON
-runQueryM env rq = withPathK "args" $ case rq of
+runQueryM env sqlGen rq = withPathK "args" $ case rq of
   RQV1 q -> runQueryV1M q
   RQV2 q -> runQueryV2M q
   where
@@ -436,10 +438,10 @@ runQueryM env rq = withPathK "args" $ case rq of
       RQSetPermissionComment q -> runSetPermComment q
       RQGetInconsistentMetadata q -> runGetInconsistentMetadata q
       RQDropInconsistentMetadata q -> runDropInconsistentMetadata q
-      RQInsert q -> runInsert q
+      RQInsert q -> runInsert sqlGen q
-      RQSelect q -> runSelect q
+      RQSelect q -> runSelect sqlGen q
-      RQUpdate q -> runUpdate q
+      RQUpdate q -> runUpdate sqlGen q
-      RQDelete q -> runDelete q
+      RQDelete q -> runDelete sqlGen q
       RQCount q -> runCount q
       RQAddRemoteSchema q -> runAddRemoteSchema env q
       RQUpdateRemoteSchema q -> runUpdateRemoteSchema env q
@@ -475,9 +477,9 @@ runQueryM env rq = withPathK "args" $ case rq of
       RQCreateRestEndpoint q -> runCreateEndpoint q
       RQDropRestEndpoint q -> runDropEndpoint q
       RQDumpInternalState q -> runDumpInternalState q
-      RQRunSql q -> runRunSQL @'Vanilla q
+      RQRunSql q -> runRunSQL @'Vanilla sqlGen q
       RQSetCustomTypes q -> runSetCustomTypes q
-      RQBulk qs -> encJFromList <$> indexedMapM (runQueryM env) qs
+      RQBulk qs -> encJFromList <$> indexedMapM (runQueryM env sqlGen) qs
 
     runQueryV2M = \case
       RQV2TrackTable q -> runTrackTableV2Q q

server/src-lib/Hasura/Server/API/V2Query.hs

@@ -13,7 +13,6 @@ import Control.Lens (preview, _Right)
 import Control.Monad.Trans.Control (MonadBaseControl)
 import Data.Aeson
 import Data.Aeson.Types (Parser)
-import Data.Environment qualified as Env
 import Data.Text qualified as T
 import GHC.Generics.Extended (constrName)
 import Hasura.App.State
@@ -29,6 +28,7 @@ import Hasura.Metadata.Class
 import Hasura.Prelude
 import Hasura.QueryTags
 import Hasura.RQL.DDL.Schema
+import Hasura.RQL.DDL.Schema.Cache.Config
 import Hasura.RQL.DML.Count
 import Hasura.RQL.DML.Delete
 import Hasura.RQL.DML.Insert
@@ -41,6 +41,7 @@ import Hasura.RQL.DML.Types
     UpdateQuery,
   )
 import Hasura.RQL.DML.Update
+import Hasura.RQL.Types.Common
 import Hasura.RQL.Types.Metadata
 import Hasura.RQL.Types.SchemaCache (MetadataWithResourceVersion (MetadataWithResourceVersion))
 import Hasura.RQL.Types.SchemaCache.Build
@@ -107,6 +108,7 @@ runQuery ::
     MonadBaseControl IO m,
     MonadError QErr m,
     HasAppEnv m,
+    HasCacheStaticConfig m,
     Tracing.MonadTrace m,
     MonadMetadataStorage m,
     MonadResolveSource m,
@@ -119,17 +121,17 @@ runQuery ::
   RQLQuery ->
   m (EncJSON, RebuildableSchemaCache)
 runQuery appContext schemaCache rqlQuery = do
-  appEnv@AppEnv {..} <- askAppEnv
+  AppEnv {..} <- askAppEnv
   when ((appEnvEnableReadOnlyMode == ReadOnlyModeEnabled) && queryModifiesUserDB rqlQuery) $
     throw400 NotSupported "Cannot run write queries when read-only mode is enabled"
 
-  let serverConfigCtx = buildServerConfigCtx appEnv appContext
+  let dynamicConfig = buildCacheDynamicConfig appContext
   MetadataWithResourceVersion metadata currentResourceVersion <- Tracing.newSpan "fetchMetadata" $ liftEitherM fetchMetadata
   ((result, updatedMetadata), updatedCache, invalidations) <-
-    runQueryM (acEnvironment appContext) rqlQuery
+    runQueryM (acSQLGenCtx appContext) rqlQuery
       -- We can use defaults here unconditionally, since there is no MD export function in V2Query
       & runMetadataT metadata (acMetadataDefaults appContext)
-      & runCacheRWT serverConfigCtx schemaCache
+      & runCacheRWT dynamicConfig schemaCache
   when (queryModifiesSchema rqlQuery) $ do
     case appEnvEnableMaintenanceMode of
       MaintenanceModeDisabled -> do
@@ -170,33 +172,32 @@ runQueryM ::
     MonadBaseControl IO m,
     UserInfoM m,
     CacheRWM m,
-    HasServerConfigCtx m,
     Tracing.MonadTrace m,
     MetadataM m,
     MonadQueryTags m
   ) =>
-  Env.Environment ->
+  SQLGenCtx ->
   RQLQuery ->
   m EncJSON
-runQueryM env rq = Tracing.newSpan (T.pack $ constrName rq) $ case rq of
+runQueryM sqlGen rq = Tracing.newSpan (T.pack $ constrName rq) $ case rq of
-  RQInsert q -> runInsert q
+  RQInsert q -> runInsert sqlGen q
-  RQSelect q -> runSelect q
+  RQSelect q -> runSelect sqlGen q
-  RQUpdate q -> runUpdate q
+  RQUpdate q -> runUpdate sqlGen q
-  RQDelete q -> runDelete q
+  RQDelete q -> runDelete sqlGen q
   RQCount q -> runCount q
-  RQRunSql q -> Postgres.runRunSQL @'Vanilla q
+  RQRunSql q -> Postgres.runRunSQL @'Vanilla sqlGen q
   RQMssqlRunSql q -> MSSQL.runSQL q
   RQMysqlRunSql q -> MySQL.runSQL q
-  RQCitusRunSql q -> Postgres.runRunSQL @'Citus q
+  RQCitusRunSql q -> Postgres.runRunSQL @'Citus sqlGen q
-  RQCockroachRunSql q -> Postgres.runRunSQL @'Cockroach q
+  RQCockroachRunSql q -> Postgres.runRunSQL @'Cockroach sqlGen q
   RQBigqueryRunSql q -> BigQuery.runSQL q
   RQDataConnectorRunSql t q -> DataConnector.runSQL t q
   RQBigqueryDatabaseInspection q -> BigQuery.runDatabaseInspection q
-  RQBulk l -> encJFromList <$> indexedMapM (runQueryM env) l
+  RQBulk l -> encJFromList <$> indexedMapM (runQueryM sqlGen) l
   RQConcurrentBulk l -> do
     when (queryModifiesSchema rq) $
       throw500 "Only read-only queries are allowed in a concurrent_bulk"
-    encJFromList <$> mapConcurrently (runQueryM env) l
+    encJFromList <$> mapConcurrently (runQueryM sqlGen) l
 
 queryModifiesUserDB :: RQLQuery -> Bool
 queryModifiesUserDB = \case

server/src-lib/Hasura/Server/App.hs

@@ -68,6 +68,7 @@ import Hasura.QueryTags
 import Hasura.RQL.DDL.ApiLimit (MonadGetApiTimeLimit)
 import Hasura.RQL.DDL.EventTrigger (MonadEventLogCleanup)
 import Hasura.RQL.DDL.Schema
+import Hasura.RQL.DDL.Schema.Cache.Config
 import Hasura.RQL.Types.Endpoint as EP
 import Hasura.RQL.Types.SchemaCache
 import Hasura.RQL.Types.Source
@@ -134,6 +135,8 @@ newtype Handler m a = Handler (ReaderT HandlerCtx (ExceptT QErr m) a)
       MonadError QErr,
       MonadTrace,
       HasAppEnv,
+      HasCacheStaticConfig,
+      HasFeatureFlagChecker,
       HasResourceLimits,
       MonadResolveSource,
       E.MonadGQLExecutionCheck,
@@ -423,6 +426,7 @@ v1QueryHandler ::
     MonadMetadataStorage m,
     MonadResolveSource m,
     HasAppEnv m,
+    HasCacheStaticConfig m,
     MonadQueryTags m,
     MonadEventLogCleanup m,
     ProvidesNetwork m,
@@ -457,6 +461,8 @@ v1MetadataHandler ::
     MonadMetadataApiAuthorization m,
     MonadEventLogCleanup m,
     HasAppEnv m,
+    HasCacheStaticConfig m,
+    HasFeatureFlagChecker m,
     ProvidesNetwork m,
     MonadGetApiTimeLimit m,
     UserInfoM m
@@ -486,6 +492,7 @@ v2QueryHandler ::
     MonadMetadataStorage m,
     MonadResolveSource m,
     HasAppEnv m,
+    HasCacheStaticConfig m,
     MonadQueryTags m,
     ProvidesNetwork m,
     UserInfoM m
@@ -713,6 +720,8 @@ mkWaiApp ::
     MonadVersionAPIWithExtraData m,
     HttpLog m,
     HasAppEnv m,
+    HasCacheStaticConfig m,
+    HasFeatureFlagChecker m,
     UserAuthentication m,
     MonadMetadataApiAuthorization m,
     E.MonadGQLExecutionCheck m,
@@ -759,6 +768,8 @@ httpApp ::
     MonadVersionAPIWithExtraData m,
     HttpLog m,
     HasAppEnv m,
+    HasCacheStaticConfig m,
+    HasFeatureFlagChecker m,
     UserAuthentication m,
     MonadMetadataApiAuthorization m,
     E.MonadGQLExecutionCheck m,

server/src-lib/Hasura/Server/Init/FeatureFlag.hs

@@ -7,6 +7,7 @@ module Hasura.Server.Init.FeatureFlag
     checkFeatureFlag,
     Identifier (..),
     FeatureFlags (..),
+    HasFeatureFlagChecker (..),
     featureFlags,
     logicalModelInterface,
   )
@@ -59,6 +60,20 @@ featureFlags =
 
 --------------------------------------------------------------------------------
 
+class Monad m => HasFeatureFlagChecker m where
+  checkFlag :: FeatureFlag -> m Bool
+
+instance HasFeatureFlagChecker m => HasFeatureFlagChecker (ReaderT r m) where
+  checkFlag = lift . checkFlag
+
+instance HasFeatureFlagChecker m => HasFeatureFlagChecker (ExceptT e m) where
+  checkFlag = lift . checkFlag
+
+instance HasFeatureFlagChecker m => HasFeatureFlagChecker (StateT s m) where
+  checkFlag = lift . checkFlag
+
+--------------------------------------------------------------------------------
+
 testFlag :: FeatureFlag
 testFlag =
   FeatureFlag

server/src-lib/Hasura/Server/SchemaUpdate.hs

@@ -27,6 +27,7 @@ import Hasura.Logging
 import Hasura.Metadata.Class
 import Hasura.Prelude
 import Hasura.RQL.DDL.Schema (runCacheRWT)
+import Hasura.RQL.DDL.Schema.Cache.Config
 import Hasura.RQL.DDL.Schema.Catalog
 import Hasura.RQL.Types.SchemaCache
 import Hasura.RQL.Types.SchemaCache.Build
@@ -139,6 +140,7 @@ startSchemaSyncListenerThread logger pool instanceId interval metaVersionRef = d
 startSchemaSyncProcessorThread ::
   ( C.ForkableMonadIO m,
     HasAppEnv m,
+    HasCacheStaticConfig m,
     MonadMetadataStorage m,
     MonadResolveSource m,
     ProvidesNetwork m
@@ -244,6 +246,7 @@ processor ::
   forall m void impl.
   ( C.ForkableMonadIO m,
     HasAppEnv m,
+    HasCacheStaticConfig m,
     MonadMetadataStorage m,
     MonadResolveSource m,
     ProvidesNetwork m
@@ -263,6 +266,7 @@ refreshSchemaCache ::
   ( MonadIO m,
     MonadBaseControl IO m,
     HasAppEnv m,
+    HasCacheStaticConfig m,
     MonadMetadataStorage m,
     MonadResolveSource m,
     ProvidesNetwork m
@@ -277,15 +281,15 @@ refreshSchemaCache
   appStateRef
   threadType
   logTVar = do
-    appEnv@AppEnv {..} <- askAppEnv
+    AppEnv {..} <- askAppEnv
     let logger = _lsLogger appEnvLoggers
     respErr <- runExceptT $
       withSchemaCacheUpdate appStateRef logger (Just logTVar) $ do
         rebuildableCache <- liftIO $ fst <$> getRebuildableSchemaCacheWithVersion appStateRef
         appContext <- liftIO $ getAppContext appStateRef
-        let serverConfigCtx = buildServerConfigCtx appEnv appContext
+        let dynamicConfig = buildCacheDynamicConfig appContext
         (msg, cache, _) <-
-          runCacheRWT serverConfigCtx rebuildableCache $ do
+          runCacheRWT dynamicConfig rebuildableCache $ do
             schemaCache <- askSchemaCache
             let engineResourceVersion = scMetadataResourceVersion schemaCache
             unless (engineResourceVersion == resourceVersion) $ do

server/src-lib/Hasura/Server/Types.hs

@@ -13,10 +13,7 @@ module Hasura.Server.Types
     PGVersion (PGVersion),
     pgToDbVersion,
     RequestId (..),
-    ServerConfigCtx (..),
-    HasServerConfigCtx (..),
     CheckFeatureFlag (..),
-    askMetadataDefaults,
     getRequestId,
     ApolloFederationStatus (..),
     isApolloFederationEnabled,
@@ -24,14 +21,9 @@ module Hasura.Server.Types
 where
 
 import Data.Aeson
-import Data.HashSet qualified as Set
 import Data.Text (intercalate, unpack)
 import Database.PG.Query qualified as PG
-import Hasura.GraphQL.Schema.NamingCase
-import Hasura.GraphQL.Schema.Options qualified as Options
 import Hasura.Prelude hiding (intercalate)
-import Hasura.RQL.Types.Common
-import Hasura.RQL.Types.Metadata (MetadataDefaults)
 import Hasura.Server.Init.FeatureFlag (CheckFeatureFlag (..))
 import Hasura.Server.Utils
 import Network.HTTP.Types qualified as HTTP
@@ -141,69 +133,6 @@ data ReadOnlyMode = ReadOnlyModeEnabled | ReadOnlyModeDisabled
 data EventingMode = EventingEnabled | EventingDisabled
   deriving (Show, Eq)
 
--- | This type represents an aggregate of different configuration options used
--- throughout the engine. The fields are the union of a subset of 'AppEnv' and a
--- subset of 'AppContext'.
---
--- This type should be considered as deprecated: avoid using it directly when
--- you can use 'AppEnv' or 'AppContext', and avoid using the entirety of it when
--- you only need a subset of the fields. Also avoid adding new fields if
--- possible, but if you do so, make sure to adjust the @Eq@ instance
--- accordingly.
-data ServerConfigCtx = ServerConfigCtx
-  { _sccFunctionPermsCtx :: Options.InferFunctionPermissions,
-    _sccRemoteSchemaPermsCtx :: Options.RemoteSchemaPermissions,
-    _sccSQLGenCtx :: SQLGenCtx,
-    _sccMaintenanceMode :: MaintenanceMode (),
-    _sccExperimentalFeatures :: Set.HashSet ExperimentalFeature,
-    _sccEventingMode :: EventingMode,
-    _sccReadOnlyMode :: ReadOnlyMode,
-    -- | stores global default naming convention
-    _sccDefaultNamingConvention :: NamingCase,
-    _sccMetadataDefaults :: MetadataDefaults,
-    _sccCheckFeatureFlag :: CheckFeatureFlag,
-    _sccApolloFederationStatus :: ApolloFederationStatus
-  }
-
--- We are currently using the entire 'ServerConfigCtx' as an input to the schema
--- cache build, and it therefore requires an 'Eq' instance. However, only a few
--- fields will change over time: those coming from the 'AppContext', and not
--- those coming from the 'AppEnv'. Consequently, this instance only checks the
--- relevant fields.
---
--- The way to fix this will be to use a smaller type as the input to the schema
--- build, such as 'AppContext' (or, rather, a relevant subset), on which a
--- "correct" @Eq@ instance can be defined.
-instance Eq ServerConfigCtx where
-  (==) = (==) `on` extractDynamicFields
-    where
-      extractDynamicFields ServerConfigCtx {..} =
-        ( _sccFunctionPermsCtx,
-          _sccRemoteSchemaPermsCtx,
-          _sccSQLGenCtx,
-          _sccExperimentalFeatures,
-          _sccDefaultNamingConvention,
-          _sccMetadataDefaults,
-          _sccApolloFederationStatus
-        )
-
-askMetadataDefaults :: HasServerConfigCtx m => m MetadataDefaults
-askMetadataDefaults = do
-  ServerConfigCtx {_sccMetadataDefaults} <- askServerConfigCtx
-  pure _sccMetadataDefaults
-
-class (Monad m) => HasServerConfigCtx m where
-  askServerConfigCtx :: m ServerConfigCtx
-
-instance HasServerConfigCtx m => HasServerConfigCtx (ReaderT r m) where
-  askServerConfigCtx = lift askServerConfigCtx
-
-instance HasServerConfigCtx m => HasServerConfigCtx (ExceptT e m) where
-  askServerConfigCtx = lift askServerConfigCtx
-
-instance HasServerConfigCtx m => HasServerConfigCtx (StateT s m) where
-  askServerConfigCtx = lift askServerConfigCtx
-
 -- | Whether or not to enable apollo federation fields.
 data ApolloFederationStatus = ApolloFederationEnabled | ApolloFederationDisabled
   deriving stock (Show, Eq, Ord, Generic)

server/test-postgres/Main.hs

@@ -31,13 +31,13 @@ import Hasura.Logging
 import Hasura.Prelude
 import Hasura.RQL.DDL.Schema.Cache
 import Hasura.RQL.DDL.Schema.Cache.Common
+import Hasura.RQL.DDL.Schema.Cache.Config
 import Hasura.RQL.Types.Common
 import Hasura.RQL.Types.Metadata (emptyMetadataDefaults)
 import Hasura.RQL.Types.ResizePool
 import Hasura.RQL.Types.SchemaCache
 import Hasura.RQL.Types.SchemaCache.Build
 import Hasura.Server.Init
-import Hasura.Server.Init.FeatureFlag as FF
 import Hasura.Server.Metrics (ServerMetricsSpec, createServerMetrics)
 import Hasura.Server.Migrate
 import Hasura.Server.Prometheus (makeDummyPrometheusMetrics)
@@ -107,20 +107,22 @@ main = do
                 Options.EnableBigQueryStringNumericInput
             maintenanceMode = MaintenanceModeDisabled
             readOnlyMode = ReadOnlyModeDisabled
-            serverConfigCtx =
+            staticConfig =
-              ServerConfigCtx
+              CacheStaticConfig
+                maintenanceMode
+                EventingEnabled
+                readOnlyMode
+                (CheckFeatureFlag $ checkFeatureFlag mempty)
+            dynamicConfig =
+              CacheDynamicConfig
                 Options.InferFunctionPermissions
                 Options.DisableRemoteSchemaPermissions
                 sqlGenCtx
-                maintenanceMode
                 mempty
-                EventingEnabled
-                readOnlyMode
                 (_default defaultNamingConventionOption)
                 emptyMetadataDefaults
-                (CheckFeatureFlag $ FF.checkFeatureFlag mempty)
                 ApolloFederationDisabled
-            cacheBuildParams = CacheBuildParams httpManager (mkPgSourceResolver print) mkMSSQLSourceResolver
+            cacheBuildParams = CacheBuildParams httpManager (mkPgSourceResolver print) mkMSSQLSourceResolver staticConfig
 
         (_appInit, appEnv) <-
           lowerManagedT $
@@ -145,11 +147,11 @@ main = do
             snd
               <$> (liftEitherM . runExceptT . _pecRunTx pgContext (PGExecCtxInfo (Tx PG.ReadWrite Nothing) InternalRawQuery))
                 (migrateCatalog (Just sourceConfig) defaultPostgresExtensionsSchema maintenanceMode =<< liftIO getCurrentTime)
-          schemaCache <- runCacheBuild cacheBuildParams $ buildRebuildableSchemaCache logger envMap metadataWithVersion serverConfigCtx
+          schemaCache <- runCacheBuild cacheBuildParams $ buildRebuildableSchemaCache logger envMap metadataWithVersion dynamicConfig
           pure (_mwrvMetadata metadataWithVersion, schemaCache)
 
         cacheRef <- newMVar schemaCache
-        pure $ NT (run . flip MigrateSuite.runCacheRefT (serverConfigCtx, cacheRef) . fmap fst . runMetadataT metadata emptyMetadataDefaults)
+        pure $ NT (run . flip MigrateSuite.runCacheRefT (dynamicConfig, cacheRef) . fmap fst . runMetadataT metadata emptyMetadataDefaults)
 
   streamingSubscriptionSuite <- StreamingSubscriptionSuite.buildStreamingSubscriptionSuite
   eventTriggerLogCleanupSuite <- EventTriggerCleanupSuite.buildEventTriggerCleanupSuite

server/test-postgres/Test/Hasura/Server/MigrateSuite.hs

@@ -22,6 +22,7 @@ import Hasura.RQL.DDL.EventTrigger (MonadEventLogCleanup (..))
 import Hasura.RQL.DDL.Metadata (ClearMetadata (..), runClearMetadata)
 import Hasura.RQL.DDL.Schema
 import Hasura.RQL.DDL.Schema.Cache.Common
+import Hasura.RQL.DDL.Schema.Cache.Config
 import Hasura.RQL.DDL.Schema.LegacyCatalog (recreateSystemMetadata)
 import Hasura.RQL.Types.Common
 import Hasura.RQL.Types.SchemaCache
@@ -38,7 +39,7 @@ import Test.Hspec.Expectations.Lifted
 
 -- -- NOTE: downgrade test disabled for now (see #5273)
 
-newtype CacheRefT m a = CacheRefT {runCacheRefT :: (ServerConfigCtx, MVar RebuildableSchemaCache) -> m a}
+newtype CacheRefT m a = CacheRefT {runCacheRefT :: (CacheDynamicConfig, MVar RebuildableSchemaCache) -> m a}
   deriving
     ( Functor,
       Applicative,
@@ -47,18 +48,16 @@ newtype CacheRefT m a = CacheRefT {runCacheRefT :: (ServerConfigCtx, MVar Rebuil
       MonadError e,
       MonadBase b,
       MonadBaseControl b,
-      MonadReader (ServerConfigCtx, MVar RebuildableSchemaCache),
+      MonadReader (CacheDynamicConfig, MVar RebuildableSchemaCache),
       MonadTx,
+      HasCacheStaticConfig,
       UserInfoM,
       MonadMetadataStorage,
       MonadResolveSource,
       ProvidesNetwork,
       MonadGetApiTimeLimit
     )
-    via (ReaderT (ServerConfigCtx, MVar RebuildableSchemaCache) m)
+    via (ReaderT (CacheDynamicConfig, MVar RebuildableSchemaCache) m)
-
-instance Monad m => HasServerConfigCtx (CacheRefT m) where
-  askServerConfigCtx = asks fst
 
 instance MonadTrans CacheRefT where
   lift = CacheRefT . const
@@ -80,20 +79,21 @@ instance
     MonadBaseControl IO m,
     MonadError QErr m,
     MonadResolveSource m,
-    ProvidesNetwork m
+    ProvidesNetwork m,
+    HasCacheStaticConfig m
   ) =>
   CacheRWM (CacheRefT m)
   where
   buildSchemaCacheWithOptions reason invalidations metadata = do
-    (serverConfigCtx, scVar) <- ask
+    (dynamicConfig, scVar) <- ask
     modifyMVar scVar \schemaCache -> do
-      ((), cache, _) <- runCacheRWT serverConfigCtx schemaCache (buildSchemaCacheWithOptions reason invalidations metadata)
+      ((), cache, _) <- runCacheRWT dynamicConfig schemaCache (buildSchemaCacheWithOptions reason invalidations metadata)
       pure (cache, ())
 
   setMetadataResourceVersionInSchemaCache resourceVersion = do
-    (serverConfigCtx, scVar) <- ask
+    (dynamicConfig, scVar) <- ask
     modifyMVar scVar \schemaCache -> do
-      ((), cache, _) <- runCacheRWT serverConfigCtx schemaCache (setMetadataResourceVersionInSchemaCache resourceVersion)
+      ((), cache, _) <- runCacheRWT dynamicConfig schemaCache (setMetadataResourceVersionInSchemaCache resourceVersion)
       pure (cache, ())
 
 instance Example (MetadataT (CacheRefT m) ()) where
@@ -114,7 +114,8 @@ suite ::
     MonadMetadataStorage m,
     MonadEventLogCleanup m,
     ProvidesNetwork m,
-    MonadGetApiTimeLimit m
+    MonadGetApiTimeLimit m,
+    HasCacheStaticConfig m
   ) =>
   PostgresConnConfiguration ->
   PGExecCtx ->
@@ -127,9 +128,9 @@ suite srcConfig pgExecCtx pgConnInfo = do
         liftIO $ putStrLn $ LBS.toString $ encode $ EngineLog t logLevel logType logDetail
 
       migrateCatalogAndBuildCache env time = do
-        serverConfigCtx <- askServerConfigCtx
+        dynamicConfig <- asks fst
         (migrationResult, metadataWithVersion) <- runTx' pgExecCtx $ migrateCatalog (Just srcConfig) (ExtensionsSchema "public") MaintenanceModeDisabled time
-        (,migrationResult) <$> runCacheBuildM (buildRebuildableSchemaCache logger env metadataWithVersion serverConfigCtx)
+        (,migrationResult) <$> runCacheBuildM (buildRebuildableSchemaCache logger env metadataWithVersion dynamicConfig)
 
       dropAndInit env time = lift do
         scVar <- asks snd