Handling Arrays of ActiveRecord Instances in ActiveModel POROs

This approach is certainly within the range of what Rails developers do when building non–database-backed objects that behave like form objects. Using ActiveModel to validate and transform your incoming parameters is idiomatic. It’s also common to see before_validation hooks used to preprocess incoming values (for example, converting model instances into their IDs).

That said, here are a few additional thoughts to consider:

1. Custom Attribute Types:
   Instead of using serialize with a plain Array, you might consider defining a custom attribute type that handles the casting. For instance, you could define a type that knows how to accept an array of instances or IDs and ensures it always returns an array of IDs. This keeps your before_validation hook slim or even eliminates it.

2. Clarity and Separation of Concerns:
   Your Query objects serve as a parameter object, a validator, and even a translator into AR scopes. Keeping these responsibilities clear and separated can be useful as the logic grows. Custom attribute types or even dedicated service objects for processing these parameters can help maintain clarity.

3. Testing and Edge Cases:
   Since you’re accepting both AR instances and IDs, be sure to cover edge cases (e.g., nil values, unrecognized types) in your validations. This is especially important when dealing with a mix of types in one attribute.

Here’s an example showing how you might refactor the before_validation hook using ActiveModel attributes with a custom type:

RUBYCopied
# Define a custom type for model references.
class ModelIdArray < ActiveModel::Type::Value
  def initialize(model_class)
    @model_class = model_class
  end

  def cast(value)
    Array.wrap(value).map do |v|
      if v.is_a?(@model_class)
        v.id
      else
        v
      end
    end
  end
end

# In your Query object:
class Query::Name
  include ActiveModel::Model
  include ActiveModel::Attributes

  attribute :created_at, :datetime
  attribute :updated_at, :datetime

  # Use the custom type for array attributes that reference models
  attribute :ids, ModelIdArray.new(Name)
  attribute :users, ModelIdArray.new(User)
  attribute :topics, ModelIdArray.new(Topic)

  enum misspellings: { no: 0, either: 1, only: 2 }

  attribute :text_name_has, :string
  attribute :with_notes, :boolean

  # With the custom type, you might not need a before_validation hook anymore.
end

In this refactored version, the custom type handles transforming instances into IDs automatically when the attribute is assigned. This not only is idiomatic in Rails 7 but also leans on Rails’ built-in typecasting system, making your code cleaner and more maintainable.

So to answer your questions:

• Yes, using ActiveModel to create model-like POROs for assembling and validating parameters is idiomatic.
• Yes, using a before_validation hook (or a custom attribute type) to convert AR model instances into IDs is a good approach as long as it aligns with your design and testing requirements.

Both solutions are valid, and you might choose one over the other based on your preference for explicit preprocessing (using before_validation) versus leveraging Rails’ type system (custom attribute types).