GraphQl/Sequalize combine multiple hasMany/BelongsToMany in single list - graphql

Question

I'm currently working on a project where I have players playing games against each-other in a 1v1 or 2v2 concept.
So I created the following 2 sequelize classes:
player.js
export class Player extends Model {
static init(sequelize, DataTypes) {
return super.init(
{
id: {
type: DataTypes.INTEGER,
primaryKey: true
},
createdAt: DataTypes.DATE,
updatedAt: DataTypes.DATE,
gender: DataTypes.STRING,
firstName: DataTypes.STRING,
lastName: DataTypes.STRING
},
{
sequelize
}
);
}
// Associations
static associate() {
this.games1 = this.hasMany(Game, { as: 'player1_team1', foreignKey: 'player1Team1Id' });
this.games2 = this.hasMany(Game, { as: 'player1_team2', foreignKey: 'player1Team2Id' });
this.games3 = this.hasMany(Game, { as: 'player2_team1', foreignKey: 'player2Team1Id' });
this.games4 = this.hasMany(Game, { as: 'player2_team2', foreignKey: 'player2Team2Id' });
}
}
game.js
export class Game extends Model {
static init(sequelize, DataTypes) {
return super.init(
{
id: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true
},
createdAt: DataTypes.DATE,
updatedAt: DataTypes.DATE,
playedAt: DataTypes.DATE,
set1_team1: {
type: DataTypes.INTEGER,
allowNull: true
},
set1_team2: {
type: DataTypes.INTEGER,
allowNull: true
},
set2_team1: {
type: DataTypes.INTEGER,
allowNull: true
},
set2_team2: {
type: DataTypes.INTEGER,
allowNull: true
},
set3_team1: {
type: DataTypes.INTEGER,
allowNull: true
},
set3_team2: {
type: DataTypes.INTEGER,
allowNull: true
}
},
{
sequelize
}
);
}
// Associations
static associate() {
this.player1_team1 = this.belongsTo(Player, {
as: 'player1_team1',
foreignKey: 'player1Team1Id'
});
this.player1_team2 = this.belongsTo(Player, {
as: 'player1_team2',
foreignKey: 'player1Team2Id'
});
this.player2_team1 = this.belongsTo(Player, {
as: 'player2_team1',
foreignKey: 'player2Team1Id'
});
this.player2_team2 = this.belongsTo(Player, {
as: 'player2_team2',
foreignKey: 'player2Team2Id'
});
}
}
Then the following scheme for GraphQl
gql`
type Player {
id: ID!
firstName: String!
lastName: String!
games: [Game]
}
type Game {
id: ID!
player1_team1: Player!
player1_team2: Player!
player2_team1: Player!
player2_team2: Player!
}
type Query {
player(id: ID!): Player
}
`
Now I'm trying to have when you query for the Player that you get all the games whether he is player1_team1, player2_team2...
But i'm a bit blocked on figuring out how to do this :/
I tried adding getGames() that combined the 4 arrays to my class, but I didn't find how to call this method
getGames() {
return [...this.games1, ...this.games2, ...this.games3, ...this.games4];
}
I tried searching for a way that you could query with a alias that combines the 4 childs (player1_team1...) but with no success (still new in GraphQl)
Could anyone help me out?

Answer 1

Game is a class. Calling new Game or a static method like Game.create generates an instance of the class. So we have
const Game = require('the location of the model')
const game = new Game()
In this example, static methods will be available on the Game variable because they apply to the class, not an instance of that class. Likewise, non-static methods you define inside the class will be available on instance and not the class (i.e. the game variable).
The hasMany method creates an association between the two models and returns an instance of the HasMany class. By writing this:
this.games1 = this.hasMany(Game, { ... })
you are setting the games1 static property because you are doing this inside a static method. As a result, the property is available on the class, not the instance. Saving the resulting association object to a static property can be helpful, not it's also not necessary. You could just as easily do:
this.hasMany(Game, { ... })
The important bit is that by calling hasMany, you are actually creating a getter on instances of the class. In this case, the 4 getters will be named getPlayer1_team1, getPlayer2_team1, getPlayer1_team2 and getPlayer2_team2 based on the alias you provided (the as parameter).
So you can add a method like:
async getGames() {
const [games1, games2, games3, games4] = await Promise.all([
this.getPlayer1_team1(),
this.getPlayer1_team2(),
this.getPlayer2_team1(),
this.getPlayer2_team2(),
])
return [...this.games1, ...this.games2, ...this.games3, ...this.games4]
}
and then call it from some instance:
const player = await Player.findByPk(1)
const games = await Player.getGames()
If your schema exposes a games field on the Player type, you can just do this in the resolver for the field:
function resolve(parent, args, context, info) {
return parent.getGames()
}
Alternatively...
You can lazy load the associated models and get the games when you fetch the player. This is generally more efficient than fetching the player and then fetching the games. So when fetching the player, you can do something like:
const player = await Player.findByPk(1, {
include: [
{ as: 'player1_team1', model: Game },
{ as: 'player1_team2', model: Game },
{ as: 'player2_team1', model: Game },
{ as: 'player2_team2', model: Game },
]
})
Note: it's important to include the same as value that you used when you defined the association. The resulting player variable will now have 4 properties on it for the associated games (player1_team1, player1_team2, etc.).
Provided you lazy load the associated Games like this when fetching instances of Player, you can now do something like this to resolve your games field in GraphQL:
function resolve(parent, args, context, info) {
return [
...parent.player1_team1,
...parent.player1_team2,
...parent.player2_team1,
...parent.player2_team2,
]
}