index.js

import { AdapterService } from '@feathersjs/adapter-commons';
import errors from '@feathersjs/errors';
import { ref, RelationExpression } from 'objection';
import utils from './utils';
import errorHandler from './error-handler';

const METHODS = {
  $or: 'orWhere',
  $and: 'andWhere',
  $ne: 'whereNot',
  $in: 'whereIn',
  $nin: 'whereNotIn',
  $null: 'whereNull',
  $not: 'whereNot'
};

const OPERATORS = {
  eq: '$eq',
  ne: '$ne',
  gte: '$gte',
  gt: '$gt',
  lte: '$lte',
  lt: '$lt',
  in: '$in',
  notIn: '$nin',
  like: '$like',
  notLike: '$notLike',
  ilike: '$ilike',
  notILike: '$notILike',
  or: '$or',
  and: '$and',
  whereNot: '$not'
};

const OPERATORS_MAP = {
  $lt: '<',
  $lte: '<=',
  $gt: '>',
  $gte: '>=',
  $like: 'like',
  $notLike: 'not like',
  $ilike: 'ilike',
  $notILike: 'not ilike',
  $regexp: '~',
  $notRegexp: '!~',
  $iRegexp: '~*',
  $notIRegexp: '!~*',
  $between: 'between',
  $notBetween: 'not between',
  $contains: '@>',
  $containsKey: '?',
  $contained: '<@',
  $any: '?|',
  $all: '?&'
};

const DESERIALIZED_ARRAY_OPERATORS = [
  'between',
  'not between',
  '?|',
  '?&'
];

const NON_COMPARISON_OPERATORS = [
  '@>',
  '?',
  '<@',
  '?|',
  '?&'
];

/**
 * Class representing an feathers adapter for Objection.js ORM.
 * @param {object} options
 * @param {string} [options.id='id'] - database id field
 * @param {string} [options.idSeparator=','] - id field primary keys separator char
 * @param {object} options.model - an Objection model
 * @param {object} options.paginate
 * @param {object} options.events
 * @param {string} options.allowedEager - Objection eager loading string.
 */
class Service extends AdapterService {
  constructor (options) {
    if (!options.model) {
      throw new errors.GeneralError('You must provide an Objection Model');
    }

    const whitelist = Object.values(OPERATORS).concat(options.whitelist || []);
    const id = options.model.idColumn || 'id';

    super(Object.assign({ id }, options, { whitelist }));

    this.idSeparator = options.idSeparator || ',';
    this.jsonSchema = options.model.jsonSchema;
    this.allowedEager = options.allowedEager;
    this.eagerOptions = options.eagerOptions;
    this.eagerFilters = options.eagerFilters;
    this.allowedInsert = options.allowedInsert && RelationExpression.create(options.allowedInsert);
    this.insertGraphOptions = options.insertGraphOptions;
    this.createUseUpsertGraph = options.createUseUpsertGraph;
    this.allowedUpsert = options.allowedUpsert && RelationExpression.create(options.allowedUpsert);
    this.upsertGraphOptions = options.upsertGraphOptions;
    this.schema = options.schema;
  }

  get Model () {
    return this.options.model;
  }

  getModel (params) {
    return this.options.model;
  }

  /**
   * Create a new query that re-queries all ids that were originally changed
   * @param id
   * @param idList
   * @param addTableName
   */
  getIdsQuery (id, idList, addTableName = true) {
    const query = {};

    if (Array.isArray(this.id)) {
      let ids = id;

      if (id && !Array.isArray(id)) {
        ids = utils.extractIds(id, this.id, this.idSeparator);
      }

      this.id.forEach((idKey, index) => {
        if (!ids) {
          if (idList) {
            if (idList[index]) {
              query[idKey] = idList[index].length === 1 ? idList[index] : { $in: idList[index] };
            }
          } else {
            query[idKey] = null;
          }
        } else if (ids[index]) {
          query[idKey] = ids[index];
        } else {
          throw new errors.BadRequest('When using composite primary key, id must contain values for all primary keys');
        }
      });
    } else {
      query[addTableName ? `${this.Model.tableName}.${this.id}` : this.id] = idList ? (idList.length === 1 ? idList[0] : { $in: idList }) : id;
    }

    return query;
  }

