How would I assign meal event guests per attendee per table per event at a conference in a GraphQL schema? - graphql

Question

I'm pondering a rebuild of a meal seating assignment app. I'll make use of GraphQL to query for attendees and their guests of a table at a meal event (assigned seating). The delivered data model looks something like this:
meal event 1
table A
attendee 1
guest 1
...
meal event 2
table L
attendee 1 (no guest this time)
...
An attendee may attend multiple meal events e.g. at a multi-day conference. That attendee may have a guest(s) at meal event(s). This could be another attendee record (two meal tickets, same info), noted as a guest however as an attendee and their guest(s) need to be seated at the same table (don't want spouse on other side of the room for example). Attendees will usually have the same guest(s) at multiple events, however not always due to cost or conflicting guest commitments or wanting to rotate guests per meal, etc.
How would I model this in a GraphQL schema? In the database I'd use join tables. However for client-facing GraphQL queries and schema types, I need to model this a bit differently (I think?). Here's what I have so far:
type Attendee {
name: String
** Can't add guests here as this may change per event
}
type Event {
name: String
tables: [Table]
}
type Table {
name: String
attendees: [Attendee]
** How do I "tree" in guests here for attendees for this table?
}
At this point do I need a join type to get guests per attendee per table per event?

Answer 1

When writing our server code, we typically encapsulate our business logic inside domain models like Event, Table, Attendee or Guest. However, these domain models don't have to have a strict one-to-one mapping with the tables we use to persist their data -- for example, an individual model might aggregate data from multiple tables.
Similarly, your GraphQL types do not have to have a one-to-one mapping to your domain models. It can often make sense to represent the same domain model as multiple types. For example, we can do something like:
type EventAttendee {
id: ID!
name: String!
}
type TableAttendee {
id: ID!
name: String!
guests: [Guest!]!
}
type Table {
id: ID!
attendees: [TableAttendee!]!
}
type Event {
id: ID!
name: String!
attendees: [EventAttendee!]!
tables: [Table!]!
}
Your schema effectively represents multiple graphs or views of your data. Depending on where on that graph your domain model ends up should determine what fields it exposes as a type -- in some contexts, exposing certain properties or relationships makes sense, in others it does not.