refactor: migrate project to es6 class syntax (#581)

Author: romain-gilliotte

src/services/belongs-to-updater.js

@@ -1,18 +1,23 @@
+class BelongsToUpdater {
+  constructor(model, association, opts, params, data) {
+    this._model = model;
+    this._params = params;
+    this._data = data;
+  }
 
-function BelongsToUpdater(model, association, opts, params, data) {
-  this.perform = async () => {
+  async perform() {
     const updateParams = {};
-    updateParams[params.associationName] = data.data ? data.data.id : null;
+    updateParams[this._params.associationName] = this._data.data ? this._data.data.id : null;
 
-    return model
-      .findByIdAndUpdate(params.recordId, {
+    return this._model
+      .findByIdAndUpdate(this._params.recordId, {
         $set: updateParams,
       }, {
         new: true,
       })
       .lean()
       .exec();
-  };
+  }
 }
 
 module.exports = BelongsToUpdater;

src/services/embedded-document-updater.js

@@ -1,17 +1,24 @@
-function EmbeddedDocumentUpdater(model, params, association, record) {
-  this.perform = () => {
-    const { recordId } = params;
-    const recordIndex = parseInt(params.recordIndex, 10);
+class EmbeddedDocumentUpdater {
+  constructor(model, params, association, record) {
+    this._model = model;
+    this._params = params;
+    this._association = association;
+    this._record = record;
+  }
 
-    delete record._id;
+  async perform() {
+    const { recordId } = this._params;
+    const recordIndex = parseInt(this._params.recordIndex, 10);
 
-    const update = Object.keys(record).reduce((acc, value) => {
-      acc.$set[`${association}.${recordIndex}.${value}`] = record[value];
+    delete this._record._id;
+
+    const update = Object.keys(this._record).reduce((acc, value) => {
+      acc.$set[`${this._association}.${recordIndex}.${value}`] = this._record[value];
       return acc;
     }, { $set: {} });
 
-    return model.findByIdAndUpdate(recordId, update);
-  };
+    return this._model.findByIdAndUpdate(recordId, update);
+  }
 }
 
 module.exports = EmbeddedDocumentUpdater;

src/services/has-many-associator.js

@@ -1,20 +1,25 @@
+class HasManyAssociator {
+  constructor(model, association, opts, params, data) {
+    this._model = model;
+    this._params = params;
+    this._data = data;
+  }
 
-function HasManyAssociator(model, association, opts, params, data) {
-  this.perform = () => {
+  perform() {
     const updateParams = {};
-    updateParams[params.associationName] = {
-      $each: data.data.map((document) => document.id),
+    updateParams[this._params.associationName] = {
+      $each: this._data.data.map((document) => document.id),
     };
 
-    return model
-      .findByIdAndUpdate(params.recordId, {
+    return this._model
+      .findByIdAndUpdate(this._params.recordId, {
         $push: updateParams,
       }, {
         new: true,
       })
       .lean()
       .exec();
-  };
+  }
 }
 
 module.exports = HasManyAssociator;

src/services/has-many-dissociator.js

@@ -1,25 +1,31 @@
 
-function HasManyDissociator(model, association, opts, params, data) {
-  const isDelete = Boolean(params.delete);
+class HasManyDissociator {
+  constructor(model, association, opts, params, data) {
+    this._model = model;
+    this._association = association;
+    this._params = params;
+    this._data = data;
+  }
 
-  this.perform = async () => {
-    const documentIds = data.data.map((document) => document.id);
+  async perform() {
+    const isDelete = Boolean(this._params.delete);
+    const documentIds = this._data.data.map((document) => document.id);
     if (isDelete) {
-      await association.deleteMany({ _id: { $in: documentIds } });
+      await this._association.deleteMany({ _id: { $in: documentIds } });
     }
 
     const updateParams = {};
-    updateParams[params.associationName] = { $in: documentIds };
+    updateParams[this._params.associationName] = { $in: documentIds };
 
-    return model
-      .findByIdAndUpdate(params.recordId, {
+    return this._model
+      .findByIdAndUpdate(this._params.recordId, {
         $pull: updateParams,
       }, {
         new: true,
       })
       .lean()
       .exec();
-  };
+  }
 }
 
 module.exports = HasManyDissociator;

src/services/has-many-getter.js

@@ -4,39 +4,46 @@ const SearchBuilder = require('./search-builder');
 const utils = require('../utils/schema');
 const FiltersParser = require('./filters-parser');
 
-function HasManyGetter(parentModel, childModel, opts, params) {
-  const OBJECTID_REGEXP = /^[0-9a-fA-F]{24}$/;
-  const schema = Interface.Schemas.schemas[utils.getModelName(childModel)];
-  const searchBuilder = new SearchBuilder(childModel, opts, params);
-  const filtersParser = new FiltersParser(childModel, params.timezone, opts);
-
-  function hasPagination() {
-    return params.page && params.page.number;
+const OBJECTID_REGEXP = /^[0-9a-fA-F]{24}$/;
+
+class HasManyGetter {
+  constructor(parentModel, childModel, opts, params) {
+    this._parentModel = parentModel;
+    this._childModel = childModel;
+    this._params = params;
+    this._opts = opts;
+    this._searchBuilder = new SearchBuilder(childModel, opts, params);
   }
 
-  function getLimit() {
-    if (hasPagination()) {
-      return parseInt(params.page.number, 10) * params.page.size;
+  _hasPagination() {
+    return this._params.page && this._params.page.number;
+  }
+
+  _getLimit() {
+    if (this._hasPagination()) {
+      return parseInt(this._params.page.number, 10) * this._params.page.size;
     }
     return 5;
   }
 
-  function getSkip() {
-    if (hasPagination()) {
-      return (parseInt(params.page.number, 10) - 1) * params.page.size;
+  _getSkip() {
+    if (this._hasPagination()) {
+      return (parseInt(this._params.page.number, 10) - 1) * this._params.page.size;
     }
     return 0;
   }
 
-  function getProjection() {
+  _getProjection() {
     const projection = {};
-    projection[params.associationName] = 1;
+    projection[this._params.associationName] = 1;
     projection._id = 0; // eslint-disable-line
 
     return projection;
   }
 
-  function handlePopulate(query) {
+  _handlePopulate(query) {
+    const schema = Interface.Schemas.schemas[utils.getModelName(this._childModel)];
+
     _.each(schema.fields, (field) => {
       if (field.reference) {
         query.populate({
@@ -46,55 +53,55 @@ function HasManyGetter(parentModel, childModel, opts, params) {
     });
   }
 
-  async function buildConditions(recordIds) {
+  async _buildConditions(recordIds) {
     const conditions = {
       $and: [{ _id: { $in: recordIds } }],
     };
 
-    if (params.search) {
-      const conditionsSearch = await searchBuilder.getConditions();
+    if (this._params.search) {
+      const conditionsSearch = await this._searchBuilder.getConditions();
       conditions.$and.push(conditionsSearch);
     }
 
-    if (params.filters) {
-      const newFilters = await filtersParser.replaceAllReferences(params.filters);
+    if (this._params.filters) {
+      const filtersParser = new FiltersParser(this._childModel, this._params.timezone, this._opts);
+      const newFilters = await filtersParser.replaceAllReferences(this._params.filters);
       const newFiltersString = JSON.stringify(newFilters);
       conditions.$and.push(await filtersParser.perform(newFiltersString));
     }
 
     return conditions;
   }
 
-  async function getRecordsAndRecordIds() {
-    let id = params.recordId;
-    if (OBJECTID_REGEXP.test(params.recordId)) {
-      id = opts.Mongoose.Types.ObjectId(id);
+  async _getRecordsAndRecordIds() {
+    let id = this._params.recordId;
+    if (OBJECTID_REGEXP.test(this._params.recordId)) {
+      id = this._opts.Mongoose.Types.ObjectId(id);
     }
 
-    const parentRecords = await parentModel
+    const parentRecords = await this._parentModel
       .aggregate()
       .match({ _id: id })
-      .unwind(params.associationName)
-      .project(getProjection())
+      .unwind(this._params.associationName)
+      .project(this._getProjection())
       .exec();
 
-    const childRecordIds = _.map(parentRecords, (record) => record[params.associationName]);
-    const conditions = await buildConditions(childRecordIds);
-    const query = childModel.find(conditions);
-    handlePopulate(query);
+    const childRecordIds = _.map(parentRecords, (record) => record[this._params.associationName]);
+    const conditions = await this._buildConditions(childRecordIds);
+    const query = this._childModel.find(conditions);
+    this._handlePopulate(query);
 
     const childRecords = await query;
     return [childRecords, childRecordIds];
   }
 
-  this.perform = async () => {
-    const [childRecords, childRecordIds] = await getRecordsAndRecordIds();
-
-    let fieldSort = params.sort;
+  async perform() {
+    const [childRecords, childRecordIds] = await this._getRecordsAndRecordIds();
+    let fieldSort = this._params.sort;
     let descending = false;
 
-    if (params.sort && (params.sort[0] === '-')) {
-      fieldSort = params.sort.substring(1);
+    if (this._params.sort && (this._params.sort[0] === '-')) {
+      fieldSort = this._params.sort.substring(1);
       descending = true;
     }
 
@@ -111,19 +118,21 @@ function HasManyGetter(parentModel, childModel, opts, params) {
     let sortedChildRecords = descending ? recordsSorted.reverse() : recordsSorted;
     let fieldsSearched = null;
 
-    if (params.search) {
-      fieldsSearched = searchBuilder.getFieldsSearched();
+    if (this._params.search) {
+      fieldsSearched = this._searchBuilder.getFieldsSearched();
     }
 
-    sortedChildRecords = _.slice(sortedChildRecords, getSkip(), getSkip() + getLimit());
+    sortedChildRecords = _.slice(
+      sortedChildRecords, this._getSkip(), this._getSkip() + this._getLimit(),
+    );
 
     return [sortedChildRecords, fieldsSearched];
-  };
+  }
 
-  this.count = async () => {
-    const recordsAndRecordIds = await getRecordsAndRecordIds();
+  async count() {
+    const recordsAndRecordIds = await this._getRecordsAndRecordIds();
     return recordsAndRecordIds[0].length;
-  };
+  }
 }
 
 module.exports = HasManyGetter;