@e22m4u/js-repository 0.6.1 → 0.6.3

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

@@ -1,7 +1,10 @@
 import {Service} from '@e22m4u/js-service';
-import {stringToRegexp} from '../utils/index.js';
-import {InvalidArgumentError} from '../errors/index.js';
-import {InvalidOperatorValueError} from '../errors/index.js';
+import {isDeepEqual, likeToRegexp, stringToRegexp} from '../utils/index.js';
+
+import {
+  InvalidArgumentError,
+  InvalidOperatorValueError,
+} from '../errors/index.js';
 
 /**
  * Operator clause tool.
@@ -12,40 +15,43 @@ export class OperatorClauseTool extends Service {
    *
    * @param {*} val1 The 1st value
    * @param {*} val2 The 2nd value
+   * @param {*} noTypeConversion
    * @returns {number} 0: =, positive: >, negative <
    */
-  compare(val1, val2) {
+  compare(val1, val2, noTypeConversion = false) {
+    if (val1 === val2) {
+      return 0;
+    }
     if (val1 == null || val2 == null) {
       return val1 == val2 ? 0 : NaN;
     }
-    if (typeof val1 === 'number') {
-      if (
-        typeof val2 === 'number' ||
-        typeof val2 === 'string' ||
-        typeof val2 === 'boolean'
-      ) {
-        if (val1 === val2) return 0;
-        return val1 - Number(val2);
-      }
-      return NaN;
+    const type1 = typeof val1;
+    const type2 = typeof val2;
+    // объекты и массивы
+    if (type1 === 'object' || type2 === 'object') {
+      return isDeepEqual(val1, val2) ? 0 : NaN;
     }
-    if (typeof val1 === 'string') {
-      const isDigits = /^\d+$/.test(val1);
-      if (isDigits) return this.compare(Number(val1), val2);
-      try {
-        if (val1 > val2) return 1;
-        if (val1 < val2) return -1;
-        if (val1 == val2) return 0;
-      } catch (e) {
-        /**/
+    // числовое сравнение
+    if (
+      (type1 === 'number' || type1 === 'string' || type1 === 'boolean') &&
+      (type2 === 'number' || type2 === 'string' || type2 === 'boolean')
+    ) {
+      if (noTypeConversion && type1 !== type2) {
+        return NaN;
+      }
+      const num1 = Number(val1);
+      const num2 = Number(val2);
+      if (!isNaN(num1) && !isNaN(num2)) {
+        return num1 - num2;
       }
-      return NaN;
     }
-    if (typeof val1 === 'boolean') {
-      return Number(val1) - Number(val2);
+    // лексикографическое сравнение
+    if (type1 === 'string' && type2 === 'string') {
+      if (val1 > val2) return 1;
+      if (val1 < val2) return -1;
+      return 0;
     }
-    // Return NaN if we don't know how to compare.
-    return val1 === val2 ? 0 : NaN;
+    return NaN;
   }
 
   /**
@@ -62,54 +68,44 @@ export class OperatorClauseTool extends Service {
           'should be an Object, but %v was given.',
         clause,
       );
-
-    // {eq: ...}
-    // {neq: ...}
-    const eqNeqTest = this.testEqNeq(clause, value);
-    if (eqNeqTest !== undefined) return eqNeqTest;
-
-    // {gt: ...}
-    // {gte: ...}
-    // {lt: ...}
-    // {lte: ...}
-    const gtLtTest = this.testGtLt(clause, value);
-    if (gtLtTest !== undefined) return gtLtTest;
-
-    // {inc: ...}
-    const incTest = this.testInq(clause, value);
-    if (incTest !== undefined) return incTest;
-
-    // {nin: ...}
-    const ninTest = this.testNin(clause, value);
-    if (ninTest !== undefined) return ninTest;
-
-    // {between: ...}
-    const betweenTest = this.testBetween(clause, value);
-    if (betweenTest !== undefined) return betweenTest;
-
-    // {exists: ...}
-    const existsTest = this.testExists(clause, value);
-    if (existsTest !== undefined) return existsTest;
-
-    // {like: ...}
-    const likeTest = this.testLike(clause, value);
-    if (likeTest !== undefined) return likeTest;
-
-    // {nlike: ...}
-    const nlikeTest = this.testNlike(clause, value);
-    if (nlikeTest !== undefined) return nlikeTest;
-
-    // {ilike: ...}
-    const ilikeTest = this.testIlike(clause, value);
-    if (ilikeTest !== undefined) return ilikeTest;
-
-    // {nilike: ...}
-    const nilikeTest = this.testNilike(clause, value);
-    if (nilikeTest !== undefined) return nilikeTest;
-
-    // {regexp: ...}
-    const regExpTest = this.testRegexp(clause, value);
-    if (regExpTest !== undefined) return regExpTest;
+    const operatorMap = {
+      eq: this.testEqNeq,
+      neq: this.testEqNeq,
+      gt: this.testGtLt,
+      gte: this.testGtLt,
+      lt: this.testGtLt,
+      lte: this.testGtLt,
+      inq: this.testInq,
+      nin: this.testNin,
+      between: this.testBetween,
+      exists: this.testExists,
+      like: this.testLike,
+      nlike: this.testNlike,
+      ilike: this.testIlike,
+      nilike: this.testNilike,
+      regexp: this.testRegexp,
+    };
+    const clauseKeys = Object.keys(clause);
+    // поиск ключей, которые являются известными операторами
+    const knownOperators = clauseKeys.filter(key => operatorMap[key]);
+    // если в объекте clause нет ни одного известного оператора,
+    // то возвращается undefined, чтобы _test() продолжил сравнение
+    if (knownOperators.length === 0) {
+      return undefined;
+    }
+    // проверка каждого из операторов
+    return knownOperators.every(op => {
+      // временный объект с текущим оператором для передачи в тестер
+      const singleOpClause = {[op]: clause[op]};
+      // обработка для regexp, для передачи флагов
+      if (op === 'regexp' && 'flags' in clause) {
+        singleOpClause.flags = clause.flags;
+      }
+      // вызов тестера с передачей контекста
+      const testFn = operatorMap[op];
+      const result = testFn.call(this, singleOpClause, value);
+      return result;
+    });
   }
 
   /**
@@ -140,8 +136,8 @@ export class OperatorClauseTool extends Service {
           'should be an Object, but %v was given.',
         clause,
       );
-    if ('eq' in clause) return this.compare(clause.eq, value) === 0;
-    if ('neq' in clause) return this.compare(clause.neq, value) !== 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;
   }
 
   /**
@@ -222,7 +218,9 @@ export class OperatorClauseTool extends Service {
         );
       }
       for (let i = 0; i < clause.inq.length; i++) {
-        if (clause.inq[i] == value) return true;
+        if (this.compare(clause.inq[i], value, true) === 0) {
+          return true;
+        }
       }
       return false;
     }
@@ -257,10 +255,9 @@ export class OperatorClauseTool extends Service {
           clause.nin,
         );
       }
-      for (let i = 0; i < clause.nin.length; i++) {
-        if (clause.nin[i] == value) return false;
-      }
-      return true;
+      return clause.nin.every(element => {
+        return this.compare(element, value, true) !== 0;
+      });
     }
   }
 
@@ -348,16 +345,16 @@ export class OperatorClauseTool extends Service {
    * @returns {boolean|undefined}
    */
   testLike(clause, value) {
-    if (!clause || typeof clause !== 'object')
+    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' && !(clause.like instanceof RegExp))
+      if (typeof clause.like !== 'string')
         throw new InvalidOperatorValueError('like', 'a String', clause.like);
-      return stringToRegexp(clause.like).test(value);
+      return likeToRegexp(clause.like).test(value);
     }
   }
 
@@ -376,20 +373,17 @@ export class OperatorClauseTool extends Service {
    * @returns {boolean|undefined}
    */
   testNlike(clause, value) {
-    if (!clause || typeof clause !== 'object')
+    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' &&
-        !(clause.nlike instanceof RegExp)
-      ) {
+      if (typeof clause.nlike !== 'string') {
         throw new InvalidOperatorValueError('nlike', 'a String', clause.nlike);
       }
-      return !stringToRegexp(clause.nlike).test(value);
+      return !likeToRegexp(clause.nlike).test(value);
     }
   }
 
@@ -408,20 +402,17 @@ export class OperatorClauseTool extends Service {
    * @returns {boolean|undefined}
    */
   testIlike(clause, value) {
-    if (!clause || typeof clause !== 'object')
+    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' &&
-        !(clause.ilike instanceof RegExp)
-      ) {
+      if (typeof clause.ilike !== 'string') {
         throw new InvalidOperatorValueError('ilike', 'a String', clause.ilike);
       }
-      return stringToRegexp(clause.ilike, 'i').test(value);
+      return likeToRegexp(clause.ilike, true).test(value);
     }
   }
 
@@ -440,24 +431,21 @@ export class OperatorClauseTool extends Service {
    * @returns {boolean|undefined}
    */
   testNilike(clause, value) {
-    if (!clause || typeof clause !== 'object')
+    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' &&
-        !(clause.nilike instanceof RegExp)
-      ) {
+      if (typeof clause.nilike !== 'string') {
         throw new InvalidOperatorValueError(
           'nilike',
           'a String',
           clause.nilike,
         );
       }
-      return !stringToRegexp(clause.nilike, 'i').test(value);
+      return !likeToRegexp(clause.nilike, true).test(value);
     }
   }