feat: add filters on related data (#532)

Author: olesyakorovina

src/services/has-many-getter.js

@@ -3,11 +3,13 @@ const P = require('bluebird');
 const Interface = require('forest-express');
 const SearchBuilder = require('./search-builder');
 const utils = require('../utils/schema');
+const FiltersParser = require('./filters-parser');
 
 function HasManyGetter(model, association, opts, params) {
   const OBJECTID_REGEXP = /^[0-9a-fA-F]{24}$/;
   const schema = Interface.Schemas.schemas[utils.getModelName(association)];
   const searchBuilder = new SearchBuilder(association, opts, params);
+  const filtersParser = new FiltersParser(association, params.timezone, opts);
 
   function hasPagination() {
     return params.page && params.page.number;
@@ -45,6 +47,25 @@ function HasManyGetter(model, association, opts, params) {
     });
   }
 
+  async function buildConditions(recordIds) {
+    const conditions = {
+      $and: [{ _id: { $in: recordIds } }],
+    };
+
+    if (params.search) {
+      const conditionsSearch = await searchBuilder.getConditions();
+      conditions.$and.push(conditionsSearch);
+    }
+
+    if (params.filters) {
+      const newFilters = await filtersParser.replaceAllReferences(params.filters);
+      const newFiltersString = JSON.stringify(newFilters);
+      conditions.$and.push(await filtersParser.perform(newFiltersString));
+    }
+
+    return conditions;
+  }
+
   function getRecordsAndRecordIds() {
     return new P((resolve, reject) => {
       let id = params.recordId;
@@ -63,15 +84,7 @@ function HasManyGetter(model, association, opts, params) {
         });
     })
       .then(async (recordIds) => {
-        const conditions = {
-          $and: [{ _id: { $in: recordIds } }],
-        };
-
-        if (params.search) {
-          const conditionsSearch = await searchBuilder.getConditions();
-          conditions.$and.push(conditionsSearch);
-        }
-
+        const conditions = await buildConditions(recordIds);
         const query = association.find(conditions);
         handlePopulate(query);
 

test/tests/services/has-many-getter.test.js

@@ -0,0 +1,244 @@
+import mongoose from 'mongoose';
+import loadFixture from 'mongoose-fixture-loader';
+import Interface from 'forest-express';
+import mongooseConnect from '../../utils/mongoose-connect';
+import HasManyGetter from '../../../src/services/has-many-getter';
+
+describe('service > has-many-getter', () => {
+  let TreeModel;
+  let LumberJackModel;
+
+  const options = {
+    Mongoose: mongoose,
+    connections: { mongoose },
+  };
+
+  const parameters = {
+    fields: {
+      order: '_id,name,country',
+    },
+    recordId: '41224d776a326fb40f000003',
+    associationName: 'owners',
+    timezone: 'Europe/Paris',
+  };
+
+  beforeAll(() => {
+    Interface.Schemas = {
+      schemas: {
+        LumberJack: {
+          name: 'LumberJack',
+          idField: '_id',
+          primaryKeys: ['_id'],
+          isCompositePrimary: false,
+          searchFields: ['name', 'country'],
+          fields: [
+            {
+              field: '_id',
+              type: 'ObjectId',
+            },
+            {
+              field: 'name',
+              type: 'String',
+            },
+
+            {
+              field: 'country',
+              type: 'String',
+            },
+          ],
+        },
+        Tree: {
+          name: 'Tree',
+          idField: '_id',
+          primaryKeys: ['_id'],
+          isCompositePrimary: false,
+          searchFields: ['name'],
+          fields: [
+            { field: '_id', type: 'ObjectId' },
+            { field: 'name', type: 'String' },
+            {
+              field: 'owners',
+              type: ['ObjectId'],
+              reference: 'LumberJack._id',
+            },
+          ],
+        },
+      },
+    };
+
+    return mongooseConnect()
+      .then(() => {
+        const LumberJackSchema = new mongoose.Schema({
+          _id: { type: 'ObjectId' },
+          name: { type: String },
+          country: { type: String },
+        });
+        const TreeSchema = new mongoose.Schema({
+          id: { type: 'ObjectId' },
+          name: { type: String },
+          owners: {
+            type: ['ObjectId'],
+            ref: 'LumberJack',
+          },
+        });
+
+        LumberJackModel = mongoose.model('LumberJack', LumberJackSchema);
+        TreeModel = mongoose.model('Tree', TreeSchema);
+        return Promise.all([LumberJackModel.remove({}), TreeModel.remove({})]);
+      })
+      .then(() => Promise.all([
+        loadFixture(LumberJackModel, [
+          {
+            _id: '41224d776a326fb40f000001',
+            name: 'Kaladin',
+            country: 'CZ',
+          },
+          {
+            _id: '41224d776a326fb40f000002',
+            name: 'Marcell Doe',
+            country: 'US',
+          },
+          {
+            _id: '41224d776a326fb40f000004',
+            name: 'Marc Schneider',
+            country: 'DE',
+          },
+          {
+            _id: '41224d776a326fb40f000005',
+            name: 'Maria Smith',
+            country: 'US',
+          },
+        ]),
+        loadFixture(TreeModel, [
+          {
+            _id: '41224d776a326fb40f000003',
+            name: 'Ashe Tree Lane',
+            owners: [
+              '41224d776a326fb40f000001',
+              '41224d776a326fb40f000002',
+              '41224d776a326fb40f000004',
+              '41224d776a326fb40f000005',
+            ],
+          },
+        ]),
+      ]));
+  });
+
+  afterAll(() => mongoose.connection.close());
+
+  it('should retrieve all the related records when there is no filters or search', async () => {
+    expect.assertions(2);
+
+    const hasManyGetter = new HasManyGetter(
+      TreeModel,
+      LumberJackModel,
+      options,
+      parameters,
+    );
+
+    const result = await hasManyGetter.perform();
+    const count = await hasManyGetter.count();
+
+
+    expect(result[0]).toHaveLength(4);
+    expect(count).toBe(4);
+  });
+
+  it('should retrieve matching records and count when search is specified', async () => {
+    expect.assertions(3);
+
+    const hasManyGetter = new HasManyGetter(
+      TreeModel,
+      LumberJackModel,
+      options,
+      {
+        ...parameters,
+        search: 'maria',
+      },
+    );
+
+    const result = await hasManyGetter.perform();
+    const count = await hasManyGetter.count();
+
+    expect(result[0]).toHaveLength(1);
+    expect(result[0][0].name).toBe('Maria Smith');
+    expect(count).toBe(1);
+  });
+
+  it('should retrieve matching records and count when filter is specified', async () => {
+    expect.assertions(4);
+
+    const hasManyGetter = new HasManyGetter(
+      TreeModel,
+      LumberJackModel,
+      options,
+      {
+        ...parameters,
+        filters: JSON.stringify({ field: 'name', operator: 'starts_with', value: 'Marc' }),
+      },
+    );
+
+    const result = await hasManyGetter.perform();
+    const count = await hasManyGetter.count();
+
+    expect(result[0]).toHaveLength(2);
+    expect(result[0][0].name).toBe('Marcell Doe');
+    expect(result[0][1].name).toBe('Marc Schneider');
+    expect(count).toBe(2);
+  });
+
+  it('should retrieve matching records and count with filter with aggregator', async () => {
+    expect.assertions(6);
+
+    const hasManyGetter = new HasManyGetter(
+      TreeModel,
+      LumberJackModel,
+      options,
+      {
+        ...parameters,
+        filters: JSON.stringify({
+          aggregator: 'and',
+          conditions: [
+            { field: 'country', operator: 'equal', value: 'US' },
+            { field: 'name', operator: 'starts_with', value: 'Mar' },
+          ],
+        }),
+      },
+    );
+
+    const result = await hasManyGetter.perform();
+    const count = await hasManyGetter.count();
+
+    expect(result[0]).toHaveLength(2);
+    expect(result[0][0].name).toBe('Marcell Doe');
+    expect(result[0][1].name).toBe('Maria Smith');
+    expect(result[0][0].country).toBe('US');
+    expect(result[0][1].country).toBe('US');
+    expect(count).toBe(2);
+  });
+
+  it('should retrieve matching records and count when filter and search are specified', async () => {
+    expect.assertions(6);
+
+    const hasManyGetter = new HasManyGetter(
+      TreeModel,
+      LumberJackModel,
+      options,
+      {
+        ...parameters,
+        search: 'mar',
+        filters: JSON.stringify({ field: 'country', operator: 'equal', value: 'US' }),
+      },
+    );
+
+    const result = await hasManyGetter.perform();
+    const count = await hasManyGetter.count();
+
+    expect(result[0]).toHaveLength(2);
+    expect(result[0][0].name).toBe('Marcell Doe');
+    expect(result[0][1].name).toBe('Maria Smith');
+    expect(result[0][0].country).toBe('US');
+    expect(result[0][1].country).toBe('US');
+    expect(count).toBe(2);
+  });
+});