Node.js 是否可以在Sequelize中对多态多对多模型进行紧急加载？

我有这个结构的目的是在Sequelize的多态多对多关联上实现急切加载

当给出选项include时，它会返回意外的结果（例如不属于此标签的食谱和帖子）

模型

//食品模型
食物。属于胃（models.Tag{
通过：{
型号：“tag_taggable”，
独特的：错误，
范围：{taggable_类型：“食品”}
},
外键：“taggable_id”，
约束条件：false
});

//配方模型
配方。属于配方（models.Tag{
通过：{
型号：“tag_taggable”，
独特的：错误，
作用域：{taggable_type:“配方”}
},
外键：“taggable_id”，
约束条件：false
});

//Post模型
Post.belongtomany（models.Tag、{
通过：{
型号：“tag_taggable”，
独特的：错误，
作用域：{taggable_type:“post”}
},
外键：“taggable_id”，
约束条件：false
});

//标记模型
标签。属于胃（模型、食物、{
通过：{
型号：“tag_taggable”，
唯一：错误
//范围：{taggable_类型：“食品”}
},
外键：“tag_id”，
约束条件：false
});
标签。属于名称（型号、配方、{
通过：{
型号：“tag_taggable”，
唯一：错误
//作用域：{taggable_type:“配方”}
},
外键：“tag_id”，
约束条件：false
});
Tag.belongtomany（models.Post、{
通过：{
型号：“tag_taggable”，
唯一：错误
//作用域：{taggable_type:“post”}
},
外键：“tag_id”，
约束条件：false
});
Tag.prototype.gettagables=异步函数（选项）{
const recipes=wait this.getRecipe（选项）；
const foods=wait this.getFood（选项）；
const posts=wait this.getPost（选项）；
返回岗位。海螺（食谱）。海螺（食品）；
}

//Tag\u Taggable连接模型
const taggable=sequelize.define(
“可标记的”，
{
id:{type:DataTypes.BIGINT，primaryKey:true，autoIncrement:true}，
tag_id:{type:DataTypes.BIGINT，unique:“tt_unique_constraint”}，
taggable_id:{type:DataTypes.BIGINT，unique:“tt_unique_constraint”，引用：null}，
taggable_类型：{type:DataTypes.STRING，unique:“tt_unique_constraint”}，
}
);

数据库 标记可标记记录：

询问 查询#1:查找所有标签，包括与急切加载相关的标签（食品、帖子、食谱）

SELECT 
    `Food`.`id`, 
    `Food`.`name`, 
    `tags`.`id` AS `tags.id`, 
    `tags`.`name` AS `tags.name`, 
    `tags->tag_taggable`.`taggable_id` AS `tags.tag_taggable.taggable_id`, 
    `tags->tag_taggable`.`tag_id` AS `tags.tag_taggable.tag_id` 
    
FROM 
    `food` AS `Food` 
    
LEFT OUTER JOIN `tag_taggable` AS `tags->tag_taggable` 
ON `Food`.`id` = `tags->tag_taggable`.`taggable_id` 

LEFT OUTER JOIN `tag` AS `tags` 
ON `tags`.`id` = `tags->tag_taggable`.`tag_id` 
AND `tags->tag_taggable`.`taggable_type` = 'food' WHERE `Food`.`id` = 2;

const tags=wait Tag.findAll({
包括：[
{model:db[“Food”]/*，必需：true*/}，
{model:db[“Post”]/*，必需：true*/}，
{model:db[“Recipe”]/*，必需：true*/}，
]
});
返回标记[0]；//找到的第一个标签

预计：只有食品（“汉堡包”、“培根”）和配方（“凯撒沙拉配方”）会出现

{ id:1 , name:"fast", foods: [ {hamburger}, {bacon} ], recipes: [ {caesar salad recipe} ], posts: [] }

输出

[
0: { 
id:1，
名称：“快”，
食物：[
{
名称：“汉堡包”，
标记id:1，
标签号：1
}, 
{
名字：“培根”，
标签编号：2，
标签号：1
} 
],
食谱：[
{
名称：“凯撒沙拉配方”，
标记id:1，
标签号：1
}, 
{
名称：“法式沙拉配方”，
标签编号：2，
标签号：1
} 
],
职位：[
{
姓名：“职位1”，
标记id:1，
标签号：1
}, 
{
姓名:"邮政2"，
标签编号：2，
标签号：1
} 
]
}
]

