@trusthab/composable-resources/src/resources/knetik_cloud_persistence.js

migrating https://github.com/knetikmedia/hab-api/tree/integration/app/resources/composable

const composer = require('../mixin_loader');

const Q = require('q');
const _ = require('lodash');
const moment = require('moment');

module.exports = (App) => {
  const { underscore } = require('inflected');

  class KnetikCloudPersistenceResource {
    static checkRequirements() {
      if (!this.knetikCloudApi && !this.knetikCloudMethods) {
        return Q.reject(
          new Error(
            'Not Implemmented! Create the knetikCloudApi and knetikCloudMethids static methods in your resources class',
          ),
        );
      }

      return Q(true);
    }

    static createSearch(query, mapper) {
      const {
        search: { index, template, paramsBuilder }
      } = this.knetikCloudMethods();

      const api = App.KnetikCloud.get('SearchApi');

      query = paramsBuilder ? paramsBuilder(query) : query;

      if (template) {
        let must = _.get(query, 'query.bool.must', []);
        must = _.merge(
          must,
          [{ match: { template } }],
        );
        _.set(query, 'query.bool.must', must);
      }

      let must_not = _.get(query, 'query.bool.must_not', []);
      must_not = _.merge(
        must_not,
        [{ exists: { field: "additional_properties.deleted_at.value" } }]
      );
      _.set(query, 'query.bool.must_not', must_not);

      App.Logger.info('KnetikCloudPersistenceResource: start search', query);

      return api.searchIndex(index, { query })
        .then(mapit);
    }

    static getPersistedList(params = {}) {
      const { list } = this.knetikCloudMethods();
      if (list) {
        return getListWithoutSearch.call(this, list, params);
      }

      const {
        search: { index, template, paramsBuilder }
      } = this.knetikCloudMethods();

      const api = App.KnetikCloud.get('SearchApi');

      params = paramsBuilder ? paramsBuilder(params) : params;

      if (template) {
        params.filter = params.filter
          ? `${params.filter}|template:${template}`
          : `template:${template}`;
      }

      return createSearch.call(this, params)
        .then(query => api.searchIndex(index, { query }))
        .then(page => ({
          content: page.hits.hits.map(hit => hit._source),
          total: page.hits.total
        }));
    }

    static getPersistedCount(params = {}) {
      const {
        search: { index, template, paramsBuilder }
      } = this.knetikCloudMethods();
      const api = App.KnetikCloud.get('SearchApi');

      params = paramsBuilder ? paramsBuilder(params) : params;

      if (template) {
        params.filter = params.filter
          ? `${params.filter}|template:${template}`
          : `template:${template}`;
      }

      return createSearch.call(this, params)
        .then(query => api.searchIndex(index, { query }))
        .then(page => page.hits.total);
    }

    static persistCreate(params) {
      const {
        create: { api, method, paramsBuilder }
      } = this.knetikCloudMethods();
      const apiClass = App.KnetikCloud.get(api);

      params = paramsBuilder(params);
      return apiClass[method](...params);
    }

    static getPersistedRecord(id) {
      const {
        find: { api, method, paramsBuilder }
      } = this.knetikCloudMethods();

      const apiClass = App.KnetikCloud.get(api);
      const params = paramsBuilder ? paramsBuilder(id) : [id];

      return apiClass[method](...params);
    }

    persistUpdate() {
      const {
        update: { api, method, paramsBuilder }
      } = this.constructor.knetikCloudMethods();
      const apiClass = App.KnetikCloud.get(api);
      const data = this.eject();
      const params = paramsBuilder(this.id, data);
      return apiClass[method](...params);
    }

    persistDestroy() {
      this.updateAttributes({ deleted_at: moment().unix() });
      return this.persistUpdate();
    }
  }

  function mapit(res) {
    App.Logger.info('KnetikCloudPersistenceResource: done  search', `${res.hits.total} found`);

    return res;
  }

  function getListWithoutSearch(list, params = {}) {
    const { api, method, paramsBuilder } = list;

    const apiInst = App.KnetikCloud.get(api);

    params = paramsBuilder ? paramsBuilder(params) : params;

    return apiInst[method](params).then(page => ({
      content: page.content,
      total: page.total_elements
    }));
  }

  function createSearch(params, id) {
    const QueryBuilder = App.get('Resources.SearchQueryBuilder');
    const {
      order, filter, size, page, with_deleted
    } = params;

    const builder = new QueryBuilder(
      this,
      {
        order,
        filter,
        size,
        page,
        id
      },
      with_deleted,
    );

    return builder.result();
  }

  return composer(KnetikCloudPersistenceResource, App);
};