@iin-mdc/koa-utils/lib/rest.js

"use strict"
const {
  pick, keys, map, reject, filter, groupBy, includes, fromPairs, omitBy, findKey, get,
  isNull, isObject, isFunction, isString,
  defaults } = require("lodash")
const deepMerge = require("@iin-mdc/koa-utils/lib/deep-merge-with-symbols")

function isEmpty(object) {
  return !object || Object.getOwnPropertySymbols(object).concat(Object.keys(object)).length === 0
}
// query = { limit: '25', offset: '0', order: 'id DESC', 'Clients.id': '3' }
function filterOptions(model, query) {
  let { like, gt, or } = model.sequelize.Sequelize.Op
  let options = {}
  const attributes = model.rawAttributes

  options.where = pick(query, keys(attributes))

  if (query.q && model.searchAttributes) {
    let search = map(model.searchAttributes, attr => {
      let s = {}
      if (query.q.match(/^\*|\*$/)) {
        s[attr] = { [like]: query.q.replace(/^\*|\*$/g, "%") }
      } else {
        s[attr] = { [like]: `${query.q}%` }
      }
      return s
    })
    options.where = deepMerge(options.where, { [or]: search })
  }

  let { order, limit, offset, lastUpdatedAt } = query
  if (order) {
    let [field, dir] = order.split(" ")
    if (field == "id") field = model.primaryKeyAttribute
    if (attributes[field])
      options.order = [[field, dir]]
    else if (field.indexOf(".") > 0) {
      const [associationName, associationField] = field.split(".")
      if (model.associations[associationName]) {
        const association = model.associations[associationName]
        options.order = [[association, associationField, dir]]
      }
    }
  }
  if (limit) options.limit = parseInt(limit, 10)
  if (offset) options.offset = parseInt(offset, 10)
  //options.limit = Math.max(options.limit || 50, 500)

  if (query.ids) {
    options.where[model.primaryKeyAttribute] = isString(query.ids) ? query.ids.split(",") : query.ids
  }
  if (lastUpdatedAt) {
    options.where.updatedAt = { [gt]: lastUpdatedAt }
  }
  return options
}

function getAssociationsFilter(model, query = {}, associations_filter = null) {
  let params = getAssociationsParams(model, query, associations_filter)
  if (params.include) {
    return { include: filter(params.include, options => !isEmpty(options.where)) }
  }
  return {}
}
function getAssociationsParams(model, query = {}, associations_filter = null) {
  const _keys = filter(keys(query), (k) => includes(k, "."))
  const associationKeys = groupBy(_keys, (k) => k.split(".")[0])
  associations_filter = associations_filter || keys(model.associations)

  if (query.order && query.order.indexOf(".") > 0) {
    const [orderAssociation, orderField, dir] = query.order.split(/[\\. ]/g)
    if (orderAssociation && orderField && dir && !includes(associations_filter, orderAssociation)) {
      associations_filter.push(orderAssociation)
    }
  }

  let include = map(model.associations, (association, name) => {
    let config = { model: association.target, as: association.as }
    let queryKeys = associationKeys[name]
    if (queryKeys) {
      config.where = fromPairs(map(queryKeys, key => [key.split(".")[1], query[key]]))
    }
    if (config.where || includes(associations_filter, name)) {
      return config
    } else {
      return null
    }
  })
  include = reject(include, isNull)
  return isEmpty(include) ? {} : { include }
}
function requiredIncludes(include) {
  return include
    .map(includeQ => {
      if (isObject(includeQ) && includeQ.required) {
        return ({
          ...includeQ,
          include: requiredIncludes(includeQ.include || [])
        })
      }
      return null
    })
    .filter(includeQ => !isNull(includeQ))
}
function createCountQuery(model, query) {
  const include = requiredIncludes(query.include || [])
  const distinctQuery = include.length > 0 && model.primaryKeyAttribute ? {
    distinct: true,
    col: model.primaryKeyAttribute
  } : {
      col: model.primaryKeyAttribute
    }

  return ({
    ...distinctQuery,
    include: include,
    where: query.where
  })
}
async function fetchObject(ctx, id) {
  let dbQuery = { where: primaryKeyValue(ctx.model, id), rejectOnEmpty: true }
  if (ctx.associations)
    dbQuery = deepMerge(getAssociationsParams(ctx.model, {}, ctx.associations), dbQuery)
  return await ctx.model.findOne(await ctx.customize(ctx, dbQuery))
}

