active_force 0.15.1 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c325fe186d67cce9500a1df17360184bd97c2fa26fed2819b327f3ea8331df7c
-  data.tar.gz: 482d5c2fabed72c3d12b646037dad7900f26e17260000a65e171d42ab41ce394
+  metadata.gz: 741f33a6c27d6bc11eaaa7655c2a7fb2ecc772f93d298e608866840b82e94321
+  data.tar.gz: 465abe2c572e35dc61817ab1bf8ac1d6d0e35e6f26eb2e933af3ed1781c2c68a
 SHA512:
-  metadata.gz: 05a36678b1ba07b3e89b1a755e7526facd18cdef04cdfcb9dd1b08224f42bbcc779959c26e869a3ead38e5add649d710e4afc4f0c1f88cdbcd73287360da3f7a
-  data.tar.gz: 13724331bdafe67729dafd0ca31a863657e125c8bb458fb8a0316aa5a2fba9f466c0e3ff52bc6fbc80a9190639636e726ac8c9940cc92836260b774cc7024ec5
+  metadata.gz: 376ab891dc3a0bf92f030dd3b756aa900c8091bfd42b3424ef1c832ecc2ac14384785f96eeadc20764f22ee02315753cba10c4b0aec067294e2175a09754dc60
+  data.tar.gz: f60cf65275aaee5e96ebb173cc0718cbc663b3cced951bccf8b417df1029055606be56bdf82617e689130d68687b8ce8f8227acab83314c54715e95e6ca28629

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Not released
 