  /**
   * Maps a feathers query to the Objection/Knex schema builder functions.
   * @param query - a query object. i.e. { type: 'fish', age: { $lte: 5 }
   * @param params
   * @param parentKey
   * @param methodKey
   * @param allowRefs
   */
  objectify (query, params, parentKey, methodKey, allowRefs) {
    if (params.$eager) { delete params.$eager; }
    if (params.$joinEager) { delete params.$joinEager; }
    if (params.$joinRelation) { delete params.$joinRelation; }
    if (params.$leftJoinRelation) { delete params.$leftJoinRelation; }
    if (params.$modifyEager) { delete params.$modifyEager; }
    if (params.$mergeEager) { delete params.$mergeEager; }
    if (params.$noSelect) { delete params.$noSelect; }
    if (params.$modify) { delete params.$modify; }
    if (params.$allowRefs) { delete params.$allowRefs; }

    Object.keys(params || {}).forEach(key => {
      let value = params[key];

      if (key === '$not') {
        const self = this;
        if (Array.isArray(value)) { // Array = $and operator
          value = { $and: value };
        }
        return query.whereNot(function () {
          // continue with all queries inverted
          self.objectify(this, value, parentKey, methodKey, allowRefs);
        });
      }

      if (utils.isPlainObject(value)) {
        return this.objectify(query, value, key, parentKey, allowRefs);
      }

      const column = parentKey && parentKey[0] !== '$' ? parentKey : key;
      const method = METHODS[methodKey] || METHODS[parentKey] || METHODS[key];
      const operator = OPERATORS_MAP[key] || '=';

      if (method) {
        if (key === '$or') {
          const self = this;

          return query.where(function () {
            return value.forEach((condition) => {
              this.orWhere(function () {
                self.objectify(this, condition, null, null, allowRefs);
              });
            });
          });
        }

        if (key === '$and') {
          const self = this;

          return query.where(function () {
            return value.forEach((condition) => {
              this.andWhere(function () {
                self.objectify(this, condition, null, null, allowRefs);
              });
            });
          });
        }

        if (key === '$null') {
          return query[value.toString() === 'true' ? method : 'whereNotNull'](column);
        }

        return query[method].call(query, column, value); // eslint-disable-line no-useless-call
      }

      const property = this.jsonSchema && this.jsonSchema.properties && (this.jsonSchema.properties[column] || (methodKey && this.jsonSchema.properties[methodKey]));
      let columnType = property && property.type;
      if (columnType) {
        if (Array.isArray(columnType)) { columnType = columnType[0]; }
        if (columnType === 'object' || columnType === 'array') {
          let refColumn;

          if (!methodKey && key[0] === '$') {
            refColumn = ref(`${this.Model.tableName}.${column}`);
          } else {
            const prop = (methodKey ? column : key)
              .replace(/\(/g, '[')
              .replace(/\)/g, ']');

            refColumn = ref(`${this.Model.tableName}.${methodKey || column}:${prop}`);
          }

          if (operator === '@>') {
            if (Array.isArray(value)) { value = JSON.stringify(value); }
          } else if (DESERIALIZED_ARRAY_OPERATORS.includes(operator)) {
            if (typeof value === 'string' && value[0] === '[' && value[value.length - 1] === ']') { value = JSON.parse(value); }
          }

          return query.where(
            NON_COMPARISON_OPERATORS.includes(operator) ? refColumn : refColumn.castText(),
            operator,
            value
          );
        }
      }

      if (DESERIALIZED_ARRAY_OPERATORS.includes(operator) && typeof value === 'string' && value[0] === '[' && value[value.length - 1] === ']') {
        value = JSON.parse(value);
      }

      if (allowRefs && typeof value === 'string') {
        const refMatches = value.match(/^ref\((.+)\)$/);

        if (refMatches) { value = ref(refMatches[1]); }
      }

      return operator === '=' ? query.where(column, value) : query.where(column, operator, value);
    });
  }

