Node.js 用';它不是Sequelize.Model的子类
当我在我的模型中添加Sequelize的关联时,我遇到了一个错误“…调用的东西不是Sequelize.Model的子类”,我调用的不是Sequelize模型Node.js 用';它不是Sequelize.Model的子类,node.js,express,sequelize.js,Node.js,Express,Sequelize.js,当我在我的模型中添加Sequelize的关联时,我遇到了一个错误“…调用的东西不是Sequelize.Model的子类”,我调用的不是Sequelize模型 E:...\Projects\WebApps\hr1\hr1\node_modules\sequelize\lib\associations\mixin.js:81 throw new Error(this.name + '.' + Utils.lowercaseFirst(Type.toString()) + ' called
E:...\Projects\WebApps\hr1\hr1\node_modules\sequelize\lib\associations\mixin.js:81
throw new Error(this.name + '.' + Utils.lowercaseFirst(Type.toString()) + ' called with something that\'s not a subclass of Sequelize.Model');
^
Error: user_employee_tm.class BelongsTo extends Association {
constructor(source, target, options) {
super(source, target, options);
this.associationType = 'BelongsTo';
this.isSingleAssociation = true;
this.foreignKeyAttribute = {};
if (this.as) {
this.isAliased = true;
this.options.name = {
singular: this.as
};
} else {
this.as = this.target.options.name.singular;
this.options.name = this.target.options.name;
}
if (_.isObject(this.options.foreignKey)) {
this.foreignKeyAttribute = this.options.foreignKey;
this.foreignKey = this.foreignKeyAttribute.name || this.foreignKeyAttribute.fieldName;
} else if (this.options.foreignKey) {
this.foreignKey = this.options.foreignKey;
}
if (!this.foreignKey) {
this.foreignKey = Utils.camelizeIf(
[
Utils.underscoredIf(this.as, this.source.options.underscored),
this.target.primaryKeyAttribute
].join('_'),
!this.source.options.underscored
);
}
this.identifier = this.foreignKey;
if (this.source.rawAttributes[this.identifier]) {
this.identifierField = this.source.rawAttributes[this.identifier].field || this.identifier;
}
this.targetKey = this.options.targetKey || this.target.primaryKeyAttribute;
this.targetKeyField = this.target.rawAttributes[this.targetKey].field || this.targetKey;
this.targetKeyIsPrimary = this.targetKey === this.target.primaryKeyAttribute;
this.targetIdentifier = this.targetKey;
this.associationAccessor = this.as;
this.options.useHooks = options.useHooks;
// Get singular name, trying to uppercase the first letter, unless the model forbids it
const singular = Utils.uppercaseFirst(this.options.name.singular);
this.accessors = {
get: 'get' + singular,
set: 'set' + singular,
create: 'create' + singular
};
}
// the id is in the source table
injectAttributes() {
const newAttributes = {};
newAttributes[this.foreignKey] = _.defaults({}, this.foreignKeyAttribute, {
type: this.options.keyType || this.target.rawAttributes[this.targetKey].type,
allowNull: true
});
if (this.options.constraints !== false) {
const source = this.source.rawAttributes[this.foreignKey] || newAttributes[this.foreignKey];
this.options.onDelete = this.options.onDelete || (source.allowNull ? 'SET NULL' : 'NO ACTION');
this.options.onUpdate = this.options.onUpdate || 'CASCADE';
}
Helpers.addForeignKeyConstraints(newAttributes[this.foreignKey], this.target, this.source, this.options, this.targetKeyField);
Utils.mergeDefaults(this.source.rawAttributes, newAttributes);
this.identifierField = this.source.rawAttributes[this.foreignKey].field || this.foreignKey;
this.source.refreshAttributes();
Helpers.checkNamingCollision(this);
return this;
}
mixin(obj) {
const methods = ['get', 'set', 'create'];
Helpers.mixinMethods(this, obj, methods);
}
/**
* Get the associated instance.
*
* @param {Object} [options]
* @param {String|Boolean} [options.scope] Apply a scope on the related model, or remove its default scope by passing false.
* @param {String} [options.schema] Apply a schema on the related model
* @see {@link Model.findOne} for a full explanation of options
* @return {Promise<Model>}
*/
get(instances, options) {
const association = this;
const where = {};
let Target = association.target;
let instance;
options = Utils.cloneDeep(options);
if (options.hasOwnProperty('scope')) {
if (!options.scope) {
Target = Target.unscoped();
} else {
Target = Target.scope(options.scope);
}
}
if (options.hasOwnProperty('schema')) {
Target = Target.schema(options.schema, options.schemaDelimiter);
}
if (!Array.isArray(instances)) {
instance = instances;
instances = undefined;
}
if (instances) {
where[association.targetKey] = {
[Op.in]: instances.map(instance => instance.get(association.foreignKey))
};
} else {
if (association.targetKeyIsPrimary && !options.where) {
return Target.findByPk(instance.get(association.foreignKey), options);
} else {
where[association.targetKey] = instance.get(association.foreignKey);
options.limit = null;
}
}
options.where = options.where ?
{[Op.and]: [where, options.where]} :
where;
if (instances) {
return Target.findAll(options).then(results => {
const result = {};
for (const instance of instances) {
result[instance.get(association.foreignKey, {raw: true})] = null;
}
for (const instance of results) {
result[instance.get(association.targetKey, {raw: true})] = instance;
}
return result;
});
}
return Target.findOne(options);
}
/**
* Set the associated model.
*
* @param {Model|String|Number} [newAssociation] An persisted instance or the primary key of an instance to associate with this. Pass `null` or `undefined` to remove the association.
* @param {Object} [options] Options passed to `this.save`
* @param {Boolean} [options.save=true] Skip saving this after setting the foreign key if false.
* @return {Promise}
*/
set(sourceInstance, associatedInstance, options) {
const association = this;
options = options || {};
let value = associatedInstance;
if (associatedInstance instanceof association.target) {
value = associatedInstance[association.targetKey];
}
sourceInstance.set(association.foreignKey, value);
if (options.save === false) return;
options = _.extend({
fields: [association.foreignKey],
allowNull: [association.foreignKey],
association: true
}, options);
// passes the changed field to save, so only that field get updated.
return sourceInstance.save(options);
}
/**
* Create a new instance of the associated model and associate it with this.
*
* @param {Object} [values]
* @param {Object} [options] Options passed to `target.create` and setAssociation.
* @see {@link Model#create} for a full explanation of options
* @return {Promise}
*/
create(sourceInstance, values, fieldsOrOptions) {
const association = this;
const options = {};
if ((fieldsOrOptions || {}).transaction instanceof Transaction) {
options.transaction = fieldsOrOptions.transaction;
}
options.logging = (fieldsOrOptions || {}).logging;
return association.target.create(values, fieldsOrOptions).then(newAssociatedObject =>
sourceInstance[association.accessors.set](newAssociatedObject, options)
);
}
} called with something that's not a subclass of Sequelize.Model
at Function.<anonymous> (E:...\Projects\WebApps\hr1\hr1\node_modules\sequelize\lib\associations\mixin.js:81:13)
at Object.<anonymous> (E:...\Projects\WebApps\hr1\hr1\models\user_employee.js:22:14)
at Module._compile (internal/modules/cjs/loader.js:688:30)
at Object.Module._extensions..js (internal/modules/cjs/loader.js:699:10)
at Module.load (internal/modules/cjs/loader.js:598:32)
at tryModuleLoad (internal/modules/cjs/loader.js:537:12)
at Function.Module._load (internal/modules/cjs/loader.js:529:3)
at Module.require (internal/modules/cjs/loader.js:636:17)
at require (internal/modules/cjs/helpers.js:20:18)
at Object.<anonymous> (E:...\Projects\WebApps\hr1\hr1\models\user.js:4:26)
at Module._compile (internal/modules/cjs/loader.js:688:30)
at Object.Module._extensions..js (internal/modules/cjs/loader.js:699:10)
at Module.load (internal/modules/cjs/loader.js:598:32)
at tryModuleLoad (internal/modules/cjs/loader.js:537:12)
at Function.Module._load (internal/modules/cjs/loader.js:529:3)
at Module.require (internal/modules/cjs/loader.js:636:17)
at require (internal/modules/cjs/helpers.js:20:18)
at Object.<anonymous> (E:...\Projects\WebApps\hr1\hr1\routes\index.js:4:12)
at Module._compile (internal/modules/cjs/loader.js:688:30)
at Object.Module._extensions..js (internal/modules/cjs/loader.js:699:10)
at Module.load (internal/modules/cjs/loader.js:598:32)
at tryModuleLoad (internal/modules/cjs/loader.js:537:12)
模型/用户_employee.js
const sequelize = require('../config/connectionDatabase');
var Sequelize = require('sequelize');
const User = require('../models/user');
var UserEmployee = sequelize.define('user_employee_tm', {
DateJoin: {
type: Sequelize.DATE
},
UserID: {
type: Sequelize.INTEGER,
references: {
model: User,
key: "ID"
}
},
CompanyID: {
type: Sequelize.INTEGER
}
});
// UserEmployee.hasOne(User, {as: 'User', foreignKey: 'UserID'});
UserEmployee.belongsTo(User , {foreignKey: 'ID', as: 'Employee'});
module.exports = UserEmployee;
有什么我错过的吗?我已尝试使用此url
用于随模型添加Associate,但仍然存在相同的问题
非常感谢您的帮助您需要在名为
associate(models)
的函数中添加关联。models
参数包含由定义名称键入的所有现有Model
定义(本例中为“user_tm”)
我发现我只需要定义UserEmployee的对象 这是我修复的代码
const sequelize = require('../config/connectionDatabase');
var Sequelize = require('sequelize');
const User = require('../models/user');
const Company = require('../models/company');
var UserEmployee = sequelize.define('user_employee_tm', {
DateJoin: {
type: Sequelize.DATE
},
UserID: {
type: Sequelize.INTEGER,
references: {
model: User,
key: "UserID"
}
},
CompanyID: {
type: Sequelize.INTEGER,
references: {
model: Company,
key: "CompanyID"
}
}
});
UserEmployee.belongsTo(Company, {as: 'Company', foreignKey: 'CompanyID'});
UserEmployee.belongsTo(User, {as: 'User', foreignKey: 'UserID'});
module.exports = UserEmployee;
不需要设置为associate,因为Sequelize已经设置了关联它们的方法,并且我还修复了它们之间的关系
希望其他和我有同样问题的人能照顾好它,不要让2个模型变成1个文件
附言。
感谢doublesharp帮助我指出我的错误行为仅针对未来的谷歌用户,这也可能发生在看似正确的代码上,但存在循环依赖关系。在我的例子中,A与B有一个belongsTo关系,当我在B处添加一个钩子来实例化A时,出现了错误(事实上,当您添加
导入时出现了错误)
我通过在一个文件中添加钩子来修复它。
A.hasOne(B)
和
B.belongsTo(A)
在同一个文件中为我解决了这个问题
我发现问题,我忘记从型号名称中删除s
User.belongstomy(models.Roles{
通过:“用户角色”,
});我就是这样解决的:A.有很多(模型B);在A模型上,然后在B模型上B.belongsTo(模型A)
“严格使用”;
const{Model}=require(“sequelize”);
常数报价=要求(“/报价”);
module.exports=(sequelize,数据类型)=>{
类客户机扩展模型{
/**
*用于定义关联的助手方法。
*此方法不是Sequelize生命周期的一部分。
*`models/index`文件将自动调用此方法。
*/
静态助理(模型){
//在这里定义关联
客户.hasOne(型号.报价);
}
}
Clients.init(
{
名字:DataTypes.STRING,
lastName:DataTypes.STRING,
电子邮件:DataTypes.STRING,
电话:DataTypes.STRING,
contactName:DataTypes.STRING,
contactPosition:DataTypes.STRING,
rncCode:DataTypes.STRING,
活动:DataTypes.BOOLEAN,
},
{
续集,
型号名称:“客户机”,
}
);
返回客户;
};代码>如果有很多模型,将所有模型放在一个文件中是不可行的
对我来说,有效的方法不是将模型添加到同一个文件中,而是创建一个新的关联
文件并导入模型,然后在其中执行下面的操作。然后在主应用程序文件中导入“/assocations”
。这解决了错误
associations
文件应该是这样的:
import {Post} from "./post";
import {Tag} from "./tag";
Tag.belongsToMany(Post, {
through: 'PostTags'
})
Post.belongsToMany(Tag, {
through: 'PostTags'
})
我是新来续集的。这种方法可能很幼稚,但它解决了我的简单用例中的鸡/蛋问题:
models/Dog.js
const{Model}=require('sequelize');
module.exports=函数(sequelize){
类狗扩展模型{}
设置超时(()=>{
狗。有很多(续集。模型。跳蚤);
}, 0);
返回犬;
}
models/flear.js
const{Model}=require('sequelize');
module.exports=函数(sequelize){
类跳蚤扩展模型{}
设置超时(()=>{
跳蚤(sequelize.models.Dog);
}, 0);
返蚤;
}
models/index.js:
const sequelize=getConnectionSomehow();
const Dog=require('./Dog')(续集);
常量跳蚤=需要('./跳蚤')(续集);
所以我需要将UserEmployee定义放在用户模型文件中?另外,我还有另一个警告{SequelizeAgerLoadingError:user_tm与user_employee_tm不关联!您还需要创建反向关系。我想补充的是,大小写也很重要。请确保定义名称与稍后使用的名称完全相同。associate
属性在TypeScript中不存在:(我可以确认这种方法有效……但这真的是个好主意吗?要做到这一点,我们必须(1)将关联(hasOne
,belongsTo
等)与模型定义分开放入一个文件中,或者(2)将关联和模型定义放在一个文件中。如果您不想处理将所有模型放在一个文件中的问题,请参阅我的答案,该答案几乎可以做到这一点,但更易于管理。
const sequelize = require('../config/connectionDatabase');
var Sequelize = require('sequelize');
const User = require('../models/user');
const Company = require('../models/company');
var UserEmployee = sequelize.define('user_employee_tm', {
DateJoin: {
type: Sequelize.DATE
},
UserID: {
type: Sequelize.INTEGER,
references: {
model: User,
key: "UserID"
}
},
CompanyID: {
type: Sequelize.INTEGER,
references: {
model: Company,
key: "CompanyID"
}
}
});
UserEmployee.belongsTo(Company, {as: 'Company', foreignKey: 'CompanyID'});
UserEmployee.belongsTo(User, {as: 'User', foreignKey: 'UserID'});
module.exports = UserEmployee;
import {Post} from "./post";
import {Tag} from "./tag";
Tag.belongsToMany(Post, {
through: 'PostTags'
})
Post.belongsToMany(Tag, {
through: 'PostTags'
})