Loaders question

[theMostCuriousHomunculus]

First of all, let me say thank you for this amazing project! Really impressed with how much server configuration gets abstracted away by mercurius, allowing me to just focus on my application features.

I do however have a question about loaders. Consider the following setup:

'use strict'

const Fastify = require('fastify')
const mercurius = require('..')

const app = Fastify()

const users = [{
  id: 1,
  enemies: [3, 4],
  friends: [2],
  name: 'Albert'
}, {
  id: 2,
  enemies: [3, 4],
  friends: [1],
  name: 'Boris'
}, {
  id: 3,
  enemies: [1, 2],
  friends: [4],
  name: 'Conrad'
}, {
  id: 4,
  enemies: [1, 2],
  friends: [3],
  name: 'David'
}]

const schema = `
  type User {
    id: ID!
    enemies: [User]
    friends: [User]
    name: String!
  }
  type Query {
    users: [Users]
  }
`

const resolvers = {
  Query: {
    users (_, params, { reply }) {
      return users;
    }
  }
}

const loaders = {
  User: {
    async enemies (queries, { reply }) {
      return queries
        .map(
          ({ obj }) => users
            .filter(
              (user) => obj
                .enemies
                .includes(
                  user.id
                )
            )
        );
    },
    async friends  (queries, { reply }) {
      return queries
        .map(
          ({ obj }) => users
            .filter(
              (user) => obj
                .friends
                .includes(
                  user.id
                )
            )
        );
    }
  }
}

app.register(mercurius, {
  schema,
  resolvers,
  loaders,
})

app.listen(3000)

Hopefully I understand the loaders syntax and this is indeed how it would look. My question is, since loaders are meant to reduce the number of round trips from the backend to the database, and both enemies and friends resolve to arrays of Users, aren't we making 2 round trips when we could theoretically make just 1 query to the Users collection/table and get back both enemies and friends in a single query? Do loaders already take care of that behind the scenes? Is there a better approach you would recommend? Or should the schema be changed so that there is only one field (perhaps "relationships") which resolves to [RelatedUser], where RelatedUser extends User and maybe has a "relation" property that can be either "enemy" or "friend"...? I feel like I'm missing something; please enlighten me! 😁

[mcollina]

The two calls are unavoidable as Mercurius can't know how enemies and friends are implemented. If you want to reduce them to one single database round trip, you'll need to implement this logic yourself in resolver.

[theMostCuriousHomunculus]

Thank you for your quick reply!

[trim21]

Graphql federation has a method __resolveReference to resolve object from ID, is it possible to have something like __resolveRoot to resolve a root object in mercurius loaders?

const loaders: MercuriusLoaders = {
  User: {
    async __resolveRoot(query, ctx): Promise<entity.User> {
      ...
    },

    async nickname(query, ctx) {
      return query.map(item=>item.obj.nickname)
    },

    async username(query, ctx) {
      return query.map(item=>item.obj.username)
    },

    async avatar(query, ctx) {
      return query.map(item=>item.obj.avatar)
    },

    async age(query, ctx) {
      return query.map(item=>item.obj.age)
    },
  },
};