2022-04-14 05:06:07 +03:00
{- # LANGUAGE TemplateHaskell # -}
2023-05-19 07:47:12 +03:00
{- # LANGUAGE ViewPatterns # -}
2022-02-25 19:08:18 +03:00
{- # OPTIONS_GHC - fno - warn - orphans # -}
2022-05-02 08:03:12 +03:00
module Hasura.Backends.DataConnector.Adapter.Schema ( ) where
2022-02-25 19:08:18 +03:00
--------------------------------------------------------------------------------
2022-09-06 07:24:46 +03:00
import Control.Lens ( ( ^. ) )
import Data.Aeson qualified as J
2022-04-28 04:51:58 +03:00
import Data.Has
2023-04-26 18:42:13 +03:00
import Data.HashMap.Strict.Extended qualified as HashMap
2022-04-14 05:06:07 +03:00
import Data.List.NonEmpty qualified as NE
2022-12-01 03:07:16 +03:00
import Data.Scientific ( fromFloatDigits )
2023-05-19 07:47:12 +03:00
import Data.Sequence qualified as Seq
2023-01-19 07:21:11 +03:00
import Data.Text.Casing ( GQLNameIdentifier , fromAutogeneratedName , fromCustomName )
2023-05-19 07:47:12 +03:00
import Data.Text.Extended ( toTxt , ( <<> ) , ( <>> ) )
import Data.Traversable ( mapAccumL )
2022-10-28 04:12:54 +03:00
import Hasura.Backends.DataConnector.API qualified as API
2022-10-20 06:23:37 +03:00
import Hasura.Backends.DataConnector.Adapter.Backend ( CustomBooleanOperator ( .. ) , columnTypeToScalarType )
2022-09-20 09:18:46 +03:00
import Hasura.Backends.DataConnector.Adapter.Types qualified as DC
2023-01-10 04:54:40 +03:00
import Hasura.Backends.DataConnector.Adapter.Types.Mutations qualified as DC
2022-04-14 05:06:07 +03:00
import Hasura.Base.Error
2023-05-19 07:47:12 +03:00
import Hasura.Function.Cache qualified as RQL
2022-04-14 05:06:07 +03:00
import Hasura.GraphQL.Parser.Class
2023-01-10 04:54:40 +03:00
import Hasura.GraphQL.Schema.Backend ( BackendSchema ( .. ) , BackendTableSelectSchema ( .. ) , BackendUpdateOperatorsSchema ( .. ) , ComparisonExp , MonadBuildSchema )
2022-04-28 04:51:58 +03:00
import Hasura.GraphQL.Schema.BoolExp qualified as GS . BE
import Hasura.GraphQL.Schema.Build qualified as GS . B
import Hasura.GraphQL.Schema.Common qualified as GS . C
server: Metadata origin for definitions (type parameter version v2)
The code that builds the GraphQL schema, and `buildGQLContext` in particular, is partial: not every value of `(ServerConfigCtx, GraphQLQueryType, SourceCache, HashMap RemoteSchemaName (RemoteSchemaCtx, MetadataObject), ActionCache, AnnotatedCustomTypes)` results in a valid GraphQL schema. When it fails, we want to be able to return better error messages than we currently do.
The key thing that is missing is a way to trace back GraphQL type information to their origin from the Hasura metadata. Currently, we have a number of correctness checks of our GraphQL schema. But these correctness checks only have access to pure GraphQL type information, and hence can only report errors in terms of that. Possibly the worst is the "conflicting definitions" error, which, in practice, can only be debugged by Hasura engineers. This is terrible DX for customers.
This PR allows us to print better error messages, by adding a field to the `Definition` type that traces the GraphQL type to its origin in the metadata. So the idea is simple: just add `MetadataObjId`, or `Maybe` that, or some other sum type of that, to `Definition`.
However, we want to avoid having to import a `Hasura.RQL` module from `Hasura.GraphQL.Parser`. So we instead define this additional field of `Definition` through a new type parameter, which is threaded through in `Hasura.GraphQL.Parser`. We then define type synonyms in `Hasura.GraphQL.Schema.Parser` that fill in this type parameter, so that it is not visible for the majority of the codebase.
The idea of associating metadata information to `Definition`s really comes to fruition when combined with hasura/graphql-engine-mono#4517. Their combination would allow us to use the API of fatal errors (just like the current `MonadError QErr`) to report _inconsistencies_ in the metadata. Such inconsistencies are then _automatically_ ignored. So no ad-hoc decisions need to be made on how to cut out inconsistent metadata from the GraphQL schema. This will allow us to report much better errors, as well as improve the likelihood of a successful HGE startup.
PR-URL: https://github.com/hasura/graphql-engine-mono/pull/4770
Co-authored-by: Samir Talwar <47582+SamirTalwar@users.noreply.github.com>
GitOrigin-RevId: 728402b0cae83ae8e83463a826ceeb609001acae
2022-06-28 18:52:26 +03:00
import Hasura.GraphQL.Schema.Parser qualified as P
2022-04-28 04:51:58 +03:00
import Hasura.GraphQL.Schema.Select qualified as GS . S
2023-05-19 07:47:12 +03:00
import Hasura.GraphQL.Schema.Table qualified as GS . T
import Hasura.GraphQL.Schema.Typename qualified as GS . N
2022-12-12 07:41:36 +03:00
import Hasura.GraphQL.Schema.Update qualified as GS . U
2023-01-10 04:54:40 +03:00
import Hasura.GraphQL.Schema.Update.Batch qualified as GS . U . B
2022-06-23 12:14:24 +03:00
import Hasura.Name qualified as Name
2022-02-25 19:08:18 +03:00
import Hasura.Prelude
2022-09-06 07:24:46 +03:00
import Hasura.RQL.IR.BoolExp qualified as IR
2022-12-12 07:41:36 +03:00
import Hasura.RQL.IR.Delete qualified as IR
import Hasura.RQL.IR.Insert qualified as IR
import Hasura.RQL.IR.Root qualified as IR
2022-07-20 08:20:49 +03:00
import Hasura.RQL.IR.Select qualified as IR
2022-12-12 07:41:36 +03:00
import Hasura.RQL.IR.Update qualified as IR
2022-05-31 01:07:02 +03:00
import Hasura.RQL.IR.Value qualified as IR
2022-04-28 04:51:58 +03:00
import Hasura.RQL.Types.Backend qualified as RQL
2023-04-24 21:35:48 +03:00
import Hasura.RQL.Types.BackendType ( BackendType ( .. ) )
2022-04-28 04:51:58 +03:00
import Hasura.RQL.Types.Column qualified as RQL
2023-05-19 07:47:12 +03:00
import Hasura.RQL.Types.Common qualified as RQL
import Hasura.RQL.Types.ComputedField as RQL
2023-05-17 17:02:09 +03:00
import Hasura.RQL.Types.NamingCase
2023-04-24 18:17:15 +03:00
import Hasura.RQL.Types.Schema.Options qualified as Options
Remove circular dependency in schema building code
### Description
The main goal of this PR is, as stated, to remove the circular dependency in the schema building code. This cycle arises from the existence of remote relationships: when we build the schema for a source A, a remote relationship might force us to jump to the schema of a source B, or some remote schema. As a result, we end up having to do a dispatch from a "leaf" of the schema, similar to the one done at the root. In turn, this forces us to carry along in the schema a lot of information required for that dispatch, AND it forces us to import the instances in scope, creating an import loop.
As discussed in #4489, this PR implements the "dependency injection" solution: we pass to the schema a function to call to do the dispatch, and to get a generated field for a remote relationship. That way, this function can be chosen at the root level, and the leaves need not be aware of the overall context.
This PR grew a bit bigger than that, however; in an attempt to try and remove the `SourceCache` from the schema altogether, it changed a lot of functions across the schema building code, to thread along the `SourceInfo b` of the source being built. This avoids having to do cache lookups within a given source. A few cases remain, such as relay, that we might try to tackle in a subsequent PR.
PR-URL: https://github.com/hasura/graphql-engine-mono/pull/4557
GitOrigin-RevId: 9388e48372877520a72a9fd1677005df9f7b2d72
2022-05-27 20:21:22 +03:00
import Hasura.RQL.Types.Source qualified as RQL
2022-08-03 22:08:34 +03:00
import Hasura.RQL.Types.SourceCustomization qualified as RQL
2023-05-17 11:53:31 +03:00
import Hasura.Table.Cache qualified as RQL
2022-04-28 04:51:58 +03:00
import Language.GraphQL.Draft.Syntax qualified as GQL
2022-02-25 19:08:18 +03:00
--------------------------------------------------------------------------------
2022-05-02 08:03:12 +03:00
instance BackendSchema 'DataConnector where
2022-02-25 19:08:18 +03:00
-- top level parsers
2022-06-07 08:32:08 +03:00
buildTableQueryAndSubscriptionFields = GS . B . buildTableQueryAndSubscriptionFields
2022-02-25 19:08:18 +03:00
buildTableRelayQueryFields = experimentalBuildTableRelayQueryFields
2023-05-19 07:47:12 +03:00
buildFunctionQueryFields = buildFunctionQueryFields'
server: reduce schema contexts to the bare minimum
### Description
This monster of a PR took way too long. As the title suggests, it reduces the schema context carried in the readers to the very strict minimum. In practice, that means that to build a source, we only require:
- the global `SchemaContext`
- the global `SchemaOptions` (soon to be renamed `SchemaSourceOptions`)
- that source's `SourceInfo`
Furthermore, _we no longer carry "default" customization options throughout the schema_. All customization information is extracted from the `SourceInfo`, when required. This prevents an entire category of bugs we had previously encountered, such as parts of the code using uninitialized / unupdated customization info.
In turn, this meant that we could remove the explicit threading of the `SourceInfo` throughout the schema, since it is now always available through the reader context.
Finally, this meant making a few adjustments to relay and actions as well, such as the introduction of a new separate "context" for actions, and a change to how we create some of the action-specific postgres scalar parsers.
I'll highlight with review comments the areas of interest.
PR-URL: https://github.com/hasura/graphql-engine-mono/pull/6709
GitOrigin-RevId: ea80fddcb24e2513779dd04b0b700a55f0028dd1
2022-11-17 13:34:05 +03:00
buildFunctionRelayQueryFields _ _ _ _ _ = pure []
buildFunctionMutationFields _ _ _ _ = pure []
2022-12-12 07:41:36 +03:00
buildTableInsertMutationFields = buildTableInsertMutationFields'
buildTableUpdateMutationFields = buildTableUpdateMutationFields'
buildTableDeleteMutationFields = buildTableDeleteMutationFields'
server: reduce schema contexts to the bare minimum
### Description
This monster of a PR took way too long. As the title suggests, it reduces the schema context carried in the readers to the very strict minimum. In practice, that means that to build a source, we only require:
- the global `SchemaContext`
- the global `SchemaOptions` (soon to be renamed `SchemaSourceOptions`)
- that source's `SourceInfo`
Furthermore, _we no longer carry "default" customization options throughout the schema_. All customization information is extracted from the `SourceInfo`, when required. This prevents an entire category of bugs we had previously encountered, such as parts of the code using uninitialized / unupdated customization info.
In turn, this meant that we could remove the explicit threading of the `SourceInfo` throughout the schema, since it is now always available through the reader context.
Finally, this meant making a few adjustments to relay and actions as well, such as the introduction of a new separate "context" for actions, and a change to how we create some of the action-specific postgres scalar parsers.
I'll highlight with review comments the areas of interest.
PR-URL: https://github.com/hasura/graphql-engine-mono/pull/6709
GitOrigin-RevId: ea80fddcb24e2513779dd04b0b700a55f0028dd1
2022-11-17 13:34:05 +03:00
buildTableStreamingSubscriptionFields _ _ _ _ = pure []
2022-02-25 19:08:18 +03:00
-- backend extensions
relayExtension = Nothing
2022-07-20 08:20:49 +03:00
nodesAggExtension = Just ()
2022-04-22 22:53:12 +03:00
streamSubscriptionExtension = Nothing
2022-02-25 19:08:18 +03:00
2022-04-14 05:06:07 +03:00
-- individual components
columnParser = columnParser'
2022-09-14 00:21:07 +03:00
enumParser = enumParser'
possiblyNullable = possiblyNullable'
2022-05-03 11:58:56 +03:00
scalarSelectionArgumentsParser _ = pure Nothing
2022-04-14 05:06:07 +03:00
orderByOperators = orderByOperators'
comparisonExps = comparisonExps'
2022-02-25 19:08:18 +03:00
2022-07-20 08:20:49 +03:00
countTypeInput = countTypeInput'
2023-01-11 05:36:03 +03:00
-- aggregateOrderByCountType is only used when generating Relay schemas, and Data Connector backends do not yet support Relay
-- If/when we want to support this we would need to add something to Capabilities to tell HGE what (integer-like) scalar
-- type should be used to represent the result of a count aggregate in relay order-by queries.
aggregateOrderByCountType =
error " aggregateOrderByCountType: not implemented for Data Connector backend "
2022-02-25 19:08:18 +03:00
computedField =
2022-05-02 08:03:12 +03:00
error " computedField: not implemented for the Data Connector backend. "
2022-02-25 19:08:18 +03:00
2022-06-30 18:22:19 +03:00
instance BackendTableSelectSchema 'DataConnector where
tableArguments = tableArgs'
selectTable = GS . S . defaultSelectTable
selectTableAggregate = GS . S . defaultSelectTableAggregate
tableSelectionSet = GS . S . defaultTableSelectionSet
2023-01-10 04:54:40 +03:00
instance BackendUpdateOperatorsSchema 'DataConnector where
type UpdateOperators 'DataConnector = DC . UpdateOperator
parseUpdateOperators = parseUpdateOperators'
2022-02-25 19:08:18 +03:00
--------------------------------------------------------------------------------
2023-05-19 07:47:12 +03:00
buildFunctionQueryFields' ::
forall r m n .
( MonadError QErr m ,
P . MonadMemoize m ,
MonadParse n ,
Has ( RQL . SourceInfo 'DataConnector ) r ,
Has GS . C . SchemaContext r ,
Has Options . SchemaOptions r
) =>
RQL . MkRootFieldName ->
DC . FunctionName ->
RQL . FunctionInfo 'DataConnector ->
DC . TableName ->
GS . C . SchemaT
r
m
[ P . FieldParser
n
( IR . QueryDB
'DataConnector
( IR . RemoteRelationshipField IR . UnpreparedValue )
( IR . UnpreparedValue 'DataConnector )
)
]
buildFunctionQueryFields' mkRootFieldName functionName functionInfo tableName = do
let -- Implementation modified from buildFunctionQueryFieldsPG
funcDesc =
Just . GQL . Description $
flip fromMaybe ( RQL . _fiComment functionInfo <|> RQL . _fiDescription functionInfo ) $
" execute function " <> functionName <<> " which returns " <>> tableName
queryResultType =
case RQL . _fiJsonAggSelect functionInfo of
RQL . JASMultipleRows -> IR . QDBMultipleRows
RQL . JASSingleObject -> IR . QDBSingleRow
catMaybes
<$> sequenceA
[ GS . C . optionalFieldParser queryResultType $ selectFunction mkRootFieldName functionInfo funcDesc
-- TODO: Aggregations are not currently supported.
-- See: GS.C.optionalFieldParser (QDBAggregation) $ selectFunctionAggregate mkRootFieldName functionInfo funcAggDesc
]
-- | User-defined function (AKA custom function) -- Modified from PG variant.
selectFunction ::
forall r m n .
( MonadBuildSchema 'DataConnector r m n
) =>
RQL . MkRootFieldName ->
-- | SQL function info
RQL . FunctionInfo 'DataConnector -> -- TODO: The function return type should have already been resolved by this point - Into TableName
-- | field description, if any
Maybe GQL . Description ->
GS . C . SchemaT r m ( Maybe ( P . FieldParser n ( GS . C . SelectExp 'DataConnector ) ) )
selectFunction mkRootFieldName fi @ RQL . FunctionInfo { .. } description = runMaybeT do
sourceInfo :: RQL . SourceInfo 'DataConnector <- asks getter
roleName <- GS . C . retrieve GS . C . scRole
let customization = RQL . _siCustomization sourceInfo
tCase = RQL . _rscNamingConvention customization
tableInfo <- lift $ GS . C . askTableInfo _fiReturnType
selectPermissions <- hoistMaybe $ GS . T . tableSelectPermissions roleName tableInfo
selectionSetParser <- MaybeT $ returnFunctionParser tableInfo
lift do
stringifyNumbers <- GS . C . retrieve Options . soStringifyNumbers
tableArgsParser <- tableArguments tableInfo
functionArgsParser <- customFunctionArgs fi _fiGQLName _fiGQLArgsName
let argsParser = liftA2 ( , ) functionArgsParser tableArgsParser
functionFieldName = RQL . runMkRootFieldName mkRootFieldName _fiGQLName
pure $
P . subselection functionFieldName description argsParser selectionSetParser
<&> \ ( ( funcArgs , tableArgs'' ) , fields ) ->
IR . AnnSelectG
{ IR . _asnFields = fields ,
IR . _asnFrom = IR . FromFunction _fiSQLName funcArgs Nothing ,
IR . _asnPerm = GS . S . tablePermissionsInfo selectPermissions ,
IR . _asnArgs = tableArgs'' ,
IR . _asnStrfyNum = stringifyNumbers ,
IR . _asnNamingConvention = Just tCase
}
where
returnFunctionParser =
case _fiJsonAggSelect of
RQL . JASSingleObject -> tableSelectionSet
RQL . JASMultipleRows -> GS . S . tableSelectionList
-- Modified version of the PG Reference: customSQLFunctionArgs.
-- | The custom SQL functions' input "args" field parser
-- > function_name(args: function_args)
customFunctionArgs ::
MonadBuildSchema 'DataConnector r m n =>
RQL . FunctionInfo 'DataConnector ->
GQL . Name ->
GQL . Name ->
GS . C . SchemaT r m ( P . InputFieldsParser n ( RQL . FunctionArgsExp 'DataConnector ( IR . UnpreparedValue 'DataConnector ) ) )
customFunctionArgs RQL . FunctionInfo { .. } functionName functionArgsName =
functionArgs'
( FTACustomFunction $
RQL . CustomFunctionNames
{ cfnFunctionName = functionName ,
cfnArgsName = functionArgsName
}
)
_fiInputArgs
-- NOTE: Modified version of server/src-lib/Hasura/Backends/Postgres/Schema/Select.hs ~ functionArgs
functionArgs' ::
forall r m n .
MonadBuildSchema 'DataConnector r m n =>
FunctionTrackedAs 'DataConnector ->
Seq . Seq ( RQL . FunctionInputArgument 'DataConnector ) ->
GS . C . SchemaT r m ( P . InputFieldsParser n ( RQL . FunctionArgsExp 'DataConnector ( IR . UnpreparedValue 'DataConnector ) ) )
functionArgs' functionTrackedAs ( toList -> inputArgs ) = do
sourceInfo :: RQL . SourceInfo 'DataConnector <- asks getter
let customization = RQL . _siCustomization sourceInfo
tCase = RQL . _rscNamingConvention customization
mkTypename = GS . N . runMkTypename $ RQL . _rscTypeNames customization
( names , session , optional , mandatory ) = mconcat $ snd $ mapAccumL splitArguments 1 inputArgs
defaultArguments = RQL . FunctionArgsExp ( snd <$> session ) HashMap . empty
if
| length session > 1 ->
throw500 " there shouldn't be more than one session argument "
| null optional && null mandatory ->
pure $ pure defaultArguments
| otherwise -> do
argumentParsers <- sequenceA $ optional <> mandatory
objectName <-
mkTypename . RQL . applyTypeNameCaseIdentifier tCase
<$> case functionTrackedAs of
FTAComputedField computedFieldName _sourceName tableName -> do
tableInfo <- GS . C . askTableInfo tableName
computedFieldGQLName <- GS . C . textToName $ computedFieldNameToText computedFieldName
tableGQLName <- GS . T . getTableIdentifierName @ 'DataConnector tableInfo
pure $ RQL . mkFunctionArgsTypeName computedFieldGQLName tableGQLName
FTACustomFunction ( CustomFunctionNames { cfnArgsName } ) ->
pure $ fromCustomName cfnArgsName
let fieldName = Name . _args
fieldDesc =
case functionTrackedAs of
FTAComputedField computedFieldName _sourceName tableName ->
GQL . Description $
" input parameters for computed field "
<> computedFieldName <<> " defined on table " <>> tableName
FTACustomFunction ( CustomFunctionNames { cfnFunctionName } ) ->
GQL . Description $ " input parameters for function " <>> cfnFunctionName
objectParser =
P . object objectName Nothing ( sequenceA argumentParsers ) ` P . bind ` \ arguments -> do
let foundArguments = HashMap . fromList $ catMaybes arguments <> session
argsWithNames = zip names inputArgs
-- All args have names in DC for now
named <- HashMap . fromList . catMaybes <$> traverse ( namedArgument foundArguments ) argsWithNames
pure $ RQL . FunctionArgsExp [] named
pure $ P . field fieldName ( Just fieldDesc ) objectParser
where
sessionPlaceholder :: DC . ArgumentExp ( IR . UnpreparedValue b )
sessionPlaceholder = DC . AEInput IR . UVSession
splitArguments ::
Int ->
RQL . FunctionInputArgument 'DataConnector ->
( Int ,
( [ Text ] , -- graphql names, in order
[ ( Text , DC . ArgumentExp ( IR . UnpreparedValue 'DataConnector ) ) ] , -- session argument
[ GS . C . SchemaT r m ( P . InputFieldsParser n ( Maybe ( Text , DC . ArgumentExp ( IR . UnpreparedValue 'DataConnector ) ) ) ) ] , -- optional argument
[ GS . C . SchemaT r m ( P . InputFieldsParser n ( Maybe ( Text , DC . ArgumentExp ( IR . UnpreparedValue 'DataConnector ) ) ) ) ] -- mandatory argument
)
)
splitArguments positionalIndex ( RQL . IASessionVariables name ) =
let argName = RQL . getFuncArgNameTxt name
in ( positionalIndex , ( [ argName ] , [ ( argName , sessionPlaceholder ) ] , [] , [] ) )
splitArguments positionalIndex ( RQL . IAUserProvided arg @ ( API . FunctionArg faName _faType _faOptional ) ) =
let ( argName , newIndex ) = ( faName , positionalIndex ) -- Names are currently always present
in -- NOTE: Positional defaults are not implemented here, but named arguments should support this.
-- See: `if Postgres.unHasDefault $ Postgres.faHasDefault arg`
( newIndex , ( [ argName ] , [] , [] , [ parseArgument arg argName ] ) )
parseArgument :: RQL . FunctionArgument 'DataConnector -> Text -> GS . C . SchemaT r m ( P . InputFieldsParser n ( Maybe ( Text , DC . ArgumentExp ( IR . UnpreparedValue 'DataConnector ) ) ) )
parseArgument ( API . FunctionArg faName faType _faOptional ) name = do
typedParser <- columnParser ( RQL . ColumnScalar $ convertScalarType faType ) ( GQL . Nullability True )
fieldName <- GS . C . textToName name
let argParser = P . fieldOptional fieldName Nothing typedParser
pure $ argParser ` GS . C . mapField ` ( ( faName , ) . DC . AEInput . IR . mkParameter )
namedArgument ::
HashMap Text ( DC . ArgumentExp ( IR . UnpreparedValue 'DataConnector ) ) ->
( Text , RQL . FunctionInputArgument 'DataConnector ) ->
n ( Maybe ( Text , DC . ArgumentExp ( IR . UnpreparedValue 'DataConnector ) ) )
namedArgument dictionary ( name , inputArgument ) = case inputArgument of
RQL . IASessionVariables _ -> pure $ Just ( name , sessionPlaceholder )
RQL . IAUserProvided ( API . FunctionArg _faName _faType faOptional ) -> case HashMap . lookup name dictionary of
Just parsedValue -> pure $ Just ( name , parsedValue ) -- Names are currently always present
Nothing ->
if faOptional
then pure Nothing
else P . parseErrorWith P . NotSupported " Non default arguments cannot be omitted "
convertScalarType :: API . ScalarType -> RQL . ScalarType 'DataConnector
convertScalarType t = DC . ScalarType ( API . getScalarType t ) Nothing -- TODO: GQL Type Name
2022-12-12 07:41:36 +03:00
buildTableInsertMutationFields' ::
2023-05-17 11:53:31 +03:00
( MonadBuildSchema 'DataConnector r m n ) =>
2022-12-12 07:41:36 +03:00
RQL . MkRootFieldName ->
GS . C . Scenario ->
RQL . TableName 'DataConnector ->
RQL . TableInfo 'DataConnector ->
GQLNameIdentifier ->
GS . C . SchemaT r m [ P . FieldParser n ( IR . AnnotatedInsert 'DataConnector ( IR . RemoteRelationshipField IR . UnpreparedValue ) ( IR . UnpreparedValue 'DataConnector ) ) ]
buildTableInsertMutationFields' mkRootFieldName scenario tableName tableInfo gqlName = do
API . Capabilities { .. } <- DC . _scCapabilities . RQL . _siConfiguration @ ( 'DataConnector ) <$> asks getter
case _cMutations >>= API . _mcInsertCapabilities of
Just _insertCapabilities -> GS . B . buildTableInsertMutationFields mkBackendInsertParser mkRootFieldName scenario tableName tableInfo gqlName
Nothing -> pure []
mkBackendInsertParser ::
2023-05-17 11:53:31 +03:00
( MonadBuildSchema 'DataConnector r m n ) =>
2022-12-12 07:41:36 +03:00
RQL . TableInfo 'DataConnector ->
GS . C . SchemaT r m ( P . InputFieldsParser n ( DC . BackendInsert ( IR . UnpreparedValue 'DataConnector ) ) )
mkBackendInsertParser _tableInfo =
pure $ pure DC . BackendInsert
buildTableUpdateMutationFields' ::
2023-05-17 11:53:31 +03:00
( MonadBuildSchema 'DataConnector r m n ) =>
2022-12-12 07:41:36 +03:00
GS . C . Scenario ->
RQL . TableInfo 'DataConnector ->
GQLNameIdentifier ->
GS . C . SchemaT r m [ P . FieldParser n ( IR . AnnotatedUpdateG 'DataConnector ( IR . RemoteRelationshipField IR . UnpreparedValue ) ( IR . UnpreparedValue 'DataConnector ) ) ]
2023-01-10 04:54:40 +03:00
buildTableUpdateMutationFields' scenario tableInfo gqlName = do
2022-12-12 07:41:36 +03:00
API . Capabilities { .. } <- DC . _scCapabilities . RQL . _siConfiguration @ ( 'DataConnector ) <$> asks getter
2023-01-10 04:54:40 +03:00
case _cMutations >>= API . _mcUpdateCapabilities of
Just _updateCapabilities -> do
updateRootFields <- GS . B . buildSingleBatchTableUpdateMutationFields DC . SingleBatch scenario tableInfo gqlName
updateManyRootField <- GS . U . B . updateTableMany DC . MultipleBatches scenario tableInfo gqlName
pure $ updateRootFields ++ ( maybeToList updateManyRootField )
Nothing -> pure []
parseUpdateOperators' ::
forall m n r .
2023-05-17 11:53:31 +03:00
( MonadBuildSchema 'DataConnector r m n ) =>
2023-01-10 04:54:40 +03:00
RQL . TableInfo 'DataConnector ->
RQL . UpdPermInfo 'DataConnector ->
GS . C . SchemaT r m ( P . InputFieldsParser n ( HashMap ( RQL . Column 'DataConnector ) ( DC . UpdateOperator ( IR . UnpreparedValue 'DataConnector ) ) ) )
parseUpdateOperators' tableInfo updatePermissions = do
2023-01-19 07:21:11 +03:00
capabilities <- DC . _scCapabilities . RQL . _siConfiguration @ ( 'DataConnector ) <$> asks getter
let scalarTypeCapabilities = API . unScalarTypesCapabilities . API . _cScalarTypes $ capabilities
-- Group all the custom operators by operator name
let customOperatorCapabilities =
scalarTypeCapabilities
2023-04-26 18:42:13 +03:00
& HashMap . toList
2023-01-19 07:21:11 +03:00
>>= ( \ ( scalarType , API . ScalarTypeCapabilities { .. } ) ->
let scalarType' = DC . mkScalarType capabilities scalarType
in API . unUpdateColumnOperators _stcUpdateColumnOperators
2023-04-26 18:42:13 +03:00
& HashMap . toList
<&> ( \ ( operatorName , operatorDefinition ) -> HashMap . singleton operatorName ( HashMap . singleton scalarType' operatorDefinition ) )
2023-01-19 07:21:11 +03:00
)
2023-04-26 18:42:13 +03:00
& HashMap . unionsWith ( <> )
2023-01-19 07:21:11 +03:00
let customOperators =
customOperatorCapabilities
2023-04-26 18:42:13 +03:00
& HashMap . toList
2023-01-19 07:21:11 +03:00
<&> ( \ ( operatorName , operatorUsages ) -> DC . UpdateCustomOperator operatorName <$> updateCustomOp operatorName operatorUsages )
2023-01-10 04:54:40 +03:00
GS . U . buildUpdateOperators
( DC . UpdateSet <$> GS . U . presetColumns updatePermissions )
2023-01-19 07:21:11 +03:00
( ( DC . UpdateSet <$> GS . U . setOp ) : customOperators )
2023-01-10 04:54:40 +03:00
tableInfo
2022-12-12 07:41:36 +03:00
2023-01-19 07:21:11 +03:00
updateCustomOp ::
forall m n r .
2023-05-17 11:53:31 +03:00
( MonadBuildSchema 'DataConnector r m n ) =>
2023-01-19 07:21:11 +03:00
API . UpdateColumnOperatorName ->
HashMap DC . ScalarType API . UpdateColumnOperatorDefinition ->
GS . U . UpdateOperator 'DataConnector r m n ( IR . UnpreparedValue 'DataConnector )
updateCustomOp ( API . UpdateColumnOperatorName operatorName ) operatorUsages = GS . U . UpdateOperator { .. }
where
extractColumnScalarType :: RQL . ColumnInfo 'DataConnector -> Maybe DC . ScalarType
extractColumnScalarType RQL . ColumnInfo { .. } =
case ciType of
RQL . ColumnScalar columnScalarType -> Just columnScalarType
RQL . ColumnEnumReference _enumReference -> Nothing
updateOperatorApplicableColumn :: RQL . ColumnInfo 'DataConnector -> Bool
updateOperatorApplicableColumn columnInfo =
-- ColumnEnumReferences are not supported at this time
extractColumnScalarType columnInfo
2023-04-26 18:42:13 +03:00
<&> ( \ columnScalarType -> HashMap . member columnScalarType operatorUsages )
2023-01-19 07:21:11 +03:00
& fromMaybe False
-- Prepend the operator name with underscore
operatorGraphqlFieldIdentifier :: GQLNameIdentifier
operatorGraphqlFieldIdentifier =
fromAutogeneratedName $ GQL . addSuffixes $$ ( GQL . litName " _ " ) [ GQL . convertNameToSuffix operatorName ]
updateOperatorParser ::
GQLNameIdentifier ->
RQL . TableName 'DataConnector ->
NonEmpty ( RQL . ColumnInfo 'DataConnector ) ->
GS . C . SchemaT r m ( P . InputFieldsParser n ( HashMap ( RQL . Column 'DataConnector ) ( IR . UnpreparedValue 'DataConnector ) ) )
updateOperatorParser tableGQLName tableName columns = do
capabilities <- DC . _scCapabilities . RQL . _siConfiguration @ ( 'DataConnector ) <$> asks getter
let operatorIdentifier = fromAutogeneratedName operatorName
let typedParser :: RQL . ColumnInfo 'DataConnector -> GS . C . SchemaT r m ( P . Parser 'P . Both n ( IR . UnpreparedValue 'DataConnector ) )
typedParser columnInfo = do
columnScalarType <- extractColumnScalarType columnInfo ` onNothing ` throw400 NotSupported " updateOperatorParser: Enum column types not supported "
argumentType <-
2023-04-26 18:42:13 +03:00
( HashMap . lookup columnScalarType operatorUsages
2023-01-19 07:21:11 +03:00
<&> ( \ API . UpdateColumnOperatorDefinition { .. } -> RQL . ColumnScalar $ DC . mkScalarType capabilities _ucodArgumentType )
)
-- This shouldn't happen 😬 because updateOperatorApplicableColumn should protect this
-- parser from being used with unsupported column types
` onNothing ` throw500 ( " updateOperatorParser: Unable to find argument type for update column operator " <> toTxt operatorName <> " used with column scalar type " <> toTxt columnScalarType )
fmap IR . mkParameter
<$> columnParser'
argumentType
( GQL . Nullability $ RQL . ciIsNullable columnInfo )
GS . U . updateOperator
tableGQLName
operatorIdentifier
operatorGraphqlFieldIdentifier
typedParser
columns
( GQL . Description $ " applies the " <> toTxt operatorName <> " operator with the given values to the specified columns " )
( GQL . Description $ " input type for applying the " <> toTxt operatorName <> " operator to columns in table " <> toTxt tableName )
2022-12-12 07:41:36 +03:00
buildTableDeleteMutationFields' ::
2023-05-17 11:53:31 +03:00
( MonadBuildSchema 'DataConnector r m n ) =>
2022-12-12 07:41:36 +03:00
RQL . MkRootFieldName ->
GS . C . Scenario ->
RQL . TableName 'DataConnector ->
RQL . TableInfo 'DataConnector ->
GQLNameIdentifier ->
GS . C . SchemaT r m [ P . FieldParser n ( IR . AnnDelG 'DataConnector ( IR . RemoteRelationshipField IR . UnpreparedValue ) ( IR . UnpreparedValue 'DataConnector ) ) ]
buildTableDeleteMutationFields' mkRootFieldName scenario tableName tableInfo gqlName = do
API . Capabilities { .. } <- DC . _scCapabilities . RQL . _siConfiguration @ ( 'DataConnector ) <$> asks getter
case _cMutations >>= API . _mcDeleteCapabilities of
Just _deleteCapabilities -> GS . B . buildTableDeleteMutationFields mkRootFieldName scenario tableName tableInfo gqlName
Nothing -> pure []
2022-02-25 19:08:18 +03:00
experimentalBuildTableRelayQueryFields ::
2023-05-17 11:53:31 +03:00
( MonadBuildSchema 'DataConnector r m n ) =>
2022-08-03 22:08:34 +03:00
RQL . MkRootFieldName ->
2022-05-02 08:03:12 +03:00
RQL . TableName 'DataConnector ->
RQL . TableInfo 'DataConnector ->
2022-05-26 14:54:30 +03:00
GQLNameIdentifier ->
2022-05-02 08:03:12 +03:00
NESeq ( RQL . ColumnInfo 'DataConnector ) ->
2022-09-06 19:48:04 +03:00
GS . C . SchemaT r m [ P . FieldParser n a ]
server: reduce schema contexts to the bare minimum
### Description
This monster of a PR took way too long. As the title suggests, it reduces the schema context carried in the readers to the very strict minimum. In practice, that means that to build a source, we only require:
- the global `SchemaContext`
- the global `SchemaOptions` (soon to be renamed `SchemaSourceOptions`)
- that source's `SourceInfo`
Furthermore, _we no longer carry "default" customization options throughout the schema_. All customization information is extracted from the `SourceInfo`, when required. This prevents an entire category of bugs we had previously encountered, such as parts of the code using uninitialized / unupdated customization info.
In turn, this meant that we could remove the explicit threading of the `SourceInfo` throughout the schema, since it is now always available through the reader context.
Finally, this meant making a few adjustments to relay and actions as well, such as the introduction of a new separate "context" for actions, and a change to how we create some of the action-specific postgres scalar parsers.
I'll highlight with review comments the areas of interest.
PR-URL: https://github.com/hasura/graphql-engine-mono/pull/6709
GitOrigin-RevId: ea80fddcb24e2513779dd04b0b700a55f0028dd1
2022-11-17 13:34:05 +03:00
experimentalBuildTableRelayQueryFields _mkRootFieldName _tableName _tableInfo _gqlName _pkeyColumns =
2022-02-25 19:08:18 +03:00
pure []
2022-04-14 05:06:07 +03:00
columnParser' ::
2023-05-17 11:53:31 +03:00
( MonadBuildSchema 'DataConnector r m n ) =>
2022-05-02 08:03:12 +03:00
RQL . ColumnType 'DataConnector ->
2022-04-28 04:51:58 +03:00
GQL . Nullability ->
2022-09-06 19:48:04 +03:00
GS . C . SchemaT r m ( P . Parser 'P . Both n ( IR . ValueWithOrigin ( RQL . ColumnValue 'DataConnector ) ) )
2022-10-03 23:09:42 +03:00
columnParser' columnType nullability = case columnType of
2023-01-11 05:36:03 +03:00
RQL . ColumnScalar scalarType @ ( DC . ScalarType name graphQLType ) ->
2022-10-03 23:09:42 +03:00
P . memoizeOn 'columnParser' ( scalarType , nullability ) $
GS . C . peelWithOrigin . fmap ( RQL . ColumnValue columnType ) . possiblyNullable' scalarType nullability
2023-01-11 05:36:03 +03:00
<$> do
gqlName <-
GQL . mkName name
` onNothing ` throw400 ValidationFailed ( " The column type name " <> name <<> " is not a valid GraphQL name " )
pure $ case graphQLType of
Nothing -> P . jsonScalar gqlName ( Just " A custom scalar type " )
Just DC . GraphQLInt -> ( J . Number . fromIntegral ) <$> P . namedInt gqlName
Just DC . GraphQLFloat -> ( J . Number . fromFloatDigits ) <$> P . namedFloat gqlName
Just DC . GraphQLString -> J . String <$> P . namedString gqlName
Just DC . GraphQLBoolean -> J . Bool <$> P . namedBoolean gqlName
Just DC . GraphQLID -> J . String <$> P . namedIdentifier gqlName
2022-10-03 23:09:42 +03:00
RQL . ColumnEnumReference ( RQL . EnumReference tableName enumValues customTableName ) ->
2023-04-26 18:42:13 +03:00
case nonEmpty ( HashMap . toList enumValues ) of
2022-10-03 23:09:42 +03:00
Just enumValuesList ->
GS . C . peelWithOrigin . fmap ( RQL . ColumnValue columnType )
<$> enumParser' tableName enumValuesList customTableName nullability
Nothing -> throw400 ValidationFailed " empty enum values "
2022-09-14 00:21:07 +03:00
enumParser' ::
2023-05-17 11:53:31 +03:00
( MonadError QErr m ) =>
2022-09-14 00:21:07 +03:00
RQL . TableName 'DataConnector ->
NonEmpty ( RQL . EnumValue , RQL . EnumValueInfo ) ->
Maybe GQL . Name ->
GQL . Nullability ->
GS . C . SchemaT r m ( P . Parser 'P . Both n ( RQL . ScalarValue 'DataConnector ) )
enumParser' _tableName _enumValues _customTableName _nullability =
throw400 NotSupported " This column type is unsupported by the Data Connector backend "
possiblyNullable' ::
2023-05-17 11:53:31 +03:00
( MonadParse m ) =>
2022-09-14 00:21:07 +03:00
RQL . ScalarType 'DataConnector ->
GQL . Nullability ->
P . Parser 'P . Both m J . Value ->
P . Parser 'P . Both m J . Value
possiblyNullable' _scalarType ( GQL . Nullability isNullable )
| isNullable = fmap ( fromMaybe J . Null ) . P . nullable
| otherwise = id
2022-04-14 05:06:07 +03:00
2022-06-10 06:59:00 +03:00
orderByOperators' :: RQL . SourceInfo 'DataConnector -> NamingCase -> ( GQL . Name , NonEmpty ( P . Definition P . EnumValueInfo , ( RQL . BasicOrderType 'DataConnector , RQL . NullsOrderType 'DataConnector ) ) )
orderByOperators' RQL . SourceInfo { _siConfiguration } _tCase =
2022-09-20 09:18:46 +03:00
let dcName = DC . _scDataConnectorName _siConfiguration
2022-10-18 07:17:57 +03:00
orderBy = GQL . addSuffixes ( DC . unDataConnectorName dcName ) [ $$ ( GQL . litSuffix " _order_by " ) ]
2022-06-10 06:59:00 +03:00
in ( orderBy , ) $
-- NOTE: NamingCase is not being used here as we don't support naming conventions for this DB
NE . fromList
[ ( define $$ ( GQL . litName " asc " ) " in ascending order " ,
2022-09-20 09:18:46 +03:00
( DC . Ascending , () )
2022-06-10 06:59:00 +03:00
) ,
( define $$ ( GQL . litName " desc " ) " in descending order " ,
2022-09-20 09:18:46 +03:00
( DC . Descending , () )
2022-06-10 06:59:00 +03:00
)
]
2022-04-14 05:06:07 +03:00
where
2022-07-25 18:53:25 +03:00
define name desc = P . Definition name ( Just desc ) Nothing [] P . EnumValueInfo
2022-04-14 05:06:07 +03:00
comparisonExps' ::
2022-04-28 04:51:58 +03:00
forall m n r .
2023-05-17 11:53:31 +03:00
( MonadBuildSchema 'DataConnector r m n ) =>
2022-05-02 08:03:12 +03:00
RQL . ColumnType 'DataConnector ->
2022-09-06 19:48:04 +03:00
GS . C . SchemaT r m ( P . Parser 'P . Input n [ ComparisonExp 'DataConnector ] )
server: reduce schema contexts to the bare minimum
### Description
This monster of a PR took way too long. As the title suggests, it reduces the schema context carried in the readers to the very strict minimum. In practice, that means that to build a source, we only require:
- the global `SchemaContext`
- the global `SchemaOptions` (soon to be renamed `SchemaSourceOptions`)
- that source's `SourceInfo`
Furthermore, _we no longer carry "default" customization options throughout the schema_. All customization information is extracted from the `SourceInfo`, when required. This prevents an entire category of bugs we had previously encountered, such as parts of the code using uninitialized / unupdated customization info.
In turn, this meant that we could remove the explicit threading of the `SourceInfo` throughout the schema, since it is now always available through the reader context.
Finally, this meant making a few adjustments to relay and actions as well, such as the introduction of a new separate "context" for actions, and a change to how we create some of the action-specific postgres scalar parsers.
I'll highlight with review comments the areas of interest.
PR-URL: https://github.com/hasura/graphql-engine-mono/pull/6709
GitOrigin-RevId: ea80fddcb24e2513779dd04b0b700a55f0028dd1
2022-11-17 13:34:05 +03:00
comparisonExps' columnType = do
2022-07-14 20:57:28 +03:00
collapseIfNull <- GS . C . retrieve Options . soDangerousBooleanCollapse
server: reduce schema contexts to the bare minimum
### Description
This monster of a PR took way too long. As the title suggests, it reduces the schema context carried in the readers to the very strict minimum. In practice, that means that to build a source, we only require:
- the global `SchemaContext`
- the global `SchemaOptions` (soon to be renamed `SchemaSourceOptions`)
- that source's `SourceInfo`
Furthermore, _we no longer carry "default" customization options throughout the schema_. All customization information is extracted from the `SourceInfo`, when required. This prevents an entire category of bugs we had previously encountered, such as parts of the code using uninitialized / unupdated customization info.
In turn, this meant that we could remove the explicit threading of the `SourceInfo` throughout the schema, since it is now always available through the reader context.
Finally, this meant making a few adjustments to relay and actions as well, such as the introduction of a new separate "context" for actions, and a change to how we create some of the action-specific postgres scalar parsers.
I'll highlight with review comments the areas of interest.
PR-URL: https://github.com/hasura/graphql-engine-mono/pull/6709
GitOrigin-RevId: ea80fddcb24e2513779dd04b0b700a55f0028dd1
2022-11-17 13:34:05 +03:00
sourceInfo :: RQL . SourceInfo 'DataConnector <- asks getter
let dataConnectorName = sourceInfo ^. RQL . siConfiguration . DC . scDataConnectorName
tCase = RQL . _rscNamingConvention $ RQL . _siCustomization sourceInfo
P . memoizeOn 'comparisonExps' ( dataConnectorName , columnType ) do
typedParser <- columnParser' columnType ( GQL . Nullability False )
let name = GQL . addSuffixes ( P . getName typedParser ) [ $$ ( GQL . litSuffix " _ " ) , GQL . convertNameToSuffix ( DC . unDataConnectorName dataConnectorName ) , $$ ( GQL . litSuffix " _comparison_exp " ) ]
desc =
GQL . Description $
" Boolean expression to compare columns of type "
<> P . getName typedParser
<<> " . All fields are combined with logical 'AND'. "
columnListParser = fmap IR . openValueOrigin <$> P . list typedParser
customOperators <- ( fmap . fmap . fmap ) IR . ABackendSpecific <$> mkCustomOperators sourceInfo tCase collapseIfNull ( P . getName typedParser )
pure $
P . object name ( Just desc ) $
fmap catMaybes $
sequenceA $
concat
[ GS . BE . equalityOperators
tCase
collapseIfNull
( IR . mkParameter <$> typedParser )
( mkListLiteral <$> columnListParser ) ,
GS . BE . comparisonOperators
tCase
collapseIfNull
( IR . mkParameter <$> typedParser ) ,
customOperators
]
2022-04-28 04:51:58 +03:00
where
2022-05-31 01:07:02 +03:00
mkListLiteral :: [ RQL . ColumnValue 'DataConnector ] -> IR . UnpreparedValue 'DataConnector
2022-04-28 04:51:58 +03:00
mkListLiteral columnValues =
2022-10-20 06:23:37 +03:00
IR . UVLiteral $ DC . ArrayLiteral ( columnTypeToScalarType columnType ) ( RQL . cvValue <$> columnValues )
2022-04-14 05:06:07 +03:00
2022-09-06 07:24:46 +03:00
mkCustomOperators ::
server: reduce schema contexts to the bare minimum
### Description
This monster of a PR took way too long. As the title suggests, it reduces the schema context carried in the readers to the very strict minimum. In practice, that means that to build a source, we only require:
- the global `SchemaContext`
- the global `SchemaOptions` (soon to be renamed `SchemaSourceOptions`)
- that source's `SourceInfo`
Furthermore, _we no longer carry "default" customization options throughout the schema_. All customization information is extracted from the `SourceInfo`, when required. This prevents an entire category of bugs we had previously encountered, such as parts of the code using uninitialized / unupdated customization info.
In turn, this meant that we could remove the explicit threading of the `SourceInfo` throughout the schema, since it is now always available through the reader context.
Finally, this meant making a few adjustments to relay and actions as well, such as the introduction of a new separate "context" for actions, and a change to how we create some of the action-specific postgres scalar parsers.
I'll highlight with review comments the areas of interest.
PR-URL: https://github.com/hasura/graphql-engine-mono/pull/6709
GitOrigin-RevId: ea80fddcb24e2513779dd04b0b700a55f0028dd1
2022-11-17 13:34:05 +03:00
RQL . SourceInfo 'DataConnector ->
2022-09-06 07:24:46 +03:00
NamingCase ->
Options . DangerouslyCollapseBooleans ->
GQL . Name ->
2022-09-06 19:48:04 +03:00
GS . C . SchemaT r m [ P . InputFieldsParser n ( Maybe ( CustomBooleanOperator ( IR . UnpreparedValue 'DataConnector ) ) ) ]
server: reduce schema contexts to the bare minimum
### Description
This monster of a PR took way too long. As the title suggests, it reduces the schema context carried in the readers to the very strict minimum. In practice, that means that to build a source, we only require:
- the global `SchemaContext`
- the global `SchemaOptions` (soon to be renamed `SchemaSourceOptions`)
- that source's `SourceInfo`
Furthermore, _we no longer carry "default" customization options throughout the schema_. All customization information is extracted from the `SourceInfo`, when required. This prevents an entire category of bugs we had previously encountered, such as parts of the code using uninitialized / unupdated customization info.
In turn, this meant that we could remove the explicit threading of the `SourceInfo` throughout the schema, since it is now always available through the reader context.
Finally, this meant making a few adjustments to relay and actions as well, such as the introduction of a new separate "context" for actions, and a change to how we create some of the action-specific postgres scalar parsers.
I'll highlight with review comments the areas of interest.
PR-URL: https://github.com/hasura/graphql-engine-mono/pull/6709
GitOrigin-RevId: ea80fddcb24e2513779dd04b0b700a55f0028dd1
2022-11-17 13:34:05 +03:00
mkCustomOperators sourceInfo tCase collapseIfNull typeName = do
2022-09-20 09:18:46 +03:00
let capabilities = sourceInfo ^. RQL . siConfiguration . DC . scCapabilities
2023-04-26 18:42:13 +03:00
case HashMap . lookup ( DC . fromGQLType typeName ) ( API . unScalarTypesCapabilities $ API . _cScalarTypes capabilities ) of
2022-09-06 07:24:46 +03:00
Nothing -> pure []
2022-10-28 04:12:54 +03:00
Just API . ScalarTypeCapabilities { .. } -> do
2023-04-26 18:42:13 +03:00
traverse ( mkCustomOperator tCase collapseIfNull ) $ HashMap . toList $ fmap ( DC . mkScalarType capabilities ) $ API . unComparisonOperators $ _stcComparisonOperators
2022-09-06 07:24:46 +03:00
mkCustomOperator ::
NamingCase ->
Options . DangerouslyCollapseBooleans ->
2022-10-28 04:12:54 +03:00
( GQL . Name , DC . ScalarType ) ->
2022-09-06 19:48:04 +03:00
GS . C . SchemaT r m ( P . InputFieldsParser n ( Maybe ( CustomBooleanOperator ( IR . UnpreparedValue 'DataConnector ) ) ) )
2022-10-28 04:12:54 +03:00
mkCustomOperator tCase collapseIfNull ( operatorName , argType ) = do
argParser <- mkArgParser argType
2022-09-06 07:24:46 +03:00
pure $
2022-10-28 04:12:54 +03:00
GS . BE . mkBoolOperator tCase collapseIfNull ( fromCustomName operatorName ) Nothing $
CustomBooleanOperator ( GQL . unName operatorName ) . Just . Right <$> argParser
2022-09-06 07:24:46 +03:00
2022-10-28 04:12:54 +03:00
mkArgParser :: DC . ScalarType -> GS . C . SchemaT r m ( P . Parser 'P . Both n ( IR . UnpreparedValue 'DataConnector ) )
2022-09-06 07:24:46 +03:00
mkArgParser argType =
fmap IR . mkParameter
<$> columnParser'
2022-10-28 04:12:54 +03:00
( RQL . ColumnScalar argType )
( GQL . Nullability True )
2022-09-06 07:24:46 +03:00
2022-04-14 05:06:07 +03:00
tableArgs' ::
forall r m n .
2023-05-17 11:53:31 +03:00
( MonadBuildSchema 'DataConnector r m n ) =>
2022-05-02 08:03:12 +03:00
RQL . TableInfo 'DataConnector ->
2022-09-06 19:48:04 +03:00
GS . C . SchemaT r m ( P . InputFieldsParser n ( IR . SelectArgsG 'DataConnector ( IR . UnpreparedValue 'DataConnector ) ) )
server: reduce schema contexts to the bare minimum
### Description
This monster of a PR took way too long. As the title suggests, it reduces the schema context carried in the readers to the very strict minimum. In practice, that means that to build a source, we only require:
- the global `SchemaContext`
- the global `SchemaOptions` (soon to be renamed `SchemaSourceOptions`)
- that source's `SourceInfo`
Furthermore, _we no longer carry "default" customization options throughout the schema_. All customization information is extracted from the `SourceInfo`, when required. This prevents an entire category of bugs we had previously encountered, such as parts of the code using uninitialized / unupdated customization info.
In turn, this meant that we could remove the explicit threading of the `SourceInfo` throughout the schema, since it is now always available through the reader context.
Finally, this meant making a few adjustments to relay and actions as well, such as the introduction of a new separate "context" for actions, and a change to how we create some of the action-specific postgres scalar parsers.
I'll highlight with review comments the areas of interest.
PR-URL: https://github.com/hasura/graphql-engine-mono/pull/6709
GitOrigin-RevId: ea80fddcb24e2513779dd04b0b700a55f0028dd1
2022-11-17 13:34:05 +03:00
tableArgs' tableInfo = do
whereParser <- GS . S . tableWhereArg tableInfo
orderByParser <- GS . S . tableOrderByArg tableInfo
2022-04-14 05:06:07 +03:00
let mkSelectArgs whereArg orderByArg limitArg offsetArg =
2022-07-20 08:20:49 +03:00
IR . SelectArgs
2022-04-14 05:06:07 +03:00
{ _saWhere = whereArg ,
_saOrderBy = orderByArg ,
_saLimit = limitArg ,
_saOffset = offsetArg ,
_saDistinct = Nothing
}
pure $
mkSelectArgs
<$> whereParser
<*> orderByParser
2022-04-28 04:51:58 +03:00
<*> GS . S . tableLimitArg
<*> GS . S . tableOffsetArg
2022-07-20 08:20:49 +03:00
countTypeInput' ::
2023-05-17 11:53:31 +03:00
( MonadParse n ) =>
2022-09-20 09:18:46 +03:00
Maybe ( P . Parser 'P . Both n DC . ColumnName ) ->
P . InputFieldsParser n ( IR . CountDistinct -> DC . CountAggregate )
2022-07-20 08:20:49 +03:00
countTypeInput' = \ case
2022-07-28 10:24:13 +03:00
Just columnEnum -> mkCountAggregate <$> P . fieldOptional Name . _column Nothing columnEnum
2022-07-20 08:20:49 +03:00
Nothing -> pure $ mkCountAggregate Nothing
where
2022-09-20 09:18:46 +03:00
mkCountAggregate :: Maybe DC . ColumnName -> IR . CountDistinct -> DC . CountAggregate
mkCountAggregate Nothing _ = DC . StarCount
mkCountAggregate ( Just column ) IR . SelectCountDistinct = DC . ColumnDistinctCount column
mkCountAggregate ( Just column ) IR . SelectCountNonDistinct = DC . ColumnCount column