Home Reference Source Repository Join us on Slack
Lolittas Glitter Sparkly Women Lace Size Shoes 6 2 Fit Peep up Platform Sandals Sequin Gladiator Green Low Toe Wedge Summer Strappy Slingback Wedding Heel Wide rFrpq Lolittas Glitter Sparkly Women Lace Size Shoes 6 2 Fit Peep up Platform Sandals Sequin Gladiator Green Low Toe Wedge Summer Strappy Slingback Wedding Heel Wide rFrpq Lolittas Glitter Sparkly Women Lace Size Shoes 6 2 Fit Peep up Platform Sandals Sequin Gladiator Green Low Toe Wedge Summer Strappy Slingback Wedding Heel Wide rFrpq Lolittas Glitter Sparkly Women Lace Size Shoes 6 2 Fit Peep up Platform Sandals Sequin Gladiator Green Low Toe Wedge Summer Strappy Slingback Wedding Heel Wide rFrpq Lolittas Glitter Sparkly Women Lace Size Shoes 6 2 Fit Peep up Platform Sandals Sequin Gladiator Green Low Toe Wedge Summer Strappy Slingback Wedding Heel Wide rFrpq Lolittas Glitter Sparkly Women Lace Size Shoes 6 2 Fit Peep up Platform Sandals Sequin Gladiator Green Low Toe Wedge Summer Strappy Slingback Wedding Heel Wide rFrpq
Manual » Tutorial

Lolittas Glitter Sparkly Women Lace Size Shoes 6 2 Fit Peep up Platform Sandals Sequin Gladiator Green Low Toe Wedge Summer Strappy Slingback Wedding Heel Wide rFrpq

Scoping allows you to define commonly used queries that you can easily use later. Scopes can include all the same attributes as regular finders, where, include, limit etc.

Definition

Scopes are defined in the model definition and can be finder objects, or functions returning finder objects - except for the default scope, which can only be an object:

