@lossless.org/client 0.1.0

package/dist_ts/nosqldb/classes.mongoadministration.d.ts

@@ -0,0 +1,73 @@
+import type { SmartdataDb } from './classes.db.js';
+export interface ISmartdataMongoOperationOptions {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export interface ISmartdataMongoReplicaSetExpectation extends ISmartdataMongoOperationOptions {
+    expectedSetName: string;
+    expectedMemberHost: string;
+}
+export interface ISmartdataMongoReplicaSetMember {
+    host: string;
+    health: number;
+    state: string;
+}
+export type TSmartdataMongoReplicaSetState = 'replication_disabled' | 'uninitialized' | 'exact_primary' | 'exact_non_primary' | 'divergent' | 'unavailable';
+export interface ISmartdataMongoReplicaSetInspection {
+    state: TSmartdataMongoReplicaSetState;
+    durationMs: number;
+    observedSetName?: string;
+    observedMembers?: ISmartdataMongoReplicaSetMember[];
+}
+export interface ISmartdataMongoReplicaSetInitializationResult {
+    status: 'initiated' | 'already_configured';
+    topology: ISmartdataMongoReplicaSetInspection;
+}
+export type TSmartdataMongoTransactionReadinessFailureReason = 'aborted' | 'timeout' | 'unsupported_topology' | 'unavailable' | 'cleanup_failed';
+export type TSmartdataMongoTransactionReadinessResult = {
+    ready: true;
+    status: 'ready';
+    durationMs: number;
+} | {
+    ready: false;
+    status: 'unavailable';
+    reason: TSmartdataMongoTransactionReadinessFailureReason;
+    durationMs: number;
+};
+export interface ISmartdataMongoDatabaseUserOptions extends ISmartdataMongoOperationOptions {
+    expectedDatabaseName: string;
+    username: string;
+    password: string;
+}
+export interface ISmartdataMongoDatabaseUserRemovalOptions extends ISmartdataMongoOperationOptions {
+    expectedDatabaseName: string;
+    username: string;
+}
+export interface ISmartdataMongoDatabaseDropOptions extends ISmartdataMongoOperationOptions {
+    expectedDatabaseName: string;
+    confirmationDatabaseName: string;
+}
+export declare class SmartdataMongoAdministration {
+    private readonly owner;
+    private readonly expectedMongoDb;
+    private readonly expectedMongoDbClient;
+    constructor(ownerArg: SmartdataDb);
+    inspectReplicaSet(optionsArg: ISmartdataMongoReplicaSetExpectation): Promise<ISmartdataMongoReplicaSetInspection>;
+    initializeSingleMemberReplicaSet(optionsArg: ISmartdataMongoReplicaSetExpectation): Promise<ISmartdataMongoReplicaSetInitializationResult>;
+    checkTransactionReadiness(optionsArg?: ISmartdataMongoOperationOptions): Promise<TSmartdataMongoTransactionReadinessResult>;
+    ensureReadWriteDatabaseUser(optionsArg: ISmartdataMongoDatabaseUserOptions): Promise<{
+        status: 'created' | 'updated';
+    }>;
+    removeDatabaseUser(optionsArg: ISmartdataMongoDatabaseUserRemovalOptions): Promise<{
+        removed: boolean;
+    }>;
+    dropDatabase(optionsArg: ISmartdataMongoDatabaseDropOptions): Promise<{
+        dropped: boolean;
+    }>;
+    private getConnectedContext;
+    private contextIsCurrent;
+    private createTopologyResult;
+    private assertDatabaseUserOptions;
+    private runAdministrationCommand;
+    private executeAdministrationCommand;
+}

package/dist_ts/nosqldb/classes.mongoadministration.js

@@ -0,0 +1,497 @@
+import * as plugins from './plugins.js';
+import { SmartdataPersistenceError } from './classes.persistence.js';
+const mongoAdministrationDefaultTimeoutMs = 5_000;
+const mongoAdministrationMaximumTimeoutMs = 30_000;
+const transactionCapabilityCollectionName = '__smartdata_transaction_capability';
+const replicaSetNameRegex = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const replicaSetMemberRegex = /^([A-Za-z0-9][A-Za-z0-9.-]{0,252}):([0-9]{1,5})$/;
+const databaseNameRegex = /^[^/\\.\s"$*<>:|?\u0000]{1,63}$/;
+const databaseUsernameRegex = /^[^\u0000\r\n]{1,128}$/;
+const assertExactDataObject = (valueArg, expectedKeysArg, descriptionArg) => {
+    if (valueArg === null
+        || typeof valueArg !== 'object'
+        || Array.isArray(valueArg)
+        || Object.getPrototypeOf(valueArg) !== Object.prototype) {
+        throw new SmartdataPersistenceError('invalid_argument', `${descriptionArg} must be a plain object.`);
+    }
+    const keys = Reflect.ownKeys(valueArg);
+    if (keys.some((keyArg) => (typeof keyArg !== 'string' || !expectedKeysArg.includes(keyArg)))) {
+        throw new SmartdataPersistenceError('invalid_argument', `${descriptionArg} has an invalid shape.`);
+    }
+    for (const key of keys) {
+        const descriptor = Object.getOwnPropertyDescriptor(valueArg, key);
+        if (!descriptor || !('value' in descriptor)) {
+            throw new SmartdataPersistenceError('invalid_argument', `${descriptionArg} must contain data properties only.`);
+        }
+    }
+    return valueArg;
+};
+const isAbortSignal = (valueArg) => (valueArg !== null
+    && typeof valueArg === 'object'
+    && typeof valueArg.aborted === 'boolean'
+    && typeof valueArg.addEventListener === 'function');
+const assertOperationOptions = (optionsArg) => {
+    const timeoutMs = optionsArg.timeoutMs ?? mongoAdministrationDefaultTimeoutMs;
+    if (!Number.isSafeInteger(timeoutMs)
+        || timeoutMs <= 0
+        || timeoutMs > mongoAdministrationMaximumTimeoutMs) {
+        throw new SmartdataPersistenceError('invalid_argument', `Mongo administration timeoutMs must be a positive safe integer no greater than ${mongoAdministrationMaximumTimeoutMs}.`);
+    }
+    if (optionsArg.signal !== undefined && !isAbortSignal(optionsArg.signal)) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Mongo administration signal must be an AbortSignal.');
+    }
+    return {
+        timeoutMs: timeoutMs,
+        signal: optionsArg.signal,
+    };
+};
+const assertReplicaSetExpectation = (optionsArg) => {
+    const options = assertExactDataObject(optionsArg, ['expectedSetName', 'expectedMemberHost', 'timeoutMs', 'signal'], 'Mongo replica-set expectation');
+    if (typeof options.expectedSetName !== 'string'
+        || !replicaSetNameRegex.test(options.expectedSetName)) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Mongo expectedSetName must be a canonical replica-set name.');
+    }
+    if (typeof options.expectedMemberHost !== 'string') {
+        throw new SmartdataPersistenceError('invalid_argument', 'Mongo expectedMemberHost must be a canonical hostname and port.');
+    }
+    const memberMatch = replicaSetMemberRegex.exec(options.expectedMemberHost);
+    const port = memberMatch ? Number(memberMatch[2]) : 0;
+    if (!memberMatch || port < 1 || port > 65_535) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Mongo expectedMemberHost must be a canonical hostname and port.');
+    }
+    return {
+        expectedSetName: options.expectedSetName,
+        expectedMemberHost: options.expectedMemberHost,
+        ...assertOperationOptions(options),
+    };
+};
+const isMongoServerError = (errorArg, codeArg, codeNameArg) => errorArg instanceof plugins.mongodb.MongoServerError
+    && (errorArg.code === codeArg || errorArg.codeName === codeNameArg);
+const isMongoTimeoutError = (errorArg) => (errorArg instanceof plugins.mongodb.MongoOperationTimeoutError);
+const isUnsupportedTransactionTopologyError = (errorArg) => (isMongoServerError(errorArg, 20, 'IllegalOperation')
+    || isMongoServerError(errorArg, 263, 'OperationNotSupportedInTransaction'));
+const isUserAlreadyExistsError = (errorArg) => (isMongoServerError(errorArg, 51_003, 'UserAlreadyExists')
+    || isMongoServerError(errorArg, 51_003, 'Location51003'));
+const isUserNotFoundError = (errorArg) => (isMongoServerError(errorArg, 11, 'UserNotFound'));
+export class SmartdataMongoAdministration {
+    owner;
+    expectedMongoDb;
+    expectedMongoDbClient;
+    constructor(ownerArg) {
+        if (ownerArg.status !== 'connected'
+            || !ownerArg.mongoDb
+            || !ownerArg.mongoDbClient
+            || ownerArg.mongoDb.client !== ownerArg.mongoDbClient) {
+            throw new SmartdataPersistenceError('unsupported_operation', 'Mongo administration requires a connected SmartData database.');
+        }
+        this.owner = ownerArg;
+        this.expectedMongoDb = ownerArg.mongoDb;
+        this.expectedMongoDbClient = ownerArg.mongoDbClient;
+    }
+    async inspectReplicaSet(optionsArg) {
+        const options = assertReplicaSetExpectation(optionsArg);
+        const startedAt = performance.now();
+        const context = this.getConnectedContext();
+        if (options.signal?.aborted) {
+            return {
+                state: 'unavailable',
+                durationMs: performance.now() - startedAt,
+            };
+        }
+        let status;
+        try {
+            status = await context.mongoDb.admin().command({ replSetGetStatus: 1 }, {
+                timeoutMS: options.timeoutMs,
+                signal: options.signal,
+            });
+        }
+        catch (errorArg) {
+            if (!this.contextIsCurrent(context)) {
+                return this.createTopologyResult('unavailable', startedAt);
+            }
+            if (isMongoServerError(errorArg, 76, 'NoReplicationEnabled')) {
+                return this.createTopologyResult('replication_disabled', startedAt);
+            }
+            if (isMongoServerError(errorArg, 94, 'NotYetInitialized')) {
+                return this.createTopologyResult('uninitialized', startedAt);
+            }
+            return this.createTopologyResult('unavailable', startedAt);
+        }
+        if (!this.contextIsCurrent(context)) {
+            return this.createTopologyResult('unavailable', startedAt);
+        }
+        const observedSetName = typeof status.set === 'string' ? status.set : undefined;
+        const rawMembers = Array.isArray(status.members) ? status.members : [];
+        const observedMembers = [];
+        let membersWellFormed = Array.isArray(status.members);
+        for (const memberArg of rawMembers) {
+            if (!memberArg || typeof memberArg !== 'object' || Array.isArray(memberArg)) {
+                membersWellFormed = false;
+                continue;
+            }
+            const member = memberArg;
+            if (typeof member.name !== 'string'
+                || typeof member.stateStr !== 'string'
+                || typeof member.health !== 'number'
+                || !Number.isFinite(member.health)) {
+                membersWellFormed = false;
+                continue;
+            }
+            observedMembers.push({
+                host: member.name,
+                health: member.health,
+                state: member.stateStr,
+            });
+        }
+        const exactConfiguration = membersWellFormed
+            && rawMembers.length === observedMembers.length
+            && observedSetName === options.expectedSetName
+            && observedMembers.length === 1
+            && observedMembers[0].host === options.expectedMemberHost;
+        if (!exactConfiguration) {
+            return {
+                state: 'divergent',
+                observedSetName,
+                observedMembers,
+                durationMs: performance.now() - startedAt,
+            };
+        }
+        const exactPrimary = status.myState === 1
+            && observedMembers[0].state === 'PRIMARY'
+            && observedMembers[0].health === 1;
+        return {
+            state: exactPrimary ? 'exact_primary' : 'exact_non_primary',
+            observedSetName,
+            observedMembers,
+            durationMs: performance.now() - startedAt,
+        };
+    }
+    async initializeSingleMemberReplicaSet(optionsArg) {
+        const options = assertReplicaSetExpectation(optionsArg);
+        const topology = await this.inspectReplicaSet(options);
+        if (topology.state === 'exact_primary' || topology.state === 'exact_non_primary') {
+            return {
+                status: 'already_configured',
+                topology,
+            };
+        }
+        if (topology.state === 'divergent') {
+            throw new SmartdataPersistenceError('invalid_configuration', 'Mongo replica-set configuration differs from the exact expected topology.');
+        }
+        if (topology.state === 'replication_disabled') {
+            throw new SmartdataPersistenceError('invalid_configuration', 'Mongo replication must be enabled before replica-set initialization.');
+        }
+        if (topology.state !== 'uninitialized') {
+            throw new SmartdataPersistenceError('unsupported_operation', 'Mongo replica-set topology is unavailable for initialization.');
+        }
+        const context = this.getConnectedContext();
+        let initializationStatus = 'initiated';
+        try {
+            const response = await context.mongoDb.admin().command({
+                replSetInitiate: {
+                    _id: options.expectedSetName,
+                    members: [{
+                            _id: 0,
+                            host: options.expectedMemberHost,
+                        }],
+                },
+            }, {
+                timeoutMS: options.timeoutMs,
+                signal: options.signal,
+            });
+            if (response.ok !== 1 || !this.contextIsCurrent(context)) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'Mongo did not acknowledge replica-set initialization.');
+            }
+        }
+        catch (errorArg) {
+            if (isMongoServerError(errorArg, 23, 'AlreadyInitialized')) {
+                initializationStatus = 'already_configured';
+            }
+            else {
+                if (errorArg instanceof SmartdataPersistenceError)
+                    throw errorArg;
+                throw new SmartdataPersistenceError('unsupported_operation', 'Mongo replica-set initialization failed.');
+            }
+        }
+        const initializedTopology = await this.inspectReplicaSet(options);
+        if (initializedTopology.state === 'divergent') {
+            throw new SmartdataPersistenceError('invalid_configuration', 'Mongo initialized a replica-set topology that differs from the expectation.');
+        }
+        if (initializedTopology.state !== 'exact_primary'
+            && initializedTopology.state !== 'exact_non_primary') {
+            throw new SmartdataPersistenceError('unsupported_operation', 'Mongo replica-set initialization could not prove the exact expected topology.');
+        }
+        return {
+            status: initializationStatus,
+            topology: initializedTopology,
+        };
+    }
+    async checkTransactionReadiness(optionsArg = {}) {
+        const options = assertExactDataObject(optionsArg, ['timeoutMs', 'signal'], 'Mongo transaction-readiness options');
+        const boundedOptions = assertOperationOptions(options);
+        const startedAt = performance.now();
+        const context = this.getConnectedContext();
+        const probeId = globalThis.crypto.randomUUID();
+        const collection = context.mongoDb.collection(transactionCapabilityCollectionName);
+        let session;
+        let failure;
+        let cleanupFailed = false;
+        try {
+            try {
+                await context.mongoDb.command({ create: transactionCapabilityCollectionName }, {
+                    timeoutMS: boundedOptions.timeoutMs,
+                    signal: boundedOptions.signal,
+                });
+            }
+            catch (errorArg) {
+                if (!isMongoServerError(errorArg, 48, 'NamespaceExists'))
+                    throw errorArg;
+            }
+            session = context.mongoDbClient.startSession();
+            session.startTransaction({
+                readConcern: { level: 'snapshot' },
+                writeConcern: { w: 'majority' },
+            });
+            const insertResponse = await context.mongoDb.command({
+                insert: transactionCapabilityCollectionName,
+                documents: [
+                    { _id: `${probeId}:1`, probeId, part: 1 },
+                    { _id: `${probeId}:2`, probeId, part: 2 },
+                ],
+                ordered: true,
+            }, {
+                session,
+                timeoutMS: boundedOptions.timeoutMs,
+                signal: boundedOptions.signal,
+            });
+            if (insertResponse.ok !== 1 || insertResponse.n !== 2) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'Mongo transaction probe did not acknowledge both writes.');
+            }
+            const abortResponse = await context.mongoDb.admin().command({
+                abortTransaction: 1,
+                writeConcern: {
+                    w: 'majority',
+                    wtimeout: boundedOptions.timeoutMs,
+                },
+            }, {
+                session,
+                timeoutMS: boundedOptions.timeoutMs,
+                signal: boundedOptions.signal,
+            });
+            if (abortResponse.ok !== 1 || !this.contextIsCurrent(context)) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'Mongo transaction probe did not acknowledge its abort.');
+            }
+            // The acknowledged raw command proves the server-side abort. Calling the
+            // public driver method afterwards advances its local transaction state;
+            // that method intentionally ignores most server-side abort errors.
+            await session.abortTransaction({ timeoutMS: boundedOptions.timeoutMs });
+            const remainingCount = await collection.countDocuments({ probeId }, {
+                limit: 2,
+                timeoutMS: boundedOptions.timeoutMs,
+                signal: boundedOptions.signal,
+            });
+            if (remainingCount !== 0 || !this.contextIsCurrent(context)) {
+                cleanupFailed = remainingCount !== 0;
+                throw new SmartdataPersistenceError('unsupported_operation', 'Mongo transaction probe did not abort cleanly.');
+            }
+            return {
+                ready: true,
+                status: 'ready',
+                durationMs: performance.now() - startedAt,
+            };
+        }
+        catch (errorArg) {
+            failure = errorArg;
+            if (session?.inTransaction()) {
+                try {
+                    await session.abortTransaction({ timeoutMS: boundedOptions.timeoutMs });
+                }
+                catch {
+                    cleanupFailed = true;
+                }
+            }
+            try {
+                await collection.deleteMany({ probeId }, { timeoutMS: boundedOptions.timeoutMs });
+            }
+            catch {
+                cleanupFailed = true;
+            }
+        }
+        finally {
+            await session?.endSession().catch(() => undefined);
+        }
+        let reason;
+        if (cleanupFailed) {
+            reason = 'cleanup_failed';
+        }
+        else if (boundedOptions.signal?.aborted) {
+            reason = 'aborted';
+        }
+        else if (isMongoTimeoutError(failure)) {
+            reason = 'timeout';
+        }
+        else if (isUnsupportedTransactionTopologyError(failure)) {
+            reason = 'unsupported_topology';
+        }
+        else {
+            reason = 'unavailable';
+        }
+        return {
+            ready: false,
+            status: 'unavailable',
+            reason,
+            durationMs: performance.now() - startedAt,
+        };
+    }
+    async ensureReadWriteDatabaseUser(optionsArg) {
+        const options = this.assertDatabaseUserOptions(optionsArg, true);
+        const context = this.getConnectedContext(options.expectedDatabaseName);
+        const usersInfo = await this.runAdministrationCommand(context, {
+            usersInfo: {
+                user: options.username,
+                db: options.expectedDatabaseName,
+            },
+        }, options, 'Mongo database-user inspection failed.');
+        if (!Array.isArray(usersInfo.users) || usersInfo.users.length > 1) {
+            throw new SmartdataPersistenceError('unsupported_operation', 'Mongo database-user inspection returned an invalid result.');
+        }
+        const updateCommand = {
+            updateUser: options.username,
+            pwd: options.password,
+            roles: [{ role: 'readWrite', db: options.expectedDatabaseName }],
+        };
+        if (usersInfo.users.length === 1) {
+            await this.runAdministrationCommand(context, updateCommand, options, 'Mongo database-user reconciliation failed.');
+            return { status: 'updated' };
+        }
+        try {
+            await this.executeAdministrationCommand(context, {
+                createUser: options.username,
+                pwd: options.password,
+                roles: [{ role: 'readWrite', db: options.expectedDatabaseName }],
+            }, options);
+            return { status: 'created' };
+        }
+        catch (errorArg) {
+            if (!isUserAlreadyExistsError(errorArg)) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'Mongo database-user reconciliation failed.');
+            }
+        }
+        await this.runAdministrationCommand(context, updateCommand, options, 'Mongo database-user reconciliation failed.');
+        return { status: 'updated' };
+    }
+    async removeDatabaseUser(optionsArg) {
+        const options = this.assertDatabaseUserOptions(optionsArg, false);
+        const context = this.getConnectedContext(options.expectedDatabaseName);
+        const usersInfo = await this.runAdministrationCommand(context, {
+            usersInfo: {
+                user: options.username,
+                db: options.expectedDatabaseName,
+            },
+        }, options, 'Mongo database-user inspection failed.');
+        if (!Array.isArray(usersInfo.users) || usersInfo.users.length > 1) {
+            throw new SmartdataPersistenceError('unsupported_operation', 'Mongo database-user inspection returned an invalid result.');
+        }
+        if (usersInfo.users.length === 0)
+            return { removed: false };
+        try {
+            await this.executeAdministrationCommand(context, { dropUser: options.username }, options);
+        }
+        catch (errorArg) {
+            if (isUserNotFoundError(errorArg))
+                return { removed: false };
+            throw new SmartdataPersistenceError('unsupported_operation', 'Mongo database-user removal failed.');
+        }
+        return { removed: true };
+    }
+    async dropDatabase(optionsArg) {
+        const options = assertExactDataObject(optionsArg, ['expectedDatabaseName', 'confirmationDatabaseName', 'timeoutMs', 'signal'], 'Mongo database-drop options');
+        if (typeof options.expectedDatabaseName !== 'string'
+            || !databaseNameRegex.test(options.expectedDatabaseName)) {
+            throw new SmartdataPersistenceError('invalid_argument', 'Mongo expectedDatabaseName must be a canonical database name.');
+        }
+        if (options.confirmationDatabaseName !== options.expectedDatabaseName
+            || ['admin', 'config', 'local'].includes(options.expectedDatabaseName)) {
+            throw new SmartdataPersistenceError('invalid_argument', 'Mongo database-drop confirmation must exactly match a non-system database.');
+        }
+        const context = this.getConnectedContext(options.expectedDatabaseName);
+        await this.runAdministrationCommand(context, { dropDatabase: 1 }, assertOperationOptions(options), 'Mongo database removal failed.');
+        return { dropped: true };
+    }
+    getConnectedContext(expectedDatabaseNameArg) {
+        if (this.owner.status !== 'connected'
+            || !this.owner.mongoDb
+            || !this.owner.mongoDbClient
+            || this.owner.mongoDb.client !== this.owner.mongoDbClient
+            || this.owner.mongoDb !== this.expectedMongoDb
+            || this.owner.mongoDbClient !== this.expectedMongoDbClient) {
+            throw new SmartdataPersistenceError('unsupported_operation', 'Mongo administration requires a connected SmartData database.');
+        }
+        if (expectedDatabaseNameArg !== undefined
+            && (this.owner.mongoDb.databaseName !== expectedDatabaseNameArg
+                || this.owner.smartdataOptions.mongoDbName !== expectedDatabaseNameArg)) {
+            throw new SmartdataPersistenceError('invalid_configuration', 'Mongo expectedDatabaseName does not match the connected database.');
+        }
+        return {
+            mongoDb: this.owner.mongoDb,
+            mongoDbClient: this.owner.mongoDbClient,
+        };
+    }
+    contextIsCurrent(contextArg) {
+        return this.owner.status === 'connected'
+            && this.owner.mongoDb === contextArg.mongoDb
+            && this.owner.mongoDbClient === contextArg.mongoDbClient;
+    }
+    createTopologyResult(stateArg, startedAtArg) {
+        return {
+            state: stateArg,
+            durationMs: performance.now() - startedAtArg,
+        };
+    }
+    assertDatabaseUserOptions(optionsArg, hasPasswordArg) {
+        const allowedKeys = hasPasswordArg
+            ? ['expectedDatabaseName', 'username', 'password', 'timeoutMs', 'signal']
+            : ['expectedDatabaseName', 'username', 'timeoutMs', 'signal'];
+        const options = assertExactDataObject(optionsArg, allowedKeys, 'Mongo database-user options');
+        if (typeof options.expectedDatabaseName !== 'string'
+            || !databaseNameRegex.test(options.expectedDatabaseName)) {
+            throw new SmartdataPersistenceError('invalid_argument', 'Mongo expectedDatabaseName must be a canonical database name.');
+        }
+        if (typeof options.username !== 'string'
+            || !databaseUsernameRegex.test(options.username)) {
+            throw new SmartdataPersistenceError('invalid_argument', 'Mongo database username must be a bounded string without control characters.');
+        }
+        if (hasPasswordArg
+            && (typeof options.password !== 'string'
+                || options.password.length < 16
+                || options.password.length > 1024
+                || /[\u0000\r\n]/.test(options.password))) {
+            throw new SmartdataPersistenceError('invalid_argument', 'Mongo database-user password must be a bounded nonempty secret without control characters.');
+        }
+        return {
+            expectedDatabaseName: options.expectedDatabaseName,
+            username: options.username,
+            password: (hasPasswordArg ? options.password : undefined),
+            ...assertOperationOptions(options),
+        };
+    }
+    async runAdministrationCommand(contextArg, commandArg, optionsArg, failureMessageArg) {
+        try {
+            return await this.executeAdministrationCommand(contextArg, commandArg, optionsArg);
+        }
+        catch {
+            throw new SmartdataPersistenceError('unsupported_operation', failureMessageArg);
+        }
+    }
+    async executeAdministrationCommand(contextArg, commandArg, optionsArg) {
+        const response = await contextArg.mongoDb.command(commandArg, {
+            timeoutMS: optionsArg.timeoutMs,
+            signal: optionsArg.signal,
+        });
+        if (response.ok !== 1 || !this.contextIsCurrent(contextArg)) {
+            throw new Error('Mongo administration acknowledgement was unavailable.');
+        }
+        return response;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.mongoadministration.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.mongoadministration.ts"],"names":[],"mappings":"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"}

package/dist_ts/nosqldb/classes.namespaceinspection.d.ts

@@ -0,0 +1,42 @@
+import * as plugins from './plugins.js';
+import type { SmartdataDb } from './classes.db.js';
+import { SmartdataSession } from './classes.session.js';
+import { type ISmartdataCollectionTopologyIndex, type TSmartdataCollectionTopologyReasonCode } from './classes.collectiontopology.js';
+export interface ISmartdataNamespaceInspectionOptions {
+    /** Default 256, maximum 1024. Overflow fails the entire observation. */
+    maxCollections?: number;
+    /** Default bounded. Exact counts scan the collection within the shared deadline. */
+    documentCountMode?: 'bounded' | 'exact';
+    /** Default 1, maximum 10000. Read one additional document to detect overflow. */
+    documentCountUpTo?: number;
+    /** Cumulative deadline. Default 5000ms, maximum 120000ms. */
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    /** Owned session for sequential observation; active transactions are unsupported. */
+    session?: SmartdataSession;
+}
+export type TSmartdataObservedDocumentCount = {
+    readonly kind: 'exact';
+    readonly value: number;
+} | {
+    readonly kind: 'at_least';
+    readonly value: number;
+};
+export interface ISmartdataObservedCollection {
+    readonly collectionName: string;
+    readonly namespaceType: 'collection' | 'view' | 'other';
+    readonly reasonCodes: readonly TSmartdataCollectionTopologyReasonCode[];
+    readonly actualIndexes: readonly ISmartdataCollectionTopologyIndex[];
+    readonly documentCount: TSmartdataObservedDocumentCount | null;
+}
+export interface ISmartdataNamespaceInspection {
+    /** Explicitly observational: catalog and data reads are not an atomic snapshot. */
+    readonly consistency: 'observational';
+    readonly collections: readonly ISmartdataObservedCollection[];
+}
+/** @internal Bounded catalog reading shared with collection preparation. */
+export declare const readBoundedInspectionCursor: <T>(cursorArg: plugins.mongodb.AbstractCursor<T>, maximumArg: number, signalArg: AbortSignal, closeOptionsArg?: () => {
+    timeoutMS: number;
+}) => Promise<T[]>;
+/** @internal Entry point exposed through SmartdataDb.inspectNamespace(). */
+export declare const inspectSmartdataNamespace: (dbArg: SmartdataDb, opts?: ISmartdataNamespaceInspectionOptions) => Promise<ISmartdataNamespaceInspection>;