Is there a way to prevent the expansion of Fragments on Interfaces?

[Luscha]

I do have 2 schemas stitched using @graphql-tools/[email protected].
One of those two subschemas is the combination of a remote schema and a local schema which is needed to attach some custom logic to the remote schema.
For context, the remote schema speaks directly to the GraphQL interface of Dgraph, and the local schema is mandatory since it's not possible to create custom resolvers and custom logic directly in Dgraph.

This is how i accomplished to merge the two schema in a single datagraph to stitch with other services:

import * as typeDefs from '@/schema/detabesu-schema.gql';
import * as typeCustomDefs from '@/schema/detabesu-custom-schema.gql';

...

// create a wrapped remote schema to forward requests to dgraph
    const remoteSchema = wrapSchema({
        schema: makeExecutableSchema({
            typeDefs: [typeDefs, ...CommonTypes()],
        }),
        executor: Executor,
        // createProxyingResolver: applicationProxyResolver,
        transforms: RemoteTransformers(),
    });

    const detabesuMerges = {};/// Generate the mergers
    const mergedSchema = mergeSchemas({
        schemas: [
            remoteSchema,
        ],
        typeDefs: [typeCustomDefs]
    });

    return {
        // add to the merged schema the resolvers generated using the remote schema
        schema: addResolversToSchema({
            schema: mergedSchema,
            resolvers: {
                ...await buildResolvers(remoteSchema),
            },
            inheritResolversFromInterfaces: true,
        }),
        batch: true,
        merge: {
            ...detabesuMerges
        },
        transforms: GatewayTransformers(),
    }

interface Metadata {
     id: ID!
}

interface Content {
     names: [String]
     descriptions: [String]
}

type Movie extends Content & Metadata {
     id: ID!
     names: [String]
     descriptions: [String]
.....
}

type Series extends Content & Metadata {
     id: ID!
     names: [String]
     descriptions: [String]
.....
}

type Query {
     get(id: ID!) Metadata !
}
.....

I noticed that when I perform queries like

{
  get(id: "adadsa") {
      ... on Content {
        names
      }
   ]
}

it gets exploded in

{
  get(id: "adadsa") {
      ... on Content {
        names
      }
      ... on Movie  {
        names
      }
      ... on Series   {
        names
      }
      ....
   ]
}

because when the deletagetToSchema" at mergeSchemaslevel is called, theExpandAbstractTypes transformer sees that the remote schema has less fields in my interface than the merged one (typeCustomDefsadds some fields which are then resolved by the attached resolvers) and causes the fragment on interfaceContent ` to be expanded to all implementing types.

this is causing me some trouble and it's suboptimal since the query becomes quite long and heavy pretty fast and dgraph do not accepts the that iì'm trying to resolve names on both Computer and Product (Already opened an issue).

Is there a way to disable tExpandAbstractTypes or a better architecture to attach resolvers to a remote source?

[Luscha]

updated the question with more context