Question: Versioning Serializers

[enrico]

Hello,

I just started playing with active model serializers.

Although my API is v1, I am trying to understand what the scenario looks like when I have to release v2.

What's the recommended way to handle different serialized attributes depending on version in active model serializers?

Right now, I'm planning to have 2 sets of namespaced API controllers, but wanted to know if it makes sense to also namespacing the serializer classes....

If I do this, will the has_many and has_one methods respect the namespace?

Does anyone have any input on what the recommended way is?

Thanks in advance.

[steveklabnik]

Hey @enrico !

This is a complex issue with many different answers. If I were you, I'd create a version attribute and include it in your serializable_hash.

Since this is not a bug, and nobody's answered in a month, I'm giving it a close.

[juljimm]

Hi,

Sorry for not reply until now, just forgot this thread I subscribed before resolving my similar case.

I just created a custom responder who makes the right choice when selecting serializer to use:

Include in your application_controller.rb:

require 'app_responder'

/lib/app_responders.rb

require 'responders/serialized_responder'

class AppResponder < ActionController::Responder
  include Responders::SerializedResponder
end

/lib/responders/serialized_responder.rb

module Responders
  module SerializedResponder

    def initialize(controller, resources, options={})
      super
      serializer = (controller.class.name.gsub("Controller","").singularize + "Serializer").constantize
      if resource.kind_of?(ActiveRecord::Relation)
        options.merge!(arrayserializer: serializer)
      else
        options.merge!(serializer: serializer)
      end
    end

  end
end

With this you will get 2 things:

1. Now you can have a /controllers/v1/items_controller.rb paired with /app/serailizers/v1/item_serializer.rb
2. You don't need to add serializer: V1::ItemSerializer or arrayserializer: V1::ItemSerializer options in your respond_with sentences (DRY!)

Maybe this addition could be added to https://github.com/plataformatec/responders

Hope it helps

[blakewatters]

Hey late to the party on this one, but I think its worth baking in some support for (optional) versioning. What I was thinking is something like this:

class WhateverSerializer < ActiveModel::Serializer
  root :whatever

  version 1 do
    attributes :id, :name, :body
  end

  # We've added some attributes here, we're just inheriting from the previous version
  version 2 do
    attributes :url, :created_at
  end

  # We've substantially changed the format, declarations here are made in an exclusive scope
  version 3, :exclusive => true do
    attributes :id, :name, :text, :something_else

    def helper_method
      # Override for v3
    end
  end

  def helper_method
    # do stuff
  end
end

You could then pass in the :version argument to the serializer and it would select the highest version greater than or equal to the version specified. You could then use a custom responder or whatever to implement the versioning determination by whatever makes sense for you app (URL param, Content-Type header, whatever).

I'd be happy to champion this work if there's interest and consensus on the API direction -- we have a similar system brewing within our application that could be generalized and polished if there's a mergeable path forward.

[vikksr]

+1

[arelenglish]

I like @blakewatters idea. Any progress on this?

I like @blakewatters idea too. Maybe no one is reading this since the issue was closed a while back?

[elfassy]

https://github.com/hookercookerman/active_model_version_serializers
haven't used it myself, but could be what you are looking for

[elfassy]

actually, what @blakewatters is describing is much better

[plehoux]

application_controller.rb:

def default_serializer_options(options = {})
  name   = controller_name.classify
  object = "V#{params[:api_version]}::#{name}Serializer"
  options.merge(serializer: object.constantize)
end

routes.rb:

Rails.application.routes.draw do
  constraints subdomain: 'api', format: 'json' do
    scope '/v1', api_version: 1 do
      resources :messages
    end
  end
end

[elfassy]

@plehoux that won't work for has_many and has_one relationships between serializers

[gabehoffman]

I like @blakewatters idea. That looks like I want it to look. It's going to be needed for many people soon enough. I think this is a great topic to be open, not closed. You can only find this when you google the topic. It's an open issue in a very real way.

[blakewatters]

Unfortunately I am no longer responsible for any Rails applications so its unlikely that I’ll be implementing this myself.

I still think the API design is what you really want though :-)

[MarkMurphy]

I agree this should be re-opened. Not sure I agree with @blakewatters solution. What if I had a serializer that took 100 lines of code or more to define, and what if each new version added another large block of code. What if it gets up to 15 or 20 versions long?

I'd prefer to keep things separated.

Leaning more towards @juljimm's proposal