mongo-seeding/dist/database/database-connector.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const mongodb_1 = require("mongodb");
const common_1 = require("../common");
const _1 = require(".");
/**
 * Provides functionality to manage connection to a MongoDB database.
 */
class DatabaseConnector {
    /**
     * Constructs the `DatabaseConnector` object.
     *
     * @param reconnectTimeoutMillis Reconnect timeout in milliseconds
     */
    constructor(reconnectTimeoutMillis) {
        this.reconnectTimeoutMillis =
            reconnectTimeoutMillis != null
                ? reconnectTimeoutMillis
                : DatabaseConnector.DEFAULT_RECONNECT_TIMEOUT_MILLIS;
    }
    /**
     * Connects to database.
     *
     * @param config Database configuration
     */
    connect(config) {
        return __awaiter(this, void 0, void 0, function* () {
            let uri, databaseName;
            if (typeof config === 'string') {
                uri = config;
                databaseName = this.getDbName(uri);
            }
            else if (_1.isSeederDatabaseConfigObject(config)) {
                uri = this.getDbConnectionUri(config);
                databaseName = config.name;
            }
            else {
                throw new Error('You have to pass connection URI or database config object');
            }
            return this.connectWithUri(uri, databaseName);
        });
    }
    /**
     * Connects to database using database connection URI.
     *
     * @param dbConnectionUri Database connection URI
     * @param dbName Database name
     */
    connectWithUri(dbConnectionUri, dbName) {
        return __awaiter(this, void 0, void 0, function* () {
            common_1.log(`Connecting to ${this.maskUriCredentials(dbConnectionUri)}...`);
            const startMillis = new Date().getTime();
            let client;
            do {
                try {
                    client = yield mongodb_1.MongoClient.connect(dbConnectionUri, {
                        ignoreUndefined: true,
                        useNewUrlParser: true,
                    });
                }
                catch (err) {
                    if (_1.checkTimeout(startMillis, this.reconnectTimeoutMillis)) {
                        throw new Error(`Timeout ${this.reconnectTimeoutMillis}s expired while connecting to database due to: ${err.name}: ${err.message}`);
                    }
                    common_1.log(`${err.message}\nRetrying...`);
                    yield _1.sleep(DatabaseConnector.SLEEP_INTERVAL_MILLIS);
                }
            } while (!client);
            common_1.log('Connection with database established.');
            this.client = client;
            const db = client.db(dbName);
            return new _1.Database(db);
        });
    }
    /**
     * Closes connection with database.
     */
    close() {
        return __awaiter(this, void 0, void 0, function* () {
            common_1.log('Closing connection...');
            if (!this.client || !this.client.isConnected()) {
                return;
            }
            yield this.client.close(true);
        });
    }
    /**
     * Constructs database connection URI from database configuration object.
     *
     * @param param0 Database connection object
     */
    getDbConnectionUri({ protocol, host, port, name, username, password, options, }) {
        const credentials = username
            ? `${username}${password ? `:${password}` : ''}@`
            : '';
        const optsUriPart = options ? this.getOptionsUriPart(options) : '';
        const portUriPart = protocol !== 'mongodb+srv' ? `:${port}` : '';
        return `${protocol}://${credentials}${host}${portUriPart}/${name}${optsUriPart}`;
    }
    /**
     * Constructs database connection options query string from database configuration object.
     *
     * @param options Database configuration object
     */
    getOptionsUriPart(options) {
        return Object.keys(options).reduce((previousUri, currentKey) => {
            let uriPartFirstChar;
            if (previousUri == '') {
                uriPartFirstChar = '?';
            }
            else {
                uriPartFirstChar = '&';
            }
            return `${previousUri}${uriPartFirstChar}${currentKey}=${options[currentKey]}`;
        }, '');
    }
    /**
     * Detects database connection credentials and masks them, replacing with masked URI credentials token.
     *
     * @param uri Database connection URI
     */
    maskUriCredentials(uri) {
        if (!uri.includes('@')) {
            return uri;
        }
        const creds = uri.substring(uri.indexOf('://') + 3, uri.indexOf('@'));
        return uri.replace(creds, DatabaseConnector.MASKED_URI_CREDENTIALS);
    }
    /**
     * Extracts database name from database connection URI.
     *
     * @param dbConnectionUri Database connection URI
     */
    getDbName(dbConnectionUri) {
        const url = dbConnectionUri.replace('mongodb://', '');
        const parts = url.split('/');
        if (parts.length === 1) {
            // Database not given, return the default one
            return DatabaseConnector.DEFAULT_DB_NAME;
        }
        const lastPart = parts[parts.length - 1];
        const givenDbName = lastPart.split('?')[0];
        return givenDbName ? givenDbName : DatabaseConnector.DEFAULT_DB_NAME;
    }
}
/**
 * Default database name.
 */
DatabaseConnector.DEFAULT_DB_NAME = 'admin';
/**
 * Default reconnect timeout in milliseconds.
 */
DatabaseConnector.DEFAULT_RECONNECT_TIMEOUT_MILLIS = 10000;
/**
 * Sleep interval in milliseconds.
 */
DatabaseConnector.SLEEP_INTERVAL_MILLIS = 500;
/**
 * Masked URI credentials token.
 */
DatabaseConnector.MASKED_URI_CREDENTIALS = '[secure]';
exports.DatabaseConnector = DatabaseConnector;
//# sourceMappingURL=database-connector.js.map