floriday/models/index.js

import { Sequelize } from 'sequelize';
import dotenv from 'dotenv';
import chalk from 'chalk';
import ora from 'ora';
import { criticalError, updateClientConfig } from './../utils.js';

dotenv.config();
const env = process.env;

console.clear()
console.log(chalk.hex('#06c581')(
    `
    ███████ ██      ██████  ██████  ██ ██████   █████  ██    ██     ██
    ██      ██     ██    ██ ██   ██ ██ ██   ██ ██   ██ ██    ██    ██  ███
    █████   ██     ██    ██ ██████  ██ ██   ██ ███████  ███████       ███
    ██      ██     ██    ██ ██   ██ ██ ██   ██ ██   ██       ██     ████
    ██      ██████  ██████  ██   ██ ██ ██████  ██   ██ ███████     ██
    `
))

let sequelize, conSpinner
try {
    conSpinner = ora('Creating connection...').start();
    sequelize = createConn();
    await checkConn();
    conSpinner.succeed();
} catch (err) {
    conSpinner.fail();
    criticalError(err);
}

// Supply Line Models
import supplyLine from './supplyLine/supplyLine.js';
import volumePrices from './supplyLine/volumePrices.js';

// Conf Models
import clientConfig from './conf/clientConfig.js';
import sequenceNumber from './conf/sequenceNumber.js';

// Supplier Models
import suppliers from './supplier/suppliers.js';
import connections from './supplier/connections.js';

// TradeItem Models
import tradeItem from './tradeItem/tradeItem.js';
import botanicalNames from './tradeItem/botanicalNames.js';
import countryOfOriginIsoCodes from './tradeItem/countryOfOriginIsoCodes.js';
import packageModel from './tradeItem/package.js';
import packingConfigurations from './tradeItem/packingConfigurations.js';
import photos from './tradeItem/photos.js';
import seasonalPeriod from './tradeItem/seasonalPeriod.js';
import characteristics from './tradeItem/characteristics.js';

/**
 * Contains all the models that are related to the application.
 * 
 * @example
 * models.@modelName@.findAll();
 * 
 * @example
 * models.tradeItem.findAll().then((data) => {
 *    console.log(data);
 * });
 * 
 * @example
 * models.tradeItem.create({
 *   tradeItemName: 'Test',
 *   foo: 'bar',
 * });
 * 
 * 
 * @type {Object.<string, Sequelize.Model>}
 */
let models = {
    sequelize: sequelize,
    tradeItem: tradeItem(sequelize),
    packingConfiguration: packingConfigurations(sequelize),
    photo: photos(sequelize),
    characteristic: characteristics(sequelize),
    countryOfOriginIsoCode: countryOfOriginIsoCodes(sequelize),
    package: packageModel(sequelize),
    seasonalPeriod: seasonalPeriod(sequelize),
    clientConfig: clientConfig(sequelize),
    botanicalName: botanicalNames(sequelize),
    supplyLine: supplyLine(sequelize),
    volumePrice: volumePrices(sequelize),
    supplier: suppliers(sequelize),
    sequenceNumber: sequenceNumber(sequelize),
    connection: connections(sequelize),
};

try {
    /* Remove ID atribute from models */
    models.characteristic.removeAttribute('id');
    models.seasonalPeriod.removeAttribute('id');
    models.package.removeAttribute('id');
    models.botanicalName.removeAttribute('id');
    models.countryOfOriginIsoCode.removeAttribute('id');
    /* ------------------------------ */

    models.characteristic.belongsTo(models.tradeItem, {
        foreignKey: 'tradeItemFk',
        as: 'tradeItem_Fk',
        targetKey: 'tradeItemId',
    });

    models.seasonalPeriod.belongsTo(models.tradeItem, {
        foreignKey: 'tradeItemFk',
        as: 'tradeItem_Fk',
        targetKey: 'tradeItemId',
    });

    models.photo.belongsTo(models.tradeItem, {
        foreignKey: 'tradeItemFk',
        as: 'tradeItem_Fk',
        targetKey: 'tradeItemId',
    });

    models.packingConfiguration.belongsTo(models.tradeItem, {
        foreignKey: 'tradeItemFk',
        as: 'tradeItem_Fk',
        targetKey: 'tradeItemId',
    });

    models.packingConfiguration.hasMany(models.package, {
        foreignKey: 'packingConfigurationFk',
        as: 'package_Fk',
        targetKey: 'packingConfigurationId',
    });

    models.package.belongsTo(models.packingConfiguration, {
        foreignKey: 'packingConfigurationFk',
        as: 'packingConfiguration_Fk',
        targetKey: 'packingConfigurationId',
    });


    models.botanicalName.belongsTo(models.tradeItem, {
        foreignKey: 'tradeItemFk',
        as: 'tradeItem_Fk',
        targetKey: 'tradeItemId',
    });

    models.countryOfOriginIsoCode.belongsTo(models.tradeItem, {
        foreignKey: 'tradeItemFk',
        as: 'tradeItem_Fk',
        targetKey: 'tradeItemId',
    });

    models.volumePrice.belongsTo(models.supplyLine, {
        foreignKey: 'supplyLineFk',
        as: 'supplyLine_Fk',
        targetKey: 'supplyLineId',
    });

    models.supplyLine.belongsTo(models.tradeItem, {
        foreignKey: 'tradeItemFk',
        as: 'tradeItem_Fk',
        targetKey: 'tradeItemId',
    });

    models.tradeItem.belongsTo(models.supplier, {
        foreignKey: 'supplierOrganizationId',
        as: 'supplierOrganization_Id',
        targetKey: 'organizationId',
    });
} catch (err) {
    throw new Error(err)
}

let action, isForce;
if (JSON.parse(process.env.FORCE_SYNC)) {
    action = 'Forcing'
    isForce = true
} else {
    action = 'Altering'
    isForce = false
}

const modSpinner = ora(`${action} models...`).start();
try {
    await sequelize.sync({ force: isForce });
    modSpinner.succeed();
}
catch (err) {
    modSpinner.fail();
    criticalError(err);
}

/**
 * Creates the connection to the database.
 * 
 * @returns {Sequelize} Sequelize instance with the connection to the database.
 */
function createConn() {
    return new Sequelize(process.env.DB_SCHEMA, process.env.DB_USER, process.env.DB_PWD, {
        host: process.env.DB_HOST,
        dialect: process.env.DB_DIALECT,
        logging: false,
        pool: {
            max: parseInt(process.env.DB_MAX_CONN_POOL),
            acquire: 60000,
            idle: 10000,
        },
    });
}

/**
 * Check if connection is ok
 */
async function checkConn() {
    try {
        await sequelize.authenticate();
    } catch (err) {
        throw new Error (err);
    } 
}

/**
 * Close connection
 */
async function closeConn() {
    const spinner = ora('Stopping connection...').start();
    try {
        await sequelize.close()
        spinner.succeed();
    } catch (err) {
        spinner.fail();
        criticalError(err)
    }
}

export { models, checkConn, closeConn};