feat(filter): add "includes all" filter to array type

Vincent Molinié · web-flow · commit 21f96694cb54 · 2021-03-05T17:41:57.000+01:00
diff --git a/.babelrc b/.babelrc
@@ -15,5 +15,6 @@
     "@babel/plugin-proposal-optional-chaining",
     "@babel/plugin-transform-runtime",
     "@babel/plugin-transform-arrow-functions",
+    "@babel/plugin-proposal-class-properties"
   ]
 }
diff --git a/package.json b/package.json
@@ -36,6 +36,7 @@
   "devDependencies": {
     "@babel/cli": "7.10.1",
     "@babel/core": "7.10.1",
+    "@babel/plugin-proposal-class-properties": "7.13.0",
     "@babel/plugin-proposal-optional-chaining": "7.10.1",
     "@babel/plugin-transform-arrow-functions": "7.10.4",
     "@babel/plugin-transform-runtime": "7.10.1",
diff --git a/src/services/composite-keys-manager.js b/src/services/composite-keys-manager.js
@@ -17,7 +17,7 @@ function CompositeKeysManager(model, schema, record) {
   };
 
   this.getRecordsConditions = function getRecordsConditions(recordsIds, options) {
-    const { OR } = new Operators(options);
+    const { OR } = Operators.getInstance(options);
     return { [OR]: recordsIds.map((recordId) => this.getRecordConditions(recordId)) };
   };
 
diff --git a/src/services/filters-parser.js b/src/services/filters-parser.js
@@ -5,7 +5,7 @@ import { NoMatchingOperatorError } from './errors';
 const { getReferenceSchema, getReferenceField } = require('../utils/query');
 
 function FiltersParser(modelSchema, timezone, options) {
-  this.OPERATORS = new Operators(options);
+  this.OPERATORS = Operators.getInstance(options);
   this.operatorDateParser = new BaseOperatorDateParser({ operators: this.OPERATORS, timezone });
 
   this.perform = async (filtersString) =>
@@ -59,58 +59,6 @@ function FiltersParser(modelSchema, timezone, options) {
     }
   };
 
-  this.formatOperator = (operator) => {
-    switch (operator) {
-      case 'not':
-        return this.OPERATORS.NOT;
-      case 'greater_than':
-      case 'after':
-        return this.OPERATORS.GT;
-      case 'less_than':
-      case 'before':
-        return this.OPERATORS.LT;
-      case 'contains':
-      case 'starts_with':
-      case 'ends_with':
-        return this.OPERATORS.LIKE;
-      case 'not_contains':
-        return this.OPERATORS.NOT_LIKE;
-      case 'present':
-      case 'not_equal':
-        return this.OPERATORS.NE;
-      case 'blank':
-      case 'equal':
-        return this.OPERATORS.EQ;
-      default:
-        throw new NoMatchingOperatorError();
-    }
-  };
-
-  this.formatValue = (operator, value) => {
-    switch (operator) {
-      case 'not':
-      case 'greater_than':
-      case 'less_than':
-      case 'not_equal':
-      case 'equal':
-      case 'before':
-      case 'after':
-        return value;
-      case 'contains':
-      case 'not_contains':
-        return `%${value}%`;
-      case 'starts_with':
-        return `${value}%`;
-      case 'ends_with':
-        return `%${value}`;
-      case 'present':
-      case 'blank':
-        return null;
-      default:
-        throw new NoMatchingOperatorError();
-    }
-  };
-
   this.formatOperatorValue = (operator, value, isTextField = false) => {
     switch (operator) {
       case 'not':
@@ -143,6 +91,8 @@ function FiltersParser(modelSchema, timezone, options) {
         } : { [this.OPERATORS.EQ]: null };
       case 'equal':
         return { [this.OPERATORS.EQ]: value };
+      case 'includes_all':
+        return { [this.OPERATORS.CONTAINS]: value };
       default:
         throw new NoMatchingOperatorError();
     }
diff --git a/src/services/has-many-dissociator.js b/src/services/has-many-dissociator.js
@@ -4,7 +4,7 @@ const orm = require('../utils/orm');
 const { ErrorHTTP422 } = require('./errors');
 
 function HasManyDissociator(model, association, options, params, data) {
-  const OPERATORS = new Operators(options);
+  const OPERATORS = Operators.getInstance(options);
   const isDelete = Boolean(params.delete);
 
   this.perform = () => {
diff --git a/src/services/resources-getter.js b/src/services/resources-getter.js
@@ -15,7 +15,7 @@ function ResourcesGetter(model, options, params) {
   const queryBuilder = new QueryBuilder(model, options, params);
   let segmentScope;
   let segmentWhere;
-  const OPERATORS = new Operators(options);
+  const OPERATORS = Operators.getInstance(options);
   const primaryKey = _.keys(model.primaryKeys)[0];
   const filterParser = new FiltersParser(schema, params.timezone, options);
   let fieldNamesRequested;
diff --git a/src/services/search-builder.js b/src/services/search-builder.js
@@ -13,7 +13,7 @@ function SearchBuilder(model, opts, params, fieldNamesRequested) {
   let associations = _.clone(model.associations);
   const hasSearchFields = schema.searchFields && _.isArray(schema.searchFields);
   let searchAssociationFields;
-  const OPERATORS = new Operators(opts);
+  const OPERATORS = Operators.getInstance(opts);
   const fieldsSearched = [];
   let hasExtendedConditions = false;
 
diff --git a/src/services/value-stat-getter.js b/src/services/value-stat-getter.js
@@ -5,7 +5,7 @@ import FiltersParser from './filters-parser';
 import Orm from '../utils/orm';
 
 function ValueStatGetter(model, params, options) {
-  const OPERATORS = new Operators(options);
+  const OPERATORS = Operators.getInstance(options);
 
   this.operatorDateParser = new BaseOperatorDateParser({
     operators: OPERATORS,
diff --git a/src/utils/operators.js b/src/utils/operators.js
@@ -1,11 +1,14 @@
-let instance = null;
+class Operators {
+  static _instance = null;
 
-function Operators(options) {
-  if (instance) return instance;
+  static _isNewSequelizeOp(options) {
+    return !!(options && options.Sequelize && options.Sequelize.Op);
+  }
 
-  if (options && options.Sequelize && options.Sequelize.Op) {
+  _setupNewSequelizeOp(options) {
     const { Op } = options.Sequelize;
     this.AND = Op.and;
+    this.CONTAINS = Op.contains;
     this.EQ = Op.eq;
     this.GT = Op.gt;
     this.GTE = Op.gte;
@@ -17,8 +20,11 @@ function Operators(options) {
     this.NOT = Op.not;
     this.NOT_LIKE = Op.notLike;
     this.OR = Op.or;
-  } else {
+  }
+
+  _setupOldSequelizeOp() {
     this.AND = '$and';
+    this.CONTAINS = '$contains';
     this.EQ = '$eq';
     this.GT = '$gt';
     this.GTE = '$gte';
@@ -32,8 +38,19 @@ function Operators(options) {
     this.OR = '$or';
   }
 
-  instance = this;
-  return this;
+  constructor(options) {
+    if (Operators._isNewSequelizeOp(options)) {
+      this._setupNewSequelizeOp(options);
+    } else {
+      this._setupOldSequelizeOp();
+    }
+
+    Operators._instance = this;
+  }
+
+  static getInstance(options) {
+    return Operators._instance || new Operators(options);
+  }
 }
 
 module.exports = Operators;
diff --git a/test/services/filters-parser.test.js b/test/services/filters-parser.test.js
@@ -12,7 +12,7 @@ describe('services > filters-parser', () => {
     sequelize: Sequelize,
   };
   const timezone = 'Europe/Paris';
-  const OPERATORS = new Operators(sequelizeOptions);
+  const OPERATORS = Operators.getInstance(sequelizeOptions);
   const defaultFiltersParser = new FiltersParser(schema, timezone, sequelizeOptions);
 
   const getExpectedCondition = (field, conditions) => {
@@ -120,6 +120,12 @@ describe('services > filters-parser', () => {
         expect(defaultFiltersParser.formatOperatorValue.bind('random', value)).toThrow(NoMatchingOperatorError);
       });
     });
+
+    it('should return the appropriate value (array)', () => {
+      expect.assertions(1);
+
+      expect(defaultFiltersParser.formatOperatorValue('includes_all', [1, 2])).toStrictEqual({ [OPERATORS.CONTAINS]: [1, 2] });
+    });
   });
 
   describe('formatAggregatorOperator function', () => {
diff --git a/test/utils/operators.test.js b/test/utils/operators.test.js
@@ -0,0 +1,57 @@
+import Sequelize from 'sequelize';
+import Operators from '../../src/utils/operators';
+
+describe('utils > operators', () => {
+  describe('with an old sequelize', () => {
+    it('should return a valid operator', () => {
+      expect.assertions(13);
+
+      const Op = new Operators();
+      expect(Op.AND).toStrictEqual('$and');
+      expect(Op.CONTAINS).toStrictEqual('$contains');
+      expect(Op.EQ).toStrictEqual('$eq');
+      expect(Op.GT).toStrictEqual('$gt');
+      expect(Op.GTE).toStrictEqual('$gte');
+      expect(Op.IN).toStrictEqual('$in');
+      expect(Op.LIKE).toStrictEqual('$like');
+      expect(Op.LT).toStrictEqual('$lt');
+      expect(Op.LTE).toStrictEqual('$lte');
+      expect(Op.NE).toStrictEqual('$ne');
+      expect(Op.NOT).toStrictEqual('$not');
+      expect(Op.NOT_LIKE).toStrictEqual('$notLike');
+      expect(Op.OR).toStrictEqual('$or');
+    });
+  });
+
+  describe('with an up to date sequelize', () => {
+    it('should return a valid operator', () => {
+      expect.assertions(13);
+
+      const Op = new Operators({ Sequelize });
+      expect(Op.AND).toStrictEqual(Sequelize.Op.and);
+      expect(Op.CONTAINS).toStrictEqual(Sequelize.Op.contains);
+      expect(Op.EQ).toStrictEqual(Sequelize.Op.eq);
+      expect(Op.GT).toStrictEqual(Sequelize.Op.gt);
+      expect(Op.GTE).toStrictEqual(Sequelize.Op.gte);
+      expect(Op.IN).toStrictEqual(Sequelize.Op.in);
+      expect(Op.LIKE).toStrictEqual(Sequelize.Op.like);
+      expect(Op.LT).toStrictEqual(Sequelize.Op.lt);
+      expect(Op.LTE).toStrictEqual(Sequelize.Op.lte);
+      expect(Op.NE).toStrictEqual(Sequelize.Op.ne);
+      expect(Op.NOT).toStrictEqual(Sequelize.Op.not);
+      expect(Op.NOT_LIKE).toStrictEqual(Sequelize.Op.notLike);
+      expect(Op.OR).toStrictEqual(Sequelize.Op.or);
+    });
+  });
+
+  describe('getInstance', () => {
+    it('should return the same object', () => {
+      expect.assertions(1);
+
+      const emptyOptions = {};
+      const Op = Operators.getInstance(emptyOptions);
+
+      expect(Op).toStrictEqual(Operators.getInstance(emptyOptions));
+    });
+  });
+});
diff --git a/yarn.lock b/yarn.lock

Original file line number	Diff line number	Diff line change
`@@ -15,5 +15,6 @@`
`15`	`15`	`"@babel/plugin-proposal-optional-chaining",`
`16`	`16`	`"@babel/plugin-transform-runtime",`
`17`	`17`	`"@babel/plugin-transform-arrow-functions",`
	`18`	`+ "@babel/plugin-proposal-class-properties"`
`18`	`19`	`]`
`19`	`20`	`}`