@bitblit/ratchet-rdbms 4.0.115-alpha

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Notes]
+Alpha releases are exactly what they sound like - places where I am trying out new things that aren't ready for prime
+time, but I need published to see how they interact with the rest of my software ecosystem.  If you use an alpha
+package without knowing why it is alpha you'll get exactly what you deserve.
+
+## [Unreleased]
+
+## In Flight
+
+## [4.0.x] - 2018-03-23
+### Initial Release
+- Basic support for RDBMS stuff
+

package/License.txt

@@ -0,0 +1,13 @@
+Copyright 2022-2023 Christopher Weiss
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,41 @@
+# @bitblit/ratchet-rdbms
+
+Typescript library to simplify using relational database systems by externalizing the queries.
+
+## Introduction
+
+Meant to be very similar to the ibatis/mybatis library in Java, which has the right level of abstraction
+of the RDBMS in my opinion.
+
+You may wish to read [the changelog](CHANGELOG.md)
+
+## Installation
+
+`yarn install @bitblit/ratchet-rdbms`
+
+## Usage
+
+### Paginator
+(To understand the terminology here you may want to read [this](https://nordicapis.com/understanding-5-types-of-web-api-pagination/))
+
+This library natively supports:
+* Cursor pagination (use columnName, sort, min, limit)
+* Keyset API pagination (use columnName, sort, min, max, maybe limit)
+* Seek API pagination (use columnName, sort, min, max, maybe limit)
+* Time-based (use columnName on a time column, sort, min, max, maybe limit)
+
+This library doesn't support offset pagination (e.g., using limit/offset in MySql) out of the box.  It does this
+on purpose - in general for large datasets offset pagination is an anti-pattern, and I hope by not supporting
+it natively it'll make it a little less likely that I'll use it when I get in a rush.  Obviously its possible
+to still implement it using this architecture.  At some point in the future I may give in and do it.
+
+# Testing
+
+Ha! No, seriously - all testing is done using Jest.  To run them:
+
+`yarn test`
+
+# Contributing
+
+Pull requests are welcome, although I'm not sure why you'd be interested!
+

package/lib/build/ratchet-rdbms-info.d.ts

@@ -0,0 +1,5 @@
+import { BuildInformation } from '@bitblit/ratchet-common/lib/build/build-information.js';
+export declare class RatchetRdbmsInfo {
+    private constructor();
+    static buildInformation(): BuildInformation;
+}

package/lib/build/ratchet-rdbms-info.js

@@ -0,0 +1,14 @@
+export class RatchetRdbmsInfo {
+    constructor() { }
+    static buildInformation() {
+        const val = {
+            version: 'LOCAL-SNAPSHOT',
+            hash: 'LOCAL-HASH',
+            branch: 'LOCAL-BRANCH',
+            tag: 'LOCAL-TAG',
+            timeBuiltISO: 'LOCAL-TIME-ISO',
+            notes: 'LOCAL-NOTES',
+        };
+        return val;
+    }
+}

package/lib/model/connection-config.d.ts

@@ -0,0 +1,4 @@
+import { DbConfig } from './db-config.js';
+export interface ConnectionConfig {
+    dbList: DbConfig[];
+}

package/lib/model/connection-config.js

@@ -0,0 +1 @@
+export {};

package/lib/model/db-config.d.ts

@@ -0,0 +1,9 @@
+export interface DbConfig {
+    label: string;
+    tunnelPort?: number;
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+}

package/lib/model/db-config.js

@@ -0,0 +1 @@
+export {};

package/lib/model/group-by-count-result.d.ts

@@ -0,0 +1,4 @@
+export interface GroupByCountResult {
+    groupByField: string;
+    count: number;
+}

package/lib/model/group-by-count-result.js

@@ -0,0 +1 @@
+export {};

package/lib/model/mysql/mysql-master-status.d.ts

@@ -0,0 +1,6 @@
+export interface MysqlMasterStatus {
+    File: string;
+    Position: number;
+    Binlog_Do_DB: string;
+    Binlog_Ignore_DB: string;
+}

package/lib/model/mysql/mysql-master-status.js

@@ -0,0 +1 @@
+export {};

package/lib/model/mysql/mysql-results-wrapper.d.ts

@@ -0,0 +1,5 @@
+import { FieldPacket } from 'mysql2';
+export interface MysqlResultsWrapper<T> {
+    results: T;
+    fields: FieldPacket[];
+}

package/lib/model/mysql/mysql-results-wrapper.js

@@ -0,0 +1 @@
+export {};

package/lib/model/mysql/mysql-slave-status.d.ts

@@ -0,0 +1,52 @@
+export interface MysqlSlaveStatus {
+    Slave_IO_State: string;
+    Master_Host: string;
+    Master_User: string;
+    Master_Port: number;
+    Connect_Retry: number;
+    Master_Log_File: string;
+    Read_Master_Log_Pos: number;
+    Relay_Log_File: string;
+    Relay_Log_Pos: number;
+    Relay_Master_Log_File: string;
+    Slave_IO_Running: string;
+    Slave_SQL_Running: string;
+    Replicate_Do_DB: string;
+    Replicate_Ignore_DB: string;
+    Replicate_Do_Table: string;
+    Replicate_Ignore_Table: string;
+    Replicate_Wild_Do_Table: string;
+    Replicate_Wild_Ignore_Table: string;
+    Last_Errno: number;
+    Last_Error: string;
+    Skip_Counter: number;
+    Exec_Master_Log_Pos: number;
+    Relay_Log_Space: number;
+    Until_Condition: string;
+    Until_Log_File: string;
+    Until_Log_Pos: number;
+    Master_SSL_Allowed: string;
+    Master_SSL_CA_File: string;
+    Master_SSL_CA_Path: string;
+    Master_SSL_Cert: string;
+    Master_SSL_Cipher: string;
+    Master_SSL_Key: string;
+    Seconds_Behind_Master: number;
+    Master_SSL_Verify_Server_Cert: string;
+    Last_IO_Errno: number;
+    Last_IO_Error: string;
+    Last_SQL_Errno: number;
+    Last_SQL_Error: string;
+    Replicate_Ignore_Server_Ids: string;
+    Master_Server_Id: number;
+    Master_SSL_Crl: string;
+    Master_SSL_Crlpath: string;
+    Using_Gtid: string;
+    Gtid_IO_Pos: string;
+    Replicate_Do_Domain_Ids: string;
+    Replicate_Ignore_Domain_Ids: string;
+    Parallel_Mode: string;
+    SQL_Delay: number;
+    SQL_Remaining_Delay: string;
+    Slave_SQL_Running_State: string;
+}

package/lib/model/mysql/mysql-slave-status.js

@@ -0,0 +1 @@
+export {};

package/lib/model/mysql/mysql-style-connection-provider.d.ts

@@ -0,0 +1,7 @@
+import { Connection, ConnectionOptions } from 'mysql2/promise';
+import { QueryDefaults } from '../query-defaults.js';
+export interface MysqlStyleConnectionProvider {
+    getConnection(name?: string): Promise<Connection | undefined>;
+    clearConnectionCache(): Promise<boolean>;
+    createNonPooledDatabaseConnection?(queryDefaults: QueryDefaults, additionalConfig?: ConnectionOptions): Promise<Connection | undefined>;
+}

package/lib/model/mysql/mysql-style-connection-provider.js

@@ -0,0 +1 @@
+export {};

package/lib/model/mysql/mysql-update-results.d.ts

@@ -0,0 +1,9 @@
+export interface MysqlUpdateResults {
+    fieldCount: number;
+    affectedRows: number;
+    insertId: number;
+    info: string;
+    serverStatus: number;
+    warningStatus: number;
+    changedRows: number;
+}

package/lib/model/mysql/mysql-update-results.js

@@ -0,0 +1 @@
+export {};

package/lib/model/paginated-results.d.ts

@@ -0,0 +1,5 @@
+export interface PaginatedResults<T> {
+    results: T[];
+    nextPageToken: string;
+    prevPageToken: string;
+}

package/lib/model/paginated-results.js

@@ -0,0 +1 @@
+export {};

package/lib/model/pagination-bounds.d.ts

@@ -0,0 +1,6 @@
+export interface PaginationBounds<T> {
+    cn: string;
+    min: T;
+    max: T;
+    count: number;
+}

package/lib/model/pagination-bounds.js

@@ -0,0 +1 @@
+export {};

package/lib/model/paginator.d.ts

@@ -0,0 +1,9 @@
+import { SortDirection } from './sort-direction.js';
+import { JwtTokenBase } from '@bitblit/ratchet-common/lib/jwt/jwt-token-base.js';
+export interface Paginator<T> extends JwtTokenBase {
+    cn: string;
+    min?: T;
+    max?: T;
+    s?: SortDirection;
+    l?: number;
+}

package/lib/model/paginator.js

@@ -0,0 +1 @@
+export {};

package/lib/model/query-defaults.d.ts

@@ -0,0 +1,4 @@
+export interface QueryDefaults {
+    databaseName: string;
+    timeoutMS: number;
+}

package/lib/model/query-defaults.js

@@ -0,0 +1 @@
+export {};

package/lib/model/query-text-provider.d.ts

@@ -0,0 +1,4 @@
+export interface QueryTextProvider {
+    fetchQuery(queryDottedPath: string): string;
+    fetchAllQueries(): Record<string, string>;
+}

package/lib/model/query-text-provider.js

@@ -0,0 +1 @@
+export {};

package/lib/model/sort-direction.d.ts

@@ -0,0 +1,4 @@
+export declare enum SortDirection {
+    Asc = "Asc",
+    Desc = "Desc"
+}

package/lib/model/sort-direction.js

@@ -0,0 +1,5 @@
+export var SortDirection;
+(function (SortDirection) {
+    SortDirection["Asc"] = "Asc";
+    SortDirection["Desc"] = "Desc";
+})(SortDirection || (SortDirection = {}));

package/lib/model/ssh/ssh-tunnel-config.d.ts

@@ -0,0 +1,7 @@
+export interface SshTunnelConfig {
+    keepAlive: boolean;
+    username: string;
+    host: string;
+    port: number;
+    privateKey: string;
+}

package/lib/model/ssh/ssh-tunnel-config.js

@@ -0,0 +1 @@
+export {};

package/lib/model/ssh/ssh-tunnel-container.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { ListenOptions, Server } from 'net';
+import type { ConnectConfig, Connection } from 'ssh2';
+import * as TunnelSsh from 'tunnel-ssh';
+export interface SshTunnelContainer {
+    tunnelOptions: TunnelSsh.TunnelOptions;
+    serverOptions: ListenOptions;
+    sshOptions: ConnectConfig;
+    forwardOptions: TunnelSsh.ForwardOptions;
+    server: Server;
+    connection?: Connection;
+}

package/lib/model/ssh/ssh-tunnel-container.js

@@ -0,0 +1 @@
+export {};

package/lib/model/ssh-config.d.ts

@@ -0,0 +1,5 @@
+export interface SshConfig {
+    localPort: number;
+    dbHost: string;
+    dbPort: number;
+}

package/lib/model/ssh-config.js

@@ -0,0 +1 @@
+export {};

package/lib/model/transaction-isolation-level.d.ts

@@ -0,0 +1,4 @@
+export declare enum TransactionIsolationLevel {
+    Default = "Default",
+    ReadUncommitted = "READ UNCOMMITTED"
+}

package/lib/model/transaction-isolation-level.js

@@ -0,0 +1,5 @@
+export var TransactionIsolationLevel;
+(function (TransactionIsolationLevel) {
+    TransactionIsolationLevel["Default"] = "Default";
+    TransactionIsolationLevel["ReadUncommitted"] = "READ UNCOMMITTED";
+})(TransactionIsolationLevel || (TransactionIsolationLevel = {}));

package/lib/named-parameter-maria-db-service.d.ts

@@ -0,0 +1,41 @@
+import { Connection, ConnectionOptions } from 'mysql2/promise';
+import { MysqlResultsWrapper } from './model/mysql/mysql-results-wrapper.js';
+import { MysqlUpdateResults } from './model/mysql/mysql-update-results.js';
+import { TransactionIsolationLevel } from './model/transaction-isolation-level.js';
+import { NonPooledMysqlStyleConnectionProvider } from './non-pooled-mysql-style-connection-provider.js';
+import { MysqlStyleConnectionProvider } from './model/mysql/mysql-style-connection-provider.js';
+import { QueryBuilder } from './query-builder/query-builder.js';
+import { GroupByCountResult } from './model/group-by-count-result.js';
+import { QueryDefaults } from './model/query-defaults.js';
+import { QueryTextProvider } from './model/query-text-provider.js';
+export declare class NamedParameterMariaDbService {
+    private queryProvider;
+    private connectionProvider;
+    private queryDefaults;
+    private static LONG_QUERY_TIME_MS;
+    private serviceName;
+    constructor(queryProvider: QueryTextProvider, connectionProvider: MysqlStyleConnectionProvider, queryDefaults: QueryDefaults);
+    getQueryDefaults(): QueryDefaults;
+    getQueryProvider(): QueryTextProvider;
+    createNonPooledMysqlStyleConnectionProvider(queryDefaults: QueryDefaults, additionalConfig?: ConnectionOptions): Promise<NonPooledMysqlStyleConnectionProvider>;
+    fetchQueryRawTextByName(queryPath: string): string;
+    queryBuilder(queryPath?: string): QueryBuilder;
+    executeUpdateOrInsertByName(queryPath: string, params?: object, timeoutMS?: number): Promise<MysqlUpdateResults>;
+    buildAndExecuteUpdateOrInsert(queryBuilder: QueryBuilder, timeoutMS?: number): Promise<MysqlUpdateResults>;
+    buildAndExecuteUpdateOrInsertWithRetry(queryBuilder: QueryBuilder, maxRetries: number, timeoutMS?: number): Promise<MysqlUpdateResults>;
+    executeQueryByName<Row>(queryPath: string, params: object, timeoutMS?: number): Promise<Row[]>;
+    executeQueryByNameSingle<Row>(queryPath: string, params: object, timeoutMS?: number): Promise<Row | null>;
+    buildAndExecute<Row>(queryBuilder: QueryBuilder, timeoutMS?: number): Promise<Row[]>;
+    buildAndExecuteSingle<Row>(queryBuilder: QueryBuilder, timeoutMS?: number): Promise<Row | null>;
+    buildAndExecuteFetchTotalRows(queryBuilder: QueryBuilder, groupBy?: string, timeoutMS?: number): Promise<GroupByCountResult[]>;
+    executeQueryWithMeta<Row>(transactionIsolationLevel: TransactionIsolationLevel, query: string, fields?: object, timeoutMS?: number, debugComment?: string): Promise<MysqlResultsWrapper<Row>>;
+    shutdown(): Promise<boolean>;
+    testConnection(quietMode?: boolean): Promise<number | null>;
+    testDbFailure(): Promise<void>;
+    changeNextQueryTransactionIsolationLevel<Row>(tx: TransactionIsolationLevel | null): Promise<MysqlResultsWrapper<Row> | null>;
+    forceCloseConnectionForTesting(): Promise<boolean>;
+    private innerExecutePreparedAsPromiseWithRetryCloseConnection;
+    private innerExecutePreparedAsPromise;
+    getDB(): Promise<Connection>;
+    resetConnection(): Promise<boolean>;
+}

package/lib/named-parameter-maria-db-service.js

@@ -0,0 +1,251 @@
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { TimeoutToken } from '@bitblit/ratchet-common/lib/lang/timeout-token.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
+import { DurationRatchet } from '@bitblit/ratchet-common/lib/lang/duration-ratchet.js';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
+import { StopWatch } from '@bitblit/ratchet-common/lib/lang/stop-watch.js';
+import { QueryUtil } from './query-builder/query-util.js';
+import { TransactionIsolationLevel } from './model/transaction-isolation-level.js';
+import { NonPooledMysqlStyleConnectionProvider } from './non-pooled-mysql-style-connection-provider.js';
+import { QueryBuilder } from './query-builder/query-builder.js';
+export class NamedParameterMariaDbService {
+    queryProvider;
+    connectionProvider;
+    queryDefaults;
+    static LONG_QUERY_TIME_MS = 8500;
+    serviceName = 'TBD';
+    constructor(queryProvider, connectionProvider, queryDefaults) {
+        this.queryProvider = queryProvider;
+        this.connectionProvider = connectionProvider;
+        this.queryDefaults = queryDefaults;
+        this.serviceName = 'NamedParameterMariaDb';
+    }
+    getQueryDefaults() {
+        return this.queryDefaults;
+    }
+    getQueryProvider() {
+        return this.queryProvider;
+    }
+    async createNonPooledMysqlStyleConnectionProvider(queryDefaults, additionalConfig) {
+        Logger.info('createTransactional :  %s : %j', queryDefaults, additionalConfig);
+        if (!this.connectionProvider.createNonPooledDatabaseConnection) {
+            throw new Error(`Connection provider does not implement createNonPooledDatabaseConnection`);
+        }
+        const newConn = await this.connectionProvider.createNonPooledDatabaseConnection(queryDefaults, additionalConfig);
+        if (!newConn) {
+            throw new Error(`Connection could not be created for DB type ${queryDefaults}`);
+        }
+        return new NonPooledMysqlStyleConnectionProvider(newConn);
+    }
+    fetchQueryRawTextByName(queryPath) {
+        return this.queryProvider.fetchQuery(queryPath);
+    }
+    queryBuilder(queryPath) {
+        const queryBuilder = new QueryBuilder(this.queryProvider);
+        if (queryPath) {
+            queryBuilder.withNamedQuery(queryPath);
+        }
+        return queryBuilder;
+    }
+    async executeUpdateOrInsertByName(queryPath, params, timeoutMS = this.queryDefaults.timeoutMS) {
+        const builder = this.queryBuilder(queryPath).withParams(params ?? {});
+        return this.buildAndExecuteUpdateOrInsert(builder, timeoutMS);
+    }
+    async buildAndExecuteUpdateOrInsert(queryBuilder, timeoutMS = this.queryDefaults.timeoutMS) {
+        const build = queryBuilder.build();
+        const resp = await this.executeQueryWithMeta(build.transactionIsolationLevel, build.query, build.namedParams, timeoutMS);
+        const rval = resp.results;
+        return rval;
+    }
+    async buildAndExecuteUpdateOrInsertWithRetry(queryBuilder, maxRetries, timeoutMS = this.queryDefaults.timeoutMS) {
+        let retry = 0;
+        let res;
+        while (!res && retry < maxRetries) {
+            retry++;
+            try {
+                res = await this.buildAndExecuteUpdateOrInsert(queryBuilder, timeoutMS);
+            }
+            catch (err) {
+                Logger.info('Caught problem while trying to update/insert : %d : %s ', retry, err);
+                await PromiseRatchet.wait(retry * 2000);
+            }
+        }
+        if (!res) {
+            throw new Error(`Failed to execute update after ${maxRetries} retries`);
+        }
+        return res;
+    }
+    async executeQueryByName(queryPath, params, timeoutMS = this.queryDefaults.timeoutMS) {
+        const builder = this.queryBuilder(queryPath).withParams(params);
+        const resp = await this.buildAndExecute(builder, timeoutMS);
+        return resp;
+    }
+    async executeQueryByNameSingle(queryPath, params, timeoutMS = this.queryDefaults.timeoutMS) {
+        const builder = this.queryBuilder(queryPath).withParams(params);
+        const resp = await this.buildAndExecute(builder, timeoutMS);
+        return resp.length === 1 ? resp[0] : null;
+    }
+    async buildAndExecute(queryBuilder, timeoutMS = this.queryDefaults.timeoutMS) {
+        const build = queryBuilder.build();
+        const resp = await this.executeQueryWithMeta(build.transactionIsolationLevel, build.query, build.namedParams, timeoutMS, queryBuilder.getDebugComment());
+        return resp.results;
+    }
+    async buildAndExecuteSingle(queryBuilder, timeoutMS = this.queryDefaults.timeoutMS) {
+        const build = queryBuilder.build();
+        const resp = await this.executeQueryWithMeta(build.transactionIsolationLevel, build.query, build.namedParams, timeoutMS, queryBuilder.getDebugComment());
+        return resp.results.length === 1 ? resp.results[0] : null;
+    }
+    async buildAndExecuteFetchTotalRows(queryBuilder, groupBy = '', timeoutMS = this.queryDefaults.timeoutMS) {
+        const buildUnfiltered = queryBuilder.buildUnfiltered();
+        let query = buildUnfiltered.query.replace('COUNT(*)', `${groupBy} as groupByField, COUNT(*) as count`);
+        query = `${query} GROUP BY ${groupBy}`;
+        Logger.info('Unfiltered query %s', buildUnfiltered.query);
+        const resp = await this.executeQueryWithMeta(buildUnfiltered.transactionIsolationLevel, query, buildUnfiltered.namedParams, timeoutMS);
+        return resp.results;
+    }
+    async executeQueryWithMeta(transactionIsolationLevel, query, fields = {}, timeoutMS = this.queryDefaults.timeoutMS, debugComment) {
+        const sw = new StopWatch();
+        if (!timeoutMS) {
+            timeoutMS = this.queryDefaults.timeoutMS;
+        }
+        await this.changeNextQueryTransactionIsolationLevel(transactionIsolationLevel);
+        const result = await PromiseRatchet.timeout(this.innerExecutePreparedAsPromiseWithRetryCloseConnection(query, fields, undefined), 'Query:' + query, timeoutMS);
+        if (TimeoutToken.isTimeoutToken(result)) {
+            Logger.warn('Timed out (after %s): %j', DurationRatchet.colonFormatMsDuration(timeoutMS), result);
+            const duration = DurationRatchet.colonFormatMsDuration(timeoutMS);
+            throw new Error(`Timed out (after ${duration}) waiting for query : ${query}`);
+        }
+        const rval = result;
+        if (!rval.results) {
+            Logger.error('DB:executeQueryWithMeta:Failure: %j', rval);
+        }
+        if (debugComment && sw.elapsedMS() > NamedParameterMariaDbService.LONG_QUERY_TIME_MS) {
+            Logger.info('NamedParameterMariaDbService long query: %s, %s', debugComment, sw.dump());
+        }
+        return rval;
+    }
+    async shutdown() {
+        Logger.info('Shutting down %s service', this.serviceName);
+        let rval;
+        try {
+            rval = await this.connectionProvider.clearConnectionCache();
+        }
+        catch (err) {
+            Logger.error('Failure trying to shutdown : %s', err, err);
+            rval = false;
+        }
+        return rval;
+    }
+    async testConnection(quietMode = false) {
+        if (!quietMode) {
+            Logger.info('Running connection test');
+        }
+        const res = await this.executeQueryWithMeta(TransactionIsolationLevel.Default, 'SELECT UNIX_TIMESTAMP(now())*1000 AS test');
+        const rows = res.results;
+        const timestamp = rows.length === 1 ? rows[0].test : null;
+        if (!quietMode) {
+            Logger.info('Test returned : %j', timestamp);
+        }
+        return timestamp;
+    }
+    async testDbFailure() {
+        await this.executeQueryWithMeta(TransactionIsolationLevel.Default, 'this is a bad query');
+    }
+    async changeNextQueryTransactionIsolationLevel(tx) {
+        if (tx && tx !== TransactionIsolationLevel.Default) {
+            Logger.debug('Setting tx to %s', tx);
+            return await this.innerExecutePreparedAsPromiseWithRetryCloseConnection('SET TRANSACTION ISOLATION LEVEL ' + tx, {});
+        }
+        return null;
+    }
+    async forceCloseConnectionForTesting() {
+        Logger.warn('Forcing connection closed for testing');
+        const conn = await this.getDB();
+        try {
+            await conn.end();
+            Logger.info('Connection has been ended, but not set to null');
+            return true;
+        }
+        catch (err) {
+            Logger.error('Error closing connection : %s', err, err);
+            return false;
+        }
+    }
+    async innerExecutePreparedAsPromiseWithRetryCloseConnection(query, fields = {}, retryCount = 1) {
+        try {
+            const result = await this.innerExecutePreparedAsPromise(query, fields);
+            return result;
+        }
+        catch (errIn) {
+            const err = ErrorRatchet.asErr(errIn);
+            if (err.message.includes('closed state') ||
+                err.message.includes('This socket has been ended by the other party') ||
+                err.message.includes('ETIMEDOUT') ||
+                err.message.includes('NeonNoConnection') ||
+                err.message.includes('ER_LOCK_WAIT_TIMEOUT')) {
+                const wait = Math.min(1000 * retryCount);
+                Logger.warn('Found closed connection or lock timeout - clearing and attempting retry after %d (try %d of 3) (%s)', wait, retryCount, err.message);
+                if (retryCount < 4) {
+                    const cleared = await this.connectionProvider.clearConnectionCache();
+                    Logger.info('Clear connection cache returned %s', cleared);
+                    await PromiseRatchet.wait(wait);
+                    return this.innerExecutePreparedAsPromiseWithRetryCloseConnection(query, fields, retryCount + 1);
+                }
+                else {
+                    Logger.warn('Ran out of retries');
+                    throw new Error('Connection closed and cannot retry any more - dying horribly');
+                }
+            }
+            else {
+                Logger.error('Named Param DB Query Failed : Err: %s Query: %s Params: %j', err, query, fields, err);
+                try {
+                    const conn = await this.getDB();
+                    Logger.error('-----\nFor paste into tooling only: \n\n%s\n\n', QueryUtil.renderQueryStringForPasteIntoTool(query, fields, (v) => conn.escape(v)));
+                }
+                catch (err2) {
+                    Logger.error('Really bad - failed trying to get the conn for logging : %s', err2);
+                }
+                throw err;
+            }
+        }
+    }
+    async innerExecutePreparedAsPromise(query, fields = {}) {
+        const conn = await this.getDB();
+        conn.config.namedPlaceholders = true;
+        const sw = new StopWatch();
+        try {
+            const [rows, outFields] = await conn.query(query, fields);
+            const rval = {
+                results: rows,
+                fields: outFields,
+            };
+            Logger.debug('Success : Finished query : %s\n%s\n\nParams : %j', sw.dump(), QueryUtil.reformatQueryForLogging(query), fields);
+            Logger.debug('-----\nFor paste into tooling only : \n\n%s\n\n', QueryUtil.renderQueryStringForPasteIntoTool(query, fields, (v) => conn.escape(v)));
+            return rval;
+        }
+        finally {
+            conn.config.namedPlaceholders = false;
+        }
+    }
+    async getDB() {
+        const conn = await this.connectionProvider.getConnection(this.queryDefaults.databaseName);
+        if (!conn) {
+            throw new Error('NeonNoConnection : getConnection returned null - likely failed to get connection from db');
+        }
+        return conn;
+    }
+    async resetConnection() {
+        let rval = false;
+        Logger.info('Resetting connection');
+        try {
+            await this.connectionProvider.clearConnectionCache();
+            const tmpValue = await this.testConnection();
+            rval = !!tmpValue;
+            Logger.info('Reset connection returning %s', rval);
+        }
+        catch (err) {
+            Logger.error('Failed to reset connection : %s', err);
+        }
+        return rval;
+    }
+}