admin/39588-vm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
39588-vm/backend/src/db/migrations/1775992051217.js
Flatlogic Bot 314c52ec08 Initial version
2026-04-12 11:09:01 +00:00

7128 lines
228 KiB
JavaScript
Raw Blame History

module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.createTable('users', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('roles', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('permissions', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('publishers', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('authors', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('genres', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('books', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('user_library_items', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('bookmarks', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('notes', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('camera_scan_sessions', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('coin_ledger_entries', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('withdrawal_requests', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('payment_transactions', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('daily_login_rewards', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('reading_streaks', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('achievement_definitions', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('user_achievements', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('rank_tiers', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('user_ranks', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('challenge_definitions', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('user_challenges', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('quiz_definitions', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('quiz_questions', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('quiz_answer_choices', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('quiz_attempts', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('friendships', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('book_clubs', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('book_club_memberships', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('club_chat_messages', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('reading_circle_events', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('recommendation_events', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('push_notifications', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('fraud_flags', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('kyc_verifications', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.createTable('user_uploads', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await queryInterface.addColumn(
'users',
'firstName',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'users',
'lastName',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'users',
'phoneNumber',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'users',
'email',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'users',
'disabled',
{
type: Sequelize.DataTypes.BOOLEAN,
defaultValue: false,
allowNull: false,
},
{ transaction }
);
await queryInterface.addColumn(
'users',
'password',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'users',
'emailVerified',
{
type: Sequelize.DataTypes.BOOLEAN,
defaultValue: false,
allowNull: false,
},
{ transaction }
);
await queryInterface.addColumn(
'users',
'emailVerificationToken',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'users',
'emailVerificationTokenExpiresAt',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'users',
'passwordResetToken',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'users',
'passwordResetTokenExpiresAt',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'users',
'provider',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'users',
'app_roleId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'roles',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'roles',
'name',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'roles',
'role_customization',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'permissions',
'name',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'publishers',
'name',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'publishers',
'country',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'publishers',
'website_url',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'publishers',
'description',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'authors',
'name',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'authors',
'bio',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'authors',
'website_url',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'authors',
'primary_language',
{
type: Sequelize.DataTypes.ENUM,
values: ['uz','ru','en','other'],
},
{ transaction }
);
await queryInterface.addColumn(
'genres',
'name',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'genres',
'description',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'books',
'title',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'books',
'subtitle',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'books',
'isbn',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'books',
'language',
{
type: Sequelize.DataTypes.ENUM,
values: ['uz','ru','en','other'],
},
{ transaction }
);
await queryInterface.addColumn(
'books',
'format',
{
type: Sequelize.DataTypes.ENUM,
values: ['ebook','audiobook','videobook','physical_reference'],
},
{ transaction }
);
await queryInterface.addColumn(
'books',
'status',
{
type: Sequelize.DataTypes.ENUM,
values: ['draft','published','archived'],
},
{ transaction }
);
await queryInterface.addColumn(
'books',
'description',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'books',
'page_count',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'books',
'word_count',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'books',
'duration_seconds',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'books',
'difficulty_score',
{
type: Sequelize.DataTypes.DECIMAL,
},
{ transaction }
);
await queryInterface.addColumn(
'books',
'popularity_score',
{
type: Sequelize.DataTypes.DECIMAL,
},
{ transaction }
);
await queryInterface.addColumn(
'books',
'published_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'books',
'publisherId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'publishers',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'user_library_items',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'user_library_items',
'bookId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'books',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'user_library_items',
'source',
{
type: Sequelize.DataTypes.ENUM,
values: ['library','upload','scan_claim'],
},
{ transaction }
);
await queryInterface.addColumn(
'user_library_items',
'status',
{
type: Sequelize.DataTypes.ENUM,
values: ['saved','in_progress','completed','archived'],
},
{ transaction }
);
await queryInterface.addColumn(
'user_library_items',
'offline_downloaded',
{
type: Sequelize.DataTypes.BOOLEAN,
defaultValue: false,
allowNull: false,
},
{ transaction }
);
await queryInterface.addColumn(
'user_library_items',
'downloaded_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'user_library_items',
'progress_percent',
{
type: Sequelize.DataTypes.DECIMAL,
},
{ transaction }
);
await queryInterface.addColumn(
'user_library_items',
'current_location',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'user_library_items',
'last_opened_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'user_library_items',
'completed_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'bookmarks',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'bookmarks',
'bookId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'books',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'bookmarks',
'location',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'bookmarks',
'label',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'bookmarks',
'added_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'notes',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'notes',
'bookId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'books',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'notes',
'location',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'notes',
'title',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'notes',
'content',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'notes',
'is_private',
{
type: Sequelize.DataTypes.BOOLEAN,
defaultValue: false,
allowNull: false,
},
{ transaction }
);
await queryInterface.addColumn(
'notes',
'noted_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'camera_scan_sessions',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'camera_scan_sessions',
'bookId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'books',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'camera_scan_sessions',
'scan_type',
{
type: Sequelize.DataTypes.ENUM,
values: ['cover','page','shelf'],
},
{ transaction }
);
await queryInterface.addColumn(
'camera_scan_sessions',
'status',
{
type: Sequelize.DataTypes.ENUM,
values: ['started','verifying','failed','completed','flagged'],
},
{ transaction }
);
await queryInterface.addColumn(
'camera_scan_sessions',
'started_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'camera_scan_sessions',
'ended_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'camera_scan_sessions',
'frames_analyzed',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'camera_scan_sessions',
'pages_detected',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'camera_scan_sessions',
'confidence_score',
{
type: Sequelize.DataTypes.DECIMAL,
},
{ transaction }
);
await queryInterface.addColumn(
'camera_scan_sessions',
'page_turning_detected',
{
type: Sequelize.DataTypes.BOOLEAN,
defaultValue: false,
allowNull: false,
},
{ transaction }
);
await queryInterface.addColumn(
'camera_scan_sessions',
'duplicate_page_detected',
{
type: Sequelize.DataTypes.BOOLEAN,
defaultValue: false,
allowNull: false,
},
{ transaction }
);
await queryInterface.addColumn(
'camera_scan_sessions',
'fraud_reason',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'camera_scan_sessions',
'coins_awarded',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'coin_ledger_entries',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'coin_ledger_entries',
'entry_type',
{
type: Sequelize.DataTypes.ENUM,
values: ['earn','spend','adjustment','reversal'],
},
{ transaction }
);
await queryInterface.addColumn(
'coin_ledger_entries',
'reason',
{
type: Sequelize.DataTypes.ENUM,
values: ['scan_read','ebook_read','quiz_passed','streak_bonus','daily_login','challenge_reward','referral','admin_adjustment','withdrawal_conversion','fraud_reversal'],
},
{ transaction }
);
await queryInterface.addColumn(
'coin_ledger_entries',
'amount_coins',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'coin_ledger_entries',
'description',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'coin_ledger_entries',
'occurred_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'coin_ledger_entries',
'scan_sessionId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'camera_scan_sessions',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'coin_ledger_entries',
'bookId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'books',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'withdrawal_requests',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'withdrawal_requests',
'status',
{
type: Sequelize.DataTypes.ENUM,
values: ['pending','processing','completed','rejected','cancelled'],
},
{ transaction }
);
await queryInterface.addColumn(
'withdrawal_requests',
'coins_amount',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'withdrawal_requests',
'cash_amount_uzs',
{
type: Sequelize.DataTypes.DECIMAL,
},
{ transaction }
);
await queryInterface.addColumn(
'withdrawal_requests',
'payout_method',
{
type: Sequelize.DataTypes.ENUM,
values: ['bank_transfer','mobile_money','e_wallet'],
},
{ transaction }
);
await queryInterface.addColumn(
'withdrawal_requests',
'payout_destination',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'withdrawal_requests',
'provider_reference',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'withdrawal_requests',
'admin_note',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'withdrawal_requests',
'requested_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'withdrawal_requests',
'processed_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'payment_transactions',
'withdrawal_requestId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'withdrawal_requests',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'payment_transactions',
'status',
{
type: Sequelize.DataTypes.ENUM,
values: ['initiated','pending','succeeded','failed','refunded'],
},
{ transaction }
);
await queryInterface.addColumn(
'payment_transactions',
'provider',
{
type: Sequelize.DataTypes.ENUM,
values: ['payme','click','apelsin','paynet','manual','other'],
},
{ transaction }
);
await queryInterface.addColumn(
'payment_transactions',
'amount_uzs',
{
type: Sequelize.DataTypes.DECIMAL,
},
{ transaction }
);
await queryInterface.addColumn(
'payment_transactions',
'provider_transaction_reference',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'payment_transactions',
'failure_reason',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'payment_transactions',
'initiated_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'payment_transactions',
'finalized_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'daily_login_rewards',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'daily_login_rewards',
'rewarded_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'daily_login_rewards',
'coins_awarded',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'daily_login_rewards',
'streak_day',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'reading_streaks',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'reading_streaks',
'current_streak_days',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'reading_streaks',
'best_streak_days',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'reading_streaks',
'last_streak_date',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'reading_streaks',
'started_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'achievement_definitions',
'name',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'achievement_definitions',
'description',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'achievement_definitions',
'category',
{
type: Sequelize.DataTypes.ENUM,
values: ['reading','streak','coins','social','quiz','challenge'],
},
{ transaction }
);
await queryInterface.addColumn(
'achievement_definitions',
'rarity',
{
type: Sequelize.DataTypes.ENUM,
values: ['common','rare','epic','legendary'],
},
{ transaction }
);
await queryInterface.addColumn(
'achievement_definitions',
'target_value',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'achievement_definitions',
'metric',
{
type: Sequelize.DataTypes.ENUM,
values: ['books_completed','minutes_read','coins_earned','streak_days','quizzes_passed','challenges_completed','friends_added'],
},
{ transaction }
);
await queryInterface.addColumn(
'achievement_definitions',
'active',
{
type: Sequelize.DataTypes.BOOLEAN,
defaultValue: false,
allowNull: false,
},
{ transaction }
);
await queryInterface.addColumn(
'user_achievements',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'user_achievements',
'achievement_definitionId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'achievement_definitions',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'user_achievements',
'earned_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'user_achievements',
'progress_value',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'user_achievements',
'notified',
{
type: Sequelize.DataTypes.BOOLEAN,
defaultValue: false,
allowNull: false,
},
{ transaction }
);
await queryInterface.addColumn(
'rank_tiers',
'name',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'rank_tiers',
'min_points',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'rank_tiers',
'max_points',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'rank_tiers',
'description',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'user_ranks',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'user_ranks',
'rank_tierId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'rank_tiers',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'user_ranks',
'rank_points',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'user_ranks',
'updated_at_time',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'challenge_definitions',
'name',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'challenge_definitions',
'description',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'challenge_definitions',
'status',
{
type: Sequelize.DataTypes.ENUM,
values: ['draft','active','ended','archived'],
},
{ transaction }
);
await queryInterface.addColumn(
'challenge_definitions',
'challenge_type',
{
type: Sequelize.DataTypes.ENUM,
values: ['read_books','read_minutes','scan_books','complete_quizzes','earn_coins'],
},
{ transaction }
);
await queryInterface.addColumn(
'challenge_definitions',
'target_value',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'challenge_definitions',
'reward_coins',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'challenge_definitions',
'start_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'challenge_definitions',
'end_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'user_challenges',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'user_challenges',
'challenge_definitionId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'challenge_definitions',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'user_challenges',
'status',
{
type: Sequelize.DataTypes.ENUM,
values: ['joined','in_progress','completed','expired','cancelled'],
},
{ transaction }
);
await queryInterface.addColumn(
'user_challenges',
'progress_value',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'user_challenges',
'joined_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'user_challenges',
'completed_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'user_challenges',
'coins_awarded',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_definitions',
'bookId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'books',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_definitions',
'title',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_definitions',
'difficulty',
{
type: Sequelize.DataTypes.ENUM,
values: ['easy','medium','hard'],
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_definitions',
'status',
{
type: Sequelize.DataTypes.ENUM,
values: ['draft','published','archived'],
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_definitions',
'question_count',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_definitions',
'time_limit_seconds',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_definitions',
'generated_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_questions',
'quiz_definitionId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'quiz_definitions',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_questions',
'prompt',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_questions',
'question_type',
{
type: Sequelize.DataTypes.ENUM,
values: ['single_choice','multiple_choice','true_false'],
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_questions',
'explanation',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_questions',
'order_index',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_answer_choices',
'quiz_questionId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'quiz_questions',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_answer_choices',
'choice_text',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_answer_choices',
'is_correct',
{
type: Sequelize.DataTypes.BOOLEAN,
defaultValue: false,
allowNull: false,
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_answer_choices',
'order_index',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_attempts',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_attempts',
'quiz_definitionId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'quiz_definitions',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_attempts',
'status',
{
type: Sequelize.DataTypes.ENUM,
values: ['started','submitted','passed','failed','abandoned'],
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_attempts',
'score_percent',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_attempts',
'correct_count',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_attempts',
'total_count',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_attempts',
'started_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_attempts',
'submitted_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'quiz_attempts',
'coins_awarded',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await queryInterface.addColumn(
'friendships',
'requesterId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'friendships',
'addresseeId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'friendships',
'status',
{
type: Sequelize.DataTypes.ENUM,
values: ['requested','accepted','blocked','declined'],
},
{ transaction }
);
await queryInterface.addColumn(
'friendships',
'requested_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'friendships',
'responded_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'book_clubs',
'name',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'book_clubs',
'description',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'book_clubs',
'visibility',
{
type: Sequelize.DataTypes.ENUM,
values: ['public','private'],
},
{ transaction }
);
await queryInterface.addColumn(
'book_clubs',
'status',
{
type: Sequelize.DataTypes.ENUM,
values: ['active','archived'],
},
{ transaction }
);
await queryInterface.addColumn(
'book_clubs',
'ownerId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'book_clubs',
'created_at_time',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'book_club_memberships',
'book_clubId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'book_clubs',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'book_club_memberships',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'book_club_memberships',
'role',
{
type: Sequelize.DataTypes.ENUM,
values: ['member','moderator','owner'],
},
{ transaction }
);
await queryInterface.addColumn(
'book_club_memberships',
'status',
{
type: Sequelize.DataTypes.ENUM,
values: ['invited','joined','left','banned'],
},
{ transaction }
);
await queryInterface.addColumn(
'book_club_memberships',
'joined_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'club_chat_messages',
'book_clubId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'book_clubs',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'club_chat_messages',
'senderId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'club_chat_messages',
'message_text',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'club_chat_messages',
'sent_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'club_chat_messages',
'is_deleted',
{
type: Sequelize.DataTypes.BOOLEAN,
defaultValue: false,
allowNull: false,
},
{ transaction }
);
await queryInterface.addColumn(
'reading_circle_events',
'book_clubId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'book_clubs',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'reading_circle_events',
'bookId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'books',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'reading_circle_events',
'title',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'reading_circle_events',
'agenda',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'reading_circle_events',
'status',
{
type: Sequelize.DataTypes.ENUM,
values: ['scheduled','ongoing','completed','cancelled'],
},
{ transaction }
);
await queryInterface.addColumn(
'reading_circle_events',
'start_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'reading_circle_events',
'end_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'reading_circle_events',
'meeting_link',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'recommendation_events',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'recommendation_events',
'bookId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'books',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'recommendation_events',
'source',
{
type: Sequelize.DataTypes.ENUM,
values: ['ai','trending','editorial','club'],
},
{ transaction }
);
await queryInterface.addColumn(
'recommendation_events',
'score',
{
type: Sequelize.DataTypes.DECIMAL,
},
{ transaction }
);
await queryInterface.addColumn(
'recommendation_events',
'explanation',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'recommendation_events',
'recommended_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'push_notifications',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'push_notifications',
'title',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'push_notifications',
'body',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'push_notifications',
'status',
{
type: Sequelize.DataTypes.ENUM,
values: ['queued','sent','failed'],
},
{ transaction }
);
await queryInterface.addColumn(
'push_notifications',
'channel',
{
type: Sequelize.DataTypes.ENUM,
values: ['fcm','email','in_app'],
},
{ transaction }
);
await queryInterface.addColumn(
'push_notifications',
'scheduled_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'push_notifications',
'sent_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'push_notifications',
'deep_link',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'fraud_flags',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'fraud_flags',
'scan_sessionId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'camera_scan_sessions',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'fraud_flags',
'severity',
{
type: Sequelize.DataTypes.ENUM,
values: ['low','medium','high','critical'],
},
{ transaction }
);
await queryInterface.addColumn(
'fraud_flags',
'status',
{
type: Sequelize.DataTypes.ENUM,
values: ['open','investigating','resolved','dismissed'],
},
{ transaction }
);
await queryInterface.addColumn(
'fraud_flags',
'reason',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'fraud_flags',
'flagged_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'fraud_flags',
'resolved_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'kyc_verifications',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'kyc_verifications',
'status',
{
type: Sequelize.DataTypes.ENUM,
values: ['not_started','pending','approved','rejected'],
},
{ transaction }
);
await queryInterface.addColumn(
'kyc_verifications',
'document_type',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'kyc_verifications',
'full_name_on_document',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'kyc_verifications',
'document_number',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'kyc_verifications',
'submitted_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'kyc_verifications',
'reviewed_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'kyc_verifications',
'review_note',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'user_uploads',
'userId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await queryInterface.addColumn(
'user_uploads',
'title',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'user_uploads',
'status',
{
type: Sequelize.DataTypes.ENUM,
values: ['uploaded','under_review','approved','rejected'],
},
{ transaction }
);
await queryInterface.addColumn(
'user_uploads',
'content_type',
{
type: Sequelize.DataTypes.ENUM,
values: ['ebook','document','audio','video'],
},
{ transaction }
);
await queryInterface.addColumn(
'user_uploads',
'rejection_reason',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await queryInterface.addColumn(
'user_uploads',
'uploaded_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await queryInterface.addColumn(
'user_uploads',
'reviewed_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'user_uploads',
'reviewed_at',
{ transaction }
);
await queryInterface.removeColumn(
'user_uploads',
'uploaded_at',
{ transaction }
);
await queryInterface.removeColumn(
'user_uploads',
'rejection_reason',
{ transaction }
);
await queryInterface.removeColumn(
'user_uploads',
'content_type',
{ transaction }
);
await queryInterface.removeColumn(
'user_uploads',
'status',
{ transaction }
);
await queryInterface.removeColumn(
'user_uploads',
'title',
{ transaction }
);
await queryInterface.removeColumn(
'user_uploads',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'kyc_verifications',
'review_note',
{ transaction }
);
await queryInterface.removeColumn(
'kyc_verifications',
'reviewed_at',
{ transaction }
);
await queryInterface.removeColumn(
'kyc_verifications',
'submitted_at',
{ transaction }
);
await queryInterface.removeColumn(
'kyc_verifications',
'document_number',
{ transaction }
);
await queryInterface.removeColumn(
'kyc_verifications',
'full_name_on_document',
{ transaction }
);
await queryInterface.removeColumn(
'kyc_verifications',
'document_type',
{ transaction }
);
await queryInterface.removeColumn(
'kyc_verifications',
'status',
{ transaction }
);
await queryInterface.removeColumn(
'kyc_verifications',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'fraud_flags',
'resolved_at',
{ transaction }
);
await queryInterface.removeColumn(
'fraud_flags',
'flagged_at',
{ transaction }
);
await queryInterface.removeColumn(
'fraud_flags',
'reason',
{ transaction }
);
await queryInterface.removeColumn(
'fraud_flags',
'status',
{ transaction }
);
await queryInterface.removeColumn(
'fraud_flags',
'severity',
{ transaction }
);
await queryInterface.removeColumn(
'fraud_flags',
'scan_sessionId',
{ transaction }
);
await queryInterface.removeColumn(
'fraud_flags',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'push_notifications',
'deep_link',
{ transaction }
);
await queryInterface.removeColumn(
'push_notifications',
'sent_at',
{ transaction }
);
await queryInterface.removeColumn(
'push_notifications',
'scheduled_at',
{ transaction }
);
await queryInterface.removeColumn(
'push_notifications',
'channel',
{ transaction }
);
await queryInterface.removeColumn(
'push_notifications',
'status',
{ transaction }
);
await queryInterface.removeColumn(
'push_notifications',
'body',
{ transaction }
);
await queryInterface.removeColumn(
'push_notifications',
'title',
{ transaction }
);
await queryInterface.removeColumn(
'push_notifications',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'recommendation_events',
'recommended_at',
{ transaction }
);
await queryInterface.removeColumn(
'recommendation_events',
'explanation',
{ transaction }
);
await queryInterface.removeColumn(
'recommendation_events',
'score',
{ transaction }
);
await queryInterface.removeColumn(
'recommendation_events',
'source',
{ transaction }
);
await queryInterface.removeColumn(
'recommendation_events',
'bookId',
{ transaction }
);
await queryInterface.removeColumn(
'recommendation_events',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'reading_circle_events',
'meeting_link',
{ transaction }
);
await queryInterface.removeColumn(
'reading_circle_events',
'end_at',
{ transaction }
);
await queryInterface.removeColumn(
'reading_circle_events',
'start_at',
{ transaction }
);
await queryInterface.removeColumn(
'reading_circle_events',
'status',
{ transaction }
);
await queryInterface.removeColumn(
'reading_circle_events',
'agenda',
{ transaction }
);
await queryInterface.removeColumn(
'reading_circle_events',
'title',
{ transaction }
);
await queryInterface.removeColumn(
'reading_circle_events',
'bookId',
{ transaction }
);
await queryInterface.removeColumn(
'reading_circle_events',
'book_clubId',
{ transaction }
);
await queryInterface.removeColumn(
'club_chat_messages',
'is_deleted',
{ transaction }
);
await queryInterface.removeColumn(
'club_chat_messages',
'sent_at',
{ transaction }
);
await queryInterface.removeColumn(
'club_chat_messages',
'message_text',
{ transaction }
);
await queryInterface.removeColumn(
'club_chat_messages',
'senderId',
{ transaction }
);
await queryInterface.removeColumn(
'club_chat_messages',
'book_clubId',
{ transaction }
);
await queryInterface.removeColumn(
'book_club_memberships',
'joined_at',
{ transaction }
);
await queryInterface.removeColumn(
'book_club_memberships',
'status',
{ transaction }
);
await queryInterface.removeColumn(
'book_club_memberships',
'role',
{ transaction }
);
await queryInterface.removeColumn(
'book_club_memberships',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'book_club_memberships',
'book_clubId',
{ transaction }
);
await queryInterface.removeColumn(
'book_clubs',
'created_at_time',
{ transaction }
);
await queryInterface.removeColumn(
'book_clubs',
'ownerId',
{ transaction }
);
await queryInterface.removeColumn(
'book_clubs',
'status',
{ transaction }
);
await queryInterface.removeColumn(
'book_clubs',
'visibility',
{ transaction }
);
await queryInterface.removeColumn(
'book_clubs',
'description',
{ transaction }
);
await queryInterface.removeColumn(
'book_clubs',
'name',
{ transaction }
);
await queryInterface.removeColumn(
'friendships',
'responded_at',
{ transaction }
);
await queryInterface.removeColumn(
'friendships',
'requested_at',
{ transaction }
);
await queryInterface.removeColumn(
'friendships',
'status',
{ transaction }
);
await queryInterface.removeColumn(
'friendships',
'addresseeId',
{ transaction }
);
await queryInterface.removeColumn(
'friendships',
'requesterId',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_attempts',
'coins_awarded',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_attempts',
'submitted_at',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_attempts',
'started_at',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_attempts',
'total_count',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_attempts',
'correct_count',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_attempts',
'score_percent',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_attempts',
'status',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_attempts',
'quiz_definitionId',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_attempts',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_answer_choices',
'order_index',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_answer_choices',
'is_correct',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_answer_choices',
'choice_text',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_answer_choices',
'quiz_questionId',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_questions',
'order_index',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_questions',
'explanation',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_questions',
'question_type',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_questions',
'prompt',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_questions',
'quiz_definitionId',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_definitions',
'generated_at',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_definitions',
'time_limit_seconds',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_definitions',
'question_count',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_definitions',
'status',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_definitions',
'difficulty',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_definitions',
'title',
{ transaction }
);
await queryInterface.removeColumn(
'quiz_definitions',
'bookId',
{ transaction }
);
await queryInterface.removeColumn(
'user_challenges',
'coins_awarded',
{ transaction }
);
await queryInterface.removeColumn(
'user_challenges',
'completed_at',
{ transaction }
);
await queryInterface.removeColumn(
'user_challenges',
'joined_at',
{ transaction }
);
await queryInterface.removeColumn(
'user_challenges',
'progress_value',
{ transaction }
);
await queryInterface.removeColumn(
'user_challenges',
'status',
{ transaction }
);
await queryInterface.removeColumn(
'user_challenges',
'challenge_definitionId',
{ transaction }
);
await queryInterface.removeColumn(
'user_challenges',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'challenge_definitions',
'end_at',
{ transaction }
);
await queryInterface.removeColumn(
'challenge_definitions',
'start_at',
{ transaction }
);
await queryInterface.removeColumn(
'challenge_definitions',
'reward_coins',
{ transaction }
);
await queryInterface.removeColumn(
'challenge_definitions',
'target_value',
{ transaction }
);
await queryInterface.removeColumn(
'challenge_definitions',
'challenge_type',
{ transaction }
);
await queryInterface.removeColumn(
'challenge_definitions',
'status',
{ transaction }
);
await queryInterface.removeColumn(
'challenge_definitions',
'description',
{ transaction }
);
await queryInterface.removeColumn(
'challenge_definitions',
'name',
{ transaction }
);
await queryInterface.removeColumn(
'user_ranks',
'updated_at_time',
{ transaction }
);
await queryInterface.removeColumn(
'user_ranks',
'rank_points',
{ transaction }
);
await queryInterface.removeColumn(
'user_ranks',
'rank_tierId',
{ transaction }
);
await queryInterface.removeColumn(
'user_ranks',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'rank_tiers',
'description',
{ transaction }
);
await queryInterface.removeColumn(
'rank_tiers',
'max_points',
{ transaction }
);
await queryInterface.removeColumn(
'rank_tiers',
'min_points',
{ transaction }
);
await queryInterface.removeColumn(
'rank_tiers',
'name',
{ transaction }
);
await queryInterface.removeColumn(
'user_achievements',
'notified',
{ transaction }
);
await queryInterface.removeColumn(
'user_achievements',
'progress_value',
{ transaction }
);
await queryInterface.removeColumn(
'user_achievements',
'earned_at',
{ transaction }
);
await queryInterface.removeColumn(
'user_achievements',
'achievement_definitionId',
{ transaction }
);
await queryInterface.removeColumn(
'user_achievements',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'achievement_definitions',
'active',
{ transaction }
);
await queryInterface.removeColumn(
'achievement_definitions',
'metric',
{ transaction }
);
await queryInterface.removeColumn(
'achievement_definitions',
'target_value',
{ transaction }
);
await queryInterface.removeColumn(
'achievement_definitions',
'rarity',
{ transaction }
);
await queryInterface.removeColumn(
'achievement_definitions',
'category',
{ transaction }
);
await queryInterface.removeColumn(
'achievement_definitions',
'description',
{ transaction }
);
await queryInterface.removeColumn(
'achievement_definitions',
'name',
{ transaction }
);
await queryInterface.removeColumn(
'reading_streaks',
'started_at',
{ transaction }
);
await queryInterface.removeColumn(
'reading_streaks',
'last_streak_date',
{ transaction }
);
await queryInterface.removeColumn(
'reading_streaks',
'best_streak_days',
{ transaction }
);
await queryInterface.removeColumn(
'reading_streaks',
'current_streak_days',
{ transaction }
);
await queryInterface.removeColumn(
'reading_streaks',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'daily_login_rewards',
'streak_day',
{ transaction }
);
await queryInterface.removeColumn(
'daily_login_rewards',
'coins_awarded',
{ transaction }
);
await queryInterface.removeColumn(
'daily_login_rewards',
'rewarded_at',
{ transaction }
);
await queryInterface.removeColumn(
'daily_login_rewards',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'payment_transactions',
'finalized_at',
{ transaction }
);
await queryInterface.removeColumn(
'payment_transactions',
'initiated_at',
{ transaction }
);
await queryInterface.removeColumn(
'payment_transactions',
'failure_reason',
{ transaction }
);
await queryInterface.removeColumn(
'payment_transactions',
'provider_transaction_reference',
{ transaction }
);
await queryInterface.removeColumn(
'payment_transactions',
'amount_uzs',
{ transaction }
);
await queryInterface.removeColumn(
'payment_transactions',
'provider',
{ transaction }
);
await queryInterface.removeColumn(
'payment_transactions',
'status',
{ transaction }
);
await queryInterface.removeColumn(
'payment_transactions',
'withdrawal_requestId',
{ transaction }
);
await queryInterface.removeColumn(
'withdrawal_requests',
'processed_at',
{ transaction }
);
await queryInterface.removeColumn(
'withdrawal_requests',
'requested_at',
{ transaction }
);
await queryInterface.removeColumn(
'withdrawal_requests',
'admin_note',
{ transaction }
);
await queryInterface.removeColumn(
'withdrawal_requests',
'provider_reference',
{ transaction }
);
await queryInterface.removeColumn(
'withdrawal_requests',
'payout_destination',
{ transaction }
);
await queryInterface.removeColumn(
'withdrawal_requests',
'payout_method',
{ transaction }
);
await queryInterface.removeColumn(
'withdrawal_requests',
'cash_amount_uzs',
{ transaction }
);
await queryInterface.removeColumn(
'withdrawal_requests',
'coins_amount',
{ transaction }
);
await queryInterface.removeColumn(
'withdrawal_requests',
'status',
{ transaction }
);
await queryInterface.removeColumn(
'withdrawal_requests',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'coin_ledger_entries',
'bookId',
{ transaction }
);
await queryInterface.removeColumn(
'coin_ledger_entries',
'scan_sessionId',
{ transaction }
);
await queryInterface.removeColumn(
'coin_ledger_entries',
'occurred_at',
{ transaction }
);
await queryInterface.removeColumn(
'coin_ledger_entries',
'description',
{ transaction }
);
await queryInterface.removeColumn(
'coin_ledger_entries',
'amount_coins',
{ transaction }
);
await queryInterface.removeColumn(
'coin_ledger_entries',
'reason',
{ transaction }
);
await queryInterface.removeColumn(
'coin_ledger_entries',
'entry_type',
{ transaction }
);
await queryInterface.removeColumn(
'coin_ledger_entries',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'camera_scan_sessions',
'coins_awarded',
{ transaction }
);
await queryInterface.removeColumn(
'camera_scan_sessions',
'fraud_reason',
{ transaction }
);
await queryInterface.removeColumn(
'camera_scan_sessions',
'duplicate_page_detected',
{ transaction }
);
await queryInterface.removeColumn(
'camera_scan_sessions',
'page_turning_detected',
{ transaction }
);
await queryInterface.removeColumn(
'camera_scan_sessions',
'confidence_score',
{ transaction }
);
await queryInterface.removeColumn(
'camera_scan_sessions',
'pages_detected',
{ transaction }
);
await queryInterface.removeColumn(
'camera_scan_sessions',
'frames_analyzed',
{ transaction }
);
await queryInterface.removeColumn(
'camera_scan_sessions',
'ended_at',
{ transaction }
);
await queryInterface.removeColumn(
'camera_scan_sessions',
'started_at',
{ transaction }
);
await queryInterface.removeColumn(
'camera_scan_sessions',
'status',
{ transaction }
);
await queryInterface.removeColumn(
'camera_scan_sessions',
'scan_type',
{ transaction }
);
await queryInterface.removeColumn(
'camera_scan_sessions',
'bookId',
{ transaction }
);
await queryInterface.removeColumn(
'camera_scan_sessions',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'notes',
'noted_at',
{ transaction }
);
await queryInterface.removeColumn(
'notes',
'is_private',
{ transaction }
);
await queryInterface.removeColumn(
'notes',
'content',
{ transaction }
);
await queryInterface.removeColumn(
'notes',
'title',
{ transaction }
);
await queryInterface.removeColumn(
'notes',
'location',
{ transaction }
);
await queryInterface.removeColumn(
'notes',
'bookId',
{ transaction }
);
await queryInterface.removeColumn(
'notes',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'bookmarks',
'added_at',
{ transaction }
);
await queryInterface.removeColumn(
'bookmarks',
'label',
{ transaction }
);
await queryInterface.removeColumn(
'bookmarks',
'location',
{ transaction }
);
await queryInterface.removeColumn(
'bookmarks',
'bookId',
{ transaction }
);
await queryInterface.removeColumn(
'bookmarks',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'user_library_items',
'completed_at',
{ transaction }
);
await queryInterface.removeColumn(
'user_library_items',
'last_opened_at',
{ transaction }
);
await queryInterface.removeColumn(
'user_library_items',
'current_location',
{ transaction }
);
await queryInterface.removeColumn(
'user_library_items',
'progress_percent',
{ transaction }
);
await queryInterface.removeColumn(
'user_library_items',
'downloaded_at',
{ transaction }
);
await queryInterface.removeColumn(
'user_library_items',
'offline_downloaded',
{ transaction }
);
await queryInterface.removeColumn(
'user_library_items',
'status',
{ transaction }
);
await queryInterface.removeColumn(
'user_library_items',
'source',
{ transaction }
);
await queryInterface.removeColumn(
'user_library_items',
'bookId',
{ transaction }
);
await queryInterface.removeColumn(
'user_library_items',
'userId',
{ transaction }
);
await queryInterface.removeColumn(
'books',
'publisherId',
{ transaction }
);
await queryInterface.removeColumn(
'books',
'published_at',
{ transaction }
);
await queryInterface.removeColumn(
'books',
'popularity_score',
{ transaction }
);
await queryInterface.removeColumn(
'books',
'difficulty_score',
{ transaction }
);
await queryInterface.removeColumn(
'books',
'duration_seconds',
{ transaction }
);
await queryInterface.removeColumn(
'books',
'word_count',
{ transaction }
);
await queryInterface.removeColumn(
'books',
'page_count',
{ transaction }
);
await queryInterface.removeColumn(
'books',
'description',
{ transaction }
);
await queryInterface.removeColumn(
'books',
'status',
{ transaction }
);
await queryInterface.removeColumn(
'books',
'format',
{ transaction }
);
await queryInterface.removeColumn(
'books',
'language',
{ transaction }
);
await queryInterface.removeColumn(
'books',
'isbn',
{ transaction }
);
await queryInterface.removeColumn(
'books',
'subtitle',
{ transaction }
);
await queryInterface.removeColumn(
'books',
'title',
{ transaction }
);
await queryInterface.removeColumn(
'genres',
'description',
{ transaction }
);
await queryInterface.removeColumn(
'genres',
'name',
{ transaction }
);
await queryInterface.removeColumn(
'authors',
'primary_language',
{ transaction }
);
await queryInterface.removeColumn(
'authors',
'website_url',
{ transaction }
);
await queryInterface.removeColumn(
'authors',
'bio',
{ transaction }
);
await queryInterface.removeColumn(
'authors',
'name',
{ transaction }
);
await queryInterface.removeColumn(
'publishers',
'description',
{ transaction }
);
await queryInterface.removeColumn(
'publishers',
'website_url',
{ transaction }
);
await queryInterface.removeColumn(
'publishers',
'country',
{ transaction }
);
await queryInterface.removeColumn(
'publishers',
'name',
{ transaction }
);
await queryInterface.removeColumn(
'permissions',
'name',
{ transaction }
);
await queryInterface.removeColumn(
'roles',
'role_customization',
{ transaction }
);
await queryInterface.removeColumn(
'roles',
'name',
{ transaction }
);
await queryInterface.removeColumn(
'users',
'app_roleId',
{ transaction }
);
await queryInterface.removeColumn(
'users',
'provider',
{ transaction }
);
await queryInterface.removeColumn(
'users',
'passwordResetTokenExpiresAt',
{ transaction }
);
await queryInterface.removeColumn(
'users',
'passwordResetToken',
{ transaction }
);
await queryInterface.removeColumn(
'users',
'emailVerificationTokenExpiresAt',
{ transaction }
);
await queryInterface.removeColumn(
'users',
'emailVerificationToken',
{ transaction }
);
await queryInterface.removeColumn(
'users',
'emailVerified',
{ transaction }
);
await queryInterface.removeColumn(
'users',
'password',
{ transaction }
);
await queryInterface.removeColumn(
'users',
'disabled',
{ transaction }
);
await queryInterface.removeColumn(
'users',
'email',
{ transaction }
);
await queryInterface.removeColumn(
'users',
'phoneNumber',
{ transaction }
);
await queryInterface.removeColumn(
'users',
'lastName',
{ transaction }
);
await queryInterface.removeColumn(
'users',
'firstName',
{ transaction }
);
await queryInterface.dropTable('user_uploads', { transaction });
await queryInterface.dropTable('kyc_verifications', { transaction });
await queryInterface.dropTable('fraud_flags', { transaction });
await queryInterface.dropTable('push_notifications', { transaction });
await queryInterface.dropTable('recommendation_events', { transaction });
await queryInterface.dropTable('reading_circle_events', { transaction });
await queryInterface.dropTable('club_chat_messages', { transaction });
await queryInterface.dropTable('book_club_memberships', { transaction });
await queryInterface.dropTable('book_clubs', { transaction });
await queryInterface.dropTable('friendships', { transaction });
await queryInterface.dropTable('quiz_attempts', { transaction });
await queryInterface.dropTable('quiz_answer_choices', { transaction });
await queryInterface.dropTable('quiz_questions', { transaction });
await queryInterface.dropTable('quiz_definitions', { transaction });
await queryInterface.dropTable('user_challenges', { transaction });
await queryInterface.dropTable('challenge_definitions', { transaction });
await queryInterface.dropTable('user_ranks', { transaction });
await queryInterface.dropTable('rank_tiers', { transaction });
await queryInterface.dropTable('user_achievements', { transaction });
await queryInterface.dropTable('achievement_definitions', { transaction });
await queryInterface.dropTable('reading_streaks', { transaction });
await queryInterface.dropTable('daily_login_rewards', { transaction });
await queryInterface.dropTable('payment_transactions', { transaction });
await queryInterface.dropTable('withdrawal_requests', { transaction });
await queryInterface.dropTable('coin_ledger_entries', { transaction });
await queryInterface.dropTable('camera_scan_sessions', { transaction });
await queryInterface.dropTable('notes', { transaction });
await queryInterface.dropTable('bookmarks', { transaction });
await queryInterface.dropTable('user_library_items', { transaction });
await queryInterface.dropTable('books', { transaction });
await queryInterface.dropTable('genres', { transaction });
await queryInterface.dropTable('authors', { transaction });
await queryInterface.dropTable('publishers', { transaction });
await queryInterface.dropTable('permissions', { transaction });
await queryInterface.dropTable('roles', { transaction });
await queryInterface.dropTable('users', { transaction });
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};
Reference in New Issue View Git Blame Copy Permalink