@e-mc/db 0.0.3 → 0.0.4

package/mongodb/index.js

@@ -1,679 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DB_SOURCE_TYPE = exports.DB_SOURCE_CLIENT = exports.getSortValue = exports.getFilterValue = exports.checkTimeout = exports.executeBatchQuery = exports.executeQuery = exports.setCredential = void 0;
-const path = require("path");
-const types_1 = require("../../types");
-const util_1 = require("../util");
-const index_1 = require("../index");
-const pool_1 = require("../pool");
-const request_1 = require("../../request");
-const MONGODB_V3 = index_1.default.checkSemVer("mongodb" /* STRINGS.PACKAGE_NAME */, 1, 4);
-const MONGODB_V330 = index_1.default.checkSemVer("mongodb" /* STRINGS.PACKAGE_NAME */, '3.3.0');
-const MONGODB_V333 = index_1.default.checkSemVer("mongodb" /* STRINGS.PACKAGE_NAME */, '3.3.0', '3.3.3');
-const MONGODB_V360 = index_1.default.checkSemVer("mongodb" /* STRINGS.PACKAGE_NAME */, '3.6.0');
-const MONGODB_TOPOLOGY = MONGODB_V3 && MONGODB_V330;
-const MONGODB_NOPOOL = MONGODB_V3 && !MONGODB_V330;
-class MongoDBPool extends pool_1.default {
-    getConnection() {
-        return this.client.connect();
-    }
-    detach(force) {
-        this.remove();
-        return this.closed ? Promise.resolve() : this.close(force);
-    }
-    close(force = false) {
-        return this.client.close(force);
-    }
-    isEmpty() {
-        if (this.closed) {
-            return true;
-        }
-        const topology = this.client.topology;
-        if (topology) {
-            if (MONGODB_V360) {
-                const name = Object.getOwnPropertySymbols(topology).find(sym => sym.toString() === 'Symbol(waitQueue)');
-                if (name) {
-                    return (0, util_1.checkEmpty)(topology[name]);
-                }
-            }
-            return (0, util_1.checkEmpty)(topology.s?.sessions);
-        }
-        return false;
-    }
-    get closeable() {
-        const topology = this.client.topology;
-        return topology ? super.closeable || !MONGODB_V333 && topology.s?.state === 'closing' : true;
-    }
-    get closed() {
-        const topology = this.client.topology;
-        if (topology && (this.success > 0 || this.failed > 0)) {
-            if (MONGODB_V333) {
-                return topology.s.servers.size === 0;
-            }
-            if (typeof topology.isDestroyed === 'function') {
-                return topology.isDestroyed();
-            }
-        }
-        return this.client.s?.hasBeenClosed === true;
-    }
-}
-const POOL_STATE = {};
-function removePoolProperties(credential) {
-    let options = credential.options;
-    if (options && !credential.uuidKey) {
-        if (MONGODB_V360) {
-            if ('maxPoolSize' in options || 'minPoolSize' in options || 'maxConnecting' in options || 'maxIdleTimeMS' in options || 'waitQueueTimeoutMS' in options || 'serverSelectionTimeoutMS' in options) {
-                options = { ...options, maxPoolSize: undefined, minPoolSize: undefined, maxConnecting: undefined, maxIdleTimeMS: undefined, waitQueueTimeoutMS: undefined, serverSelectionTimeoutMS: undefined };
-            }
-        }
-        else if ('poolSize' in options || 'minSize' in options) {
-            options = { ...options, poolSize: undefined, minSize: undefined };
-        }
-        return { uri: credential.uri, options };
-    }
-    return credential;
-}
-function getCacheObject(item) {
-    const credential = item.credential;
-    return { uri: item.uri, options: item.options, uuidKey: credential?.uuidKey };
-}
-function getPoolKey(credential) {
-    const options = credential.options;
-    if (options && credential.uri) {
-        const auth = options.auth;
-        let result = credential.uri + (auth ? '_' + (auth.username || '') + '@' + (auth.password || '') : '') + '_' + (options.authMechanism || '') + index_1.default.asString(options.authMechanismProperties);
-        if (options.tls) {
-            const { tlsCertificateKeyFilePassword = '', tlsAllowInvalidHostnames, tlsAllowInvalidCertificates, tlsInsecure } = options;
-            let { tlsCertificateFile = '', tlsCertificateKeyFile = '', tlsCAFile = '' } = options;
-            if (MONGODB_V3) {
-                tlsCertificateFile = '';
-                tlsCertificateKeyFile = checkBuffer(tlsCertificateKeyFile);
-                tlsCAFile = checkBuffer(tlsCAFile);
-            }
-            result += tlsCertificateFile + tlsCertificateKeyFile + tlsCAFile + tlsCertificateKeyFilePassword + (tlsAllowInvalidHostnames ? '1' : '0') + (tlsAllowInvalidCertificates ? '1' : '0') + (tlsInsecure ? '1' : '0');
-        }
-        else if (options.ssl) {
-            let { sslCert = '', sslKey = '', sslCA = '' } = options;
-            if (MONGODB_V3) {
-                sslCert = checkBuffer(sslCert);
-                sslKey = checkBuffer(sslKey);
-                sslCA = checkBuffer(sslCA);
-            }
-            result += sslCert + sslKey + sslCA + (options.sslPass || '') + (options.sslValidate !== false ? '1' : '0');
-        }
-        return result;
-    }
-}
-function checkBuffer(value) {
-    if (typeof value === 'string') {
-        return value;
-    }
-    if (Buffer.isBuffer(value)) {
-        return value.toString('utf-8');
-    }
-    if (Array.isArray(value)) {
-        const items = value.map(item => checkBuffer(item)).filter(item => item);
-        if (items.length) {
-            return items.join('');
-        }
-    }
-    return '';
-}
-function setCredential(item) {
-    const credential = this.getCredential(item);
-    const options = item.options || (item.options = {});
-    let uri = item.uri;
-    if (credential) {
-        let { protocol, server, hostname, port, username, password } = (0, util_1.parseServerAuth)(credential, 27017 /* VALUES.PORT */), { auth, authMechanism = 'DEFAULT', authSource, authMechanismProperties } = credential, authentication = '';
-        if (authMechanism === 'GSSAPI') {
-            const principal = auth?.username || username || options.auth?.username;
-            if ((0, types_1.isString)(principal)) {
-                authentication = encodeURIComponent(principal) + '@';
-            }
-        }
-        else if (auth?.username) {
-            if (!MONGODB_V3) {
-                options.auth = auth;
-            }
-            else {
-                username = auth.username;
-                password = auth.password;
-            }
-        }
-        if (!uri || !index_1.default.isURL(uri)) {
-            if (MONGODB_V3 || !options.auth) {
-                authentication = (0, util_1.getBasicAuth)(username, password);
-            }
-            if (!server && hostname) {
-                server = hostname + ':' + (port || 27017 /* VALUES.PORT */);
-            }
-            if (!server) {
-                throw (0, types_1.errorMessage)("mongodb" /* STRINGS.MODULE_NAME */, 'Not defined - server address');
-            }
-            uri = (protocol || 'mongodb:') + '//' + authentication + server;
-        }
-        else if (!MONGODB_V3) {
-            options.auth || (options.auth = { username, password });
-        }
-        else if (!(0, util_1.hasBasicAuth)(uri) && (authentication || (authentication = (0, util_1.getBasicAuth)(username, password)))) {
-            const url = uri.split('://');
-            uri = url[0] + '://' + authentication + url[1];
-        }
-        if (MONGODB_V3 && 'auth' in options) {
-            delete options.auth;
-        }
-        if (uri.indexOf('?') === -1) {
-            if (uri[uri.length - 1] !== '/') {
-                uri += '/';
-            }
-            uri += '?';
-        }
-        uri += (uri[uri.length - 1] !== '?' ? '&' : '') + 'authMechanism=' + encodeURIComponent(authMechanism);
-        switch (authMechanism) {
-            case 'MONGODB-X509': {
-                const checkFile = (value) => {
-                    if ((0, types_1.isString)(value)) {
-                        if (request_1.default.isCert(value = value.trim())) {
-                            return MONGODB_V3 ? value : '';
-                        }
-                        if (index_1.default.isPath(value = path.resolve(value)) && this.canRead(value, { ownPermissionOnly: true })) {
-                            return MONGODB_V3 ? index_1.default.readText(value, true) : value;
-                        }
-                    }
-                    return '';
-                };
-                let { tlsCertificateFile, tlsCertificateKeyFile, tlsCAFile } = credential, valid;
-                if (tlsCertificateFile || tlsCertificateKeyFile) {
-                    if (!MONGODB_V3 && (tlsCertificateFile = checkFile(tlsCertificateFile))) {
-                        options.tlsCertificateFile = tlsCertificateFile;
-                        valid = true;
-                    }
-                    if (tlsCertificateKeyFile = checkFile(tlsCertificateKeyFile)) {
-                        options.tlsCertificateKeyFile = tlsCertificateKeyFile;
-                        valid = true;
-                    }
-                    if (valid) {
-                        const { tlsCertificateKeyFilePassword, tlsAllowInvalidHostnames, tlsAllowInvalidCertificates, tlsInsecure } = credential;
-                        if (tlsCAFile = checkFile(tlsCAFile)) {
-                            options.tlsCAFile = tlsCAFile;
-                        }
-                        if (tlsCertificateKeyFilePassword) {
-                            options.tlsCertificateKeyFilePassword = tlsCertificateKeyFilePassword;
-                        }
-                        if (typeof tlsAllowInvalidHostnames === 'boolean') {
-                            options.tlsAllowInvalidHostnames = tlsAllowInvalidHostnames;
-                        }
-                        if (typeof tlsAllowInvalidCertificates === 'boolean') {
-                            options.tlsAllowInvalidCertificates = tlsAllowInvalidCertificates;
-                        }
-                        if (typeof tlsInsecure === 'boolean') {
-                            options.tlsInsecure = tlsInsecure;
-                        }
-                        options.tls = true;
-                        uri += '&tls=true';
-                    }
-                }
-                else {
-                    let { sslCert, sslKey, sslCA } = credential;
-                    if (sslCert = checkFile(sslCert)) {
-                        options.sslCert = sslCert;
-                        if (sslKey = checkFile(sslKey)) {
-                            options.sslKey = sslKey;
-                        }
-                        if (MONGODB_V3) {
-                            if (sslCA) {
-                                const ca = (!Array.isArray(sslCA) ? [sslCA] : sslCA).map(value => this.readFile(value, { ownPermissionOnly: true, encoding: 'utf-8' })).filter(value => value);
-                                if (ca.length) {
-                                    options.sslCA = ca;
-                                }
-                            }
-                        }
-                        else if (sslCA = checkFile(sslCA)) {
-                            options.sslCA = sslCA;
-                        }
-                        const { sslPass, sslValidate } = credential;
-                        if (sslPass) {
-                            options.sslPass = sslPass;
-                        }
-                        if (typeof sslValidate === 'boolean') {
-                            options.sslValidate = sslValidate;
-                        }
-                        options.ssl = true;
-                        uri += '&ssl=true';
-                        valid = true;
-                    }
-                }
-                if (!valid) {
-                    throw (0, types_1.errorMessage)("mongodb" /* STRINGS.MODULE_NAME */, 'Missing TLS/SSL credentials');
-                }
-                authSource || (authSource = '$external');
-                break;
-            }
-            case 'GSSAPI': {
-                authSource || (authSource = '$external');
-                let serviceName;
-                if ((0, types_1.isObject)(authMechanismProperties)) {
-                    if (!MONGODB_V3) {
-                        options.authMechanismProperties = authMechanismProperties;
-                        break;
-                    }
-                    serviceName = authMechanismProperties.SERVICE_NAME;
-                }
-                else if ((0, types_1.isString)(authMechanismProperties)) {
-                    serviceName = authMechanismProperties;
-                }
-                serviceName || (serviceName = "mongodb" /* STRINGS.MODULE_NAME */);
-                uri += !MONGODB_V3 ? '&authMechanismProperties=' + encodeURIComponent('SERVICE_NAME:' + serviceName) : '&gssapiServiceName=' + encodeURIComponent(serviceName);
-                break;
-            }
-            case 'PLAIN':
-                uri += '&maxPoolSize=1';
-                authSource || (authSource = '$external');
-                break;
-            case 'MONGODB-AWS':
-                if ((0, types_1.isObject)(authMechanismProperties)) {
-                    options.authMechanismProperties = authMechanismProperties;
-                }
-                authSource || (authSource = '$external');
-                break;
-        }
-        if (authSource) {
-            uri += '&authSource=' + encodeURIComponent(authSource);
-        }
-        item.uri = uri;
-    }
-    else if (!(0, types_1.isString)(uri)) {
-        throw (0, types_1.errorMessage)("mongodb" /* STRINGS.MODULE_NAME */, 'Not defined - credentials');
-    }
-    if (MONGODB_TOPOLOGY) {
-        options.useUnifiedTopology = true;
-    }
-    const usePool = item.usePool;
-    if (usePool) {
-        if (MONGODB_NOPOOL) {
-            item.usePool = false;
-            return;
-        }
-        let username, password, pool;
-        if (typeof usePool === 'string' && (username = !MONGODB_V3 && options.auth?.username || item.uri && (0, util_1.parseConnectionString)(item.uri)?.username)) {
-            [password, pool] = pool_1.default.validateKey(POOL_STATE, username, usePool);
-            if (pool) {
-                pool.add(item, password);
-                return;
-            }
-        }
-        const poolKey = getPoolKey(item);
-        if (poolKey) {
-            if (!(pool = POOL_STATE[poolKey]) || pool.closed) {
-                const config = this.getPoolConfig("mongodb" /* STRINGS.MODULE_NAME */, password);
-                if (config) {
-                    const { min, max, idle, queue_max, queue_idle } = config;
-                    if (MONGODB_V360) {
-                        if (min >= 0) {
-                            options.minPoolSize ?? (options.minPoolSize = min);
-                        }
-                        if (max > 0) {
-                            options.maxPoolSize ?? (options.maxPoolSize = max);
-                        }
-                        if (idle >= 0) {
-                            options.maxIdleTimeMS ?? (options.maxIdleTimeMS = idle);
-                        }
-                        if (queue_max > 0 && !MONGODB_V3) {
-                            options.maxConnecting ?? (options.maxConnecting = queue_max);
-                        }
-                        if (queue_idle >= 0) {
-                            options.waitQueueTimeoutMS ?? (options.waitQueueTimeoutMS = queue_idle);
-                        }
-                    }
-                    else {
-                        if (min >= 0) {
-                            options.minSize ?? (options.minSize = min);
-                        }
-                        if (max > 0) {
-                            options.poolSize ?? (options.poolSize = max);
-                        }
-                    }
-                }
-                const db = require("mongodb" /* STRINGS.PACKAGE_NAME */);
-                new MongoDBPool(new db.MongoClient(item.uri, options), poolKey, username && password ? { username, password } : undefined).add(item).parent = POOL_STATE;
-            }
-            else {
-                pool.add(item);
-            }
-        }
-        else {
-            item.usePool = false;
-        }
-    }
-}
-exports.setCredential = setCredential;
-async function executeQuery(item, options) {
-    return (await executeBatchQuery.call(this, [item], options))[0] || [];
-}
-exports.executeQuery = executeQuery;
-async function executeBatchQuery(batch, options = '', outResult) {
-    const length = batch.length;
-    if (length === 0) {
-        return [];
-    }
-    const db = require("mongodb" /* STRINGS.PACKAGE_NAME */);
-    let parallel, checkObject, connectOnce, errorQuery, sessionKey, outCacheMiss;
-    if ((0, types_1.isPlainObject)(options)) {
-        ({ parallel, checkObject, connectOnce, errorQuery, sessionKey, outCacheMiss } = options);
-    }
-    else {
-        if (typeof options === 'string') {
-            sessionKey = options;
-        }
-        options = undefined;
-    }
-    if (length === 1) {
-        connectOnce = false;
-        parallel = false;
-    }
-    else if (parallel === undefined) {
-        parallel = !batch.some(item => item.parallel === false);
-    }
-    if (!parallel) {
-        outResult || (outResult = new Array(length));
-    }
-    const caching = this.hasCache("mongodb" /* STRINGS.MODULE_NAME */, sessionKey);
-    const tasks = new Array(length);
-    const clients = [];
-    let mongoClient, mongoCredential, mongoCache = 0, onceCredential = connectOnce ? getCacheObject(batch[0]) : undefined;
-    const getConnection = async (item, credential) => {
-        item.transactionState = 64 /* TRANSACTION_DB.AUTH */;
-        const pool = item.usePool && pool_1.default.findKey(POOL_STATE, item.usePool, getPoolKey(connectOnce ? batch[0] : item), ...connectOnce ? [item, batch[0]] : [item]);
-        let client;
-        if (pool) {
-            try {
-                client = await pool.getConnection();
-                pool.connected = true;
-            }
-            catch {
-                if (pool.closeable) {
-                    await pool.detach();
-                }
-                pool.connected = false;
-            }
-        }
-        if (!client) {
-            if (connectOnce && parallel) {
-                const size = length - mongoCache;
-                if (size > 1) {
-                    credential.options.maxPoolSize = size;
-                }
-            }
-            clients.push(client = await new db.MongoClient(credential.uri, credential.options).connect());
-        }
-        if (connectOnce) {
-            mongoClient = client;
-            mongoCredential = credential;
-        }
-        item.transactionState &= ~64 /* TRANSACTION_DB.AUTH */;
-        return client;
-    };
-    for (let i = 0; i < length; ++i) {
-        const item = batch[i];
-        const { source, name, table, id, aggregate, sort, client, cacheObjectKey, ignoreCache } = item;
-        let { query, update, streamRow, limit = 0 } = item;
-        if (!table) {
-            const error = (0, types_1.errorMessage)(source, "Missing database table" /* ERR_DB.TABLE */);
-            ++mongoCache;
-            if (this.handleFail(error, item, { errorQuery })) {
-                if (!parallel) {
-                    tasks.length = 0;
-                    break;
-                }
-                tasks[i] = Promise.reject(error);
-            }
-            else if (parallel) {
-                tasks[i] = Promise.resolve([]);
-            }
-            else {
-                outResult[i] = [];
-            }
-            continue;
-        }
-        item.transactionState = 1 /* TRANSACTION_DB.ACTIVE */;
-        const getCollection = (target) => target.db(name, client?.db).collection(table, client?.collection);
-        const credential = mongoCredential || onceCredential || getCacheObject(item);
-        const renewCache = ignoreCache === 0;
-        const cacheValue = renewCache ? { sessionKey, renewCache } : sessionKey;
-        const coercing = this.hasCoerce("mongodb" /* STRINGS.MODULE_NAME */, 'options', credential.uuidKey);
-        const targetObject = typeof checkObject === 'string' ? coercing && (0, types_1.asFunction)(checkObject) : checkObject;
-        if (typeof streamRow === 'string') {
-            streamRow = coercing && (0, types_1.asFunction)(streamRow);
-        }
-        let queryString = '', rows, pipeline;
-        if ((caching && ignoreCache !== true || ignoreCache === false || ignoreCache === 1 || renewCache) && (!targetObject || typeof cacheObjectKey === 'string') && !streamRow) {
-            queryString = (name || '') + '_' + table + '_' + limit + index_1.default.asString(sort, true) + index_1.default.asString(client, true) + (targetObject ? targetObject.toString() + cacheObjectKey : '');
-        }
-        if (aggregate) {
-            pipeline = Array.isArray(aggregate) ? aggregate : aggregate.pipeline;
-        }
-        if (id && (!query || limit === 1) && !pipeline) {
-            query = { '_id': new db.ObjectId(id) };
-            limit = 1;
-        }
-        if (queryString) {
-            const setResult = () => {
-                if (ignoreCache !== 1 && (rows = this.getQueryResult(source, removePoolProperties(credential), queryString, cacheValue))) {
-                    ++mongoCache;
-                    if (parallel) {
-                        tasks[i] = Promise.resolve(rows);
-                    }
-                    else {
-                        outResult[i] = rows;
-                    }
-                    this.add(item, 4 /* TRANSACTION_DB.COMMIT */ | 128 /* TRANSACTION_DB.CACHE */);
-                    return true;
-                }
-                return false;
-            };
-            if (pipeline || query) {
-                queryString += index_1.default.asString(aggregate || query, true);
-                if ((aggregate || !update) && setResult()) {
-                    continue;
-                }
-            }
-            else if (!aggregate && setResult()) {
-                continue;
-            }
-            if (!ignoreCache && outCacheMiss) {
-                outCacheMiss.push(source);
-            }
-        }
-        if (onceCredential && parallel) {
-            try {
-                mongoClient = await getConnection(item, onceCredential);
-            }
-            catch {
-                connectOnce = false;
-                parallel = false;
-            }
-            onceCredential = undefined;
-        }
-        tasks[i] = new Promise(async (resolve, reject) => {
-            let commandType;
-            try {
-                let cursor;
-                if (pipeline || query) {
-                    const collection = getCollection(mongoClient || await getConnection(item, credential));
-                    if (pipeline) {
-                        const aggregateOptions = aggregate?.options;
-                        if (coercing) {
-                            pipeline.forEach(doc => (0, types_1.coerceObject)(doc));
-                            if (aggregateOptions) {
-                                (0, types_1.coerceObject)(aggregateOptions);
-                            }
-                        }
-                        cursor = collection.aggregate(pipeline, aggregateOptions);
-                        if (sort) {
-                            cursor.sort(getSortValue(sort, coercing)[0]);
-                        }
-                        if (limit > 0) {
-                            cursor.limit(limit);
-                        }
-                    }
-                    else {
-                        const [filter, command] = getFilterValue(query, coercing);
-                        if (update && coercing) {
-                            (0, types_1.coerceObject)(update);
-                        }
-                        if ((0, types_1.isArray)(update)) {
-                            commandType = this.commandType.INSERT;
-                            const insertOptions = item.execute?.insert;
-                            if (insertOptions) {
-                                await collection.insertMany(update, coercing ? (0, types_1.coerceObject)(insertOptions) : insertOptions);
-                            }
-                            else {
-                                await collection.insertMany(update);
-                            }
-                            update = undefined;
-                        }
-                        else if (item.updateType === 1) {
-                            update = undefined;
-                        }
-                        if (limit === 1) {
-                            let document;
-                            if (update) {
-                                commandType = this.commandType.UPDATE;
-                                document = await collection[item.updateType === 2 ? 'findOneAndReplace' : item.updateType === 3 ? 'findOneAndDelete' : 'findOneAndUpdate'](filter, update, command);
-                            }
-                            else {
-                                commandType = this.commandType.SELECT;
-                                document = await collection.findOne(filter, command);
-                            }
-                            rows = document ? [document] : [];
-                        }
-                        else {
-                            if (update) {
-                                commandType = this.commandType.UPDATE;
-                                await collection.updateMany(filter, update);
-                            }
-                            cursor = collection.find(filter, command);
-                        }
-                    }
-                }
-                else if (!aggregate) {
-                    cursor = getCollection(mongoClient || await getConnection(item, credential)).find();
-                }
-                if (cursor) {
-                    commandType = this.commandType.SELECT;
-                    if (!pipeline) {
-                        if (sort) {
-                            cursor.sort(...getSortValue(sort, coercing));
-                        }
-                        if (limit > 1) {
-                            cursor.limit(limit);
-                        }
-                    }
-                    if (streamRow) {
-                        const processRow = typeof streamRow === 'function' && streamRow;
-                        const stream = cursor.stream();
-                        let error;
-                        rows = [];
-                        stream
-                            .on('data', row => {
-                            if (processRow) {
-                                const err = processRow(row);
-                                if (err === false) {
-                                    return;
-                                }
-                                if (err instanceof Error) {
-                                    error = err;
-                                    return;
-                                }
-                            }
-                            rows.push(row);
-                        })
-                            .on('error', err => error = err)
-                            .on('close', () => {
-                            if (error && this.handleFail(error, item, { errorQuery, commandType })) {
-                                reject(error);
-                            }
-                            else {
-                                this.add(item, 4 /* TRANSACTION_DB.COMMIT */);
-                                resolve(!error ? this.setQueryResult(source, removePoolProperties(mongoCredential || credential), queryString, rows, cacheValue) : rows);
-                            }
-                        })
-                            .on('end', () => stream.destroy());
-                    }
-                    else {
-                        rows = await cursor.toArray();
-                    }
-                }
-                if (rows) {
-                    this.add(item, 4 /* TRANSACTION_DB.COMMIT */);
-                    if (targetObject) {
-                        rows = targetObject(item, rows);
-                    }
-                    resolve(this.setQueryResult(source, removePoolProperties(mongoCredential || credential), queryString, rows, cacheValue));
-                }
-                else {
-                    throw (0, types_1.errorMessage)(source, "Missing database query" /* ERR_DB.QUERY */);
-                }
-            }
-            catch (err) {
-                if (this.handleFail(err, item, { errorQuery, commandType })) {
-                    reject(err);
-                }
-                else {
-                    resolve([]);
-                }
-            }
-        });
-        if (!parallel) {
-            try {
-                outResult[i] = await tasks[i];
-            }
-            catch {
-                tasks.length = 0;
-                break;
-            }
-        }
-    }
-    return this.processRows(batch, tasks, {
-        disconnect: () => clients.forEach(item => item.close(true)),
-        parallel
-    }, outResult);
-}
-exports.executeBatchQuery = executeBatchQuery;
-function checkTimeout(value, limit = 0) {
-    return pool_1.default.checkTimeout(POOL_STATE, value, limit);
-}
-exports.checkTimeout = checkTimeout;
-function getFilterValue(query, coerce) {
-    let value, options;
-    if ((0, types_1.isObject)(query) && query.value && query.options) {
-        ({ value, options } = query);
-    }
-    else {
-        value = query;
-    }
-    if (coerce) {
-        (0, types_1.coerceObject)(value);
-        if (options) {
-            (0, types_1.coerceObject)(options);
-        }
-    }
-    return [value, options];
-}
-exports.getFilterValue = getFilterValue;
-function getSortValue(sort, coerce) {
-    let value, direction;
-    if ((0, types_1.isObject)(sort) && sort.value && sort.direction) {
-        ({ value, direction } = sort);
-    }
-    else {
-        value = sort;
-    }
-    if (coerce) {
-        (0, types_1.coerceObject)(value);
-    }
-    return [value, direction];
-}
-exports.getSortValue = getSortValue;
-exports.DB_SOURCE_CLIENT = true;
-exports.DB_SOURCE_TYPE = types_1.DB_TYPE.NOSQL | types_1.DB_TYPE.DOCUMENT;

package/mssql/index.d.ts

@@ -1,7 +0,0 @@
-import type { MSSQLDataSource } from '../../types/lib/db';
-
-import type { IDbSourceClient } from '../types';
-
-declare const MSSQL: IDbSourceClient<MSSQLDataSource>;
-
-export = MSSQL;