Support for first, limit, group and order about her HOT 6 CLOSED

Your best bet is to define scopes or class methods on the model, since Her can't predict what conventions an API follows for each of these options. Some examples

class User
  include Her::Model

  # @example
  #
  #   User.page(2) # Fetched via GET "/users?page=2
  scope :page, ->(value) { where(page: value) }

  # @example
  #
  #   User.limit(100) # Fetched via GET "/users?limit=100
  scope :limit, ->(value) { where(limit: value) }

  # @example
  #
  #   User.order(:name) # Fetched via GET "/users?sort=name_asc
  def self.order(params = {})
    params = Hash[params, :asc] if params.is_a? ::Symbol
    where(sort: params.flatten.join('_'))
  end
end

Another idea would be to move these into a base class or mixin so they could be reused.

from her.

Problem with that is that I'm wrapping the where statement as per an earlier post. It's almost like I need the ability to do something like

scope :limit, -> (value) { param(limit: value) }

where the param method would accept any parameter.

Best,

Josh

from her.

What's the purpose behind the param method? Can you provide a sample of what the HTTP request would look like?

from her.

Ok, see now where this particular problem is discussed in #519. Let's move the conversation over there and see if we can find a solution since we covered support of limit, page, etc. 😺

from her.

Ok. So.

I have overridden the where method for Her like such:

module Her
  module Model
    class Relation
      # Add a query string parameter
      #
      # @example
      #   @users = User.all
      #   # Fetched via GET "/users"
      #
      # @example
      #   @users = User.where(:approved => 1).all
      #   # Fetched via GET "/users?approved=1"
      def where(params = {})
        return self if params.blank? && !@_fetch.nil?
        clone.tap do |r|
          r.params = r.params.merge({where: params})
          r.clear_fetch_cache!
        end
      end
      alias all where
    end

so that where is automatically wrapped in a "where" attribute. Then on the API I have this...

   @devices = ::Device.all

    filters = params[:where]
    if filters.present?
      filters.keys.each do |key|
        if key == 'term'
          @devices = @devices.where(filters[key])
        else
          @devices = @devices.where("#{key}" => filters[key])
        end
      end
    end

so when I user Her I do something like:

Device.where(active: true) =>  https://api.example.com/devices?where[active]=true

or 

Device.where({term: ["created_at > ?",1.month.ago]}

And all of the above work fine and let me run any query.

As you can see, because of this I can't just put things like limit, order, etc into the where statement, which doesn't make sense logically anyway. If, however, I had a catch-all method, like param I could do:

def first
  Device.param({limit: 1, order: 'created_at desc'})
end

and then on the API:

passed_params = params[:param]
if passed_params.present?
  passed_params.each do |key|
     case key
        when 'limit'
           @device = @device.limit(passed_params[:key])
       when 'order'
          ....
     end
  end
end

make sense?

from her.

@zacharywelch that one was me also :)

That addresses more mutating existing methods (I didnt use any of those btw) instead of adding new ones.

from her.