agilite-core/dist/index.js

A NodeJS module that provides reusable backend functionality to the Agilit-e environment

'use strict';
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.resetDbModelConnection = exports.sendMail = exports.getModal = exports.getDbModel = exports.generateMongoDbUrl = void 0;
const agilite_utils_1 = __importDefault(require("agilite-utils"));
const mongoose_1 = __importDefault(require("agilite-utils/dist/mongoose"));
const connections = {};
const generateMongoDbUrl = (config, dbName) => {
    if (!config || !dbName || !config.protocol || !config.host) {
        throw new Error('Invalid configuration or missing parameters');
    }
    let url = config.protocol;
    if (config.username && config.password) {
        url += `${config.username}:${config.password}@`;
    }
    url += config.host;
    url += `/${dbName}`;
    if (config.urlSuffix) {
        url += config.urlSuffix;
    }
    return url;
};
exports.generateMongoDbUrl = generateMongoDbUrl;
const getDbModel = (id_1, dbName_1, mongoConfig_1, modelName_1, modelSchema_1, ...args_1) => __awaiter(void 0, [id_1, dbName_1, mongoConfig_1, modelName_1, modelSchema_1, ...args_1], void 0, function* (id, dbName, mongoConfig, modelName, modelSchema, returnConnection = false) {
    let conn;
    let url;
    let maxPoolSize = undefined;
    let model;
    try {
        if (!id || !dbName || !mongoConfig || !modelName || !modelSchema) {
            throw new Error('Invalid configuration or missing parameters');
        }
        maxPoolSize = mongoConfig.maxPoolSizes[id] || mongoConfig.maxPoolSizes['default'];
        if (!connections[id]) {
            url = (0, exports.generateMongoDbUrl)(mongoConfig.general, dbName);
            conn = yield mongoose_1.default.createConnection(url, { maxPoolSize }).asPromise();
            connections[id] = conn;
        }
        else {
            conn = connections[id];
        }
        model = (0, exports.getModal)(conn, modelName, modelSchema);
        if (returnConnection) {
            return { model, conn };
        }
        else {
            return model;
        }
    }
    catch (e) {
        throw e;
    }
});
exports.getDbModel = getDbModel;
const getModal = (conn, modelName, modelSchema) => {
    if (conn.models[modelName])
        return conn.model(modelName);
    return conn.model(modelName, modelSchema);
};
exports.getModal = getModal;
const sendMail = (templateId, mailConfig, to, templateData) => {
    return new Promise((resolve, reject) => {
        ;
        (() => __awaiter(void 0, void 0, void 0, function* () {
            let errMsg = null;
            let result = null;
            try {
                if (!mailConfig.enabled)
                    return resolve();
                const data = {
                    personalizations: [
                        {
                            to,
                            bcc: mailConfig.bcc,
                            dynamic_template_data: templateData
                        }
                    ],
                    from: mailConfig.from,
                    reply_to: mailConfig.reply_to,
                    template_id: templateId
                };
                const config = {
                    headers: mailConfig.headers,
                    method: mailConfig.method,
                    url: mailConfig.url,
                    data
                };
                config.headers.authorization = `Bearer ${mailConfig.apiKey}`;
                result = yield agilite_utils_1.default.axiosRequest(config);
                resolve(result.data);
            }
            catch (e) {
                if (e.response) {
                    errMsg = e.response.data;
                }
                else if (e.message) {
                    errMsg = e.message;
                }
                else if (e.request) {
                    errMsg = e.request;
                }
                else {
                    errMsg = e;
                }
                reject(errMsg);
            }
        }))();
    });
};
exports.sendMail = sendMail;
const resetDbModelConnection = (id) => __awaiter(void 0, void 0, void 0, function* () {
    try {
        if (!id) {
            throw new Error('Invalid or missing id parameter');
        }
        if (connections[id]) {
            yield connections[id].close();
            delete connections[id];
            return true;
        }
        return false;
    }
    catch (e) {
        throw e;
    }
});
exports.resetDbModelConnection = resetDbModelConnection;
//# sourceMappingURL=index.js.map