Change role join table association (HABTM) to a has_many through association

[phlegx]

Hi!

I want to add more data to the role join table. Actually rolify uses a HABTM table. Why don't change rolify to use a has_many through association? So, everybody can expand the role join table with custom data.

module Rolify
  ...
  def rolify(options = {})
    include Role
    ...

    rolify_options = { :class_name => options[:role_cname].camelize }
    # NOTE not needed any more
    # rolify_options.merge!({ :join_table => self.role_join_table_name }) if Rolify.orm == "active_record"
    rolify_options.merge!(options.reject{ |k,v| ![ :before_add, :after_add, :before_remove, :after_remove ].include? k.to_sym })

    # NOTE defining the association has_many through
    # has_and_belongs_to_many :roles, rolify_options
    has_many self.role_join_table_name.to_sym
    has_many :roles, rolify_options.merge!(through: self.role_join_table_name.to_sym)

   ...
  end

Here an example using a hstore (Postgresql) field:

    execute 'CREATE EXTENSION IF NOT EXISTS hstore'

    create_table :users_roles do |t|
      t.references :user, index: { with: :role_id }, null: false
      t.references :role, null: false
      t.hstore :configurations
      t.timestamps
    end

Here the model:

class UsersRole < ActiveRecord::Base

  store_accessor :configurations, :color

  validates :user, presence: true
  validates :role, presence: true
  validates :color,         ...

  belongs_to :user
  belongs_to :role

end

[wldcordeiro]

I believe this was a requested feature that the original creator was working on but never completed. It definitely would be an interesting addition.

[phlegx]

This code works. The only thing is, how to add configuration data to a new user record, for example in a view with nested attributes. First I need to add the role and then I can create nested attributes for the configuration. How do you add roles from a user view?

[werleo]

👍 There is a pull request for has many through option:

#181

[maxcal]

I found a workaround for using has_many through: with Rolify 5.1.0 in a new app (Rails 5, Postgres).

First you of course want to alter the migration:

class RolifyCreateRoles < ActiveRecord::Migration
  def change
    create_table(:roles) do |t|
      t.string :name
      t.references :resource, :polymorphic => true
      t.timestamps
    end

    create_table(:user_roles) do |t|
      t.references :user
      t.references :role
      t.timestamps
    end

    add_index(:roles, :name)
    add_index(:roles, [ :name, :resource_type, :resource_id ])
    add_index(:user_roles, [ :user_id, :role_id ])
  end
end

Then setup the models:

class Role < ApplicationRecord
  has_many :user_roles
  has_many :users, through: :user_roles

  belongs_to :resource,
             polymorphic: true,
             optional: true

  validates :resource_type,
            inclusion: { in: Rolify.resource_types },
            allow_nil: true

  scopify
end

class UserRole < ApplicationRecord
  belongs_to :user
  belongs_to :role
end

class User < ApplicationRecord
  rolify
  has_many :user_roles
  has_many :roles, through: :user_roles
end

The key is putting has_many :roles, through: :user_roles after the call to rolify so that it overwrites the HABTM association. Of course it would be better with a config option that enables a less hacky solution but I have not found any hitches yet when it comes to adding roles or querying.

[ashiksp]

Thanks @maxcal.

Note: Without altering any migration referencing UsersRole instead of UserRole should work as intended.

class Role < ApplicationRecord
  has_many :users_roles
  has_many :users, through: :users_roles

  belongs_to :resource,
             polymorphic: true,
             optional: true

  validates :resource_type,
            inclusion: { in: Rolify.resource_types },
            allow_nil: true

  scopify
end

class UsersRole < ApplicationRecord
  belongs_to :user
  belongs_to :role
end

class User < ApplicationRecord
  rolify
  has_many :users_roles
  has_many :roles, through: :users_roles
end

[maxcal]

Breaking the pluralization conventions feels hacky. Better to call the class UserRole and set 'table_name = "users_roles"'

[ashiksp]

Agree, that would be nice to keep conventions.

[scverano]

Hey mates,

I tried this setup since I need to add additional columns in user_roles table - #318 (comment)

But, unfortunately it does not working using Rails 5.2.1 and Ruby 2.5.1

ActiveRecord::HasManyThroughOrderError (Cannot have a has_many :through association 'User#roles' which goes through 'User#user_roles' before the through association is defined.)

[maxcal]

You have to declare the association you are going through first:

class User
  has_many :user_roles
  has_many :roles, through: :user_roles
end

Not:

class User
  has_many :roles, through: :user_roles
  has_many :user_roles
end

[TimFletcher]

I have the same issue as @scverano on Rails 5.2.0 and my association declarations are definitely in the right order.

I suspect this Rails issue which was fixed in rails/rails@652258e and released in 5.2.1. Doesn't seem to help though.

Update: Seems to work with @ashiksp's solution so long as you do NOT set the table name with self.table_name = 'users_roles'. Perhaps then renaming the table via a migration as suggested by @maxcal is the best approach.