Errored field should return null, is instead causing the entire query to return null

[twiclo]

Here's my query:

{
  users {
    username
    name {
      first,
      last
    },
    team {
      supervisor {
        username
      }
    }
  }
}

And the response:

{
  "data": null,
  "errors": [
    {
      "message": "Sqlx error: no rows returned by a query that expected to return at least one row",
      "locations": [
        {
          "line": 8,
          "column": 5
        }
      ],
      "path": [
        "users",
        "team"
      ]
    }
  ]
}

Since not all users are on a team I would expect to get all users back and just have the team section be null. Here's the code:

#[derive(Serialize, Debug)]
pub struct User {
  pub user_id: i32,
  pub username: String,
  pub first_name: String,
  pub middle_name: Option<String>,
  pub last_name: String,
  pub role_id: i32,
  pub status_id: i32,
  pub date_created: NaiveDateTime,
  pub is_employee: bool
}

#[derive(Serialize, Debug)]
pub struct Team {
  pub team_id: i32,
  pub name: String,
  pub supervisor_id: i32,
  pub role_id: i32,
}

#[graphql_object(context = Context)]
impl User {
  #[graphql(name="id")]
  fn user_id(&self) -> i32 { self.user_id }
  fn username(&self) -> String { self.username.clone() }
  fn name(&self) -> Name {
    Name {
      first: self.first_name.clone(),
      middle: self.middle_name.clone(),
      last: self.last_name.clone(),
    }
  }
  async fn team(&self, ctx: &Context) -> FieldResult<Team> {
    Ok(Team::get_users_team(validate_perm(&ctx.user.perms)?, ctx, self.user_id).await?)
  }
  ///A predefined list of permissions
  async fn role(&self, ctx: &Context) -> FieldResult<String> {
    sqlx::query_scalar!("select name from role where role_id = $1", self.role_id)
      .fetch_one(&ctx.pool).await
      .map_err(|e: sqlx::Error| e.into())
  }
  fn date_created(&self) -> NaiveDateTime { self.date_created }
  fn is_employee(&self) -> bool { self.is_employee }
}

impl Team {
  pub async fn get_users_team(_: Grant<ReadAnyTeam>, ctx: &Context, user_id: i32) -> Result<Self, CustomError> {
    Ok(sqlx::query_as!(
      Self,
      "select team.* from team
        join user_team using(team_id)
        where user_id = $1",
      user_id).fetch_one(&ctx.pool).await?)
  }

[tyranron]

@twiclo your User.team field cannot be null, because you've declared it as non-nullable type in the schema.

To make it nullable, you should declare the computable field to return the nullable type:

#[graphql_object(context = Context)]
impl User {
  async fn team(&self, ctx: &Context) -> FieldResult<Option<Team>> {
    // and return `Ok(None)` whenever you want to return `null`
  }
}

Or if you want to turn any error into null (which I don't recommend), just don't use the Result, only Option:

#[graphql_object(context = Context)]
impl User {
  async fn team(&self, ctx: &Context) -> Option<Team> {
    Ok(Team::get_users_team(validate_perm(&ctx.user.perms).ok()?, ctx, self.user_id).await.ok()?)
  }
}

[twiclo]

Why would you not recommend an errored field returning null? Would that hide the error?

[tyranron]

@twiclo yes. Something like that. Usually, you have to type of errors: expected (like there is no user/team found) and unexpected (like, database is down, code panicking, or anything else). It' s OK to return null for expected errors according to the desired query semantics, but returning null for unexpected errors - is simply lying to the client side, as it may consider that a user/group doesn't exist (or a user doesn't participate in group), while in fact he does, and the matter was in some sporadic net error or similar. It's the same as instead of returning "500 Internal server error" on HTTP server we would always return "404 Not Found". After 404 the client may stop doing request and show the incorrect information, but with 500 it will report about backend error and retry with backoff.