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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e22m4u/js-repository-mongodb-adapter",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "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.33"
+    "@e22m4u/js-repository": "~0.0.34"
   },
   "devDependencies": {
     "@commitlint/cli": "^17.7.1",

package/src/mongodb-adapter.js

@@ -267,14 +267,15 @@ export class MongodbAdapter extends Adapter {
    * @private
    */
   _buildProjection(modelName, fields) {
-    if (!fields) return;
-    fields = Array.isArray(fields) ? fields : [fields];
+    if (fields == null) return;
+    if (Array.isArray(fields) === false) fields = [fields];
     if (!fields.length) return;
     if (fields.indexOf('_id') === -1) fields.push('_id');
     return fields.reduce((acc, field) => {
       if (!field || typeof field !== 'string')
         throw new InvalidArgumentError(
-          'A field name must be a non-empty String, but %v given.',
+          'The provided option "fields" should be a non-empty String ' +
+            'or an Array of non-empty String, but %v given.',
           field,
         );
       let colName = this._getColName(modelName, field);
@@ -321,24 +322,25 @@ export class MongodbAdapter extends Adapter {
    * @private
    */
   _buildSort(modelName, clause) {
-    if (!clause) return;
-    clause = Array.isArray(clause) ? clause : [clause];
+    if (clause == null) return;
+    if (Array.isArray(clause) === false) clause = [clause];
     if (!clause.length) return;
     const utils = this.getService(ModelDefinitionUtils);
     const idPropName = this._getIdPropName(modelName);
     return clause.reduce((acc, order) => {
       if (!order || typeof order !== 'string')
         throw new InvalidArgumentError(
-          'A field order must be a non-empty String, but %v given.',
+          'The provided option "order" should be a non-empty String ' +
+            'or an Array of non-empty String, but %v given.',
           order,
         );
       const direction = order.match(/\s+(A|DE)SC$/);
-      let key = order.replace(/\s+(A|DE)SC$/, '').trim();
-      if (key === idPropName) {
-        key = '_id';
+      let field = order.replace(/\s+(A|DE)SC$/, '').trim();
+      if (field === idPropName) {
+        field = '_id';
       } else {
         try {
-          key = utils.getColumnNameByPropertyName(modelName, key);
+          field = utils.getColumnNameByPropertyName(modelName, field);
         } catch (error) {
           if (
             !(error instanceof InvalidArgumentError) ||
@@ -348,7 +350,7 @@ export class MongodbAdapter extends Adapter {
           }
         }
       }
-      acc[key] = direction && direction[1] === 'DE' ? -1 : 1;
+      acc[field] = direction && direction[1] === 'DE' ? -1 : 1;
       return acc;
     }, {});
   }
@@ -577,8 +579,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,
@@ -603,8 +605,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

@@ -41,6 +41,356 @@ describe('MongodbAdapter', function () {
     await MDB_CLIENT.close(true);
   });
 
+  describe('_buildProjection', function () {
+    describe('single field', function () {
+      it('returns undefined if the second argument is undefined', async function () {
+        const schema = createSchema();
+        schema.defineModel({name: 'model', datasource: 'mongodb'});
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const res = A._buildProjection('model', undefined);
+        expect(res).to.be.undefined;
+      });
+
+      it('returns undefined if the second argument is null', async function () {
+        const schema = createSchema();
+        schema.defineModel({name: 'model', datasource: 'mongodb'});
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const res = A._buildProjection('model', null);
+        expect(res).to.be.undefined;
+      });
+
+      it('requires the second argument to be a non-empty string', async function () {
+        const schema = createSchema();
+        schema.defineModel({name: 'model', datasource: 'mongodb'});
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const throwable = v => () => A._buildProjection('model', v);
+        const error = v =>
+          format(
+            'The provided option "fields" should be a non-empty String ' +
+              'or an Array of non-empty String, but %s given.',
+            v,
+          );
+        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({})).to.throw(error('Object'));
+        expect(throwable('bar')()).to.be.eql({_id: 1, bar: 1});
+        expect(throwable(undefined)()).to.be.undefined;
+        expect(throwable(null)()).to.be.undefined;
+      });
+
+      it('converts the given property name to the column name', async function () {
+        const schema = createSchema();
+        schema.defineModel({
+          name: 'model',
+          datasource: 'mongodb',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              columnName: 'bar',
+            },
+          },
+        });
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const res = A._buildProjection('model', 'foo');
+        expect(res).to.be.eql({_id: 1, bar: 1});
+      });
+
+      it('includes "_id" field to the projection', async function () {
+        const schema = createSchema();
+        schema.defineModel({name: 'model', datasource: 'mongodb'});
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const res = A._buildProjection('model', 'foo');
+        expect(res).to.be.eql({_id: 1, foo: 1});
+      });
+
+      it('includes "_id" as a column name of the given property', async function () {
+        const schema = createSchema();
+        schema.defineModel({
+          name: 'model',
+          datasource: 'mongodb',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              primaryKey: true,
+              columnName: '_id',
+            },
+          },
+        });
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const res = A._buildProjection('model', 'foo');
+        expect(res).to.be.eql({_id: 1});
+      });
+    });
+
+    describe('multiple fields', function () {
+      it('returns undefined if the second argument is an empty array', async function () {
+        const schema = createSchema();
+        schema.defineModel({name: 'model', datasource: 'mongodb'});
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const res = A._buildProjection('model', []);
+        expect(res).to.be.undefined;
+      });
+
+      it('requires the second argument to be an array of non-empty strings', async function () {
+        const schema = createSchema();
+        schema.defineModel({name: 'model', datasource: 'mongodb'});
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const throwable = v => () => A._buildProjection('model', v);
+        const error = v =>
+          format(
+            'The provided option "fields" should be a non-empty String ' +
+              'or an Array of non-empty String, but %s given.',
+            v,
+          );
+        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([{}])).to.throw(error('Object'));
+        expect(throwable([undefined])).to.throw(error('undefined'));
+        expect(throwable([null])).to.throw(error('null'));
+        expect(throwable([])()).to.be.undefined;
+        expect(throwable(['bar'])()).to.be.eql({_id: 1, bar: 1});
+      });
+
+      it('converts the given 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._buildProjection('model', ['foo', 'baz']);
+        expect(res).to.be.eql({_id: 1, bar: 1, qux: 1});
+      });
+
+      it('includes "_id" field to the projection', async function () {
+        const schema = createSchema();
+        schema.defineModel({name: 'model', datasource: 'mongodb'});
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const res = A._buildProjection('model', ['foo', 'bar']);
+        expect(res).to.be.eql({_id: 1, foo: 1, bar: 1});
+      });
+
+      it('includes "_id" as a column name of the given property', async function () {
+        const schema = createSchema();
+        schema.defineModel({
+          name: 'model',
+          datasource: 'mongodb',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              primaryKey: true,
+              columnName: '_id',
+            },
+          },
+        });
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const res = A._buildProjection('model', ['foo', 'bar']);
+        expect(res).to.be.eql({_id: 1, bar: 1});
+      });
+    });
+  });
+
+  describe('_buildSort', function () {
+    describe('single field', function () {
+      it('returns undefined if the second argument is undefined', async function () {
+        const schema = createSchema();
+        schema.defineModel({name: 'model', datasource: 'mongodb'});
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const res = A._buildSort('model', undefined);
+        expect(res).to.be.undefined;
+      });
+
+      it('returns undefined if the second argument is null', async function () {
+        const schema = createSchema();
+        schema.defineModel({name: 'model', datasource: 'mongodb'});
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const res = A._buildSort('model', null);
+        expect(res).to.be.undefined;
+      });
+
+      it('requires the second argument to be a non-empty string', async function () {
+        const schema = createSchema();
+        schema.defineModel({name: 'model', datasource: 'mongodb'});
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const throwable = v => () => A._buildSort('model', v);
+        const error = v =>
+          format(
+            'The provided option "order" should be a non-empty String ' +
+              'or an Array of non-empty String, but %s given.',
+            v,
+          );
+        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({})).to.throw(error('Object'));
+        expect(throwable('bar')()).to.be.eql({bar: 1});
+        expect(throwable(undefined)()).to.be.undefined;
+        expect(throwable(null)()).to.be.undefined;
+      });
+
+      it('recognizes direction by the given direction 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');
+        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});
+      });
+
+      it('converts the given property name to the column name', async function () {
+        const schema = createSchema();
+        schema.defineModel({
+          name: 'model',
+          datasource: 'mongodb',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              columnName: 'bar',
+            },
+          },
+        });
+        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({bar: 1});
+        expect(res2).to.be.eql({bar: -1});
+        expect(res3).to.be.eql({bar: 1});
+      });
+    });
+
+    describe('multiple fields', function () {
+      it('returns undefined if the second argument is an empty array', async function () {
+        const schema = createSchema();
+        schema.defineModel({name: 'model', datasource: 'mongodb'});
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const res = A._buildSort('model', []);
+        expect(res).to.be.undefined;
+      });
+
+      it('requires the second argument to be an array of non-empty strings', async function () {
+        const schema = createSchema();
+        schema.defineModel({name: 'model', datasource: 'mongodb'});
+        const A = await schema
+          .getService(AdapterRegistry)
+          .getAdapter('mongodb');
+        const throwable = v => () => A._buildSort('model', v);
+        const error = v =>
+          format(
+            'The provided option "order" should be a non-empty String ' +
+              'or an Array of non-empty String, but %s given.',
+            v,
+          );
+        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([{}])).to.throw(error('Object'));
+        expect(throwable([undefined])).to.throw(error('undefined'));
+        expect(throwable([null])).to.throw(error('null'));
+        expect(throwable([])()).to.be.undefined;
+        expect(throwable(['bar', 'baz'])()).to.be.eql({bar: 1, baz: 1});
+      });
+
+      it('recognizes direction by the given direction 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});
+      });
+
+      it('converts the given 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 res1 = A._buildSort('model', ['foo', 'baz']);
+        const res2 = A._buildSort('model', ['foo DESC', 'baz ASC']);
+        const res3 = A._buildSort('model', ['foo ASC', 'baz DESC']);
+        expect(res1).to.be.eql({bar: 1, qux: 1});
+        expect(res2).to.be.eql({bar: -1, qux: 1});
+        expect(res3).to.be.eql({bar: 1, qux: -1});
+      });
+    });
+  });
+
   describe('create', function () {
     it('generates a new identifier when a value of a primary key is not provided', async function () {
       const schema = createSchema();
@@ -949,6 +1299,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 () {
@@ -1301,6 +1666,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 () {