make Federation + Dataloader work

[Boshen]

When Apollo Gateway sends something like

  query Query {
    _entities(representations: [{__typename:"User", userId:1},{__typename:"User", userId:2}]) {
      ...on User {
        userId
      }
    }
  }

dataloader inside #[graphql(entity)] is not working at the moment.

I guess the relevant code is here, but I couldn't investigate no further..:

                for item in representations {
                    res.push(
                        self.inner.find_entity(ctx, &item.0).await?.ok_or_else(|| {
                            ServerError::new("Entity not found.").at(ctx.item.pos)
                        })?,
                    );
                }

[sunli829]

I'll check this out tomorrow.😄

[sunli829]

I added an example:

async-graphql/tests/federation.rs

Line 155 in 1e6ae23

pub async fn test_find_entity_with_context() {

[Boshen]

@sunli829 I think you need to check the keys, otherwise your test passes despite dataloader malfunctioning:

        async fn load(&self, keys: &[ID]) -> Result<HashMap<ID, Self::Value>, Self::Error> {
            assert_eq!(
                vec![ID::from("1"), ID::from("2"), ID::from("3"), ID::from("4")],
                keys
            );
           ...
        }

I'm still learning async rust, but after some debugging it seems Delay::new(self.delay).await; inside dataloader.load_manyis not blocking inside the for item in representations loop

[Boshen]

Using join_all worked:

                let representations: Vec<Any> = ctx.param_value("representations", None)?;
                let res = join_all(
                    representations
                        .iter()
                        .map(|item| self.inner.find_entity(ctx, &item.0)),
                )
                .await
                .into_iter()
                .map(|item| {
                    item.unwrap()
                        .ok_or_else(|| ServerError::new("Entity not found.").at(ctx.item.pos))
                        .unwrap()
                })
                .collect();
                return Ok(Some(Value::List(res)));
            }

But I guess there is a better way ...

[sunli829]

Using join_all worked:

                let representations: Vec<Any> = ctx.param_value("representations", None)?;
                let res = join_all(
                    representations
                        .iter()
                        .map(|item| self.inner.find_entity(ctx, &item.0)),
                )
                .await
                .into_iter()
                .map(|item| {
                    item.unwrap()
                        .ok_or_else(|| ServerError::new("Entity not found.").at(ctx.item.pos))
                        .unwrap()
                })
                .collect();
                return Ok(Some(Value::List(res)));
            }

But I guess there is a better way ...

It is indeed better to use join_all, thank you for your suggestion. 🙂

[sunli829]

Released in v2.5.11

[Boshen]

🌹