@e22m4u/js-repository 0.8.4 → 0.8.6

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

@@ -19,39 +19,48 @@ export class FieldsClauseTool extends Service {
     const isArray = Array.isArray(input);
     let entities = isArray ? input : [input];
     entities.forEach(entity => {
-      if (!entity || typeof entity !== 'object' || Array.isArray(entity))
+      if (!entity || typeof entity !== 'object' || Array.isArray(entity)) {
         throw new InvalidArgumentError(
           'The first argument of FieldsClauseTool.filter should be an Object or ' +
             'an Array of Object, but %v was given.',
           entity,
         );
+      }
     });
 
-    if (!modelName || typeof modelName !== 'string')
+    if (!modelName || typeof modelName !== 'string') {
       throw new InvalidArgumentError(
         'The second argument of FieldsClauseTool.filter should be ' +
           'a non-empty String, but %v was given.',
         modelName,
       );
+    }
 
-    if (clause == null) return input;
+    if (clause == null) {
+      return input;
+    }
     const fields = Array.isArray(clause) ? clause.slice() : [clause];
-    if (!fields.length) return input;
+    if (!fields.length) {
+      return input;
+    }
 
     fields.forEach(field => {
-      if (!field || typeof field !== 'string')
+      if (!field || typeof field !== 'string') {
         throw new InvalidArgumentError(
           'The provided option "fields" should be a non-empty String ' +
             'or an Array of non-empty String, but %v was given.',
           field,
         );
+      }
     });
 
     const pkPropName =
       this.getService(ModelDefinitionUtils).getPrimaryKeyAsPropertyName(
         modelName,
       );
-    if (fields.indexOf(pkPropName) === -1) fields.push(pkPropName);
+    if (fields.indexOf(pkPropName) === -1) {
+      fields.push(pkPropName);
+    }
 
     entities = entities.map(entity => selectObjectKeys(entity, fields));
     return isArray ? entities : entities[0];
@@ -63,16 +72,21 @@ export class FieldsClauseTool extends Service {
    * @param {string|string[]|undefined} clause
    */
   static validateFieldsClause(clause) {
-    if (clause == null) return;
+    if (clause == null) {
+      return;
+    }
     const fields = Array.isArray(clause) ? clause : [clause];
-    if (!fields.length) return;
+    if (!fields.length) {
+      return;
+    }
     fields.forEach(field => {
-      if (!field || typeof field !== 'string')
+      if (!field || typeof field !== 'string') {
         throw new InvalidArgumentError(
           'The provided option "fields" should be a non-empty String ' +
             'or an Array of non-empty String, but %v was given.',
           field,
         );
+      }
     });
   }
 
@@ -83,16 +97,21 @@ export class FieldsClauseTool extends Service {
    * @returns {string[]|undefined}
    */
   static normalizeFieldsClause(clause) {
-    if (clause == null) return;
+    if (clause == null) {
+      return;
+    }
     const fields = Array.isArray(clause) ? clause : [clause];
-    if (!fields.length) return;
+    if (!fields.length) {
+      return;
+    }
     fields.forEach(field => {
-      if (!field || typeof field !== 'string')
+      if (!field || typeof field !== 'string') {
         throw new InvalidArgumentError(
           'The provided option "fields" should be a non-empty String ' +
             'or an Array of non-empty String, but %v was given.',
           field,
         );
+      }
     });
     return fields;
   }

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

@@ -178,8 +178,9 @@ export class IncludeClauseTool extends Service {
           relNames.push(el);
         } else if (typeof el === 'object') {
           Object.keys(el).forEach(key => {
-            if (Object.prototype.hasOwnProperty.call(el, key))
+            if (Object.prototype.hasOwnProperty.call(el, key)) {
               relNames.push(key);
+            }
           });
         }
       });
@@ -187,26 +188,32 @@ export class IncludeClauseTool extends Service {
       const duplicateNames = relNames.filter(
         (name, i) => relNames.indexOf(name) !== i,
       );
-      if (duplicateNames.length)
+      if (duplicateNames.length) {
         throw new InvalidArgumentError(
           'The provided option "include" has duplicates of %v.',
           duplicateNames[0],
         );
+      }
     } else if (typeof clause === 'object') {
       // validate object
       if ('relation' in clause) {
         // {relation: 'name', scope: {}}
-        if (!clause.relation || typeof clause.relation !== 'string')
+        if (!clause.relation || typeof clause.relation !== 'string') {
           throw new InvalidArgumentError(
             'The provided option "relation" should be ' +
               'a non-empty String, but %v was given.',
             clause.relation,
           );
-        if ('scope' in clause && clause) this.validateScopeClause(clause.scope);
+        }
+        if ('scope' in clause && clause) {
+          this.validateScopeClause(clause.scope);
+        }
       } else {
         // {foo: 'bar', 'baz': ['qux'], ...}
         Object.keys(clause).forEach(key => {
-          if (!Object.prototype.hasOwnProperty.call(clause, key)) return;
+          if (!Object.prototype.hasOwnProperty.call(clause, key)) {
+            return;
+          }
           this.validateIncludeClause(key);
           this.validateIncludeClause(clause[key]);
         });
@@ -227,12 +234,15 @@ export class IncludeClauseTool extends Service {
    * @param {object|undefined} clause
    */
   static validateScopeClause(clause) {
-    if (clause == null) return;
-    if (typeof clause !== 'object' || Array.isArray(clause))
+    if (clause == null) {
+      return;
+    }
+    if (typeof clause !== 'object' || Array.isArray(clause)) {
       throw new InvalidArgumentError(
         'The provided option "scope" should be an Object, but %v was given.',
         clause,
       );
+    }
     // {where: ...}
     if (clause.where != null) {
       WhereClauseTool.validateWhereClause(clause.where);
@@ -284,33 +294,41 @@ export class IncludeClauseTool extends Service {
       const duplicateNames = relNames.filter(
         (name, i) => relNames.indexOf(name) !== i,
       );
-      if (duplicateNames.length)
+      if (duplicateNames.length) {
         throw new InvalidArgumentError(
           'The provided option "include" has duplicates of %v.',
           duplicateNames[0],
         );
+      }
     } else if (typeof clause === 'object') {
       // normalize object
       if ('relation' in clause) {
         // {relation: 'name', scope: {...}}
-        if (!clause.relation || typeof clause.relation !== 'string')
+        if (!clause.relation || typeof clause.relation !== 'string') {
           throw new InvalidArgumentError(
             'The provided option "relation" should be ' +
               'a non-empty String, but %v was given.',
             clause.relation,
           );
+        }
         const normalized = {relation: clause.relation};
         const scope = this.normalizeScopeClause(clause.scope);
-        if (scope) normalized.scope = scope;
+        if (scope) {
+          normalized.scope = scope;
+        }
         result.push(normalized);
       } else {
         // {foo: 'bar', baz: ['qux'], ...}
         Object.keys(clause).forEach(key => {
-          if (!Object.prototype.hasOwnProperty.call(clause, key)) return;
+          if (!Object.prototype.hasOwnProperty.call(clause, key)) {
+            return;
+          }
           this.validateIncludeClause(key);
           const normalized = {relation: key};
           const include = this.normalizeIncludeClause(clause[key]);
-          if (include.length) normalized.scope = {include};
+          if (include.length) {
+            normalized.scope = {include};
+          }
           result.push(normalized);
         });
       }
@@ -332,12 +350,15 @@ export class IncludeClauseTool extends Service {
    * @returns {object|undefined}
    */
   static normalizeScopeClause(clause) {
-    if (clause == null) return;
-    if (typeof clause !== 'object' || Array.isArray(clause))
+    if (clause == null) {
+      return;
+    }
+    if (typeof clause !== 'object' || Array.isArray(clause)) {
       throw new InvalidArgumentError(
         'The provided option "scope" should be an Object, but %v was given.',
         clause,
       );
+    }
     const result = {};
     // {where: ...}
     if (clause.where != null) {
@@ -368,7 +389,9 @@ export class IncludeClauseTool extends Service {
     if (clause.include != null) {
       result.include = this.normalizeIncludeClause(clause.include);
     }
-    if (Object.keys(result).length) return result;
+    if (Object.keys(result).length) {
+      return result;
+    }
     return undefined;
   }
 }

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

@@ -47,8 +47,12 @@ export class OperatorClauseTool extends Service {
     }
     // лексикографическое сравнение
     if (type1 === 'string' && type2 === 'string') {
-      if (val1 > val2) return 1;
-      if (val1 < val2) return -1;
+      if (val1 > val2) {
+        return 1;
+      }
+      if (val1 < val2) {
+        return -1;
+      }
       return 0;
     }
     return NaN;
@@ -62,12 +66,13 @@ export class OperatorClauseTool extends Service {
    * @returns {boolean|undefined}
    */
   testAll(clause, value) {
-    if (!clause || typeof clause !== 'object' || Array.isArray(clause))
+    if (!clause || typeof clause !== 'object' || Array.isArray(clause)) {
       throw new InvalidArgumentError(
         'The first argument of OperatorUtils.testAll ' +
           'should be an Object, but %v was given.',
         clause,
       );
+    }
     const operatorMap = {
       eq: this.testEqNeq,
       neq: this.testEqNeq,
@@ -130,14 +135,19 @@ export class OperatorClauseTool extends Service {
    * @returns {boolean|undefined}
    */
   testEqNeq(clause, value) {
-    if (!clause || typeof clause !== 'object')
+    if (!clause || typeof clause !== 'object') {
       throw new InvalidArgumentError(
         'The first argument of OperatorUtils.testEqNeq ' +
           'should be an Object, but %v was given.',
         clause,
       );
-    if ('eq' in clause) return this.compare(clause.eq, value, true) === 0;
-    if ('neq' in clause) return this.compare(clause.neq, value, true) !== 0;
+    }
+    if ('eq' in clause) {
+      return this.compare(clause.eq, value, true) === 0;
+    }
+    if ('neq' in clause) {
+      return this.compare(clause.neq, value, true) !== 0;
+    }
   }
 
   /**
@@ -176,16 +186,25 @@ export class OperatorClauseTool extends Service {
    * @returns {boolean|undefined}
    */
   testGtLt(clause, value) {
-    if (!clause || typeof clause !== 'object')
+    if (!clause || typeof clause !== 'object') {
       throw new InvalidArgumentError(
         'The first argument of OperatorUtils.testGtLt ' +
           'should be an Object, but %v was given.',
         clause,
       );
-    if ('gt' in clause) return this.compare(value, clause.gt) > 0;
-    if ('gte' in clause) return this.compare(value, clause.gte) >= 0;
-    if ('lt' in clause) return this.compare(value, clause.lt) < 0;
-    if ('lte' in clause) return this.compare(value, clause.lte) <= 0;
+    }
+    if ('gt' in clause) {
+      return this.compare(value, clause.gt) > 0;
+    }
+    if ('gte' in clause) {
+      return this.compare(value, clause.gte) >= 0;
+    }
+    if ('lt' in clause) {
+      return this.compare(value, clause.lt) < 0;
+    }
+    if ('lte' in clause) {
+      return this.compare(value, clause.lte) <= 0;
+    }
   }
 
   /**
@@ -203,12 +222,13 @@ export class OperatorClauseTool extends Service {
    * @returns {boolean|undefined}
    */
   testInq(clause, value) {
-    if (!clause || typeof clause !== 'object')
+    if (!clause || typeof clause !== 'object') {
       throw new InvalidArgumentError(
         'The first argument of OperatorUtils.testInq ' +
           'should be an Object, but %v was given.',
         clause,
       );
+    }
     if ('inq' in clause && clause.inq !== undefined) {
       if (!clause.inq || !Array.isArray(clause.inq)) {
         throw new InvalidOperatorValueError(
@@ -241,12 +261,13 @@ export class OperatorClauseTool extends Service {
    * @returns {boolean|undefined}
    */
   testNin(clause, value) {
-    if (!clause || typeof clause !== 'object')
+    if (!clause || typeof clause !== 'object') {
       throw new InvalidArgumentError(
         'The first argument of OperatorUtils.testNin ' +
           'should be an Object, but %v was given.',
         clause,
       );
+    }
     if ('nin' in clause && clause.nin !== undefined) {
       if (!clause.nin || !Array.isArray(clause.nin)) {
         throw new InvalidOperatorValueError(
@@ -276,12 +297,13 @@ export class OperatorClauseTool extends Service {
    * @returns {boolean|undefined}
    */
   testBetween(clause, value) {
-    if (!clause || typeof clause !== 'object')
+    if (!clause || typeof clause !== 'object') {
       throw new InvalidArgumentError(
         'The first argument of OperatorUtils.testBetween ' +
           'should be an Object, but %v was given.',
         clause,
       );
+    }
     if ('between' in clause && clause.between !== undefined) {
       if (!Array.isArray(clause.between) || clause.between.length !== 2) {
         throw new InvalidOperatorValueError(
@@ -312,12 +334,13 @@ export class OperatorClauseTool extends Service {
    * @returns {boolean|undefined}
    */
   testExists(clause, value) {
-    if (!clause || typeof clause !== 'object')
+    if (!clause || typeof clause !== 'object') {
       throw new InvalidArgumentError(
         'The first argument of OperatorUtils.testExists ' +
           'should be an Object, but %v was given.',
         clause,
       );
+    }
     if ('exists' in clause && clause.exists !== undefined) {
       if (typeof clause.exists !== 'boolean') {
         throw new InvalidOperatorValueError(
@@ -345,15 +368,17 @@ export class OperatorClauseTool extends Service {
    * @returns {boolean|undefined}
    */
   testLike(clause, value) {
-    if (!clause || typeof clause !== 'object' || Array.isArray(clause))
+    if (!clause || typeof clause !== 'object' || Array.isArray(clause)) {
       throw new InvalidArgumentError(
         'The first argument of OperatorUtils.testLike ' +
           'should be an Object, but %v was given.',
         clause,
       );
+    }
     if ('like' in clause && clause.like !== undefined) {
-      if (typeof clause.like !== 'string')
+      if (typeof clause.like !== 'string') {
         throw new InvalidOperatorValueError('like', 'a String', clause.like);
+      }
       return likeToRegexp(clause.like).test(value);
     }
   }
@@ -373,12 +398,13 @@ export class OperatorClauseTool extends Service {
    * @returns {boolean|undefined}
    */
   testNlike(clause, value) {
-    if (!clause || typeof clause !== 'object' || Array.isArray(clause))
+    if (!clause || typeof clause !== 'object' || Array.isArray(clause)) {
       throw new InvalidArgumentError(
         'The first argument of OperatorUtils.testNlike ' +
           'should be an Object, but %v was given.',
         clause,
       );
+    }
     if ('nlike' in clause && clause.nlike !== undefined) {
       if (typeof clause.nlike !== 'string') {
         throw new InvalidOperatorValueError('nlike', 'a String', clause.nlike);
@@ -402,12 +428,13 @@ export class OperatorClauseTool extends Service {
    * @returns {boolean|undefined}
    */
   testIlike(clause, value) {
-    if (!clause || typeof clause !== 'object' || Array.isArray(clause))
+    if (!clause || typeof clause !== 'object' || Array.isArray(clause)) {
       throw new InvalidArgumentError(
         'The first argument of OperatorUtils.testIlike ' +
           'should be an Object, but %v was given.',
         clause,
       );
+    }
     if ('ilike' in clause && clause.ilike !== undefined) {
       if (typeof clause.ilike !== 'string') {
         throw new InvalidOperatorValueError('ilike', 'a String', clause.ilike);
@@ -431,12 +458,13 @@ export class OperatorClauseTool extends Service {
    * @returns {boolean|undefined}
    */
   testNilike(clause, value) {
-    if (!clause || typeof clause !== 'object' || Array.isArray(clause))
+    if (!clause || typeof clause !== 'object' || Array.isArray(clause)) {
       throw new InvalidArgumentError(
         'The first argument of OperatorUtils.testNilike ' +
           'should be an Object, but %v was given.',
         clause,
       );
+    }
     if ('nilike' in clause && clause.nilike !== undefined) {
       if (typeof clause.nilike !== 'string') {
         throw new InvalidOperatorValueError(
@@ -472,12 +500,13 @@ export class OperatorClauseTool extends Service {
    * @returns {boolean|undefined}
    */
   testRegexp(clause, value) {
-    if (!clause || typeof clause !== 'object')
+    if (!clause || typeof clause !== 'object') {
       throw new InvalidArgumentError(
         'The first argument of OperatorUtils.testRegexp ' +
           'should be an Object, but %v was given.',
         clause,
       );
+    }
     if ('regexp' in clause && clause.regexp !== undefined) {
       if (
         typeof clause.regexp !== 'string' &&
@@ -490,12 +519,15 @@ export class OperatorClauseTool extends Service {
         );
       }
       const flags = clause.flags || undefined;
-      if (flags && typeof flags !== 'string')
+      if (flags && typeof flags !== 'string') {
         throw new InvalidArgumentError(
           'RegExp flags should be a String, but %v was given.',
           clause.flags,
         );
-      if (!value || typeof value !== 'string') return false;
+      }
+      if (!value || typeof value !== 'string') {
+        return false;
+      }
       const regExp = stringToRegexp(clause.regexp, flags);
       return !!value.match(regExp);
     }

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

@@ -13,22 +13,31 @@ export class OrderClauseTool extends Service {
    * @param {string|string[]|undefined} clause
    */
   sort(entities, clause) {
-    if (clause == null) return;
-    if (Array.isArray(clause) === false) clause = [clause];
-    if (!clause.length) return;
+    if (clause == null) {
+      return;
+    }
+    if (Array.isArray(clause) === false) {
+      clause = [clause];
+    }
+    if (!clause.length) {
+      return;
+    }
     const mapping = [];
     clause.forEach((key, index) => {
-      if (!key || typeof key !== 'string')
+      if (!key || typeof key !== 'string') {
         throw new InvalidArgumentError(
           'The provided option "order" should be a non-empty String ' +
             'or an Array of non-empty String, but %v was given.',
           key,
         );
+      }
       let reverse = 1;
       const matches = key.match(/\s+(A|DE)SC$/i);
       if (matches) {
         key = key.replace(/\s+(A|DE)SC/i, '');
-        if (matches[1].toLowerCase() === 'de') reverse = -1;
+        if (matches[1].toLowerCase() === 'de') {
+          reverse = -1;
+        }
       }
       mapping[index] = {key: key, reverse};
     });
@@ -41,16 +50,23 @@ export class OrderClauseTool extends Service {
    * @param {string|string[]|undefined} clause
    */
   static validateOrderClause(clause) {
-    if (clause == null) return;
-    if (Array.isArray(clause) === false) clause = [clause];
-    if (!clause.length) return;
+    if (clause == null) {
+      return;
+    }
+    if (Array.isArray(clause) === false) {
+      clause = [clause];
+    }
+    if (!clause.length) {
+      return;
+    }
     clause.forEach(field => {
-      if (!field || typeof field !== 'string')
+      if (!field || typeof field !== 'string') {
         throw new InvalidArgumentError(
           'The provided option "order" should be a non-empty String ' +
             'or an Array of non-empty String, but %v was given.',
           field,
         );
+      }
     });
   }
 
@@ -61,16 +77,23 @@ export class OrderClauseTool extends Service {
    * @returns {string[]|undefined}
    */
   static normalizeOrderClause(clause) {
-    if (clause == null) return;
-    if (Array.isArray(clause) === false) clause = [clause];
-    if (!clause.length) return;
+    if (clause == null) {
+      return;
+    }
+    if (Array.isArray(clause) === false) {
+      clause = [clause];
+    }
+    if (!clause.length) {
+      return;
+    }
     clause.forEach(field => {
-      if (!field || typeof field !== 'string')
+      if (!field || typeof field !== 'string') {
         throw new InvalidArgumentError(
           'The provided option "order" should be a non-empty String ' +
             'or an Array of non-empty String, but %v was given.',
           field,
         );
+      }
     });
     return clause;
   }

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

@@ -14,22 +14,25 @@ export class SliceClauseTool extends Service {
    * @returns {object[]}
    */
   slice(entities, skip = undefined, limit = undefined) {
-    if (!Array.isArray(entities))
+    if (!Array.isArray(entities)) {
       throw new InvalidArgumentError(
         'The first argument of SliceClauseTool.slice ' +
           'should be an Array, but %v was given.',
         entities,
       );
-    if (skip != null && typeof skip !== 'number')
+    }
+    if (skip != null && typeof skip !== 'number') {
       throw new InvalidArgumentError(
         'The provided option "skip" should be a Number, but %v was given.',
         skip,
       );
-    if (limit != null && typeof limit !== 'number')
+    }
+    if (limit != null && typeof limit !== 'number') {
       throw new InvalidArgumentError(
         'The provided option "limit" should be a Number, but %v was given.',
         limit,
       );
+    }
     skip = skip || 0;
     limit = limit || entities.length;
     return entities.slice(skip, skip + limit);
@@ -41,12 +44,15 @@ export class SliceClauseTool extends Service {
    * @param {number|undefined} skip
    */
   static validateSkipClause(skip) {
-    if (skip == null) return;
-    if (typeof skip !== 'number')
+    if (skip == null) {
+      return;
+    }
+    if (typeof skip !== 'number') {
       throw new InvalidArgumentError(
         'The provided option "skip" should be a Number, but %v was given.',
         skip,
       );
+    }
   }
 
   /**
@@ -55,11 +61,14 @@ export class SliceClauseTool extends Service {
    * @param {number|undefined} limit
    */
   static validateLimitClause(limit) {
-    if (limit == null) return;
-    if (typeof limit !== 'number')
+    if (limit == null) {
+      return;
+    }
+    if (typeof limit !== 'number') {
       throw new InvalidArgumentError(
         'The provided option "limit" should be a Number, but %v was given.',
         limit,
       );
+    }
   }
 }