Feature request: Expose a Hash merged to the root, not as a sub key

[elado]

I'd like to be able to append an arbitrary hash to the final result of the entity, without nesting it.

There are a couple of ways I can think of:

class ArticleEntity < Grape::Entity
   expose :title

   # example 1 - most flexible, merge output with this hash
   expose_on_root do |object, options|
      {
         key: "value",
         key_2: object.something
      }
   end

   # example 2: include another entity without nesting it in the result hash
   expose_on_root using: LikeableEntity

   # which is a shortcut for:
   expose_on_root do |object, options|
      LikeableEntity.represent(object, options).as_json
   end
end

class LikeableEntity < Grape::Entity
   expose :like_count
   expose :likers, using: UserEntity
end

ArticleEntity.represent(article).as_json
# => { title: ..., key: ..., key_2: ..., like_count: ..., likers: [...] }

Thoughts?

[dblock]

For the first part of the example my initial reaction is, why isn't this just expose :key and expose :key_2, what's the purpose of group-nesting? The second one with LikeableEntity makes more sense. But something tells me I would want to include LikeableEntity and get all its exposures (it's a class, so we can't do that though).

Maybe I just don't love the name, and it could be as simple as expose ..., nested: false?

I think expose self using: :LikeableEntity should work without any DSL changes (self can be omitted), it never makes sense to expose your own object as a nested thing IHMO.

[elado]

why isn't this just expose :key and expose :key_2

because you can return any hash that would be merged to root, not just a specified set of keys.

Let's say that only for admins I want to expose a few unknown properties on the root. If I don't know them in advance, I can't use expose. However, with expose_on_root I can just return any hash.

It helps when the model is normalized and the JSON is denormalized.

I wrote a 🐒 monkey patch

module Grape
  class Entity
    def self.exposures_on_root
      return @exposures_on_root unless @exposures_on_root.nil?

      @exposures_on_root = []

      if superclass.respond_to? :exposures_on_root
        @exposures_on_root = superclass.exposures_on_root + @exposures_on_root
      end

      @exposures_on_root
    end

    def self.expose_on_root(options={}, &block)
      options[:proc] = block if block_given?
      exposures_on_root << options
    end

    alias_method :as_json_old, :as_json
    alias_method :serializable_hash_old, :serializable_hash

    def serializable_hash(runtime_options = {})
      output = serializable_hash_old(runtime_options)

      self.class.exposures_on_root.each do |exposure_on_root|
        partial_output = instance_exec(object, options, &exposure_on_root[:proc])
        output.reverse_merge!(partial_output)
      end

      output
    end

    alias_method :as_json, :serializable_hash
  end
end

class ArticleEntity < Grape::Entity
  # ...
  expose_on_root do |object, options|
     if options[:admin]
       object.admin_metadata.merge(some_other_key: object.something_else.some_other_key)
     end
  end
end

[elado]

In Rabl it's called glue https://github.com/nesquena/rabl#gluing-attributes

[dblock]

As much as I like glue, what do you think about my suggestion of using a nested: false option? Just brainstorming for now. Or maybe merge?

[elado]

I like merge.

[dblock]

Please check out #204 - add your 👍 or/and comment.

[elado]

@dblock thanks! I've been on the dark side of Node for a while now but it seems great.