merging same type from different sources?

[sbauch]

I'm having a hard time understanding the best way to achieve what feels like a pretty straightforward goal. Perhaps my data source situation is unconventional?

I have 2 sources, both GraphQL endpoints.

Each schema defines the same Project entity:

  type Project @entity {
    id: ID!
    name: String!
  }

With 100% confidence we can say that each source has completely unique Projects by the id field - no Project with the same ID will ever appear in both sources. Each source also has the same query interface for projects, i.e. the ability to order query by name.

I want to provide a single query, projects() that supports the project filters shared by each source and returns an intelligently stitched (i.e. respects order args) result of Projects from each source.

What I am unclear on:

• should this be supported out of the box if the types match?
• would renaming types on each source and then using the rename transformation help? (i.e. the AuthorWithBooks => Author rename example)
• is this appropriate for the type merging transformation?
• is my reliance on additional resolvers is the best way to accomplish this?

Additional Resolvers

I wrote my own resolver, it's so simple it feels like it should not be needed? But it breaks any notion of ordering from the outside query which would be not super fun to implement myself. Otherwise this works well.

const projects = async (root, args, context, info) => {
  const sourceA = await context.SourceA.Query.projects({
      root,
      args,
      context,
      info,

    });

  const sourceB = await context.SourceB.Query.projects({
    root,
    args,
    context,
    info,

  });


  const latest = [...sourceA, ...sourceB];

  return latest;
};


const resolvers = {
  Query: {
    projects
  },
};

module.exports = { resolvers };

Out of Box

Using the exact same entity definitions on each source and without any transforms, I seem to only get results from one of the sources.

Rename Transform

I also tried naming the source types differently and then using a rename transform to make them the same in the unified schema, but this had the same result as the previous attempt, where things where types were named the same in each source.

sources:
  - name: SourceA
    handler:
      graphql:
        endpoint: SOURCE_A_URL
    transforms:
      - rename:
          renames:
            - from:
                type: AProject
              to:
                type: Project
            - from:
                type: Query
                field: aProjects
              to:
                type: Query
                field: projects
  - name: SourceB
    handler:    
      graphql:
        endpoint: SOURCE_B_URL
      batch: true
    transforms:
      - rename:
          mode: wrap
          renames:
            - from:
                type: BProject
              to:
                type: Project
            - from:
                type: Query
                field: bProjects
              to:
                type: Query
                field: projects

Type Merging

I also tried extending the rename with type merging, but not sure it's really a fit? The keyArg part would be a negation, where we find to query projects in SourceB where the ID is not in the list of projects from SourceA? Which shouldn't matter because SourceA IDs will never appear in SourceB?

sources:
  - name: SourceA
    handler:
      graphql:
        endpoint: SOURCE_A_URL
    transforms:
      - rename:
          renames:
            - from:
                type: AProject
              to:
                type: Project
            - from:
                type: Query
                field: aProjects
              to:
                type: Query
                field: projects
      - typeMerging:
          queryFields:
            - queryFieldName: projects
              keyField: id
              keyArg: id 
  - name: SourceB
    handler:    
      graphql:
        endpoint: SOURCE_B_URL
      batch: true
    transforms:
      - rename:
          mode: wrap
          renames:
            - from:
                type: BProject
              to:
                type: Project
            - from:
                type: Query
                field: bProjects
              to:
                type: Query
                field: projects
      - typeMerging:
          queryFields:
            - queryFieldName: projects
              keyField: id
              keyArg: 'where_not.id_in'

Other approaches?

I don't have any more ideas here, hoping I'm just missing something.

Simply put, what's the mesh way for unifying query results across sources for a common entity, where entity instances only ever appear in one source?

[ardatan]

This is not possible currently. You have to implement your own additional resolvers that fetch from both sources.

[Urigo]

@sbauch unless you can think of another API that might make that possible?

[albertogg99]

Hello, is there any update about this situation? Is there any way to pull the same type from 2 different sources?

