I've been trying to create associations with Sequelize but to no avail, I kept getting a hasOne is not a function error. I've learned that it may be because of circular dependencies with my imports. So I started using the Sequelize instance in my index.js file and importing that instance in other model files:
index.js:
'use strict';
const fs = require('fs');
const path = require('path');
const Sequelize = require('sequelize');
const basename = path.basename(__filename);
const env = process.env.NODE_ENV || 'development';
const config = require(__dirname + '/../config/config.json')[env];
const db = {};
const practAppt = require('./practAppt')
const practUser = require('./practUsers')
practAppt.hasOne(practUser, {foreignKey: "email"})
practUser.hasMany(practAppt, {foreignKey: "client"})
var sequelize = new Sequelize({
dialect: 'sqlite',
storage: 'C:/backend/db.sqlite3'
});
//let sequelize;
// if (config.use_env_variable) {
// sequelize = new Sequelize(process.env[config.use_env_variable], config);
// } else {
// sequelize = new Sequelize(config.database, config.username, config.password, config);
// }
fs
.readdirSync(__dirname)
.filter(file => {
return (file.indexOf('.') !== 0) && (file !== basename) && (file.slice(-3) === '.js');
})
.forEach(file => {
console.log("FILE", file)
const model = require((path.join(__dirname, file)));
db[model.name] = model;
});
Object.keys(db).forEach(modelName => {
if (db[modelName].associate) {
db[modelName].associate(db);
}
});
sequelize
.authenticate()
.then(() => {
console.log('Connection has been established successfully.');
})
.catch(err => {
console.error('Unable to connect to the database:', err);
});
db.sequelize = sequelize;
db.Sequelize = Sequelize;
module.exports = db;
practUsers.js
const Sequelize = require('sequelize')
const Op = Sequelize.Op
const db = require("./index")
const practUser = db.define("practUsers", {
// attributes
firstName: {
type: Sequelize.STRING,
allowNull: false
},
lastName: {
type: Sequelize.STRING,
allowNull: false
},
address: {
type: Sequelize.STRING,
allowNull: false
},
unit: {
type: Sequelize.STRING,
allowNull: false
},
city: {
type: Sequelize.STRING,
allowNull: false
},
province: {
type: Sequelize.STRING,
allowNull: false
},
postal_code: {
type: Sequelize.STRING,
allowNull: false
},
phoneNumber: {
type: Sequelize.STRING,
allowNull: false
},
email: {
type: Sequelize.STRING,
allowNull: false,
unique: true
},
birthdate: {
type: Sequelize.STRING,
allowNull: false
},
healthCardNumber: {
type: Sequelize.STRING,
allowNull: false,
unique: true
},
profession: {
type: Sequelize.STRING,
allowNull: false
},
designation: {
type: Sequelize.STRING,
allowNull: false
},
userType: {
type: Sequelize.STRING,
allowNull: false
},
})
// automatically create the table with the model definition
//sequelize.sync()
// test the connections
module.exports = {practUser}
But now it's telling me db.define is not a function, even if I export sequelize in index.js I get the same error. How do I properly create associations? I should create them in index.js correct? Or does it not matter? The docs seems to be useless on this front.
your db object as exported from index.js doesn't have the define method. You probably need to write:
const practUser = db.sequelize.define(....
Related
I am new to sequelize orm.
While developing backend with express, sequelize and mssql, I created models with sequelize-cli.
Before I have index.js file and new models created by seqeulize-cli command 'sequelize init' and 'sequelize model:generate..", I had no issue.
But as I start the server I encountered the error saying "TypeError: Class constructor model cannot be invoked without 'new'".
I have not touched index.js file and the new model generated by sequelize-cli is class-basis.
I tried to change class-basis model to sequelize.define() but still get the same error.
Please help me resolve the issue.
Thanks!!
Here is my code.
index.js
"use strict";
const fs = require("fs");
const path = require("path");
const Sequelize = require("sequelize");
const process = require("process");
const basename = path.basename(__filename);
const env = process.env.NODE_ENV || "development";
const config = require(__dirname + "/../config/config.json")[env];
const db = {};
let sequelize;
if (config.use_env_variable) {
sequelize = new Sequelize(process.env[config.use_env_variable], config);
sequelize = new Sequelize(
config.database,
config.username,
config.password,
config
);
} else {
}
fs.readdirSync(__dirname)
.filter((file) => {
return (
file.indexOf(".") !== 0 && file !== basename && file.slice(-3) === ".js"
);
})
.forEach((file) => {
console.log("##########", path.join(__dirname, file))
const model = require(path.join(__dirname, file))(
sequelize,
Sequelize.DataTypes
);
db[model.name] = model;
});
Object.keys(db).forEach((modelName) => {
if (db[modelName].associate) {
db[modelName].associate(db);
}
});
db.sequelize = sequelize;
db.Sequelize = Sequelize;
module.exports = db;
GroupCode.js
"use strict";
const { Model } = require("sequelize");
module.exports = (sequelize, DataTypes) => {
class GroupCode extends Model {
/**
* Helper method for defining associations.
* This method is not a part of Sequelize lifecycle.
* The `models/index` file will call this method automatically.
*/
static associate({ CommonCode }) {
// define association here
this.hasMany(CommonCode);
}
}
GroupCode.init(
{
id: {
type: DataTypes.INTEGER,
autoIncrement: true,
allowNull: false,
primaryKey: true,
},
name: {
type: DataTypes.STRING,
allowNull: false,
unique: true,
},
description: {
type: DataTypes.STRING,
},
active: {
type: DataTypes.BOOLEAN,
defaultValue: true,
},
createdBy: {
type: DataTypes.STRING,
},
updatedBy: {
type: DataTypes.STRING,
},
},
{
sequelize,
modelName: "GroupCode",
}
);
return GroupCode;
};
CommonCode.js
"use strict";
const { Model } = require("sequelize");
module.exports = (sequelize, DataTypes) => {
class CommonCode extends Model {
/**
* Helper method for defining associations.
* This method is not a part of Sequelize lifecycle.
* The `models/index` file will call this method automatically.
*/
static associate({ GroupCode }) {
// define association here
this.belongsTo(GroupCode, {
foreignKey: { name: "groupCodeId", allowNull: false },
});
}
}
CommonCode.init(
{
id: {
type: DataTypes.INTEGER,
autoIncrement: true,
allowNull: false,
primaryKey: true,
},
name: {
type: DataTypes.STRING,
allowNull: false,
unique: true,
},
value: {
type: DataTypes.STRING,
allowNull: false,
unique: true,
},
seq: {
type: DataTypes.INTEGER,
default: 1,
},
active: {
type: DataTypes.BOOLEAN,
defaultValue: true,
},
createdBy: {
type: DataTypes.STRING,
},
updatedBy: {
type: DataTypes.STRING,
},
},
{
sequelize,
modelName: "CommonCode",
}
);
return CommonCode;
};
Resolve the error that appears when start the server.
(Update below)
I'm trying to set up model associations using Sequelize and the .associate method.
I have the setup below but this returns an error:
UnhandledPromiseRejectionWarning: SequelizeEagerLoadingError:
ProductMember is not associated to Product!
What am I doing wrong?
Db setup:
const { Sequelize } = require("sequelize");
const config = require("./db.config.js");
const sequelize = new Sequelize(config[process.env]);
module.exports = sequelize;
db.config.js:
module.exports = {
development: {
database: DB_NAME,
username: DB_USER,
password: DB_PASS,
dialect: DB_DRIVER,
logging: false,
options: {
host: DB_HOST,
port: DB_PORT,
pool: {},
},
},
}
/models/product.js:
const { DataTypes } = require("sequelize");
const sequelize = require("../db");
const Product = sequelize.define(
"Product",
{
id: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
allowNull: false,
},
name: {
type: DataTypes.STRING(255),
unique: true,
allowNull: false,
},
}
{
tableName: "products",
}
}
Product.associate = (models) => {
Product.belongsToMany(models.User, {
through: models.ProductMember,
foreignKey: "product_id",
otherKey: "user_id",
});
Product.hasMany(models.ProductMember, {
foreignKey: "product_id",
allowNull: false,
});
};
module.exports = sequelize.model("Product", Product);
models/user.js:
const { DataTypes } = require("sequelize");
const sequelize = require("../db");
const User = sequelize.define(
"User",
{
id: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
allowNull: false,
},
email: {
type: DataTypes.STRING(255),
allowNull: false,
unique: true,
isEmail: true,
},
username: {
type: DataTypes.STRING(15),
allowNull: false,
unique: true,
},
},
{
tableName: "users",
}
);
User.associate = (models) => {
User.belongsToMany(models.Product, {
through: models.ProductMember,
foreignKey: "user_id",
otherKey: "product_id",
});
User.hasMany(models.ProductMember, {
foreignKey: "user_id",
allowNull: false,
});
User.belongsToMany(models.Product, {
through: models.UserFavouriteProducts,
foreignKey: "user_id",
otherKey: "product_id",
});
}
module.exports = sequelize.model("User", User);
models/productMember.js:
const { DataTypes } = require("sequelize");
const sequelize = require("../db");
const ProductMember = sequelize.define(
"ProductMember",
{
id: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
allowNull: false,
},
isAdmin: {
type: DataTypes.BOOLEAN,
defaultValue: false,
},
},
{
tableName: "product_members",
}
);
ProductMember.associate = (models) => {
ProductMember.belongsTo(models.User);
ProductMember.belongsTo(models.Product);
};
module.exports = sequelize.model("ProductMember", ProductMember);
Update: Based on this post I updated the Db setup file to:
const fs = require('fs');
const path = require('path');
var basename = path.basename(module.filename);
const models = path.join(__dirname, '../models');
const db = {};
const Sequelize = require("sequelize");
const config = require("./db.config.js");
const sequelize = new Sequelize(config[process.env]);
fs
.readdirSync(models)
.filter(function (file) {
return (file.indexOf('.') !== 0) && (file !== basename) && (file.slice(-3) === '.js');
})
.forEach(function (file) {
var model = require(path.join(models, file))(
sequelize,
Sequelize.DataTypes
);
db[model.name] = model;
})
Object.keys(db).forEach(function (modelName) {
if (db[modelName].associate) {
db[modelName].associate(db);
}
})
db.Sequelize = Sequelize;
db.sequelize = sequelize;
module.exports = db;
Model file:
module.exports = (sequelize, Sequelize) => {
const Coupon = db.sequelize.define(
//... continue as it was
return Coupon;
}
So for the model file:
Wrapped it inside module.exports = (sequelize, Sequelize) => { }
return Coupon at the end
removed const sequelize = require("../db");
New problem: But with this new setup, Sequelize-related controller methods no longer work... For example for a controller file:
const User = require("../models/user");
const ensureLoggedIn = async (req, res, next) => {
...
const user = await User.findByPk(id);
it produces the error:
User.findByPk is not a function
I've tried adding const sequelize = require("../db"); to the controller file and then const user = await sequelize.User.findByPk(id); but that produced the same error.
I've tried adding const db = require("../db"); to the controller file and then const user = await db.sequelize.User.findByPk(id); but that produced the error "Cannot read property 'findByPk' of undefined".
First, you don't need to call sequelize.model to get a model that registered in Sequelize, you can just export a return value from sequelize.define:
const Product = sequelize.define(
"Product",
...
module.exports = Product;
Second, it seems you didn't call associate methods of all registered models.
Look at my answer here to get an idea of how to do it.
Update: to use models if you defined them like in my answer you need to access them like this:
const { sequelize } = require("../db");
const user = await sequelize.models.User.findByPk(id);
...
My models/index.js file:
'use strict';
const fs = require('fs');
const path = require('path');
const {Sequelize, Op, Model, DataTypes} = require("sequelize");
const basename = path.basename(__filename);
const env = process.env.NODE_ENV || 'development';
const config = require(__dirname + '/../config/config.json')[env];
const db = {};
let sequelize;
if (config.use_env_variable) {
sequelize = new Sequelize(process.env[config.use_env_variable], config);
} else {
sequelize = new Sequelize(config.database, config.username, config.password, config);
}
fs.readdirSync(__dirname)
.filter(file => {
return (file.indexOf('.') !== 0) && (file !== basename) && (file.slice(-3) === '.js');
})
.forEach(file => {
const model = require(path.join(__dirname, file))(sequelize, Sequelize.DataTypes);
db[model.name] = model;
});
Object.keys(db).forEach(modelName => {
if (db[modelName].associate) {
db[modelName].associate(db);
}
});
db.sequelize = sequelize;
db.Sequelize = Sequelize;
db.sequelize.define('Category', {
name: {type: String, allowNull: false},
url: {type: String, allowNull: false, unique: true},
}, {
freezeTableName: true,
timestamps: true
}
);
db.sequelize.sync({ force: true }); # it should create table
module.exports = db.sequelize.models;
console.log(db.sequelize.models) # output: {Category: Category}
If I make any queries to the model it throw an err:
UnhandledPromiseRejectionWarning: SequelizeDatabaseError: SQLITE_ERROR: no such table: Category;
How can I insert the models in db?
You need to create a migration script to create the table,
shell$ sequelize migration:create --name create-category-table
'use strict';
module.exports = {
up: async (queryInterface, Sequelize) => {
await queryInterface.createTable('Categories', {
id: {
allowNull: false,
autoIncrement: true,
primaryKey: true,
type: Sequelize.INTEGER
},
name: {
type: Sequelize.STRING
},
createdAt: {
allowNull: false,
type: Sequelize.DATE
},
updatedAt: {
allowNull: false,
type: Sequelize.DATE
}
});
},
down: async (queryInterface, Sequelize) => {
await queryInterface.dropTable('Categories');
}
};
shell$ sequelize db:migrate
I have 2 express.js applications and run sequelize.sync(), but in my first app it generate the tables, and the others not generate the tables, i wonder why, because the script is identic.
database.js
const Sequelize = require('sequelize');
const sequelize = new Sequelize('student-affairs', 'root', '', {
dialect: 'mysql',
host: 'localhost',
operatorsAliases: false,
});
module.exports = sequelize;
organization.js
const Sequelize = require('sequelize');
const sequelize = require('../configs/database');
const Organization = sequelize.define('organization', {
id: {
type: Sequelize.INTEGER,
allowNull: false,
primaryKey: true,
autoIncrement: true
},
name: {
type: Sequelize.STRING,
allowNull: false
},
logo: {
type: Sequelize.STRING
},
createdBy: {
type: Sequelize.INTEGER,
allowNull: false
},
updatedBy: {
type: Sequelize.INTEGER,
allowNull: false
}
});
module.exports = Organization;
app.js
// Database
const sequelize = require('./configs/database');
sequelize
.sync()
.then(result => {
console.log(result);
app.listen(3001);
})
.catch(err => {
console.log(err);
});
But after i log it, it always return the models empty like this
models: {},
modelManager: ModelManager { models: [], sequelize: [Circular] },
it doesn't have the models. anyone can explain why? thanks
I just realize that i am not call the organization model in app.js, once i define it in app.js and it fix the problem.
I think it's a basic mistake. Now i understand how it works.
// Models
const Organization = require('./models/organization');
sequelize
.sync()
.then(result => {
app.listen(3000);
})
.catch(err => {
console.log(err);
});
I am creating a one-to-many relationship and ran into a strange error when I pass the associated model to my db object. I don't understand where the error will come from as the method follows the documentation. Do I need to write a reference within my targeted model?
Error:
db.DiscoverySource.associate(db);
^
TypeError: db.DiscoverySource.associate is not a function
at Object.<anonymous> (/Users/user/Desktop/Projects/node/app/app/models/db-index.js:33:20)
Source Model (One) organization.js:
module.exports = function(sequelize, DataTypes) {
var Organization = sequelize.define('organization', {
organizationId: {
type: DataTypes.INTEGER,
field: 'organization_id',
autoIncrement: true,
primaryKey: true
},
organizationName: {
type: DataTypes.STRING,
field: 'organization_name'
},
admin: DataTypes.STRING
},{
freezeTableName: true,
classMethods: {
associate: function(db) {
Organization.belongsToMany(db.User, { through: 'member', foreignKey: 'user_id' }),
Organization.hasMany(db.DiscoverySource, { foreignKey: 'organization_id' });
},
}
});
return Organization;
}
Target (Many) discovery-source.js:
module.exports = function(sequelize, DataTypes) {
var DiscoverySource = sequelize.define('discovery_source', {
discoverySourceId: {
type: DataTypes.INTEGER,
field: 'discovery_source_id',
autoIncrement: true,
primaryKey: true
},
discoverySource: {
type: DataTypes.STRING,
field: 'discovery_source_name'
},
organizationId: {
type: DataTypes.TEXT,
field: 'organization_id'
},
},{
freezeTableName: true,
});
return DiscoverySource;
}
db-index.js joining the models:
var Sequelize = require('sequelize');
var path = require('path');
var config = require(path.resolve(__dirname, '..', '..','./config/config.js'));
var sequelize = new Sequelize(config.database, config.username, config.password, {
host:'localhost',
port:'3306',
dialect: 'mysql'
});
sequelize.authenticate().then(function(err) {
if (!!err) {
console.log('Unable to connect to the database:', err)
} else {
console.log('Connection has been established successfully.')
}
});
var db = {}
db.Member = sequelize.import(__dirname + "/member");
db.Organization = sequelize.import(__dirname + "/organization");
db.User = sequelize.import(__dirname + "/user");
db.DiscoverySource = sequelize.import(__dirname + "/discovery-source");
db.User.associate(db);
db.Organization.associate(db);
db.DiscoverySource.associate(db);
db.sequelize = sequelize;
db.Sequelize = Sequelize;
sequelize.sync();
module.exports = db;
You're getting an error because you haven't defined associate in classMethods for DiscoverySource. It looks like you don't need to call that, so just remove that line altogether.