  mergeRelations (optionRelations, paramRelations) {
    if (!paramRelations) {
      return optionRelations;
    }

    if (!optionRelations) {
      return RelationExpression.create(paramRelations);
    }

    return optionRelations.merge(paramRelations);
  }

  modifyQuery (query, modify) {
    let modifiers = null;

    if (typeof modify === 'string') {
      if (modify[0] === '[' && modify[modify.length - 1] === ']') {
        query.modify(...JSON.parse(modify));
      } else if (modify[0] === '{' && modify[modify.length - 1] === '}') {
        modifiers = JSON.parse(modify);
      } else {
        query.modify(modify.split(','));
      }
    } else if (Array.isArray(modify)) {
      query.modify(...modify);
    } else {
      modifiers = modify;
    }

    if (modifiers) {
      for (const [modifier, args] of Object.entries(modifiers)) {
        if (args === true) { query.modify(modifier); } else { query.modify(modifier, ...args); }
      }
    }
  }

  getGroupByColumns (query) {
    for (const operation of query._operations) {
      if (operation.name === 'groupBy') {
        const args = operation.args;

        return Array.isArray(args[0]) ? args[0] : args;
      }
    }

    return null;
  }

  async _createTransaction (params) {
    if (!params.transaction && params.atomic) {
      delete params.atomic;
      params.transaction = params.transaction || {};
      params.transaction.trx = await this.Model.startTransaction();
      return params.transaction;
    }
    return null;
  }

  _commitTransaction (transaction) {
    return async (data) => {
      if (transaction) {
        await transaction.trx.commit();
      }
      return data;
    };
  }

  _rollbackTransaction (transaction) {
    return async (err) => {
      if (transaction) {
        await transaction.trx.rollback();
      }
      throw err;
    };
  }

  _createQuery (params = {}) {
    const trx = params.transaction ? params.transaction.trx : null;
    const schema = params.schema || this.schema;
    const query = this.Model.query(trx);
    if (schema) {
      query.context({
        onBuild (builder) {
          builder.withSchema(schema);
        }
      });
    }
    return query;
  }

  _selectQuery (q, $select) {
    if ($select && Array.isArray($select)) {
      const items = $select.concat(Array.isArray(this.id) ? this.id.map(el => { return `${this.Model.tableName}.${el}`; }) : `${this.Model.tableName}.${this.id}`);

      for (const [key, item] of Object.entries(items)) {
        const matches = item.match(/^ref\((.+)\)( as (.+))?$/);
        if (matches) {
          items[key] = ref(matches[1]).as(matches[3] || matches[1]);
        }
      }

      q.select(...items);
    }
    return q;
  }

  // Analyse $select and get an object map with fields -> alias
  _selectAliases ($select) {
    if (!Array.isArray($select)) {
      return {
      };
    }
    return $select.reduce((result, item) => {
      const matches = item.match(/^(?:ref\((\S+)\)|(\S+))(?: as (.+))?$/);
      if (matches) {
        const tableField = matches[1] || matches[2];
        const field = tableField.startsWith(`${this.Model.tableName}.`) ? tableField.substr(this.Model.tableName.length + 1) : tableField;
        const alias = matches[3] || field;
        result[field] = alias;
      } else {
        // Can't parse $select !
        throw new errors.BadRequest(`${item} is not a valid select statement`);
      }
      return result;
    }, {});
  }

  _selectFields (params, originalData = {}) {
    return newObject => {
      if (params.query && params.query.$noSelect) {
        return originalData;
      }
      // Remove not selected fields
      if (params.query && params.query.$select && !params.query.$select.find(field => field === '*' || field === `${this.Model.tableName}.*`)) {
        const $fieldsOrAliases = this._selectAliases(params.query.$select);
        for (const key of Object.keys(newObject)) {
          if (!$fieldsOrAliases[key]) {
            delete newObject[key];
          } else if ($fieldsOrAliases[key] !== key) {
            // Aliased field
            newObject[$fieldsOrAliases[key]] = newObject[key];
            delete newObject[key];
          }
        }
      }
      return newObject;
    };
  }

