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;
};

usersTags

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，我知道解决方法是设置{{ 1}}为假，但我必须跟踪所有活动，我知道另一种解决方法是创建一个自定义模型方法来处理此问题，但我仍然想知道是否有一种方法可以实现这一目标而不必创建其他方法自定义方法

Answer 1

您的代码未按照正确的异步顺序进行，因此您的_user全局变量未启动，我认为这是正确的顺序：

let _user;

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

Node.JS：Sequelize关联集无法恢复偏执状态下的记录

1 个答案: