apeman-app-rest/lib/endpoints/related_update_endpoint.js

apeman app to handle restful endpoint.

/**
 * Endpoint for related update
 * @augments Endpoint
 * @class RelatedUpdateEndpoint
 */
'use strict'

const Endpoint = require('./endpoint')
const validateDataType = require('../validating/validate_data_type')
const validateModelExists = require('../validating/validate_model_exists')
const validateDataGiven = require('../validating/validate_data_given')

const { toType, toData, defineRelatedOne, defineRelatedUpdate } = require('apemanmodel')
const co = require('co')

/** @lends RelatedUpdateEndpoint */
class RelatedUpdateEndpoint extends Endpoint {
  /**
   * @override
   */
  getDefaultConfig () {
    return {
      name: 'relatedUpdate'
    }
  }

  /**
   * @override
   */
  handle (ctx, next) {
    const s = this
    let succeed = s.bindSucceed(ctx)
    let fail = s.bindFail(ctx)

    let { state } = ctx
    let { model, id, relatedId, association, transaction, data } = state

    return co(function * () {
      let dataGivenError = validateDataGiven(data)
      if (dataGivenError) {
        return fail(dataGivenError)
      }
      let error = s.validate(data, state)

      if (error) {
        return fail(error)
      }

      let relatedOne = defineRelatedOne(model, association, transaction)
      let relatedInstance = yield relatedOne(id, relatedId)
      let relatedExistsError = validateModelExists(model, id, relatedInstance)
      if (relatedExistsError) {
        return fail(relatedExistsError)
      }

      let updated = yield s.relatedUpdate(id, relatedInstance, data, state)
      return succeed(
        {},
        toData(association.target, updated, {}),
        {
          self: '.'
        }
      )
    })
  }

  /**
   * @override
   */
  validate (data, state) {
    let { model, id, instance, association } = state
    let type = toType(association.target)
    let existsError = validateModelExists(model, id, instance)
    if (existsError) {
      return existsError
    }

    let typeError = validateDataType(data, type)
    if (typeError) {
      return typeError
    }
    return null
  }

  relatedUpdate (id, relatedInstance, data, state) {
    return co(function * () {
      let { model, association, transaction } = state
      let relatedUpdate = defineRelatedUpdate(model, association, transaction)
      return yield relatedUpdate(id, relatedInstance, data.attributes)
    })
  }

}

module.exports = RelatedUpdateEndpoint