title: Sequelize Association called with something that's not a subclass of Sequelize.Model
body: <p>I'm having error "...called with something that's not a subclass of Sequelize.Model" when I add association of Sequelize in my model it called error that what I call is not Sequelize Model</p>
  
  <pre><code>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&lt;Model&gt;}
     */
    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 =&gt; instance.get(association.foreignKey))
        };
      } else {
        if (association.targetKeyIsPrimary &amp;&amp; !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 =&gt; {
          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 =&gt;
        sourceInstance[association.accessors.set](newAssociatedObject, options)
      );
    }
  } called with something that's not a subclass of Sequelize.Model
      at Function.&lt;anonymous&gt; (E:...\Projects\WebApps\hr1\hr1\node_modules\sequelize\lib\associations\mixin.js:81:13)
      at Object.&lt;anonymous&gt; (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.&lt;anonymous&gt; (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.&lt;anonymous&gt; (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)
  </code></pre>
  
  <p>Here's my Code for</p>
  
  <p>model/User.js</p>
  
  <pre><code>var bcrypt =  require('bcrypt');
  const sequelize = require('../config/connectionDatabase')
  var Sequelize = require('sequelize');
  const UserEmployee = require('../models/user_employee');
  
  var User = sequelize.define('user_tm', {
      NameFirst: {
          type: Sequelize.STRING
      },
      NameLast: {
          type: Sequelize.STRING
      },
      username: {
          type: Sequelize.STRING,
          unique: true,
          allowNull: false
      },
      password: {
          type: Sequelize.STRING,
          allowNull: false
      }
  }, {
      hooks: {
      beforeCreate: (user) =&gt; {
          const salt = bcrypt.genSaltSync();
          user.password = bcrypt.hashSync(user.password, salt);
      }
      },
      instanceMethods: {
      validPassword: function(password) {
          return bcrypt.compareSync(password, this.password);
      }
      }    
  });
  
  User.hasOne(UserEmployee, {foreignKey: 'UserID', as: 'User'});
  User.prototype.validPassword = function (password) {
      return bcrypt.compareSync(password, this.password);
  };
  module.exports = User;
  </code></pre>
  
  <p>model/user_employee.js</p>
  
  <pre><code>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;
  </code></pre>
  
  <p>is there something I missed of? I've try to use this url
  <a href="https://dreamdevourer.com/example-of-sequelize-associations-in-feathersjs/" rel="noreferrer">https://dreamdevourer.com/example-of-sequelize-associations-in-feathersjs/</a></p>
  
  <p>for adding assosicate along with model, but still having the same problem.</p>
  
  <p>Much thanks for your help</p>