The official MongoDB Node.js driver
APACHE-2.0 License
Bot releases are visible (Hide)
Published by github-actions[bot] about 1 month ago
The MongoDB Node.js team is pleased to announce version 6.9.0 of the mongodb
package!
Increased the driver's max supported Wire Protocol version and server version in preparation for the upcoming release of MongoDB 8.0.
[!WARNING]
Support for 3.6 servers is deprecated and will be removed in a future version.
The driver now natively supports explicit resource management for MongoClient
, ClientSession
, ChangeStreams
and cursors. Additionally, on compatible Node.js versions, explicit resource management can be used with cursor.stream()
and the GridFSDownloadStream
, since these classes inherit resource management from Node.js' readable streams.
This feature is experimental and subject to changes at any time. This feature will remain experimental until the proposal has reached stage 4 and Node.js declares its implementation of async disposable resources as stable.
To use explicit resource management with the Node driver, you must:
tslib
polyfills for your applicationSymbol.asyncDispose
(see the TS 5.2 release announcement for more information).Explicit resource management is a feature that ensures that resources' disposal methods are always called when the resources' scope is exited. For driver resources, explicit resource management guarantees that the resources' corresponding close
method is called when the resource goes out of scope.
// before:
{
try {
const client = MongoClient.connect('<uri>');
try {
const session = client.startSession();
const cursor = client.db('my-db').collection("my-collection").find({}, { session });
try {
const doc = await cursor.next();
} finally {
await cursor.close();
}
} finally {
await session.endSession();
}
} finally {
await client.close();
}
}
// with explicit resource management:
{
await using client = MongoClient.connect('<uri>');
await using session = client.startSession();
await using cursor = client.db('my-db').collection('my-collection').find({}, { session });
const doc = await cursor.next();
}
// outside of scope, the cursor, session and mongo client will be cleaned up automatically.
The full explicit resource management proposal can be found here.
For users on Node versions that support the autoSelectFamily
and autoSelectFamilyAttemptTimeout
options (Node 18.13+), they can now be provided to the MongoClient
and will be passed through to socket creation. autoSelectFamily
will default to true
with autoSelectFamilyAttemptTimeout
by default not defined. Example:
const client = new MongoClient(process.env.MONGODB_URI, { autoSelectFamilyAttemptTimeout: 100 });
allowPartialTrustChain
Node.js TLS optionThis option is now exposed through the MongoClient constructor's options parameter and controls the X509_V_FLAG_PARTIAL_CHAIN
OpenSSL flag.
enableUtf8Validation
optionStarting in v6.8.0 we inadvertently removed the ability to disable UTF-8 validation when deserializing BSON. Validation is normally a good thing, but it was always meant to be configurable and the recent Node.js runtime issues (v22.7.0) make this option indispensable for avoiding errors from mistakenly generated invalid UTF-8 bytes.
ConnectionReadyEvent
now has a durationMS
property that represents the time between the connection creation event and when the connection ready event is fired.
ConnectionCheckedOutEvent
/ConnectionCheckFailedEvent
now have a durationMS
property that represents the time between checkout start and success/failure.
Node.js bundles OpenSSL, which means we can access the crypto APIs from C++ directly, avoiding the need to define them in JavaScript and call back into the JS engine to perform encryption. Now, when running the bindings in a version of Node.js that bundles OpenSSL 3 (should correspond to Node.js 18+), the cryptoCallbacks
option will be ignored and C++ defined callbacks will be used instead. This improves the performance of encryption dramatically, as much as 5x faster. ๐
This improvement was made to [email protected] which is available now!
We have added some defensive programming to the options that specify spawn path and spawn arguments for mongocryptd
due to the sensitivity of the system resource they control, namely, launching a process. Now, mongocryptdSpawnPath
and mongocryptdSpawnArgs
must be own properties of autoEncryption.extraOptions
. This makes it more difficult for a global prototype pollution bug related to these options to occur.
Queryable encryption range queries are now officially supported. To use this feature, you must:
[!IMPORTANT]
Collections and documents encrypted with range queryable fields with a 7.0 server are not compatible with range queries on 8.0 servers.
Documentation for queryable encryption can be found in the MongoDB server manual.
insertMany
and bulkWrite
accept ReadonlyArray
inputsThis improves the typescript developer experience, developers tend to use ReadonlyArray
because it can help understand where mutations are made and when enabling noUncheckedIndexedAccess
leads to a better type narrowing experience.
Please note, that the array is read only but not the documents, the driver adds _id
fields to your documents unless you request that the server generate the _id
with forceServerObjectId
Previously, the driver would erroneously retry writes on pre-4.4 sharded clusters based on a nested code in the server response (error.result.writeConcernError.code). Per the common drivers specification, retryability should be based on the top-level code (error.code). With this fix, the driver avoids unnecessary retries.
LocalKMSProviderConfiguration
's key
property accepts Binary
for auto encryptionIn https://github.com/mongodb/node-mongodb-native/pull/4160 we fixed a type issue where a local
KMS provider at runtime accepted a BSON
Binary
instance but the Typescript inaccurately only permitted Buffer
and string
. The same change has now been applied to AutoEncryptionOptions
.
BulkOperationBase
(superclass of UnorderedBulkOperation
and OrderedBulkOperation
) now reports length
property in TypescriptThe length
getter for these classes was defined manually using Object.defineProperty
which hid it from typescript. Thanks to @sis0k0 we now have the getter defined on the class, which is functionally the same, but a greatly improved DX when working with types. ๐
MongoWriteConcernError.code
is overwritten by nested code within MongoWriteConcernError.result.writeConcernError.code
MongoWriteConcernError
is now correctly formed such that the original top-level code is preserved
MongoWriteConcernError.code
should be set to MongoWriteConcernError.result.writeConcernError.code
writeConcernError.code
cursor.toArray()
Prior to this change, toArray()
simply used the cursor's async iterator API, which parses BSON documents lazily (see more here). toArray()
, however, eagerly fetches the entire set of results, pushing each document into the returned array. As such, toArray
does not have the same benefits from lazy parsing as other parts of the cursor API.
With this change, when toArray()
accumulates documents, it empties the current batch of documents into the array before calling the async iterator again, which means each iteration will fetch the next batch rather than wrap each document in a promise. This allows the cursor.toArray()
to avoid the required delays associated with async/await execution, and allows for a performance improvement of up to 5% on average! ๐
Note: This performance optimization does not apply if a transform has been provided to cursor.map()
before toArray
is called.
cursor.next()
and cursor[Symbol.asyncIterator]
In 6.8.0, we inadvertently prevented the use of cursor.next()
along with using for await
syntax to iterate cursors. If your code made use of the following pattern and the call to cursor.next
retrieved all your documents in the first batch, then the for-await loop would never be entered. This issue is now fixed.
const firstDoc = await cursor.next();
for await (const doc of cursor) {
// process doc
// ...
}
mongocryptdSpawnPath
and mongocryptdSpawnArgs
(#4151) (f48f8d3)allowPartialTrustChain
TLS flag (#4228) (d6c147d)error.writeConcern.code
to determine retryability (#4155) (b26c328)We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
Published by github-actions[bot] about 1 month ago
The MongoDB Node.js team is pleased to announce version 6.8.2 of the mongodb
package!
In 6.8.0, we inadvertently prevented the use of cursor.next() along with using for await syntax to iterate cursors. If your code made use of the following pattern and the call to cursor.next retrieved all your documents in the first batch, then the for-await loop would never be entered. This issue is now fixed.
const firstDoc = await cursor.next();
for await (const doc of cursor) {
// process doc
// ...
}
We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
Published by github-actions[bot] about 1 month ago
The MongoDB Node.js team is pleased to announce version 6.8.1 of the mongodb
package!
enableUtf8Validation
optionStarting in v6.8.0 we inadvertently removed the ability to disable UTF-8 validation when deserializing BSON. Validation is normally a good thing, but it was always meant to be configurable and the recent Node.js runtime issues (v22.7.0) make this option indispensable for avoiding errors from mistakenly generated invalid UTF-8 bytes.
We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
Published by github-actions[bot] 4 months ago
The MongoDB Node.js team is pleased to announce version 6.8.0 of the mongodb
package!
ReadConcernMajorityNotAvailableYet
to retryable errorsReadConcernMajorityNotAvailableYet
(error code 134
) is now a retryable read error.
KMS providers can now be associated with a name and multiple keys can be provided per-KMS provider. The following example configures a ClientEncryption object with multiple AWS keys:
const clientEncryption = new ClientEncryption(keyVaultClient, {
'aws:key1': {
accessKeyId: ...,
secretAccessKey: ...
},
'aws:key2': {
accessKeyId: ...,
secretAccessKey: ...
},
clientEncryption.createDataKey('aws:key-1', { ... });
Named KMS providers are supported for azure, AWS, KMIP, local and gcp KMS providers. Named KMS providers cannot be used if the application is using the automatic KMS provider refresh capability.
This feature requires mongodb-client-encryption>=6.0.1.
delegated
optionWhen creating a KMIP data key, delegated
can now be specified. If true, the KMIP provider will perform encryption / decryption of the data key locally, ensuring that the encryption key never leaves the KMIP server.
clientEncryption.createDataKey('kmip', { masterKey: { delegated: true } } );
This feature requires mongodb-client-encryption>=6.0.1.
MongoDB cursors (find, aggregate, etc.) operate on batches of documents equal to batchSize
. Each time the driver runs out of documents for the current batch it gets more (getMore
) and returns each document one at a time through APIs like cursor.next()
or for await (const doc of cursor)
.
Prior to this change, the Node.js driver was designed in such a way that the entire BSON response was decoded after it was received. Parsing BSON, just like parsing JSON, is a synchronous blocking operation. This means that throughout a cursor's lifetime invocations of .next()
that need to fetch a new batch hold up on parsing batchSize
(default 1000) documents before returning to the user.
In an effort to provide more responsiveness, the driver now decodes BSON "on demand". By operating on the layers of data returned by the server, the driver now receives a batch, and only obtains metadata like size, and if there are more documents to iterate after this batch. After that, each document is parsed out of the BSON as the cursor is iterated.
A perfect example of where this comes in handy is our beloved mongosh
! ๐
test> db.test.find()
[
{ _id: ObjectId('665f7fc5c9d5d52227434c65'), ... },
...
]
Type "it" for more
That Type "it" for more
message would now print after parsing only the documents displayed rather than after the entire batch is parsed.
The Github release for the mongodb
package now contains a detached signature file for the NPM package (named
mongodb-X.Y.Z.tgz.sig
), on every major and patch release to 6.x and 5.x. To verify the signature, follow the instructions in the 'Release Integrity' section of the README.md
file.
LocalKMSProviderConfiguration
's key
property accepts Binary
A local
KMS provider at runtime accepted a BSON
Binary
instance but the Typescript inaccurately only permitted Buffer
and string
.
The cursor has a few properties that represent the current state from the perspective of the driver and server. This PR corrects an issue that never made it to a release but we would like to take the opportunity to re-highlight what each of these properties mean.
cursor.closed
- cursor.close()
has been called, and there are no more documents stored in the cursor.cursor.killed
- cursor.close()
was called while the cursor still had a non-zero id, and the driver sent a killCursors command to free server-side resourcescursor.id == null
- The cursor has yet to send it's first command (ex. find
, aggregate
)cursor.id.isZero()
- The server sent the driver a cursor id of 0
indicating a cursor no longer exists on the server side because all data has been returned to the driver.cursor.bufferedCount()
- The amount of documents stored locally in the cursor.Binary
as local KMS provider key (#4160) (fb724eb)We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
Published by github-actions[bot] 5 months ago
The MongoDB Node.js team is pleased to announce version 6.7.0 of the mongodb
package!
MONGODB-OIDC
is now supported as an authentication mechanism for MongoDB server versions 7.0+. The currently supported facets to authenticate with are callback authentication, human interaction callback authentication, Azure machine authentication, and GCP machine authentication.
The MongoClient
must be instantiated with authMechanism=MONGODB-OIDC
in the URI or in the client options. Additional required auth mechanism properties of TOKEN_RESOURCE
and ENVIRONMENT
are required and another optional username can be provided. Example:
const client = new MongoClient('mongodb+srv://<username>@<host>:<port>/?authMechanism=MONGODB-OIDC&authMechanismProperties=TOKEN_RESOURCE:<azure_token>,ENVIRONMENT:azure');
await client.connect();
The MongoClient
must be instantiated with authMechanism=MONGODB-OIDC
in the URI or in the client options. Additional required auth mechanism properties of TOKEN_RESOURCE
and ENVIRONMENT
are required. Example:
const client = new MongoClient('mongodb+srv://<host>:<port>/?authMechanism=MONGODB-OIDC&authMechanismProperties=TOKEN_RESOURCE:<gcp_token>,ENVIRONMENT:gcp');
await client.connect();
The user can provide a custom callback to the MongoClient
that returns a valid response with an access token. The callback is provided as an auth mechanism property an has the signature of:
const oidcCallBack = (params: OIDCCallbackParams): Promise<OIDCResponse> => {
// params.timeoutContext is an AbortSignal that will abort after 30 seconds for non-human and 5 minutes for human.
// params.version is the current OIDC API version.
// params.idpInfo is the IdP info returned from the server.
// params.username is the optional username.
// Make a call to get a token.
const token = ...;
return {
accessToken: token,
expiresInSeconds: 300,
refreshToken: token
};
}
const client = new MongoClient('mongodb+srv://<host>:<port>/?authMechanism=MONGODB-OIDC', {
authMechanismProperties: {
OIDC_CALLBACK: oidcCallback
}
});
await client.connect();
For callbacks that require human interaction, set the callback to the OIDC_HUMAN_CALLBACK
property:
const client = new MongoClient('mongodb+srv://<host>:<port>/?authMechanism=MONGODB-OIDC', {
authMechanismProperties: {
OIDC_HUMAN_CALLBACK: oidcCallback
}
});
await client.connect();
Fixed an issue where when setting useBigInt64
=true
on MongoClients or Dbs an internal function compareTopologyVersion
would throw an error when encountering a bigint value.
We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
The MongoDB Node.js team is pleased to announce version 6.6.2 of the mongodb
package!
Starting in version 6.6.0, when using the stream
server monitoring mode, heartbeats were incorrectly timed as having a duration of 0, leading to server selection viewing each server as equally desirable for selection.
We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
Published by github-actions[bot] 6 months ago
The MongoDB Node.js team is pleased to announce version 6.6.1 of the mongodb
package!
ref()
-ed timer keeps event loop running until client.connect()
resolvesWhen the MongoClient
is first starting up (client.connect()
) monitoring connections begin the process of discovering servers to make them selectable. The ref()
-ed serverSelectionTimeoutMS
timer keeps Node.js' event loop running as the monitoring connections are created. In the last release we inadvertently unref()
-ed this initial timer which would allow Node.js to close before the monitors could create connections.
We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
Published by github-actions[bot] 6 months ago
The MongoDB Node.js team is pleased to announce version 6.6.0 of the mongodb
package!
When creating an aggregation pipeline cursor, a new generic method addStage()
has been added in the fluid API for users to add aggregation pipeline stages in a general manner.
const documents = await users.aggregate().addStage({ $project: { name: true } }).toArray();
Thank you @prenaissance for contributing this feature!
MongoMissingDependencyErrors
MongoMissingDependencyError
s now include a cause
and a dependencyName
field, which can be used to programmatically determine which package is missing and why the driver failed to load it.
For example:
MongoMissingDependencyError: The iHateJavascript module does not exist
at findOne (mongodb/main.js:7:11)
at Object.<anonymous> (mongodb/main.js:14:1)
... 3 lines matching cause stack trace ...
at Module._load (node:internal/modules/cjs/loader:1021:12) {
dependencyName: 'iHateJavascript',
[Symbol(errorLabels)]: Set(0) {},
[cause]: Error: Cannot find module 'iHateJavascript'
Require stack:
- mongodb/main.js
at require (node:internal/modules/helpers:179:18)
at findOne (mongodb/main.js:5:5)
at Object.<anonymous> (mongodb/main.js:14:1) {
code: 'MODULE_NOT_FOUND',
requireStack: [ 'mongodb/main.js' ]
}
}
ServerDescription
Round Trip Time (RTT) measurement changesServerDescription.roundTripTime
is now a moving averagePreviously, ServerDescription.roundTripTime
was calculated as a weighted average of the most recently observed heartbeat duration and the previous duration. This update changes this behaviour to average ServerDescription.roundTripTime
over the last 10 observed heartbeats. This should reduce the likelihood that the selected server changes as a result of momentary spikes in server latency.
minRoundTripTime
to ServerDescription
A new minRoundTripTime
property is now available on the ServerDescription
class which gives the minimum RTT over the last 10 heartbeats. Note that this value will be reported as 0 when fewer than 2 samples have been observed.
type
supported in SearchIndexDescription
It is now possible to specify the type of a search index when creating a search index:
const indexName = await collection.createSearchIndex({
name: 'my-vector-search-index',
// new! specifies that a `vectorSearch` index is created
type: 'vectorSearch',
definition: {
mappings: { dynamic: false }
}
});
Collection.findOneAndModify
's UpdateFilter.$currentDate
no longer throws on collections with limited schemaExample:
// collection has no schema
collection.update(
$currentData: {
lastModified: true
} // no longer throws a TS error
);
TopologyDescription
now properly stringifies itself to JSONThe TopologyDescription
class is exposed by the driver in server selection errors and topology monitoring events to provide insight into the driver's current representation of the server's topology and to aid in debugging. However, the TopologyDescription uses Map
s internally, which get serialized to {}
when JSON stringified. We recommend using Node's util.inspect()
helper to print topology descriptions because inspect
properly handles all JS types and all types we use in the driver. However, if JSON must be used, the TopologyDescription
now provides a custom toJSON()
hook:
client.on('topologyDescriptionChanged', ({ newDescription }) => {
// recommended!
console.log('topology description changed', inspect(newDescription, { depth: Infinity, colors: true }))
// now properly prints the entire topology description
console.log('topology description changed', JSON.stringify(newDescription))
});
readConcern
and writeConcern
in Collection.listSearchIndexes
options argument[!Important]
readConcern
andwriteConcern
are no longer viable keys in the options argument passed intoCollection.listSearchIndexes
This type change is a correctness fix.
Collection.listSearchIndexes
is an Atlas specific method, and Atlas' search indexes do not support readConcern
and writeConcern
options. The types for this function now reflect this functionality.
ReadPreferenceMode
other than 'primary'
The following error will now only be thrown when a user provides a ReadPreferenceMode
other than primary
and then tries to perform a command that involves a read:
new MongoTransactionError('Read preference in a transaction must be primary');
Prior to this change, the Node Driver would incorrectly throw this error even when the operation does not perform a read.
Note: a RunCommandOperation
is treated as a read operation for this error.
TopologyDescription.error
type is MongoError
[!Important]
TheTopologyDescription.error
property type is nowMongoError
rather thanMongoServerError
.
This type change is a correctness fix.
Before this change, the following errors that were not instances of MongoServerError
were already passed into TopologyDescription.error
at runtime:
MongoNetworkError
(excluding MongoNetworkRuntimeError
)MongoError
with a MongoErrorLabel.HandshakeError
labelindexExists()
no longer supports the full
optionThe Collection.indexExists()
helper supported an option, full
, that modified the internals of the method. When full
was set to true
, the driver would always return false
, regardless of whether or not the index exists.
The full
option is intended to modify the return type of index enumeration APIs (Collection.indexes()
and Collection.indexInformation()
, but since the return type of Collection.indexExists()
this option does not make sense for the Collection.indexExists()
helper.
We have removed support for this option.
indexExists()
, indexes()
and indexInformation()
support cursor options in TypescriptThese APIs have supported cursor options at runtime since the 4.x version of the driver, but our Typescript has incorrectly omitted cursor options from these APIs.
Collection.indexInformation()
, Collection.indexes()
and Db.indexInformation()
are helpers that return index information for a given collection or database. These helpers take an option, full
, that configures whether the return value contains full index descriptions or a compact summary:
collection.indexes({ full: true }); // returns an array of index descriptions
collection.indexes({ full: false }); // returns an object, mapping index names to index keys
However, the Typescript return type of these helpers was always Document
. Thanks to @prenaissance, these helpers now have accurate type information! The helpers return a new type, IndexDescriptionCompact | IndexDescriptionInfo[]
, which accurately reflects the return type of these helpers. The helpers also support type narrowing by providing a boolean literal as an option to the API:
collection.indexes(); // returns `IndexDescriptionCompact | IndexDescriptionInfo[]`
collection.indexes({ full: false }); // returns an `IndexDescriptionCompact`
collection.indexes({ full: true }); // returns an `IndexDescriptionInfo[]`
collection.indexInfo(); // returns `IndexDescriptionCompact | IndexDescriptionInfo[]`
collection.indexInfo({ full: false }); // returns an `IndexDescriptionCompact`
collection.indexInfo({ full: true }); // returns an `IndexDescriptionInfo[]`
db.indexInfo(); // returns `IndexDescriptionCompact | IndexDescriptionInfo[]`
db.indexInfo({ full: false }); // returns an `IndexDescriptionCompact`
db.indexInfo({ full: true }); // returns an `IndexDescriptionInfo[]`
In addition to letting users provide KMS credentials manually, client-side encryption supports fetching AWS KMS credentials on-demand using the AWS SDK. However, AWS credential mechanisms that returned access keys with expiration timestamps caused the driver to throw an error.
The driver will no longer throw an error when receiving an expiration token from the AWS SDK.
ClusterTime
interface signature
optionalityThe ClusterTime
interface incorrectly reported the signature
field as required, the server may omit it, so the typescript has been updated to reflect reality.
timeoutMS
and defaultTimeoutMS
(#4068) (ddd1e81)cause
and package name for all MongoMissingDependencyError
s (#4067) (62ea94b)minRoundTripTime
to ServerDescription
and change roundTripTime
to a moving average (#4059) (0e3d6ea)type
option in create search index helpers (#4060) (3598c23)bson
to ^6.5.0 (#4035) (8ab2055)bson
to ^6.7.0 (#4099) (7f191cf)Collection.findOneAndModify
UpdateFilter.$currentDate
(#4047) (a8670a7)ReadPreferenceMode
other than primary
(#4075) (39fc198)v
to createIndexes
command when version
is specified (#4043) (1879a04)TopologyDescription.error
type to MongoError
(#4028) (30432e8)full
is set to true
(#4034) (0ebc1ac)libmongocrypt
after fetching AWS KMS credentials (#4057) (c604e74)ClusterTime.signature
can be undefined (#4069) (ce55ca9)We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
Published by github-actions[bot] 7 months ago
The MongoDB Node.js team is pleased to announce version 6.5.0 of the mongodb
package!
pkFactory
When performing inserts, the driver automatically generates _id
s for each document if there is no _id
present. By default, the driver generates ObjectId
s. An option, pkFactory
, can be used to configure the driver to generate _id
s that are not object ids.
For a long time, only Collection.insert
and Collection.insertMany
actually used the pkFactory
, if configured. Notably, Collection.bulkWrite()
, Collection.initializeOrderedBulkOp()
and Collection.initializeOrderedBulkOp()
always generated ObjectId
s, regardless of what was configured on collection.
The driver always generates _id
s for inserted documents using the pkFactory
.
[!CAUTION]
If you are using apkFactory
and performing bulk writes, you may have inserted data into your database that does not have_id
s generated by thepkFactory
.
When connecting to a secondary in a replica set with a direct connection, if a read operation is performed, the driver attaches a read preference of primaryPreferred
to the command.
The Connection class has recently been refactored to operate on our socket operations using promises. An oversight how we made async network operations interruptible made new promises for every operation. We've simplified the approach and corrected the leak.
When connecting using a convenient SRV connection string (mongodb+srv://
) hostnames are obtained from an SRV dns lookup and some configuration options are obtained from a TXT dns query. Those DNS operations are now performed in parallel to reduce first-time connection latency.
The Node.js driver now keeps track of container metadata in the client.env.container
field of the handshake document.
If space allows, the following metadata will be included in client.env.container
:
env?: {
container?: {
orchestrator?: 'kubernetes' // if process.env.KUBERNETES_SERVICE_HOST is set
runtime?: 'docker' // if the '/.dockerenv' file exists
}
}
Note: If neither Kubernetes nor Docker is present, client.env
will not have the container
property.
errorResponse
to MongoServerErrorThe MongoServer error maps keys from the error document returned by the server on to itself. There are some use cases where the original error document is desirable to obtain in isolation. So now, the mongoServerError.errorResponse
property stores a reference to the error document returned by the server.
CloseOptions
interfaceThe CloseOptions
interface was unintentionally made public and was only intended for use in the driver's internals. Due to recent refactoring (NODE-5915), this interface is no longer used in the driver. Since it was marked public, out of an abundance of caution we will not be removing it outside of a major version, but we have deprecated it and will be removing it in the next major version.
CERT_HAS_EXPIRED
(#4014) (057c223)Connection
class (#4022) (69de253)We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
Published by github-actions[bot] 8 months ago
The MongoDB Node.js team is pleased to announce version 6.4.0 of the mongodb
package!
When retrying reads or writes on a sharded cluster, the driver will attempt to select a different mongos for the retry if multiple are present. This should heuristically avoid encountering the original error that caused the need to retry the operation.
Instead of creating a new AWS provider for each authentication, we cache the AWS credentials provider per client to prevent overwhelming the auth endpoint and ensure that cached credentials are not shared with other clients.
^6.4.0
BSON has had a number of performance increases in the last two releases (6.3.0 and 6.4.0). Small basic latin (ASCII) only strings, small memory allocations (ObjectId and Decimal128) and numeric parsing operations (int32, doubles, and longs) have all had optimizations applied to them.
For details check out the release notes here: BSON 6.3.0 and BSON 6.4.0 ๐
The reading operations will be resumed after receiving the ExceededTimeLimit
error.
Internal to the field-level encryption machinery is a helper that opens a TLS socket to the KMS provider endpoint and submits a KMS request. The code neglected to add a 'close'
event listener to the socket, which had the potential to improperly leave the promise pending indefinitely if no error was encountered.
The authentication was rejected by the saslContinue command from mongosh due to missing "=" padding from the client. We fixed the way we parse payload to preserve trailing "="s.
countDocuments
now types the filter using the collection SchemaPreviously, countDocuments
had a weakly typed Document
type for the filter allowing any JS object as input. The filter is now typed as Filter<Schema>
to enable autocompletion, and, hopefully, catch minor bugs.
Thank you to @pashok88895 for contributing to this improvement.
$addToSet
in bulkWrite
was fixedPreviously the following code sample would show a type error:
interface IndexSingatureTestDocument extends Document {
readonly myId: number;
readonly mySet: number[];
}
const indexSingatureCollection = undefined as unknown as Collection<IndexSingatureTestDocument>;
indexSingatureCollection.bulkWrite([
{
updateOne: {
filter: { myId: 0 },
update: {
$addToSet: { mySet: 0 } // The type error! Type 'number' is not assignable to type 'never'.
}
}
}
]);
It happened because the driver's Document
type falls back to any
, and internally we could not distinguish whether or not this assignment was intentional and should be allowed.
After this change, users can extend their types from Document
/any
, or use properties of any
type and we skip the $addToSet
validation in those cases.
The ServerHeartbeatSucceeded and ServerHeartbeatFailed event have a duration property that represents the time it took to perform the hello
handshake with MongoDB. The Monitor responsible for issuing heartbeats mistakenly included the time it took to create the socket in this field, which inflates the value with the time it takes to perform a DNS lookup, TCP, and TLS handshakes.
These were previously swallowed and now will be emitted on the error
event:
const transform = new Transform({
transform(data, encoding, callback) {
callback(null, data);
},
});
const stream = db.collection('tests').find().sort({ studentId: -1 }).stream({ transform });
stream.on('error', err => {
// The error will properly be emitted here.
});
Users may provide an AWS_SESSION_TOKEN
as a client option or AWS configuration in addition to a username and password. But if the token is not provided, the driver won't throw an exception and let AWS SDK handle the request.
^6.4.0
(#4007) (90f2f70)
We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
Published by github-actions[bot] 11 months ago
The MongoDB Node.js team is pleased to announce version 5.9.2 of the mongodb
package!
When enabling serverApi the driver's RTT mesurment logic (used to determine the closest node) still sent the legacy hello command "isMaster" causing the server to return an error. Unfortunately, the error handling logic did not correctly destroy the socket which would cause a leak.
Both sending the correct hello command and the error handling connection clean up logic are fixed in this change.
We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
Published by github-actions[bot] 11 months ago
The MongoDB Node.js team is pleased to announce version 4.17.2 of the mongodb
package!
When enabling serverApi the driver's RTT mesurment logic (used to determine the closest node) still sent the legacy hello command "isMaster" causing the server to return an error. Unfortunately, the error handling logic did not correctly destroy the socket which would cause a leak.
Both sending the correct hello command and the error handling connection clean up logic are fixed in this change.
We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
Published by github-actions[bot] 11 months ago
The MongoDB Node.js team is pleased to announce version 6.3.0 of the mongodb
package!
serverMonitoringMode
For users that want to control the behaviour of the monitoring connection between each node in the topology, a new option, serverMonitoringMode
, has been added. This defaults to auto
but can be forced into a specific mode by providing a value of poll
or stream
. When the setting is auto
the monitoring mode will be determined by the environment the driver is running in, specifically, FaaS environments prefer "polling" mode and all others prefer "streaming".
A polling monitor periodically issues a hello
command to the node at an interval of heartbeatFrequencyMS
. A streaming monitor sends an initial hello
and then will automatically get a response from the Node when a change in server configuration occurs or at a maximum time of heartbeatFrequencyMS
. The value of that option defaults to 10000 milliseconds.
This new option can be provided in the connection string or as an option to the MongoClient
.
// In the connection string.
new MongoClient('mongodb://127.0.0.1:27017/?serverMonitoringMode=stream');
// In the options
new MongoClient('mongodb://127.0.0.1:27017/', { serverMonitoringMode: 'stream' });
serverApi
is enabledWhen enabling serverApi
the driver's RTT measurement logic (used to determine the closest node) still sent the legacy hello command "isMaster" causing the server to return an error. Unfortunately, the error handling logic did not correctly destroy the socket which would cause a leak.
Both sending the correct hello command and the error handling connection clean-up logic are fixed in this change.
The GridFS contentType
and aliases
options are deprecated. According to the GridFS spec, applications wishing to store contentType
and aliases
should add a corresponding field to the metadata
document instead.
The mongodb-connection-string-url
package which parses connection strings relied on Node's punycode module, the package now imports the community package removing the deprecation warning on Node.js 20+.
We invite you to try the mongodb
library immediately and report any issues to the NODE project.
Published by github-actions[bot] about 1 year ago
The MongoDB Node.js team is pleased to announce version 6.2.0 of the mongodb
package!
BSON now prints in full color! ๐ ๐
See our release notes for BSON 6.2.0 here for more examples!
insertedIds
in bulk write now contain only successful insertionsPrior to this fix, the bulk write error's result.insertedIds
property contained the _id
of each attempted insert in a bulk operation.
Now, when a bulkwrite()
or an insertMany()
operation rejects one or more inserts, throwing an error, the error's result.insertedIds
property will only contain the _id
fields of successfully inserted documents.
findOne()
When running a findOne
against a time series collection, the driver left the implicit session for the cursor un-ended due to the way the server returns the resulting cursor information. Now the cursor will always be cleaned up regardless of the outcome of the find operation.
Database and collection name checking will now be in sync with the MongoDB server's naming restrictions. Specifically, users can now create collections that start or end with the '.' character.
awaited
field to SDAM heartbeat events (#3895) (b50aadc)We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
Published by github-actions[bot] about 1 year ago
The MongoDB Node.js team is pleased to announce version 5.9.1 of the mongodb
package!
insertedIds
in bulk write now contain only successful insertionsPrior to this fix, the bulk write error's result.insertedIds
property contained the _id
of each attempted insert in a bulk operation.
Now, when a bulkwrite()
or an insertMany()
operation rejects one or more inserts, throwing an error, the error's result.insertedIds
property will only contain the _id
fields of successfully inserted documents.
findOne()
When running a findOne
against a time series collection, the driver left the implicit session for the cursor un-ended due to the way the server returns the resulting cursor information. Now the cursor will always be cleaned up regardless of the outcome of the find operation.
We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
Published by github-actions[bot] about 1 year ago
The MongoDB Node.js team is pleased to announce version 5.9.0 of the mongodb
package!
bson
version to make use of new Decimal128
behaviourIn this release, we have adopted the changes made to Decimal128
in bson version 5.5. The Decimal128
constructor and fromString()
methods now throw when detecting a loss of precision (more than 34 significant digits). We also expose a new fromStringWithRounding()
method which restores the previous rounding behaviour.
See the bson v5.5.0 release notes for more information.
When using IAM AssumeRoleWithWebIdentity AWS authentication the driver uses the @aws-sdk/credential-providers package to contact the Security Token Service API for temporary credentials. AWS recommends using Regional AWS STS endpoints instead of the global endpoint to reduce latency, build-in redundancy, and increase session token validity. Unfortunately, environment variables AWS_STS_REGIONAL_ENDPOINTS
and AWS_REGION
do not directly control the region the SDK's STS client contacts for credentials.
The driver now has added support for detecting these variables and setting the appropriate options when calling the SDK's API: fromNodeProviderChain().
[!IMPORTANT]
The driver will only set region options if BOTH environment variables are present.AWS_STS_REGIONAL_ENDPOINTS
MUST be set to either'legacy'
or'regional'
, andAWS_REGION
must be set.
In a previous release, 5.7.0, we refactored cursor internals from callbacks to async/await. In particular, the next
function that powers cursors was written with callbacks and would recursively call itself depending on the cursor type. For ChangeStreams
, this function would call itself if there were no new changes to return to the user. After converting that code to async/await each recursive call created a new promise that saved the current async context. This would slowly build up memory usage if no new changes came in to unwind the recursive calls.
The function is now implemented as a loop, memory leak be gone!
We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
Published by github-actions[bot] about 1 year ago
The MongoDB Node.js team is pleased to announce version 6.1.0 of the mongodb
package!
Decimal128.fromStringWithRounding()
methodIn this release, we have adopted the changes made to Decimal128 in bson version 6.1.0. We have added a new fromStringWithRounding()
method which exposes the previously available inexact rounding behaviour.
See the bson v6.1.0 release notes for more information.
When using IAM AssumeRoleWithWebIdentity AWS authentication the driver uses the @aws-sdk/credential-providers package to contact the Security Token Service API for temporary credentials. AWS recommends using Regional AWS STS endpoints instead of the global endpoint to reduce latency, build-in redundancy, and increase session token validity. Unfortunately, environment variables AWS_STS_REGIONAL_ENDPOINTS
and AWS_REGION
do not directly control the region the SDK's STS client contacts for credentials.
The driver now has added support for detecting these variables and setting the appropriate options when calling the SDK's API: fromNodeProviderChain().
[!IMPORTANT]
The driver will only set region options if BOTH environment variables are present.AWS_STS_REGIONAL_ENDPOINTS
MUST be set to either'legacy'
or'regional'
, andAWS_REGION
must be set.
In a previous release, 5.7.0, we refactored cursor internals from callbacks to async/await. In particular, the next
function that powers cursors was written with callbacks and would recursively call itself depending on the cursor type. For ChangeStreams
, this function would call itself if there were no new changes to return to the user. After converting that code to async/await each recursive call created a new promise that saved the current async context. This would slowly build up memory usage if no new changes came in to unwind the recursive calls.
The function is now implemented as a loop, memory leak be gone!
We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
Published by github-actions[bot] about 1 year ago
The MongoDB Node.js team is pleased to announce version 6.0.0 of the mongodb
package!
The main focus of this release was usability improvements and a streamlined API. Read on for details!
[!IMPORTANT]
This is a list of changes relative to v5.8.1 of the driver. ALL changes listed below are BREAKING.
Users migrating from an older version of the driver are advised to upgrade to at least v5.8.1 before adopting v6.
The minimum supported Node.js version is now v16.20.1. We strive to keep our minimum supported Node.js version in sync with the runtime's release cadence to keep up with the latest security updates and modern language features.
This driver version has been updated to use [email protected]
. BSON functionality re-exported from the driver is subject to the changes outlined in the BSON V6 release notes.
kerberos
optional peer dependency minimum version raised to 2.0.1
, dropped support for 1.x
zstd
optional peer depedency minimum version raised to 1.1.0
from 1.0.0
mongodb-client-encryption
optional peer dependency minimum version raised to 6.0.0
from 2.3.0
(note that mongodb-client-encryption
does not have 3.x-5.x
version releases)[!NOTE]
As of version 6.0.0, all useful public APIs formerly exposed frommongodb-client-encryption
have been moved into the driver and should now be imported directly from the driver. These APIs rely internally on the functionality exposed frommongodb-client-encryption
, but there is no longer any need to explicitly referencemongodb-client-encryption
in your application code.
socks
to be installed optionallyThe driver uses the socks
dependency to connect to mongod
or mongos
through a SOCKS5 proxy. socks
used to be a required dependency of the driver and was installed automatically. Now, socks
is a peerDependency
that must be installed to enable socks
proxy support.
findOneAndX
family of methods will now return only the found document or null
by default (includeResultMetadata
is false by default)Previously, the default return type of this family of methods was a ModifyResult
containing the found document and additional metadata. This additional metadata is unnecessary for the majority of use cases, so now, by default, they will return only the found document or null
.
The previous behavior is still available by explicitly setting includeResultMetadata: true
in the options.
See the following blog post for more information.
// This has the same behaviour as providing `{ includeResultMetadata: false }` in the v5.7.0+ driver
await collection.findOneAndUpdate({ hello: 'world' }, { $set: { hello: 'WORLD' } });
// > { _id: new ObjectId("64c4204517f785be30795c92"), hello: 'world' }
// This has the same behaviour as providing no options in any previous version of the driver
await collection.findOneAndUpdate(
{ hello: 'world' },
{ $set: { hello: 'WORLD' } },
{ includeResultMetadata: true }
);
// > {
// > lastErrorObject: { n: 1, updatedExisting: true },
// > value: { _id: new ObjectId("64c4208b17f785be30795c93"), hello: 'world' },
// > ok: 1
// > }
session.commitTransaction()
and session.abortTransaction()
return voidEach of these methods erroneously returned server command results that can be different depending on server version or type the driver is connected to. These methods return a promise that if resolved means the command (aborting or commiting) sucessfully completed and rejects otherwise. Viewing command responses is possible through the command monitoring APIs on the MongoClient
.
withSession
and withTransaction
return the value returned by the provided functionThe await client.withSession(async session => {})
now returns the value that the provided function returns. Previously, this function returned void
this is a feature to align with the following breaking change.
The await session.withTransaction(async () => {})
method now returns the value that the provided function returns. Previously, this function returned the server command response which is subject to change depending on the server version or type the driver is connected to. The return value got in the way of writing robust, reliable, consistent code no matter the backing database supporting the application.
[!WARNING]
When upgrading to this version of the driver, be sure to audit any usages ofwithTransaction
forif
statements or other conditional checks on the return value ofwithTransaction
. Previously, the return value was the command response if the transaction was committed andundefined
if it had been manually aborted. It would only throw if an operation or the author of the function threw an error. Since prior to this release it was not possible to get the result of the function passed towithTransaction
we suspect most existing functions passed to this method returnvoid
, makingwithTransaction
avoid
returning function in this major release. Take care to ensure that the return values of your function match the expectation of the code that follows the completion ofwithTransaction
.
MongoClient
Providing a session from one MongoClient
to a method on a different MongoClient
has never been a supported use case and leads to undefined behavior. To prevent this mistake, the driver now throws a MongoInvalidArgumentError
if session is provided to a driver helper from a different MongoClient
.
// pre v6
const session = client1.startSession();
client2.db('foo').collection('bar').insertOne({ name: 'john doe' }, { session }); // no error thrown, undefined behavior
// v6+
const session = client1.startSession();
client2.db('foo').collection('bar').insertOne({ name: 'john doe' }, { session });
// MongoInvalidArgumentError thrown
encrypt
, decrypt
, and createDataKey
methodsDriver v5 dropped support for callbacks in asynchronous functions in favor of returning promises in order to provide more consistent type and API experience. In alignment with that, we are now removing support for callbacks from the ClientEncryption
class.
MongoCryptError
is now a subclass of MongoError
Since MongoCryptError
made use of Node.js 16's Error
API, it has long supported setting the Error.cause
field using options passed in via the constructor. Now that Node.js 16 is our minimum supported version, MongoError
has been modified to make use of this API as well, allowing us to let MongoCryptError
subclass from it directly.
useNewUrlParser
and useUnifiedTopology
emit deprecation warningsThese options were removed in 4.0.0 but continued to be parsed and silently left unused. We have now added a deprecation warning through Node.js' warning system and will fully remove these options in the next major release.
Prior to this change, we accepted the values '1', 'y', 'yes', 't'
as synonyms for true
and '-1', '0', 'f', 'n', 'no'
as synonyms for false
. These have now been removed in an effort to make working with connection string options simpler.
// Incorrect
const client = new MongoClient('mongodb://localhost:27017?tls=1'); // throws MongoParseError
// Correct
const client = new MongoClient('mongodb://localhost:27017?tls=true');
In order to avoid accidental misconfiguration the driver will no longer prioritize the first instance of an option provided on the URI. Instead repeated options that are not permitted to be repeated will throw an error.
This change will ensure that connection strings that contain options like tls=true&tls=false
are no longer ambiguous.
In order to align with Node.js best practices of keeping I/O async, we have updated the MongoClient
to store the file names provided to the existing tlsCAFile
and tlsCertificateKeyFile
options, as well as the tlsCRLFile
option, and only read these files the first time it connects. Prior to this change, the files were read synchronously on MongoClient
construction.
[!NOTE]
This has no effect on driver functionality when TLS configuration files are properly specified. However, if there are any issues with the TLS configuration files (invalid file name), the error is now thrown when theMongoClient
is connected instead of at construction time.
const client = new MongoClient(CONNECTION_STRING, {
tls: true,
tlsCAFile: 'caFileName',
tlsCertificateKeyFile: 'certKeyFile',
tlsCRLFile: 'crlPemFile'
}); // Files are not read here, but file names are stored on the MongoClient
await client.connect(); // Files are now read and their contents stored
await client.close();
await client.connect(); // Since the file contents have already been cached, the files will not be read again.
Take a look at our TLS documentation for more information on the tlsCAFile
, tlsCertificateKeyFile
, and tlsCRLFile
options.
These APIs allow for specifying a command BSON document directly, so the driver does not try to enumerate all possible commands that could be passed to this API in an effort to be as forward and backward compatible as possible.
The db.command()
and admin.command()
APIs have their options
types updated to accurately reflect options compatible on all commands that could be passed to either API.
Perhaps most notably, readConcern
and writeConcern
options are no longer handled by the driver. Users must attach these properties to the command that is passed to the .command()
method.
ConnectionPoolCreatedEvent.options
The options
field of ConnectionPoolCreatedEvent
now has the following shape:
{
maxPoolSize: number,
minPoolSize: number,
maxConnecting: number,
maxIdleTimeMS: number,
waitQueueTimeoutMS: number
}
The following connection string will now produce the following readPreferenceTags:
'mongodb://host?readPreferenceTags=region:ny&readPreferenceTags=rack:r1&readPreferenceTags=';
// client.options.readPreference.tags
[{ region: 'ny' }, { rack: 'r1' }, {}];
The empty readPreferenceTags
allows drivers to still select a server if the leading tag conditions are not met.
GridFSBucketWriteStream
's Writable
method overrides and event emissionOur implementation of a writeable stream for GridFSBucketWriteStream
mistakenly overrode the write()
and end()
methods, as well as, manually emitted 'close'
, 'drain'
, 'finish'
events. Per Node.js documentation, these methods and events are intended for the Node.js stream implementation to provide, and an author of a stream implementation is supposed to override _write
, _final
, and allow Node.js to manage event emitting.
Since the API is still a Writable
stream most usages will continue to work with no changes, the .write()
and .end()
methods are still available and take the same arguments. The breaking change relates to the improper manually emitted event listeners that are now handled by Node.js. The 'finish'
and 'drain'
events will no longer receive the GridFSFile
document as an argument (this is the document inserted to the bucket's files collection after all chunks have been inserted). Instead, it will be available on the stream itself as a property: gridFSFile
.
// If our event handler is declared as a `function` "this" is bound to the stream.
fs.createReadStream('./file.txt')
.pipe(bucket.openUploadStream('file.txt'))
.on('finish', function () {
console.log(this.gridFSFile);
});
// If our event handler is declared using big arrow notation,
// the property is accessible on a scoped variable
const uploadStream = bucket.openUploadStream('file.txt');
fs.createReadStream('./file.txt')
.pipe(uploadStream)
.on('finish', () => console.log(uploadStream.gridFSFile));
Since the class no longer emits its own events: static constants GridFSBucketWriteStream.ERROR
, GridFSBucketWriteStream.FINISH
, GridFSBucketWriteStream.CLOSE
have been removed to avoid confusion about the source of the events and the arguments their listeners accept.
GridFSBucketReadStream
The GridFSBucketReadStream
internals have also been corrected to no longer emit events that are handled by Node's stream logic. Since the class no longer emits its own events: static constants GridFSBucketReadStream.ERROR
, GridFSBucketReadStream.DATA
, GridFSBucketReadStream.CLOSE
, and GridFSBucketReadStream.END
have been removed to avoid confusion about the source of the events and the arguments their listeners accept.
createDataKey
return type fixPreviously, the TypeScript for createDataKey
incorrectly declared the result to be a DataKey
but the method actually returns the DataKey's insertedId
.
db.addUser()
and admin.addUser()
removedThe deprecated addUser
APIs have been removed. The driver maintains support across many server versions and the createUser
command has support for different features based on the server's version. Since applications can generally write code to work against a uniform and perhaps more modern server, the path forward is for applications to send the createUser
command directly.
The associated options interface with this API has also been removed: AddUserOptions
.
See the createUser
documentation for more information.
const db = client.db('admin');
// Example addUser usage
await db.addUser('myUsername', 'myPassword', { roles: [{ role: 'readWrite', db: 'mflix' }] });
// Example equivalent command usage
await db.command({
createUser: 'myUsername',
pwd: 'myPassword',
roles: [{ role: 'readWrite', db: 'mflix' }]
});
collection.stats()
removedThe collStats
command is deprecated starting in server v6.2 so the driver is removing its bespoke helper in this major release. The collStats
command is still available to run manually via await db.command()
. However, the recommended migration is to use the $collStats
aggregation stage.
The following interfaces associated with this API have also been removed: CollStatsOptions
and WiredTigerData
.
BulkWriteResult
deprecated properties removedThe following deprecated properties have been removed as they duplicated those outlined in the [MongoDB CRUD specification|https://github.com/mongodb/specifications/blob/611ecb5d624708b81a4d96a16f98aa8f71fcc189/source/crud/crud.rst#write-results]. The list indicates what properties provide the correct migration:
BulkWriteResult.nInserted
-> BulkWriteResult.insertedCount
BulkWriteResult.nUpserted
-> BulkWriteResult.upsertedCount
BulkWriteResult.nMatched
-> BulkWriteResult.matchedCount
BulkWriteResult.nModified
-> BulkWriteResult.modifiedCount
BulkWriteResult.nRemoved
-> BulkWriteResult.deletedCount
BulkWriteResult.getUpsertedIds
-> BulkWriteResult.upsertedIds
/ BulkWriteResult.getUpsertedIdAt(index: number)
BulkWriteResult.getInsertedIds
-> BulkWriteResult.insertedIds
The following options have been removed with their supported counterparts listed after the ->
sslCA
-> tlsCAFile
sslCRL
-> tlsCRLFile
sslCert
-> tlsCertificateKeyFile
sslKey
-> tlsCertificateKeyFile
sslPass
-> tlsCertificateKeyFilePassword
sslValidate
-> tlsAllowInvalidCertificates
tlsCertificateFile
-> tlsCertificateKeyFile
keepAlive
and keepAliveInitialDelay
options have been removedTCP keep alive will always be on and now set to a value of 30000ms.
The removed functionality listed in this section was either unused or not useful outside the driver internals.
MongoError
and its subclasses now clearly indicate they are meant for internal use onlyMongoError
and its subclasses are not meant to be constructed by users as they are thrown within the driver on specific error conditions to allow users to react to these conditions in ways which match their use cases. The constructors for these types are now subject to change outside of major versions and their API documentation has been updated to reflect this.
AutoEncrypter
and MongoClient.autoEncrypter
are now internalAs of this release, users will no longer be able to access the AutoEncrypter
interface or the MongoClient.autoEncrypter
field of an encrypted MongoClient
instance as they do not have a use outside the driver internals.
ClientEncryption.onKMSProvidersRefresh
function removedClientEncryption.onKMSProvidersRefresh
was added as a public API in version 2.3.0 of mongodb-client-encryption
to allow for automatic refresh of KMS provider credentials. Subsequently, we added the capability to automatically refresh KMS credentials using the KMS provider's preferred refresh mechanism, and onKMSProviderRefresh
is no longer used.
EvalOptions
removedThis cleans up some dead code in the sense that there were no eval
command related APIs but the EvalOptions
type was public, so we want to ensure there are no surprises now that this type has been removed.
onKMSProvidersRefresh
(#3787)We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
Published by github-actions[bot] about 1 year ago
The MongoDB Node.js team is pleased to announce version 5.8.1 of the mongodb
package!
saslprep
updated to correct library.Fixes the import of saslprep to be the correct @mongodb-js/saslprep
library.
We invite you to try the mongodb
library immediately, and report any issues to the NODE project.
Published by github-actions[bot] about 1 year ago
The MongoDB Node.js team is pleased to announce version 4.17.1 of the mongodb
package!
saslprep
updated to correct library.Fixes the import of saslprep to be the correct @mongodb-js/saslprep
library.
We invite you to try the mongodb
library immediately, and report any issues to the NODE project.