@e22m4u/js-repository 0.8.7 → 0.8.9

package/src/filter/order-clause-tool.spec.js

@@ -6,8 +6,68 @@ const S = new OrderClauseTool();
 
 describe('OrderClauseTool', function () {
   describe('sort', function () {
+    it('should require the parameter "entities" to be an array', function () {
+      const throwable = v => () => S.sort(v, 'prop');
+      const error = s =>
+        format('Parameter "entities" must be an Array, but %s was given.', s);
+      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({})).to.throw(error('Object'));
+      expect(throwable(undefined)).to.throw(error('undefined'));
+      expect(throwable(null)).to.throw(error('null'));
+      throwable([{prop: true}])();
+      throwable([{}])();
+    });
+
+    it('should require the parameter "clause" to be a correct value', function () {
+      const entities = [{prop: 1}, {prop: 2}];
+      const throwable = v => () => S.sort(entities, v);
+      const error = s =>
+        format(
+          'Option "order" must be a non-empty String or an Array ' +
+            'of non-empty String, but %s was given.',
+          s,
+        );
+      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'));
+      throwable('prop')();
+      throwable(['prop'])();
+      throwable([])();
+      throwable(undefined)();
+      throwable(null)();
+    });
+
+    it('should require elements of the parameter "clause" to be a non-empty string', function () {
+      const entities = [{prop: 1}, {prop: 2}];
+      const throwable = v => () => S.sort(entities, [v]);
+      const error = s =>
+        format(
+          'Element 0 of the option "order" must be a non-empty String, ' +
+            'but %s was given.',
+          s,
+        );
+      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('Array'));
+      expect(throwable({})).to.throw(error('Object'));
+      expect(throwable(undefined)).to.throw(error('undefined'));
+      expect(throwable(null)).to.throw(error('null'));
+      throwable('prop')();
+    });
+
     describe('single field', function () {
-      it('does not throw an error if the given field is not exist', function () {
+      it('does not throw an error if the given field does not exist', function () {
         const objects = [{foo: 1}, {foo: 2}, {foo: 3}, {foo: 4}];
         S.sort(objects, 'bar');
         expect(objects).to.have.length(4);
@@ -83,7 +143,7 @@ describe('OrderClauseTool', function () {
     });
 
     describe('multiple fields', function () {
-      it('does not throw an error if multiple fields are not exist', function () {
+      it('does not throw an error if multiple fields do not exist', function () {
         const objects = [{foo: 1}, {foo: 2}, {foo: 3}, {foo: 4}];
         S.sort(objects, ['bar', 'baz']);
         expect(objects).to.have.length(4);
@@ -281,7 +341,7 @@ describe('OrderClauseTool', function () {
     });
 
     describe('nested single field', function () {
-      it('does not throw an error if the nested field is not exist', function () {
+      it('does not throw an error if the nested field does not exist', function () {
         const objects = [
           {foo: 1},
           {foo: 2, bar: undefined},
@@ -392,7 +452,7 @@ describe('OrderClauseTool', function () {
     });
 
     describe('nested multiple fields', function () {
-      it('does not throw an error if nested multiple fields are not exist', function () {
+      it('does not throw an error if nested multiple fields do not exist', function () {
         const objects = [
           {foo: 1},
           {foo: 2, bar: undefined},
@@ -596,102 +656,103 @@ describe('OrderClauseTool', function () {
   });
 
   describe('validateOrderClause', function () {
-    describe('single field', function () {
-      it('requires the first argument as a non-empty string', function () {
-        const throwable = v => () => OrderClauseTool.validateOrderClause(v);
-        const error = v =>
-          format(
-            'The provided option "order" should be a non-empty String ' +
-              'or an Array of non-empty String, but %s was 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'));
-        throwable('field')();
-        throwable(undefined)();
-        throwable(null)();
-      });
+    it('should require the parameter "clause" to be a correct value', function () {
+      const throwable = v => () => OrderClauseTool.validateOrderClause(v);
+      const error = s =>
+        format(
+          'Option "order" must be a non-empty String or an Array ' +
+            'of non-empty String, but %s was given.',
+          s,
+        );
+      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'));
+      throwable('prop')();
+      throwable(['prop'])();
+      throwable([])();
+      throwable(undefined)();
+      throwable(null)();
     });
 
-    describe('multiple fields', function () {
-      it('requires the first argument as a non-empty string', function () {
-        const throwable = v => () => OrderClauseTool.validateOrderClause(v);
-        const error = v =>
-          format(
-            'The provided option "order" should be a non-empty String ' +
-              'or an Array of non-empty String, but %s was 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'));
-        throwable(['field'])();
-        throwable([])();
-      });
+    it('should require elements of the parameter "clause" to be a non-empty string', function () {
+      const throwable = v => () => OrderClauseTool.validateOrderClause([v]);
+      const error = s =>
+        format(
+          'Element 0 of the option "order" must be a non-empty String, ' +
+            'but %s was given.',
+          s,
+        );
+      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('Array'));
+      expect(throwable({})).to.throw(error('Object'));
+      expect(throwable(undefined)).to.throw(error('undefined'));
+      expect(throwable(null)).to.throw(error('null'));
+      throwable('prop')();
     });
   });
 
   describe('normalizeOrderClause', function () {
-    describe('single field', function () {
-      it('requires the first argument as a non-empty string', function () {
-        const throwable = v => () => OrderClauseTool.normalizeOrderClause(v);
-        const error = v =>
-          format(
-            'The provided option "order" should be a non-empty String ' +
-              'or an Array of non-empty String, but %s was 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('field')()).to.be.eql(['field']);
-        expect(throwable(undefined)()).to.be.undefined;
-        expect(throwable(null)()).to.be.undefined;
-      });
+    it('should require the parameter "clause" to be a correct value', function () {
+      const throwable = v => () => OrderClauseTool.normalizeOrderClause(v);
+      const error = s =>
+        format(
+          'Option "order" must be a non-empty String or an Array ' +
+            'of non-empty String, but %s was given.',
+          s,
+        );
+      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'));
+      throwable('prop')();
+      throwable(['prop'])();
+      throwable([])();
+      throwable(undefined)();
+      throwable(null)();
+    });
 
-      it('returns an array of string', function () {
-        const fn = OrderClauseTool.normalizeOrderClause;
-        expect(fn('foo')).to.be.eql(['foo']);
-      });
+    it('should require elements of the parameter "clause" to be a non-empty string', function () {
+      const throwable = v => () => OrderClauseTool.normalizeOrderClause([v]);
+      const error = s =>
+        format(
+          'Element 0 of the option "order" must be a non-empty String, ' +
+            'but %s was given.',
+          s,
+        );
+      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('Array'));
+      expect(throwable({})).to.throw(error('Object'));
+      expect(throwable(undefined)).to.throw(error('undefined'));
+      expect(throwable(null)).to.throw(error('null'));
+      throwable('prop')();
     });
 
-    describe('multiple fields', function () {
-      it('requires the first argument as a non-empty string', function () {
-        const throwable = v => () => OrderClauseTool.normalizeOrderClause(v);
-        const error = v =>
-          format(
-            'The provided option "order" should be a non-empty String ' +
-              'or an Array of non-empty String, but %s was 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(['field'])()).to.be.eql(['field']);
-        expect(throwable([])()).to.be.undefined;
-      });
+    it('should wrap a string value with an array', function () {
+      const res = OrderClauseTool.normalizeOrderClause('foo');
+      expect(res).to.be.eql(['foo']);
+    });
 
-      it('returns an array of strings', function () {
-        const fn = OrderClauseTool.normalizeOrderClause;
-        expect(fn(['foo', 'bar'])).to.be.eql(['foo', 'bar']);
-      });
+    it('should return a non-empty array as is', function () {
+      const res = OrderClauseTool.normalizeOrderClause(['foo', 'bar']);
+      expect(res).to.be.eql(['foo', 'bar']);
+    });
+
+    it('should return undefined for an empty array', function () {
+      const res = OrderClauseTool.normalizeOrderClause([]);
+      expect(res).to.be.undefined;
     });
   });
 });

package/src/filter/slice-clause-tool.js

@@ -16,20 +16,19 @@ export class SliceClauseTool extends Service {
   slice(entities, skip = undefined, limit = undefined) {
     if (!Array.isArray(entities)) {
       throw new InvalidArgumentError(
-        'The first argument of SliceClauseTool.slice ' +
-          'should be an Array, but %v was given.',
+        'Parameter "entities" must be an Array, but %v was given.',
         entities,
       );
     }
     if (skip != null && typeof skip !== 'number') {
       throw new InvalidArgumentError(
-        'The provided option "skip" should be a Number, but %v was given.',
+        'Option "skip" must be a Number, but %v was given.',
         skip,
       );
     }
     if (limit != null && typeof limit !== 'number') {
       throw new InvalidArgumentError(
-        'The provided option "limit" should be a Number, but %v was given.',
+        'Option "limit" must be a Number, but %v was given.',
         limit,
       );
     }
@@ -49,7 +48,7 @@ export class SliceClauseTool extends Service {
     }
     if (typeof skip !== 'number') {
       throw new InvalidArgumentError(
-        'The provided option "skip" should be a Number, but %v was given.',
+        'Option "skip" must be a Number, but %v was given.',
         skip,
       );
     }
@@ -66,7 +65,7 @@ export class SliceClauseTool extends Service {
     }
     if (typeof limit !== 'number') {
       throw new InvalidArgumentError(
-        'The provided option "limit" should be a Number, but %v was given.',
+        'Option "limit" must be a Number, but %v was given.',
         limit,
       );
     }

package/src/filter/slice-clause-tool.spec.js

@@ -6,14 +6,10 @@ const S = new SliceClauseTool();
 
 describe('SliceClauseTool', function () {
   describe('slice', function () {
-    it('requires the first argument to be an array', function () {
+    it('requires the parameter "entities" to be an array', function () {
       const throwable = v => () => S.slice(v);
       const error = v =>
-        format(
-          'The first argument of SliceClauseTool.slice ' +
-            'should be an Array, but %s was given.',
-          v,
-        );
+        format('Parameter "entities" must be an Array, but %s was given.', v);
       expect(throwable('str')).to.throw(error('"str"'));
       expect(throwable('')).to.throw(error('""'));
       expect(throwable(10)).to.throw(error('10'));
@@ -27,14 +23,11 @@ describe('SliceClauseTool', function () {
       expect(throwable([])()).to.be.eql([]);
     });
 
-    it('requires the provided second argument to be a number', function () {
+    it('requires the parameter "skip" to be a number', function () {
       const items = [{foo: 'bar'}];
       const throwable = v => () => S.slice(items, v);
       const error = v =>
-        format(
-          'The provided option "skip" should be a Number, but %s was given.',
-          v,
-        );
+        format('Option "skip" must be a Number, but %s was given.', v);
       expect(throwable('str')).to.throw(error('"str"'));
       expect(throwable('')).to.throw(error('""'));
       expect(throwable(true)).to.throw(error('true'));
@@ -47,14 +40,11 @@ describe('SliceClauseTool', function () {
       expect(throwable(null)()).to.be.eql(items);
     });
 
-    it('requires the provided third argument to be a number', function () {
+    it('requires the parameter "limit" to be a number', function () {
       const items = [{foo: 'bar'}];
       const throwable = v => () => S.slice(items, undefined, v);
       const error = v =>
-        format(
-          'The provided option "limit" should be a Number, but %s was given.',
-          v,
-        );
+        format('Option "limit" must be a Number, but %s was given.', v);
       expect(throwable('str')).to.throw(error('"str"'));
       expect(throwable('')).to.throw(error('""'));
       expect(throwable(true)).to.throw(error('true'));
@@ -118,10 +108,7 @@ describe('SliceClauseTool', function () {
     it('requires a number value', function () {
       const throwable = v => () => SliceClauseTool.validateSkipClause(v);
       const error = v =>
-        format(
-          'The provided option "skip" should be a Number, but %s was given.',
-          v,
-        );
+        format('Option "skip" must be a Number, but %s was given.', v);
       expect(throwable('str')).to.throw(error('"str"'));
       expect(throwable('')).to.throw(error('""'));
       expect(throwable(true)).to.throw(error('true'));
@@ -139,10 +126,7 @@ describe('SliceClauseTool', function () {
     it('requires a number value or a falsy value', function () {
       const throwable = v => () => SliceClauseTool.validateLimitClause(v);
       const error = v =>
-        format(
-          'The provided option "limit" should be a Number, but %s was given.',
-          v,
-        );
+        format('Option "limit" must be a Number, but %s was given.', v);
       expect(throwable('str')).to.throw(error('"str"'));
       expect(throwable('')).to.throw(error('""'));
       expect(throwable(true)).to.throw(error('true'));

package/src/filter/where-clause-tool.js

@@ -41,8 +41,7 @@ export class WhereClauseTool extends Service {
   filter(entities, where = undefined) {
     if (!Array.isArray(entities)) {
       throw new InvalidArgumentError(
-        'The first argument of WhereClauseTool.filter should be ' +
-          'an Array of Object, but %v was given.',
+        'Parameter "entities" must be an Array of Object, but %v was given.',
         entities,
       );
     }
@@ -59,18 +58,22 @@ export class WhereClauseTool extends Service {
    * @returns {Function}
    */
   _createFilter(whereClause) {
-    if (typeof whereClause !== 'object' || Array.isArray(whereClause)) {
+    if (
+      !whereClause ||
+      typeof whereClause !== 'object' ||
+      Array.isArray(whereClause)
+    ) {
       throw new InvalidArgumentError(
-        'The provided option "where" should be an Object, but %v was given.',
+        'Option "where" must be an Object, but %v was given.',
         whereClause,
       );
     }
     const keys = Object.keys(whereClause);
-    return data => {
-      if (typeof data !== 'object') {
+    return (data, index) => {
+      if (!data || typeof data !== 'object' || Array.isArray(data)) {
         throw new InvalidArgumentError(
-          'The first argument of WhereClauseTool.filter should be ' +
-            'an Array of Object, but %v was given.',
+          'Entity at index %d must be an Object, but %v was given.',
+          index,
           data,
         );
       }
@@ -79,14 +82,18 @@ export class WhereClauseTool extends Service {
         if (key === 'and' && key in whereClause) {
           const andClause = whereClause[key];
           if (Array.isArray(andClause)) {
-            return andClause.every(clause => this._createFilter(clause)(data));
+            return andClause.every(clause =>
+              this._createFilter(clause)(data, index),
+            );
           }
         }
         // OrClause (recursion)
         else if (key === 'or' && key in whereClause) {
           const orClause = whereClause[key];
           if (Array.isArray(orClause)) {
-            return orClause.some(clause => this._createFilter(clause)(data));
+            return orClause.some(clause =>
+              this._createFilter(clause)(data, index),
+            );
           }
         }
         // PropertiesClause (properties)
@@ -172,7 +179,7 @@ export class WhereClauseTool extends Service {
     }
     if (typeof clause !== 'object' || Array.isArray(clause)) {
       throw new InvalidArgumentError(
-        'The provided option "where" should be an Object, but %v was given.',
+        'Option "where" must be an Object, but %v was given.',
         clause,
       );
     }

package/src/filter/where-clause-tool.spec.js

@@ -59,13 +59,12 @@ const OBJECTS = [
 
 describe('WhereClauseTool', function () {
   describe('filter', function () {
-    it('requires the first argument to be an array of objects', function () {
+    it('requires the parameter "entities" to be an array of objects', function () {
       const throwable = v => () => S.filter(v, {});
-      const error = v =>
+      const error = s =>
         format(
-          'The first argument of WhereClauseTool.filter should be ' +
-            'an Array of Object, but %s was given.',
-          v,
+          'Parameter "entities" must be an Array of Object, but %s was given.',
+          s,
         );
       expect(throwable('str')).to.throw(error('"str"'));
       expect(throwable('')).to.throw(error('""'));
@@ -80,13 +79,27 @@ describe('WhereClauseTool', function () {
       expect(throwable([])()).to.be.eql([]);
     });
 
-    it('requires the second argument to be an object', function () {
+    it('requires elements of the parameter "entities" to be an object', function () {
+      const throwable = v => () => S.filter([v], {});
+      const error = s =>
+        format('Entity at index 0 must be an Object, but %s was given.', s);
+      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([])).to.throw(error('Array'));
+      expect(throwable(undefined)).to.throw(error('undefined'));
+      expect(throwable(null)).to.throw(error('null'));
+      throwable({foo: 'bar'})();
+      throwable({})();
+    });
+
+    it('requires the parameter "where" to be an object', function () {
       const throwable = v => () => S.filter(OBJECTS, v);
-      const error = v =>
-        format(
-          'The provided option "where" should be an Object, but %s was given.',
-          v,
-        );
+      const error = s =>
+        format('Option "where" must be an Object, but %s was given.', s);
       expect(throwable('str')).to.throw(error('"str"'));
       expect(throwable('')).to.throw(error('""'));
       expect(throwable(10)).to.throw(error('10'));
@@ -390,13 +403,10 @@ describe('WhereClauseTool', function () {
   });
 
   describe('validateWhereClause', function () {
-    it('requires the first argument to be an object or a function', function () {
+    it('requires the option "where" to be an object or a function', function () {
       const throwable = v => () => WhereClauseTool.validateWhereClause(v);
-      const error = v =>
-        format(
-          'The provided option "where" should be an Object, but %s was given.',
-          v,
-        );
+      const error = s =>
+        format('Option "where" must be an Object, but %s was given.', s);
       expect(throwable('str')).to.throw(error('"str"'));
       expect(throwable('')).to.throw(error('""'));
       expect(throwable(10)).to.throw(error('10'));