ActiveModel::Serializer Subclass that will accept any attribute dynamically? - ruby-on-rails

Question

I'm building an API engine for an existing app, which will serve JSON with ActiveModel::Serializer. On the existing app, There are some controllers that just render regular old hashes that aren't instances of any ActiveModel subclass - originally, these were AJAX endpoints so it didn't matter what class the response body was.
I need to recreate some of these existing endpoints in the API module, so for instances like these, I want to build a custom serializer that will accept whatever attributes you throw at it. something like...
In the Controller:
def show
response = {
key: "this is a custom object and not an AM instance"
}
render json: response, serializer: Api::V1::CustomSerializer
end
And the serializer:
module Api
module V1
class CustomSerializer < ActiveModel::Serializer
def attributes
*object.keys.map(&:to_sym)
end
def read_attribute_for_serialization(attr)
object[attr.to_s]
end
end
end
end
Couple of problems:
a) The call to render in the controller doesn't seem to like the amount of args I've passed to render, which supposedly takes *args, which suggests to me there is something wrong with the override methods I've written.
b) If I were to just put attributes *object.class.column_names.map(&:to_sym) in the first line of the class, object is undefined outside of a method.
c) I call it inside a method, the resulting hash is nested inside whatever I choose to call that method. Not really what I had in mind.
My question: has anyone successfully created a serializer that will accept any attribute? Would love to know how.
PLEASE NOTE: I would like achieve this with AMS if I can - we're using the adapter for JSON API for all our response bodies. I would much rather make this work then initialize a hash identical to the json api standard we're using every time the response is not an AM instance.

Answer 1

For the folks who might have stumbled across the same problem, I ended up assembling a catch-all serializer class for anything i want to render that isn't a subclass of Active Record. Like so:
module Api
module V1
class CustomSerializer
def initialize(obj, error: false, type: nil)
#hash = error ? error_hash(obj) : success_hash(type, obj)
end
def to_h
#hash
end
private
def error_hash(obj)
{
errors: {
pointer: obj[:error] || obj[:errors]
},
detail: detail(obj)
}
end
def success_hash(type, obj)
{
id: obj.try(:id) ? obj[:id] : nil,
type: type.nil? ? 'hash' : type,
data: obj.try(:id) ? obj.except(:id) : obj,
links: ''
}
end
def detail(obj)
obj[:detail] || obj[:message] || obj[:msg]
end
end
end
end
Note that I'm working with the JSON API standard. Then, instead of doing something like this for an activemodel serializer:
render json: #device, serializer: Api::V1::DeviceSerializer
I can do something like this:
render json: Api::V1::CustomSerializer.new(#response, error: false, type: 'feed').to_h
basically just means I can still render the JSON api standard for anything that is just an instance of a Hash class, or anything for which I'm doing external API requests and storing in a Hash. Hope this helps someone someday.