@bitblit/ratchet-rdbms 6.0.146-alpha → 6.0.147-alpha

package/src/query-builder/query-builder.ts

@@ -0,0 +1,445 @@
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+
+import { QueryBuilderResult } from './query-builder-result.js';
+import { TransactionIsolationLevel } from '../model/transaction-isolation-level.js';
+import { QueryTextProvider } from '../model/query-text-provider.js';
+import { Paginator } from '../model/paginator.js';
+import { SortDirection } from '../model/sort-direction.js';
+
+export class QueryBuilder {
+  public static readonly ALLOWED_SQL_CONSTRUCT: RegExp = /^[a-z0-9_.`]+$/i;
+  private readonly queryProvider: QueryTextProvider;
+
+  private query?: string;
+
+  // Meta data
+  public meta: { queryPath?: string } = Object.freeze({});
+
+  private sqlConstructs: Record<string, unknown> = {};
+  private namedParams: Record<string, unknown> = {};
+  private conditionals: Record<string, unknown> = {};
+
+  private debugComment = '';
+
+  private paginator?: Paginator<any>;
+
+  private debugAnnotateMode = false;
+  private transactionIsolationLevel: TransactionIsolationLevel = TransactionIsolationLevel.Default;
+
+  constructor(queryProvider: QueryTextProvider) {
+    this.queryProvider = queryProvider;
+  }
+
+  public clone(): QueryBuilder {
+    const clone: QueryBuilder = new QueryBuilder(this.queryProvider);
+    if (this.query) {
+      clone.withBaseQuery(this.query);
+    }
+    clone.sqlConstructs = structuredClone(this.sqlConstructs);
+    clone.namedParams = structuredClone(this.namedParams);
+    clone.conditionals = structuredClone(this.conditionals);
+    clone.paginator = structuredClone(this.paginator);
+    clone.debugComment = this.debugComment;
+    clone.transactionIsolationLevel = this.transactionIsolationLevel;
+    return clone;
+  }
+
+  public withTransactionIsolationLevel(level: TransactionIsolationLevel): QueryBuilder {
+    this.transactionIsolationLevel = level;
+    return this;
+  }
+
+  public withDebugComment(comment: string): QueryBuilder {
+    this.debugComment = comment;
+    return this;
+  }
+
+  public appendDebugComment(comment: string): QueryBuilder {
+    this.debugComment = this.debugComment + comment;
+    return this;
+  }
+
+  public withNamedQuery(queryPath: string): QueryBuilder {
+    this.query = this.queryProvider.fetchQuery(queryPath);
+    if (!StringRatchet.trimToNull(this.query)) {
+      ErrorRatchet.throwFormattedErr('Requested query that does not exist : %s', queryPath);
+    }
+    this.meta = Object.freeze({ queryPath: queryPath });
+    this.withDebugComment(' ' + queryPath + ' ');
+    return this;
+  }
+
+  public withBaseQuery(baseQuery: string): void {
+    this.query = baseQuery;
+  }
+
+  public withSqlConstruct(key: string, value: unknown): QueryBuilder {
+    this.sqlConstructs[key] = value;
+    return this;
+  }
+
+  public withSqlConstructs(params: Record<string, unknown>): QueryBuilder {
+    this.sqlConstructs = Object.assign(this.sqlConstructs, params);
+    return this;
+  }
+
+  public removeParam(key: string): QueryBuilder {
+    //eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+    delete this.namedParams[key];
+    return this;
+  }
+
+  public paramNames(): string[] {
+    return Object.keys(this.namedParams);
+  }
+
+  public withParam(key: string, value: unknown): QueryBuilder {
+    this.namedParams[key] = value;
+    return this;
+  }
+
+  public withParams(params: unknown): QueryBuilder {
+    this.namedParams = Object.assign(this.namedParams, params ?? {});
+    return this;
+  }
+
+  public withExpandedParam(keyPrefix: string, values: unknown[], extendIfExists: boolean): QueryBuilder {
+    const lengthParamName: string = keyPrefix + 'Length';
+    let oldSize: number = this.fetchCopyOfParam<number>(lengthParamName) ?? 0;
+    if (oldSize > 0 && !extendIfExists) {
+      Logger.silly('Old item found and not extending - removing old params');
+      const toRemove: string[] = this.paramNames().filter((s) => s.startsWith(keyPrefix));
+      toRemove.forEach((s) => this.removeParam(s));
+      oldSize = 0;
+    }
+
+    this.withParam(lengthParamName, values.length + oldSize);
+    for (let i = 0; i < values.length; i++) {
+      const value = values[i];
+
+      if (typeof value === 'object' && !!value) {
+        for (const key of Object.keys(value)) {
+          const paramKey = keyPrefix + key.charAt(0).toUpperCase() + key.slice(1) + (i + oldSize);
+          this.withParam(paramKey, value[key as keyof typeof value]);
+        }
+      } else {
+        const paramKey = keyPrefix + i;
+        this.withParam(paramKey, value);
+      }
+    }
+    return this;
+  }
+
+  public withConditional(tag: string, state = true): QueryBuilder {
+    this.conditionals[tag] = state;
+    return this;
+  }
+
+  public withConditionals(params: Record<string, boolean>): QueryBuilder {
+    this.conditionals = Object.assign(this.conditionals, params);
+    return this;
+  }
+
+  public withPaginator(paginator: Paginator<any>): QueryBuilder {
+    RequireRatchet.notNullOrUndefined(paginator, 'paginator');
+    RequireRatchet.notNullOrUndefined(paginator.cn, 'paginator.cn');
+    RequireRatchet.true(paginator.min || paginator.max || paginator.l, 'paginator must have some limit');
+    paginator.s = paginator.s ?? SortDirection.Asc; // Default to asc sort
+
+    this.paginator = paginator;
+    return this;
+  }
+
+  public fetchCopyOfParam<T>(paramName: string): T | undefined {
+    return this.namedParams[paramName] as T | undefined;
+  }
+
+  public fetchCopyOfConditional<T>(conditionalName: string): T | undefined {
+    return this.conditionals[conditionalName] as T | undefined;
+  }
+
+  public containsParam(paramName: string): boolean {
+    return this.namedParams[paramName] != undefined;
+  }
+
+  public getDebugComment(): string {
+    return this.debugComment;
+  }
+
+  public containsConditional(conditionalName: string): boolean {
+    return this.conditionals[conditionalName] != undefined;
+  }
+
+  public build(): QueryBuilderResult {
+    const build = this.clone();
+    return build.internalBuild(false);
+  }
+
+  public buildUnfiltered(): QueryBuilderResult {
+    const builder: QueryBuilder = this.clone();
+    return builder.internalBuild(true);
+  }
+
+  protected internalBuild(unfiltered: boolean): QueryBuilderResult {
+    this.applyQueryFragments();
+    this.applyConditionalBlocks();
+    this.applyRepeatBlocks();
+    this.applyPagination(unfiltered);
+    this.applySqlConstructs();
+    this.applyComments();
+    this.runQueryChecks();
+    this.stripNonAsciiParams();
+
+    return new QueryBuilderResult((this.query ?? '').trim(), this.namedParams, this.paginator, this.transactionIsolationLevel);
+  }
+
+  private stripNonAsciiParams(): void {
+    const reduced = StringRatchet.stripNonAscii(JSON.stringify(this.namedParams));
+    this.namedParams = JSON.parse(reduced) as Record<string, unknown>;
+  }
+
+  private runQueryChecks(): void {
+    const quotedNamedParams = [...(this.query?.matchAll(/['"]:[A-z-]*['"]/gm) ?? [])];
+    if (quotedNamedParams.length > 0) {
+      Logger.warn(
+        'The resulting query contains quoted named params check this this is intended. Instances found: %s',
+        quotedNamedParams.join(', '),
+      );
+    }
+  }
+
+  private applyComments(): void {
+    if (this.debugComment.length && this.query) {
+      const firstSpaceIndex = this.query.indexOf(' ');
+      //const requestId = ContextUtil.currentRequestId(); TODO: Reimplement?
+      const comment = this.debugComment; // + (requestId ? ` ${requestId}` : '');
+      this.query = this.query.substring(0, firstSpaceIndex + 1) + `/*${comment}*/` + this.query.substring(firstSpaceIndex + 1);
+    }
+  }
+
+  public applySqlConstructs(): void {
+    for (const key of Object.keys(this.sqlConstructs)) {
+      let value: string;
+      const val = this.sqlConstructs[key];
+      // If an array, check each individually, then join with comma
+      if (Array.isArray(val)) {
+        val.forEach((v: unknown) => {
+          if (typeof v !== 'string' || !v.match(QueryBuilder.ALLOWED_SQL_CONSTRUCT)) {
+            throw new Error(`sql construct entry ${v as string} is invalid value must be alphanumeric only.`);
+          }
+        });
+        value = val.join(', ');
+      } else {
+        value = StringRatchet.safeString(val);
+        if (value.length > 0 && !value.match(QueryBuilder.ALLOWED_SQL_CONSTRUCT)) {
+          throw new Error(`sql construct ${value} is invalid value must be alphanumeric only.`);
+        }
+      }
+
+      const sqlReservedWords: string[] = ['update', 'insert', 'delete', 'drop', 'select'];
+      for (const word of sqlReservedWords) {
+        if (value.toLowerCase().includes(word)) {
+          throw new Error(`sql construct ${value} is invalid value must not contain reserved word ${word}.`);
+        }
+      }
+
+      const rawKey = `##sqlConstruct:${key}##`;
+      while (this.query?.includes(rawKey)) {
+        this.query = this.query.replace(rawKey, value);
+      }
+    }
+  }
+
+  private applyRepeatBlocks(): void {
+    const startSymbol = '<repeat';
+    const endSymbol = '>';
+
+    while (true) {
+      const startIndex = this.query?.indexOf(startSymbol);
+      if (startIndex === -1 || !this.query || typeof startIndex !== 'number') {
+        return;
+      }
+
+      const endIndex = this.query.indexOf(endSymbol, startIndex);
+      if (endIndex == -1) {
+        throw new Error(
+          `Invalid query when finding end symbol matching ${endSymbol} in ${this.query} check that you have closed all your tags correctly.`,
+        );
+      }
+
+      const content = this.query.substring(startIndex + startSymbol.length, endIndex).trim();
+
+      const countSymbol = 'count=';
+      let countParam = '';
+
+      const joinSymbol = 'join=';
+      let joinString: string | undefined;
+
+      const params = content.split(' ');
+      for (const param of params) {
+        if (param.includes(countSymbol)) {
+          countParam = param.substring(param.indexOf(countSymbol) + countSymbol.length);
+        }
+
+        if (param.includes(joinSymbol)) {
+          joinString = param.substring(param.indexOf(joinSymbol) + joinSymbol.length);
+        }
+      }
+
+      const endTag = `</repeat>`;
+      const endTagIndex = this.query.indexOf(endTag);
+
+      const repeatedContent: string = this.query.substring(endIndex + endSymbol.length, endTagIndex);
+
+      this.query = this.query.substring(0, startIndex) + this.query.substring(endTagIndex + endTag.length);
+
+      const count = this.namedParams[countParam.substring(1)] as number;
+      for (let i = 0; i < count; i++) {
+        let indexedContent = repeatedContent;
+        if (joinString && i != 0) {
+          indexedContent += joinString;
+        }
+
+        let startParamTagIndex = indexedContent.indexOf(`::`);
+        while (startParamTagIndex != -1) {
+          const endParamTagIndex = indexedContent.indexOf(`::`, startParamTagIndex + 2);
+
+          if (endParamTagIndex == -1) {
+            throw new Error(
+              `Invalid query when finding end symbol matching :: check that you have closed all your tags correctly. Query: ${this.query} `,
+            );
+          }
+
+          const param = indexedContent.substring(startParamTagIndex + 2, endParamTagIndex);
+          indexedContent = indexedContent.replace('::' + param + '::', ':' + param + i);
+
+          startParamTagIndex = indexedContent.indexOf(`::`);
+        }
+
+        this.query = this.query.substring(0, startIndex) + indexedContent + this.query.substring(startIndex);
+      }
+    }
+  }
+
+  private applyQueryFragments(): void {
+    const startSymbol = '[[';
+    const endSymbol = ']]';
+
+    while (true) {
+      const startIndex = this.query?.indexOf(startSymbol);
+      if (startIndex == -1 || !this.query || typeof startIndex !== 'number') {
+        return;
+      }
+
+      const endIndex = this.query.indexOf(endSymbol, startIndex);
+      if (endIndex == -1) {
+        throw new Error(
+          `Invalid query when finding end symbol matching ${endSymbol} in ${this.query} check that you have closed all your tags correctly.`,
+        );
+      }
+
+      const rawName = this.query.substring(startIndex + startSymbol.length, endIndex);
+      const namedQueryElement = this.queryProvider.fetchQuery(rawName);
+      if (!namedQueryElement) {
+        throw new Error(`Invalid query, query fragment ${rawName} not found in named queries.`);
+      }
+      this.query = this.query.replace(`[[${rawName}]]`, namedQueryElement);
+    }
+  }
+
+  private applyPagination(unfiltered: boolean): void {
+    const paginationRawKey = '##pagination##';
+
+    if (!unfiltered && this.paginator) {
+      const sortDirEnum: SortDirection = this.paginator.s == SortDirection.Desc ? SortDirection.Desc : SortDirection.Asc;
+      const sortDir: string = StringRatchet.safeString(sortDirEnum);
+
+      if (this.paginator.min || this.paginator.max) {
+        let wc: string = 'WHERE ##sqlConstruct:queryBuilderPaginatorWhere##';
+        this.withSqlConstruct('queryBuilderPaginatorWhere', this.paginator.cn);
+        if (this.paginator.min) {
+          wc += '>= :queryBuilderPaginatorWhereMin';
+          this.withParam('queryBuilderPaginatorWhereMin', this.paginator.min);
+        }
+        if (this.paginator.max) {
+          if (this.paginator.min) {
+            wc += ' AND ##sqlConstruct:queryBuilderPaginatorWhere##';
+          }
+          wc += '< :queryBuilderPaginatorWhereMax';
+          this.withParam('queryBuilderPaginatorWhereMax', this.paginator.max);
+        }
+        this.query += wc;
+      }
+
+      this.query += ` ORDER BY ##sqlConstruct:queryBuilderOrderBy## ${sortDir}`;
+      this.withSqlConstruct('queryBuilderOrderBy', this.paginator.cn);
+
+      if (this.paginator.l) {
+        this.query += ' LIMIT :queryBuilderLimit';
+        this.withParam('queryBuilderLimit', this.paginator.l);
+      }
+    }
+
+    if (unfiltered && this.query) {
+      const paginationSplitIndex = this.query.indexOf(paginationRawKey);
+      if (paginationSplitIndex != -1) {
+        this.query = 'SELECT COUNT(*) ' + this.query.substring(paginationSplitIndex + paginationRawKey.length);
+      }
+    }
+
+    while (this.query?.includes(paginationRawKey)) {
+      this.query = this.query.replace(paginationRawKey, '');
+    }
+  }
+
+  private applyConditionalBlocks(): void {
+    const startSymbol = '<<';
+    const endSymbol = '>>';
+
+    while (true) {
+      const startIndex = this.query?.indexOf(startSymbol);
+      if (startIndex == -1 || !this.query || typeof startIndex !== 'number') {
+        return;
+      }
+
+      const endIndex = this.query.indexOf(endSymbol, startIndex);
+      if (endIndex == -1) {
+        throw new Error(
+          `Invalid query when finding end symbol matching ${endSymbol} in ${this.query} check that you have closed all your tags correctly.`,
+        );
+      }
+
+      const rawTag = this.query.substring(startIndex + startSymbol.length, endIndex);
+      const tag = rawTag.replace(':', '');
+      const endTag = `<</${rawTag}>>`;
+      const endTagIndex = this.query.indexOf(endTag);
+      if (endTagIndex == -1) {
+        throw new Error(
+          `Invalid query when finding conditional end tag matching ${endTag} in ${this.query} check that your query contains an exact match of this tag.`,
+        );
+      }
+
+      let replacement = this.query.substring(endIndex + endSymbol.length, endTagIndex);
+      if (rawTag.startsWith(':')) {
+        const param = this.namedParams[tag];
+        if (param == null || (Array.isArray(param) && param.length == 0)) {
+          replacement = '';
+        }
+      } else {
+        const conditional = this.conditionals[tag.replace('!', '')];
+        if (conditional == undefined || conditional == tag.startsWith('!')) {
+          replacement = '';
+        }
+      }
+
+      if (this.debugAnnotateMode) {
+        replacement = '/* conditional ' + tag + '*/';
+      }
+
+      this.query = this.query.substring(0, startIndex) + replacement + this.query.substring(endTagIndex + endTag.length);
+    }
+  }
+}