  _checkUpsertId (id, newObject) {
    const updateId = this.getIdsQuery(id, undefined, false);
    Object.keys(updateId).forEach(key => {
      if (!Object.prototype.hasOwnProperty.call(newObject, key)) {
        newObject[key] = updateId[key]; // id is missing in data, we add it
      } else if (newObject[key] !== updateId[key]) {
        throw new errors.BadRequest(`Id '${key}': values mismatch between data '${newObject[key]}' and request '${updateId[key]}'`);
      }
    });
  }

  createQuery (params = {}) {
    const { filters, query } = this.filterQuery(params);
    const q = this._createQuery(params);
    const eagerOptions = { ...this.eagerOptions, ...params.eagerOptions };

    if (this.allowedEager) { q.allowGraph(this.allowedEager); }

    if (params.mergeAllowEager) { q.allowGraph(params.mergeAllowEager); }

    // $select uses a specific find syntax, so it has to come first.
    this._selectQuery(q, filters.$select);

    // $eager for Objection eager queries
    if (query && query.$eager) {
      q.withGraphFetched(query.$eager, eagerOptions);

      delete query.$eager;
    }

    const joinEager = query && query.$joinEager;

    if (joinEager) {
      q.withGraphJoined(query.$joinEager, eagerOptions);

      delete query.$joinEager;
    }

    const joinRelation = query && query.$joinRelation;

    if (joinRelation) {
      q.joinRelated(query.$joinRelation);

      delete query.$joinRelation;
    }

    const leftJoinRelation = query && query.$leftJoinRelation;

    if (leftJoinRelation) {
      q.leftJoinRelated(query.$leftJoinRelation);

      delete query.$leftJoinRelation;
    }

    if (query && query.$mergeEager) {
      q[joinEager ? 'withGraphJoined' : 'withGraphFetched'](query.$mergeEager, eagerOptions);

      delete query.$mergeEager;
    }

    if (query && query.$modify) {
      this.modifyQuery(q, query.$modify);

      delete query.$modify;
    }

    if (joinRelation || leftJoinRelation) {
      const groupByColumns = this.getGroupByColumns(q);

      if (!groupByColumns) {
        q.distinct(`${this.Model.tableName}.*`);
      }
    }

    // apply eager filters if specified
    if (this.eagerFilters) {
      const eagerFilters = Array.isArray(this.eagerFilters) ? this.eagerFilters : [this.eagerFilters];

      for (const eagerFilter of eagerFilters) {
        q.modifyGraph(eagerFilter.expression, eagerFilter.filter);
      }
    }

    if (query && query.$modifyEager) {
      for (const eagerFilterExpression of Object.keys(query.$modifyEager)) {
        const eagerFilterQuery = query.$modifyEager[eagerFilterExpression];

        q.modifyGraph(eagerFilterExpression, builder => {
          this.objectify(builder, eagerFilterQuery, null, null, query.$allowRefs);
        });
      }

      delete query.$modifyEager;
    }

    // build up the knex query out of the query params
    this.objectify(q, query, null, null, query.$allowRefs);

    if (filters.$sort) {
      Object.keys(filters.$sort).forEach(item => {
        const matches = item.match(/^ref\((.+)\)$/);
        const key = matches ? ref(matches[1]) : item;

        q.orderBy(key, filters.$sort[item] === 1 ? 'asc' : 'desc');
      });
    }

    return q;
  }

