mquery

mquery is a fluent mongodb query builder designed to run in multiple environments.

Features

• fluent query builder api
• custom base query support
• MongoDB 2.4 geoJSON support
• method + option combinations validation
• node.js driver compatibility
• environment detection
• debug support
• separated collection implementations for maximum flexibility

Use

1const mongo = require('mongodb');
2
3const client = new mongo.MongoClient(uri);
4await client.connect();
5// get a collection
6const collection = client.collection('artists');
7
8// pass it to the constructor
9await mquery(collection).find({...});
10
11// or pass it to the collection method
12const docs = await mquery().find({...}).collection(collection);
13
14// or better yet, create a custom query constructor that has it always set
15const Artist = mquery(collection).toConstructor();
16const docs = await Artist().find(...).where(...);

mquery requires a collection object to work with. In the example above we just pass the collection object created using the official MongoDB driver.

Fluent API

• mquery
  • Features
  • Use
  • Fluent API
  • Helpers
    • find()
    • findOne()
    • count()
    • findOneAndUpdate()
      • findOneAndUpdate() options
    • findOneAndRemove()
      • findOneAndRemove() options
    • distinct()
    • exec()
    • stream()
    • all()
    • and()
    • box()
    • circle()
    • elemMatch()
    • equals()
    • exists()
    • geometry()
    • gt()
    • gte()
    • in()
    • intersects()
    • lt()
    • lte()
    • maxDistance()
    • mod()
    • ne()
    • nin()
    • nor()
    • near()
      • Example
    • or()
    • polygon()
    • regex()
    • select()
      • String syntax
    • selected()
    • selectedInclusively()
    • selectedExclusively()
    • size()
    • slice()
    • within()
    • where()
    • $where()
    • batchSize()
    • collation()
    • comment()
    • hint()
    • j()
    • limit()
    • maxTime()
    • skip()
    • sort()
    • read()
      • Preferences:
      • Preference Tags:
    • readConcern()
      • Read Concern Level:
    • writeConcern()
      • Write Concern:
    • slaveOk()
    • tailable()
    • wtimeout()
  • Helpers
    • collection()
    • then()
    • merge(object)
    • setOptions(options)
      • setOptions() options
    • setTraceFunction(func)
    • mquery.setGlobalTraceFunction(func)
    • mquery.canMerge(conditions)
  • mquery.use$geoWithin
  • Custom Base Queries
  • Validation
  • Debug support
  • General compatibility
    • ObjectIds
    • Read Preferences
  • Future goals
  • Installation
  • License

Helpers

• collection
• then
• merge
• setOptions
• setTraceFunction
• mquery.setGlobalTraceFunction
• mquery.canMerge
• mquery.use$geoWithin

find()

Declares this query a find query. Optionally pass a match clause.

1mquery().find()
2mquery().find(match)
3await mquery().find()
4const docs = await mquery().find(match);
5assert(Array.isArray(docs));

findOne()

Declares this query a findOne query. Optionally pass a match clause.

1mquery().findOne()
2mquery().findOne(match)
3await mquery().findOne()
4const doc = await mquery().findOne(match);
5if (doc) {
6  // the document may not be found
7  console.log(doc);
8}

count()

Declares this query a count query. Optionally pass a match clause.

1mquery().count()
2mquery().count(match)
3await mquery().count()
4const number = await mquery().count(match);
5console.log('we found %d matching documents', number);

findOneAndUpdate()

Declares this query a findAndModify with update query. Optionally pass a match clause, update document, options.

When executed, the first matching document (if found) is modified according to the update document and passed back.

findOneAndUpdate() options

Options are passed to the setOptions() method.

• returnDocument: string - 'after' to return the modified document rather than the original. defaults to 'before'
• upsert: boolean - creates the object if it doesn't exist. defaults to false
• sort: if multiple docs are found by the match condition, sets the sort order to choose which doc to update

1query.findOneAndUpdate()
2query.findOneAndUpdate(updateDocument)
3query.findOneAndUpdate(match, updateDocument)
4query.findOneAndUpdate(match, updateDocument, options)
5
6// the following all execute the command
7await query.findOneAndUpdate()
8await query.findOneAndUpdate(updateDocument)
9await query.findOneAndUpdate(match, updateDocument)
10const doc = await await query.findOneAndUpdate(match, updateDocument, options);
11if (doc) {
12  // the document may not be found
13  console.log(doc);
14}

findOneAndRemove()

