@lossless.org/nosqldb 10.10.0 → 11.0.0

package/ts/ts_nosqldb/rust-db-bridge.ts

@@ -6,6 +6,7 @@ import { normalizeNoSqlDbFileStorageOptions } from './file-storage-options.js';
 import type { TNoSqlDbFileStorageStartup } from './file-storage-startup.js';
 import * as path from 'node:path';
 import * as url from 'node:url';
+import type { ChildProcess } from 'node:child_process';
 import { EventEmitter } from 'node:events';
 import {
   normalizeNoSqlDbStorageRehearsalInput,
@@ -163,6 +164,92 @@ export interface IDocumentsResult {
   total: number;
 }
 
+/**
+ * Bounds of the engine standard-error tail that start failures, unexpected
+ * engine exits and failed management calls carry: the engine's last 64 lines.
+ * A longer line keeps its first 1,024 characters, followed by
+ * ` [<n> more characters]`.
+ */
+export const noSqlDbEngineStderrTailLimits = Object.freeze({ lines: 64, lineCharacters: 1024 });
+
+/**
+ * Attach the engine's last standard-error lines to an error as its own field
+ * `engineStderrTail`, leaving its message and cause unchanged. Values that
+ * cannot carry a field (primitives, frozen objects) are left as they are.
+ */
+export function attachNoSqlDbEngineStderrTail(errorArg: unknown, tailArg: readonly string[]): void {
+  if (errorArg === null || (typeof errorArg !== 'object' && typeof errorArg !== 'function')) return;
+  if (!Object.isExtensible(errorArg) && !Object.prototype.hasOwnProperty.call(errorArg, 'engineStderrTail')) return;
+  try {
+    Object.defineProperty(errorArg, 'engineStderrTail', {
+      value: Object.freeze([...tailArg]),
+      enumerable: true,
+      configurable: true,
+      writable: false,
+    });
+  } catch {
+    // A non-configurable field of the same name stays as the caller made it.
+  }
+}
+
+/**
+ * The engine process exited with a non-zero status or by a signal while its
+ * server was running and no stop was in progress. `engineStderrTail` holds
+ * its last standard-error lines.
+ */
+export class NoSqlDbEngineExitError extends Error {
+  public readonly engineStderrTail: readonly string[];
+
+  constructor(
+    public readonly exitCode: number | null,
+    public readonly signal: string | null,
+    engineStderrTailArg: readonly string[],
+  ) {
+    super(`nosqldb Rust process exited unexpectedly (code=${exitCode}, signal=${signal})`);
+    this.name = 'NoSqlDbEngineExitError';
+    this.engineStderrTail = Object.freeze([...engineStderrTailArg]);
+  }
+}
+
+/**
+ * A start that the engine refused because the storage root, or a feature it
+ * carries, comes from a later NoSQLDB release than this one: the engine's
+ * management reply carried the code `UNKNOWN_ROOT`. The engine wrote nothing
+ * into the root (storage-root-names-and-start.md, "Roots of later releases";
+ * requirements A300 and A319). `code` holds the code, and `cause` the
+ * management error that carried it.
+ */
+export class NoSqlDbUnknownRootError extends Error {
+  public readonly code = 'UNKNOWN_ROOT' as const;
+  public readonly responseErrorCode = 'UNKNOWN_ROOT' as const;
+
+  constructor(options?: { cause?: unknown }) {
+    super('NoSQLDB refuses this storage root: the root, or a feature it carries, comes from a later NoSQLDB release than this one', options);
+    this.name = 'NoSqlDbUnknownRootError';
+  }
+}
+
+/** The bounded record of one engine process's last standard-error lines. */
+class EngineStderrTail {
+  private lines: string[] = [];
+
+  public add(lineArg: string): void {
+    const limit = noSqlDbEngineStderrTailLimits.lineCharacters;
+    this.lines.push(lineArg.length > limit
+      ? `${lineArg.slice(0, limit)} [${lineArg.length - limit} more characters]`
+      : lineArg);
+    if (this.lines.length > noSqlDbEngineStderrTailLimits.lines) this.lines.shift();
+  }
+
+  public clear(): void {
+    this.lines = [];
+  }
+
+  public snapshot(): string[] {
+    return [...this.lines];
+  }
+}
+
 export class NoSqlDbManagementOperationTerminationError extends AggregateError {
   constructor(operationErrorArg: unknown, terminationErrorArg: unknown) {
     super(
@@ -363,6 +450,7 @@ interface INoSqlDbRustConfig {
   storagePath?: string;
   query?: INoSqlDbQueryOptions;
   inbound?: INoSqlDbInboundOptions;
+  storageBudgetBytes?: number;
   auth?: {
     enabled?: boolean;
     users?: Array<{
@@ -397,8 +485,8 @@ function getPackageRoot(): string {
 }
 
 /**
- * Map Node.js process.platform/process.arch to tsrust's friendly name suffix.
- * tsrust names cross-compiled binaries as: rustdb_linux_amd64, rustdb_linux_arm64, etc.
+ * Map Node.js process.platform/process.arch to rsrepo's friendly name suffix.
+ * rsrepo names cross-compiled binaries as: rustdb_linux_amd64, rustdb_linux_arm64, etc.
  */
 function getTsrustPlatformSuffix(): string | null {
   const archMap: Record<string, string> = { x64: 'amd64', arm64: 'arm64' };
@@ -414,14 +502,14 @@ function getTsrustPlatformSuffix(): string | null {
 
 /**
  * Build local search paths for the Rust binary, including dist_rust/ candidates
- * (built by tsrust) and local development build paths.
+ * (built by rsrepo) and local development build paths.
  */
 function buildLocalPaths(): string[] {
   const packageRoot = getPackageRoot();
   const suffix = getTsrustPlatformSuffix();
   const paths: string[] = [];
 
-  // dist_rust/ candidates (tsrust cross-compiled output)
+  // dist_rust/ candidates (rsrepo cross-compiled output)
   if (suffix) {
     paths.push(path.join(packageRoot, 'dist_rust', `rustdb_${suffix}`));
   }
@@ -433,18 +521,40 @@ function buildLocalPaths(): string[] {
 
   return paths;
 }
-export function getRustDbAllocatorEnv(
-  environment: NodeJS.ProcessEnv = process.env,
-): Record<string, string> {
-  return {
-    MIMALLOC_ARENA_EAGER_COMMIT: environment.MIMALLOC_ARENA_EAGER_COMMIT ?? '0',
-    MIMALLOC_ALLOW_LARGE_OS_PAGES: environment.MIMALLOC_ALLOW_LARGE_OS_PAGES ?? '0',
-  };
+
+const binaryHelp = 'Set NOSQLDB_RUST_BINARY env var, install the platform package, or build locally with `rsrepo`.';
+
+/**
+ * What a spawn() that returned false after `waitedMs` means, stating only what
+ * is known. Smartrust refuses a `binaryPath` that does not pass its validation
+ * before spawn() can return false, so with one the engine there passed
+ * Smartrust's validation and did not report ready within the bridge's limit,
+ * and its path is given as the caller gave it.
+ * Without one, whatever NOSQLDB_RUST_BINARY holds (one of the places that
+ * Smartrust's search looks), either the search found no engine or the engine
+ * it found did not report ready, and nothing tells which.
+ */
+export function describeRefusedSpawn(binaryPath: string | undefined, waitedMs: number): string {
+  if (binaryPath !== undefined) {
+    return `the nosqldb engine at ${binaryPath} did not report ready within the bridge's limit: it waited ${waitedMs} ms`;
+  }
+  return `the nosqldb engine did not start: spawn() returned false after ${waitedMs} ms, which means either that no nosqldb Rust binary `
+    + `was found (${binaryHelp}) or that the engine found did not report ready within the bridge's limit`;
 }
 
 export interface IRustDbBridgeOptions {
   /** Exact engine executable, validated by Smartrust without discovery fallback or permission changes. */
   binaryPath?: string;
+  /**
+   * Receives every line the engine writes to its standard error, in order and
+   * without its line break. Without it, no engine line reaches the host
+   * process's standard error. Either way the bridge keeps the last lines for
+   * errors (`noSqlDbEngineStderrTailLimits`). Each call runs in its own
+   * microtask after the bridge has recorded the line, so an exception it
+   * throws cannot disturb the bridge; it is not caught and reaches the process
+   * as an uncaught exception.
+   */
+  engineLog?: (line: string) => void;
 }
 
 /**
@@ -460,17 +570,100 @@ export class RustDbBridge extends EventEmitter {
    * termination, or when the bridge is connected to an external process.
    */
   public get processId(): number | undefined {
+    return this.childProcess?.pid;
+  }
+
+  /** The engine child process of the latest spawn, while the bridge holds it. */
+  private get childProcess(): ChildProcess | undefined {
     const transport = (this.bridge as unknown as {
-      transport?: { childProcess?: { pid?: number } | null };
+      transport?: { childProcess?: ChildProcess | null };
     }).transport;
-    return transport?.childProcess?.pid;
+    return transport?.childProcess ?? undefined;
+  }
+
+  /** How the engine process of the latest spawn exited, once it has. */
+  private engineExit: { code: number | null; signal: string | null } | null = null;
+  private engineExitPromise: Promise<void> | undefined;
+
+  /** Records the exit of the engine process that a spawn has just started. */
+  private watchEngineExit(): void {
+    const child = this.childProcess;
+    if (!child) return;
+    this.engineExitPromise = new Promise((resolveArg) => {
+      const record = (code: number | null, signal: string | null) => {
+        this.engineExit = { code, signal };
+        resolveArg();
+      };
+      if (child.exitCode !== null || child.signalCode !== null) record(child.exitCode, child.signalCode);
+      else child.once('exit', record);
+    });
+  }
+
+  /**
+   * The exit code and signal of the engine process of the latest spawn, as its
+   * process exit reported them, each null where it reported none; or null
+   * while that process has not exited, or no spawn started one.
+   */
+  public get lastEngineExit(): { code: number | null; signal: string | null } | null {
+    return this.engineExit;
+  }
+
+  /** Whether the engine process of the latest spawn exists and has not exited. */
+  public get engineProcessAlive(): boolean {
+    return this.engineExitPromise !== undefined && this.engineExit === null;
+  }
+
+  /** Waits up to `timeoutMs` for the engine process to exit by itself; resolves whether it has. */
+  public async waitForEngineExit(timeoutMs: number): Promise<boolean> {
+    if (!this.engineExitPromise) return false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    await Promise.race([
+      this.engineExitPromise,
+      new Promise<void>((resolveArg) => { timer = setTimeout(resolveArg, timeoutMs); }),
+    ]);
+    if (timer) clearTimeout(timer);
+    return this.engineExit !== null;
+  }
+
+  /**
+   * Closes the engine's management input, the end of the management protocol
+   * after an acknowledged `stop`, on which the engine exits by itself. This is
+   * neither a signal nor a kill. Returns whether there was an input to close.
+   */
+  public endManagementInput(): boolean {
+    const input = this.childProcess?.stdin;
+    if (!input || input.writableEnded) return false;
+    input.end();
+    return true;
   }
   private terminationConfirmed = true;
   private terminationPromise: Promise<void> | undefined;
   private terminationFailure: unknown;
+  private readonly stderrTail = new EngineStderrTail();
+  /** The `binaryPath` this bridge was given, if any, as given: the bridge's only configured path. */
+  private readonly binaryPath: string | undefined;
+  private spawnRefusal: string | undefined;
+
+  /**
+   * Why Smartrust's spawn() returned false, as far as the bridge knows. Each
+   * spawn() clears it as it starts, and sets it when Smartrust's spawn()
+   * returns false before this spawn()'s own `timeoutMs` or `signal` cuts it
+   * short, before the engine is ended. That spawn() then returns false, or
+   * throws if ending the engine fails. After any other spawn() it is
+   * undefined, including one cut short by its own `timeoutMs` or `signal`.
+   * Smartrust's spawn() returns false both when it finds no engine and when
+   * the engine it starts does not report ready within its limit; a
+   * `binaryPath` tells the two apart, as Smartrust refuses one that does not
+   * pass its validation with RustBinaryLocatorError before spawn() can return
+   * false.
+   */
+  public get spawnFailureMessage(): string | undefined {
+    return this.spawnRefusal;
+  }
 
   constructor(options: IRustDbBridgeOptions = {}) {
     super();
+    this.binaryPath = options.binaryPath;
 
     this.bridge = new plugins.smartrust.RustBridge<TNoSqlDbCommands>({
       binaryName: 'rustdb',
@@ -479,7 +672,14 @@ export class RustDbBridge extends EventEmitter {
       platformPackagePrefix: '@lossless.org/nosqldb',
       localPaths: buildLocalPaths(),
       maxPayloadSize: 100 * 1024 * 1024, // database exports/imports can be larger than command replies
-      env: getRustDbAllocatorEnv(),
+    });
+
+    // Smartrust delivers the engine's standard error one line at a time.
+    const engineLog = options.engineLog;
+    this.bridge.on('stderr', (line: string) => {
+      this.stderrTail.add(line);
+      // Microtasks run in order, so the lines keep their order.
+      if (engineLog) queueMicrotask(() => engineLog(line));
     });
 
     // Forward events from the inner bridge
@@ -489,11 +689,43 @@ export class RustDbBridge extends EventEmitter {
     });
   }
 
+  /**
+   * The last standard-error lines of the running or most recently spawned
+   * engine process, within `noSqlDbEngineStderrTailLimits`.
+   */
+  public get engineStderrTail(): string[] {
+    return this.stderrTail.snapshot();
+  }
+
+  /**
+   * Send one management command. A failure while no engine runs (it exited
+   * or never started) carries the engine's last standard-error lines.
+   */
+  private async send<TMethod extends keyof TNoSqlDbCommands & string>(
+    methodArg: TMethod,
+    paramsArg: TNoSqlDbCommands[TMethod]['params'],
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<TNoSqlDbCommands[TMethod]['result']> {
+    try {
+      return await this.bridge.sendCommand(methodArg, paramsArg, optionsArg);
+    } catch (error) {
+      if (!this.bridge.running) attachNoSqlDbEngineStderrTail(error, this.stderrTail.snapshot());
+      throw error;
+    }
+  }
+
   /**
    * Spawn the Rust binary in management mode.
-   * Returns true if the binary was found and spawned successfully.
+   * Returns true once the engine reported ready. Returns false when
+   * Smartrust's spawn() returned false: no engine was found, or the one found
+   * did not report ready within the bridge's limit. spawnFailureMessage then
+   * says what that means, as far as the bridge knows, and still says it if
+   * ending that engine fails and this throws instead. After any other
+   * outcome, including a throw on this spawn()'s own `timeoutMs` or `signal`,
+   * spawnFailureMessage is undefined.
    */
   public async spawn(optionsArg?: INoSqlDbManagementOperationOptions): Promise<boolean> {
+    this.spawnRefusal = undefined;
     validateNoSqlDbManagementOperationOptions(optionsArg);
     if (optionsArg?.signal?.aborted) {
       throw new plugins.smartrust.RustBridgeRequestError(
@@ -508,6 +740,11 @@ export class RustDbBridge extends EventEmitter {
 
     this.terminationConfirmed = false;
     this.terminationFailure = undefined;
+    this.stderrTail.clear();
+    const spawnStartedAt = performance.now();
+    // The previous engine's exit belongs to it, also when this spawn fails.
+    this.engineExit = null;
+    this.engineExitPromise = undefined;
     const spawnPromise = this.bridge.spawn();
     let timeout: ReturnType<typeof setTimeout> | undefined;
     let abortHandler: (() => void) | undefined;
@@ -540,7 +777,9 @@ export class RustDbBridge extends EventEmitter {
 
     try {
       const spawned = await Promise.race([spawnPromise, cancellationPromise]);
+      if (spawned) this.watchEngineExit();
       if (!spawned) {
+        this.spawnRefusal = describeRefusedSpawn(this.binaryPath, Math.round(performance.now() - spawnStartedAt));
         await this.terminate({ gracePeriodMs: 0 });
       }
       return spawned;
@@ -652,7 +891,7 @@ export class RustDbBridge extends EventEmitter {
     const request = normalizeNoSqlDbStorageRehearsalInput(inputArg);
     validateNoSqlDbManagementOperationOptions(optionsArg);
     try {
-      return await this.bridge.sendCommand('createStoppedStorageRehearsal',
+      return await this.send('createStoppedStorageRehearsal',
         { request, timeoutMs: optionsArg.timeoutMs }, optionsArg) as INoSqlDbStorageRehearsalReceipt;
     } catch (error) {
       await this.awaitManagementOperationTermination(error);
@@ -667,7 +906,7 @@ export class RustDbBridge extends EventEmitter {
     const input = normalizeLocalNoSqlDbStoppedStorageRootRelocationInput(inputArg);
     validateNoSqlDbManagementOperationOptions(optionsArg);
     try {
-      return await this.bridge.sendCommand(
+      return await this.send(
         'relocateStoppedStorageRoot',
         { ...input, timeoutMs: optionsArg?.timeoutMs },
         optionsArg,
@@ -691,7 +930,7 @@ export class RustDbBridge extends EventEmitter {
     const input = normalizeStoppedStorageRootAlignmentInput(inputArg);
     validateNoSqlDbManagementOperationOptions(optionsArg);
     try {
-      return await this.bridge.sendCommand(method, { ...input, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
+      return await this.send(method, { ...input, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
     } catch (error) {
       await this.awaitManagementOperationTermination(error);
       throw normalizeStoppedOperationUnknownMethod(error, method);
@@ -705,7 +944,7 @@ export class RustDbBridge extends EventEmitter {
     const input = normalizeStoppedStorageRootInspectionInput(inputArg);
     validateNoSqlDbManagementOperationOptions(optionsArg);
     try {
-      return await this.bridge.sendCommand('inspectStoppedStorageRoot',
+      return await this.send('inspectStoppedStorageRoot',
         { ...input, timeoutMs: optionsArg?.timeoutMs }, optionsArg) as TLocalNoSqlDbStoppedStorageRootInspection;
     } catch (error) {
       await this.awaitManagementOperationTermination(error);
@@ -725,7 +964,7 @@ export class RustDbBridge extends EventEmitter {
       timeoutMs: optionsArg?.timeoutMs,
     };
     try {
-      return await this.bridge.sendCommand(
+      return await this.send(
         'inspectOfflinePhysicalNamespaces',
         params,
         optionsArg,
@@ -743,7 +982,7 @@ export class RustDbBridge extends EventEmitter {
     const input = normalizeLocalNoSqlDbOfflineInspectionInput(inputArg);
     validateNoSqlDbManagementOperationOptions(optionsArg);
     try {
-      return await this.bridge.sendCommand(
+      return await this.send(
         'inspectOfflineStringValue',
         { ...input, timeoutMs: optionsArg?.timeoutMs },
         optionsArg,
@@ -761,34 +1000,38 @@ export class RustDbBridge extends EventEmitter {
     normalizeNoSqlDbFileStorageOptions(config);
     validateNoSqlDbManagementOperationOptions(optionsArg);
     try {
-      return await this.bridge.sendCommand(
+      return await this.send(
         'start',
         { config, timeoutMs: optionsArg?.timeoutMs },
         optionsArg,
       ) as { connectionUri: string };
     } catch (error) {
       await this.awaitManagementOperationTermination(error);
+      // The unknown-root refusal is told apart by its code, never by its message.
+      if (error instanceof Error && 'responseErrorCode' in error && error.responseErrorCode === 'UNKNOWN_ROOT') {
+        throw new NoSqlDbUnknownRootError({ cause: error });
+      }
       throw error;
     }
   }
 
   public async stopDb(): Promise<void> {
-    await this.bridge.sendCommand('stop', {} as Record<string, never>);
+    await this.send('stop', {} as Record<string, never>);
   }
 
   public async getStatus(): Promise<{ running: boolean }> {
-    return await this.bridge.sendCommand('getStatus', {} as Record<string, never>) as { running: boolean };
+    return await this.send('getStatus', {} as Record<string, never>) as { running: boolean };
   }
 
   public async getMetrics(): Promise<INoSqlDbMetrics> {
-    return this.bridge.sendCommand('getMetrics', {} as Record<string, never>) as Promise<INoSqlDbMetrics>;
+    return this.send('getMetrics', {} as Record<string, never>) as Promise<INoSqlDbMetrics>;
   }
 
   public async getHealth(
     optionsArg?: INoSqlDbManagementOperationOptions,
   ): Promise<INoSqlDbHealth> {
     try {
-      return await this.bridge.sendCommand(
+      return await this.send(
         'getHealth',
         {} as Record<string, never>,
         optionsArg,
@@ -803,7 +1046,7 @@ export class RustDbBridge extends EventEmitter {
     params: INoSqlDbDatabaseTenantInput,
   ): Promise<INoSqlDbDatabaseTenantDescriptor> {
     try {
-      return await this.bridge.sendCommand('createDatabaseTenant', params) as INoSqlDbDatabaseTenantDescriptor;
+      return await this.send('createDatabaseTenant', params) as INoSqlDbDatabaseTenantDescriptor;
     } catch (error) {
       throw normalizeNoSqlDbResourceFenceError(error);
     }
@@ -814,7 +1057,7 @@ export class RustDbBridge extends EventEmitter {
     optionsArg?: INoSqlDbManagementOperationOptions,
   ): Promise<INoSqlDbEnsureDatabaseTenantResult> {
     try {
-      return await this.bridge.sendCommand(
+      return await this.send(
         'ensureDatabaseTenant',
         params,
         optionsArg,
@@ -830,7 +1073,7 @@ export class RustDbBridge extends EventEmitter {
     optionsArg?: INoSqlDbManagementOperationOptions,
   ): Promise<INoSqlDbAttestDatabaseTenantResult> {
     try {
-      return await this.bridge.sendCommand(
+      return await this.send(
         'attestDatabaseTenant',
         params,
         optionsArg,
@@ -846,7 +1089,7 @@ export class RustDbBridge extends EventEmitter {
     optionsArg?: INoSqlDbManagementOperationOptions,
   ): Promise<INoSqlDbAllocateDatabaseTenantResult> {
     try {
-      return await this.bridge.sendCommand(
+      return await this.send(
         'allocateDatabaseTenant',
         params,
         optionsArg,
@@ -862,7 +1105,7 @@ export class RustDbBridge extends EventEmitter {
     optionsArg?: INoSqlDbManagementOperationOptions,
   ): Promise<INoSqlDbDeleteDatabaseTenantResult> {
     try {
-      return await this.bridge.sendCommand(
+      return await this.send(
         'deleteDatabaseTenant',
         params,
         optionsArg,
@@ -878,7 +1121,7 @@ export class RustDbBridge extends EventEmitter {
     optionsArg?: INoSqlDbManagementOperationOptions,
   ): Promise<INoSqlDbIssueDatabaseAllocationReadAccessGrantResult> {
     try {
-      return await this.bridge.sendCommand(
+      return await this.send(
         'issueDatabaseAllocationReadAccessGrant',
         params,
         optionsArg,
@@ -899,7 +1142,7 @@ export class RustDbBridge extends EventEmitter {
     optionsArg?: INoSqlDbManagementOperationOptions,
   ): Promise<INoSqlDbRevokeDatabaseAllocationReadAccessGrantResult> {
     try {
-      return await this.bridge.sendCommand(
+      return await this.send(
         'revokeDatabaseAllocationReadAccessGrant',
         params,
         optionsArg,
@@ -918,11 +1161,11 @@ export class RustDbBridge extends EventEmitter {
   public async rotateDatabaseTenantPassword(
     params: INoSqlDbRotateDatabaseTenantPasswordInput,
   ): Promise<INoSqlDbDatabaseTenantDescriptor> {
-    return this.bridge.sendCommand('rotateDatabaseTenantPassword', params) as Promise<INoSqlDbDatabaseTenantDescriptor>;
+    return this.send('rotateDatabaseTenantPassword', params) as Promise<INoSqlDbDatabaseTenantDescriptor>;
   }
 
   public async listDatabaseTenants(): Promise<INoSqlDbDatabaseTenantDescriptor[]> {
-    const result = await this.bridge.sendCommand('listDatabaseTenants', {} as Record<string, never>) as { tenants: INoSqlDbDatabaseTenantDescriptor[] };
+    const result = await this.send('listDatabaseTenants', {} as Record<string, never>) as { tenants: INoSqlDbDatabaseTenantDescriptor[] };
     return result.tenants;
   }
 
@@ -930,7 +1173,7 @@ export class RustDbBridge extends EventEmitter {
     databaseName: string;
     username: string;
   }): Promise<INoSqlDbDatabaseTenantDescriptor> {
-    return this.bridge.sendCommand('getDatabaseTenantDescriptor', params) as Promise<INoSqlDbDatabaseTenantDescriptor>;
+    return this.send('getDatabaseTenantDescriptor', params) as Promise<INoSqlDbDatabaseTenantDescriptor>;
   }
 
   public async getDatabaseResourceFenceState(
@@ -938,7 +1181,7 @@ export class RustDbBridge extends EventEmitter {
     optionsArg?: INoSqlDbManagementOperationOptions,
   ): Promise<INoSqlDbDatabaseResourceFenceState | null> {
     try {
-      return await this.bridge.sendCommand(
+      return await this.send(
         'getDatabaseResourceFenceState',
         params,
         optionsArg,
@@ -954,7 +1197,7 @@ export class RustDbBridge extends EventEmitter {
     optionsArg?: INoSqlDbManagementOperationOptions,
   ): Promise<INoSqlDbDatabaseExport> {
     try {
-      return await this.bridge.sendCommand(
+      return await this.send(
         'exportDatabase',
         params,
         optionsArg,
@@ -970,7 +1213,7 @@ export class RustDbBridge extends EventEmitter {
     optionsArg?: INoSqlDbManagementOperationOptions,
   ): Promise<INoSqlDbDatabaseExport> {
     try {
-      return await this.bridge.sendCommand(
+      return await this.send(
         'exportHeldDatabase',
         params,
         optionsArg,
@@ -986,7 +1229,7 @@ export class RustDbBridge extends EventEmitter {
     optionsArg?: INoSqlDbManagementOperationOptions,
   ): Promise<INoSqlDbDatabaseContentDigest> {
     try {
-      return await this.bridge.sendCommand(
+      return await this.send(
         'getDatabaseContentDigest',
         params,
         optionsArg,
@@ -1002,7 +1245,7 @@ export class RustDbBridge extends EventEmitter {
     optionsArg?: INoSqlDbManagementOperationOptions,
   ): Promise<INoSqlDbImportDatabaseResult> {
     try {
-      return await this.bridge.sendCommand(
+      return await this.send(
         'importDatabase',
         { ...params, timeoutMs: optionsArg?.timeoutMs },
         optionsArg,
@@ -1018,7 +1261,7 @@ export class RustDbBridge extends EventEmitter {
     optionsArg?: INoSqlDbManagementOperationOptions,
   ): Promise<TNoSqlDbCommitDatabasePublicationResult> {
     try {
-      return await this.bridge.sendCommand(
+      return await this.send(
         'commitDatabasePublication',
         params,
         optionsArg,
@@ -1035,23 +1278,23 @@ export class RustDbBridge extends EventEmitter {
     db?: string;
     collection?: string;
   } = {}): Promise<IOpLogResult> {
-    return this.bridge.sendCommand('getOpLog', params) as Promise<IOpLogResult>;
+    return this.send('getOpLog', params) as Promise<IOpLogResult>;
   }
 
   public async getCommittedWrites(params: INoSqlDbGetCommittedWritesInput): Promise<INoSqlDbCommittedWritesPage> {
-    return this.bridge.sendCommand('getCommittedWrites', params);
+    return this.send('getCommittedWrites', params);
   }
 
   public async getOpLogStats(): Promise<IOpLogStats> {
-    return this.bridge.sendCommand('getOpLogStats', {} as Record<string, never>) as Promise<IOpLogStats>;
+    return this.send('getOpLogStats', {} as Record<string, never>) as Promise<IOpLogStats>;
   }
 
   public async revertToSeq(seq: number, dryRun = false): Promise<IRevertResult> {
-    return this.bridge.sendCommand('revertToSeq', { seq, dryRun }) as Promise<IRevertResult>;
+    return this.send('revertToSeq', { seq, dryRun }) as Promise<IRevertResult>;
   }
 
   public async getCollections(db?: string): Promise<ICollectionInfo[]> {
-    const result = await this.bridge.sendCommand('getCollections', db ? { db } : {}) as { collections: ICollectionInfo[] };
+    const result = await this.send('getCollections', db ? { db } : {}) as { collections: ICollectionInfo[] };
     return result.collections;
   }
 
@@ -1061,6 +1304,6 @@ export class RustDbBridge extends EventEmitter {
     limit = 50,
     skip = 0,
   ): Promise<IDocumentsResult> {
-    return this.bridge.sendCommand('getDocuments', { db, collection, limit, skip }) as Promise<IDocumentsResult>;
+    return this.send('getDocuments', { db, collection, limit, skip }) as Promise<IDocumentsResult>;
   }
 }