Hmm, I agree that includes should probably throw an error if the argument passed is undefined.

I have thought about this before (when re-writing scopes actually) - and there is currently no good solution. Of course you could sort the models in the order that best suits your case - in this specific case making sure that groupType is loaded before group.

A better solution to this would probably be to have an addScope function for these kind of cases. You could then call this function when all models are loaded (in associate or similar)

Glad this is truly a bug and not just programmer error!

I agree, I think an addScope function would be the most elegant solution. Adding scopes in something like index.js might seem strange at first, but I think it could potentially be a helpful design pattern.

I'll see if I can help contribute to some documentation for the time being.

@janmeier do you have any tips about implementing this addScope function, how I could do this? I have about 40 models and counting so manually ordering them seems daunting 😧

@aarosil This is actually the only code that handles scopes on the model now https://github.com/sequelize/sequelize/blob/master/lib/model.js#L647-L651. So an addScope function should call conformIncludes and add the scope to this.options.scopes

@bomattin I have found a workaround:

module.exports = function(sequelize, DataTypes) {
    var group = sequelize.define("group", {
        ...
        ...
    }, {
        classMethods: {
            associate: function(models) {

                ...
                group.belongsTo(models.groupType, {
                    foreignKey:"grouptypeid"
                });
            }
        }
    }, {
        scopes: {
            includeType: function() {
                return {
                    include: [{association: group.associations.groupType}]
                };

                // or

                var groupType = group.associations.groupType.target;

                return {
                    include: [{model: groupType}]
                };
            }
        }
    });
    console.log(sequelize.models);
    return group;
};

However, this won't work with defaultScope.

@irobert91 Workaround works great. Nice find! Thanks.

Not sure if this is the right place to ask, but it seemed like the most relevant issue. I've noticed that, regardless of what order I specify to load my models, sometimes I get issues where models are undefined at the time I try to reference them in scopes. However, if I define the scope as a function instead of a JS object, things work fine, presumably because the evaluation of the scope as a function is deferred. Is that correct? Is there a better way or should I stick with this method for now?

For reference, this works:

scopes: {
  categories: function() {
    return {
      include: [
        {
          model: models.category,
        }
      ]
    };
  }

But this doesn't:

scopes: {
  categories: {
      include: [
        {
          model: models.category,
        }
      ]
    }
  }

@markdboyd That's fascinating. I suspect you're correct, it absolutely must be because the function evaluation is deferred.

We do have Model.addScope() now, so it depends on which method you prefer. Personally, I prefer having all my model information in one place, so I'd prefer your method if I weren't already using addScope() in models/index.js.

Yeah, I prefer keeping all my model information together as well. I guess I'll keep this workaround for now

I know this has been closed but I have found a problem with this workaround. I have been setting my scopes and functions that return an object, but the documentation says that defaultScope must be just a plain object. So it fails in that case. Is there another workaround people are using for that scenario?

how about this method?