package/src/query-builder/query-util.spec.ts

@@ -0,0 +1,20 @@
+import { describe, expect, test } from 'vitest';
+import { QueryUtil } from './query-util.js';
+
+describe('query-util', () => {
+  test('extract used params', () => {
+    const test: string =
+      'REPLACE /* TicketDao.saveDeliveryInformation */INTO delivery_information (delivery_information_guid, contact_phone, street_1, street_2, city, state, zip) VALUES (:deliveryInformationGuid, :contactPhone, :street1, :street2, :city, :state, :zip)';
+
+    const used: string[] = QueryUtil.extractUsedNamedParams(test);
+
+    expect(used.length).toBe(7);
+    expect(used.includes(':deliveryInformationGuid')).toBeTruthy;
+    expect(used.includes(':contactPhone')).toBeTruthy;
+    expect(used.includes(':street1')).toBeTruthy;
+    expect(used.includes(':street2')).toBeTruthy;
+    expect(used.includes(':city')).toBeTruthy;
+    expect(used.includes(':state')).toBeTruthy;
+    expect(used.includes(':zip')).toBeTruthy;
+  });
+});

package/src/query-builder/query-util.ts

@@ -0,0 +1,162 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+
+export class QueryUtil {
+  private fields: string[] = [];
+  private replacements: Record<string, unknown> = {};
+
+  public addReplacement(replacement: Record<string, unknown>, ...fields: string[]): void {
+    this.replacements = Object.assign(this.replacements, replacement);
+    this.addFields(...fields);
+  }
+
+  public appendReplacement(replacementKey: string, appendValue: string, ...fields: string[]): void {
+    this.replacements[replacementKey] = this.replacements[replacementKey] + appendValue;
+    this.addFields(...fields);
+  }
+
+  public addFields(...fields: string[]): void {
+    this.fields = this.fields.concat(...fields);
+  }
+
+  public getFields(): string[] {
+    return this.fields;
+  }
+
+  public getReplacements(): Record<string, unknown> {
+    return this.replacements;
+  }
+
+  public static sqlInjectionUnsafeParamRenderer(value: unknown): string {
+    const rFn = (val: unknown): string => (typeof val === 'string' ? '"' + val + '"' : StringRatchet.safeString(val));
+    const repl: string = Array.isArray(value) ? value.map((s: unknown) => rFn(s)).join(',') : rFn(value);
+    return repl;
+  }
+
+  public static renderQueryStringForPasteIntoTool(
+    query: string,
+    inFields: object | null,
+    transform: (x: unknown) => string = QueryUtil.sqlInjectionUnsafeParamRenderer,
+  ): string | null {
+    const fields = inFields ?? {};
+    // This is not safe from sql injection at all so it really should only be used for
+    let rval = QueryUtil.reformatQueryForLogging(query);
+    if (rval) {
+      const keys = Object.keys(fields);
+      // Sort longest first so that it replaces correctly
+      keys.sort((b, a) => a.length - b.length);
+
+      for (const key of keys) {
+        const val: unknown = fields[key as keyof typeof fields];
+        const find: string = ':' + key;
+        const repl: string = transform(val);
+        rval = rval.split(find).join(repl);
+      }
+      if (!rval.endsWith(';')) {
+        rval += ';';
+      }
+    }
+    return rval;
+  }
+
+  public static reformatQueryForLogging(qry: string, inMaxLineLength = 80): string | null {
+    let maxLineLength: number = inMaxLineLength;
+    if (!StringRatchet.trimToNull(qry)) {
+      return null;
+    }
+    let loggableQuery = '';
+    // First, remove any built in CR/LF returns
+    let cleaned: string = StringRatchet.trimToEmpty(qry).split('\n').join(' ').split('\r').join(' ');
+    while (cleaned.length > maxLineLength) {
+      let idx: number = Math.min(cleaned.length, maxLineLength);
+      // Scan back until we hit a space or a comma
+      while (idx > 0 && ![' ', ','].includes(cleaned.charAt(idx))) {
+        idx--;
+      }
+      if (idx > 0) {
+        loggableQuery += cleaned.substring(0, idx) + '\n';
+        cleaned = StringRatchet.trimToEmpty(cleaned.substring(idx));
+      } else {
+        Logger.silly('Input contains a string longer than the max line length - bumping');
+        maxLineLength += 2;
+      }
+    }
+    return loggableQuery + (cleaned.length > 0 ? cleaned : '');
+  }
+
+  // Used by dbs like sqlite3 that want the prefix in the supplied record
+  public static addPrefixToFieldNames(fields: Record<string, any>, prefix: string = ':'): Record<string, any> {
+    const rval: Record<string, any> = {};
+    Object.keys(fields).forEach((k) => {
+      rval[prefix + k] = fields[k];
+    });
+    return rval;
+  }
+
+  // If any supplied fields are null/undefined, replaces their variable in the source query
+  // Needed by dbs like sqlite3 that dont handle null injection well
+  public static replaceNullReplacementsInQuery(query: string, fields: Record<string, any>): string {
+    const rval: string = query;
+    Object.keys(fields).forEach((k) => {
+      if (fields[k] === null || fields[k] === undefined) {
+        rval.replaceAll(k, 'null');
+      }
+    });
+    return rval;
+  }
+
+  // Return a record that only contains fields that are actually used in the query
+  public static removeUnusedFields(query: string, fields: Record<string, any>, prefix?: string): Record<string, any> {
+    const usedFields: string[] = QueryUtil.extractUsedNamedParams(query);
+    const rval: Record<string, any> = {};
+    Object.keys(fields).forEach((k) => {
+      if (usedFields.includes(k) || (prefix && usedFields.includes(prefix + k))) {
+        rval[k] = fields[k];
+      }
+    });
+    return rval;
+  }
+
+  public static extractUsedNamedParams(query: string): string[] {
+    // TODO: Cmon, this really should be a regex...
+    //const usedParams: string[] = [...query.matchAll(/:[a-z0-9]+/i)].map((s) => StringRatchet.safeString(s));
+    let state: number = 0;
+    let idx: number = 0;
+    const frags: string[] = []; // debug only
+    const usedParams: string[] = [];
+    let curString: string = '';
+    while (idx < query.length) {
+      const nextChar: string = query.charAt(idx++);
+      if (state === 0) {
+        // Not in a var
+        if (nextChar === ':') {
+          frags.push(curString);
+          curString = ':';
+          state = 1;
+        } else {
+          curString += nextChar;
+        }
+      } else if (state === 1) {
+        // In a var
+        if (!StringRatchet.stringContainsOnlyAlphanumeric(nextChar)) {
+          usedParams.push(curString);
+          curString = nextChar;
+          state = 0;
+        } else {
+          curString += nextChar;
+        }
+      } else {
+        throw ErrorRatchet.fErr('Cant happen - invalid state');
+      }
+    }
+    // Whatever was left
+    if (state === 0) {
+      frags.push(curString);
+    } else {
+      usedParams.push(curString);
+    }
+
+    return usedParams;
+  }
+}

