|
| 1 | +module JSONAPI |
| 2 | + class RelationshipBuilder |
| 3 | + attr_reader :model_class, :options, :relationship_class |
| 4 | + delegate :register_relationship, to: :@resource_class |
| 5 | + |
| 6 | + def initialize(relationship_class, model_class, options) |
| 7 | + @relationship_class = relationship_class |
| 8 | + @model_class = model_class |
| 9 | + @resource_class = options[:parent_resource] |
| 10 | + @options = options |
| 11 | + end |
| 12 | + |
| 13 | + def define_relationship_methods(relationship_name) |
| 14 | + # Initialize from an ActiveRecord model's properties |
| 15 | + if model_class && model_class.ancestors.collect{|ancestor| ancestor.name}.include?('ActiveRecord::Base') |
| 16 | + model_association = model_class.reflect_on_association(relationship_name) |
| 17 | + if model_association |
| 18 | + options[:class_name] ||= model_association.class_name |
| 19 | + end |
| 20 | + end |
| 21 | + |
| 22 | + relationship = register_relationship( |
| 23 | + relationship_name, |
| 24 | + relationship_class.new(relationship_name, options) |
| 25 | + ) |
| 26 | + |
| 27 | + foreign_key = define_foreign_key_setter(relationship.foreign_key) |
| 28 | + |
| 29 | + case relationship |
| 30 | + when JSONAPI::Relationship::ToOne |
| 31 | + associated = define_resource_relationship_accessor(:one, relationship_name) |
| 32 | + args = [relationship, foreign_key, associated, relationship_name] |
| 33 | + |
| 34 | + relationship.belongs_to? ? build_belongs_to(*args) : build_has_one(*args) |
| 35 | + when JSONAPI::Relationship::ToMany |
| 36 | + associated = define_resource_relationship_accessor(:many, relationship_name) |
| 37 | + |
| 38 | + build_to_many(relationship, foreign_key, associated, relationship_name) |
| 39 | + end |
| 40 | + end |
| 41 | + |
| 42 | + def define_foreign_key_setter(foreign_key) |
| 43 | + define_on_resource "#{foreign_key}=" do |value| |
| 44 | + @model.method("#{foreign_key}=").call(value) |
| 45 | + end |
| 46 | + foreign_key |
| 47 | + end |
| 48 | + |
| 49 | + def define_resource_relationship_accessor(type, relationship_name) |
| 50 | + associated_records_method_name = { |
| 51 | + one: "record_for_#{relationship_name}", |
| 52 | + many: "records_for_#{relationship_name}" |
| 53 | + } |
| 54 | + .fetch(type) |
| 55 | + |
| 56 | + define_on_resource associated_records_method_name do |
| 57 | + relationship = self.class._relationships[relationship_name] |
| 58 | + relation_name = relationship.relation_name(context: @context) |
| 59 | + records_for(relation_name) |
| 60 | + end |
| 61 | + |
| 62 | + associated_records_method_name |
| 63 | + end |
| 64 | + |
| 65 | + def build_belongs_to(relationship, foreign_key, associated_records_method_name, relationship_name) |
| 66 | + # Calls method matching foreign key name on model instance |
| 67 | + define_on_resource foreign_key do |
| 68 | + @model.method(foreign_key).call |
| 69 | + end |
| 70 | + |
| 71 | + # Returns instantiated related resource object or nil |
| 72 | + define_on_resource relationship_name do |options = {}| |
| 73 | + relationship = self.class._relationships[relationship_name] |
| 74 | + |
| 75 | + if relationship.polymorphic? |
| 76 | + associated_model = public_send(associated_records_method_name) |
| 77 | + resource_klass = self.class.resource_for_model(associated_model) if associated_model |
| 78 | + return resource_klass.new(associated_model, @context) if resource_klass |
| 79 | + else |
| 80 | + resource_klass = relationship.resource_klass |
| 81 | + if resource_klass |
| 82 | + associated_model = public_send(associated_records_method_name) |
| 83 | + return associated_model ? resource_klass.new(associated_model, @context) : nil |
| 84 | + end |
| 85 | + end |
| 86 | + end |
| 87 | + end |
| 88 | + |
| 89 | + def build_has_one(relationship, foreign_key, associated_records_method_name, relationship_name) |
| 90 | + # Returns primary key name of related resource class |
| 91 | + define_on_resource foreign_key do |
| 92 | + relationship = self.class._relationships[relationship_name] |
| 93 | + |
| 94 | + record = public_send(associated_records_method_name) |
| 95 | + return nil if record.nil? |
| 96 | + record.public_send(relationship.resource_klass._primary_key) |
| 97 | + end |
| 98 | + |
| 99 | + # Returns instantiated related resource object or nil |
| 100 | + define_on_resource relationship_name do |options = {}| |
| 101 | + relationship = self.class._relationships[relationship_name] |
| 102 | + |
| 103 | + resource_klass = relationship.resource_klass |
| 104 | + if resource_klass |
| 105 | + associated_model = public_send(associated_records_method_name) |
| 106 | + return associated_model ? resource_klass.new(associated_model, @context) : nil |
| 107 | + end |
| 108 | + end |
| 109 | + end |
| 110 | + |
| 111 | + def build_to_many(relationship, foreign_key, associated_records_method_name, relationship_name) |
| 112 | + # Returns array of primary keys of related resource classes |
| 113 | + define_on_resource foreign_key do |
| 114 | + records = public_send(associated_records_method_name) |
| 115 | + return records.collect do |record| |
| 116 | + record.public_send(relationship.resource_klass._primary_key) |
| 117 | + end |
| 118 | + end |
| 119 | + |
| 120 | + # Returns array of instantiated related resource objects |
| 121 | + define_on_resource relationship_name do |options = {}| |
| 122 | + relationship = self.class._relationships[relationship_name] |
| 123 | + |
| 124 | + resource_klass = relationship.resource_klass |
| 125 | + records = public_send(associated_records_method_name) |
| 126 | + |
| 127 | + filters = options.fetch(:filters, {}) |
| 128 | + unless filters.nil? || filters.empty? |
| 129 | + records = resource_klass.apply_filters(records, filters, options) |
| 130 | + end |
| 131 | + |
| 132 | + sort_criteria = options.fetch(:sort_criteria, {}) |
| 133 | + unless sort_criteria.nil? || sort_criteria.empty? |
| 134 | + order_options = relationship.resource_klass.construct_order_options(sort_criteria) |
| 135 | + records = resource_klass.apply_sort(records, order_options, @context) |
| 136 | + end |
| 137 | + |
| 138 | + paginator = options[:paginator] |
| 139 | + if paginator |
| 140 | + records = resource_klass.apply_pagination(records, paginator, order_options) |
| 141 | + end |
| 142 | + |
| 143 | + return records.collect do |record| |
| 144 | + if relationship.polymorphic? |
| 145 | + resource_klass = self.class.resource_for_model(record) |
| 146 | + end |
| 147 | + resource_klass.new(record, @context) |
| 148 | + end |
| 149 | + end |
| 150 | + end |
| 151 | + |
| 152 | + def define_on_resource(method_name, &block) |
| 153 | + return if @resource_class.method_defined?(method_name) |
| 154 | + @resource_class.inject_method_definition(method_name, block) |
| 155 | + end |
| 156 | + end |
| 157 | +end |
0 commit comments