data-api-client 2.0.0-beta.0 → 2.1.0

package/dist/compat/pg.js

@@ -0,0 +1,344 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPgClient = createPgClient;
+exports.createPgPool = createPgPool;
+const events_1 = require("events");
+const pg_escape_1 = __importDefault(require("pg-escape"));
+const client_1 = require("../client");
+const errors_1 = require("./errors");
+function convertPgPlaceholders(sql, params = []) {
+    const namedParams = {};
+    const convertedSql = sql.replace(/\$(\d+)/g, (match, index) => {
+        const paramIndex = parseInt(index, 10) - 1;
+        if (paramIndex >= 0 && paramIndex < params.length) {
+            const key = `p${index}`;
+            namedParams[key] = params[paramIndex];
+            return `:${key}`;
+        }
+        return match;
+    });
+    return { sql: convertedSql, params: namedParams };
+}
+function inferCommand(sql) {
+    var _a;
+    const match = (_a = sql.trim().split(/\s+/)[0]) === null || _a === void 0 ? void 0 : _a.toUpperCase();
+    const knownCommands = ['SELECT', 'INSERT', 'UPDATE', 'DELETE', 'CREATE', 'DROP', 'ALTER', 'TRUNCATE', 'GRANT', 'REVOKE'];
+    return knownCommands.includes(match) ? match : 'QUERY';
+}
+function convertToPgResult(result, sql, rowMode) {
+    if (result.records && Array.isArray(result.records)) {
+        let rows = result.records;
+        const fields = rows.length > 0 && typeof rows[0] === 'object' && rows[0] !== null
+            ? Object.keys(rows[0]).map((name) => ({ name }))
+            : [];
+        if (rowMode === 'array' && rows.length > 0 && typeof rows[0] === 'object') {
+            rows = rows.map((row) => Object.values(row));
+        }
+        return {
+            rows,
+            rowCount: rows.length,
+            command: inferCommand(sql),
+            fields,
+            oid: 0
+        };
+    }
+    else if (result.numberOfRecordsUpdated !== undefined) {
+        return {
+            rows: [],
+            rowCount: result.numberOfRecordsUpdated,
+            command: inferCommand(sql),
+            fields: [],
+            oid: 0
+        };
+    }
+    else if (result.insertId !== undefined) {
+        return {
+            rows: [],
+            rowCount: 1,
+            command: 'INSERT',
+            fields: [],
+            oid: 0
+        };
+    }
+    else {
+        return {
+            rows: [],
+            rowCount: 0,
+            command: inferCommand(sql),
+            fields: [],
+            oid: 0
+        };
+    }
+}
+function createPgClient(config) {
+    const pgConfig = {
+        ...config,
+        engine: 'pg',
+        hydrateColumnNames: true
+    };
+    const core = (0, client_1.init)(pgConfig);
+    const eventEmitter = new events_1.EventEmitter();
+    let transactionId;
+    async function executeQuery(sqlOrConfig, params) {
+        let sql;
+        let values = [];
+        let rowMode;
+        if (typeof sqlOrConfig === 'string') {
+            sql = sqlOrConfig;
+            values = params || [];
+        }
+        else {
+            sql = sqlOrConfig.text;
+            values = params !== undefined ? params : (sqlOrConfig.values || []);
+            rowMode = sqlOrConfig.rowMode;
+        }
+        const upperSql = sql.trim().toUpperCase();
+        if (upperSql === 'BEGIN' || upperSql.startsWith('BEGIN ')) {
+            const txResult = await core.beginTransaction();
+            transactionId = txResult.transactionId;
+            return {
+                rows: [],
+                rowCount: 0,
+                command: 'BEGIN',
+                fields: []
+            };
+        }
+        if (upperSql === 'COMMIT') {
+            if (transactionId) {
+                await core.commitTransaction({ transactionId });
+                transactionId = undefined;
+            }
+            return {
+                rows: [],
+                rowCount: 0,
+                command: 'COMMIT',
+                fields: []
+            };
+        }
+        if (upperSql === 'ROLLBACK') {
+            if (transactionId) {
+                await core.rollbackTransaction({ transactionId });
+                transactionId = undefined;
+            }
+            return {
+                rows: [],
+                rowCount: 0,
+                command: 'ROLLBACK',
+                fields: []
+            };
+        }
+        const { sql: convertedSql, params: namedParams } = convertPgPlaceholders(sql, values);
+        const queryOptions = {
+            sql: convertedSql,
+            parameters: namedParams
+        };
+        if (transactionId) {
+            queryOptions.transactionId = transactionId;
+        }
+        const result = await core.query(queryOptions);
+        return convertToPgResult(result, sql, rowMode);
+    }
+    const client = Object.assign(eventEmitter, {
+        connect(callback) {
+            if (callback) {
+                process.nextTick(() => callback(null));
+                return;
+            }
+            return Promise.resolve();
+        },
+        end(callback) {
+            if (callback) {
+                process.nextTick(() => callback());
+                return;
+            }
+            return Promise.resolve();
+        },
+        copyFrom(_queryText) {
+            throw new Error('COPY FROM is not supported by RDS Data API');
+        },
+        copyTo(_queryText) {
+            throw new Error('COPY TO is not supported by RDS Data API');
+        },
+        pauseDrain() {
+        },
+        resumeDrain() {
+        },
+        escapeIdentifier(str) {
+            return pg_escape_1.default.ident(str);
+        },
+        escapeLiteral(str) {
+            return pg_escape_1.default.literal(str);
+        },
+        setTypeParser(_oid, _format, _parseFn) {
+        },
+        getTypeParser(_oid, _format) {
+            return (text) => text;
+        },
+        release(_err) {
+        },
+        query(sqlOrConfig, paramsOrCallback, callback) {
+            if (typeof sqlOrConfig === 'object' && 'submit' in sqlOrConfig) {
+                throw new Error('Query streams are not supported by RDS Data API');
+            }
+            let params = [];
+            let cb;
+            if (typeof sqlOrConfig === 'object' && 'text' in sqlOrConfig) {
+                if (typeof paramsOrCallback === 'function') {
+                    cb = paramsOrCallback;
+                }
+                else if (Array.isArray(paramsOrCallback)) {
+                    params = paramsOrCallback;
+                    cb = callback;
+                }
+            }
+            else {
+                if (typeof paramsOrCallback === 'function') {
+                    cb = paramsOrCallback;
+                }
+                else if (Array.isArray(paramsOrCallback)) {
+                    params = paramsOrCallback;
+                    cb = callback;
+                }
+            }
+            if (cb) {
+                executeQuery(sqlOrConfig, params)
+                    .then((result) => cb(null, result))
+                    .catch((err) => {
+                    const pgError = (0, errors_1.mapToPostgresError)(err);
+                    client.emit('error', pgError);
+                    cb(pgError, null);
+                });
+                return;
+            }
+            return executeQuery(sqlOrConfig, params).catch((err) => {
+                const pgError = (0, errors_1.mapToPostgresError)(err);
+                client.emit('error', pgError);
+                throw pgError;
+            });
+        }
+    });
+    return client;
+}
+function createPgPool(config) {
+    const pgConfig = {
+        ...config,
+        engine: 'pg',
+        hydrateColumnNames: true
+    };
+    const core = (0, client_1.init)(pgConfig);
+    const eventEmitter = new events_1.EventEmitter();
+    async function executePoolQuery(sqlOrConfig, params) {
+        let sql;
+        let values = [];
+        let rowMode;
+        if (typeof sqlOrConfig === 'string') {
+            sql = sqlOrConfig;
+            values = params || [];
+        }
+        else {
+            sql = sqlOrConfig.text;
+            values = params !== undefined ? params : (sqlOrConfig.values || []);
+            rowMode = sqlOrConfig.rowMode;
+        }
+        const { sql: convertedSql, params: namedParams } = convertPgPlaceholders(sql, values);
+        const result = await core.query({
+            sql: convertedSql,
+            parameters: namedParams
+        });
+        return convertToPgResult(result, sql, rowMode);
+    }
+    const pool = Object.assign(eventEmitter, {
+        get totalCount() {
+            return 0;
+        },
+        get idleCount() {
+            return 0;
+        },
+        get waitingCount() {
+            return 0;
+        },
+        get expiredCount() {
+            return 0;
+        },
+        get ending() {
+            return false;
+        },
+        get ended() {
+            return false;
+        },
+        options: {},
+        connect(callback) {
+            const getClient = () => {
+                const client = createPgClient(config);
+                client.release = () => {
+                    pool.emit('remove', client);
+                };
+                pool.emit('acquire', client);
+                pool.emit('connect', client);
+                return client;
+            };
+            if (callback) {
+                try {
+                    const client = getClient();
+                    process.nextTick(() => callback(null, client));
+                }
+                catch (err) {
+                    process.nextTick(() => callback(err));
+                }
+                return;
+            }
+            return Promise.resolve(getClient());
+        },
+        end(callback) {
+            if (callback) {
+                process.nextTick(() => callback());
+                return;
+            }
+            return Promise.resolve();
+        },
+        query(sqlOrConfig, paramsOrCallback, callback) {
+            if (typeof sqlOrConfig === 'object' && 'submit' in sqlOrConfig) {
+                throw new Error('Query streams are not supported by RDS Data API');
+            }
+            let params = [];
+            let cb;
+            if (typeof sqlOrConfig === 'object' && 'text' in sqlOrConfig) {
+                if (typeof paramsOrCallback === 'function') {
+                    cb = paramsOrCallback;
+                }
+                else if (Array.isArray(paramsOrCallback)) {
+                    params = paramsOrCallback;
+                    cb = callback;
+                }
+            }
+            else {
+                if (typeof paramsOrCallback === 'function') {
+                    cb = paramsOrCallback;
+                }
+                else if (Array.isArray(paramsOrCallback)) {
+                    params = paramsOrCallback;
+                    cb = callback;
+                }
+            }
+            if (cb) {
+                executePoolQuery(sqlOrConfig, params)
+                    .then((result) => cb(null, result))
+                    .catch((err) => {
+                    const pgError = (0, errors_1.mapToPostgresError)(err);
+                    pool.emit('error', pgError);
+                    cb(pgError, null);
+                });
+                return;
+            }
+            return executePoolQuery(sqlOrConfig, params).catch((err) => {
+                const pgError = (0, errors_1.mapToPostgresError)(err);
+                pool.emit('error', pgError);
+                throw pgError;
+            });
+        }
+    });
+    return pool;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { init } from './client';
+export = init;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAC/B,SAAS,IAAI,CAAA"}

package/dist/index.js

@@ -0,0 +1,3 @@
+'use strict';
+const client_1 = require("./client");
+module.exports = client_1.init;

package/dist/params.d.ts

@@ -0,0 +1,19 @@
+import type { InternalConfig, Parameters, ParameterValue, NamedParameter, FormattedParameter, SqlParamInfo, FormatOptions, SupportedType } from './types';
+export declare const parseParams: (args: any[]) => Parameters[];
+export declare const parseDatabase: (config: InternalConfig, args: any[]) => string | undefined;
+export declare const parseHydrate: (config: InternalConfig, args: any[]) => boolean;
+export declare const parseFormatOptions: (config: InternalConfig, args: any[]) => Required<FormatOptions>;
+export declare const prepareParams: ({ secretArn, resourceArn }: InternalConfig, args: any[]) => {
+    secretArn: string;
+    resourceArn: string;
+    [key: string]: any;
+};
+export declare const normalizeParams: (params: Parameters[]) => (NamedParameter | NamedParameter[])[];
+export declare const processParams: (engine: string, sql: string, sqlParams: Record<string, SqlParamInfo>, params: (NamedParameter | NamedParameter[])[], formatOptions: Required<FormatOptions>, row?: number) => {
+    processedParams: (FormattedParameter | FormattedParameter[])[];
+    escapedSql: string;
+};
+export declare const formatParam: (n: string, v: ParameterValue, formatOptions: Required<FormatOptions>, engine?: string) => FormattedParameter;
+export declare const splitParams: (p: Record<string, ParameterValue>) => NamedParameter[];
+export declare const formatType: (name: string, value: ParameterValue, type: SupportedType | null | undefined, typeHint: string | undefined, formatOptions: Required<FormatOptions>) => FormattedParameter;
+//# sourceMappingURL=params.d.ts.map

package/dist/params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["../src/params.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,cAAc,EACd,UAAU,EACV,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,SAAS,CAAA;AAIhB,eAAO,MAAM,WAAW,GAAI,MAAM,GAAG,EAAE,KAAG,UAAU,EAa5C,CAAA;AAGR,eAAO,MAAM,aAAa,GAAI,QAAQ,cAAc,EAAE,MAAM,GAAG,EAAE,KAAG,MAAM,GAAG,SAS9D,CAAA;AAGf,eAAO,MAAM,YAAY,GAAI,QAAQ,cAAc,EAAE,MAAM,GAAG,EAAE,KAAG,OAKpC,CAAA;AAG/B,eAAO,MAAM,kBAAkB,GAAI,QAAQ,cAAc,EAAE,MAAM,GAAG,EAAE,KAAG,QAAQ,CAAC,aAAa,CAkBrE,CAAA;AAG1B,eAAO,MAAM,aAAa,GACxB,4BAA4B,cAAc,EAC1C,MAAM,GAAG,EAAE,KACV;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAK9D,CAAA;AAOD,eAAO,MAAM,eAAe,GAAI,QAAQ,UAAU,EAAE,KAAG,CAAC,cAAc,GAAG,cAAc,EAAE,CAAC,EAavF,CAAA;AAGH,eAAO,MAAM,aAAa,GACxB,QAAQ,MAAM,EACd,KAAK,MAAM,EACX,WAAW,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EACvC,QAAQ,CAAC,cAAc,GAAG,cAAc,EAAE,CAAC,EAAE,EAC7C,eAAe,QAAQ,CAAC,aAAa,CAAC,EACtC,MAAK,MAAU,KACd;IAAE,eAAe,EAAE,CAAC,kBAAkB,GAAG,kBAAkB,EAAE,CAAC,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAgCtF,CAAA;AAGD,eAAO,MAAM,WAAW,GAAI,GAAG,MAAM,EAAE,GAAG,cAAc,EAAE,eAAe,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,KAAG,kBAC/C,CAAA;AAGrE,eAAO,MAAM,WAAW,GAAI,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,KAAG,cAAc,EACiB,CAAA;AAG/F,eAAO,MAAM,UAAU,GACrB,MAAM,MAAM,EACZ,OAAO,cAAc,EACrB,MAAM,aAAa,GAAG,IAAI,GAAG,SAAS,EACtC,UAAU,MAAM,GAAG,SAAS,EAC5B,eAAe,QAAQ,CAAC,aAAa,CAAC,KACrC,kBAgBF,CAAA"}

package/dist/params.js

@@ -0,0 +1,125 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatType = exports.splitParams = exports.formatParam = exports.processParams = exports.normalizeParams = exports.prepareParams = exports.parseFormatOptions = exports.parseHydrate = exports.parseDatabase = exports.parseParams = void 0;
+const sqlstring_1 = __importDefault(require("sqlstring"));
+const pg_escape_1 = __importDefault(require("pg-escape"));
+const utils_1 = require("./utils");
+const parseParams = (args) => Array.isArray(args[0].parameters)
+    ? args[0].parameters
+    : typeof args[0].parameters === 'object'
+        ? [args[0].parameters]
+        : Array.isArray(args[1])
+            ? args[1]
+            : typeof args[1] === 'object'
+                ? [args[1]]
+                : args[0].parameters
+                    ? (0, utils_1.error)(`'parameters' must be an object or array`)
+                    : args[1]
+                        ? (0, utils_1.error)('Parameters must be an object or array')
+                        : [];
+exports.parseParams = parseParams;
+const parseDatabase = (config, args) => config.transactionId
+    ? config.database
+    : typeof args[0].database === 'string'
+        ? args[0].database
+        : args[0].database
+            ? (0, utils_1.error)(`'database' must be a string.`)
+            : config.database
+                ? config.database
+                : undefined;
+exports.parseDatabase = parseDatabase;
+const parseHydrate = (config, args) => typeof args[0].hydrateColumnNames === 'boolean'
+    ? args[0].hydrateColumnNames
+    : args[0].hydrateColumnNames
+        ? (0, utils_1.error)(`'hydrateColumnNames' must be a boolean.`)
+        : config.hydrateColumnNames;
+exports.parseHydrate = parseHydrate;
+const parseFormatOptions = (config, args) => typeof args[0].formatOptions === 'object'
+    ? {
+        deserializeDate: typeof args[0].formatOptions.deserializeDate === 'boolean'
+            ? args[0].formatOptions.deserializeDate
+            : args[0].formatOptions.deserializeDate
+                ? (0, utils_1.error)(`'formatOptions.deserializeDate' must be a boolean.`)
+                : config.formatOptions.deserializeDate,
+        treatAsLocalDate: typeof args[0].formatOptions.treatAsLocalDate == 'boolean'
+            ? args[0].formatOptions.treatAsLocalDate
+            : args[0].formatOptions.treatAsLocalDate
+                ? (0, utils_1.error)(`'formatOptions.treatAsLocalDate' must be a boolean.`)
+                : config.formatOptions.treatAsLocalDate
+    }
+    : args[0].formatOptions
+        ? (0, utils_1.error)(`'formatOptions' must be an object.`)
+        : config.formatOptions;
+exports.parseFormatOptions = parseFormatOptions;
+const prepareParams = ({ secretArn, resourceArn }, args) => {
+    return Object.assign({ secretArn, resourceArn }, typeof args[0] === 'object' ? omit(args[0], ['hydrateColumnNames', 'parameters']) : {});
+};
+exports.prepareParams = prepareParams;
+const omit = (obj, values) => Object.keys(obj).reduce((acc, x) => (values.includes(x) ? acc : Object.assign(acc, { [x]: obj[x] })), {});
+const normalizeParams = (params) => params.reduce((acc, p) => Array.isArray(p)
+    ? acc.concat([(0, exports.normalizeParams)(p)])
+    : (Object.keys(p).length === 2 && 'name' in p && typeof p.value !== 'undefined') ||
+        (Object.keys(p).length === 3 &&
+            'name' in p &&
+            typeof p.value !== 'undefined' &&
+            'cast' in p)
+        ? acc.concat(p)
+        : acc.concat(...(0, exports.splitParams)(p)), []);
+exports.normalizeParams = normalizeParams;
+const processParams = (engine, sql, sqlParams, params, formatOptions, row = 0) => {
+    return {
+        processedParams: params.reduce((acc, p) => {
+            if (Array.isArray(p)) {
+                const result = (0, exports.processParams)(engine, sql, sqlParams, p, formatOptions, row);
+                if (row === 0) {
+                    sql = result.escapedSql;
+                    row++;
+                }
+                return acc.concat([result.processedParams]);
+            }
+            else if (sqlParams[p.name]) {
+                if (sqlParams[p.name].type === 'n_ph') {
+                    if (p.cast) {
+                        const regex = new RegExp(':' + p.name + '\\b', 'g');
+                        sql = sql.replace(regex, engine === 'pg' ? `:${p.name}::${p.cast}` : `CAST(:${p.name} AS ${p.cast})`);
+                    }
+                    acc.push((0, exports.formatParam)(p.name, p.value, formatOptions, engine));
+                }
+                else if (row === 0) {
+                    const regex = new RegExp('::' + p.name + '\\b', 'g');
+                    const escapedId = engine === 'pg'
+                        ? pg_escape_1.default.ident(p.value)
+                        : sqlstring_1.default.escapeId(p.value);
+                    sql = sql.replace(regex, escapedId);
+                }
+                return acc;
+            }
+            else {
+                return acc;
+            }
+        }, []),
+        escapedSql: sql
+    };
+};
+exports.processParams = processParams;
+const formatParam = (n, v, formatOptions, engine) => (0, exports.formatType)(n, v, (0, utils_1.getType)(v), (0, utils_1.getTypeHint)(v, engine), formatOptions);
+exports.formatParam = formatParam;
+const splitParams = (p) => Object.keys(p).reduce((arr, x) => arr.concat({ name: x, value: p[x] }), []);
+exports.splitParams = splitParams;
+const formatType = (name, value, type, typeHint, formatOptions) => {
+    return Object.assign(typeHint != null ? { name, typeHint } : { name }, type === null
+        ? { value }
+        : {
+            value: {
+                [type ? type : (0, utils_1.error)(`'${name}' is an invalid type`)]: type === 'isNull'
+                    ? true
+                    : (0, utils_1.isDate)(value)
+                        ? (0, utils_1.formatToTimeStamp)(value, formatOptions && formatOptions.treatAsLocalDate)
+                        : value
+            }
+        });
+};
+exports.formatType = formatType;

package/dist/query.d.ts

@@ -0,0 +1,5 @@
+import type { InternalConfig, QueryResult } from './types';
+export declare const query: (this: {
+    rollback?: (err: Error, status: any) => void;
+} | undefined, config: InternalConfig, ..._args: any[]) => Promise<QueryResult>;
+//# sourceMappingURL=query.d.ts.map

package/dist/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAe1D,eAAO,MAAM,KAAK,GAChB,MAAM;IAAE,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,KAAK,IAAI,CAAA;CAAE,GAAG,SAAS,EAClE,QAAQ,cAAc,EACtB,GAAG,OAAO,GAAG,EAAE,KACd,OAAO,CAAC,WAAW,CAoErB,CAAA"}

package/dist/query.js

@@ -0,0 +1,39 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.query = void 0;
+const client_rds_data_1 = require("@aws-sdk/client-rds-data");
+const utils_1 = require("./utils");
+const params_1 = require("./params");
+const results_1 = require("./results");
+const retry_1 = require("./retry");
+const query = async function (config, ..._args) {
+    const args = Array.isArray(_args[0]) ? (0, utils_1.flatten)(_args) : _args;
+    const sql = (0, utils_1.parseSQL)(args);
+    const sqlParams = (0, utils_1.getSqlParams)(sql);
+    const hydrateColumnNames = (0, params_1.parseHydrate)(config, args);
+    const formatOptions = (0, params_1.parseFormatOptions)(config, args);
+    const parameters = (0, params_1.normalizeParams)((0, params_1.parseParams)(args));
+    const { processedParams, escapedSql } = (0, params_1.processParams)(config.engine, sql, sqlParams, parameters, formatOptions);
+    const isBatch = processedParams.length > 0 && Array.isArray(processedParams[0]);
+    const params = Object.assign((0, params_1.prepareParams)(config, args), {
+        database: (0, params_1.parseDatabase)(config, args),
+        sql: escapedSql
+    }, processedParams.length > 0
+        ?
+            { [isBatch ? 'parameterSets' : 'parameters']: processedParams }
+        : {}, hydrateColumnNames && !isBatch ? { includeResultMetadata: true } : {}, config.transactionId ? { transactionId: config.transactionId } : {});
+    try {
+        const result = await (0, retry_1.withRetry)(() => isBatch
+            ? config.RDS.send(new client_rds_data_1.BatchExecuteStatementCommand(params))
+            : config.RDS.send(new client_rds_data_1.ExecuteStatementCommand(params)), config.retryOptions);
+        return (0, results_1.formatResults)(result, hydrateColumnNames, args[0].includeResultMetadata === true, formatOptions);
+    }
+    catch (e) {
+        if (this && this.rollback) {
+            const rollback = await config.RDS.send(new client_rds_data_1.RollbackTransactionCommand((0, utils_1.pick)(params, ['resourceArn', 'secretArn', 'transactionId'])));
+            this.rollback(e, rollback);
+        }
+        throw e;
+    }
+};
+exports.query = query;

package/dist/results.d.ts

@@ -0,0 +1,12 @@
+import type { ExecuteStatementCommandOutput, BatchExecuteStatementCommandOutput, Field } from '@aws-sdk/client-rds-data';
+import type { QueryResult, UpdateResult, FormatOptions } from './types';
+export declare const formatResults: (result: ExecuteStatementCommandOutput | BatchExecuteStatementCommandOutput, hydrate: boolean, includeMeta: boolean, formatOptions: Required<FormatOptions>) => QueryResult;
+export declare const formatRecords: (recs: Field[][] | undefined, columns: {
+    label?: string;
+    typeName?: string;
+}[] | undefined, hydrate: boolean, formatOptions: Required<FormatOptions>) => any[];
+export declare const formatRecordValue: (value: any, typeName: string | undefined, formatOptions: Required<FormatOptions>) => any;
+export declare const formatUpdateResults: (res: {
+    generatedFields?: Field[];
+}[]) => UpdateResult[];
+//# sourceMappingURL=results.d.ts.map

package/dist/results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"results.d.ts","sourceRoot":"","sources":["../src/results.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,6BAA6B,EAAE,kCAAkC,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAA;AACxH,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAIvE,eAAO,MAAM,aAAa,GACxB,QAAQ,6BAA6B,GAAG,kCAAkC,EAC1E,SAAS,OAAO,EAChB,aAAa,OAAO,EACpB,eAAe,QAAQ,CAAC,aAAa,CAAC,KACrC,WAuBF,CAAA;AAID,eAAO,MAAM,aAAa,GACxB,MAAM,KAAK,EAAE,EAAE,GAAG,SAAS,EAC3B,SAAS;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,GAAG,SAAS,EAC5D,SAAS,OAAO,EAChB,eAAe,QAAQ,CAAC,aAAa,CAAC,KACrC,GAAG,EAsDL,CAAA;AAsBD,eAAO,MAAM,iBAAiB,GAC5B,OAAO,GAAG,EACV,UAAU,MAAM,GAAG,SAAS,EAC5B,eAAe,QAAQ,CAAC,aAAa,CAAC,KACrC,GAmCF,CAAA;AAGD,eAAO,MAAM,mBAAmB,GAAI,KAAK;IAAE,eAAe,CAAC,EAAE,KAAK,EAAE,CAAA;CAAE,EAAE,KAAG,YAAY,EAGnF,CAAA"}

package/dist/results.js

@@ -0,0 +1,93 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatUpdateResults = exports.formatRecordValue = exports.formatRecords = exports.formatResults = void 0;
+const utils_1 = require("./utils");
+const formatResults = (result, hydrate, includeMeta, formatOptions) => {
+    const { columnMetadata, numberOfRecordsUpdated, records, generatedFields, updateResults } = result;
+    return Object.assign(includeMeta ? { columnMetadata } : {}, numberOfRecordsUpdated !== undefined && !records ? { numberOfRecordsUpdated } : {}, records
+        ? {
+            records: (0, exports.formatRecords)(records, columnMetadata, hydrate, formatOptions)
+        }
+        : {}, updateResults ? { updateResults: (0, exports.formatUpdateResults)(updateResults) } : {}, generatedFields && generatedFields.length > 0 ? { insertId: generatedFields[0].longValue } : {});
+};
+exports.formatResults = formatResults;
+const formatRecords = (recs, columns, hydrate, formatOptions) => {
+    const fmap = recs && recs[0]
+        ? recs[0].map((_field, i) => {
+            return Object.assign({}, columns ? { label: columns[i].label, typeName: columns[i].typeName } : {});
+        })
+        : [];
+    return recs
+        ? recs.map((rec) => {
+            return rec.reduce((acc, field, i) => {
+                if (field.isNull === true) {
+                    return hydrate
+                        ? Object.assign(acc, { [fmap[i].label]: null })
+                        : acc.concat(null);
+                }
+                else if (fmap[i] && fmap[i].field) {
+                    const value = (0, exports.formatRecordValue)(field[fmap[i].field], fmap[i].typeName, formatOptions);
+                    return hydrate
+                        ? Object.assign(acc, { [fmap[i].label]: value })
+                        : acc.concat(value);
+                }
+                else {
+                    Object.keys(field).map((type) => {
+                        if (type !== 'isNull' && field[type] !== null) {
+                            fmap[i]['field'] = type;
+                        }
+                    });
+                    const value = (0, exports.formatRecordValue)(field[fmap[i].field], fmap[i].typeName, formatOptions);
+                    return hydrate
+                        ? Object.assign(acc, { [fmap[i].label]: value })
+                        : acc.concat(value);
+                }
+            }, hydrate ? {} : []);
+        })
+        : [];
+};
+exports.formatRecords = formatRecords;
+const flattenArrayValue = (arrayValue) => {
+    if (!arrayValue)
+        return [];
+    if (arrayValue.stringValues)
+        return arrayValue.stringValues.slice();
+    if (arrayValue.longValues)
+        return arrayValue.longValues.slice();
+    if (arrayValue.doubleValues)
+        return arrayValue.doubleValues.slice();
+    if (arrayValue.booleanValues)
+        return arrayValue.booleanValues.slice();
+    if (arrayValue.arrayValues) {
+        return arrayValue.arrayValues.map((nested) => flattenArrayValue(nested.arrayValue || nested));
+    }
+    return [];
+};
+const formatRecordValue = (value, typeName, formatOptions) => {
+    if (value instanceof Uint8Array) {
+        return Buffer.from(value);
+    }
+    if (value && typeof value === 'object' && typeName && typeName.startsWith('_')) {
+        return flattenArrayValue(value);
+    }
+    if (formatOptions &&
+        formatOptions.deserializeDate &&
+        typeName &&
+        ['DATE', 'DATETIME', 'TIMESTAMP', 'TIMESTAMPTZ', 'TIMESTAMP WITH TIME ZONE'].includes(typeName.toUpperCase())) {
+        return (0, utils_1.formatFromTimeStamp)(value, (formatOptions && formatOptions.treatAsLocalDate) || typeName === 'TIMESTAMP WITH TIME ZONE');
+    }
+    else if (typeName === 'JSON') {
+        return JSON.parse(value);
+    }
+    else if (typeName === 'YEAR') {
+        return typeof value === 'string' ? parseInt(value, 10) : value;
+    }
+    else {
+        return value;
+    }
+};
+exports.formatRecordValue = formatRecordValue;
+const formatUpdateResults = (res) => res.map((x) => {
+    return x.generatedFields && x.generatedFields.length > 0 ? { insertId: x.generatedFields[0].longValue } : {};
+});
+exports.formatUpdateResults = formatUpdateResults;