@sustainhawaii/healthies-kfs-utilities/src/index.js

import 'babel-core/register'
import 'babel-polyfill'
import Promise from 'bluebird'
import _ from 'lodash'
import inspect from 'object-inspect'
import log from 'loglevel'

const nodeArgs = require('node-args')

// Add loglevel plugin to display inspected optional second parameter:
const originalFactory = log.methodFactory
log.methodFactory = function (methodName, logLevel, loggerName) {
  const rawMethod = originalFactory(methodName, logLevel, loggerName)
  return (message, optionalData = null) => {
    let msg = message
    if (optionalData) {
      msg += ': ' + inspect(optionalData)
    }
    rawMethod(msg)
  }
}
log.setLevel(log.getLevel()) // Be sure to call setLevel method in order to apply plugin
export const logger = log

// wrapper for kinvey-flex-sdk service method
export const initFlexSdk = defineService => {
  const sdk = require('kinvey-flex-sdk')
  const opts = nodeArgs.port ? {port: nodeArgs.port} : null
  sdk.service(opts, defineService)
}

export const getAsyncDataStore = (collectionName, modules) => {
  const store = modules.dataStore()
  const collection = store.collection(collectionName)
  return Promise.promisifyAll(collection)
}

export const getAsyncUserStore = modules => {
  const store = modules.userStore()
  return Promise.promisifyAll(store)
}

export const setLowercaseFields = (data, fields) => {
  if (_.isArray(fields) && _.isPlainObject(data)) {
    const result = {...data}
    _.forEach(fields, field => {
      if (_.isString(data[field])) {
        result[`${field}LC`] = _.toLower(data[field])
      }
    })
    return result
  }
}

export const findEntityById = (entityType, entityId, modules) => {
  const store = entityType === 'user'
    ? getAsyncUserStore(modules)
    : getAsyncDataStore(entityType, modules)
  return store.findByIdAsync(entityId)
}

/**
 * Return a plain object containing the keys and values from newData that should be denormalized in another collection.
 * @param {string} collectionName
 * @param {object} newData
 * @param {object} denormMap Keys of denormMap objects for each collection can be written in dot-notation, but not values. The values are top-level user fields for denormalization. For example, denormMap can be {org: {name: orgName, address.zip: orgZip}}
 * @return {object}
 */
export const getPotentialDenormalizedData = ({collectionName, newData, denormMap}) => _.chain(denormMap)
  .mapValues((val, key) => _.get(newData, key))
  .pickBy(val => !_.isEmpty(val))
  .value()

/**
 * Return a plain object containing the keys and values from potentialDenormalizedData that are different than in oldData.
 * @param {object} oldData
 * @param {object} potentialDenormalizedData
 * @param {object} denormMap
 * @return {object}
 */
export const getFinalDenormalizedData = ({oldData, potentialDenormalizedData, denormMap}) => _.chain(potentialDenormalizedData)
  .pickBy((val, key) => val !== _.get(oldData, key)) // pick relevant values that are different from previously-saved
  .mapKeys((val, key) => denormMap[key]) // change keys from source keys to target keys
  .value()

/**
 * Return a plain object containing:
 *   oldData: the previously-saved collection data
 *   denormData: any fields in newData that are changing and are to be denormalized in other collections.
 *
 * @param {string} collectionName
 * @param {object} newData
 * @param {string} entityId
 * @param {object} denormMap Keys of denormMap objects for each collection can be written in dot-notation, but not values. The values are top-level user fields for denormalization. For example, denormMap can be {org: {name: orgName, address.zip: orgZip}}
 * @param {string} modules
 * @returns {Promise<any>}
 */
export const getDenormalizedData = async ({collectionName, entityId, newData, denormMap, kinveyModules}) => {
  const relevantData = getPotentialDenormalizedData({collectionName, newData, denormMap})
  if (_.isEmpty(relevantData)) {
    return null
  }
  const oldData = await findEntityById(collectionName, entityId, kinveyModules)
  const denormData = getFinalDenormalizedData({oldData, relevantData, denormMap})
  return {
    oldData,
    denormData: _.isEmpty(denormData) ? null : denormData
  }
}

/**
 * Methods for setting and deleting objects with unique "id" keys in an array of objects.
 */
export const entityList = {
  findIndex: (arr, item) => _.findIndex(arr, existingItem => existingItem.id === item.id),
  /**
   * Add or update an object in an array.
   * @param {array} arr
   * @param {object} item Must have an "id" key set.
   * @returns {any[]}
   */
  set: (arr = [], item) => {
    const result = Array.from(arr)
    const idx = entityList.findIndex(arr, item)
    if (idx === -1) {
      result.push(item)
    } else {
      result.splice(idx, 1, item)
    }
    return result
  },
  /**
   * Remove an object from an array.
   * @param {array} arr
   * @param {object} item Must have an "id" key set.
   * @returns {any[]}
   */
  del: (arr = [], item) => {
    const result = Array.from(arr)
    const idx = entityList.findIndex(arr, item)
    if (idx !== -1) {
      result.splice(idx, 1)
    }
    return result
  }
}