意外的#1 它显示了两篇文章和一个食谱，而不应该出现在标签fast中

当包含相关模型时，范围似乎不会影响内部联接（taggable_类型看起来像被忽略）

如果我在tags0上调用gettagables，我将获得数组中的预期项（但是这不是急于加载）

查询#2（反向）：查找与“bacon”关联的所有标记

const food=wait food.findOne({
其中：{id:2}，
包括：[
{ 
型号：db[“Tag”]//必需：true
}
]
});

期望

输出

{
id:2，
名字：“培根”，
标签：[
{
名称：“快”，
tag_taggable：{
标签编号：2，
标签号：1
}
}, 
{
名称：空
tag_taggable：{
标签编号：2，
标签编号：2
}
} 
]

意外的#2 它在标签include中包含了错误的模型（它在标签中包含了一个配方），显示为null（不知何故它是一个配方）

SQL 查询#1生成的一个错误sql查询：Tag.include（Food、Recipe、Post）

查询#2生成的第二个错误sql查询：Food.include（Tag）

包裹

"sequelize": "^6.3.4",
"sequelize-cli": "^6.2.0",
"sqlite3": "^5.0.0",

我如何处理这个模型，包括紧急加载情况

{ id:2, name:"bacon", tags:[ {fast} ] }

SELECT 
    `Tag`.`id`, 
    `Tag`.`name`, 
    `Tag`.`color`, 
    `Tag`.`created_at` AS `createdAt`, 
    `Tag`.`updated_at` AS `updatedAt`, 
    `foods`.`id` AS `foods.id`, 
    `foods`.`name` AS `foods.name`, 
    `foods->tag_taggable`.`taggable_id` AS `foods.tag_taggable.taggable_id`, 
    `foods->tag_taggable`.`tag_id` AS `foods.tag_taggable.tag_id`, 
    `recipes`.`name` AS `recipes.name`, 
    `recipes->tag_taggable`.`taggable_id` AS `recipes.tag_taggable.taggable_id`,
    `recipes->tag_taggable`.`tag_id` AS `recipes.tag_taggable.tag_id` 

FROM
    `tag` AS `Tag` 
    
LEFT OUTER JOIN `tag_taggable` AS `foods->tag_taggable` 
ON `Tag`.`id` = `foods->tag_taggable`.`tag_id` 

LEFT OUTER JOIN `food` AS `foods` 
ON `foods`.`id` = `foods->tag_taggable`.`taggable_id` 

LEFT OUTER JOIN `tag_taggable` AS `recipes->tag_taggable` 
ON `Tag`.`id` = `recipes->tag_taggable`.`tag_id` 

LEFT OUTER JOIN `recipe` AS `recipes` 
ON `recipes`.`id` = `recipes->tag_taggable`.`taggable_id`;

LEFT OUTER JOIN `tag_taggable` AS `post->tag_taggable` 
ON `Tag`.`id` = `posts->tag_taggable`.`tag_id` 

LEFT OUTER JOIN `post` AS `posts` 
ON `posts`.`id` = `posts->tag_taggable`.`taggable_id`;

SELECT 
    `Food`.`id`, 
    `Food`.`name`, 
    `tags`.`id` AS `tags.id`, 
    `tags`.`name` AS `tags.name`, 
    `tags->tag_taggable`.`taggable_id` AS `tags.tag_taggable.taggable_id`, 
    `tags->tag_taggable`.`tag_id` AS `tags.tag_taggable.tag_id` 
    
FROM 
    `food` AS `Food` 
    
LEFT OUTER JOIN `tag_taggable` AS `tags->tag_taggable` 
ON `Food`.`id` = `tags->tag_taggable`.`taggable_id` 

LEFT OUTER JOIN `tag` AS `tags` 
ON `tags`.`id` = `tags->tag_taggable`.`tag_id` 
AND `tags->tag_taggable`.`taggable_type` = 'food' WHERE `Food`.`id` = 2;

"sequelize": "^6.3.4",
"sequelize-cli": "^6.2.0",
"sqlite3": "^5.0.0",