@lossless.org/nosqldb 10.10.0 → 10.11.0

package/ts/ts_nosqldb/server/classes.nosqldbserver.ts

@@ -1,738 +0,0 @@
-import {
-  RustDbBridge,
-  NoSqlDbManagementOperationTerminationError,
-} from '../rust-db-bridge.js';
-import { validateNoSqlDbManagementOperationOptions } from '../offline-inspection.js';
-import type { INoSqlDbGetCommittedWritesInput, INoSqlDbCommittedWritesPage } from '../committed-writes.js';
-import { validateNoSqlDbStorageRehearsalStartup } from '../storage-rehearsal.js';
-import { assertNoLocalNoSqlDbStorageRootRelocationWorkspace } from '../storage-root-relocation.js';
-import {
-  type TNoSqlDbFileStorageStartup,
-} from '../file-storage-startup.js';
-import {
-  normalizeNoSqlDbFileStorageOptions,
-} from '../file-storage-options.js';
-import type {
-  IOpLogEntry,
-  IOpLogResult,
-  IOpLogStats,
-  IRevertResult,
-  ICollectionInfo,
-  IDocumentsResult,
-  INoSqlDbMetrics,
-  INoSqlDbQueryOptions,
-  INoSqlDbInboundOptions,
-} from '../rust-db-bridge.js';
-import type {
-  INoSqlDbHealth,
-  INoSqlDbDatabaseTenantInput,
-  INoSqlDbAttestDatabaseTenantInput,
-  INoSqlDbAttestDatabaseTenantResult,
-  INoSqlDbEnsureDatabaseTenantInput,
-  INoSqlDbEnsureDatabaseTenantResult,
-  INoSqlDbAllocateDatabaseTenantInput,
-  INoSqlDbAllocateDatabaseTenantResult,
-  INoSqlDbDeleteDatabaseTenantInput,
-  INoSqlDbRotateDatabaseTenantPasswordInput,
-  INoSqlDbDatabaseTenantDescriptor,
-  INoSqlDbDeleteDatabaseTenantResult,
-  INoSqlDbIssueDatabaseAllocationReadAccessGrantInput,
-  INoSqlDbIssueDatabaseAllocationReadAccessGrantResult,
-  INoSqlDbRevokeDatabaseAllocationReadAccessGrantInput,
-  INoSqlDbRevokeDatabaseAllocationReadAccessGrantResult,
-  INoSqlDbDatabaseExport,
-  INoSqlDbExportDatabaseInput,
-  INoSqlDbExportHeldDatabaseInput,
-  INoSqlDbDatabaseContentDigest,
-  INoSqlDbGetDatabaseContentDigestInput,
-  INoSqlDbImportDatabaseInput,
-  INoSqlDbImportDatabaseResult,
-  INoSqlDbCommitDatabasePublicationInput,
-  INoSqlDbManagementOperationOptions,
-  INoSqlDbDatabaseResourceFenceState,
-  TNoSqlDbCommitDatabasePublicationResult,
-} from '../service-types.js';
-
-/**
- * Server configuration options
- */
-export interface INoSqlDbServerOptions {
-  /** Exact engine executable. Invalid explicit paths reject without chmod or discovery fallback. Omit for normal discovery. */
-  binaryPath?: string;
-  /** Exact rehearsal operation ID. Requires authenticated current-format-only file storage and an explicit private Unix socket. Never promotes a rehearsal. */
-  storageRehearsalId?: string;
-  /** Default: current-format-only. existing-only also requires initialized storage and refuses fresh creation. */
-  fileStorageStartup?: TNoSqlDbFileStorageStartup;
-  /** Port to listen on (default: 27017, 0 requests an OS-assigned port) - ignored if socketPath is set */
-  port?: number;
-  /** Host to bind to (default: 127.0.0.1) - ignored if socketPath is set */
-  host?: string;
-  /** Unix socket path - if set, server listens on socket instead of TCP */
-  socketPath?: string;
-  /** Storage type: 'memory' or 'file' (default: 'memory') */
-  storage?: 'memory' | 'file';
-  /** Path for file storage (required if storage is 'file') */
-  storagePath?: string;
-  /** Authentication configuration. Disabled by default. */
-  auth?: INoSqlDbAuthOptions;
-  /** TLS transport configuration for TCP listeners. Disabled by default. */
-  tls?: INoSqlDbTlsOptions;
-  /** In-memory oplog: whether it is kept, and its retention limits (defaults: enabled, 10000 entries / 8 MiB). */
-  oplog?: INoSqlDbOplogOptions;
-  /** Memory, temporary storage, and concurrency admission for large sorts. */
-  query?: INoSqlDbQueryOptions;
-  /** Memory budgets for received requests (default: sized from the memory limit). */
-  inbound?: INoSqlDbInboundOptions;
-}
-
-export interface INoSqlDbOplogOptions {
-  /** Keep the oplog (default: true). When false, writes prepare no history, and getOpLog, getOpLogStats and revertToSeq reject with "oplog is disabled". */
-  enabled?: boolean;
-  /** Maximum number of retained oplog entries (default: 10000). */
-  maxEntries?: number;
-  /** Maximum approximate retained bytes, the entry table included (default: 8 MiB). Oldest entries are evicted first; reverts cannot reach past evicted entries. */
-  maxBytes?: number;
-}
-
-export interface INoSqlDbAuthOptions {
-  enabled?: boolean;
-  users?: INoSqlDbAuthUser[];
-  scramIterations?: number;
-}
-
-export interface INoSqlDbAuthUser {
-  username: string;
-  password: string;
-  database?: string;
-  roles?: string[];
-}
-
-export interface INoSqlDbTlsOptions {
-  enabled?: boolean;
-  certPath?: string;
-  keyPath?: string;
-  caPath?: string;
-  requireClientCert?: boolean;
-}
-
-/**
- * NoSqlDbServer - Wire protocol compatible database server backed by Rust
- *
- * This server implements the wire protocol to allow official drivers to
- * connect and perform operations. The core engine runs as a Rust sidecar
- * binary managed via @push.rocks/smartrust IPC.
- *
- * @example
- * ```typescript
- * import { NoSqlDbServer } from '@lossless.org/nosqldb';
- * import { MongoClient } from 'mongodb';
- *
- * const server = new NoSqlDbServer({ port: 27017 });
- * await server.start();
- *
- * const client = new MongoClient(server.getConnectionUri());
- * await client.connect();
- * ```
- */
-export class NoSqlDbServer {
-  private options: INoSqlDbServerOptions;
-  private bridge: RustDbBridge;
-  private bridgeOwned = false;
-  private startInProgress = false;
-  private startCompletionPromise: Promise<void> | null = null;
-  private stopCompletionPromise: Promise<void> | null = null;
-  private isRunning = false;
-  private resolvedConnectionUri = '';
-  private resolvedPort: number | undefined;
-
-  constructor(options: INoSqlDbServerOptions = {}) {
-    validateNoSqlDbStorageRehearsalStartup(options);
-    const fileStorage = normalizeNoSqlDbFileStorageOptions(options);
-    this.options = {
-      binaryPath: options.binaryPath,
-      storageRehearsalId: options.storageRehearsalId,
-      ...fileStorage,
-      port: options.port ?? 27017,
-      host: options.host ?? '127.0.0.1',
-      socketPath: options.socketPath,
-      storage: options.storage ?? 'memory',
-      storagePath: options.storagePath ?? './data',
-      auth: options.auth,
-      tls: options.tls,
-      oplog: options.oplog,
-      query: options.query,
-      inbound: options.inbound,
-    };
-    this.bridge = new RustDbBridge({ binaryPath: this.options.binaryPath });
-    this.bridge.on('exit', (code: number | null, signal: string | null) => {
-      const exitedUnexpectedly = this.isRunning
-        && !this.stopCompletionPromise
-        && (code !== 0 || signal !== null);
-      this.isRunning = false;
-      this.resolvedConnectionUri = '';
-      this.resolvedPort = undefined;
-      if (exitedUnexpectedly) {
-        console.error(`nosqldb Rust process exited unexpectedly (code=${code}, signal=${signal})`);
-      }
-    });
-  }
-
-  /**
-   * Start the server
-   */
-  async start(optionsArg?: INoSqlDbManagementOperationOptions): Promise<void> {
-    validateNoSqlDbManagementOperationOptions(optionsArg);
-    optionsArg?.signal?.throwIfAborted();
-    if (this.isRunning || this.startInProgress || this.bridgeOwned || this.stopCompletionPromise) {
-      throw new Error('Server is already running or still owns a Rust bridge');
-    }
-
-    const startupStartedAt = Date.now();
-    const startupDeadline = optionsArg?.timeoutMs === undefined
-      ? undefined
-      : startupStartedAt + optionsArg.timeoutMs;
-    const timeoutError = new DOMException(
-      optionsArg?.timeoutMs === undefined
-        ? 'NoSQLDB startup timed out'
-        : `NoSQLDB startup timed out after ${optionsArg.timeoutMs}ms`,
-      'TimeoutError',
-    );
-    const startupAbortController = new AbortController();
-    let startupTimeout: ReturnType<typeof setTimeout> | undefined;
-    let externalAbortHandler: (() => void) | undefined;
-    if (optionsArg?.signal) {
-      externalAbortHandler = () => {
-        startupAbortController.abort(optionsArg.signal!.reason);
-      };
-      optionsArg.signal.addEventListener('abort', externalAbortHandler, { once: true });
-    }
-    if (optionsArg?.timeoutMs !== undefined) {
-      startupTimeout = setTimeout(() => {
-        startupAbortController.abort(timeoutError);
-      }, optionsArg.timeoutMs);
-    }
-    const checkpoint = () => {
-      if (
-        startupDeadline !== undefined
-        && Date.now() >= startupDeadline
-        && !startupAbortController.signal.aborted
-      ) {
-        startupAbortController.abort(timeoutError);
-      }
-      startupAbortController.signal.throwIfAborted();
-    };
-    const getBridgeOperationOptions = (): INoSqlDbManagementOperationOptions | undefined => {
-      checkpoint();
-      const remainingTimeoutMs = startupDeadline === undefined
-        ? undefined
-        : startupDeadline - Date.now();
-      if (remainingTimeoutMs !== undefined && remainingTimeoutMs <= 0) {
-        startupAbortController.abort(timeoutError);
-        checkpoint();
-      }
-      if (!optionsArg?.signal && remainingTimeoutMs === undefined) return undefined;
-      return {
-        ...(optionsArg?.signal ? { signal: optionsArg.signal } : {}),
-        ...(remainingTimeoutMs === undefined ? {} : { timeoutMs: remainingTimeoutMs }),
-      };
-    };
-
-    this.startInProgress = true;
-    let resolveStartCompletion!: () => void;
-    const startCompletionPromise = new Promise<void>((resolveArg) => {
-      resolveStartCompletion = resolveArg;
-    });
-    this.startCompletionPromise = startCompletionPromise;
-    try {
-      checkpoint();
-      // Relocation workspace admission is read-only; the native owner alone
-      // classifies and initializes storage after acquiring its root lease.
-      if (this.options.storage === 'file' && this.options.storagePath) {
-        await assertNoLocalNoSqlDbStorageRootRelocationWorkspace(this.options.storagePath);
-        checkpoint();
-      }
-
-      // Ownership starts before spawn because a rejected spawn can still have
-      // created a child whose termination must be confirmed.
-      this.bridgeOwned = true;
-      const spawned = await this.bridge.spawn(getBridgeOperationOptions());
-      checkpoint();
-      if (!spawned) {
-        throw new Error(
-          'nosqldb Rust binary not found. Set NOSQLDB_RUST_BINARY env var, ' +
-          'install the platform package, or build locally with `tsrust`.'
-        );
-      }
-
-      // Send config, get back connectionUri
-      const result = await this.bridge.startDb({
-        port: this.options.port,
-        host: this.options.host,
-        socketPath: this.options.socketPath,
-        storage: this.options.storage ?? 'memory',
-        storagePath: this.options.storagePath,
-        ...(this.options.fileStorageStartup === 'existing-only' ? { fileStorageStartup: 'existing-only' as const } : {}),
-        storageRehearsalId: this.options.storageRehearsalId,
-        auth: this.options.auth,
-        tls: this.options.tls,
-        oplog: this.options.oplog,
-        query: this.options.query,
-        inbound: this.options.inbound,
-      }, getBridgeOperationOptions());
-      checkpoint();
-      if (!this.bridgeOwned || !this.bridge.running) {
-        throw new Error('nosqldb Rust process exited during startup');
-      }
-
-      if (!this.options.socketPath) {
-        const connectionUrl = new URL(result.connectionUri);
-        const resolvedPort = Number(connectionUrl.port);
-        if (
-          connectionUrl.protocol !== 'mongodb:'
-          || !connectionUrl.hostname
-          || !Number.isInteger(resolvedPort)
-          || resolvedPort < 1
-          || resolvedPort > 65_535
-        ) {
-          throw new Error(`nosqldb returned an invalid TCP connection URI: ${result.connectionUri}`);
-        }
-        this.resolvedPort = resolvedPort;
-      }
-      this.resolvedConnectionUri = result.connectionUri;
-      checkpoint();
-      this.isRunning = true;
-    } catch (error) {
-      const startupError = error instanceof NoSqlDbManagementOperationTerminationError
-        ? error
-        : optionsArg?.signal?.aborted
-          ? optionsArg.signal.reason
-          : startupAbortController.signal.aborted || (
-              startupDeadline !== undefined && Date.now() >= startupDeadline
-            )
-            ? timeoutError
-            : error;
-      this.isRunning = false;
-      this.resolvedConnectionUri = '';
-      this.resolvedPort = undefined;
-      if (this.bridgeOwned) {
-        try {
-          await this.bridge.terminate();
-          this.bridgeOwned = false;
-        } catch (cleanupError) {
-          throw new AggregateError(
-            [startupError, cleanupError],
-            'NoSQLDB startup failed and Rust bridge cleanup was incomplete',
-            { cause: startupError },
-          );
-        }
-      }
-      throw startupError;
-    } finally {
-      if (startupTimeout) clearTimeout(startupTimeout);
-      if (externalAbortHandler && optionsArg?.signal) {
-        optionsArg.signal.removeEventListener('abort', externalAbortHandler);
-      }
-      this.startInProgress = false;
-      resolveStartCompletion();
-      if (this.startCompletionPromise === startCompletionPromise) {
-        this.startCompletionPromise = null;
-      }
-    }
-  }
-
-  /**
-   * Stop the server
-   */
-  stop(): Promise<void> {
-    if (this.stopCompletionPromise) {
-      return this.stopCompletionPromise;
-    }
-
-    const stopCompletionPromise = this.stopInternal();
-    this.stopCompletionPromise = stopCompletionPromise;
-    const releaseStopCompletion = () => {
-      if (this.stopCompletionPromise === stopCompletionPromise) {
-        this.stopCompletionPromise = null;
-      }
-    };
-    void stopCompletionPromise.then(releaseStopCompletion, releaseStopCompletion);
-    return stopCompletionPromise;
-  }
-
-  private async stopInternal(): Promise<void> {
-    const startCompletionPromise = this.startCompletionPromise;
-    if (startCompletionPromise) {
-      await startCompletionPromise;
-    }
-
-    if (!this.isRunning && !this.bridgeOwned) {
-      return;
-    }
-
-    const requestGracefulStop = this.isRunning && this.bridge.running;
-    if (requestGracefulStop) {
-      try {
-        await this.bridge.stopDb();
-      } catch {
-        // Confirmed bridge termination below still releases the owned process.
-      }
-    }
-
-    await this.bridge.terminate();
-    this.bridgeOwned = false;
-    this.isRunning = false;
-    this.resolvedConnectionUri = '';
-    this.resolvedPort = undefined;
-  }
-
-  /**
-   * Get the connection URI for this server
-   */
-  getConnectionUri(): string {
-    if (this.resolvedConnectionUri) {
-      return this.resolvedConnectionUri;
-    }
-    // Fallback: compute from options
-    if (this.options.socketPath) {
-      const encodedPath = encodeURIComponent(this.options.socketPath);
-      return `mongodb://${encodedPath}`;
-    }
-    const baseUri = `mongodb://${this.options.host ?? '127.0.0.1'}:${this.options.port ?? 27017}`;
-    return this.options.tls?.enabled ? `${baseUri}/?tls=true` : baseUri;
-  }
-
-  /**
-   * Get the socket path (if using Unix socket mode)
-   */
-  get socketPath(): string | undefined {
-    return this.options.socketPath;
-  }
-
-  /**
-   * Check if the server is running
-   */
-  /** Process id of the spawned Rust engine, when it runs as a child process. */
-  get processId(): number | undefined {
-    return this.bridge.processId;
-  }
-
-  get running(): boolean {
-    return this.isRunning;
-  }
-
-  private async runDatabaseManagementOperation<TResult>(
-    operationArg: () => Promise<TResult>,
-  ): Promise<TResult> {
-    try {
-      return await operationArg();
-    } catch (error) {
-      if (
-        !this.bridge.running
-        || error instanceof NoSqlDbManagementOperationTerminationError
-      ) {
-        this.isRunning = false;
-        this.resolvedConnectionUri = '';
-        this.resolvedPort = undefined;
-        if (this.bridge.ownershipReleased) {
-          this.bridgeOwned = false;
-        }
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Get the port the server is listening on
-   */
-  get port(): number {
-    return this.resolvedPort ?? this.options.port ?? 27017;
-  }
-
-  /**
-   * Get the host the server is bound to
-   */
-  get host(): string {
-    return this.options.host ?? '127.0.0.1';
-  }
-
-  /**
-   * Create an isolated database/user pair for an application tenant.
-   */
-  async createDatabaseTenant(
-    params: INoSqlDbDatabaseTenantInput,
-  ): Promise<INoSqlDbDatabaseTenantDescriptor> {
-    const descriptor = await this.bridge.createDatabaseTenant(params);
-    return this.withTenantMongoUri(descriptor, params.password);
-  }
-
-  /** Authoritatively allocate an absent, fenced database tenant. */
-  async allocateDatabaseTenant(
-    params: INoSqlDbAllocateDatabaseTenantInput,
-    optionsArg?: INoSqlDbManagementOperationOptions,
-  ): Promise<INoSqlDbAllocateDatabaseTenantResult> {
-    const descriptor = await this.runDatabaseManagementOperation(
-      () => this.bridge.allocateDatabaseTenant(params, optionsArg),
-    );
-    return this.withTenantMongoUri(descriptor, params.password);
-  }
-
-  /**
-   * Idempotently provision or rotate one exclusively owned database tenant.
-   */
-  async ensureDatabaseTenant(
-    params: INoSqlDbEnsureDatabaseTenantInput,
-    optionsArg?: INoSqlDbManagementOperationOptions,
-  ): Promise<INoSqlDbEnsureDatabaseTenantResult> {
-    const descriptor = await this.runDatabaseManagementOperation(
-      () => this.bridge.ensureDatabaseTenant(params, optionsArg),
-    );
-    return this.withTenantMongoUri(descriptor, params.password);
-  }
-
-  /** Verify an exact tenant credential without changing provider state. */
-  async attestDatabaseTenant(
-    params: INoSqlDbAttestDatabaseTenantInput,
-    optionsArg?: INoSqlDbManagementOperationOptions,
-  ): Promise<INoSqlDbAttestDatabaseTenantResult> {
-    return this.runDatabaseManagementOperation(
-      () => this.bridge.attestDatabaseTenant(params, optionsArg),
-    );
-  }
-
-  /**
-   * Delete a tenant database and its tenant user(s).
-   */
-  async deleteDatabaseTenant(
-    params: INoSqlDbDeleteDatabaseTenantInput,
-    optionsArg?: INoSqlDbManagementOperationOptions,
-  ): Promise<INoSqlDbDeleteDatabaseTenantResult> {
-    return this.runDatabaseManagementOperation(
-      () => this.bridge.deleteDatabaseTenant(params, optionsArg),
-    );
-  }
-
-  /** Issue one fixed-expiry read grant bound to an exact active allocation. */
-  async issueDatabaseAllocationReadAccessGrant(
-    params: INoSqlDbIssueDatabaseAllocationReadAccessGrantInput,
-    optionsArg?: INoSqlDbManagementOperationOptions,
-  ): Promise<INoSqlDbIssueDatabaseAllocationReadAccessGrantResult> {
-    const descriptor = await this.runDatabaseManagementOperation(
-      () => this.bridge.issueDatabaseAllocationReadAccessGrant(params, optionsArg),
-    );
-    return this.withTenantMongoUri(descriptor, params.password);
-  }
-
-  /** Idempotently revoke one allocation read grant without returning a secret. */
-  async revokeDatabaseAllocationReadAccessGrant(
-    params: INoSqlDbRevokeDatabaseAllocationReadAccessGrantInput,
-    optionsArg?: INoSqlDbManagementOperationOptions,
-  ): Promise<INoSqlDbRevokeDatabaseAllocationReadAccessGrantResult> {
-    return this.runDatabaseManagementOperation(
-      () => this.bridge.revokeDatabaseAllocationReadAccessGrant(params, optionsArg),
-    );
-  }
-
-  /**
-   * Rotate a tenant user's password without restarting the server.
-   */
-  async rotateDatabaseTenantPassword(
-    params: INoSqlDbRotateDatabaseTenantPasswordInput,
-  ): Promise<INoSqlDbDatabaseTenantDescriptor> {
-    const descriptor = await this.bridge.rotateDatabaseTenantPassword(params);
-    return this.withTenantMongoUri(descriptor, params.password);
-  }
-
-  /**
-   * List known database tenants.
-   */
-  async listDatabaseTenants(): Promise<INoSqlDbDatabaseTenantDescriptor[]> {
-    return this.bridge.listDatabaseTenants();
-  }
-
-  /**
-   * Get a tenant descriptor without exposing a password.
-   */
-  async getDatabaseTenantDescriptor(params: {
-    databaseName: string;
-    username: string;
-  }): Promise<INoSqlDbDatabaseTenantDescriptor> {
-    return this.bridge.getDatabaseTenantDescriptor(params);
-  }
-
-  /** Inspect the durable high-water mark without exposing mutation receipts. */
-  async getDatabaseResourceFenceState(
-    params: { databaseName: string },
-    optionsArg?: INoSqlDbManagementOperationOptions,
-  ): Promise<INoSqlDbDatabaseResourceFenceState | null> {
-    return this.runDatabaseManagementOperation(
-      () => this.bridge.getDatabaseResourceFenceState(params, optionsArg),
-    );
-  }
-
-  /**
-   * Export one database as an Extended JSON snapshot.
-   */
-  async exportDatabase(
-    params: INoSqlDbExportDatabaseInput,
-    optionsArg?: INoSqlDbManagementOperationOptions,
-  ): Promise<INoSqlDbDatabaseExport> {
-    return this.runDatabaseManagementOperation(
-      () => this.bridge.exportDatabase(params, optionsArg),
-    );
-  }
-
-  /** Read an exact held publication without opening its serving data plane. */
-  async exportHeldDatabase(
-    params: INoSqlDbExportHeldDatabaseInput,
-    optionsArg?: INoSqlDbManagementOperationOptions,
-  ): Promise<INoSqlDbDatabaseExport> {
-    return this.runDatabaseManagementOperation(
-      () => this.bridge.exportHeldDatabase(params, optionsArg),
-    );
-  }
-
-  /** Compute a bounded, database-name-independent digest of logical database content. */
-  async getDatabaseContentDigest(
-    params: INoSqlDbGetDatabaseContentDigestInput,
-    optionsArg?: INoSqlDbManagementOperationOptions,
-  ): Promise<INoSqlDbDatabaseContentDigest> {
-    return this.runDatabaseManagementOperation(
-      () => this.bridge.getDatabaseContentDigest(params, optionsArg),
-    );
-  }
-
-  /**
-   * Replace one database with a previously exported snapshot.
-   */
-  async importDatabase(
-    params: INoSqlDbImportDatabaseInput,
-    optionsArg?: INoSqlDbManagementOperationOptions,
-  ): Promise<INoSqlDbImportDatabaseResult> {
-    return this.runDatabaseManagementOperation(
-      () => this.bridge.importDatabase(params, optionsArg),
-    );
-  }
-
-  /** Release an exact held database publication after downstream fsync. */
-  async commitDatabasePublication(
-    params: INoSqlDbCommitDatabasePublicationInput,
-    optionsArg?: INoSqlDbManagementOperationOptions,
-  ): Promise<TNoSqlDbCommitDatabasePublicationResult> {
-    return this.runDatabaseManagementOperation(
-      () => this.bridge.commitDatabasePublication(params, optionsArg),
-    );
-  }
-
-  /**
-   * Get readiness/health details for long-running service use.
-   */
-  async getHealth(
-    optionsArg?: INoSqlDbManagementOperationOptions,
-  ): Promise<INoSqlDbHealth> {
-    if (!this.isRunning) {
-      return {
-        running: false,
-        storage: this.options.storage,
-        storagePath: this.options.storage === 'file' ? this.options.storagePath : undefined,
-        resourceFencingVersion: this.options.storage === 'file' ? 1 : undefined,
-        resourceFencingSupported: this.options.storage === 'file' ? false : undefined,
-        resourceFencingRequiresDrain: this.options.storage === 'file' ? true : undefined,
-        allocationFencingVersion: this.options.storage === 'file' ? 1 : undefined,
-        allocationFencingSupported: this.options.storage === 'file' ? false : undefined,
-        allocationFencingRequiresDrain: this.options.storage === 'file' ? true : undefined,
-        publicationHoldVersion: 1,
-        publicationHoldSupported: false,
-        publicationHoldRequiresExternalDrain: false,
-        authEnabled: Boolean(this.options.auth?.enabled),
-        authUsers: this.options.auth?.users?.length ?? 0,
-        usersPathConfigured: false,
-        databaseCount: 0,
-        collectionCount: 0,
-      };
-    }
-    return this.runDatabaseManagementOperation(
-      () => this.bridge.getHealth(optionsArg),
-    );
-  }
-
-  // --- OpLog / Debug API ---
-
-  async getCommittedWrites(params: INoSqlDbGetCommittedWritesInput): Promise<INoSqlDbCommittedWritesPage> {
-    return this.runDatabaseManagementOperation(() => this.bridge.getCommittedWrites(params));
-  }
-
-  /**
-   * Get oplog entries, optionally filtered.
-   */
-  async getOpLog(params: {
-    sinceSeq?: number;
-    limit?: number;
-    db?: string;
-    collection?: string;
-  } = {}): Promise<IOpLogResult> {
-    return this.bridge.getOpLog(params);
-  }
-
-  /**
-   * Get aggregate oplog statistics.
-   */
-  async getOpLogStats(): Promise<IOpLogStats> {
-    return this.bridge.getOpLogStats();
-  }
-
-  /**
-   * Revert database state to a specific oplog sequence number.
-   * Use dryRun=true to preview which entries would be reverted.
-   */
-  async revertToSeq(seq: number, dryRun = false): Promise<IRevertResult> {
-    return this.bridge.revertToSeq(seq, dryRun);
-  }
-
-  /**
-   * List all collections across all databases, with document counts.
-   */
-  async getCollections(db?: string): Promise<ICollectionInfo[]> {
-    return this.bridge.getCollections(db);
-  }
-
-  /**
-   * Get documents from a collection with pagination.
-   */
-  async getDocuments(
-    db: string,
-    collection: string,
-    limit = 50,
-    skip = 0,
-  ): Promise<IDocumentsResult> {
-    return this.bridge.getDocuments(db, collection, limit, skip);
-  }
-
-  /**
-   * Get server metrics including database/collection counts and oplog info.
-   */
-  async getMetrics(): Promise<INoSqlDbMetrics> {
-    return this.bridge.getMetrics();
-  }
-
-  private withTenantMongoUri<TDescriptor extends INoSqlDbDatabaseTenantDescriptor>(
-    descriptor: TDescriptor,
-    password: string,
-  ): TDescriptor & { mongodbUri: string } {
-    return {
-      ...descriptor,
-      mongodbUri: this.buildTenantMongoUri(descriptor.databaseName, descriptor.username, password),
-    };
-  }
-
-  private buildTenantMongoUri(databaseName: string, username: string, password: string): string {
-    const host = this.options.socketPath
-      ? encodeURIComponent(this.options.socketPath)
-      : `${this.options.host ?? '127.0.0.1'}:${this.port}`;
-    const auth = `${encodeURIComponent(username)}:${encodeURIComponent(password)}@`;
-    const query = new URLSearchParams({ authSource: databaseName });
-    if (this.options.tls?.enabled) {
-      query.set('tls', 'true');
-    }
-    return `mongodb://${auth}${host}/${encodeURIComponent(databaseName)}?${query.toString()}`;
-  }
-}