Constraints & Circularities

Adding constraints between tables means that tables must be created in the database in a certain order, when using sequelize.sync. If Task has a reference to User, the User table must be created before the Task table can be created. This can sometimes lead to circular references, where Sequelize cannot find an order in which to sync. Imagine a scenario of documents and versions. A document can have multiple versions, and for convenience, a document has a reference to its current version.

  1. const { Sequelize, Model, DataTypes } = require("sequelize");
  3. class Document extends Model {}
  4. Document.init({
  5.     author: DataTypes.STRING
  6. }, { sequelize, modelName: 'document' });
  8. class Version extends Model {}
  9. Version.init({
  10.   timestamp: DataTypes.DATE
  11. }, { sequelize, modelName: 'version' });
  13. Document.hasMany(Version); // This adds documentId attribute to version
  14. Document.belongsTo(Version, {
  15.   as: 'Current',
  16.   foreignKey: 'currentVersionId'
  17. }); // This adds currentVersionId attribute to document

However, unfortunately the code above will result in the following error:

  1. Cyclic dependency found. documents is dependent of itself. Dependency chain: documents -> versions => documents

In order to alleviate that, we can pass constraints: false to one of the associations:

  1. Document.hasMany(Version);
  2. Document.belongsTo(Version, {
  3.   as: 'Current',
  4.   foreignKey: 'currentVersionId',
  5.   constraints: false
  6. });

Which will allow us to sync the tables correctly:

  1. CREATE TABLE IF NOT EXISTS "documents" (
  2.   "id" SERIAL,
  3.   "author" VARCHAR(255),
  4.   "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL,
  5.   "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL,
  6.   "currentVersionId" INTEGER,
  7.   PRIMARY KEY ("id")
  8. );
  10. CREATE TABLE IF NOT EXISTS "versions" (
  11.   "id" SERIAL,
  12.   "timestamp" TIMESTAMP WITH TIME ZONE,
  13.   "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL,
  14.   "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL,
  15.   "documentId" INTEGER REFERENCES "documents" ("id") ON DELETE
  16.   SET
  17.     NULL ON UPDATE CASCADE,
  18.     PRIMARY KEY ("id")
  19. );

Enforcing a foreign key reference without constraints

Sometimes you may want to reference another table, without adding any constraints, or associations. In that case you can manually add the reference attributes to your schema definition, and mark the relations between them.

  1. class Trainer extends Model {}
  2. Trainer.init({
  3.   firstName: Sequelize.STRING,
  4.   lastName: Sequelize.STRING
  5. }, { sequelize, modelName: 'trainer' });
  7. // Series will have a trainerId = Trainer.id foreign reference key
  8. // after we call Trainer.hasMany(series)
  9. class Series extends Model {}
  10. Series.init({
  11.   title: Sequelize.STRING,
  12.   subTitle: Sequelize.STRING,
  13.   description: Sequelize.TEXT,
  14.   // Set FK relationship (hasMany) with `Trainer`
  15.   trainerId: {
  16.     type: DataTypes.INTEGER,
  17.     references: {
  18.       model: Trainer,
  19.       key: 'id'
  20.     }
  21.   }
  22. }, { sequelize, modelName: 'series' });
  24. // Video will have seriesId = Series.id foreign reference key
  25. // after we call Series.hasOne(Video)
  26. class Video extends Model {}
  27. Video.init({
  28.   title: Sequelize.STRING,
  29.   sequence: Sequelize.INTEGER,
  30.   description: Sequelize.TEXT,
  31.   // set relationship (hasOne) with `Series`
  32.   seriesId: {
  33.     type: DataTypes.INTEGER,
  34.     references: {
  35.       model: Series, // Can be both a string representing the table name or a Sequelize model
  36.       key: 'id'
  37.     }
  38.   }
  39. }, { sequelize, modelName: 'video' });
  41. Series.hasOne(Video);
  42. Trainer.hasMany(Series);