mirror of
https://github.com/hasura/graphql-engine.git
synced 2024-12-18 04:51:35 +03:00
6e1761f8f9
### Description This PR adds the ability to perform remote joins from remote schemas in the engine. To do so, we alter the definition of an `ExecutionStep` targeting a remote schema: the `ExecStepRemote` constructor now expects a `Maybe RemoteJoins`. This new argument is used when processing the execution step, in the transport layer (either `Transport.HTTP` or `Transport.WebSocket`). For this `Maybe RemoteJoins` to be extracted from a parsed query, this PR also extends the `Execute.RemoteJoin.Collect` module, to implement "collection" from a selection set. Not only do those new functions extract the remote joins, but they also apply all necessary transformations to the selection sets (such as inserting the necessary "phantom" fields used as join keys). Finally in `Execute.RemoteJoin.Join`, we make two changes. First, we now always look for nested remote joins, regardless of whether the join we just performed went to a source or a remote schema; and second we adapt our join tree logic according to the special cases that were added to deal with remote server edge cases. Additionally, this PR refactors / cleans / documents `Execute.RemoteJoin.RemoteServer`. This is not required as part of this change and could be moved to a separate PR if needed (a similar cleanup of `Join` is done independently in #3894). It also introduces a draft of a new documentation page for this project, that will be refined in the release PR that ships the feature (either #3069 or a copy of it). While this PR extends the engine, it doesn't plug such relationships in the schema, meaning that, as of this PR, the new code paths in `Join` are technically unreachable. Adding the corresponding schema code and, ultimately, enabling the metadata API will be done in subsequent PRs. ### Keeping track of concrete type names The main change this PR makes to the existing `Join` code is to handle a new reserved field we sometimes use when targeting remote servers: the `__hasura_internal_typename` field. In short, a GraphQL selection set can sometimes "branch" based on the concrete "runtime type" of the object on which the selection happens: ```graphql query { author(id: 53478) { ... on Writer { name articles { title } } ... on Artist { name articles { title } } } } ``` If both of those `articles` are remote joins, we need to be able, when we get the answer, to differentiate between the two different cases. We do this by asking for `__typename`, to be able to decide if we're in the `Writer` or the `Artist` branch of the query. To avoid further processing / customization of results, we only insert this `__hasura_internal_typename: __typename` field in the query in the case of unions of interfaces AND if we have the guarantee that we will processing the request as part of the remote joins "folding": that is, if there's any remote join in this branch in the tree. Otherwise, we don't insert the field, and we leave that part of the response untouched. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/3810 GitOrigin-RevId: 89aaf16274d68e26ad3730b80c2d2fdc2896b96c
108 lines
3.8 KiB
Haskell
108 lines
3.8 KiB
Haskell
module Hasura.RQL.IR.Root
|
|
( SourceConfigWith (..),
|
|
RootField (..),
|
|
MutationDB (..),
|
|
ActionQuery (..),
|
|
ActionMutation (..),
|
|
QueryRootField,
|
|
MutationRootField,
|
|
SubscriptionRootField,
|
|
QueryDBRoot (..),
|
|
MutationDBRoot (..),
|
|
RemoteRelationshipField (..),
|
|
)
|
|
where
|
|
|
|
import Data.Aeson.Ordered qualified as JO
|
|
import Data.Kind (Type)
|
|
import Hasura.Prelude
|
|
import Hasura.RQL.IR.Delete
|
|
import Hasura.RQL.IR.Insert
|
|
import Hasura.RQL.IR.RemoteSchema
|
|
import Hasura.RQL.IR.Select
|
|
import Hasura.RQL.IR.Update
|
|
import Hasura.RQL.Types.Action qualified as RQL
|
|
import Hasura.RQL.Types.Backend qualified as RQL
|
|
import Hasura.RQL.Types.Common qualified as RQL
|
|
import Hasura.RQL.Types.QueryTags qualified as RQL
|
|
import Hasura.RQL.Types.RemoteSchema qualified as RQL
|
|
import Hasura.SQL.AnyBackend qualified as AB
|
|
import Hasura.SQL.Backend
|
|
|
|
data SourceConfigWith (db :: BackendType -> Type) (b :: BackendType)
|
|
= SourceConfigWith (RQL.SourceConfig b) (Maybe RQL.QueryTagsConfig) (db b)
|
|
|
|
data RootField (db :: BackendType -> Type) remote action raw where
|
|
RFDB ::
|
|
RQL.SourceName ->
|
|
AB.AnyBackend (SourceConfigWith db) ->
|
|
RootField db remote action raw
|
|
RFRemote :: remote -> RootField db remote action raw
|
|
RFAction :: action -> RootField db remote action raw
|
|
RFRaw :: raw -> RootField db remote action raw
|
|
|
|
data MutationDB (b :: BackendType) (r :: Type) v
|
|
= MDBInsert (AnnInsert b r v)
|
|
| MDBUpdate (AnnotatedUpdateG b r v)
|
|
| MDBDelete (AnnDelG b r v)
|
|
| -- | This represents a VOLATILE function, and is AnnSimpleSelG for easy
|
|
-- re-use of non-VOLATILE function tracking code.
|
|
MDBFunction RQL.JsonAggSelect (AnnSimpleSelectG b r v)
|
|
deriving stock (Generic, Functor, Foldable, Traversable)
|
|
|
|
data ActionQuery (r :: Type)
|
|
= AQQuery !(RQL.AnnActionExecution r)
|
|
| AQAsync !(RQL.AnnActionAsyncQuery ('Postgres 'Vanilla) r)
|
|
deriving stock (Functor, Foldable, Traversable)
|
|
|
|
data ActionMutation (r :: Type)
|
|
= AMSync !(RQL.AnnActionExecution r)
|
|
| AMAsync !RQL.AnnActionMutationAsync
|
|
|
|
-- The `db` type argument of @RootField@ expects only one type argument, the backend `b`, as not all
|
|
-- types stored in a RootField will have a second parameter like @QueryDB@ does: they all only have
|
|
-- in common the fact that they're parametric over the backend. To define @QueryRootField@ in terms
|
|
-- of @QueryDB@ (and likewise for mutations), we need a type-level function `b -> QueryDB b (v
|
|
-- b)`. Sadly, neither type synonyms nor type families may be partially applied. Hence the need for
|
|
-- @QueryDBRoot@ and @MutationDBRoot@.
|
|
newtype QueryDBRoot r v b = QDBR (QueryDB b r (v b))
|
|
|
|
newtype MutationDBRoot r v b = MDBR (MutationDB b r (v b))
|
|
|
|
-- | IR of a remote relationship. A remote relationship currently can be to
|
|
-- either a remote schema or a database's table. See RemoteSourceSelect for
|
|
-- explanation on 'vf'.
|
|
data RemoteRelationshipField vf
|
|
= RemoteSchemaField (RemoteSchemaSelect (RemoteRelationshipField vf))
|
|
| -- | AnyBackend is used here to capture a relationship to an arbitrary target
|
|
RemoteSourceField (AB.AnyBackend (RemoteSourceSelect (RemoteRelationshipField vf) vf))
|
|
|
|
-- | Represents a query root field to an action
|
|
type QueryActionRoot v =
|
|
ActionQuery (RemoteRelationshipField v)
|
|
|
|
-- | Represents a mutation root field to an action
|
|
type MutationActionRoot v =
|
|
ActionMutation (RemoteRelationshipField v)
|
|
|
|
type QueryRootField v =
|
|
RootField
|
|
(QueryDBRoot (RemoteRelationshipField v) v)
|
|
(RemoteSchemaRootField (RemoteRelationshipField v) RQL.RemoteSchemaVariable)
|
|
(QueryActionRoot v)
|
|
JO.Value
|
|
|
|
type MutationRootField v =
|
|
RootField
|
|
(MutationDBRoot (RemoteRelationshipField v) v)
|
|
(RemoteSchemaRootField (RemoteRelationshipField v) RQL.RemoteSchemaVariable)
|
|
(MutationActionRoot v)
|
|
JO.Value
|
|
|
|
type SubscriptionRootField v =
|
|
RootField
|
|
(QueryDBRoot (RemoteRelationshipField v) v)
|
|
Void
|
|
Void
|
|
Void
|