@blazedpath/commons 0.3.1 → 0.4.0

package/blz-rds/blz-rds-executor.js

@@ -0,0 +1,578 @@
+const toString = Object.prototype.toString;
+const { z } = require('zod');
+const logger = require('pino')();
+class SqlInjectionGuard {
+    constructor(logger = console) {
+        this.logger = logger;    
+        this._initialized = false;        
+    }
+
+    _initialize() {
+        if (this._initialized) return;
+        this._initialized = true;
+        const allowedPatternsEnv = process.env.blz_securityApiSanitizeAllowedSqlInputPatterns;            
+        const paramPatternsEnv = process.env.blz_securityApiSanitizeDangerousParamPatterns;
+        const sqlPatternsEnv = process.env.blz_securityApiSanitizeDangerousSqlPatterns;        
+        this.onlyLog = process.env.blz_securityApiSanitizeOnlyLog === 'true';        
+        const parseRegexArray = (input) => {
+            try {
+                if (input == undefined || input == null) return null
+                const rawList = JSON.parse(input); // must be an array of strings type ["--", "\\bselect\\b.+\\bfrom\\b"]
+                return rawList.map(pattern => new RegExp(pattern, 'i'));
+            } catch {
+                return null;
+            }
+        };
+        this.dangerousParamPatterns =
+            parseRegexArray(paramPatternsEnv) || [
+                /--/i,
+                /\/\*/i,
+                /\*\//i,
+                /\bor\b\s+\w+\s*=/i,
+                /\bor\b\s+.*?=.*?/i,
+                /\bor\b\s+'.*?'\s*=\s*'.*?'/i,                
+                /\bor\b\s+\w+\s*like/i,
+                /\band\b\s+\w+\s*=/i,
+                /\band\b\s+\w+\s*like/i,
+                /\bselect\b[\s\S]+?\bfrom\b/i,
+                /\bunion\s+select\b/i,
+                /\bdrop\s+table\b/i,
+                /\binsert\s+into\b/i,
+                /\bupdate\b\s+\w+\s+\bset\b[\s\S]*?=/i,
+                /\bdelete\s+from\b/i,
+                /\bpg_sleep\s*\(/i,
+                /\bdbms_lock\.sleep\s*\(/i,
+                /\bexec\s*\(/i,
+                /\bexecute\s*\(/i
+            ];
+        this.dangerousSqlPatterns =
+            parseRegexArray(sqlPatternsEnv) || [
+                /;\s*drop\b/i,
+                /;\s*truncate\b/i,
+                /\bpg_sleep\s*\(/i,
+                /\bdbms_lock\.sleep\s*\(/i,
+                /\bexec(ute)?\s*(\(|\s)/i,
+                /\binformation_schema\b/i,
+                /\bpg_catalog\b/i,
+            ];        
+        this.allowedInputPatterns =
+            parseRegexArray(allowedPatternsEnv) || [
+                new RegExp('^[^<>]*<$', 'i'),
+                new RegExp('^>[^<>]*$', 'i')
+            ]; 
+        // Define a schema for each param object
+        this.paramSchema = z.object({
+            name: z.string(),
+            value: z.any(), // value can be string, number, etc.
+        });
+        // Schema for the full list
+        this.paramsSchema = z.array(this.paramSchema);
+    }
+
+    isAllowedByWhitelist(value) {
+        return this.allowedInputPatterns.some(pattern => pattern.test(value));
+    }
+
+    validateParamValue(name, value) {
+        this. _initialize()
+        if (typeof value !== 'string') return;
+        const trimmed = value.trim();
+        if (this.isAllowedByWhitelist(trimmed)) return
+        // Always check for dangerous SQL injection patterns
+        for (const pattern of this.dangerousParamPatterns) {            
+            if (pattern.test(trimmed)) {
+                const message = `Potential SQL injection in parameter "${name}": ${value}`;
+                if (this.onlyLog) {
+                    this.logger?.warn?.(`[SQLInjectionGuard] ${message}`);
+                } else {
+                    const err = new Error('Potential SQL injection');
+                    err.code = 'SQLInjection';
+                    err.data = message;
+                    throw err;
+                }
+            }
+        }
+    }
+   
+    validateParamList(params) {
+        this. _initialize()
+        this.paramsSchema.parse(params); // Validate structure with Zod
+        for (const param of params) {
+            this.validateParamValue(param.name, param.value);
+        }
+        return params;
+    }
+
+    validateRawSql(sql) {
+        this. _initialize()
+        if (typeof sql !== 'string') return false;
+        for (const pattern of this.dangerousSqlPatterns) {
+            if (pattern.test(sql.toLowerCase())) {
+                const message = `Potential SQL injection in "${sql}" pattern:${pattern}`;
+                if (this.onlyLog) {
+                    this.logger.warn(`[SQLInjectionGuard] ${message}`);
+                } else {
+                    const err = new Error('Potential SQL injection');
+                    err.code = 'SQLInjection';
+                    err.data = message;
+                    throw err;
+                }
+            }
+        }
+        return sql
+    }
+
+    validateObject(obj) {
+        this. _initialize()
+        const checkValue = (value) => {
+            if (typeof value === 'string') {
+                const trimmed = value.trim();
+                if (!this.isAllowedByWhitelist(trimmed)) {
+                    for (const pattern of this.dangerousParamPatterns) {
+                        if (pattern.test(trimmed)) {
+                            const message = `Value "${value}" violates SQL injection policy.`;
+                            if (this.onlyLog) {
+                                this.logger.warn(`[SQLInjectionGuard] ${message}`);
+                            } else {
+                                const err = new Error('Potential SQL injection');
+                                err.code = 'BadRequest';
+                                err.data = message;
+                                throw err;
+                            }
+                        }
+                    }
+                }
+            } else if (Array.isArray(value)) {
+                for (const item of value) checkValue(item);
+            } else if (typeof value === 'object' && value !== null) {
+                for (const key in value) {
+                    if (Object.hasOwn(value, key)) {
+                        checkValue(value[key]);
+                    }
+                }
+            }
+        };
+
+        checkValue(obj);
+        return obj;
+    }
+}
+// Instantiate guard once (e.g., globally or per module)
+const guard = new SqlInjectionGuard(logger);
+
+let adjustTypes = function (row, types) {
+    if (types) {
+        for (let i = 0; i < types.length; i++) {
+            if (i < row.length) {
+                let type = types[i];
+                switch (type) {
+                    case 'string':
+                        row[i] = convertToString(row[i]);
+                        break;
+                    case 'integer':
+                        row[i] = convertToInteger(row[i]);
+                        break;
+                    case 'decimal':
+                        row[i] = convertToDecimal(row[i]);
+                        break;
+                    case 'boolean':
+                        row[i] = convertToBoolean(row[i]);
+                        break;
+                    case 'datetime':
+                        row[i] = convertToDatetime(row[i]);
+                        break;
+                    case 'date':
+                        row[i] = convertToDate(row[i]);
+                        break;
+                    case 'time':
+                        row[i] = convertToTime(row[i]);
+                        break;
+                    case 'binary':
+                        row[i] = convertToBinary(row[i]);
+                        break;
+                }
+            }
+        }
+    }
+};
+let convertToString = function (value) {
+    if (value === null)
+        return null;
+    let valueType = toString.call(value);
+    if (valueType === '[object String]')
+        return value;
+    if (valueType === '[object Number]')
+        return value.toString();
+    if (valueType === '[object Boolean]')
+        return value ? 'true' : 'false';
+    if (valueType === '[object Date]')
+        return value.toJSON();
+    throw errorInvalidConversion(value, 'string');
+};
+let convertToInteger = function (value) {
+    if (value === null)
+        return null;
+    let valueType = toString.call(value);
+    if (valueType === '[object String]' && !isNaN(value))
+        return Math.round(Number(value));
+    if (valueType === '[object Number]')
+        return Math.round(value);
+    if (valueType === '[object Boolean]')
+        return value ? 1 : 0;
+    throw errorInvalidConversion(value, 'integer');
+};
+let convertToDecimal = function (value) {
+    if (value === null)
+        return null;
+    let valueType = toString.call(value);
+    if (valueType === '[object String]' && !isNaN(value))
+        return Number(value);
+    if (valueType === '[object Number]')
+        return value;
+    if (valueType === '[object Boolean]')
+        return value ? 1 : 0;
+    throw errorInvalidConversion(value, 'decimal');
+};
+let convertToBoolean = function (value) {
+    if (value === null)
+        return null;
+    let valueType = toString.call(value);
+    if (valueType === '[object String]') {
+        if (value === '1' || value.toUpperCase() === 'T' || value.toUpperCase() === 'TRUE' || value.toUpperCase() === 'Y' || value.toUpperCase() === 'YES')
+            return true;
+        if (value === '0' || value.toUpperCase() === 'F' || value.toUpperCase() === 'FALSE' || value.toUpperCase() === 'N' || value.toUpperCase() === 'NO')
+            return false;
+    }
+    if (valueType === '[object Number]') {
+        if (value === 1)
+            return true;
+        if (value === 0)
+            return false;
+    }
+    if (valueType === '[object Boolean]')
+        return value;
+    throw errorInvalidConversion(value, 'boolean');
+};
+let convertToDatetime = function (value) {
+    if (value === null)
+        return null;
+    let valueType = toString.call(value);
+    if (valueType === '[object String]') {
+        let matchDatetime = /^(\d{4})-(\d{1,2})-(\d{1,2})[T,\s](\d{1,2})\:(\d{1,2})\:(\d{1,2})\.?(\d+)?Z?$/.exec(value);
+        if (matchDatetime)
+            return new Date(Date.UTC(Number(matchDatetime[1]), Number(matchDatetime[2]) - 1, Number(matchDatetime[3]), Number(matchDatetime[4]), Number(matchDatetime[5]), Number(matchDatetime[6] || 0), convertMilliseconds(matchDatetime[7])));
+        else {
+            const probableDate = new Date(value);
+            if (probableDate.toString() !== 'Invalid Date') {
+                return probableDate;
+            }
+        }
+    }
+    if (valueType === '[object Date]') {
+        return value;
+    }
+    if (valueType === "[object Number]") {
+        return new Date(value);
+    }
+    throw errorInvalidConversion(value, 'datetime');
+};
+let convertToDate = function (value) {
+    if (value === null)
+        return null;
+    let valueType = toString.call(value);
+    if (valueType === '[object String]') {
+        let matchDate = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(value);
+        if (matchDate)
+            //TODO: revisar por qu esta asumiendo que es una fecha UTC cuando deberia ser local
+            return new Date(Date.UTC(Number(matchDate[1]), Number(matchDate[2]) - 1, Number(matchDate[3]), 0, 0, 0, 0));
+        let matchDatetime = /^(\d{4})-(\d{1,2})-(\d{1,2})[T,\s](\d{1,2})\:(\d{1,2})\:(\d{1,2})\.?(\d+)?Z?$/.exec(value);
+        if (matchDatetime)
+            return new Date(Date.UTC(Number(matchDatetime[1]), Number(matchDatetime[2]) - 1, Number(matchDatetime[3]), 0, 0, 0, 0));
+        else {
+            const probableDate = new Date(value);
+            if (probableDate.toString() !== 'Invalid Date') {
+                //TODO: revisar por qu esta asumiendo que es una fecha UTC cuando deberia ser local
+                return new Date(Date.UTC(probableDate.getUTCFullYear(), probableDate.getUTCMonth(), probableDate.getUTCDate(), 0, 0, 0, 0));
+            }
+        }
+    }
+    if (valueType === "[object Number]") {
+        value = new Date(value);
+    }
+    if (valueType === '[object Date]') {
+        return new Date(Date.UTC(value.getUTCFullYear(), value.getUTCMonth(), value.getUTCDate(), 0, 0, 0, 0));
+    }
+    throw errorInvalidConversion(value, 'date');
+};
+let convertToTime = function (value) {
+    if (value === null)
+        return null;
+    let valueType = toString.call(value);
+    if (valueType === '[object String]') {
+        let matchTime = /^\+?(\d{1,2})\:(\d{1,2})\:(\d{1,2})\.?(\d+)?$/.exec(value);
+        if (matchTime) {
+            return new Date(Date.UTC(1970, 0, 1, Number(matchTime[1]), Number(matchTime[2]), Number(matchTime[3]), convertMilliseconds(matchTime[4])));
+        }
+        let matchDatetime = /^(\d{4})-(\d{1,2})-(\d{1,2})[T,\s](\d{1,2})\:(\d{1,2})\:(\d{1,2})\.?(\d+)?Z?$/.exec(value);
+        if (matchDatetime) {
+            return new Date(Date.UTC(1970, 0, 1, Number(matchDatetime[4]), Number(matchDatetime[5]), Number(matchDatetime[6] || 0), convertMilliseconds(matchDatetime[7])));
+        }
+    }
+    if (valueType === '[object Date]') {
+        return new Date(Date.UTC(1970, 0, 1, value.getUTCHours(), value.getUTCMinutes(), value.getUTCSeconds(), value.getUTCMilliseconds()));
+    }
+    throw errorInvalidConversion(value, 'time');
+};
+let convertToBinary = function (value) {
+    if (value == null)
+        return null;
+    if (value && value.type === 'Buffer')
+        return Buffer.from(value);
+    if (Buffer.isBuffer(value))
+        return value;
+    if (Array.isArray(value))
+        return Buffer.from(value);
+    throw errorInvalidConversion(value, 'binary');
+};
+let convertMilliseconds = function (strMilliseconds) {
+    if (strMilliseconds) {
+        if (strMilliseconds.length < 3)
+            strMilliseconds = strMilliseconds.padEnd(3, '0');
+        if (strMilliseconds.length > 3)
+            strMilliseconds = strMilliseconds.substr(0, 3);
+        return Number(strMilliseconds);
+    }
+    else
+        return 0;
+};
+let errorInvalidConversion = function (value, targetType) {
+    let err = new Error();
+    err.code = 'InvalidConversion';
+    err.data = { value: value, targetType: targetType };
+    return err;
+};
+
+function getTransactionsContext(callContext) {
+    if (!callContext.rdsTransactionContext) {
+        callContext.rdsTransactionContext = [];
+    }
+    return callContext.rdsTransactionContext;
+}
+/**
+ * @param {*} callContext
+ * @param {*} connection
+ * @return { rdsConnection: RdsConnection, mustBeClosed: boolean }
+ */
+let getRdsConnection = async function (callContext, connection) {
+    /**
+     * 1-. Debido a que cada petición tiene su propia pila de conexiones para la
+     * transacción, la obtenemos para ver cúal es la conexión que debe devolver.
+     */
+    let transactionsStack = getTransactionsContext(callContext);
+    /**
+     * 2-. Si la pila se encuentra vacía, indica que no estamos en un entorno de
+     * transacción, por lo tanto, devolvemos una conexión nueva.
+     */
+    if (transactionsStack.length === 0) {
+        let rdsConnection = new RdsConnection(await connection.provider.createRdsConnection(connection), connection.provider);
+        return { rdsConnection, mustBeClosed: true };
+    } else {
+        /**
+         * 3-. Si la pila no se encuentra vacía, significa que estamos en un contexto en donde
+         * se manejan transacciones, la transaccion que debe utilizarla conexion es la última
+         *
+         * De esta transaccion, debemos obtener la conexion asociada al nombre de conexión. Si
+         * esta no existe, debemos generar una conexion nueva.
+         */
+        let connectionName = connection.name;
+        var transactionBrick = transactionsStack[transactionsStack.length - 1];
+
+        if (!transactionBrick.connection) {
+            let rdsConnection = new RdsConnection(await connection.provider.createRdsConnection(connection), connection.provider);
+            return { rdsConnection, mustBeClosed: true };
+        }
+        let rdsConnection = transactionBrick.connection[connectionName];
+        if (!rdsConnection) {
+            /**
+             * Sino, tenemos que crear una nueva conexión y asociarla con el bloque de transacción para poder
+             * registrarla y devolverla de ahora en mas. Además, se inicializa la conexión para indicar el tipo
+             * de propagación que va a tener la transacción
+             */
+            rdsConnection = new RdsConnection(await connection.provider.createRdsConnection(connection), connection.provider);
+            transactionBrick.connection[connectionName] = rdsConnection;
+            await rdsConnection.beginTransaction();
+        }
+        /**
+         * Si el bloque de transacción tiene asociada una conexión, devolvemos la misma, acompañada con
+         * el tipo de transacción que estamos llevando adelante.
+         */
+        return { rdsConnection, mustBeClosed: false };
+    }
+};
+/**
+ * @param {*} nativeConnection
+ * @param {*} provider
+ * @constructor
+ */
+function RdsConnection(nativeConnection, provider) {
+    let transactionRequest = false;
+    return {
+        async beginTransaction() {
+            transactionRequest = true;
+            return await provider.beginTransaction(nativeConnection);
+        },
+        async close() {
+            transactionRequest = false;
+            return await provider.close(nativeConnection);
+        },
+        async commitTransaction() {
+            transactionRequest = false;
+            return await provider.commitTransaction(nativeConnection);
+        },
+        get connection() {
+            return nativeConnection;
+        },
+        get isTransactionRequest() {
+            return transactionRequest;
+        },
+        async rollbackTransaction() {
+            transactionRequest = false;
+            return await provider.rollbackTransaction(nativeConnection);
+        }
+    }
+}
+
+let _relationalDatabaseQueryId;
+
+module.exports = {
+    execute: async function (callContext, connection, sql, parameters, options, types, fnSelection) {
+        let traceId = null;
+        let traceStartTime = null;
+        if (process.env.blz_traceAll === 'true' || process.env.blz_traceRelationalDatabaseQueries === 'true') {
+            if (typeof _relationalDatabaseQueryId === 'undefined')
+                _relationalDatabaseQueryId = 1;
+            else
+                _relationalDatabaseQueryId++;
+            traceId = _relationalDatabaseQueryId;
+            traceStartTime = Date.now();
+            console.log((callContext.devTime ? '' : new Date().toISOString() + ' | ') + 'RELATIONAL DATABASE QUERY (' + traceId + ') | ' + connection.name + ' | ' + sql + ' | PARAMETERS: ' + JSON.stringify(parameters));
+        }
+        let resultSet = null, rdsConnection = null, mustBeClosed = null;
+        try {
+            if (process.env.blz_securityApiSanitizeSqlInjection) {
+                sql = guard.validateRawSql(sql)
+                parameters = guard.validateParamList(parameters);
+            }
+            ({ rdsConnection, mustBeClosed } = await getRdsConnection(callContext, connection));
+            if (options) {
+                options.isTransactionRequest = rdsConnection.isTransactionRequest;
+            } else {
+                options = {
+                    isTransactionRequest: rdsConnection.isTransactionRequest
+                };
+            }
+            let preResult = await connection.provider.executeSql(rdsConnection.connection, sql, parameters, options);
+            if (process.env.blz_traceAll === 'true' || process.env.blz_traceRelationalDatabaseQueries === 'true')
+                console.log((callContext.devTime ? '' : new Date().toISOString() + ' | ') + 'RELATIONAL DATABASE QUERY (' + traceId + ') | ' + connection.name + ' | ' + (Date.now() - traceStartTime) + ' milliseconds');
+            let result = { data: null };
+            if (preResult.data) {
+                if (options.queryOne) {
+                    let row = preResult.data.length > 0 ? preResult.data[0] : null;
+                    if (row) {
+                        adjustTypes(row, types);
+                        if (process.env.blz_traceAll === 'true' || process.env.blz_traceRelationalDatabaseQueries === 'true')
+                            console.log((callContext.devTime ? '' : new Date().toISOString() + ' | ') + 'RELATIONAL DATABASE QUERY (' + traceId + ') | ' + connection.name + ' | ' + JSON.stringify(row));
+                        result.data = await fnSelection(row);
+                    }
+                    else {
+                        if (process.env.blz_traceAll === 'true' || process.env.blz_traceRelationalDatabaseQueries === 'true')
+                            console.log((callContext.devTime ? '' : new Date().toISOString() + ' | ') + 'RELATIONAL DATABASE QUERY (' + traceId + ') | ' + connection.name + ' | No records found');
+                        result.data = null;
+                    }
+                }
+                else {
+                    result.data = [];
+                    let rowIndex = 0;
+                    for (let i = 0; i < preResult.data.length; i++) {
+                        let row = preResult.data[i];
+                        adjustTypes(row, types);
+                        rowIndex++;
+                        if (rowIndex <= 10 && (process.env.blz_traceAll === 'true' || process.env.blz_traceRelationalDatabaseQueries === 'true'))
+                            console.log((callContext.devTime ? '' : new Date().toISOString() + ' | ') + 'RELATIONAL DATABASE QUERY (' + traceId + ') | ' + connection.name + ' | ' + JSON.stringify(row));
+                        result.data.push(await fnSelection(row));
+                    }
+                    if (rowIndex === 0 && (process.env.blz_traceAll === 'true' || process.env.blz_traceRelationalDatabaseQueries === 'true'))
+                        console.log((callContext.devTime ? '' : new Date().toISOString() + ' | ') + 'RELATIONAL DATABASE QUERY (' + traceId + ') | ' + connection.name + ' | No records found');
+                    if (rowIndex > 10 && (process.env.blz_traceAll === 'true' || process.env.blz_traceRelationalDatabaseQueries === 'true'))
+                        console.log((callContext.devTime ? '' : new Date().toISOString() + ' | ') + 'RELATIONAL DATABASE QUERY (' + traceId + ') | ' + connection.name + ' | More records found');
+                }
+            }
+            else if (preResult.resultSet) {
+                resultSet = preResult.resultSet;
+                if (options.queryOne) {
+                    let row = await resultSet.getRow();
+                    if (row) {
+                        adjustTypes(row, types);
+                        if (process.env.blz_traceAll === 'true' || process.env.blz_traceRelationalDatabaseQueries === 'true')
+                            console.log((callContext.devTime ? '' : new Date().toISOString() + ' | ') + 'RELATIONAL DATABASE QUERY (' + traceId + ') | ' + connection.name + ' | ' + JSON.stringify(row));
+                        result.data = await fnSelection(row);
+                    }
+                    else {
+                        if (process.env.blz_traceAll === 'true' || process.env.blz_traceRelationalDatabaseQueries === 'true')
+                            console.log((callContext.devTime ? '' : new Date().toISOString() + ' | ') + 'RELATIONAL DATABASE QUERY (' + traceId + ') | ' + connection.name + ' | No records found');
+                        result.data = null;
+                    }
+                }
+                else {
+                    result.data = [];
+                    let rowIndex = 0;
+                    let row = await resultSet.getRow();
+                    if (row)
+                        adjustTypes(row, types);
+                    while (row) {
+                        rowIndex++;
+                        if (rowIndex <= 10 && (process.env.blz_traceAll === 'true' || process.env.blz_traceRelationalDatabaseQueries === 'true'))
+                            console.log((callContext.devTime ? '' : new Date().toISOString() + ' | ') + 'RELATIONAL DATABASE QUERY (' + traceId + ') | ' + connection.name + ' | ' + JSON.stringify(row));
+                        result.data.push(await fnSelection(row));
+                        row = await resultSet.getRow();
+                        if (row)
+                            adjustTypes(row, types);
+                    }
+                    if (rowIndex === 0 && (process.env.blz_traceAll === 'true' || process.env.blz_traceRelationalDatabaseQueries === 'true'))
+                        console.log((callContext.devTime ? '' : new Date().toISOString() + ' | ') + 'RELATIONAL DATABASE QUERY (' + traceId + ') | ' + connection.name + ' | No records found');
+                    if (rowIndex > 10 && (process.env.blz_traceAll === 'true' || process.env.blz_traceRelationalDatabaseQueries === 'true'))
+                        console.log((callContext.devTime ? '' : new Date().toISOString() + ' | ') + 'RELATIONAL DATABASE QUERY (' + traceId + ') | ' + connection.name + ' | More records found');
+                }
+            }
+            if (preResult.rowsAffected)
+                result.rowsAffected = preResult.rowsAffected;
+            if (preResult.id)
+                result.id = preResult.id;
+            if (preResult.ids)
+                result.ids = preResult.ids;
+            if (preResult.outParameters)
+                result.outParameters = preResult.outParameters;
+            if (resultSet && resultSet.close)
+                await resultSet.close();
+            if (mustBeClosed)
+                await connection.provider.close(rdsConnection.connection);
+            return result;
+        }
+        catch (err) {
+            if (resultSet && resultSet.close)
+                await resultSet.close();
+            if (mustBeClosed)
+                await connection.provider.close(rdsConnection.connection);
+            let rdsError = new Error();
+            rdsError.code = 'RdsError';
+            rdsError.message = 'Error executing sql ' + sql;
+            rdsError.data = { connectionName: connection.name, sql: sql, parameters: parameters };
+            rdsError.innerError = err;
+            throw rdsError;
+        }
+    },
+    checkConnection: async function (connection) {
+        ({ rdsConnection, mustBeClosed } = await getRdsConnection({}, connection));
+        let rdsConnection = new RdsConnection(await connection.provider.createRdsConnection(connection), connection.provider);
+    }
+};