Hey there! Let’s break down exactly why you’re seeing that red error, and walk through practical solutions to get the filtered nested data you need.

The Root Cause #

When you run domestic_workers_nextofkin as a top-level query, your GraphQL schema allows the where parameter because the root resolver for that field is built to handle filtering.

But when you nest it under domestic_workers_relationships, the problem is:

• Your schema does not expose a where parameter for the domestic_workers_nextofkin field when it’s a child of domestic_workers_relationships.
• This usually happens because the backend (like Hasura, which your query syntax strongly suggests you’re using) hasn’t been configured to allow filtering on that specific nested association, or the resolver for the nested field doesn’t support filtering logic.

Fixes to Try #

Option 1: Configure Your Backend (If Using Hasura) #

Since your query style matches Hasura’s auto-generated schema, here’s how to enable filtering on the nested field:

1. Open your Hasura Console and go to Data → Schema.
2. Find the domestic_workers_relationships type in the schema browser.
3. Look for the domestic_workers_nextofkin field under it. Check if it has the where parameter enabled.
4. If not, go to Data → Relationships and verify the association between domestic_workers_relationships and domestic_workers_nextofkin. Ensure that filtering permissions are enabled for this nested field in your role’s permissions settings.
5. Refresh your schema, and the where parameter should now work in the nested query.

Option 2: Restructure Your Query (No Backend Changes Needed) #

If you can’t modify the backend schema, split your query to fetch the filtered domestic_workers_nextofkin as a top-level field, then associate it with your main query data on the frontend:

query User($userId: Int) {
  # Fetch filtered nextofkin first, linked to the user's data
  filteredNextofkin: domestic_workers_nextofkin(
    where: {
      archived: {_is_null: true},
      domestic_workers_relationships: {
        domestic_workers_workers: {
          users_user: {id: {_eq: $userId}}
        }
      }
    }
  ) {
    full_name
    mobile_phone1
    domestic_workers_relationships {
      id # Use this ID to match with relationships in the main query
      relationship
    }
  }

  # Your original main query (remove the filtered nested nextofkin part)
  users_user(where: {id: {_eq: $userId}}) {
    domestic_workers_pictures(order_by: {id: desc}, limit: 1) { id }
    id
    password
    username
    # ... keep all your other existing fields ...
    domestic_workers_workers {
      domestic_workers_pictures(order_by: {id: desc}, limit: 1) { id }
      # ... keep all your other worker fields ...
      domestic_workers_relationships {
        id # Match this ID to filteredNextofkin's relationship ID
        payment
        payment_currency
        # ... keep all your other relationship fields ...
        # Remove the problematic nested domestic_workers_nextofkin here
      }
      # ... keep your other worker-related fields ...
    }
  }
}

Then, on your frontend, you can map the filteredNextofkin entries to their corresponding domestic_workers_relationships using the shared id field.

Option 3: Modify the Backend Resolver (Custom GraphQL APIs) #

If you’re using a custom GraphQL backend (not Hasura), you’ll need to update the schema definition for the domestic_workers_relationships type to include a where parameter for the domestic_workers_nextofkin field, then update the resolver to handle that filtering logic. For example:

# Update your schema
type DomesticWorkersRelationship {
  # ... existing fields ...
  domestic_workers_nextofkin(where: NextofkinFilterInput): [DomesticWorkersNextofkin]
}

Then adjust the resolver to apply the where filter when fetching the nested nextofkin records.

Final Notes #

The key takeaway is that GraphQL field parameters (like where) are defined per field in your schema—just because a top-level field supports filtering doesn’t mean its nested counterpart does. Choose the fix that best fits your ability to modify the backend or adjust your frontend logic.

内容的提问来源于stack exchange，提问作者maykhid