suggestion on integration approach

[lsfera]

Hello, I'm working on a POC to introduce mesh/federation, looking for some advice on integration approach.
Here's a brief summary of one of the first use cases I'm gonna solve:

Having a .meshrc.yaml configuration file with two sources

sources:
  - name: orderapi
    handler:
      graphql:
        endpoint: '{env.ORDER_API_ENDPOINT}'
  - name: catalog
    handler:
      openapi:
        source: '{env.PRODUCT_API_ENDPOINT}/swagger'
        endpoint: '{env.PRODUCT_API_ENDPOINT}'

the merged schema provides the following queries:

query{
 getOrderDetails(tenant:String!, orderNumber:String!) {
    tenant
    ....
    orderLines{
      product{
        productId
      }    
    }
  }
}

getProductDetails(tenant: String! productId: [String]!): [CatalogItem]

being OrderLine.product field of OrderItem type

My goal is to:

• merge the OrderItem and CatalogItem types into a (new?) Product type within the OrlerLine.product field;
• batch resolving catalog schema getProductDetails calls ( hence avoiding the N+1 issue)

I learned that custom resolvers are not design to deal with compound keys ( the tenant arg/field does not belong to OrderLine root).
Reading the documentation it looks like the proper way to deal with such use case is moving to custom resolvers via dataloader but I'm still trying to figure out out the various pieces are glued together.

Any advice would be appreciated
Thanks

[lsfera]

Not sure if I ended up with the best approach but it's working as intended - good enough for now.

I manually extended the Product Type with additional fields from CatalogItem ( somewhat concerning for code maintenance ) through the extend directive.
I'll let the resolver here hoping to gather some feedback.

import type { CatalogItem, MeshContext, OrderDetails, Resolvers, } from ".mesh";

const cache = new WeakMap();
const key = {};

const resolvers: Resolvers = {
  Query: {
    getOrderDetails: {
      selectionSet:
        `{
            orderNumber
            tenant
        }`,
      resolve: async (root, args, context, info) => {
        const { tenant, orderNumber } = args;
        const order: OrderDetails = await context.orders.Query.getOrderDetails(
          {
            root,
            args: {
              orderNumber,
              tenant
            },
            context,
            info,
          });
        cache.set(key, tenant);
        return order;
      },
    }
  },
  OrderLine: {
    product: {
      selectionSet:
        `{
            productId
            tenant
         }`,
      resolve: async (root, _args, context: MeshContext, info) => {
        const item: CatalogItem[] = await context.catalog.Query.getProductDetails({
          root,
          args: {
            gtin: root.product.gtin,
            tenant: cache.get(key)
          },
          context,
          info,
          // batching
          key: root.product.gtin,
          argsFromKeys: productId => ({ productId, tenant: cache.get(key) }),
        });
        return { ...root.product, ...item };
      }
    }
  }
}
export default resolvers;

Cheers