What to use interface or union?

Users GraphQL
#1

Hello,
[BACKGROUND]
So we have such a schema

interface Node {
	id: String! @id
}

interface Thing {
	name: String! @search(by:[fulltext])
	description: String @search(by:[fulltext])
}

interface Member{
	id: ID!
	member: [Member!]
	memberOf: [Member!] @hasInverse(field: member)
}

type Person implements Thing & Member{
	email: String! @search(by:[fulltext]) @id
}

type Organization implements Thing & Member{
	vatID: String
}

type Brand implements Thing & Member {
	aggregateRating: Float
}

And now I have query

queryPerson {
        id
        email
        name,
        memberOf {
            id
            ... on Thing {
                name
            }
        }
    }

Runs smoothly.
But what if I would like to filter members by name? It is not in Member interface but is in Thing.
I cannot add name property to Member because it will fail as types inhertis from Thing and Member.
So such query is impossible

queryPerson {
        id
        email
        name,
        memberOf(filter: { name: { anyofterms: "test" } }) {
            id
            ... on Thing {
                name
            }
        }
    }

.
Seems like union here would be better option as it generates filter you can specify per type.
But union cannot have @hasInverse attribute and I feel it inconvenient.

So I am missing probably interface inhertiance but maybe you could guide me and change way of thinking, please.

#2

Why not combine Thing and Member into a single interface if every type that implements one of them always implements the other? This is true with the schema you provided, but maybe you have more schema than provided.

To get the API you desire, you may have to relax some of the required ! fields and combine the interfaces together.

#3

Why not combine Thing and Member into a single interface if every type that implements one of them always implements the other? This is true with the schema you provided, but maybe you have more schema than provided.

Yes, you answered to yourself. I can have ofr example type Poduct that is only Thing.

To get the API you desire, you may have to relax some of the required ! fields and combine the interfaces together.

Removed ! in Thing near name, and copied it to Member.
I got

{
    "errors": [
        {
            "message": "resolving updateGQLSchema failed because input:12: Field Person.name can only be defined once.\n (Locations: [{Line: 3, Column: 4}])",
            "extensions": {
                "code": "Error"
            }
        }
    ]
}
#4

What I mean is that you may have to combine Member and Thing into a single interface instead of two different interfaces to get what you wish. Unless you want to write a slew of custom queries and mutations to do what you want and lose a bunch of the extra stuff that is also available. You will have to compromise somewhere most likely.

#5

Yes, it is not completely like object-oriented.
I like concept of union but I would like to have possibility for @hasInverse to potentially not having to do mutation update twice.