Declares this query a findAndModify with remove query. Alias of findOneAndDelete. Optionally pass a match clause, options.

When executed, the first matching document (if found) is modified according to the update document, removed from the collection and passed as a result.

findOneAndRemove() options

Options are passed to the setOptions() method.

• sort: if multiple docs are found by the condition, sets the sort order to choose which doc to modify and remove

1A.where().findOneAndDelete()
2A.where().findOneAndRemove()
3A.where().findOneAndRemove(match)
4A.where().findOneAndRemove(match, options)
5
6// the following all execute the command
7await A.where().findOneAndRemove()
8await A.where().findOneAndRemove(match)
9const doc = await A.where().findOneAndRemove(match, options);
10if (doc) {
11  // the document may not be found
12  console.log(doc);
13}

distinct()

Declares this query a distinct query. Optionally pass the distinct field, a match clause.

1mquery().distinct()
2mquery().distinct(match)
3mquery().distinct(match, field)
4mquery().distinct(field)
5
6// the following all execute the command
7await mquery().distinct()
8await mquery().distinct(field)
9await mquery().distinct(match)
10const result = await mquery().distinct(match, field);
11console.log(result);

exec()

Executes the query.

1const docs = await mquery().findOne().where('route').intersects(polygon).exec()

stream()

Executes the query and returns a stream.

1var stream = mquery().find().stream(options);
2stream.on('data', cb);
3stream.on('close', fn);

Note: this only works with find() operations.

Note: returns the stream object directly from the node-mongodb-native driver. (currently streams1 type stream). Any options will be passed along to the driver method.

---

all()

Specifies an $all query condition

1mquery().where('permission').all(['read', 'write'])

MongoDB documentation

and()

Specifies arguments for an $and condition

1mquery().and([{ color: 'green' }, { status: 'ok' }])

MongoDB documentation

box()

Specifies a $box condition

1var lowerLeft = [40.73083, -73.99756]
2var upperRight= [40.741404,  -73.988135]
3
4mquery().where('location').within().box(lowerLeft, upperRight)

MongoDB Documentation

circle()

Specifies a $center or $centerSphere condition.

1var area = { center: [50, 50], radius: 10, unique: true }
2query.where('loc').within().circle(area)
3query.circle('loc', area);
4
5// for spherical calculations
6var area = { center: [50, 50], radius: 10, unique: true, spherical: true }
7query.where('loc').within().circle(area)
8query.circle('loc', area);

• MongoDB Documentation - center
• MongoDB Documentation - centerSphere

elemMatch()

Specifies an $elemMatch condition

1query.where('comment').elemMatch({ author: 'autobot', votes: {$gte: 5}})
2
3query.elemMatch('comment', function (elem) {
4  elem.where('author').equals('autobot');
5  elem.where('votes').gte(5);
6})

MongoDB Documentation

equals()

Specifies the complementary comparison value for the path specified with where().

1mquery().where('age').equals(49);
2
3// is the same as
4
5mquery().where({ 'age': 49 });

exists()

Specifies an $exists condition

1// { name: { $exists: true }}
2mquery().where('name').exists()
3mquery().where('name').exists(true)
4mquery().exists('name')
5
6// { name: { $exists: false }}
7mquery().where('name').exists(false);
8mquery().exists('name', false);

MongoDB Documentation

geometry()

Specifies a $geometry condition

1var polyA = [[[ 10, 20 ], [ 10, 40 ], [ 30, 40 ], [ 30, 20 ]]]
2query.where('loc').within().geometry({ type: 'Polygon', coordinates: polyA })
3
4// or
5var polyB = [[ 0, 0 ], [ 1, 1 ]]
6query.where('loc').within().geometry({ type: 'LineString', coordinates: polyB })
7
8// or
9var polyC = [ 0, 0 ]
10query.where('loc').within().geometry({ type: 'Point', coordinates: polyC })
11
12// or
13query.where('loc').intersects().geometry({ type: 'Point', coordinates: polyC })
14
15// or
16query.where('loc').near().geometry({ type: 'Point', coordinates: [3,5] })

geometry() must come after intersects(), within(), or near().

The object argument must contain type and coordinates properties.

• type String
• coordinates Array

MongoDB Documentation

gt()

Specifies a $gt query condition.

1mquery().where('clicks').gt(999)

MongoDB Documentation

gte()

Specifies a $gte query condition.

MongoDB Documentation

1mquery().where('clicks').gte(1000)

in()

Specifies an $in query condition.

