Sequelize move JavaScript logic to the DB? - node.js

Question

An Organization can have multiple Grounds, and the number of grounds that are available can vary on daily basis.
The user should get a list of all the Grounds, irrespective of the fact whether they are available during the given/specified dates.
The thing which will be displayed to the user, is that the certain ground is not available in the given dates.
Denoted by rest["available"] in the Code.
So I am doing this work manually in javascript, can not I some how shift the javascript logic to the
Sequelize as well? so that it returns me the "available" status as well as "average" in the response.
Actually, I have large amount of data, and I believe looping in the JS code is not an efficient way of doing it.
Therefore, I believe the logic must be moved to the Data Base, but I am unsure about doing it using Sequelize.
The database Tables, their relationship & JS code are given below.
Organization.model.js
module.exports = function(sequelize, DataTypes) {
let Organization = sequelize.define('Organization', {
id: {
type: DataTypes.INTEGER,
autoIncrement: true,
unique: true,
allowNull: false
},
name: {
type: DataTypes.STRING,
primaryKey: true,
}
}, {
timestamps: false,
freezeTableName: true,
tableName: "Organization",
underscored: false
});
Organization.associate = function(models) {
Organization.hasMany(models.Grounds, {
onDelete: 'cascade',
hooks: true,
foreignKey: 'OrganizationName',
sourceKey: 'name'
});
};
return Organization;
};
Grounds.model.js
module.exports = function(sequelize, DataTypes) {
let Grounds = sequelize.define('Grounds', {
id: {
type: DataTypes.INTEGER,
autoIncrement: true,
primaryKey: true
},
OrganizationName: {
type: DataTypes.STRING,
references: {
model: 'Organization',
key: 'name'
}
},
NumbersAvailable: {
type: DataTypes.INTEGER
},
Date: DataTypes.DATEONLY
}, {
timestamps: false,
freezeTableName: true,
tableName: "Grounds",
underscored: false
});
Grounds.associate = function(models) {
Grounds.belongsTo(models.Organization, {
foreignKey: 'OrganizationName',
targetKey: 'name'
});
};
return Grounds;
};
JavaScript Logic:
//Get all the Grounds, in the specified Dates, e.g: '2018-05-01' & '2018-05-04'
let organizations = await Organization.findAll({
include: [
model: Grounds,
where: {
Date: {
$gte: '2018-05-01',
$lte: '2018-05-04'
}
}
]
});
//Calculate the Grounds Availability, in the specified Dates, e.g: '2018-05-01' & '2018-05-04'
let finalResult = organizations.map(function(currVal){
let organization = currVal.dataValues;
let {Grounds, ...rest} = organization;
rest["available"] = true; //Custom Key.
rest["average"] = 0; //Custom Key.
Grounds.forEach(function(ground){
let Date = ground.Date;
rest["average"] += ground.NumbersAvailable;
let number = ground.NumbersAvailable;
if(number == 0) rest["available"] = false;
});
rest["average"] = rest["average"]/Grounds.length;
});
Sample Table Data:
Organization TABLE:
id name
---------------------------
1 authority1
2 authority2
3 authority3
Grounds TABLE:
id NumbersAvailable OrganizationName Date GroundName
----------------------------------------------------------------------------
1 5 authority1 2018-05-01 someName
2 3 authority1 2018-05-02 someName
3 6 authority1 2018-05-03 someName
4 2 authority1 2018-05-04 someName
5 7 authority2 2018-05-01 someName
6 3 authority2 2018-05-02 someName
7 0 authority2 2018-05-03 someName
8 1 authority2 2018-05-04 someName
9 2 authority3 2018-05-01 someName
10 1 authority3 2018-05-02 someName
11 3 authority3 2018-05-03 someName
12 1 authority3 2018-05-04 someName

Answer 1

The way you'd move your logic back into the data layer is by using a view or database function (links to Postgres docs; other databases may use "procedure" instead of "function"). Since your specific case here involves running some simple calculations on all organizations and their grounds, a view on a query that joins those two tables with GROUP BY and some aggregation should suffice. You can treat the view as a read-only model as far as Sequelize is concerned; per this issue, the only catch is that you can't sync it.
If you're doing something more complex, you'll need a function, and this is where things start to get hairy. How you implement a function depends on the dialect of SQL you're using, since each database has its own linguistic quirks (SQL Server uses SELECT TOP n instead of SELECT .... LIMIT n, and so on). Here's where you run into the first potential issue -- you're now locked into that one database server, be it Postgres, SQL Server, or what have you. If you want to support another database, you'll need to port your function into its dialect.
The second problem with using a function is that, to my knowledge, Sequelize doesn't provide an easy way to execute database function which return tabular results -- the reasoning being that it, like other object-relational mappers, abstracts specificities such as dialect away and only provides an interface for things you can write the basic suite of SELECT, INSERT, etc statements against. Functions are therefore ignored. In order to execute one, you'll need to use its raw query functionality.