[FickleLife]

I've just gone through this with six identical sources (graphql handler) so can share my solution. I also thought this would be a common use case where there would be a simple pattern to follow but not so!

The basic steps are:

1. Define your sources as normal in .meshrc.yaml
2. Create custom typedef/schema to take the root nodes and encapsulate into a new root node (I also use graphql-codegen to extract the schema of the first source and then a simple bash script to merge it with my custom "base" schema with the new "switcher" root node.)
3. Create custom resolver which uses the new root node ("switcher" in the code below) and a variable to tell graphql-mesh which source/context to route the query to
4. Remove the "old" root nodes using filterschemas

Using three identical mock graphql server with two root nodes of "hello" and "greetings", encapsulate (don't be confused with the encapsulate transformer of graphql-mesh) them into a new root node of "switcher" with a variable of "client", the
resolver code looks like:

import { Resolvers } from "./.mesh";
import { GraphQLResolveInfo, FieldNode } from "graphql";

console.log("Loading resolvers...");

const resolvers: Resolvers = {
  Query: {
    switcher: {
      resolve: async (root, args, context, info) => {
        const { client } = args;
        let serverContext;

        // Determine the server context based on the client argument
        switch (client) {
          case "SERVER1":
            serverContext = context.Server1;
            break;
          case "SERVER2":
            serverContext = context.Server2;
            break;
          case "SERVER3":
            serverContext = context.Server3;
            break;
          default:
            throw new Error(`Invalid client: ${client}`);
        }

        // Initialize result object
        const result: any = {};

        // Check if 'greetings' field is requested
        if (isFieldRequested(info, "greetings")) {
          result.greetings = await resolveGreetings(
            serverContext,
            root,
            args,
            context,
            info
          );
        }

        // Check if 'hello' field is requested
        if (isFieldRequested(info, "hello")) {
          result.hello = await resolveHello(
            serverContext,
            root,
            args,
            context,
            info
          );
        }

        return result;
      },
    },
  },
};

// Utility function to check if a specific field is requested in the query
function isFieldRequested(
  info: GraphQLResolveInfo,
  fieldName: string
): boolean {
  return info.fieldNodes.some((node) =>
    node.selectionSet?.selections.some(
      (selection) =>
        selection.kind === "Field" && selection.name.value === fieldName
    )
  );
}

// Resolver function for the 'greetings' field
async function resolveGreetings(serverContext, root, args, context, info) {
  try {
    const fieldNode = extractFieldNode(info, "greetings");
    if (!fieldNode) {
      throw new Error("Missing field node for 'greetings'");
    }

    return await serverContext.Query.greetings({
      root,
      args,
      context,
      info: { ...info, fieldNodes: [fieldNode] },
    });
  } catch (error) {
    console.error(`Error resolving 'greetings':`, error);
    throw new Error(`Failed to fetch 'greetings' data: ${error.message}`);
  }
}

// Resolver function for the 'hello' field
async function resolveHello(serverContext, root, args, context, info) {
  try {
    const fieldNode = extractFieldNode(info, "hello");
    if (!fieldNode) {
      throw new Error("Missing field node for 'hello'");
    }

    return await serverContext.Query.hello({
      root,
      args,
      context,
      info: { ...info, fieldNodes: [fieldNode] },
    });
  } catch (error) {
    console.error(`Error resolving 'hello':`, error);
    throw new Error(`Failed to fetch 'hello' data: ${error.message}`);
  }
}

// Utility function to extract a specific field node from info
function extractFieldNode(
  info: GraphQLResolveInfo,
  fieldName: string
): FieldNode | undefined {
  for (const node of info.fieldNodes) {
    if (node.selectionSet) {
      for (const selection of node.selectionSet.selections) {
        if (selection.kind === "Field" && selection.name.value === fieldName) {
          return selection as FieldNode;
        }
      }
    }
  }
  return undefined;
}

export default resolvers;

You only need to handle the root nodes in the resolver, all nested nodes work fine.