function primaryKeyValue(model, object) {
  let value = isObject(object) ? object[model.primaryKeyAttribute] : object
  return fromPairs([[model.primaryKeyAttribute, value]])
}

function ctxExtend(ctx, modelName, options) {
  const model = isString(modelName) ? ctx.models[modelName] : modelName
  let [callback, opts] = isFunction(options) ? [options, {}] : [null, options || {}]
  let defaultOptions = {
    model: model,
    customize: async (_ctx, dbQuery) => dbQuery,
    serialize: async object => omitBy(object.toJSON(), (_v, k) => k.match(/password|encrypted/)),
    callback: callback || get(options, findKey(pick(options, "update", "create", "destroy"), isFunction)),
    associations: opts.associations || model.preloadAssociations || []
  }
  return defaults(ctx, opts, defaultOptions)
}
const handlers = {
  auth: (ctx, next) => {
    if (ctx.state.allowedRoles) {
      if (ctx.state.user && includes(ctx.state.allowedRoles, ctx.state.user.role)) {
        return next()
      } else {
        ctx.status = 401
      }
    }
    else
      return next()
  },
  show: (...args) => async (ctx) => {
    let { model, serialize } = ctxExtend(ctx, ...args)
    let object = await fetchObject(ctx, ctx.params.id)

    ctx.body = {
      data: await serialize(object, ctx),
      meta: {
        id: model.primaryKeyAttribute
      }
    }
  },
  list: (...args) => async (ctx) => {
    const { model, serialize, customize, associations } = ctxExtend(ctx, ...args)

    const filter = filterOptions(model, ctx.request.query)
    const associationsFilter = getAssociationsFilter(model, ctx.request.query, associations)
    const associationsParams = getAssociationsParams(model, ctx.request.query, associations)

    const dbQuery = await customize(ctx, deepMerge({}, filter, associationsParams))
    const countQuery = createCountQuery(model, await customize(ctx, deepMerge({}, filter, associationsFilter)))

    const rows = await model.findAll(dbQuery)
    const count = await model.count(countQuery)

    ctx.body = {
      data: await Promise.all(rows.map(row => serialize(row, ctx))),
      meta: {
        total: count,
        id: model.primaryKeyAttribute
      }
    }
  },
  update: (...args) => async (ctx) => {
    let { model, serialize, callback } = ctxExtend(ctx, ...args)
    let object = await fetchObject(ctx, ctx.params.id)

    if (callback.length == 4) {
      let afterCalback = async () => { }
      await ctx.models.sequelize.transaction(async (transaction) => {
        transaction.then = (callback) => afterCalback = callback
        object = await callback(ctx, object, ctx.request.body, transaction)
      })
      await afterCalback()
    } else {
      object = await callback(ctx, object, ctx.request.body)
    }
    object = await fetchObject(ctx, object[model.primaryKeyAttribute])
    ctx.body = {
      data: await serialize(object, ctx),
      meta: {
        id: model.primaryKeyAttribute
      }
    }
  },
  create: (...args) => async (ctx) => {
    let { model, serialize, callback } = ctxExtend(ctx, ...args)

    let object = model.build({})
    if (callback.length == 4) {
      let afterCalback = async () => { }
      await ctx.models.sequelize.transaction(async (transaction) => {
        transaction.then = (callback) => afterCalback = callback
        object = await callback(ctx, object, ctx.request.body, transaction)
      })
      await afterCalback()
    } else {
      object = await callback(ctx, object, ctx.request.body)
    }
    object = await fetchObject(ctx, object[model.primaryKeyAttribute])
    ctx.body = {
      data: await serialize(object, ctx),
      meta: {
        id: model.primaryKeyAttribute
      }
    }
  },
  destroy: (...args) => async (ctx) => {
    let { model, callback } = ctxExtend(ctx, ...args)
    let object = await fetchObject(ctx, ctx.params.id)
    if (callback) {
      if (callback.length == 3) {
        await ctx.models.sequelize.transaction(async (transaction) => {
          object = await callback(ctx, object, transaction)
        })
      } else {
        object = await callback(ctx, object)
      }
    } else {
      await object.destroy()
    }
    ctx.body = {
      data: primaryKeyValue(model, object),
      meta: {
        id: model.primaryKeyAttribute
      }
    }
  }
}
module.exports = { filterOptions, getAssociationsParams, handlers }