nodejs + sequelize :: include where required false - node.js

Question

i have the following hierarchy of objects:
user
parent (hasOne)
children (hasMany)
once i have a user object, im attempting to load the associated parent object along with some of its children. the following works:
user.getParent({
include: [{
model: Child
}]
}).then(function(parent) {
var children = parent.children;
});
but if i want to selectively load some of the parent's children, like so:
user.getParent({
include: [{
model: Child,
where: { gender: 'FEMALE' }
}]
}).then(function(parent) {
var daughters = parent.daughters;
});
if the parent has one or more daughters, the query works and i get the parent data along with all daughters' data. however, if the parent has only sons, the parent object returned is null..
i want that if the parent has no daughters, the parent object should still be resolved with children = null or children = []..
also, if i wanted to simply load a count of children while loading the parent, how can i go about doing that?
thanks

Answer 1

it turned out to be an issue with my own code.. sequelize fails to load a model if a nested include has a where clause that returns no models.. to ensure it doesnt fail completely, you can set a required: false clause along with the where clause.. this makes sequelize return a blank array instead of failing the load completely..
more info at https://github.com/sequelize/sequelize/issues/4019

Answer 2

required: false + where is inconsistent/buggy in sequelize 6.5.1 SQLite vs PostgreSQL
Edit: it was working fine as of sequelize v6.13.0, so it got fixed somewhere along the way.
This is one of the many many many Sequelize association bugs/inconsistencies that make me want to try and find another ORM at some point. Reported at: https://github.com/sequelize/sequelize/issues/13809
Consider the following example where we want to:
list all tags
in addition, determine if each tag has been assigned to a selected animal
Our where condition on the animal then is a simple "check if the animal is a specific animal", and can only return 0 or 1 entries therefore. But the same would be valid with any other more complex condition.
main.js
#!/usr/bin/env node
const assert = require('assert')
const path = require('path')
const { DataTypes, Sequelize } = require('sequelize')
let sequelize
if (process.argv[2] === 'p') {
sequelize = new Sequelize('tmp', undefined, undefined, {
dialect: 'postgres',
host: '/var/run/postgresql',
})
} else {
sequelize = new Sequelize({
dialect: 'sqlite',
storage: 'tmp.sqlite'
})
}
;(async () => {
const Animal = sequelize.define('Animal', {
species: { type: DataTypes.STRING },
})
const Tag = sequelize.define('Tag', {
name: { type: DataTypes.STRING },
})
Animal.belongsToMany(Tag, { through: 'AnimalTag' })
Tag.belongsToMany(Animal, { through: 'AnimalTag' })
await sequelize.sync({force: true})
const animal0 = await Animal.create({ species: 'bat' })
const animal1 = await Animal.create({ species: 'ant' })
const animal2 = await Animal.create({ species: 'dog' })
const tag0 = await Tag.create({ name: 'mammal' })
const tag1 = await Tag.create({ name: 'flying' })
const tag2 = await Tag.create({ name: 'aquatic' })
await animal0.addTag(tag0)
await animal0.addTag(tag1)
await animal2.addTag(tag1)
const animals = [animal0, animal1, animal2]
for (let animal of animals) {
let rows
rows = await Tag.findAll({
include: [{
model: Animal,
where: { id: animal.id },
// No effect.
//on: { id: animal.id },
through: {
// Same as putting the where outside of through.
//where: { AnimalId: animal.id },
},
required: false,
}],
order: [['name', 'ASC']],
})
console.error(animal.species);
console.error(rows.map(row => { return {
name: row.name,
animals: row.Animals.map(animal => animal.species),
} }))
}
})().finally(() => { return sequelize.close() })
package.json
{
"name": "tmp",
"private": true,
"version": "1.0.0",
"dependencies": {
"pg": "8.5.1",
"pg-hstore": "2.3.3",
"sequelize": "6.5.1",
"sqlite3": "5.0.2"
}
}
Run:
npm install
./main.js p
./main.js
The PotsgreSQL results are as expected:
bat
[
{ name: 'aquatic', animals: [] },
{ name: 'flying', animals: [ 'bat' ] },
{ name: 'mammal', animals: [ 'bat' ] }
]
ant
[
{ name: 'aquatic', animals: [] },
{ name: 'flying', animals: [] },
{ name: 'mammal', animals: [] }
]
dog
[
{ name: 'aquatic', animals: [] },
{ name: 'flying', animals: [] },
{ name: 'mammal', animals: [ 'dog' ] }
]
But the SQLite results are just plain wrong:
bat
[
{ name: 'aquatic', animals: [] },
{ name: 'flying', animals: [ 'bat' ] },
{ name: 'mammal', animals: [ 'bat', null ] }
]
ant
[
{ name: 'aquatic', animals: [] },
{ name: 'flying', animals: [] },
{ name: 'mammal', animals: [] }
]
dog
[
{ name: 'aquatic', animals: [] },
{ name: 'flying', animals: [] },
{ name: 'mammal', animals: [] }
]
I don't mind the null that much, I can work around that.
But dog not being a mammal, that I cannot work around.
Underlying queries
We can look at the underlying queries to guess what is going on.
PostgreSQL has queries of type:
SELECT
"Tag"."name",
"Animals"."species" AS "Animals.species",
FROM
"Tags" AS "Tag"
LEFT OUTER JOIN (
"AnimalTag" AS "Animals->AnimalTag"
INNER JOIN "Animals" AS "Animals" ON "Animals"."id" = "Animals->AnimalTag"."AnimalId"
) ON "Tag"."id" = "Animals->AnimalTag"."TagId"
AND "Animals"."id" = 1
ORDER BY
"Tag"."name" ASC;
SQLite has queries of type:
SELECT
`Tag`.`name`,
`Animals`.`species` AS `Animals.species`
FROM `Tags` AS `Tag`
LEFT OUTER JOIN `AnimalTag` AS `Animals->AnimalTag`
ON `Tag`.`id` = `Animals->AnimalTag`.`TagId`
LEFT OUTER JOIN `Animals` AS `Animals`
ON `Animals`.`id` = `Animals->AnimalTag`.`AnimalId`
AND `Animals`.`id`= 3
ORDER BY
`Tag`.`name` ASC;
So only the PostgreSQL query is the desired one because of the way it uses the subquery so that the:
ON "Tag"."id" = "Animals->AnimalTag"."TagId"
AND "Animals"."id" = 1
gets applied only to the outer LEFT OUTER JOIN.
The SQLite query produces undesired results, running it manually for each animal we get outputs:
bat
aquatic|
flying|bat
mammal|bat
mammal|
ant
aquatic|
flying|
mammal|
mammal|
dot
aquatic|
flying|
mammal|
mammal|dog
so what seems to happen is that the animal first result is null, then sequelize ignores it on the return, which would explain why we saw:
{ name: 'mammal', animals: [ 'bat', null ] }
for bat but:
{ name: 'mammal', animals: [] }
for dog.
The desired statement would have the AND on the first LEFT OUTER JOIN:
SELECT
`Tag`.`name`,
`Animals`.`species` AS `Animals.species`
FROM `Tags` AS `Tag`
LEFT OUTER JOIN `AnimalTag` AS `Animals->AnimalTag`
ON `Tag`.`id` = `Animals->AnimalTag`.`TagId`
AND `Animals->AnimalTag`.`AnimalId`= 1
LEFT OUTER JOIN `Animals` AS `Animals`
ON `Animals`.`id` = `Animals->AnimalTag`.`AnimalId`
ORDER BY
`Tag`.`name` ASC;
Workaround: super many to many
The best workaround I could come up so far is to use super many to many, this is often a good bet when the problem is that we need greater control about ON conditions:
#!/usr/bin/env node
const assert = require('assert')
const path = require('path')
const { DataTypes, Sequelize } = require('sequelize')
let sequelize
let logging = process.argv[3] === '1'
if (process.argv[2] === 'p') {
sequelize = new Sequelize('tmp', undefined, undefined, {
dialect: 'postgres',
host: '/var/run/postgresql',
logging,
})
} else {
sequelize = new Sequelize({
dialect: 'sqlite',
storage: 'tmp.sqlite',
logging,
})
}
;(async () => {
const AnimalTag = sequelize.define('AnimalTag')
const Animal = sequelize.define('Animal', {
species: { type: DataTypes.STRING },
})
const Tag = sequelize.define('Tag', {
name: { type: DataTypes.STRING },
})
AnimalTag.belongsTo(Animal)
Animal.hasMany(AnimalTag)
AnimalTag.belongsTo(Tag)
Tag.hasMany(AnimalTag)
Animal.belongsToMany(Tag, { through: AnimalTag })
Tag.belongsToMany(Animal, { through: AnimalTag })
await sequelize.sync({force: true})
const animal0 = await Animal.create({ species: 'bat' })
const animal1 = await Animal.create({ species: 'ant' })
const animal2 = await Animal.create({ species: 'dog' })
const tag0 = await Tag.create({ name: 'flying' })
const tag1 = await Tag.create({ name: 'mammal' })
const tag2 = await Tag.create({ name: 'aquatic' })
await animal0.addTag(tag0)
await animal0.addTag(tag1)
await animal2.addTag(tag1)
const animals = [animal0, animal1, animal2]
for (let animal of animals) {
let rows
rows = await Tag.findAll({
include: [{
model: AnimalTag,
where: { AnimalId: animal.id },
required: false,
include: [{
model: Animal,
}]
}],
order: [['name', 'ASC']],
})
console.error(rows.map(row => { return {
name: row.name,
animals: row.AnimalTags.map(animalTag => animalTag.Animal.species)
} }))
console.error();
}
})().finally(() => { return sequelize.close() })
produces the correct output for both PostgreSQL and Sequelize. The produced query is exactly what we wanted:
SELECT
"Tag"."id",
"Tag"."name",
"Tag"."createdAt",
"Tag"."updatedAt",
"AnimalTags"."createdAt" AS "AnimalTags.createdAt",
"AnimalTags"."updatedAt" AS "AnimalTags.updatedAt",
"AnimalTags"."AnimalId" AS "AnimalTags.AnimalId",
"AnimalTags"."TagId" AS "AnimalTags.TagId",
"AnimalTags->Animal"."id" AS "AnimalTags.Animal.id",
"AnimalTags->Animal"."species" AS "AnimalTags.Animal.species",
"AnimalTags->Animal"."createdAt" AS "AnimalTags.Animal.createdAt",
"AnimalTags->Animal"."updatedAt" AS "AnimalTags.Animal.updatedAt"
FROM
"Tags" AS "Tag"
LEFT OUTER JOIN "AnimalTags" AS "AnimalTags" ON "Tag"."id" = "AnimalTags"."TagId"
AND "AnimalTags"."AnimalId" = 3
LEFT OUTER JOIN "Animals" AS "AnimalTags->Animal" ON "AnimalTags"."AnimalId" = "AnimalTags->Animal"."id"
ORDER BY
"Tag"."name" ASC;
Tested on Ubuntu 21.10, PostgreSQL 13.5.