1mquery().where('author_id').in([3, 48901, 761])

MongoDB Documentation

intersects()

Declares an $geoIntersects query for geometry().

1query.where('path').intersects().geometry({
2    type: 'LineString'
3  , coordinates: [[180.0, 11.0], [180, 9.0]]
4})
5
6// geometry arguments are supported
7query.where('path').intersects({
8    type: 'LineString'
9  , coordinates: [[180.0, 11.0], [180, 9.0]]
10})

Must be used after where().

MongoDB Documentation

lt()

Specifies a $lt query condition.

1mquery().where('clicks').lt(50)

MongoDB Documentation

lte()

Specifies a $lte query condition.

1mquery().where('clicks').lte(49)

MongoDB Documentation

maxDistance()

Specifies a $maxDistance query condition.

1mquery().where('location').near({ center: [139, 74.3] }).maxDistance(5)

MongoDB Documentation

mod()

Specifies a $mod condition

1mquery().where('count').mod(2, 0)

MongoDB Documentation

ne()

Specifies a $ne query condition.

1mquery().where('status').ne('ok')

MongoDB Documentation

nin()

Specifies an $nin query condition.

1mquery().where('author_id').nin([3, 48901, 761])

MongoDB Documentation

nor()

Specifies arguments for an $nor condition.

1mquery().nor([{ color: 'green' }, { status: 'ok' }])

MongoDB Documentation

near()

Specifies arguments for a $near or $nearSphere condition.

These operators return documents sorted by distance.

Example

1query.where('loc').near({ center: [10, 10] });
2query.where('loc').near({ center: [10, 10], maxDistance: 5 });
3query.near('loc', { center: [10, 10], maxDistance: 5 });
4
5// GeoJSON
6query.where('loc').near({ center: { type: 'Point', coordinates: [10, 10] }});
7query.where('loc').near({ center: { type: 'Point', coordinates: [10, 10] }, maxDistance: 5, spherical: true });
8query.where('loc').near().geometry({ type: 'Point', coordinates: [10, 10] });
9
10// For a $nearSphere condition, pass the `spherical` option.
11query.near({ center: [10, 10], maxDistance: 5, spherical: true });

MongoDB Documentation

or()

Specifies arguments for an $or condition.

1mquery().or([{ color: 'red' }, { status: 'emergency' }])

MongoDB Documentation

polygon()

Specifies a $polygon condition

1mquery().where('loc').within().polygon([10,20], [13, 25], [7,15])
2mquery().polygon('loc', [10,20], [13, 25], [7,15])

MongoDB Documentation

regex()

Specifies a $regex query condition.

1mquery().where('name').regex(/^sixstepsrecords/)

MongoDB Documentation

select()

Specifies which document fields to include or exclude

1// 1 means include, 0 means exclude
2mquery().select({ name: 1, address: 1, _id: 0 })
3
4// or
5
6mquery().select('name address -_id')

String syntax

When passing a string, prefixing a path with - will flag that path as excluded. When a path does not have the - prefix, it is included.

1// include a and b, exclude c
2query.select('a b -c');
3
4// or you may use object notation, useful when
5// you have keys already prefixed with a "-"
6query.select({a: 1, b: 1, c: 0});

Cannot be used with distinct().

selected()

Determines if the query has selected any fields.

1var query = mquery();
2query.selected() // false
3query.select('-name');
4query.selected() // true

selectedInclusively()

Determines if the query has selected any fields inclusively.

1var query = mquery().select('name');
2query.selectedInclusively() // true
3
4var query = mquery();
5query.selected() // false
6query.select('-name');
7query.selectedInclusively() // false
8query.selectedExclusively() // true

selectedExclusively()

Determines if the query has selected any fields exclusively.

1var query = mquery().select('-name');
2query.selectedExclusively() // true
3
4var query = mquery();
5query.selected() // false
6query.select('name');
7query.selectedExclusively() // false
8query.selectedInclusively() // true

size()

Specifies a $size query condition.

1mquery().where('someArray').size(6)

MongoDB Documentation

slice()

Specifies a $slice projection for a path

1mquery().where('comments').slice(5)
2mquery().where('comments').slice(-5)
3mquery().where('comments').slice([-10, 5])

MongoDB Documentation

within()

Sets a $geoWithin or $within argument for geo-spatial queries.

