653 lines
19 KiB
JavaScript
653 lines
19 KiB
JavaScript
import { models } from './models/sequelize.js';
|
|
import { Op } from 'sequelize';
|
|
import { v4 as uuidv4 } from 'uuid';
|
|
import axios from 'axios';
|
|
import moment from 'moment';
|
|
import chalk from 'chalk';
|
|
import ora from 'ora';
|
|
|
|
const env = process.env;
|
|
|
|
/**
|
|
* Gets the Access Token.
|
|
*
|
|
* @param {Boolean} isForce Force to request new token
|
|
*/
|
|
export async function requestToken(isForce = false) {
|
|
let spinner = ora(`Requesting new token...`).start();
|
|
try {
|
|
const clientConfigData = await models.config.findOne();
|
|
|
|
let tokenExpiration, token;
|
|
if (clientConfigData) {
|
|
token = clientConfigData.currentToken;
|
|
tokenExpiration = clientConfigData.tokenExpiration;
|
|
}
|
|
|
|
if (isForce || !token || !tokenExpiration || moment().isAfter(tokenExpiration)) {
|
|
const clientId = JSON.parse(env.USE_SECRETS_DB) ? clientConfigData.clientId || env.CLIENT_ID : env.CLIENT_ID;
|
|
const clientSecret = JSON.parse(env.USE_SECRETS_DB) ? clientConfigData.clientSecret || env.CLIENT_SECRET : env.CLIENT_SECRET;
|
|
|
|
const data = new URLSearchParams({
|
|
grant_type: 'client_credentials',
|
|
client_id: clientId,
|
|
client_secret: clientSecret,
|
|
scope: 'role:app catalog:read supply:read organization:read network:write network:read'
|
|
}).toString();
|
|
const headers = { 'Content-Type': 'application/x-www-form-urlencoded' };
|
|
const response = (await vnRequest('POST', env.API_ENDPOINT, data, headers, spinner)).data;
|
|
|
|
const tokenExpiration = moment()
|
|
.add(response.expires_in, 's')
|
|
.format('YYYY-MM-DD HH:mm:ss');
|
|
|
|
await updateClientConfig({
|
|
clientId,
|
|
clientSecret,
|
|
currentToken: response.access_token,
|
|
tokenExpiration,
|
|
});
|
|
spinner.succeed();
|
|
} else
|
|
spinner.succeed('Using stored token...');
|
|
} catch (err) {
|
|
spinner.fail();
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the current token.
|
|
*
|
|
* @returns {string}
|
|
*/
|
|
export async function getCurrentToken() {
|
|
return (await models.config.findOne()).currentToken;
|
|
}
|
|
|
|
/**
|
|
* Check the floriday data config.
|
|
*/
|
|
export async function checkConfig() {
|
|
const spinner = ora(`Checking config...`).start();
|
|
|
|
const excludedEnvVars = ['VSCODE_GIT_ASKPASS_EXTRA_ARGS'];
|
|
const requiredEnvVars = Object.keys(env);
|
|
const filteredEnvVars = requiredEnvVars.filter(reqEnvVar => !excludedEnvVars.includes(reqEnvVar));
|
|
|
|
for (const reqEnvVar of filteredEnvVars) {
|
|
if (!process.env[reqEnvVar]) {
|
|
spinner.fail();
|
|
throw new Error(`You haven't provided the ${reqEnvVar} environment variable`);
|
|
}
|
|
}
|
|
const clientConfigData = await models.config.findOne();
|
|
if (!clientConfigData)
|
|
await updateClientConfig(env.CLIENT_ID, env.CLIENT_SECRET);
|
|
|
|
spinner.succeed();
|
|
}
|
|
|
|
/**
|
|
* Returns the expiration of current token.
|
|
*
|
|
* @returns {string}
|
|
*/
|
|
export async function getCurrentTokenExpiration() {
|
|
return (await models.config.findOne()).tokenExpiration;
|
|
}
|
|
|
|
/**
|
|
* Updates the access token in the client config table.
|
|
*
|
|
* @param {Array} clientConfig [clientId, clientSecret, currenToken, tokenExpiration]
|
|
*/
|
|
export async function updateClientConfig(clientConfig) {
|
|
try {
|
|
if (!JSON.parse(process.env.USE_SECRETS_DB))
|
|
clientId = clientSecret = null
|
|
await models.config.upsert({
|
|
id: 1,
|
|
...clientConfig,
|
|
});
|
|
} catch (err) {
|
|
throw(err);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Pauses the execution of the script for the specified number of milliseconds.
|
|
*
|
|
* @param {Integer} ms
|
|
*/
|
|
export async function sleep(ms) {
|
|
await new Promise(resolve => setTimeout(resolve, ms));
|
|
}
|
|
|
|
/**
|
|
* Sync a model.
|
|
*
|
|
* @param {String} model (organization | tradeItem | supplyLine | clockPresaleSupply)
|
|
*/
|
|
export async function syncModel(model) {
|
|
let spinner = ora(`Syncing ${model}...`).start();
|
|
let i = 1;
|
|
try {
|
|
const dbSeqNum = await models.sequenceNumber.findOne({ where: { model } })
|
|
let curSeqNum = dbSeqNum?.maxSequenceNumber ?? 0;
|
|
|
|
let maxSeqUrl, syncUrl;
|
|
switch (model) {
|
|
case 'organization':
|
|
maxSeqUrl = `${env.API_URL}/organizations/current-max-sequence`;
|
|
syncUrl = `${env.API_URL}/organizations/sync/`;
|
|
break;
|
|
case 'warehouse':
|
|
maxSeqUrl = `${env.API_URL}/warehouses/current-max-sequence`;
|
|
syncUrl = `${env.API_URL}/warehouses/sync/`;
|
|
break;
|
|
case 'tradeItem':
|
|
maxSeqUrl = `${env.API_URL}/trade-items/current-max-sequence`;
|
|
syncUrl = `${env.API_URL}/trade-items/sync/`;
|
|
break;
|
|
case 'supplyLine':
|
|
maxSeqUrl = `${env.API_URL}/supply-lines/current-max-sequence`;
|
|
syncUrl = `${env.API_URL}/supply-lines/sync/`;
|
|
break;
|
|
case 'clockPresaleSupply':
|
|
maxSeqUrl = `${env.API_URL}/auction/clock-presales-supply/max-sequence-number`;
|
|
syncUrl = `${env.API_URL}/auction/clock-presales-supply/sync/`;
|
|
break;
|
|
default:
|
|
throw new Error('Unsupported model');
|
|
}
|
|
|
|
const maxSeqNum = (await vnRequest('GET', maxSeqUrl, null, null, spinner)).data;
|
|
for (curSeqNum; curSeqNum < maxSeqNum; curSeqNum++) {
|
|
let params, misSeqNum;
|
|
if (model === 'organization')
|
|
params = new URLSearchParams({organizationType: 'SUPPLIER'}).toString();
|
|
else if (model === 'supplyLine')
|
|
params = new URLSearchParams({postFilterSelectedTradeItems: false}).toString();
|
|
|
|
const res = (await vnRequest('GET', `${syncUrl}${curSeqNum}${params ? `?${params}` : ''}`, null, null, spinner)).data;
|
|
curSeqNum = res.maximumSequenceNumber;
|
|
const objects = res.results;
|
|
misSeqNum = maxSeqNum - curSeqNum;
|
|
spinner.text = `Syncing ${i - 1} ${model}, ${misSeqNum} missing...`;
|
|
for (let object of objects) {
|
|
switch (model) {
|
|
case 'organization':
|
|
await insertOrganization(object);
|
|
break;
|
|
case 'warehouse':
|
|
await insertWarehouse(object);
|
|
break;
|
|
case 'tradeItem':
|
|
await insertTradeItem(object);
|
|
break;
|
|
case 'supplyLine':
|
|
await insertSupplyLine(object);
|
|
break;
|
|
case 'clockPresaleSupply':
|
|
await insertClockPresalesSupply(object);
|
|
break;
|
|
default:
|
|
throw new Error('Unsupported model');
|
|
}
|
|
|
|
spinner.text = `Syncing ${i++} ${model}, ${misSeqNum} missing...`
|
|
};
|
|
|
|
await insertSequenceNumber(model, curSeqNum);
|
|
}
|
|
if (curSeqNum < maxSeqNum)
|
|
await insertSequenceNumber(model, maxSeqNum);
|
|
spinner.text = (i != 1)
|
|
? `Syncing ${i} ${model}...`
|
|
: `Syncing ${model}... ${chalk.gray('(Not found)')}`;
|
|
spinner.succeed();
|
|
} catch (err) {
|
|
spinner.fail();
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Create the connections in Floriday.
|
|
*/
|
|
export async function syncConnections(){
|
|
await deleteConnections();
|
|
|
|
let spinner;
|
|
try {
|
|
let connectionsInDb = await models.organization.findAll({
|
|
where: {
|
|
isConnected: true,
|
|
companyGln: {
|
|
[Op.ne]: null
|
|
},
|
|
rfhRelationId: {
|
|
[Op.ne]: null
|
|
},
|
|
}
|
|
});
|
|
|
|
const connectionsInFloriday = (await vnRequest('GET', `${env.API_URL}/connections`, null, null, spinner)).data;
|
|
|
|
let isExists = false, connectionsToPut = [];
|
|
for (let connectionInDb of connectionsInDb) {
|
|
for (let connectionInFloriday of connectionsInFloriday)
|
|
if (connectionInFloriday == connectionInDb.organizationId) {
|
|
isExists = true;
|
|
break;
|
|
}
|
|
if (!isExists) connectionsToPut.push(connectionInDb.organizationId)
|
|
isExists = false;
|
|
}
|
|
|
|
if (connectionsToPut.length) spinner = ora(`Creating connections in Floriday...`).start();
|
|
|
|
let i = 1;
|
|
for (let connection of connectionsToPut) {
|
|
spinner.text = `Creating ${i++} of ${connectionsToPut.length} connections in Floriday...`
|
|
await vnRequest('PUT', `${env.API_URL}/connections/${connection}`, null, null, spinner);
|
|
}
|
|
if (spinner) spinner.succeed();
|
|
} catch (err) {
|
|
if (spinner) spinner.fail();
|
|
throw new Error(err);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Insert sequence number in the database.
|
|
*
|
|
* @param {String} model
|
|
* @param {Number} sequenceNumber
|
|
*/
|
|
export async function insertSequenceNumber(model, sequenceNumber) {
|
|
const tx = await models.sequelize.transaction();
|
|
try {
|
|
await models.sequenceNumber.upsert({
|
|
model: model,
|
|
maxSequenceNumber: sequenceNumber,
|
|
}, { transaction: tx });
|
|
await tx.commit();
|
|
} catch (err) {
|
|
await tx.rollback();
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Insert trade item and dependences in the database.
|
|
*
|
|
* @param {Array} tradeItem
|
|
*/
|
|
export async function insertTradeItem(tradeItem) {
|
|
const tx = await models.sequelize.transaction();
|
|
try {
|
|
// Upsert trade item
|
|
await models.tradeItem.upsert({
|
|
...tradeItem,
|
|
organizationId: tradeItem.supplierOrganizationId,
|
|
lastSync: moment(),
|
|
}, { transaction: tx });
|
|
|
|
// Upsert characteristics
|
|
if (tradeItem.characteristics)
|
|
if (tradeItem.characteristics.length)
|
|
for (const characteristic of tradeItem.characteristics) {
|
|
await models.characteristic.upsert({
|
|
tradeItemId: tradeItem.tradeItemId,
|
|
...characteristic,
|
|
}, { transaction: tx });
|
|
}
|
|
// Upsert seasonal periods
|
|
if (tradeItem.seasonalPeriods)
|
|
if (tradeItem.seasonalPeriods.length)
|
|
for (const seasonalPeriod of tradeItem.seasonalPeriods) {
|
|
await models.seasonalPeriod.upsert({
|
|
tradeItemId: tradeItem.tradeItemId,
|
|
...seasonalPeriod,
|
|
}, { transaction: tx });
|
|
}
|
|
|
|
// Upsert photos
|
|
if (tradeItem.photos)
|
|
if (tradeItem.photos.length)
|
|
for (const photo of tradeItem.photos) {
|
|
await models.photo.upsert({
|
|
...photo,
|
|
tradeItemId: tradeItem.tradeItemId,
|
|
}, { transaction: tx });
|
|
}
|
|
|
|
// Upsert packing configurations
|
|
if (tradeItem.packingConfigurations)
|
|
if (tradeItem.packingConfigurations.length)
|
|
for (const packingConfiguration of tradeItem.packingConfigurations) {
|
|
const uuid = uuidv4();
|
|
|
|
await models.packingConfiguration.upsert({
|
|
packingConfigurationId: uuid,
|
|
...packingConfiguration,
|
|
additionalPricePerPiece_currency: packingConfiguration.additionalPricePerPiece.currency,
|
|
additionalPricePerPiece_value: packingConfiguration.additionalPricePerPiece.value,
|
|
tradeItemId: tradeItem.tradeItemId,
|
|
}, { transaction: tx });
|
|
|
|
await models.package.upsert({
|
|
...packingConfiguration.package,
|
|
packingConfigurationId: uuid,
|
|
}, { transaction: tx });
|
|
}
|
|
|
|
// Upsert country of origin ISO codes
|
|
if (tradeItem.countryOfOriginIsoCodes)
|
|
if (tradeItem.countryOfOriginIsoCodes.length)
|
|
for (const isoCode of tradeItem.countryOfOriginIsoCodes || []) {
|
|
await models.countryOfOriginIsoCode.upsert({
|
|
isoCode,
|
|
tradeItemId: tradeItem.tradeItemId,
|
|
}, { transaction: tx });
|
|
}
|
|
|
|
// Upsert botanical names
|
|
if (tradeItem.botanicalNames)
|
|
if (tradeItem.botanicalNames.length)
|
|
for (const botanicalName of tradeItem.botanicalNames) {
|
|
await models.botanicalName.upsert({
|
|
botanicalNameId: uuidv4(),
|
|
name: botanicalName,
|
|
tradeItemId: tradeItem.tradeItemId,
|
|
}, { transaction: tx });
|
|
}
|
|
|
|
await tx.commit();
|
|
} catch (err) {
|
|
await tx.rollback();
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Insert clock presales supply in the database.
|
|
*
|
|
* @param {Array} clockPresaleSupply
|
|
*/
|
|
export async function insertClockPresalesSupply(clockPresaleSupply) {
|
|
const tx = await models.sequelize.transaction();
|
|
try {
|
|
await models.clockPresaleSupply.upsert({
|
|
...clockPresaleSupply,
|
|
pricePerPiece_currency: clockPresaleSupply.pricePerPiece.currency,
|
|
pricePerPiece_value: clockPresaleSupply.pricePerPiece.value,
|
|
organizationId: clockPresaleSupply.supplierOrganizationId,
|
|
}, { transaction: tx });
|
|
await tx.commit();
|
|
} catch (err) {
|
|
await tx.rollback();
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Insert warehouse in the database.
|
|
*
|
|
* @param {Array} warehouse
|
|
*/
|
|
export async function insertWarehouse(warehouse) {
|
|
const tx = await models.sequelize.transaction();
|
|
try {
|
|
await models.warehouse.upsert({
|
|
...warehouse,
|
|
location_gln: warehouse.location.gln,
|
|
location_address_addressLine: warehouse.location.address.addressLine,
|
|
location_address_city: warehouse.location.address.city,
|
|
location_address_countryCode: warehouse.location.address.countryCode,
|
|
location_address_postalCode: warehouse.location.address.postalCode,
|
|
location_address_stateOrProvince: warehouse.location.address.stateOrProvince,
|
|
lastSync: moment(),
|
|
}, { transaction: tx });
|
|
await tx.commit();
|
|
} catch (err) {
|
|
await tx.rollback();
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Insert organization in the database.
|
|
*
|
|
* @param {Array} organization
|
|
*/
|
|
export async function insertOrganization(organization) {
|
|
const tx = await models.sequelize.transaction();
|
|
try {
|
|
await models.organization.upsert({
|
|
...organization,
|
|
isConnected: JSON.parse(env.ORGS_ALWAYS_CONN),
|
|
lastSync: moment(),
|
|
}, { transaction: tx });
|
|
await tx.commit();
|
|
} catch (err) {
|
|
await tx.rollback();
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Insert supply line and dependences in the database.
|
|
*
|
|
* @param {Array} supplyLine
|
|
*/
|
|
export async function insertSupplyLine(supplyLine) {
|
|
const tx = await models.sequelize.transaction();
|
|
try {
|
|
// Check if the warehouse exists, and if it doesn't, create it
|
|
let warehouse = await models.warehouse.findOne({
|
|
where: { warehouseId: supplyLine.warehouseId }
|
|
});
|
|
if (!warehouse) {
|
|
let warehouse = (await vnRequest('GET', `${env.API_URL}/warehouses/${supplyLine.warehouseId}`, null, null, spinner)).data;
|
|
|
|
// Check if the organization exists, and if it doesn't, create it
|
|
let organization = await models.organization.findOne({
|
|
where: { organizationId: warehouse.organizationId }
|
|
}, { transaction: tx });
|
|
if (!organization) {
|
|
let organization = (await vnRequest('GET', `${env.API_URL}/organizations/${warehouse.organizationId}`, null, null, spinner)).data;
|
|
await insertOrganization(organization);
|
|
}
|
|
|
|
await insertWarehouse(warehouse);
|
|
}
|
|
|
|
// Check if the trade item exists, and if it doesn't, create it
|
|
let tradeItem = await models.tradeItem.findOne({
|
|
where: { tradeItemId: supplyLine.tradeItemId }
|
|
}, { transaction: tx });
|
|
if (!tradeItem) {
|
|
let tradeItem = (await vnRequest('GET', `${env.API_URL}/trade-items/${supplyLine.tradeItemId}`, null, null, spinner)).data;
|
|
await insertTradeItem(tradeItem);
|
|
}
|
|
|
|
await models.supplyLine.upsert({
|
|
...supplyLine,
|
|
organizationId: supplyLine.supplierOrganizationId,
|
|
deliveryPeriodStartDateTime: supplyLine.deliveryPeriod?.startDateTime ?? null,
|
|
deliveryPeriodEndDateTime: supplyLine.deliveryPeriod?.endDateTime ?? null,
|
|
orderPeriodStartDateTime: supplyLine.orderPeriod?.startDateTime ?? null,
|
|
orderPeriodEndDateTime: supplyLine.orderPeriod?.endDateTime ?? null,
|
|
agreementReference_code: supplyLine.agreementReference?.code ?? null,
|
|
agreementReference_description: supplyLine.agreementReference?.description ?? null,
|
|
lastSync: moment(),
|
|
}, { transaction: tx });
|
|
|
|
// Upsert packing configurations
|
|
if (supplyLine.packingConfigurations.length)
|
|
for (const packingConfiguration of supplyLine.packingConfigurations)
|
|
await models.supplyLinePackingConfiguration.upsert({
|
|
packingConfigurationId: uuidv4(),
|
|
...packingConfiguration,
|
|
packageVbnPackageCode: packingConfiguration.package.vbnPackageCode,
|
|
packageCustomPackageId: packingConfiguration.package.customPackageId,
|
|
additionalPricePerPieceCurrency: packingConfiguration.additionalPricePerPiece.currency,
|
|
additionalPricePerPieceValue: packingConfiguration.additionalPricePerPiece.value,
|
|
supplyLineId: supplyLine.supplyLineId,
|
|
}, { transaction: tx });
|
|
|
|
// Upsert volume price
|
|
for (let volumePrice of supplyLine.volumePrices)
|
|
await models.volumePrice.upsert({
|
|
supplyLineId: supplyLine.supplyLineId,
|
|
...volumePrice,
|
|
}, { transaction: tx });
|
|
|
|
await tx.commit();
|
|
} catch (err) {
|
|
await tx.rollback();
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes Floriday connections that we don't have in the database.
|
|
**/
|
|
export async function deleteConnections() {
|
|
let spinner;
|
|
try {
|
|
let i = 1;
|
|
const connectionsInFloriday = (await vnRequest('GET', `${env.API_URL}/connections`, null, null, spinner)).data;
|
|
const connectionsInDb = await models.organization.findAll({
|
|
attributes: ['organizationId'],
|
|
where: { isConnected: true }
|
|
});
|
|
|
|
let isExists = false, ghostConnections = [];
|
|
for (let connectionInFloriday of connectionsInFloriday) {
|
|
for (let connectionInDb of connectionsInDb)
|
|
if (connectionInFloriday == connectionInDb.organizationId) {
|
|
isExists = true;
|
|
break;
|
|
}
|
|
if (!isExists) ghostConnections.push(connectionInFloriday)
|
|
isExists = false;
|
|
}
|
|
|
|
if (ghostConnections.length) spinner = ora(`Deleting connections that aren't in the db...`).start();
|
|
|
|
for (let connection of ghostConnections) {
|
|
await vnRequest('DELETE', `${env.API_URL}/connections/${connection}`, null, null, spinner);
|
|
spinner.text = `Deleting ${i++} of ${ghostConnections.length} connections that aren't in the db...`
|
|
}
|
|
if (spinner) spinner.succeed();
|
|
} catch (err) {
|
|
if (spinner) spinner.fail();
|
|
criticalError(err);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Perform a REST request.
|
|
*
|
|
* @param {String} url
|
|
* @param {String} method
|
|
* @param {Array} body
|
|
* @param {Array} header
|
|
* @param {Array} spinner
|
|
*
|
|
* @return {Array}
|
|
**/
|
|
export async function vnRequest(method, url, data, headers, spinner) {
|
|
if (!headers)
|
|
headers = {
|
|
'Content-Type': 'application/json',
|
|
'Authorization': `Bearer ${await getCurrentToken()}`,
|
|
'X-Api-Key': process.env.API_KEY,
|
|
};
|
|
|
|
while(true) {
|
|
try {
|
|
return (['GET', 'DELETE'].includes(method))
|
|
? await axios({method, url, headers})
|
|
: await axios({method, url, data, headers});
|
|
} catch (err) {
|
|
switch (err.code) {
|
|
case 'ECONNRESET': // Client network socket TLS
|
|
case 'EAI_AGAIN': // getaddrinfo
|
|
if (spinner) spinner.warn();
|
|
warning(err);
|
|
await sleep(1000);
|
|
if (spinner) spinner.start();
|
|
break;
|
|
case 'ECONNABORTED':
|
|
case 'ECONNREFUSED':
|
|
case 'ERR_BAD_REQUEST':
|
|
switch (err.response.status) {
|
|
case 404: // Not found
|
|
return err;
|
|
case 504:
|
|
case 502:
|
|
if (spinner) spinner.warn();
|
|
warning(err);
|
|
await sleep(1000);
|
|
if (spinner) spinner.start();
|
|
break;
|
|
case 429: // Too Many Requests
|
|
if (spinner) spinner.warn();
|
|
warning(err);
|
|
await sleep(60000);
|
|
if (spinner) spinner.start();
|
|
break;
|
|
case 401: // Unauthorized
|
|
if (spinner) spinner.warn();
|
|
warning(err);
|
|
await requestToken(true);
|
|
headers.Authorization
|
|
? headers.Authorization = `Bearer ${await getCurrentToken()}`
|
|
: criticalError(err);
|
|
if (spinner) spinner.start();
|
|
break;
|
|
default:
|
|
if (spinner) spinner.warn();
|
|
warning(err);
|
|
await sleep(env.MS_RETRY_UNHANDLED_ERROR);
|
|
if (spinner) spinner.start();
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
if (spinner) spinner.warn();
|
|
warning(err);
|
|
await sleep(env.MS_RETRY_UNHANDLED_ERROR);
|
|
if (spinner) spinner.start();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Critical error.
|
|
*
|
|
* @param {err}
|
|
**/
|
|
export async function criticalError(err) {
|
|
console.log(chalk.red.bold(`[CRITICAL]`), chalk.red(err.message));
|
|
process.exit();
|
|
}
|
|
|
|
/**
|
|
* Warning.
|
|
*
|
|
* @param {err}
|
|
**/
|
|
export async function warning(err) {
|
|
(err.response?.status && err.response?.data?.message)
|
|
? (console.log(chalk.yellow.bold(`[WARNING]`), chalk.yellow(`${err.response.status} - ${err.response.data.message}`)))
|
|
: (console.log(chalk.yellow.bold(`[WARNING]`), chalk.yellow(err.message)));
|
|
} |