Background: I have an account called "lavertg", and a database so called "lavertg" (and the account is configured to have read/write to only that database) that I connected to using this connection string:

mongosh "mongodb+srv://omitted/lavertg" --username lavertg --password omitted

 

On Mac/Linux, the "db" command shows the current database:

> db
lavertg

 

On Windows mongosh, it shows pages of information:

> db
Database {
mongo: Mongo {
internalState: ShellInternalState {
initialServiceProvider: CliServiceProvider {
mongoClient: MongoClient

{ _events: [Object: null prototype] \{ newListener: [Function] }

,
_eventsCount: 1,
_maxListeners: undefined,
s: {
url: 'mongodb+srv://omitted/lavertg',
options:

{ servers: [Array], authSource: 'admin', replicaSet: 'atlas-5nj3bs-shard-0', ssl: true, caseTranslate: true, useNewUrlParser: true, useUnifiedTopology: true, appname: 'mongosh 0.0.5', auth: [Object], retryWrites: false, tls: false, tlsAllowInvalidCertificates: false, tlsAllowInvalidHostnames: false, checkServerIdentity: true, sslValidate: true, dbName: 'lavertg', srvHost: 'omitted', password: 'omitted', user: 'lavertg', socketTimeoutMS: 360000, connectTimeoutMS: 10000, useRecoveryToken: true, readPreference: [ReadPreference], credentials: [MongoCredentials], promiseLibrary: [Function: Promise] }

,
promiseLibrary: [Function: Promise],
dbCache: Map { 'admin' => [Db] },
sessions: Set {},
writeConcern: undefined,
namespace: MongoDBNamespace { db: 'admin', collection: undefined }
},
topology: NativeTopology {
_events: [Object: null prototype]

{ topologyDescriptionChanged: [Array], authenticated: [Function], error: [Array], timeout: [Array], close: [Array], parseError: [Array], fullsetup: [Array], all: [Array], reconnect: [Array], commandStarted: [Function], commandSucceeded: [Function], commandFailed: [Function], serverOpening: [Function], serverClosed: [Function], serverDescriptionChanged: [Function], serverHeartbeatStarted: [Function], serverHeartbeatSucceeded: [Function], serverHeartbeatFailed: [Function], topologyOpening: [Function], topologyClosed: [Function], joined: [Function], left: [Function], ping: [Function], ha: [Function], connectionPoolCreated: [Function], connectionPoolClosed: [Function], connectionCreated: [Function], connectionReady: [Function], connectionClosed: [Function], connectionCheckOutStarted: [Function], connectionCheckOutFailed: [Function], connectionCheckedOut: [Function], connectionCheckedIn: [Function], connectionPoolCleared: [Function], open: [Array] }

,
_eventsCount: 35,
_maxListeners: Infinity,
s: {
id: 0,
options: [Object],
seedlist: [Array],
state: 'connected',
description: [TopologyDescription],
serverSelectionTimeoutMS: 30000,
heartbeatFrequencyMS: 10000,
minHeartbeatFrequencyMS: 500,
Cursor: [Function: Cursor],
bson: BSON {},
servers: [Map],
sessionPool: [ServerSessionPool],
sessions: Set {},
promiseLibrary: [Function: Promise],
credentials: [MongoCredentials],
clusterTime: [Object],
connectionTimers: Set {},
srvPoller: [SrvPoller],
detectTopologyDescriptionChange: [Function]
},
[Symbol(kCapture)]: false,
[Symbol(waitQueue)]: Denque

{ _head: 3, _tail: 3, _capacityMask: 3, _list: [Array] }

},
[Symbol(kCapture)]: false
},
uri: 'mongodb+srv://omitted/lavertg',
platform: 2,
initialDb: 'lavertg'
},
messageBus: Nanobus {
_name: 'mongosh',
_starListeners: [],
_listeners:

{ 'mongosh:connect': [ [Function] ], 'mongosh:new-user': [ [Function] ], 'mongosh:update-user': [ [Function] ], 'mongosh:error': [ [Function] ], 'mongosh:help': [ [Function] ], 'mongosh:rewritten-async-input': [ [Function] ], 'mongosh:use': [ [Function] ], 'mongosh:show': [ [Function] ], 'mongosh:setCtx': [ [Function] ], 'mongosh:api-call': [ [Function] ] }

},
asyncWriter: AsyncWriter {
symbols: SymbolTable {
signatures: {
unknown: { type: 'unknown', attributes: {} },
CommandResult: {
type: 'CommandResult',
hasAsyncChild: false,
returnsPromise: false,
attributes: {}
},
BulkWriteResult: {
type: 'BulkWriteResult',
hasAsyncChild: false,
returnsPromise: false,
attributes: {}
},
InsertManyResult: {
type: 'InsertManyResult',
hasAsyncChild: false,
returnsPromise: false,
attributes: {}
},
InsertOneResult: {
type: 'InsertOneResult',
hasAsyncChild: false,
returnsPromise: false,
attributes: {}
},
UpdateResult: {
type: 'UpdateResult',
hasAsyncChild: false,
returnsPromise: false,
attributes: {}
},
DeleteResult: {
type: 'DeleteResult',
hasAsyncChild: false,
returnsPromise: false,
attributes: {}
},
CursorIterationResult: {
type: 'CursorIterationResult',
hasAsyncChild: false,
returnsPromise: false,
attributes: {}
},
AggregationCursor:

{ type: 'AggregationCursor', hasAsyncChild: true, returnsPromise: false, attributes: [Object] }

,
Collection:

{ type: 'Collection', hasAsyncChild: true, returnsPromise: false, attributes: [Object] }

,
Cursor:

{ type: 'Cursor', hasAsyncChild: true, returnsPromise: false, attributes: [Object] }

,
Database:

{ type: 'Database', hasAsyncChild: true, returnsPromise: false, attributes: [Object] }

,
ExplainableCursor:

{ type: 'ExplainableCursor', hasAsyncChild: true, returnsPromise: false, attributes: [Object] }

,
Explainable:

{ type: 'Explainable', hasAsyncChild: true, returnsPromise: false, attributes: [Object] }

,
Shard: {
type: 'Shard',
hasAsyncChild: true,
returnsPromise: false,
attributes: {}
},
ReplicaSet: {
type: 'ReplicaSet',
hasAsyncChild: true,
returnsPromise: false,
attributes: {}
},
Mongo:

{ type: 'Mongo', hasAsyncChild: true, returnsPromise: true, attributes: [Object] }

,
ShellApi:

{ type: 'ShellApi', hasAsyncChild: true, returnsPromise: false, attributes: [Object] }

},
scopeStack: [

{ CommandResult: [Object], BulkWriteResult: [Object], InsertManyResult: [Object], InsertOneResult: [Object], UpdateResult: [Object], DeleteResult: [Object], CursorIterationResult: [Object], AggregationCursor: [Object], Collection: [Object], Cursor: [Object], Database: [Object], ExplainableCursor: [Object], Explainable: [Object], Shard: [Object], ReplicaSet: [Object], Mongo: [Object], ShellApi: [Object], db: [Object], rs: [Object], sh: [Object], use: [Object], show: [Object], exit: [Object], connect: [Object], it: [Object] }

,
{}
],
savedState: [

{ CommandResult: [Object], BulkWriteResult: [Object], InsertManyResult: [Object], InsertOneResult: [Object], UpdateResult: [Object], DeleteResult: [Object], CursorIterationResult: [Object], AggregationCursor: [Object], Collection: [Object], Cursor: [Object], Database: [Object], ExplainableCursor: [Object], Explainable: [Object], Shard: [Object], ReplicaSet: [Object], Mongo: [Object], ShellApi: [Object], db: [Object], rs: [Object], sh: [Object], use: [Object], show: [Object], exit: [Object], connect: [Object], it: [Object] }

,
{}
]
},
plugin: [Function]
},
shellApi: ShellApi { internalState: [Circular] },
mongos: [ [Circular] ],
connectionInfo: {
buildInfo: {
version: '4.2.6',
gitVersion: '20364840b8f1af16917e4c23c1b5f5efd8b352f8',
modules: [ 'enterprise' ],
allocator: 'tcmalloc',
javascriptEngine: 'mozjs',
sysInfo: 'deprecated',
versionArray: [ 4, 2, 6, 0 ],
openssl:

{ running: 'OpenSSL 1.0.1e-fips 11 Feb 2013', compiled: 'OpenSSL 1.0.1e-fips 11 Feb 2013' }

,
buildEnvironment:

{ distmod: 'rhel70', distarch: 'x86_64', cc: '/opt/mongodbtoolchain/v3/bin/gcc: gcc (GCC) 8.2.0', ccflags: '-fno-omit-frame-pointer -fno-strict-aliasing -ggdb -pthread -Wall -Wsign-compare -Wno-unknown-pragmas -Winvalid-pch -Werror -O2 -Wno-unused-local-typedefs -Wno-unused-function -Wno-deprecated-declarations -Wno-unused-const-variable -Wno-unused-but-set-variable -Wno-missing-braces -fstack-protector-strong -fno-builtin-memcmp', cxx: '/opt/mongodbtoolchain/v3/bin/g++: g++ (GCC) 8.2.0', cxxflags: '-Woverloaded-virtual -Wno-maybe-uninitialized -fsized-deallocation -std=c++17', linkflags: '-pthread -Wl,-z,now -rdynamic -Wl,--fatal-warnings -fstack-protector-strong -fuse-ld=gold -Wl,--build-id -Wl,--hash-style=gnu -Wl,-z,noexecstack -Wl,--warn-execstack -Wl,-z,relro -Wl,-rpath,/usr/lib64/perl5/CORE', target_arch: 'x86_64', target_os: 'linux' }

,
bits: 64,
debug: false,
maxBsonObjectSize: 16777216,
storageEngines: [
'biggie',
'devnull',
'ephemeralForTest',
'inMemory',
'queryable_wt',
'wiredTiger'
],
ok: 1,
'$clusterTime': {
clusterTime: Timestamp

{ _bsontype: 'Timestamp', low_: 1, high_: 1592334441 }

,
signature: { hash: [Binary], keyId: [Long] }
},
operationTime: Timestamp

{ _bsontype: 'Timestamp', low_: 1, high_: 1592334441 }

},
topology: NativeTopology {
_events: [Object: null prototype]

{ topologyDescriptionChanged: [ [Function], [Function] ], authenticated: [Function], error: [ [Function], [Function: listener], [Function: listener], [Function: listener] ], timeout: [ [Function], [Function: listener], [Function: listener], [Function: listener] ], close: [ [Function], [Function: listener], [Function: listener], [Function: listener] ], parseError: [ [Function], [Function: listener], [Function: listener], [Function: listener] ], fullsetup: [ [Function], [Function], [Function], [Function] ], all: [ [Function], [Function], [Function], [Function] ], reconnect: [ [Function], [Function: listener], [Function: listener], [Function: listener] ], commandStarted: [Function], commandSucceeded: [Function], commandFailed: [Function], serverOpening: [Function], serverClosed: [Function], serverDescriptionChanged: [Function], serverHeartbeatStarted: [Function], serverHeartbeatSucceeded: [Function], serverHeartbeatFailed: [Function], topologyOpening: [Function], topologyClosed: [Function], joined: [Function], left: [Function], ping: [Function], ha: [Function], connectionPoolCreated: [Function], connectionPoolClosed: [Function], connectionCreated: [Function], connectionReady: [Function], connectionClosed: [Function], connectionCheckOutStarted: [Function], connectionCheckOutFailed: [Function], connectionCheckedOut: [Function], connectionCheckedIn: [Function], connectionPoolCleared: [Function], open: [ [Function], [Function], [Function] ] }

,
_eventsCount: 35,
_maxListeners: Infinity,
s: {
id: 0,
options:

{ useUnifiedTopology: true, localThresholdMS: 15, serverSelectionTimeoutMS: 30000, heartbeatFrequencyMS: 10000, minHeartbeatFrequencyMS: 500, cursorFactory: [Function: Cursor], reconnect: false, emitError: true, maxPoolSize: 5, minPoolSize: 0, monitorCommands: false, servers: [Array], authSource: 'admin', setName: 'atlas-5nj3bs-shard-0', ssl: true, caseTranslate: true, useNewUrlParser: true, appname: 'mongosh 0.0.5', auth: [Object], retryWrites: false, tls: false, tlsAllowInvalidCertificates: false, tlsAllowInvalidHostnames: false, checkServerIdentity: true, rejectUnauthorized: true, dbName: 'lavertg', srvHost: 'omitted', password: 'omitted', user: 'lavertg', socketTimeout: 360000, connectionTimeout: 10000, useRecoveryToken: true, readPreference: [ReadPreference], credentials: [MongoCredentials], promiseLibrary: [Function: Promise], metadata: [Object], compression: [Object] }

,
seedlist: [ [Object], [Object], [Object] ],
state: 'connected',
description: TopologyDescription

{ type: 'ReplicaSetWithPrimary', setName: 'atlas-5nj3bs-shard-0', maxSetVersion: 1, maxElectionId: 7fffffff0000000000000002, servers: [Map], stale: false, compatible: true, compatibilityError: null, logicalSessionTimeoutMinutes: 30, heartbeatFrequencyMS: 10000, localThresholdMS: 15, commonWireVersion: 8 }

,
serverSelectionTimeoutMS: 30000,
heartbeatFrequencyMS: 10000,
minHeartbeatFrequencyMS: 500,
Cursor: [Function: Cursor],
bson: BSON {},
servers: Map

{ 'training-shard-00-00.rxlbf.mongodb.net:27017' => [Server], 'training-shard-00-02.rxlbf.mongodb.net:27017' => [Server], 'training-shard-00-01.rxlbf.mongodb.net:27017' => [Server] }

,
sessionPool: ServerSessionPool

{ topology: [Circular], sessions: [Array] }

,
sessions: Set {},
promiseLibrary: [Function: Promise],
credentials: MongoCredentials

{ username: 'lavertg', password: 'omitted', source: 'admin', mechanism: 'scram-sha-1', mechanismProperties: undefined }

,
clusterTime: { clusterTime: [Timestamp], signature: [Object] },
connectionTimers: Set {},
srvPoller: SrvPoller {
_events: [Object: null prototype] {},
_eventsCount: 0,
_maxListeners: undefined,
srvHost: 'omitted',
rescanSrvIntervalMS: 60000,
heartbeatFrequencyMS: 10000,
logger: [Logger],
haMode: false,
generation: 0,
_timeout: null,
[Symbol(kCapture)]: false
},
detectTopologyDescriptionChange: [Function]
},
[Symbol(kCapture)]: false,
[Symbol(waitQueue)]: Denque

{ _head: 3, _tail: 3, _capacityMask: 3, _list: [ undefined, undefined, undefined, undefined ] }

},
extraInfo:

{ is_atlas: true, is_localhost: false, server_version: '4.2.6', server_os: 'linux', server_arch: 'x86_64', is_enterprise: true, auth_type: 'scram-sha-1', is_data_lake: false, dl_version: null, node_version: 'v12.16.1', is_genuine: true, non_genuine_server_name: 'mongodb' }

},
currentDb: [Circular],
currentCursor: null,
context: {
global: [Circular],
clearInterval: [Function: clearInterval],
clearTimeout: [Function: clearTimeout],
setInterval: [Function: setInterval],
setTimeout: [Function: setTimeout]

{ [Symbol(util.promisify.custom)]: [Function] }

,
queueMicrotask: [Function: queueMicrotask],
clearImmediate: [Function: clearImmediate],
setImmediate: [Function: setImmediate]

{ [Symbol(util.promisify.custom)]: [Function] }

,
toIterator: [Function],
print: [Function],
internalState: [Circular],
use: [Function] { help: [Function] Help },
show: [Function] { help: [Function] Help },
exit: [Function] { help: [Function] Help },
Mongo: [Function] { help: [Function] Help },
connect: [Function] { help: [Function] Help },
it: [Function] { help: [Function] Help },
shellApiName: [Function] { help: undefined },
quit: [Function] { help: [Function] Help },
help: [Function] Help,
printjson: [Function],
RegExp: [Function: RegExp],
DBRef: [Function: DBRef],
DBPointer: [Function: DBPointer],
Map: [Function: Map] { Map: [Circular] },
MaxKey: [Function: MaxKey],
MinKey: [Function: MinKey],
ObjectId: [Function: ObjectId],
Symbol: [Function: Symbol],
Timestamp: [Function: Timestamp],
Code: [Function: Code],
NumberDecimal: [Function: NumberDecimal],
NumberInt: [Function: NumberInt],
NumberLong: [Function: NumberLong],
Date: [Function: _a],
ISODate: [Function: ISODate],
BinData: [Function: BinData],
HexData: [Function: HexData],
UUID: [Function: UUID],
MD5: [Function: MD5],
bsonsize: [Function: bsonsize],
rs: ReplicaSet { mongo: [Circular] },
sh: Shard { mongo: [Circular] }
},
cliOptions:

{ _: [ 'mongodb+srv://omitted/lavertg' ], async: false, disableImplicitSessions: false, help: false, h: false, ipv6: false, nodb: false, norc: false, quiet: false, redactInfo: false, retryWrites: false, shell: false, tls: false, tlsAllowInvalidCertificates: false, tlsAllowInvalidHostnames: false, tlsFIPSMode: false, verbose: false, version: false, username: 'lavertg', u: 'lavertg', password: 'omitted', p: 'omitted' }

},
databases: { lavertg: [Circular] },
uri: 'mongodb://localhost/',
options: undefined,
serviceProvider: CliServiceProvider {
mongoClient: MongoClient

{ _events: [Object: null prototype] \{ newListener: [Function] }

,
_eventsCount: 1,
_maxListeners: undefined,
s: {
url: 'mongodb+srv://omitted/lavertg',
options: {
servers: [ [Object], [Object], [Object] ],
authSource: 'admin',
replicaSet: 'atlas-5nj3bs-shard-0',
ssl: true,
caseTranslate: true,
useNewUrlParser: true,
useUnifiedTopology: true,
appname: 'mongosh 0.0.5',
auth:

{ username: 'lavertg', password: 'omitted', db: 'admin', user: 'lavertg' }

,
retryWrites: false,
tls: false,
tlsAllowInvalidCertificates: false,
tlsAllowInvalidHostnames: false,
checkServerIdentity: true,
sslValidate: true,
dbName: 'lavertg',
srvHost: 'omitted',
password: 'omitted',
user: 'lavertg',
socketTimeoutMS: 360000,
connectTimeoutMS: 10000,
useRecoveryToken: true,
readPreference: ReadPreference { mode: 'primary', tags: undefined },
credentials: MongoCredentials

{ username: 'lavertg', password: 'omitted', source: 'admin', mechanism: 'scram-sha-1', mechanismProperties: undefined }

,
promiseLibrary: [Function: Promise]
},
promiseLibrary: [Function: Promise],
dbCache: Map {
'admin' => Db {
_events: [Object: null prototype] {},
_eventsCount: 0,
_maxListeners: undefined,
s: [Object],
serverConfig: [Getter],
bufferMaxEntries: [Getter],
databaseName: [Getter],
[Symbol(kCapture)]: false
}
},
sessions: Set {},
writeConcern: undefined,
namespace: MongoDBNamespace { db: 'admin', collection: undefined }
},
topology: NativeTopology {
_events: [Object: null prototype]

{ topologyDescriptionChanged: [ [Function], [Function] ], authenticated: [Function], error: [ [Function], [Function: listener], [Function: listener], [Function: listener] ], timeout: [ [Function], [Function: listener], [Function: listener], [Function: listener] ], close: [ [Function], [Function: listener], [Function: listener], [Function: listener] ], parseError: [ [Function], [Function: listener], [Function: listener], [Function: listener] ], fullsetup: [ [Function], [Function], [Function], [Function] ], all: [ [Function], [Function], [Function], [Function] ], reconnect: [ [Function], [Function: listener], [Function: listener], [Function: listener] ], commandStarted: [Function], commandSucceeded: [Function], commandFailed: [Function], serverOpening: [Function], serverClosed: [Function], serverDescriptionChanged: [Function], serverHeartbeatStarted: [Function], serverHeartbeatSucceeded: [Function], serverHeartbeatFailed: [Function], topologyOpening: [Function], topologyClosed: [Function], joined: [Function], left: [Function], ping: [Function], ha: [Function], connectionPoolCreated: [Function], connectionPoolClosed: [Function], connectionCreated: [Function], connectionReady: [Function], connectionClosed: [Function], connectionCheckOutStarted: [Function], connectionCheckOutFailed: [Function], connectionCheckedOut: [Function], connectionCheckedIn: [Function], connectionPoolCleared: [Function], open: [ [Function], [Function], [Function] ] }

,
_eventsCount: 35,
_maxListeners: Infinity,
s: {
id: 0,
options:

{ useUnifiedTopology: true, localThresholdMS: 15, serverSelectionTimeoutMS: 30000, heartbeatFrequencyMS: 10000, minHeartbeatFrequencyMS: 500, cursorFactory: [Function: Cursor], reconnect: false, emitError: true, maxPoolSize: 5, minPoolSize: 0, monitorCommands: false, servers: [Array], authSource: 'admin', setName: 'atlas-5nj3bs-shard-0', ssl: true, caseTranslate: true, useNewUrlParser: true, appname: 'mongosh 0.0.5', auth: [Object], retryWrites: false, tls: false, tlsAllowInvalidCertificates: false, tlsAllowInvalidHostnames: false, checkServerIdentity: true, rejectUnauthorized: true, dbName: 'lavertg', srvHost: 'omitted', password: 'omitted', user: 'lavertg', socketTimeout: 360000, connectionTimeout: 10000, useRecoveryToken: true, readPreference: [ReadPreference], credentials: [MongoCredentials], promiseLibrary: [Function: Promise], metadata: [Object], compression: [Object] }

,
seedlist: [ [Object], [Object], [Object] ],
state: 'connected',
description: TopologyDescription

{ type: 'ReplicaSetWithPrimary', setName: 'atlas-5nj3bs-shard-0', maxSetVersion: 1, maxElectionId: 7fffffff0000000000000002, servers: [Map], stale: false, compatible: true, compatibilityError: null, logicalSessionTimeoutMinutes: 30, heartbeatFrequencyMS: 10000, localThresholdMS: 15, commonWireVersion: 8 }

,
serverSelectionTimeoutMS: 30000,
heartbeatFrequencyMS: 10000,
minHeartbeatFrequencyMS: 500,
Cursor: [Function: Cursor],
bson: BSON {},
servers: Map

{ 'training-shard-00-00.rxlbf.mongodb.net:27017' => [Server], 'training-shard-00-02.rxlbf.mongodb.net:27017' => [Server], 'training-shard-00-01.rxlbf.mongodb.net:27017' => [Server] }

,
sessionPool: ServerSessionPool

{ topology: [Circular], sessions: [Array] }

,
sessions: Set {},
promiseLibrary: [Function: Promise],
credentials: MongoCredentials

{ username: 'lavertg', password: 'omitted', source: 'admin', mechanism: 'scram-sha-1', mechanismProperties: undefined }

,
clusterTime: { clusterTime: [Timestamp], signature: [Object] },
connectionTimers: Set {},
srvPoller: SrvPoller {
_events: [Object: null prototype] {},
_eventsCount: 0,
_maxListeners: undefined,
srvHost: 'omitted',
rescanSrvIntervalMS: 60000,
heartbeatFrequencyMS: 10000,
logger: [Logger],
haMode: false,
generation: 0,
_timeout: null,
[Symbol(kCapture)]: false
},
detectTopologyDescriptionChange: [Function]
},
[Symbol(kCapture)]: false,
[Symbol(waitQueue)]: Denque

{ _head: 3, _tail: 3, _capacityMask: 3, _list: [ undefined, undefined, undefined, undefined ] }

},
[Symbol(kCapture)]: false
},
uri: 'mongodb+srv://omitted/lavertg',
platform: 2,
initialDb: 'lavertg'
}
},
name: 'lavertg',
collections: {
then: Collection {
mongo: Mongo {
internalState: ShellInternalState {
initialServiceProvider: CliServiceProvider {
mongoClient: MongoClient

{ _events: [Object: null prototype], _eventsCount: 1, _maxListeners: undefined, s: [Object], topology: [NativeTopology], [Symbol(kCapture)]: false }

,
uri: 'mongodb+srv://omitted/lavertg',
platform: 2,
initialDb: 'lavertg'
},
messageBus: Nanobus {
_name: 'mongosh',
_starListeners: [],
_listeners:

{ 'mongosh:connect': [Array], 'mongosh:new-user': [Array], 'mongosh:update-user': [Array], 'mongosh:error': [Array], 'mongosh:help': [Array], 'mongosh:rewritten-async-input': [Array], 'mongosh:use': [Array], 'mongosh:show': [Array], 'mongosh:setCtx': [Array], 'mongosh:api-call': [Array] }

},
asyncWriter: AsyncWriter {
symbols: SymbolTable

{ signatures: [Object], scopeStack: [Array], savedState: [Array] }

,
plugin: [Function]
},
shellApi: ShellApi { internalState: [Circular] },
mongos: [ [Circular] ],
connectionInfo: {
buildInfo:

{ version: '4.2.6', gitVersion: '20364840b8f1af16917e4c23c1b5f5efd8b352f8', modules: [Array], allocator: 'tcmalloc', javascriptEngine: 'mozjs', sysInfo: 'deprecated', versionArray: [Array], openssl: [Object], buildEnvironment: [Object], bits: 64, debug: false, maxBsonObjectSize: 16777216, storageEngines: [Array], ok: 1, '$clusterTime': [Object], operationTime: [Timestamp] }

,
topology: NativeTopology

{ _events: [Object: null prototype], _eventsCount: 35, _maxListeners: Infinity, s: [Object], [Symbol(kCapture)]: false, [Symbol(waitQueue)]: [Denque] }

,
extraInfo:

{ is_atlas: true, is_localhost: false, server_version: '4.2.6', server_os: 'linux', server_arch: 'x86_64', is_enterprise: true, auth_type: 'scram-sha-1', is_data_lake: false, dl_version: null, node_version: 'v12.16.1', is_genuine: true, non_genuine_server_name: 'mongodb' }

},
currentDb: [Circular],
currentCursor: null,
context: {
global: [Circular],
clearInterval: [Function: clearInterval],
clearTimeout: [Function: clearTimeout],
setInterval: [Function: setInterval],
setTimeout: [Function: setTimeout]

{ [Symbol(util.promisify.custom)]: [Function] }

,
queueMicrotask: [Function: queueMicrotask],
clearImmediate: [Function: clearImmediate],
setImmediate: [Function: setImmediate]

{ [Symbol(util.promisify.custom)]: [Function] }

,
toIterator: [Function],
print: [Function],
internalState: [Circular],
use: [Function] { help: [Function] Help },
show: [Function] { help: [Function] Help },
exit: [Function] { help: [Function] Help },
Mongo: [Function] { help: [Function] Help },
connect: [Function] { help: [Function] Help },
it: [Function] { help: [Function] Help },
shellApiName: [Function] { help: undefined },
quit: [Function] { help: [Function] Help },
help: [Function] Help,
printjson: [Function],
RegExp: [Function: RegExp],
DBRef: [Function: DBRef],
DBPointer: [Function: DBPointer],
Map: [Function: Map] { Map: [Circular] },
MaxKey: [Function: MaxKey],
MinKey: [Function: MinKey],
ObjectId: [Function: ObjectId],
Symbol: [Function: Symbol],
Timestamp: [Function: Timestamp],
Code: [Function: Code],
NumberDecimal: [Function: NumberDecimal],
NumberInt: [Function: NumberInt],
NumberLong: [Function: NumberLong],
Date: [Function: _a],
ISODate: [Function: ISODate],
BinData: [Function: BinData],
HexData: [Function: HexData],
UUID: [Function: UUID],
MD5: [Function: MD5],
bsonsize: [Function: bsonsize],
rs: ReplicaSet { mongo: [Circular] },
sh: Shard { mongo: [Circular] }
},
cliOptions:

{ _: [ 'mongodb+srv://omitted/lavertg' ], async: false, disableImplicitSessions: false, help: false, h: false, ipv6: false, nodb: false, norc: false, quiet: false, redactInfo: false, retryWrites: false, shell: false, tls: false, tlsAllowInvalidCertificates: false, tlsAllowInvalidHostnames: false, tlsFIPSMode: false, verbose: false, version: false, username: 'lavertg', u: 'lavertg', password: 'omitted', p: 'omitted' }

},
databases: { lavertg: [Circular] },
uri: 'mongodb://localhost/',
options: undefined,
serviceProvider: CliServiceProvider {
mongoClient: MongoClient

{ _events: [Object: null prototype] \{ newListener: [Function] }

,
_eventsCount: 1,
_maxListeners: undefined,
s: {
url: 'mongodb+srv://omitted/lavertg',
options: [Object],
promiseLibrary: [Function: Promise],
dbCache: [Map],
sessions: Set {},
writeConcern: undefined,
namespace: [MongoDBNamespace]
},
topology: NativeTopology

{ _events: [Object: null prototype], _eventsCount: 35, _maxListeners: Infinity, s: [Object], [Symbol(kCapture)]: false, [Symbol(waitQueue)]: [Denque] }

,
[Symbol(kCapture)]: false
},
uri: 'mongodb+srv://omitted/lavertg',
platform: 2,
initialDb: 'lavertg'
}
},
database: [Circular],
name: 'then'
}
}
}