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

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@bitblit/ratchet-rdbms",
-  "version": "6.0.146-alpha",
+  "version": "6.0.148-alpha",
   "description": "Ratchet tooling for working with relational databases",
   "sideEffects": false,
   "type": "module",
   "files": [
+    "src/**",
     "lib/**",
     "bin/**"
   ],
@@ -47,7 +48,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@bitblit/ratchet-common": "6.0.146-alpha"
+    "@bitblit/ratchet-common": "6.0.148-alpha"
   },
   "optionalDependencies": {
     "@aws-sdk/client-rds-data": "3.922.0",
@@ -60,7 +61,7 @@
   },
   "peerDependencies": {
     "@aws-sdk/client-rds-data": "^3.922.0",
-    "@bitblit/ratchet-common": "6.0.146-alpha",
+    "@bitblit/ratchet-common": "6.0.148-alpha",
     "better-sqlite3": "^12.4.1",
     "get-port": "^7.1.0",
     "mysql2": "^3.15.3",

package/src/build/ratchet-rdbms-info.ts

@@ -0,0 +1,19 @@
+import { BuildInformation } from '@bitblit/ratchet-common/build/build-information';
+
+export class RatchetRdbmsInfo {
+  // Empty constructor prevents instantiation
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {}
+
+  public static buildInformation(): BuildInformation {
+    const val: BuildInformation = {
+      version: 'LOCAL-SNAPSHOT',
+      hash: 'LOCAL-HASH',
+      branch: 'LOCAL-BRANCH',
+      tag: 'LOCAL-TAG',
+      timeBuiltISO: 'LOCAL-TIME-ISO',
+      notes: 'LOCAL-NOTES',
+    };
+    return val;
+  }
+}

package/src/model/connection-and-tunnel.ts

@@ -0,0 +1,7 @@
+import { SshTunnelContainer } from './ssh/ssh-tunnel-container.js';
+
+export interface ConnectionAndTunnel<T, R> {
+  config: R;
+  db: T;
+  ssh: SshTunnelContainer;
+}

package/src/model/database-access-provider.ts

@@ -0,0 +1,11 @@
+import { DatabaseAccess } from './database-access.js';
+import { QueryDefaults } from './query-defaults.js';
+
+export interface DatabaseAccessProvider {
+  /**
+   * @param name if omitted, returns the default connection
+   */
+  getDatabaseAccess(name?: string): Promise<DatabaseAccess | undefined>;
+  clearDatabaseAccessCache(): Promise<boolean>;
+  createNonPooledDatabaseAccess?(queryDefaults: QueryDefaults, additionalConfig?: Record<string, any>): Promise<DatabaseAccess | undefined>;
+}

package/src/model/database-access.ts

@@ -0,0 +1,30 @@
+// Represents the object used to actually talk to the database, such
+// as a Connection object in mysql/maria, an HTTP wrapper for an HTTP db,
+// or a AsyncDatabase object in sqlite.  Usually it'll be a wrapper around
+// the actual object to act as an adapter
+import { RequestResults } from './request-results.js';
+import { ModifyResults } from './modify-results.js';
+import { DatabaseRequestType } from './database-request-type.js';
+
+// T = Class of the connection
+// R = Class of any extra connection configuration props
+// S = Class of the object returned by a query (data)
+export interface DatabaseAccess {
+  // Force the connection closed
+  close(): Promise<boolean>;
+  escape(value: any): string;
+
+  testConnection(logTestResults?: boolean): Promise<number>; // Should be a fast test like 'select 1'
+
+  preQuery?(): Promise<void>;
+  query<S>(query: string, fields: Record<string, any>): Promise<RequestResults<S>>;
+  modify(query: string, fields: Record<string, any>): Promise<RequestResults<ModifyResults>>;
+  // TODO: Handle DDL specially?
+  onRequestSuccessOnly?(type: DatabaseRequestType): Promise<void>;
+  onRequestFailureOnly?(type: DatabaseRequestType): Promise<void>;
+  onRequestSuccessOrFailure?(type: DatabaseRequestType): Promise<void>;
+
+  beginTransaction?(): Promise<void>;
+  commitTransaction?(): Promise<void>;
+  rollbackTransaction?(): Promise<void>;
+}

package/src/model/database-config-list.ts

@@ -0,0 +1,3 @@
+export interface DatabaseConfigList<T> {
+  dbList: T[];
+}

package/src/model/database-request-type.ts

@@ -0,0 +1,6 @@
+export enum DatabaseRequestType {
+  Query = 'Query', // eg Select
+  Modify = 'Modify', // eg Insert/Update/Delete
+  Definition = 'Definition', // eg, DDL
+  Meta = 'Meta', // eg - set transation isolation level
+}

package/src/model/group-by-count-result.ts

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

package/src/model/modify-results.ts

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

package/src/model/named-parameter-database-service-config.ts

@@ -0,0 +1,13 @@
+import { QueryTextProvider } from './query-text-provider.js';
+import { DatabaseAccessProvider } from './database-access-provider.js';
+import { QueryDefaults } from './query-defaults.js';
+import { LoggerInstance } from '@bitblit/ratchet-common/logger/logger-instance';
+
+export interface NamedParameterDatabaseServiceConfig {
+  serviceName: string;
+  queryProvider: QueryTextProvider;
+  connectionProvider: DatabaseAccessProvider;
+  queryDefaults: QueryDefaults;
+  longQueryTimeMs: number;
+  logger?: LoggerInstance;
+}

package/src/model/paginated-results.ts

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

package/src/model/pagination-bounds.ts

@@ -0,0 +1,12 @@
+/**
+ * Defines the bounds of a paginator.
+ *
+ * Returns the min and max values for the column specified and the total count - can
+ * be used to roughly predict page values
+ */
+export interface PaginationBounds<T> {
+  cn: string;
+  min: T;
+  max: T;
+  count: number;
+}

package/src/model/paginator.ts

@@ -0,0 +1,20 @@
+import { SortDirection } from './sort-direction.js';
+import { JwtTokenBase } from '@bitblit/ratchet-common/jwt/jwt-token-base';
+
+/**
+ * Defines a paginator.
+ *
+ * Field names are short in here because this gets serialized when passed back and forth.  They are:
+ * cn: ColumnName (required)
+ * min: min value for that column (optional)
+ * max: max value for that column (optional)
+ * s: sort direction for the column (optional, defaults to Asc)
+ * l: limit (optional)
+ */
+export interface Paginator<T> extends JwtTokenBase {
+  cn: string;
+  min?: T;
+  max?: T;
+  s?: SortDirection;
+  l?: number;
+}

package/src/model/query-defaults.ts

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

package/src/model/query-text-provider.ts

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

package/src/model/request-results.ts

@@ -0,0 +1,4 @@
+export interface RequestResults<R> {
+  results: R;
+  fields?: Record<string, any>[];
+}

package/src/model/simple-query-text-provider.ts

@@ -0,0 +1,18 @@
+import { QueryTextProvider } from './query-text-provider.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+
+export class SimpleQueryTextProvider implements QueryTextProvider {
+  constructor(private values: Record<string, string>) {}
+
+  public fetchQuery(queryDottedPath: string): string {
+    let rval: string = null;
+    if (StringRatchet.trimToNull(queryDottedPath)) {
+      rval = (this.values ?? {})[queryDottedPath];
+    }
+    return rval;
+  }
+
+  public fetchAllQueries(): Record<string, string> {
+    return Object.assign({}, this.values ?? {});
+  }
+}

package/src/model/sort-direction.ts

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

package/src/model/ssh/ssh-tunnel-config.ts

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

package/src/model/ssh/ssh-tunnel-container.ts

@@ -0,0 +1,13 @@
+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;
+  localPort: number;
+  connection?: Connection;
+}