1mquery().within().box()
2mquery().within().circle()
3mquery().within().geometry()
4
5mquery().where('loc').within({ center: [50,50], radius: 10, unique: true, spherical: true });
6mquery().where('loc').within({ box: [[40.73, -73.9], [40.7, -73.988]] });
7mquery().where('loc').within({ polygon: [[],[],[],[]] });
8
9mquery().where('loc').within([], [], []) // polygon
10mquery().where('loc').within([], []) // box
11mquery().where('loc').within({ type: 'LineString', coordinates: [...] }); // geometry

As of mquery 2.0, $geoWithin is used by default. This impacts you if running MongoDB < 2.4. To alter this behavior, see mquery.use$geoWithin.

Must be used after where().

MongoDB Documentation

where()

Specifies a path for use with chaining

1// instead of writing:
2mquery().find({age: {$gte: 21, $lte: 65}});
3
4// we can instead write:
5mquery().where('age').gte(21).lte(65);
6
7// passing query conditions is permitted too
8mquery().find().where({ name: 'vonderful' })
9
10// chaining
11await mquery()
12  .where('age').gte(21).lte(65)
13  .where({ 'name': /^vonderful/i })
14  .where('friends').slice(10)
15  .exec()

$where()

Specifies a $where condition.

Use $where when you need to select documents using a JavaScript expression.

1await query.$where('this.comments.length > 10 || this.name.length > 5').exec()
2
3query.$where(function () {
4  return this.comments.length > 10 || this.name.length > 5;
5})

Only use $where when you have a condition that cannot be met using other MongoDB operators like $lt. Be sure to read about all of its caveats before using.

---

batchSize()

Specifies the batchSize option.

1query.batchSize(100)

Cannot be used with distinct().

MongoDB documentation

collation()

Specifies the collation option.

1query.collation({ locale: "en_US", strength: 1 })

MongoDB documentation

comment()

Specifies the comment option.

1query.comment('login query');

Cannot be used with distinct().

MongoDB documentation

hint()

Sets query hints.

1mquery().hint({ indexA: 1, indexB: -1 })

Cannot be used with distinct().

MongoDB documentation

j()

Requests acknowledgement that this operation has been persisted to MongoDB's on-disk journal.

This option is only valid for operations that write to the database:

• deleteOne()
• deleteMany()
• findOneAndDelete()
• findOneAndUpdate()
• updateOne()
• updateMany()

Defaults to the j value if it is specified in writeConcern

1mquery().j(true);

limit()

Specifies the limit option.

1query.limit(20)

Cannot be used with distinct().

MongoDB documentation

maxTime()

Specifies the maxTimeMS option.

1query.maxTime(100)
2query.maxTimeMS(100)

MongoDB documentation

skip()

Specifies the skip option.

1query.skip(100).limit(20)

Cannot be used with distinct().

MongoDB documentation

sort()

Sets the query sort order.

If an object is passed, key values allowed are asc, desc, ascending, descending, 1, and -1.

If a string is passed, it must be a space delimited list of path names. The sort order of each path is ascending unless the path name is prefixed with - which will be treated as descending.

1// these are equivalent
2query.sort({ field: 'asc', test: -1 });
3query.sort('field -test');

Cannot be used with distinct().

MongoDB documentation

read()

Sets the readPreference option for the query.

1mquery().read('primary')
2mquery().read('p')  // same as primary
3
4mquery().read('primaryPreferred')
5mquery().read('pp') // same as primaryPreferred
6
7mquery().read('secondary')
8mquery().read('s')  // same as secondary
9
10mquery().read('secondaryPreferred')
11mquery().read('sp') // same as secondaryPreferred
12
13mquery().read('nearest')
14mquery().read('n')  // same as nearest
15
16mquery().setReadPreference('primary') // alias of .read()

Preferences:

• primary - (default) Read from primary only. Operations will produce an error if primary is unavailable. Cannot be combined with tags.
• secondary - Read from secondary if available, otherwise error.
• primaryPreferred - Read from primary if available, otherwise a secondary.
• secondaryPreferred - Read from a secondary if available, otherwise read from the primary.
• nearest - All operations read from among the nearest candidates, but unlike other modes, this option will include both the primary and all secondaries in the random selection.

Aliases

• p primary
• pp primaryPreferred
• s secondary
• sp secondaryPreferred
• n nearest

Preference Tags:

To keep the separation of concerns between mquery and your driver clean, mquery#read() no longer handles specifying a second tags argument as of version 0.5. If you need to specify tags, pass any non-string argument as the first argument. mquery will pass this argument untouched to your collections methods later. For example:

1// example of specifying tags using the Node.js driver
2var ReadPref = require('mongodb').ReadPreference;
3var preference = new ReadPref('secondary', [{ dc:'sf', s: 1 },{ dc:'ma', s: 2 }]);
4mquery(...).read(preference).exec();

Read more about how to use read preferences here and here.

readConcern()

Sets the readConcern option for the query.

1// local
2mquery().readConcern('local')
3mquery().readConcern('l')
4mquery().r('l')
5
6// available
7mquery().readConcern('available')
8mquery().readConcern('a')
9mquery().r('a')
10
11// majority
12mquery().readConcern('majority')
13mquery().readConcern('m')
14mquery().r('m')
15
16// linearizable
17mquery().readConcern('linearizable')
18mquery().readConcern('lz')
19mquery().r('lz')
20
21// snapshot
22mquery().readConcern('snapshot')
23mquery().readConcern('s')
24mquery().r('s')

Read Concern Level:

• local - The query returns from the instance with no guarantee guarantee that the data has been written to a majority of the replica set members (i.e. may be rolled back). (MongoDB 3.2+)
• available - The query returns from the instance with no guarantee guarantee that the data has been written to a majority of the replica set members (i.e. may be rolled back). (MongoDB 3.6+)
• majority - The query returns the data that has been acknowledged by a majority of the replica set members. The documents returned by the read operation are durable, even in the event of failure. (MongoDB 3.2+)
• linearizable - The query returns data that reflects all successful majority-acknowledged writes that completed prior to the start of the read operation. The query may wait for concurrently executing writes to propagate to a majority of replica set members before returning results. (MongoDB 3.4+)
• snapshot - Only available for operations within multi-document transactions. Upon transaction commit with write concern "majority", the transaction operations are guaranteed to have read from a snapshot of majority-committed data. (MongoDB 4.0+)

Aliases

• l local
• a available
• m majority
• lz linearizable
• s snapshot

Read more about how to use read concern here.

writeConcern()

Sets the writeConcern option for the query.

This option is only valid for operations that write to the database:

• deleteOne()
• deleteMany()
• findOneAndDelete()
• findOneAndUpdate()
• updateOne()
• updateMany()

1mquery().writeConcern(0)
2mquery().writeConcern(1)
3mquery().writeConcern({ w: 1, j: true, wtimeout: 2000 })
4mquery().writeConcern('majority')
5mquery().writeConcern('m') // same as majority
6mquery().writeConcern('tagSetName') // if the tag set is 'm', use .writeConcern({ w: 'm' }) instead
7mquery().w(1) // w is alias of writeConcern

Write Concern:

writeConcern({ w: <value>, j: <boolean>, wtimeout: <number> }`)

• the w option to request acknowledgement that the write operation has propagated to a specified number of mongod instances or to mongod instances with specified tags
• the j option to request acknowledgement that the write operation has been written to the journal
• the wtimeout option to specify a time limit to prevent write operations from blocking indefinitely

Can be break down to use the following syntax:

mquery().w(<value>).j(<boolean>).wtimeout(<number>)

Read more about how to use write concern here

slaveOk()

Sets the slaveOk option. true allows reading from secondaries.

deprecated use read() preferences instead if on mongodb >= 2.2

1query.slaveOk() // true
2query.slaveOk(true)
3query.slaveOk(false)

MongoDB documentation

tailable()

Sets tailable option.

1mquery().tailable() <== true
2mquery().tailable(true)
3mquery().tailable(false)

Cannot be used with distinct().

MongoDB Documentation

wtimeout()

Specifies a time limit, in milliseconds, for the write concern. If w > 1, it is maximum amount of time to wait for this write to propagate through the replica set before this operation fails. The default is 0, which means no timeout.

This option is only valid for operations that write to the database:

• deleteOne()
• deleteMany()
• findOneAndDelete()
• findOneAndUpdate()
• updateOne()
• updateMany()

Defaults to wtimeout value if it is specified in writeConcern

1mquery().wtimeout(2000)
2mquery().wTimeout(2000)

Helpers

collection()

Sets the querys collection.

1mquery().collection(aCollection)

then()

Executes the query and returns a promise which will be resolved with the query results or rejected if the query responds with an error.

1mquery().find(..).then(success, error);

This is very useful when combined with co or koa, which automatically resolve promise-like objects for you.

1co(function*(){
2  var doc = yield mquery().findOne({ _id: 499 });
3  console.log(doc); // { _id: 499, name: 'amazing', .. }
4})();

NOTE: The returned promise is a bluebird promise but this is customizable. If you want to use your favorite promise library, simply set mquery.Promise = YourPromiseConstructor. Your Promise must be promises A+ compliant.

merge(object)

Merges other mquery or match condition objects into this one. When an mquery instance is passed, its match conditions, field selection and options are merged.

1const drum = mquery({ type: 'drum' }).collection(instruments);
2const redDrum = mquery({ color: 'red' }).merge(drum);
3const n = await redDrum.count();
4console.log('there are %d red drums', n);

Internally uses mquery.canMerge to determine validity.

setOptions(options)

Sets query options.

1mquery().setOptions({ collection: coll, limit: 20 })

setOptions() options

• tailable *
• sort *
• limit *
• skip *
• maxTime *
• batchSize *
• comment *
• hint *
• collection: the collection to query against

* denotes a query helper method is also available

setTraceFunction(func)

Set a function to trace this query. Useful for profiling or logging.

1function traceFunction (method, queryInfo, query) {
2  console.log('starting ' + method + ' query');
3
4  return function (err, result, millis) {
5    console.log('finished ' + method + ' query in ' + millis + 'ms');
6  };
7}
8
9mquery().setTraceFunction(traceFunction).findOne({name: 'Joe'}, cb);

The trace function is passed (method, queryInfo, query)

• method is the name of the method being called (e.g. findOne)
• queryInfo contains information about the query:
  • conditions: query conditions/criteria
  • options: options such as sort, fields, etc
  • doc: document being updated
• query is the query object

The trace function should return a callback function which accepts:

• err: error, if any
• result: result, if any
• millis: time spent waiting for query result

NOTE: stream requests are not traced.

mquery.setGlobalTraceFunction(func)

Similar to setTraceFunction() but automatically applied to all queries.

1mquery.setTraceFunction(traceFunction);

mquery.canMerge(conditions)

Determines if conditions can be merged using mquery().merge().

1var query = mquery({ type: 'drum' });
2var okToMerge = mquery.canMerge(anObject)
3if (okToMerge) {
4  query.merge(anObject);
5}

mquery.use$geoWithin

MongoDB 2.4 introduced the $geoWithin operator which replaces and is 100% backward compatible with $within. As of mquery 0.2, we default to using $geoWithin for all within() calls.

If you are running MongoDB < 2.4 this will be problematic. To force mquery to be backward compatible and always use $within, set the mquery.use$geoWithin flag to false.

1mquery.use$geoWithin = false;

Custom Base Queries

Often times we want custom base queries that encapsulate predefined criteria. With mquery this is easy. First create the query you want to reuse and call its toConstructor() method which returns a new subclass of mquery that retains all options and criteria of the original.

1var greatMovies = mquery(movieCollection).where('rating').gte(4.5).toConstructor();
2
3// use it!
4const n = await greatMovies().count();
5console.log('There are %d great movies', n);
6
7const docs = await greatMovies().where({ name: /^Life/ }).select('name').find();
8console.log(docs);

Validation

Method and options combinations are checked for validity at runtime to prevent creation of invalid query constructs. For example, a distinct query does not support specifying options like hint or field selection. In this case an error will be thrown so you can catch these mistakes in development.

Debug support

Debug mode is provided through the use of the debug module. To enable:

1DEBUG=mquery node yourprogram.js

Read the debug module documentation for more details.

General compatibility

ObjectIds

mquery clones query arguments before passing them to a collection method for execution. This prevents accidental side-affects to the objects you pass. To clone ObjectIds we need to make some assumptions.

First, to check if an object is an ObjectId, we check its constructors name. If it matches either ObjectId or ObjectID we clone it.

To clone ObjectIds, we call its optional clone method. If a clone method does not exist, we fall back to calling new obj.constructor(obj.id). We assume, for compatibility with the Node.js driver, that the ObjectId instance has a public id property and that when creating an ObjectId instance we can pass that id as an argument.

Read Preferences

mquery supports specifying Read Preferences to control from which MongoDB node your query will read. The Read Preferences spec also support specifying tags. To pass tags, some drivers (Node.js driver) require passing a special constructor that handles both the read preference and its tags. If you need to specify tags, pass an instance of your drivers ReadPreference constructor or roll your own. mquery will store whatever you provide and pass later to your collection during execution.

Future goals

• mongo shell compatibility
• browser compatibility

Installation

1npm install mquery

License

MIT