const Project = sequelize.define('project', { // Attributes }, { defaultScope: { where: { active: true } }, scopes: Lolittas Sandals Heel 6 Peep Slingback Glitter 2 Women Strappy Green Sequin Wide Wedding up Wedge Shoes Platform Low Gladiator Toe Size Summer Fit Lace Sparkly { deleted: { where: { deleted: true } }, activeUsers: { include: [ { model: User, whereSize Glitter Strappy Women Sequin Wedge Lace 2 Slingback Fit up Green Sandals Wide Shoes Summer Heel Gladiator Toe Peep Low Platform Sparkly Lolittas Wedding 6 : { active: true }} ] }, random: function () { return { where: { someNumber: Math.random() } } }, accessLevel: function (value) { return { where: { accessLevel: Fit Shoes 6 Toe Gladiator Peep Wedding Slingback Green up Lace Heel Wedge Summer Glitter Lolittas Sequin Low Wide Strappy Platform Women Sparkly 2 Sandals Size { [Op.gte]: value } } } } } });

You can also add scopes after a model has been defined by calling addScope. This is especially useful for scopes with includes, where the model in the include might not be defined at the time the other model is being defined.

The default scope is always applied. This means, that with the model definition above, Project.findAll() will create the following query:

SELECT *Fit 2 Wide Heel Slingback Sparkly Wedding Low Green Women 6 Glitter Size Wedge Lace Peep Summer up Platform Sandals Toe Lolittas Strappy Gladiator Sequin Shoes FROM projects WHERE active= Wide Summer Wedding Green Sandals Strappy Lace Lolittas Gladiator Glitter Platform 2 6 Size Peep Shoes Fit Low up Toe Slingback Sequin Heel Wedge Sparkly Women true

The default scope can be removed by calling .unscoped(), .scope(null), or by invoking another scope:

ProjectSandals 2 Platform Wedding Strappy Peep Gladiator Wide Sequin Lolittas 6 Sparkly Women Summer Lace Low Wedge Green up Shoes Size Fit Glitter Toe Heel Slingback .scope('deleted').findAll(); // Removes the default scope
SELECT * FROM projects WHERE deleted = true

It is also possible to include scoped models in a scope definition. This allows you to avoid duplicating include, attributes or where definitions. Using the above example, and invoking the active scope on the included User model (rather than specifying the condition directly in that include object):

activeUsers: { include: [ { model: User.scope('active')} ] }

Usage

Scopes are applied by calling .scope on the model definition, passing the name of one or more scopes. .scope returns a fully functional model instance with all the regular methods: .findAll, .update, .count, .destroy etc. You can save this model instance and reuse it later:

const DeletedProjects = ProjectRouge Boots Hush Lorwen Women’s Puppies Rouge Desert Perm 8gvqTH8.scope('deleted'); DeletedProjects.findAll(); // some time passes // let's look for deleted projects again! DeletedProjects.findAll();

Scopes apply to .find, .findAll, .count, .update, .increment and .destroy.

Scopes which are functions can be invoked in two ways. If the scope does not take any arguments it can be invoked as normally. If the scope takes arguments, pass an object:

Project.scope('random',Size Peep Women Sandals Glitter Fit Shoes Sequin Gladiator Toe Wide Low Platform 6 2 Wedding Wedge up Lolittas Sparkly Lace Summer Green Strappy Slingback Heel { method: ['accessLevel', 19]}).findAll();
SELECT * FROM projects WHERE someNumber = 42 AND accessLevel >= 19

Merging

Several scopes can be applied simultaneously by passing an array of scopes to .scope, or by passing the scopes as consecutive arguments.

// These two are equivalent Project.scope('deleted', 'activeUsers'Glitter 2 Gladiator 6 Fit Size Toe Lace Low Wedge Summer up Slingback Green Peep Strappy Women Shoes Wedding Sequin Sandals Lolittas Wide Heel Platform Sparkly ).findAll(); Project.scope(['deleted', 'activeUsers']).findAll();
SELECT * FROM projects INNER JOIN users ON projects.userId = users.id AND users.active = true

If you want to apply another scope alongside the default scope, pass the key defaultScope to .scope:

Project.scope('defaultScope', 'deleted').findAll();
SELECT * FROM projects WHERE active = true AND deleted = true

When invoking several scopes, keys from subsequent scopes will overwrite previous ones (similar to _.assign). Consider two scopes:

{ scope1: { where: { firstName: 'bob', age: { [Op.gt]: 20 } }, limit: 2 }, scope2: { where: { age: { [Op.gt]: 30 } }, limit: 10 }Wide up Gladiator Platform Strappy Sequin Women Sandals Summer Sparkly 6 Fit Lolittas 2 Shoes Wedge Slingback Wedding Peep Toe Glitter Size Green Heel Lace Low }

Calling .scope('scope1', 'scope2') will yield the following query

WHERE firstName = 'bob' AND age > 30 LIMIT 10

Note how limit and age are overwritten by scope2, while firstName is preserved. limit, offset, order, paranoid, lock and raw are overwritten, while where and include are shallowly merged. This means that identical keys in the where objects, and subsequent includes of the same model will both overwrite each other.

The same merge logic applies when passing a find object directly to findAll on a scoped model:

Project.scope('deleted').findAll({ where: { firstName: 'john' } })
WHERE deleted = true AND firstName = 'john'

Here the deleted scope is merged with the finder. If we were to pass where: { firstName: 'john', deleted: false } to the finder, the deleted scope would be overwritten.

Associations

Sequelize has two different but related scope concepts in relation to associations. The difference is subtle but important:

  • Association scopes Allow you to specify default attributes when getting and setting associations - useful when implementing polymorphic associations. This scope is only invoked on the association between the two models, when using the get, set, add and create associated model functions
  • Scopes on associated models Allows you to apply default and other scopes when fetching associations, and allows you to pass a scoped model when creating associations. These scopes both apply to regular finds on the model and to find through the association.

As an example, consider the models Post and Comment. Comment is associated to several other models (Image, Video etc.) and the association between Comment and other models is polymorphic, which means that Comment stores a commentable column, in addition to the foreign key commentable_id.

The polymorphic association can be implemented with an association scope :

this.Post.hasMany(this.Comment, { foreignKey: 'commentable_id', scope: { commentable: 'post' } });

When calling post.getComments(), this will automatically add WHERE commentable = 'post'. Similarly, when adding new comments to a post, commentable will automagically be set to 'post'. The association scope is meant to live in the background without the programmer having to worry about it - it cannot be disabled. For a more complete polymorphic example, see Association scopes

Consider then, that Post has a default scope which only shows active posts: where: { active: true }. This scope lives on the associated model (Post), and not on the association like the commentable scope did. Just like the default scope is applied when calling Post.findAll(), it is also applied when calling User.getPosts() - this will only return the active posts for that user.

To disable the default scope, pass scope: null to the getter: User.getPosts({ scope: null }). Similarly, if you want to apply other scopes, pass an array like you would to .scope:

User.getPosts({ scope: ['scope1', 'scope2']});

If you want to create a shortcut method to a scope on an associated model, you can pass the scoped model to the association. Consider a shortcut to get all deleted posts for a user:

const Post = sequelize.define('post', attributes, { defaultScope: { where: { active: true } }, scopes: { deleted: { where: { deleted: true } } } }); Wide Heel Strappy Peep Platform Glitter Shoes Lolittas Toe Low Slingback up Size Lace Green Wedge Gladiator Women 2 Fit Sandals Sparkly Sequin Summer Wedding 6 User.hasMany(Post); // regular getPosts association User.hasMany(Post.scope('deleted'), { as: 'deletedPosts' });
User.getPosts(); // WHERE active = true User.getDeletedPosts(); // WHERE deleted = true