+## 0.17.0
+
+- Fix bug with has_many queries due to query method chaining mutating in-place (https://github.com/Beyond-Finance/active_force/pull/10)
+
+## 0.16.0
+
+- Fix `default` in models when default value is overridden by the same value, it is still sent to salesforce (https://github.com/Beyond-Finance/active_force/pull/61)
+- Support to fetch multi-level associations during eager load (https://github.com/Beyond-Finance/active_force/pull/62)
+
 ## 0.15.1
 
 - Revert new `pluck` implementation due to compatibility issues (https://github.com/Beyond-Finance/active_force/pull/60)

data/README.md

@@ -192,6 +192,21 @@ It is also possible to eager load associations:
 Comment.includes(:post)
 ```
 
+It is possible to eager load multi level associations
+
+In order to utilize multi level eager loads, the API version should be set to 58.0 or higher when instantiating a Restforce client 
+
+```ruby
+Restforce.new({api_version: '58.0'})
+```
+
+Examples:
+
+```ruby
+Comment.includes(post: :owner)
+Comment.includes({post: {owner: :account}})
+```
+
 ### Aggregates
 
 Summing the values of a column:

data/lib/active_force/active_query.rb

@@ -4,7 +4,6 @@ require 'forwardable'
 
 module ActiveForce
   class PreparedStatementInvalid < ArgumentError; end
-
   class RecordNotFound < StandardError
     attr_reader :table_name, :conditions
 
@@ -19,15 +18,16 @@ module ActiveForce
   class ActiveQuery < Query
     extend Forwardable
 
-    attr_reader :sobject, :association_mapping
+    attr_reader :sobject, :association_mapping, :belongs_to_association_mapping
 
     def_delegators :sobject, :sfdc_client, :build, :table_name, :mappings
     def_delegators :to_a, :each, :map, :inspect, :pluck, :each_with_object
 
-    def initialize sobject
+    def initialize (sobject, custom_table_name = nil)
       @sobject = sobject
       @association_mapping = {}
-      super table_name
+      @belongs_to_association_mapping = {}
+      super custom_table_name || table_name
       fields sobject.fields
     end
 
@@ -42,36 +42,34 @@ module ActiveForce
     alias_method :all, :to_a
 
     def count
-      super
-      sfdc_client.query(to_s).first.expr0
+      sfdc_client.query(super.to_s).first.expr0
     end
 
     def sum field
-      super(mappings[field])
-      sfdc_client.query(to_s).first.expr0
+      raise ArgumentError, 'field is required' if field.blank?
+      raise ArgumentError, "field '#{field}' does not exist on #{sobject}" unless mappings.key?(field.to_sym)
+
+      sfdc_client.query(super(mappings.fetch(field.to_sym)).to_s).first.expr0
     end
 
     def limit limit
-      super
-      limit == 1 ? to_a.first : self
+      limit == 1 ? super.to_a.first : super
     end
 
     def not args=nil, *rest
       return self if args.nil?
+
       super build_condition args, rest
-      self
     end
 
     def where args=nil, *rest
       return self if args.nil?
-      return clone_self_and_clear_cache.where(args, *rest) if @decorated_records.present?
       super build_condition args, rest
-      self
     end
 
-    def select *fields
-      fields.map! { |field| mappings[field] }
-      super *fields
+    def select *selected_fields
+      selected_fields.map! { |field| mappings[field] }
+      super *selected_fields
     end
 
     def find!(id)
@@ -93,18 +91,17 @@ module ActiveForce
     end
 
     def includes(*relations)
-      relations.each do |relation|
-        association = sobject.associations[relation]
-        fields Association::EagerLoadProjectionBuilder.build association
-        # downcase the key and downcase when we do the comparison so we don't do any more crazy string manipulation
-        association_mapping[association.sfdc_association_field.downcase] = association.relation_name
-      end
+      includes_query = Association::EagerLoadBuilderForNestedIncludes.build(relations, sobject)
+      fields includes_query[:fields]
+      association_mapping.merge!(includes_query[:association_mapping])
       self
     end
 
     def none
-      @records = []
-      where(id: '1'*18).where(id: '0'*18)
+      clone_and_set_instance_variables(
+        records: [],
+        conditions: [build_condition(id: '1' * 18), build_condition(id: '0' * 18)]
+      )
     end
 
     def loaded?
@@ -208,13 +205,6 @@ module ActiveForce
       sfdc_client.query(self.to_s)
     end
 
-    def clone_self_and_clear_cache
-      new_query = self.clone
-      new_query.instance_variable_set(:@decorated_records, nil)
-      new_query.instance_variable_set(:@records, nil)
-      new_query
-    end
-
     def build_order_by(args)
       args.map do |arg|
         case arg
@@ -231,6 +221,5 @@ module ActiveForce
     def order_type(type)
       type == :desc ? 'DESC' : 'ASC'
     end
-
   end
 end

data/lib/active_force/association/belongs_to_association.rb

@@ -16,7 +16,11 @@ module ActiveForce
       end
 
       def default_relationship_name
-        parent.mappings[foreign_key].gsub(/__c\z/, '__r')
+        if !parent.custom_table? && !relation_model.custom_table?
+          relation_model.table_name
+        else
+          parent.mappings[foreign_key].gsub(/__c\z/, '__r')
+        end
       end
 
       def default_foreign_key

data/lib/active_force/association/eager_load_builder_for_nested_includes.rb

@@ -0,0 +1,84 @@
+module ActiveForce
+
+  module Association
+    class InvalidAssociationError < StandardError; end
+
+    class EagerLoadBuilderForNestedIncludes
+
+      class << self
+        def build(relations, current_sobject, parent_association_field = nil)
+          new(relations, current_sobject, parent_association_field).projections
+        end
+      end
+
+      attr_reader :relations, :current_sobject, :association_mapping, :parent_association_field, :fields
+
+      def initialize(relations, current_sobject, parent_association_field = nil)
+        @relations = [relations].flatten
+        @current_sobject = current_sobject
+        @association_mapping = {}
+        @parent_association_field = parent_association_field
+        @fields = []
+      end
+
+
+      def projections
+        relations.each do |relation|
+          case relation
+          when Symbol
+            association = current_sobject.associations[relation]
+            raise InvalidAssociationError, "Association named #{relation} was not found on #{current_sobject}" if association.nil?
+            build_includes(association)
+          when Hash
+            build_hash_includes(relation)
+          end
+        end
+        { fields: fields, association_mapping: association_mapping }
+      end
+
+      def build_includes(association)
+        fields.concat(EagerLoadProjectionBuilder.build(association, parent_association_field))
+        association_mapping[association.sfdc_association_field.downcase] = association.relation_name
+      end
+
+      def build_hash_includes(relation, model = current_sobject, parent_association_field = nil)
+        relation.each do |key, value|
+          association = model.associations[key]
+          raise InvalidAssociationError, "Association named #{key} was not found on #{model}" if association.nil?
+          case association
+          when ActiveForce::Association::BelongsToAssociation
+            build_includes(association)
+            nested_query = build_relation_for_belongs_to(association, value)
+            fields.concat(nested_query[:fields])
+            association_mapping.merge!(nested_query[:association_mapping])
+          else
+            nested_query = build_relation(association, value)
+            fields.concat(nested_query[:fields])
+            association_mapping.merge!(nested_query[:association_mapping])
+          end
+        end
+      end
+
+      private
+
+      def build_relation(association, nested_includes)
+        sub_query = Query.new(association.sfdc_association_field)
+        sub_query.fields association.relation_model.fields
+        association_mapping[association.sfdc_association_field.downcase] = association.relation_name
+        nested_includes_query = self.class.build(nested_includes, association.relation_model)
+        sub_query.fields nested_includes_query[:fields]
+        { fields: ["(#{sub_query})"], association_mapping: nested_includes_query[:association_mapping] }
+      end
+
+
+      def build_relation_for_belongs_to(association, nested_includes)
+        if parent_association_field.present?
+          current_parent_association_field = "#{parent_association_field}.#{association.sfdc_association_field}"
+        else
+          current_parent_association_field = association.sfdc_association_field
+        end
+        self.class.build(nested_includes, association.relation_model, current_parent_association_field)
+      end
+    end
+  end
+end

data/lib/active_force/association/eager_load_projection_builder.rb

@@ -2,31 +2,33 @@ module ActiveForce
   module Association
     class EagerLoadProjectionBuilder
       class << self
-        def build(association)
-          new(association).projections
+        def build(association, parent_association_field = nil)
+          new(association, parent_association_field).projections
         end
       end
 
-      attr_reader :association
+      attr_reader :association, :parent_association_field
 
-      def initialize(association)
+      def initialize(association, parent_association_field = nil)
         @association = association
+        @parent_association_field = parent_association_field
       end
 
       def projections
         klass = association.class.name.split('::').last
         builder_class = ActiveForce::Association.const_get "#{klass}ProjectionBuilder"
-        builder_class.new(association).projections
+        builder_class.new(association, parent_association_field).projections
       rescue NameError
         raise "Don't know how to build projections for #{klass}"
       end
     end
 
     class AbstractProjectionBuilder
-      attr_reader :association
+      attr_reader :association, :parent_association_field
 
-      def initialize(association)
+      def initialize(association, parent_association_field = nil)
         @association = association
+        @parent_association_field = parent_association_field
       end
 
       def projections
@@ -57,8 +59,13 @@ module ActiveForce
 
     class BelongsToAssociationProjectionBuilder < AbstractProjectionBuilder
       def projections
+        association_field = if parent_association_field.present?
+                              "#{ parent_association_field }.#{ association.sfdc_association_field }"
+                            else
+                              association.sfdc_association_field
+                            end
         association.relation_model.fields.map do |field|
-          "#{ association.sfdc_association_field }.#{ field }"
+          "#{ association_field }.#{ field }"
         end
       end
     end

data/lib/active_force/association/relation_model_builder.rb

@@ -2,19 +2,20 @@ module ActiveForce
   module Association
     class RelationModelBuilder
       class << self
-        def build(association, value)
-          new(association, value).build_relation_model
+        def build(association, value, association_mapping = {})
+          new(association, value, association_mapping).build_relation_model
         end
       end
 
-      def initialize(association, value)
+      def initialize(association, value, association_mapping = {})
         @association = association
         @value = value
+        @association_mapping = association_mapping
       end
 
       def build_relation_model
         klass = resolve_class
-        klass.new(@association, @value).call
+        klass.new(@association, @value, @association_mapping).call
       end
 
       private
@@ -28,11 +29,12 @@ module ActiveForce
     end
 
     class AbstractBuildFrom
-      attr_reader :association, :value
+      attr_reader :association, :value, :association_mapping
 
-      def initialize(association, value)
+      def initialize(association, value, association_mapping = {})
         @association = association
         @value = value
+        @association_mapping = association_mapping
       end
 
       def call
@@ -42,13 +44,13 @@ module ActiveForce
 
     class BuildFromHash < AbstractBuildFrom
       def call
-        association.build value
+        association.build(value, association_mapping)
       end
     end
 
     class BuildFromArray < AbstractBuildFrom
       def call
-        value.map { |mash| association.build mash }
+        value.map { |mash| association.build(mash, association_mapping) }
       end
     end
 

data/lib/active_force/association.rb

@@ -4,6 +4,7 @@ require 'active_force/association/relation_model_builder'
 require 'active_force/association/has_many_association'
 require 'active_force/association/has_one_association'
 require 'active_force/association/belongs_to_association'
+require 'active_force/association/eager_load_builder_for_nested_includes'
 
 module ActiveForce
   module Association

data/lib/active_force/query.rb

@@ -31,33 +31,34 @@ module ActiveForce
     end
 
     def select *columns
-      @query_fields = columns
-      self
+      clone_and_set_instance_variables(query_fields: columns)
+    end
+
+    def where condition = nil
+      new_conditions = @conditions | [condition]
+      if new_conditions != @conditions
+        clone_and_set_instance_variables({conditions: new_conditions})
+      else
+        self
+      end
     end
 
     def not condition
-      @conditions << "NOT ((#{ condition.join(') AND (') }))"
-      self
+      condition ? where("NOT ((#{condition.join(') AND (')}))") : self
     end
 
     def or query
-      @conditions = ["(#{ and_conditions }) OR (#{ query.and_conditions })"]
-      self
-    end
+      return self unless query
 
-    def where condition = nil
-      @conditions << condition if condition
-      self
+      clone_and_set_instance_variables(conditions: ["(#{and_conditions}) OR (#{query.and_conditions})"])
     end
 
     def order order
-      @order = order if order
-      self
+      order ? clone_and_set_instance_variables(order: order) : self
     end
 
     def limit size
-      @size = size if size
-      self
+      size ? clone_and_set_instance_variables(size: size) : self
     end
 
     def limit_value
@@ -65,8 +66,7 @@ module ActiveForce
     end
 
     def offset offset
-      @offset = offset
-      self
+      clone_and_set_instance_variables(offset: offset)
     end
 
     def offset_value
@@ -74,8 +74,7 @@ module ActiveForce
     end
 
     def find id
-      where "#{ @table_id } = '#{ id }'"
-      limit 1
+      where("#{ @table_id } = '#{ id }'").limit 1
     end
 
     def first
@@ -87,18 +86,17 @@ module ActiveForce
     end
 
     def join object_query
-      fields ["(#{ object_query.to_s })"]
-      self
+      chained_query = self.clone
+      chained_query.fields ["(#{ object_query.to_s })"]
+      chained_query
     end
 
     def count
-      @query_fields = ["count(Id)"]
-      self
+      clone_and_set_instance_variables(query_fields: ["count(Id)"])
     end
 
     def sum field
-      @query_fields = ["sum(#{field})"]
-      self
+      clone_and_set_instance_variables(query_fields: ["sum(#{field})"])
     end
 
     protected
@@ -125,5 +123,13 @@ module ActiveForce
       def build_offset
         "OFFSET #{ @offset }" if @offset
       end
+
+      def clone_and_set_instance_variables instance_variable_hash={}
+        clone = self.clone
+        clone.instance_variable_set(:@decorated_records, nil)
+        clone.instance_variable_set(:@records, nil)
+        instance_variable_hash.each { |k,v| clone.instance_variable_set("@#{k.to_s}", v) }
+        clone
+      end
   end
 end

data/lib/active_force/sobject.rb

@@ -68,7 +68,7 @@ module ActiveForce
           if association_mapping.has_key?(column.downcase)
             column = association_mapping[column.downcase]
           end
-          sobject.write_value column, value
+          sobject.write_value column, value, association_mapping
         end
       end
       sobject.clear_changes_information
@@ -173,10 +173,10 @@ module ActiveForce
       self
     end
 
-    def write_value key, value
+    def write_value key, value, association_mapping = {}
       if association = self.class.find_association(key.to_sym)
         field = association.relation_name
-        value = Association::RelationModelBuilder.build(association, value)
+        value = Association::RelationModelBuilder.build(association, value, association_mapping)
       elsif key.to_sym.in?(mappings.keys)
         # key is a field name
         field = key
@@ -227,9 +227,13 @@ module ActiveForce
     end
 
     def attributes_for_create
-      @attributes.each_value.select { |value| value.is_a?(ActiveModel::Attribute::UserProvidedDefault) }
-                            .map(&:name)
-                            .concat(changed)
+      default_attributes.concat(changed)
+    end
+
+    def default_attributes
+      @attributes.each_value.select do |value| 
+        value.is_a?(ActiveModel::Attribute::UserProvidedDefault) || value.instance_values["original_attribute"].is_a?(ActiveModel::Attribute::UserProvidedDefault)
+      end.map(&:name)
     end
 
     def attributes_for_update

data/lib/active_force/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveForce
-  VERSION = '0.15.1'
+  VERSION = '0.17.0'
 end