Identifying multiple instances of a polymorphic association in Rails

I recently had a problem which was solved by a polymorphic association and made things easy. Then came a twist: I needed model B to have a reference to two identifiable instances of A (polymorphic).

I’m having a hard time explaining what the problem is without an example so I hope that the rest of the post and examples will shed light on that.

The basics - a polymorphic association

I have a House and a Car. They both need to be protected by an AccessCode of some sort. The user interface will be such that if you enter an access code, you’ll end up inside the House or the Car without really knowing what you’re getting into.

Polymorphic are such that a model can belong to more than one other model on a single association.

class AccessCode < ActiveRecord::Base
  belongs_to :protected_belonging, polymorphic: true

  before_create do
    self.code = rand(100) # Imagine something complex and unique here :-)
  end
end

class Car < ActiveRecord::Base
  has_one :access_code, as: :protected_belonging
  after_create do
    self.create_access_code
  end
end

class House < ActiveRecord::Base
  has_one :access_code, as: :protected_belonging
  after_create do
    self.create_access_code
  end
end

For polymorphic associations to work, the access_codes table will need to hold the type as well as the id of the linked object.

class CreateExampleSchemas < ActiveRecord::Migration
  def change
    create_table :houses do |t|
      t.string :address
    end

    create_table :cars do |t|
      t.string :make
      t.string :model
    end

    create_table :access_codes do |t|
      t.integer :code
      t.integer :protected_belonging_id
      t.string :protected_belonging_type
    end
  end
end

Learn more about polymorphic associations from the Rails guides

With that set up, an AccessCode can belong to multiple types of protected belongings. As I mentioned earlier, one goal I had set out from early on was that I should be able to find a protected belonging based on an entered access code.

> car = Car.create(make: "Subaru", model: "WRX")
#=> <Car id: 1, make: "Subaru", model: "WRX")

> car.access_code
#=> <AccessCode id: 1, protected_belonging_type: "Car", protected_belonging_id: 1, code: 5>

> AccessCode.find_by_code(5).protected_belonging
#=> <Car id: 1, make: "Subaru", model: "WRX">

> house = House.create(address: "123 Broadway St, NY")
#=> <House id: 1, address: "123 Broadway St, NY">

> house.access_code
#=> <AccessCode id: 2, protected_belonging_type: "House", protected_belonging_id: 1, code: 94>

> AccessCode.find_by_code(94).protected_belonging
#=> <House id: 1, address: "123 Broadway St, NY">

But what if my house has 2 doors to protect?

My house has two doors, a front and back door. I’d really like to protect each doors with their own unique access codes. I thought the solution was going to be as easy as linking House to two AccessCode objects.

class House < ActiveRecord::Base
  has_one :front_door_access_code, as: :protected_belonging, class_name: "AccessCode"
  has_one :back_door_access_code, as: :protected_belonging, class_name: "AccessCode"
  after_create do
    self.create_front_door_access_code
    self.create_back_door_access_code
  end
end

This will create 2 access codes successfully, but I don’t know which door I am allowed to open based on my access code.

> house = House.create(address: "123 Broadway St, NY")
#=> <House id: 1, address: "123 Broadway St, NY">

> house.front_door_access_code
#=> <AccessCode id: 1, protected_belonging_type: "House", protected_belonging_id: 1, access_code: 3>

> house.back_door_access_code
#=> <AccessCode id: 1, protected_belonging_type: "House", protected_belonging_id: 1, access_code: 3>

> AccessCode.all
#=> [
#=>   <AccessCode id: 1, protected_belonging_type: "House", protected_belonging_id: 1, access_code: 3>,
#=>   <AccessCode id: 2, protected_belonging_type: "House", protected_belonging_id: 1, access_code: 56>
#=> ]

This had me scratching my head for a bit and I couldn’t find any good solution online. I knew I’d have to manage a door_type field in AccessCode, but the thought of having to manage that explicitely when defining the association didn’t sit right with me. It also didn’t help that the door_type concept doesn’t apply to all types of protected belongings.

Single table inheritance (STI) to the rescue

By making the front and back door access codes their own types, I don’t have to manage the type field manually, Rails will handle it automagically.

To get STI going, the first thing needed is a type field in the access_codes table. This will allow Rails to save different types of objects in a single table, and return the right object types on fetch.

class AddTypeToAccessCodes < ActiveRecord::Migration
  def change
    add_column :access_codes, :type, :string, default: "AccessCode"
  end
end

Read more about single table inheritance in the ActiveRecord documentation.

Once there’s a type field in AccessCode, subclasses can be defined. The House class can also appropriately link to 2 access code types.

class FrontDoorAccessCode < AccessCode
end

class BackDoorAccessCode < AccessCode
end

class House < ActiveRecord::Base
  has_one :front_door_access_code, as: :protected_belonging
  has_one :back_door_access_code, as: :protected_belonging
  after_create do
    self.create_front_door_access_code
    self.create_back_door_access_code
  end
end

The results? Total security! It’s now possible to identify which door an access code opens.

> house = House.create(address: "123 Broadway St, NY")
#=> <House id: 1, address: "123 Broadway St, NY">

> car = Car.create(make: "Subaru", model: "WRX")
#=> <Car id: 1, make: "Subaru", model: "WRX")

> AccessCode.all
#=> [
#=>   <FrontDoorAccessCode id: 1, type: "FrontDoorAccessCode", protected_belonging_type: "House", protected_belonging_id: 1, access_code: 3>
#=>   <BackDoorAccessCode id: 2, type: "BackDoorAccessCode", protected_belonging_type: "House", protected_belonging_id: 1, access_code: 54>
#=>   <AccessCode id: 3, type: "AccessCode", protected_belonging_type: "Car", protected_belonging_id: 1, code: 5>
#=> ]

> house.front_door_access_code
#=> <FrontDoorAccessCode id: 1, type: "FrontDoorAccessCode", protected_belonging_type: "House", protected_belonging_id: 1, access_code: 3>

> house.back_door_access_code
#=> <BackDoorAccessCode id: 2, type: "BackDoorAccessCode", protected_belonging_type: "House", protected_belonging_id: 1, access_code: 54>

> AccessCode.find_by_code(3).protected_belonging
#=> <House id: 1, address: "123 Broadway St, NY">

> AccessCode.find_by_code(54).protected_belonging
#=> <House id: 1, address: "123 Broadway St, NY">

> AccessCode.find_by_code(54).protected_belonging.front_door_access_code.code == 54
#=> true

Final thoughts

The same house will always be returned by the access code search. Given that I have an AccessCode instance and I can get the door specific FrontDoorAccessCode or BackDoorAccessCode instances for a House, I’ll be able to act accordingly based on that information.

Additionally, I’m not sure how I feel about having to create AccessCode subclasses every time a protected belonging needs to be protected by more than one AccessCode. In my real word use case, I don’t think that this will happen often so I’m happy with this solution.

comments powered by Disqus
Learn More

Subscribe via RSS