Multiple migration statements in one migration file - node.js

Question

I am trying to execute multiple migration statements in a single migration file in order to make changes to multiple columns of same table in one go.
I want to know that whether I am doing it in a write way or not or is there a better and more appropriate way to do it:
Migration Code
module.exports = {
up: function(queryInterface, Sequelize, done) {
queryInterface.changeColumn('users', 'name', {
type: Sequelize.STRING,
allowNull: false,
require: true,
unique: true
}).success(function() {
queryInterface.changeColumn('users', 'address', {
type: Sequelize.STRING,
allowNull: false,
require: true,
unique: true
}).success(function() {
queryInterface.changeColumn('users', 'city', {
type: Sequelize.STRING,
allowNull: false,
require: true,
unique: true
}).success(function() {
queryInterface.changeColumn('users', 'state', {
type: Sequelize.STRING,
allowNull: false,
require: true,
defaultValue: "ncjnbcb"
});
done();
});
});
});
}
};
But I face an error which says:
TypeError: undefined is not a function
Since i couldn't find any way of debugging error in migrations, it will be great if someone helps me out in resolving it or if possible, tell about the way as of how can we figure out the errors in a migration.

Answer 1

Your TypeError is probably because you're not returning anything. The docs say that each migration function should return a Promise. No mention of a done callback.
To that end, try the following:
return Promise.all([
queryInterface.changeColumn...,
queryInterface.changeColumn...
]);

Answer 2

Using Promise.all with transactions (safer migration) :
module.exports = {
up: async (queryInterface, Sequelize) => {
return queryInterface.sequelize.transaction(t => {
return Promise.all([
queryInterface.changeColumn('users', 'name',
{ type: Sequelize.STRING },
{ transaction: t }
),
queryInterface.changeColumn('users', 'address',
{ type: Sequelize.STRING },
{ transaction: t }
),
queryInterface.changeColumn('users', 'city',
{ type: Sequelize.STRING },
{ transaction: t }
)
]);
});
},
down: async (queryInterface, Sequelize) => {
return queryInterface.sequelize.transaction((t) => {
return Promise.all([
queryInterface.removeColumn('users', 'name', { transaction: t }),
queryInterface.removeColumn('users', 'address', { transaction: t }),
queryInterface.removeColumn('users', 'city', { transaction: t })
])
})
}
};
Using Promise.all without transactions would cause issues if some of the queries are rejected. It is safe to use transactions so that all operations would be executed successfully or none of the changes would be made.

Answer 3

module.exports = {
up: async (queryInterface, Sequelize) => {
try {
await queryInterface.addColumn('User', 'name', {
type: Sequelize.STRING
});
await queryInterface.addColumn('User', 'nickname', {
type: Sequelize.STRING
});
return Promise.resolve();
} catch (e) {
return Promise.reject(e);
}
},
down: async (queryInterface, Sequelize) => {
try {
await queryInterface.removeColumn('Challenges', 'name');
await queryInterface.removeColumn('Challenges', 'nickname');
return Promise.resolve();
} catch (e) {
return Promise.reject(e);
}
}
};

Answer 4

So this is a combination of 2 answers.
#Firmino Changani - Works great but will complete some of the migrations even if some fail
#Aswin Sanakan - Means they all work or none migrate but if the second migration depends on the first it will not work
I was creating a table and adding a special index to that table. So I ended up combining them and the below works for me:
'use strict';
module.exports = {
up: async (queryInterface, Sequelize) => {
return queryInterface.sequelize.transaction(async t => {
try {
await queryInterface.createTable(
'phonenumbers',
{
id: {
allowNull: false,
autoIncrement: true,
primaryKey: true,
type: Sequelize.INTEGER
},
full_number: {
type: Sequelize.STRING,
unique: true
},
phone: {
type: Sequelize.STRING
},
extension: {
type: Sequelize.INTEGER,
},
country_id: {
type: Sequelize.INTEGER
},
is_valid_format: {
type: Sequelize.BOOLEAN
},
type: {
type: Sequelize.STRING
},
createdAt: {
allowNull: false,
type: Sequelize.DATE
},
updatedAt: {
allowNull: false,
type: Sequelize.DATE
},
},
{ transaction: t }
),
await queryInterface.addIndex(
'phonenumbers',
['phone'],
{
name: 'constraint-phone-extension',
where: {extension: null},
transaction: t
}
)
return Promise.resolve();
} catch (e) {
return Promise.reject(e);
}
});
},
down: async (queryInterface, Sequelize) => {
return queryInterface.sequelize.transaction(async t => {
try {
await queryInterface.dropTable('phonenumbers', { transaction: t }),
return Promise.resolve();
} catch (e) {
return Promise.reject(e);
}
})
}
};