  /**
   * `find` service function for Objection.
   * @param params
   */
  _find (params = {}) {
    const find = (params, count, filters, query) => {
      const q = params.objection || this.createQuery(params);
      const groupByColumns = this.getGroupByColumns(q);

      // Handle $limit
      if (filters.$limit) {
        q.limit(filters.$limit);
      }

      // Handle $skip
      if (filters.$skip) {
        q.offset(filters.$skip);
      }

      let executeQuery = total => {
        return q.then(data => {
          return {
            total,
            limit: filters.$limit,
            skip: filters.$skip || 0,
            data
          };
        });
      };

      if (filters.$limit === 0) {
        executeQuery = total => {
          return Promise.resolve({
            total,
            limit: filters.$limit,
            skip: filters.$skip || 0,
            data: []
          });
        };
      }

      if (count) {
        const countColumns = groupByColumns || (Array.isArray(this.id) ? this.id.map(idKey => `${this.Model.tableName}.${idKey}`) : [`${this.Model.tableName}.${this.id}`]);
        const countQuery = this._createQuery(params);

        if (query.$joinRelation || query.$leftJoinRelation) {
          if (query.$joinRelation) {
            countQuery
              .joinRelated(query.$joinRelation)
              .countDistinct({ total: countColumns });
          }
          if (query.$leftJoinRelation) {
            countQuery
              .leftJoinRelated(query.$leftJoinRelation)
              .countDistinct({ total: countColumns });
          }
        } else if (query.$joinEager) {
          countQuery
            .joinRelated(query.$joinEager)
            .countDistinct({ total: countColumns });
        } else if (countColumns.length > 1) {
          countQuery.countDistinct({ total: countColumns });
        } else {
          countQuery.count({ total: countColumns });
        }

        if (query && query.$modify && params.modifierFiltersResults !== false) {
          this.modifyQuery(countQuery, query.$modify);
        }

        this.objectify(countQuery, query, null, null, query.$allowRefs);

        return countQuery
          .then(count => count && count.length ? parseInt(count[0].total, 10) : 0)
          .then(executeQuery)
          .catch(errorHandler);
      }

      return executeQuery().catch(errorHandler);
    };

    const { filters, query, paginate } = this.filterQuery(params);
    const result = find(params, Boolean(paginate && paginate.default), filters, query);

    if (!paginate || !paginate.default) {
      return result.then(page => page.data || page);
    }

    return result;
  }

  _get (id, params = {}) {
    // merge user query with the 'id' to get
    const findQuery = Object.assign({}, { $and: [] }, params.query);
    findQuery.$and.push(this.getIdsQuery(id)); // BUG will fail with composite primary key because table name will be missing

    return this._find(Object.assign({}, params, { query: findQuery }))
      .then(page => {
        const data = page.data || page;

        if (data.length !== 1) {
          throw new errors.NotFound(`No record found for id '${id}'`);
        }

        return data[0];
      });
  }

  _getCreatedRecords (insertResults, inputData, params) {
    if (params.query && params.query.$noSelect) {
      return inputData;
    }
    if (!Array.isArray(insertResults)) {
      insertResults = [insertResults];
    }

    const findQuery = Object.assign({ $and: [] }, params.query);
    const idsQueries = [];

    if (Array.isArray(this.id)) {
      for (const insertResult of insertResults) {
        const ids = [];
        for (const idKey of this.id) {
          if (idKey in insertResult) {
            ids.push(insertResult[idKey]);
          } else {
            return inputData;
          }
        }
        idsQueries.push(this.getIdsQuery(ids));
      }
    } else {
      const ids = [];
      for (const insertResult of insertResults) {
        if (this.id in insertResult) {
          ids.push(insertResult[this.id]);
        } else {
          return inputData;
        }
      }
      idsQueries.push(this.getIdsQuery(null, ids));
    }

    if (idsQueries.length > 1) {
      findQuery.$and.push({ $or: idsQueries });
    } else {
      findQuery.$and = findQuery.$and.concat(idsQueries);
    }

    return this._find(Object.assign({}, params, { query: findQuery }))
      .then(page => {
        const records = page.data || page;
        if (Array.isArray(inputData)) {
          return records;
        }
        return records[0];
      });
  }

