@e22m4u/js-repository-mongodb-adapter 0.0.20 → 0.0.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e22m4u/js-repository-mongodb-adapter",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "MongoDB адаптер для @e22m4u/js-repository",
   "type": "module",
   "main": "src/index.js",
@@ -38,7 +38,7 @@
   "peerDependencies": {
     "@e22m4u/js-format": "*",
     "@e22m4u/js-service": "*",
-    "@e22m4u/js-repository": "~0.0.34"
+    "@e22m4u/js-repository": "~0.0.36"
   },
   "devDependencies": {
     "@commitlint/cli": "^17.7.1",

package/src/mongodb-adapter.js

@@ -364,16 +364,32 @@ export class MongodbAdapter extends Adapter {
    * @private
    */
   _buildQuery(modelName, clause) {
+    if (clause == null) return;
+    if (typeof clause !== 'object' || Array.isArray(clause))
+      throw new InvalidArgumentError(
+        'The provided option "where" should be an Object, but %v given.',
+        clause,
+      );
     const query = {};
-    if (!clause || typeof clause !== 'object') return query;
     const idPropName = this._getIdPropName(modelName);
     Object.keys(clause).forEach(key => {
+      if (String(key).indexOf('$') !== -1)
+        throw new InvalidArgumentError(
+          'The symbol "$" is not supported, but %v given.',
+          key,
+        );
       let cond = clause[key];
       // and/or/nor clause
       if (key === 'and' || key === 'or' || key === 'nor') {
-        if (Array.isArray(cond))
-          cond = cond.map(c => this._buildQuery(modelName, c));
-        query['$' + key] = cond;
+        if (cond == null) return;
+        if (!Array.isArray(cond))
+          throw new InvalidOperatorValueError(key, 'an Array', cond);
+        if (cond.length === 0) return;
+        cond = cond.map(c => this._buildQuery(modelName, c));
+        cond = cond.filter(c => c != null);
+        const opKey = '$' + key;
+        query[opKey] = query[opKey] ?? [];
+        query[opKey] = [...query[opKey], ...cond];
         return;
       }
       // id
@@ -394,29 +410,30 @@ export class MongodbAdapter extends Adapter {
       }
       // operator
       if (cond && cond.constructor && cond.constructor.name === 'Object') {
+        const opConds = [];
         // eq
         if ('eq' in cond) {
-          query[key] = this._coerceId(cond.eq);
+          opConds.push({$eq: this._coerceId(cond.eq)});
         }
         // neq
         if ('neq' in cond) {
-          query[key] = {$ne: this._coerceId(cond.neq)};
+          opConds.push({$ne: this._coerceId(cond.neq)});
         }
         // gt
         if ('gt' in cond) {
-          query[key] = {$gt: cond.gt};
+          opConds.push({$gt: cond.gt});
         }
         // lt
         if ('lt' in cond) {
-          query[key] = {$lt: cond.lt};
+          opConds.push({$lt: cond.lt});
         }
         // gte
         if ('gte' in cond) {
-          query[key] = {$gte: cond.gte};
+          opConds.push({$gte: cond.gte});
         }
         // lte
         if ('lte' in cond) {
-          query[key] = {$lte: cond.lte};
+          opConds.push({$lte: cond.lte});
         }
         // inq
         if ('inq' in cond) {
@@ -426,7 +443,7 @@ export class MongodbAdapter extends Adapter {
               'an Array of possible values',
               cond.inq,
             );
-          query[key] = {$in: cond.inq.map(v => this._coerceId(v))};
+          opConds.push({$in: cond.inq.map(v => this._coerceId(v))});
         }
         // nin
         if ('nin' in cond) {
@@ -436,7 +453,7 @@ export class MongodbAdapter extends Adapter {
               'an Array of possible values',
               cond,
             );
-          query[key] = {$nin: cond.nin.map(v => this._coerceId(v))};
+          opConds.push({$nin: cond.nin.map(v => this._coerceId(v))});
         }
         // between
         if ('between' in cond) {
@@ -446,7 +463,7 @@ export class MongodbAdapter extends Adapter {
               'an Array of 2 elements',
               cond.between,
             );
-          query[key] = {$gte: cond.between[0], $lte: cond.between[1]};
+          opConds.push({$gte: cond.between[0], $lte: cond.between[1]});
         }
         // exists
         if ('exists' in cond) {
@@ -456,7 +473,7 @@ export class MongodbAdapter extends Adapter {
               'a Boolean',
               cond.exists,
             );
-          query[key] = {$exists: cond.exists};
+          opConds.push({$exists: cond.exists});
         }
         // like
         if ('like' in cond) {
@@ -466,7 +483,7 @@ export class MongodbAdapter extends Adapter {
               'a String or RegExp',
               cond.like,
             );
-          query[key] = {$regex: stringToRegexp(cond.like)};
+          opConds.push({$regex: stringToRegexp(cond.like)});
         }
         // nlike
         if ('nlike' in cond) {
@@ -476,7 +493,7 @@ export class MongodbAdapter extends Adapter {
               'a String or RegExp',
               cond.nlike,
             );
-          query[key] = {$not: stringToRegexp(cond.nlike)};
+          opConds.push({$not: stringToRegexp(cond.nlike)});
         }
         // ilike
         if ('ilike' in cond) {
@@ -486,7 +503,7 @@ export class MongodbAdapter extends Adapter {
               'a String or RegExp',
               cond.ilike,
             );
-          query[key] = {$regex: stringToRegexp(cond.ilike, 'i')};
+          opConds.push({$regex: stringToRegexp(cond.ilike, 'i')});
         }
         // nilike
         if ('nilike' in cond) {
@@ -500,7 +517,7 @@ export class MongodbAdapter extends Adapter {
               cond.nilike,
             );
           }
-          query[key] = {$not: stringToRegexp(cond.nilike, 'i')};
+          opConds.push({$not: stringToRegexp(cond.nilike, 'i')});
         }
         // regexp and flags (optional)
         if ('regexp' in cond) {
@@ -520,14 +537,22 @@ export class MongodbAdapter extends Adapter {
               'RegExp flags must be a String, but %v given.',
               cond.flags,
             );
-          query[key] = {$regex: stringToRegexp(cond.regexp, flags)};
+          opConds.push({$regex: stringToRegexp(cond.regexp, flags)});
+        }
+        // adds a single operator condition
+        if (opConds.length === 1) {
+          query[key] = opConds[0];
+          // adds multiple operator conditions
+        } else if (opConds.length > 1) {
+          query['$and'] = query['$and'] ?? [];
+          opConds.forEach(c => query['$and'].push({[key]: c}));
         }
         return;
       }
       // unknown
       query[key] = cond;
     });
-    return query;
+    return Object.keys(query).length ? query : undefined;
   }
 
   /**

package/src/mongodb-adapter.spec.js

@@ -7,6 +7,7 @@ import {DataType} from '@e22m4u/js-repository';
 import {createMongodbUrl} from './utils/index.js';
 import {MongodbAdapter} from './mongodb-adapter.js';
 import {AdapterRegistry} from '@e22m4u/js-repository';
+import {InvalidOperatorValueError} from '@e22m4u/js-repository';
 import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME as DEF_PK} from '@e22m4u/js-repository';
 
 const CONFIG = {
@@ -274,18 +275,34 @@ describe('MongodbAdapter', function () {
         expect(throwable(null)()).to.be.undefined;
       });
 
-      it('recognizes direction by the given direction flag', async function () {
+      it('uses ascending direction by default', async function () {
         const schema = createSchema();
         schema.defineModel({name: 'model', datasource: 'mongodb'});
         const A = await schema
           .getService(AdapterRegistry)
           .getAdapter('mongodb');
-        const res1 = A._buildSort('model', 'foo');
-        const res2 = A._buildSort('model', 'foo DESC');
-        const res3 = A._buildSort('model', 'foo ASC');
-        expect(res1).to.be.eql({foo: 1});
-        expect(res2).to.be.eql({foo: -1});
-        expect(res3).to.be.eql({foo: 1});
+        const res = A._buildSort('model', 'foo');
+        expect(res).to.be.eql({foo: 1});
+      });
+
+      it('uses descending direction by the "DESC" flag', async function () {
+        const schema = createSchema();
+        schema.defineModel({name: 'model', datasource: 'mongodb'});
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const res = A._buildSort('model', 'foo DESC');
+        expect(res).to.be.eql({foo: -1});
+      });
+
+      it('uses ascending direction by the "ASC" flag', async function () {
+        const schema = createSchema();
+        schema.defineModel({name: 'model', datasource: 'mongodb'});
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const res = A._buildSort('model', 'foo ASC');
+        expect(res).to.be.eql({foo: 1});
       });
 
       it('converts the given property name to the column name', async function () {
@@ -348,18 +365,44 @@ describe('MongodbAdapter', function () {
         expect(throwable(['bar', 'baz'])()).to.be.eql({bar: 1, baz: 1});
       });
 
-      it('recognizes direction by the given direction flag', async function () {
+      it('uses ascending direction by default', async function () {
+        const schema = createSchema();
+        schema.defineModel({name: 'model', datasource: 'mongodb'});
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const res = A._buildSort('model', ['foo', 'bar']);
+        expect(res).to.be.eql({foo: 1, bar: 1});
+      });
+
+      it('uses descending direction by the "DESC" flag', async function () {
+        const schema = createSchema();
+        schema.defineModel({name: 'model', datasource: 'mongodb'});
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const res = A._buildSort('model', ['foo DESC', 'bar DESC']);
+        expect(res).to.be.eql({foo: -1, bar: -1});
+      });
+
+      it('uses ascending direction by the "ASC" flag', async function () {
         const schema = createSchema();
         schema.defineModel({name: 'model', datasource: 'mongodb'});
         const A = await schema
           .getService(AdapterRegistry)
           .getAdapter('mongodb');
-        const res1 = A._buildSort('model', ['foo', 'bar']);
-        const res2 = A._buildSort('model', ['foo DESC', 'bar ASC']);
-        const res3 = A._buildSort('model', ['foo ASC', 'bar DESC']);
-        expect(res1).to.be.eql({foo: 1, bar: 1});
-        expect(res2).to.be.eql({foo: -1, bar: 1});
-        expect(res3).to.be.eql({foo: 1, bar: -1});
+        const res = A._buildSort('model', ['foo ASC', 'bar ASC']);
+        expect(res).to.be.eql({foo: 1, bar: 1});
+      });
+
+      it('uses multiple directions by the multiple fields', async function () {
+        const schema = createSchema();
+        schema.defineModel({name: 'model', datasource: 'mongodb'});
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const res = A._buildSort('model', ['foo', 'bar DESC', 'baz ASC']);
+        expect(res).to.be.eql({foo: 1, bar: -1, baz: 1});
       });
 
       it('converts the given property names to column names', async function () {
@@ -391,6 +434,482 @@ describe('MongodbAdapter', function () {
     });
   });
 
+  describe('_buildQuery', function () {
+    it('requires the second argument to be an object', async function () {
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const throwable = v => () => A._buildQuery('model', v);
+      const error = v =>
+        format(
+          'The provided option "where" should be an Object, but %s given.',
+          v,
+        );
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable('')).to.throw(error('""'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      expect(throwable({foo: 'bar'})()).to.be.eql({foo: 'bar'});
+      expect(throwable({})()).to.be.undefined;
+      expect(throwable(undefined)()).to.be.undefined;
+      expect(throwable(null)()).to.be.undefined;
+    });
+
+    it('converts the property names to column names', async function () {
+      const schema = createSchema();
+      schema.defineModel({
+        name: 'model',
+        datasource: 'mongodb',
+        properties: {
+          foo: {
+            type: DataType.STRING,
+            columnName: 'bar',
+          },
+          baz: {
+            type: DataType.STRING,
+            columnName: 'qux',
+          },
+        },
+      });
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', {foo: 'a1', baz: null});
+      expect(res).to.be.eql({bar: 'a1', qux: null});
+    });
+
+    it('throws an error when using "$" character', async function () {
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const throwable = () => A._buildQuery('model', {$and: []});
+      expect(throwable).to.throw(
+        'The symbol "$" is not supported, but "$and" given.',
+      );
+    });
+
+    it('the "and" operator requires an array of objects', async function () {
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const throwable = v => () => A._buildQuery('model', {and: v});
+      const error = v => {
+        v = v.replace(/"/g, '$');
+        const e = new InvalidOperatorValueError('and', 'an Array', v);
+        return e.message.replace(/"/g, '').replace(/\$/g, '"');
+      };
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable('')).to.throw(error('""'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+    });
+
+    it('the "or" operator requires an array of objects', async function () {
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const throwable = v => () => A._buildQuery('model', {or: v});
+      const error = v => {
+        v = v.replace(/"/g, '$');
+        const e = new InvalidOperatorValueError('or', 'an Array', v);
+        return e.message.replace(/"/g, '').replace(/\$/g, '"');
+      };
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable('')).to.throw(error('""'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+    });
+
+    it('the "nor" operator requires an array of objects', async function () {
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const throwable = v => () => A._buildQuery('model', {nor: v});
+      const error = v => {
+        v = v.replace(/"/g, '$');
+        const e = new InvalidOperatorValueError('nor', 'an Array', v);
+        return e.message.replace(/"/g, '').replace(/\$/g, '"');
+      };
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable('')).to.throw(error('""'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+    });
+
+    it('does not include an empty value of "and" operator', async function () {
+      const input1 = {foo: 'a1', and: []};
+      const input2 = {foo: 'a2', and: undefined};
+      const input3 = {foo: 'a3', and: null};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res1 = A._buildQuery('model', input1);
+      const res2 = A._buildQuery('model', input2);
+      const res3 = A._buildQuery('model', input3);
+      expect(res1).to.be.eql({foo: 'a1'});
+      expect(res2).to.be.eql({foo: 'a2'});
+      expect(res3).to.be.eql({foo: 'a3'});
+    });
+
+    it('does not include an empty value of "or" operator', async function () {
+      const input1 = {foo: 'a1', or: []};
+      const input2 = {foo: 'a2', or: undefined};
+      const input3 = {foo: 'a3', or: null};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res1 = A._buildQuery('model', input1);
+      const res2 = A._buildQuery('model', input2);
+      const res3 = A._buildQuery('model', input3);
+      expect(res1).to.be.eql({foo: 'a1'});
+      expect(res2).to.be.eql({foo: 'a2'});
+      expect(res3).to.be.eql({foo: 'a3'});
+    });
+
+    it('does not include an empty value of "nor" operator', async function () {
+      const input1 = {foo: 'a1', nor: []};
+      const input2 = {foo: 'a2', nor: undefined};
+      const input3 = {foo: 'a3', nor: null};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res1 = A._buildQuery('model', input1);
+      const res2 = A._buildQuery('model', input2);
+      const res3 = A._buildQuery('model', input3);
+      expect(res1).to.be.eql({foo: 'a1'});
+      expect(res2).to.be.eql({foo: 'a2'});
+      expect(res3).to.be.eql({foo: 'a3'});
+    });
+
+    it('converts the "and" operator to "$and"', async function () {
+      const input = {and: [{foo: 'bar'}, {baz: 'qux'}]};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res).to.be.eql({$and: [{foo: 'bar'}, {baz: 'qux'}]});
+    });
+
+    it('converts the "or" operator to "$or"', async function () {
+      const input = {or: [{foo: 'bar'}, {baz: 'qux'}]};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res).to.be.eql({$or: [{foo: 'bar'}, {baz: 'qux'}]});
+    });
+
+    it('converts the "nor" operator to "$nor"', async function () {
+      const input = {nor: [{foo: 'bar'}, {baz: 'qux'}]};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res).to.be.eql({$nor: [{foo: 'bar'}, {baz: 'qux'}]});
+    });
+
+    it('converts the "eq" operator to "$eq"', async function () {
+      const input = {foo: {eq: 'bar'}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res).to.be.eql({foo: {$eq: 'bar'}});
+    });
+
+    it('converts the "neq" operator to "$ne"', async function () {
+      const input = {foo: {neq: 'bar'}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res).to.be.eql({foo: {$ne: 'bar'}});
+    });
+
+    it('converts the "gt" operator to "$gt"', async function () {
+      const input = {foo: {gt: 5}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res).to.be.eql({foo: {$gt: 5}});
+    });
+
+    it('converts the "lt" operator to "$lt"', async function () {
+      const input = {foo: {lt: 5}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res).to.be.eql({foo: {$lt: 5}});
+    });
+
+    it('converts the "gte" operator to "$gte"', async function () {
+      const input = {foo: {gte: 5}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res).to.be.eql({foo: {$gte: 5}});
+    });
+
+    it('converts the "lte" operator to "$lte"', async function () {
+      const input = {foo: {lte: 5}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res).to.be.eql({foo: {$lte: 5}});
+    });
+
+    it('converts the "inq" operator to "$in"', async function () {
+      const input = {foo: {inq: [1, 2, 3]}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res).to.be.eql({foo: {$in: [1, 2, 3]}});
+    });
+
+    it('converts the "nin" operator to "$nin"', async function () {
+      const input = {foo: {nin: ['a', 'b', 'c']}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res).to.be.eql({foo: {$nin: ['a', 'b', 'c']}});
+    });
+
+    it('converts the "between" operator to "$gte" and "$lte"', async function () {
+      const input = {foo: {between: [1, 10]}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      const expected = {foo: {$gte: 1, $lte: 10}};
+      expect(res).to.be.eql(expected);
+    });
+
+    it('converts the "exists" operator to "$exists"', async function () {
+      const input1 = {foo: {exists: true}};
+      const input2 = {foo: {exists: false}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res1 = A._buildQuery('model', input1);
+      const res2 = A._buildQuery('model', input2);
+      expect(res1).to.be.eql({foo: {$exists: true}});
+      expect(res2).to.be.eql({foo: {$exists: false}});
+    });
+
+    it('converts the "like" operator to "$regex"', async function () {
+      const input = {foo: {like: 'test'}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res).to.be.eql({foo: {$regex: /test/}});
+    });
+
+    it('converts the "nlike" operator to "$not"', async function () {
+      const input = {foo: {nlike: 'test'}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res).to.be.eql({foo: {$not: /test/}});
+    });
+
+    it('converts the "ilike" operator to "$regex" with "i" flag', async function () {
+      const input = {foo: {ilike: 'test'}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res).to.be.eql({foo: {$regex: /test/i}});
+    });
+
+    it('converts the "nilike" operator to "$not" with "i" flag', async function () {
+      const input = {foo: {nilike: 'test'}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res).to.be.eql({foo: {$not: /test/i}});
+    });
+
+    it('converts property value to an instance of ObjectId', async function () {
+      const oid = new ObjectId();
+      const id = String(oid);
+      const input = {foo: id};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res.foo).to.be.instanceof(ObjectId);
+      expect(res.foo).to.be.eql(oid);
+    });
+
+    it('the "eq" operator converts ObjectId string to an instance', async function () {
+      const oid = new ObjectId();
+      const id = oid.toString();
+      const input = {foo: {eq: id}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const {
+        foo: {$eq: res},
+      } = A._buildQuery('model', input);
+      expect(res).to.be.instanceOf(ObjectId);
+      expect(res).to.be.eql(oid);
+    });
+
+    it('the "neq" operator converts ObjectId string to an instance', async function () {
+      const oid = new ObjectId();
+      const id = oid.toString();
+      const input = {foo: {neq: id}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const {
+        foo: {$ne: res},
+      } = A._buildQuery('model', input);
+      expect(res).to.be.instanceOf(ObjectId);
+      expect(res).to.be.eql(oid);
+    });
+
+    it('the "inq" operator converts ObjectId string to an instance', async function () {
+      const oid = new ObjectId();
+      const id = oid.toString();
+      const input = {foo: {inq: [id]}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const {
+        foo: {$in: res},
+      } = A._buildQuery('model', input);
+      expect(res[0]).to.be.instanceOf(ObjectId);
+      expect(res[0]).to.be.eql(oid);
+    });
+
+    it('the "nin" operator converts ObjectId string to an instance', async function () {
+      const oid = new ObjectId();
+      const id = oid.toString();
+      const input = {foo: {nin: [id]}};
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const {
+        foo: {$nin: res},
+      } = A._buildQuery('model', input);
+      expect(res[0]).to.be.instanceOf(ObjectId);
+      expect(res[0]).to.be.eql(oid);
+    });
+
+    it('combines the given operators by the "and" clause', async function () {
+      const input = {
+        foo: {
+          eq: 'bar',
+          neq: 'baz',
+          gt: 5,
+          lt: 10,
+          gte: 6,
+          lte: 9,
+          inq: ['qux'],
+          nin: ['qwe'],
+          between: [100, 200],
+          exists: true,
+          like: 'asd',
+          nlike: 'zxc',
+          ilike: 'rty',
+          nilike: 'fgh',
+          regexp: 'vbn',
+          flags: 'i',
+        },
+      };
+      const expected = {
+        $and: [
+          {foo: {$eq: 'bar'}},
+          {foo: {$ne: 'baz'}},
+          {foo: {$gt: 5}},
+          {foo: {$lt: 10}},
+          {foo: {$gte: 6}},
+          {foo: {$lte: 9}},
+          {foo: {$in: ['qux']}},
+          {foo: {$nin: ['qwe']}},
+          {foo: {$gte: 100, $lte: 200}},
+          {foo: {$exists: true}},
+          {foo: {$regex: /asd/}},
+          {foo: {$not: /zxc/}},
+          {foo: {$regex: /rty/i}},
+          {foo: {$not: /fgh/i}},
+          {foo: {$regex: /vbn/i}},
+        ],
+      };
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res).to.be.eql(expected);
+    });
+
+    it('combines the given operators by the existing "and" clause', async function () {
+      const input = {
+        and: [{featured: true}, {removed: false}],
+        foo: {
+          eq: 'bar',
+          neq: 'baz',
+          gt: 5,
+          lt: 10,
+          gte: 6,
+          lte: 9,
+          inq: ['qux'],
+          nin: ['qwe'],
+          between: [100, 200],
+          exists: true,
+          like: 'asd',
+          nlike: 'zxc',
+          ilike: 'rty',
+          nilike: 'fgh',
+          regexp: 'vbn',
+          flags: 'i',
+        },
+      };
+      const expected = {
+        $and: [
+          {featured: true},
+          {removed: false},
+          {foo: {$eq: 'bar'}},
+          {foo: {$ne: 'baz'}},
+          {foo: {$gt: 5}},
+          {foo: {$lt: 10}},
+          {foo: {$gte: 6}},
+          {foo: {$lte: 9}},
+          {foo: {$in: ['qux']}},
+          {foo: {$nin: ['qwe']}},
+          {foo: {$gte: 100, $lte: 200}},
+          {foo: {$exists: true}},
+          {foo: {$regex: /asd/}},
+          {foo: {$not: /zxc/}},
+          {foo: {$regex: /rty/i}},
+          {foo: {$not: /fgh/i}},
+          {foo: {$regex: /vbn/i}},
+        ],
+      };
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const res = A._buildQuery('model', input);
+      expect(res).to.be.eql(expected);
+    });
+  });
+
   describe('create', function () {
     it('generates a new identifier when a value of a primary key is not provided', async function () {
       const schema = createSchema();