@e-mc/db 0.0.1

package/mongodb/index.js

@@ -0,0 +1,679 @@
+"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.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.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.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.COMMIT */ | 128 /* TRANSACTION.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.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.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

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