  /**
   * @param data
   * @param params
   * @returns {Promise<Object|Object[]>}
   * @private
   */
  _batchInsert (data, params) {
    const { dialect } = this.Model.knex().client;
    // batch insert only works with Postgresql and SQL Server
    if (dialect === 'postgresql' || dialect === 'mssql') {
      return this._createQuery(params)
        .insert(data)
        .returning(this.id);
    }
    if (!Array.isArray(data)) {
      return this._createQuery(params).insert(data);
    }
    const promises = data.map(dataItem => {
      return this._createQuery(params).insert(dataItem);
    });
    return Promise.all(promises);
  }

  /**
   * `create` service function for Objection.
   * @param {object} data
   * @param {object} params
   */
  async _create (data, params = {}) {
    const transaction = await this._createTransaction(params);
    const q = this._createQuery(params);
    let promise = q;
    const allowedUpsert = this.mergeRelations(this.allowedUpsert, params.mergeAllowUpsert);
    const allowedInsert = this.mergeRelations(this.allowedInsert, params.mergeAllowInsert);
    const upsertGraphOptions = { ...this.upsertGraphOptions, ...params.mergeUpsertGraphOptions };
    const insertGraphOptions = { ...this.insertGraphOptions, ...params.mergeInsertGraphOptions };

    if (this.createUseUpsertGraph) {
      if (allowedUpsert) {
        q.allowGraph(allowedUpsert);
      }
      q.upsertGraph(data, upsertGraphOptions);
    } else if (allowedInsert) {
      q.allowGraph(allowedInsert);
      q.insertGraph(data, insertGraphOptions);
    } else {
      promise = this._batchInsert(data, params);
    }
    return promise
      .then(insertResults => this._getCreatedRecords(insertResults, data, params))
      .then(this._commitTransaction(transaction), this._rollbackTransaction(transaction))
      .catch(errorHandler);
  }

  /**
   * `update` service function for Objection.
   * @param id
   * @param data
   * @param params
   */
  _update (id, data, params = {}) {
    // NOTE : First fetch the item to update to account for user query
    return this._get(id, params)
      .then(() => {
        // NOTE: Next, fetch table metadata so
        // that we can fill any existing keys that the
        // client isn't updating with null;
        return this.Model.fetchTableMetadata()
          .then(async meta => {
            let newObject = Object.assign({}, data);
            let transaction = null;

            const allowedUpsert = this.mergeRelations(this.allowedUpsert, params.mergeAllowUpsert);

            if (allowedUpsert) {
              // Ensure the object we fetched is the one we update
              this._checkUpsertId(id, newObject);
              // Create transaction if needed
              transaction = await this._createTransaction(params);
            }

            for (const key of meta.columns) {
              if (newObject[key] === undefined) {
                newObject[key] = null;
              }
            }

            if (allowedUpsert) {
              const upsertGraphOptions = { ...this.upsertGraphOptions, ...params.mergeUpsertGraphOptions };
              return this._createQuery(params)
                .allowGraph(allowedUpsert)
                .upsertGraphAndFetch(newObject, upsertGraphOptions).then(this._commitTransaction(transaction), this._rollbackTransaction(transaction));
            }

            // NOTE (EK): Delete id field so we don't update it
            if (Array.isArray(this.id)) {
              for (const idKey of this.id) {
                delete newObject[idKey];
              }
            } else {
              delete newObject[this.id];
            }
            return this._createQuery(params)
              .where(this.getIdsQuery(id))
              .update(newObject)
              .then(() => { // BUG if nothing updated, throw a NotFound
                // NOTE (EK): Restore the id field so we can return it to the client
                if (Array.isArray(this.id)) {
                  newObject = Object.assign({}, newObject, this.getIdsQuery(id));
                } else {
                  newObject[this.id] = id;
                }
                return newObject;
              });
          })
          .then(this._selectFields(params, data));
      })
      .catch(errorHandler);
  }

