@e22m4u/js-repository-mongodb-adapter 0.0.19 → 0.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e22m4u/js-repository-mongodb-adapter",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "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,15 +364,24 @@ 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 => {
       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));
+        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);
         query['$' + key] = cond;
         return;
       }
@@ -527,7 +536,7 @@ export class MongodbAdapter extends Adapter {
       // unknown
       query[key] = cond;
     });
-    return query;
+    return Object.keys(query).length ? query : undefined;
   }
 
   /**
@@ -579,8 +588,8 @@ export class MongodbAdapter extends Adapter {
     modelData[idPropName] = id;
     const tableData = this._toDatabase(modelName, modelData);
     const table = this._getCollection(modelName);
-    const {modifiedCount} = await table.replaceOne({_id: id}, tableData);
-    if (modifiedCount < 1)
+    const {matchedCount} = await table.replaceOne({_id: id}, tableData);
+    if (matchedCount < 1)
       throw new InvalidArgumentError('Identifier %v is not found.', String(id));
     const projection = this._buildProjection(
       modelName,
@@ -605,8 +614,8 @@ export class MongodbAdapter extends Adapter {
     delete modelData[idPropName];
     const tableData = this._toDatabase(modelName, modelData);
     const table = this._getCollection(modelName);
-    const {modifiedCount} = await table.updateOne({_id: id}, {$set: tableData});
-    if (modifiedCount < 1)
+    const {matchedCount} = await table.updateOne({_id: id}, {$set: tableData});
+    if (matchedCount < 1)
       throw new InvalidArgumentError('Identifier %v is not found.', String(id));
     const projection = this._buildProjection(
       modelName,

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,120 @@ 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('converts strings of the ObjectId to instances', async function () {
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const A = await schema.getService(AdapterRegistry).getAdapter('mongodb');
+      const oid1 = new ObjectId();
+      const oid2 = new ObjectId();
+      const id1 = String(oid1);
+      const id2 = String(oid2);
+      const res = A._buildQuery('model', {foo: id1, bar: id2});
+      expect(res.foo).to.be.instanceof(ObjectId);
+      expect(res.bar).to.be.instanceof(ObjectId);
+      expect(res.foo).to.be.eql(oid1);
+      expect(res.bar).to.be.eql(oid2);
+    });
+
+    it('adds "$" prefix to the "and", "or" and "nor" operator keys', async function () {
+      const input = {
+        and: [{foo: 'a1'}],
+        or: [{foo: 'a2'}],
+        nor: [{foo: 'a3'}],
+      };
+      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: 'a1'}],
+        $or: [{foo: 'a2'}],
+        $nor: [{foo: 'a3'}],
+      });
+    });
+
+    it('does not include an empty array of "and", "or" and "nor" operators', async function () {
+      const input1 = {foo: 'a1', and: [], or: [], nor: []};
+      const input2 = {foo: 'a2', and: undefined, or: undefined, nor: undefined};
+      const input3 = {foo: 'a3', and: null, or: null, 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('operators "and", "or" and "nor" are require 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 = (k, v) => () => A._buildQuery('model', {[k]: v});
+      const error = (k, v) => {
+        const e = new InvalidOperatorValueError(k, 'an Array', v);
+        return e.message;
+      };
+      const testOf = v => {
+        expect(throwable('and', v)).to.throw(error('and', v));
+        expect(throwable('or', v)).to.throw(error('or', v));
+        expect(throwable('nor', v)).to.throw(error('nor', v));
+      };
+      testOf('str');
+      testOf('');
+      testOf(10);
+      testOf(0);
+      testOf(true);
+      testOf(false);
+    });
+  });
+
   describe('create', function () {
     it('generates a new identifier when a value of a primary key is not provided', async function () {
       const schema = createSchema();
@@ -1299,6 +1456,21 @@ describe('MongodbAdapter', function () {
         .findOne({_id: oid});
       expect(rawData).to.be.eql({_id: oid, fooCol: 15, barCol: 25, bazCol: 35});
     });
+
+    it('does not throws an error if nothing changed', async function () {
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const rep = schema.getRepository('model');
+      const created = await rep.create({foo: 10});
+      const id = created[DEF_PK];
+      const replaced = await rep.replaceById(id, {foo: 10});
+      expect(replaced).to.be.eql({[DEF_PK]: id, foo: 10});
+      const oid = new ObjectId(id);
+      const rawData = await MDB_CLIENT.db()
+        .collection('model')
+        .findOne({_id: oid});
+      expect(rawData).to.be.eql({_id: oid, foo: 10});
+    });
   });
 
   describe('patchById', function () {
@@ -1651,6 +1823,21 @@ describe('MongodbAdapter', function () {
         .findOne({_id: oid});
       expect(rawData).to.be.eql({_id: oid, fooCol: 15, barCol: 25, bazCol: 35});
     });
+
+    it('does not throws an error if nothing changed', async function () {
+      const schema = createSchema();
+      schema.defineModel({name: 'model', datasource: 'mongodb'});
+      const rep = schema.getRepository('model');
+      const created = await rep.create({foo: 10});
+      const id = created[DEF_PK];
+      const patched = await rep.patchById(id, {foo: 10});
+      expect(patched).to.be.eql({[DEF_PK]: id, foo: 10});
+      const oid = new ObjectId(id);
+      const rawData = await MDB_CLIENT.db()
+        .collection('model')
+        .findOne({_id: oid});
+      expect(rawData).to.be.eql({_id: oid, foo: 10});
+    });
   });
 
   describe('find', function () {