Node.JS:Sequelize 关联集无法恢复对偏执狂的记录

Question

我有 2 个模型 users 和 tags ，两者都通过另一个名为 usersTags 的模型关联，并且所有 3 个模型都设置了带有自定义时间戳的偏执。我知道关联模型将添加额外的方法来处理所有关联模型的关联，所以我想为用户进行一个简单的 setTags 调用，文档显示如果在方法中的数组中不包含元素存储在数据库中它应该被删除，否则它应该被创建/恢复。

所以我尝试恢复以前删除的 tag 但由于某种原因它失败了。模型定义如下:

用户

module.exports = function(sequelize, DataTypes) {
    const Users = sequelize.define("users", {
        id: {
            type: DataTypes.INTEGER(11),
            allowNull: false,
            primaryKey: true,
            autoIncrement: true
        },
        username: {
            type: DataTypes.STRING(100),
            allowNull: false,
            validate: {
                len: {
                    args: [3, 100],
                    msg: "String length is not in this range"
                }
            }
        },
        password: {
            type: DataTypes.STRING(100),
            allowNull: false,
            field: "password_hash"
        }
    }, {
        tableName: "users",
        createdAt: "create_time",
        updatedAt: "update_time",
        deletedAt: "delete_time",
        paranoid: true
    });

    Users.associate = function(models) {
        // Add this association to include tag records
        this.belongsToMany(models.tags, {
            through: {
                model: models.usersTags,
                unique: true
            },
            foreignKey: "users_id",
            constraints: false
        });
    };

    return Users;
};

标签

module.exports = function(sequelize, DataTypes) {
    const Tags = sequelize.define("tags", {
        id: {
            type: DataTypes.INTEGER(11),
            allowNull: false,
            primaryKey: true,
            autoIncrement: true
        },
        name: {
            type: DataTypes.STRING(45),
            allowNull: false
        }
    }, {
        tableName: "tags",
        createdAt: "create_time",
        updatedAt: "update_time",
        deletedAt: "delete_time",
        paranoid: true
    });

    Tags.associate = function(models) {
        this.belongsToMany(models.users, {
            through: {
                model: models.usersTags,
                unique: true
            },
            foreignKey: "tags_id",
            constraints: false
        });
    };

    return Tags;
};

用户标签

module.exports = function(sequelize, DataTypes) {
    const UsersTags = sequelize.define("usersTags", {
        users_id: {
            type: DataTypes.INTEGER(11),
            allowNull: false,
            primaryKey: true,
            references: {
                model: "users",
                key: "id"
            }
        },
        tags_id: {
            type: DataTypes.INTEGER(11),
            allowNull: false,
            primaryKey: true,
            references: {
                model: "tags",
                key: "id"
            }
        }
    }, {
        tableName: "users_tags",
        createdAt: "create_time",
        updatedAt: "update_time",
        deletedAt: "delete_time",
        paranoid: true,
        indexes: [
            {
                unique: true,
                fields: ["users_id", "tags_id"]
            }
        ]
    });

    return UsersTags;
};

测试

let _user;

models.users.findOne({where: {id: 100}})
    .then(user => {
        _user = user;

        return _user.setTags([1]);          // Successfully create association tag with id 1
    })
    .then(() => _user.setTags([]))   // Successfully remove all associated tags
    .then(() => _user.setTags([1])); // Should restore association tag with id 1 but fails

执行的查询

app:database Executing (default): SELECT `id`, `username`, `first_name`, `last_name`, `birthday`, `description`, `location`, `email`, `type`, `image_path` FROM `users` AS `users` WHERE ((`users`.`delete_time` > '2018-08-28 19:40:15' OR `users`.`delete_time` IS NULL) AND `users`.`id` = 100); +0ms
app:database Executing (default): SELECT `users_id`, `tags_id`, `create_time`, `update_time`, `delete_time` FROM `users_tags` AS `usersTags` WHERE ((`usersTags`.`delete_time` > '2018-08-28 19:40:15' OR `usersTags`.`delete_time` IS NULL) AND `usersTags`.`users_id` = 100); +6ms
app:database Executing (default): INSERT INTO `users_tags` (`users_id`,`tags_id`,`create_time`,`update_time`) VALUES (100,1,'2018-08-28 19:40:15','2018-08-28 19:40:15'); +7ms

由于某种原因，标签搜索查询无法检索包含 delete_time 集的标签，因此最后一个查询是 insert 而不是 update ，我知道解决方法是将 paranoid 设置为 false 但我必须跟踪所有事件，我知道另一种解决方法是创建一个自定义模型方法来处理这个问题，但我仍然想知道是否有一种方法可以实现这一点而无需创建一个额外的自定义方法

Answer 1

您的代码的异步顺序不正确，因此您的 _user 全局变量未启动，我认为这是正确的顺序:

let _user;

models.users.findOne({where: {id: 100}})
.then(user => {
    _user = user;
    _user.setTags([]).then(()=>{
        _user.setTags([1])
    })
})