  /**
   * `patch` service function for Objection.
   * @param id
   * @param data
   * @param params
   */
  _patch (id, data, params = {}) {
    let { filters, query } = this.filterQuery(params);

    const allowedUpsert = this.mergeRelations(this.allowedUpsert, params.mergeAllowUpsert);
    const upsertGraphOptions = { ...this.upsertGraphOptions, ...params.mergeUpsertGraphOptions };
    if (allowedUpsert && id !== null) {
      const dataCopy = Object.assign({}, data);
      this._checkUpsertId(id, dataCopy);

      // Get object first to ensure it satisfy user query
      return this._get(id, params).then(async () => {
        // Create transaction if needed
        const transaction = await this._createTransaction(params);
        return this._createQuery(params)
          .allowGraph(allowedUpsert)
          .upsertGraphAndFetch(dataCopy, upsertGraphOptions)
          .then(this._selectFields(params, data)).then(this._commitTransaction(transaction), this._rollbackTransaction(transaction));
      });
    }

    const dataCopy = Object.assign({}, data);

    const mapIds = page => Array.isArray(this.id)
      ? this.id.map(idKey => [...new Set((page.data || page).map(current => current[idKey]))])
      : (page.data || page).map(current => current[this.id]);

    // By default we will just query for the one id. For multi patch
    // we create a list of the ids of all items that will be changed
    // to re-query them after the update
    const ids =
      id === null ? this._find(params).then(mapIds) : Promise.resolve([id]);

    if (id !== null) {
      if (Array.isArray(this.id)) {
        query = Object.assign({}, query, this.getIdsQuery(id));
      } else {
        query[this.id] = id;
      }
    }

    const q = this._createQuery(params);

    this.objectify(q, query, null, null, query.$allowRefs);

    if (Array.isArray(this.id)) {
      for (const idKey of this.id) {
        delete dataCopy[idKey];
      }
    } else {
      delete dataCopy[this.id];
    }

    return ids
      .then(idList => {
        // Create a new query that re-queries all ids that
        // were originally changed
        const selectParam = filters.$select ? { $select: filters.$select } : undefined;
        const findParams = Object.assign({}, params, { query: Object.assign({}, params.query, this.getIdsQuery(id, idList), selectParam) });

        // Update find query if needed with patched values
        const updateKeys = (obj) => {
          for (const key of Object.keys(obj)) {
            if (key in dataCopy) {
              obj[key] = dataCopy[key];
            } else {
              if (Array.isArray(obj[key])) {
                obj[key].forEach(obj => updateKeys(obj));
              }
            }
          }
        };
        updateKeys(findParams.query);

        return q.patch(dataCopy).then(() => {
          return params.query && params.query.$noSelect
            ? dataCopy
            : this._find(findParams).then(page => {
              const items = page.data || page;

              if (id !== null) {
                if (items.length === 1) {
                  return items[0];
                } else {
                  throw new errors.NotFound(`No record found for id '${id}'`);
                }
              } else if (!items.length) {
                throw new errors.NotFound(`No record found for id '${id}'`);
              }

              return items;
            });
        });
      })
      .catch(errorHandler);
  }

  /**
   * `remove` service function for Objection.
   * @param id
   * @param params
   */
  _remove (id, params = {}) {
    params.query = Object.assign({}, params.query);

    // NOTE (EK): First fetch the record so that we can return
    // it when we delete it.
    if (id !== null) {
      if (Array.isArray(this.id)) {
        params.query = Object.assign({}, params.query, this.getIdsQuery(id));
      } else {
        params.query[this.id] = id;
      }
    }

    const { query: queryParams } = this.filterQuery(params);
    const query = this._createQuery(params);

    this.objectify(query, queryParams, null, null, query.$allowRefs);

    if (params.query && params.query.$noSelect) {
      return query.delete().then(() => {
        return {};
      })
        .catch(errorHandler);
    } else {
      return this._find(params)
        .then(page => {
          const items = page.data || page;

          return query.delete().then(() => {
            if (id !== null) {
              if (items.length === 1) {
                return items[0];
              } else {
                throw new errors.NotFound(`No record found for id '${id}'`);
              }
            } else if (!items.length) {
              throw new errors.NotFound(`No record found for id '${id}'`);
            }

            return items;
          });
        })
        .catch(errorHandler);
    }
  }
}

export default function init (options) {
  return new Service(options);
}

init.Service = Service;
init.ERROR = errorHandler.ERROR;