package/src/rds-data-api/model/rds-data-api-connection-config.ts

@@ -0,0 +1,8 @@
+export interface RdsDataApiConnectionConfig {
+  label: string;
+  resourceArn: string;
+  secretArn: string;
+  database: string;
+  maximumWaitForDbResumeInMillis?: number;
+  dbResumePingTimeMillis?: number;
+}

package/src/rds-data-api/rds-data-api-connection-provider.ts

@@ -0,0 +1,39 @@
+import { DatabaseAccessProvider } from "../model/database-access-provider.js";
+import { DatabaseAccess } from "../model/database-access.js";
+import { QueryDefaults } from "../model/query-defaults.ts";
+import { RDSDataClient } from "@aws-sdk/client-rds-data";
+import { RdsDataApiConnectionConfig } from "./model/rds-data-api-connection-config.ts";
+import { RdsDataApiDatabaseAccess } from "./rds-data-api-database-access.ts";
+import { DatabaseConfigList } from "../model/database-config-list.ts";
+import { ErrorRatchet } from "@bitblit/ratchet-common/lang/error-ratchet";
+
+/**
+ */
+export class RdsDataApiConnectionProvider implements DatabaseAccessProvider {
+
+  constructor(
+    private client: RDSDataClient,
+    private configPromiseProvider: () => Promise<DatabaseConfigList<RdsDataApiConnectionConfig>>,
+  ) {}
+
+  public async getDatabaseAccess(name?: string): Promise<DatabaseAccess | undefined> {
+    const configs: DatabaseConfigList<RdsDataApiConnectionConfig> = await this.configPromiseProvider();
+    let cfg: RdsDataApiConnectionConfig = null;
+    if (name) {
+      cfg = configs.dbList.find(s=>s.label===name);
+    } else if (configs.dbList.length===1) {
+      cfg = configs.dbList[0];
+    } else {
+      throw ErrorRatchet.fErr('Database Access not found for name, or no entries found');
+    }
+    return new RdsDataApiDatabaseAccess(this.client, cfg);
+  }
+
+  public async clearDatabaseAccessCache(): Promise<boolean> {
+    return true; // We don't really cache these
+  }
+
+  public async createNonPooledDatabaseAccess(queryDefaults: QueryDefaults): Promise<DatabaseAccess | undefined> {
+    return this.getDatabaseAccess(queryDefaults.databaseName);
+  }
+}