package/src/model/transaction-isolation-level.ts

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

package/src/mysql/model/mysql-db-config.ts

@@ -0,0 +1,14 @@
+import { SshTunnelConfig } from '../../model/ssh/ssh-tunnel-config.js';
+
+export interface MysqlDbConfig {
+  label: string;
+  host: string;
+  port: number;
+  user: string;
+  password: string;
+  database: string;
+  sshTunnelConfig?: SshTunnelConfig;
+
+  ssl?: string | Record<string, any>;
+  decimalNumbers?: boolean;
+}

package/src/mysql/model/mysql-master-status.ts

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

package/src/mysql/model/mysql-slave-status.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/src/mysql/mysql-style-database-access.ts

@@ -0,0 +1,85 @@
+import { Connection, ConnectionOptions, FieldPacket, RowDataPacket } from 'mysql2/promise';
+import { DatabaseAccess } from '../model/database-access.js';
+import { RequestResults } from '../model/request-results.js';
+import { ModifyResults } from '../model/modify-results.js';
+import { DatabaseRequestType } from '../model/database-request-type.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+
+export class MysqlStyleDatabaseAccess implements DatabaseAccess {
+  constructor(
+    private _connection: Connection,
+    private _connectionOptions: ConnectionOptions,
+  ) {}
+
+  public async testConnection(logTestResults?: boolean): Promise<number | null> {
+    if (logTestResults) {
+      Logger.info('Running connection test');
+    }
+
+    const res: RequestResults<any> = await this.query('SELECT UNIX_TIMESTAMP(now())*1000 AS test', {});
+    const rows = res.results as { test: number }[];
+    const timestamp = rows.length === 1 ? rows[0].test : null;
+    if (logTestResults) {
+      Logger.info('Test returned : %j', timestamp);
+    }
+    return timestamp;
+  }
+
+  public getRawDatabase(): Connection {
+    return this._connection;
+  }
+
+  public getRawDatabaseConfig(): ConnectionOptions {
+    return this._connectionOptions;
+  }
+
+  public testConnectionQueryString(): string {
+    return 'SELECT UNIX_TIMESTAMP(now())*1000 AS test';
+  }
+
+  public async close(): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
+  public escape(query: any): string {
+    return this._connection.escape(query);
+  }
+
+  public async preQuery(): Promise<void> {
+    this._connection.config.namedPlaceholders = true;
+  }
+
+  public async query<R>(query, fields): Promise<RequestResults<R>> {
+    const [rows, outFields] = await this._connection.query(query, fields);
+
+    const castRows: RowDataPacket[] = rows as RowDataPacket[];
+    const castFields: FieldPacket[] = outFields;
+
+    const rval: RequestResults<R> = {
+      results: castRows as R,
+      fields: castFields,
+    };
+
+    return rval;
+  }
+
+  public async modify(query: string, fields: Record<string, any>): Promise<RequestResults<ModifyResults>> {
+    const tmp: RequestResults<ModifyResults> = await this.query(query, fields);
+    return tmp;
+  }
+
+  public async onRequestSuccessOrFailure(_type: DatabaseRequestType): Promise<void> {
+    this._connection.config.namedPlaceholders = false;
+  }
+
+  /*
+  public async onQueryFailureOnly(): Promise<void> {
+    return Promise.resolve(undefined);
+  }
+
+  public async onQuerySuccessOnly(): Promise<void> {
+    return Promise.resolve(undefined);
+  }
+
+   */
+}