hyper-model 1.0.alpha1.2 → 1.0.alpha1.7

data/lib/reactive_record/active_record/public_columns_hash.rb

@@ -6,39 +6,38 @@ module ActiveRecord
   # adds method to get the HyperMesh public column types
   # this works because the public folder is currently required to be eager loaded.
   class Base
+    @@hyper_stack_public_columns_hash_mutex = Mutex.new
     def self.public_columns_hash
-      return @public_columns_hash if @public_columns_hash && Rails.env.production?
-      files = []
-      Hyperstack.public_model_directories.each do |dir|
-        dir_length = Rails.root.join(dir).to_s.length + 1
-        Dir.glob(Rails.root.join(dir, '**', '*.rb')).each do |file|
-          require_dependency(file) # still the file is loaded to make sure for development and test env
-          files << file[dir_length..-4]
+      @@hyper_stack_public_columns_hash_mutex.synchronize do
+        return @public_columns_hash if @public_columns_hash && Rails.env.production?
+        files = []
+        Hyperstack.public_model_directories.each do |dir|
+          dir_length = Rails.root.join(dir).to_s.length + 1
+          Dir.glob(Rails.root.join(dir, '**', '*.rb')).each do |file|
+            require_dependency(file) # still the file is loaded to make sure for development and test env
+            files << file[dir_length..-4]
+          end
         end
-      end
-      @public_columns_hash = {}
-      # descendants only works for already loaded models!
-      descendants.each do |model|
-        if files.include?(model.name.underscore) && model.name.underscore != 'application_record'
-          @public_columns_hash[model.name] = model.columns_hash rescue nil # why rescue?
+        @public_columns_hash = {}
+        # descendants only works for already loaded models!
+        descendants.each do |model|
+          if files.include?(model.name.underscore) && model.name.underscore != 'application_record'
+            @public_columns_hash[model.name] = model.columns_hash rescue nil # why rescue?
+          end
         end
-        # begin
-        #   @public_columns_hash[model.name] = model.columns_hash if model.table_name
-        # rescue Exception => e
-        #   binding.pry
-        #   @public_columns_hash = nil
-        #   raise $!, "Could not read 'columns_hash' for #{model}: #{$!}", $!.backtrace
-        # end if files.include?(model.name.underscore) && model.name.underscore != 'application_record'
+        @public_columns_hash
       end
-      @public_columns_hash
     end
 
+    @@hyper_stack_public_columns_hash_as_json_mutex = Mutex.new
     def self.public_columns_hash_as_json
-      return @public_columns_hash_json if @public_columns_hash_json && Rails.env.production?
-      pch = public_columns_hash
-      return @public_columns_hash_json if @prev_public_columns_hash == pch
-      @prev_public_columns_hash = pch
-      @public_columns_hash_json = pch.to_json
+      @@hyper_stack_public_columns_hash_as_json_mutex.synchronize do
+        return @public_columns_hash_json if @public_columns_hash_json && Rails.env.production?
+        pch = public_columns_hash
+        return @public_columns_hash_json if @prev_public_columns_hash == pch
+        @prev_public_columns_hash = pch
+        @public_columns_hash_json = pch.to_json
+      end
     end
   end
 end

data/lib/reactive_record/active_record/reactive_record/backing_record_inspector.rb

@@ -4,11 +4,11 @@ module ReactiveRecord
   # the appropriate string.  The order of execution is important!
   module BackingRecordInspector
     def inspection_details
-      return error_details    unless errors.empty?
-      return new_details      if new?
+      return error_details     unless errors.empty?
+      return new_details       if new?
       return destroyed_details if destroyed
-      return loading_details  unless @attributes.key? primary_key
-      return dirty_details    unless changed_attributes.empty?
+      return loading_details   unless @attributes.key? primary_key
+      return dirty_details     unless changed_attributes.empty?
       "[loaded id: #{id}]"
     end
 
@@ -26,11 +26,28 @@ module ReactiveRecord
     end
 
     def loading_details
-      "[loading #{vector}]"
+      "[loading #{pretty_vector}]"
     end
 
     def dirty_details
       "[changed id: #{id} #{changes}]"
     end
+
+    def pretty_vector
+      v = []
+      i = 0
+      while i < vector.length
+        if vector[i] == 'all' && vector[i + 1].is_a?(Array) &&
+           vector[i + 1][0] == '___hyperstack_internal_scoped_find_by' &&
+           vector[i + 2] == '*0'
+          v << ['find_by', vector[i + 1][1]]
+          i += 3
+        else
+          v << vector[i]
+          i += 1
+        end
+      end
+      v
+    end
   end
 end

data/lib/reactive_record/active_record/reactive_record/base.rb

@@ -38,6 +38,7 @@ module ReactiveRecord
     attr_accessor :aggregate_owner
     attr_accessor :aggregate_attribute
     attr_accessor :destroyed
+    attr_accessor :being_destroyed
     attr_accessor :updated_during
     attr_accessor :synced_attributes
     attr_accessor :virgin
@@ -67,30 +68,35 @@ module ReactiveRecord
       load_data { ServerDataCache.load_from_json(json, target) }
     end
 
+    def self.find_locally(model, attrs, new_only: nil)
+      if (id_to_find = attrs[model.primary_key])
+        !new_only && lookup_by_id(model, id_to_find)
+      else
+        @records[model.base_class].detect do |r|
+          (r.new? || !new_only) &&
+            !attrs.detect { |attr, value| r.synced_attributes[attr] != value }
+        end
+      end
+    end
+
+    def self.find_by_id(model, id)
+      find(model, model.primary_key => id)
+    end
+
     def self.find(model, attrs)
       # will return the unique record with this attribute-value pair
       # value cannot be an association or aggregation
 
       # add the inheritance column if this is an STI subclass
 
-      inher_col = model.inheritance_column
-      if inher_col && model < model.base_class && !attrs.key?(inher_col)
-        attrs = attrs.merge(inher_col => model.model_name.to_s)
-      end
+      attrs = model.__hyperstack_preprocess_attrs(attrs)
 
       model = model.base_class
       primary_key = model.primary_key
 
       # already have a record with these attribute-value pairs?
 
-      record =
-        if (id_to_find = attrs[primary_key])
-          lookup_by_id(model, id_to_find)
-        else
-          @records[model].detect do |r|
-            !attrs.detect { |attr, value| r.synced_attributes[attr] != value }
-          end
-        end
+      record = find_locally(model, attrs)
 
       unless record
         # if not, and then the record may be loaded, but not have this attribute set yet,
@@ -102,10 +108,8 @@ module ReactiveRecord
           attrs = attrs.merge primary_key => id
         end
         # if we don't have a record then create one
-        # (record = new(model)).vector = [model, [:find_by, attribute => value]] unless record
-        record ||= set_vector_lookup(new(model), [model, [:find_by, attrs]])
-        # and set the values
-        attrs.each { |attr, value| record.sync_attribute(attr, value) }
+        record ||= set_vector_lookup(new(model), [model, *find_by_vector(attrs)])
+        record.sync_attributes(attrs)
       end
       # finally initialize and return the ar_instance
       record.set_ar_instance!
@@ -115,6 +119,9 @@ module ReactiveRecord
       # this is the equivilent of find but for associations and aggregations
       # because we are not fetching a specific attribute yet, there is NO communication with the
       # server.  That only happens during find.
+
+      return DummyPolymorph.new(vector) unless model
+
       model = model.base_class
 
       # do we already have a record with this vector?  If so return it, otherwise make a new one.
@@ -122,7 +129,6 @@ module ReactiveRecord
       # record = @records[model].detect { |record| record.vector == vector }
       record = lookup_by_vector(vector)
       unless record
-
         record = new model
         set_vector_lookup(record, vector)
       end
@@ -145,7 +151,7 @@ module ReactiveRecord
       @attributes = {}
       @changed_attributes = []
       @virgin = true
-      records[model] << self
+      records[model.base_class] << self
       Base.set_object_id_lookup(self)
     end
 
@@ -175,6 +181,7 @@ module ReactiveRecord
         @ar_instance.instance_variable_set(:@backing_record, existing_record)
         existing_record.attributes.merge!(attributes) { |key, v1, v2| v1 }
       end
+      @id = value
       value
     end
 
@@ -201,7 +208,7 @@ module ReactiveRecord
     end
 
     def errors
-      @errors ||= ActiveModel::Errors.new(self)
+      @errors ||= ActiveModel::Errors.new(ar_instance)
     end
 
     # called when we have a newly created record, to initialize
@@ -211,7 +218,7 @@ module ReactiveRecord
 
     def initialize_collections
       if (!vector || vector.empty?) && id && id != ''
-        Base.set_vector_lookup(self, [@model, [:find_by, @model.primary_key => id]])
+        Base.set_vector_lookup(self, [@model, *find_by_vector(@model.primary_key => id)])
       end
       Base.load_data do
         @model.reflect_on_all_associations.each do |assoc|
@@ -247,12 +254,16 @@ module ReactiveRecord
         return if @create_sync
         @create_sync = true
       end
-      model.unscoped << ar_instance
+      model.unscoped._internal_push ar_instance
       @synced_with_unscoped = !@synced_with_unscoped
     end
 
-    def sync_attribute(attribute, value)
+    def sync_attributes(attrs)
+      attrs.each { |attr, value| sync_attribute(attr, value) }
+      self
+    end
 
+    def sync_attribute(attribute, value)
       @synced_attributes[attribute] = @attributes[attribute] = value
       Base.set_id_lookup(self) if attribute == primary_key
 
@@ -260,7 +271,7 @@ module ReactiveRecord
 
       if value.is_a? Collection
         @synced_attributes[attribute] = value.dup_for_sync
-      elsif aggregation = model.reflect_on_aggregation(attribute) and (aggregation.klass < ActiveRecord::Base)
+      elsif (aggregation = model.reflect_on_aggregation(attribute)) && (aggregation.klass < ActiveRecord::Base)
         value.backing_record.sync!
       elsif aggregation
         @synced_attributes[attribute] = aggregation.deserialize(aggregation.serialize(value))
@@ -278,6 +289,14 @@ module ReactiveRecord
       Base.lookup_by_id(model, id)
     end
 
+    def id_loaded?
+      @id
+    end
+
+    def loaded_id=(id)
+      @id = id
+    end
+
     def revert
       @changed_attributes.dup.each do |attribute|
         @ar_instance.send("#{attribute}=", @synced_attributes[attribute])
@@ -292,9 +311,11 @@ module ReactiveRecord
       @saving = true
     end
 
-    def errors!(hash)
+    def errors!(hash, saving = false)
+      @errors_at_last_sync = hash if saving
       notify_waiting_for_save
       errors.clear && return unless hash
+      errors.non_reactive_clear
       hash.each do |attribute, messages|
         messages.each do |message|
           errors.add(attribute, message)
@@ -302,6 +323,10 @@ module ReactiveRecord
       end
     end
 
+    def revert_errors!
+      errors!(@errors_at_last_sync)
+    end
+
     def saved!(save_only = nil) # sets saving to false AND notifies
       notify_waiting_for_save
       return self if save_only
@@ -403,6 +428,7 @@ module ReactiveRecord
 
     def destroy_associations
       @destroyed = false
+      @being_destroyed = true
       model.reflect_on_all_associations.each do |association|
         if association.collection?
           @attributes[association.attribute].replace([]) if @attributes[association.attribute]

data/lib/reactive_record/active_record/reactive_record/collection.rb

@@ -29,7 +29,7 @@ module ReactiveRecord
       @owner = owner  # can be nil if this is an outer most scope
       @association = association
       @target_klass = target_klass
-      if owner and !owner.id and vector.length <= 1
+      if owner && !owner.id && vector.length <= 1
         @collection = []
       elsif vector.length > 0
         @vector = vector
@@ -52,14 +52,19 @@ module ReactiveRecord
     def all
       observed
       @dummy_collection.notify if @dummy_collection
+      # unless false && @collection # this fixes https://github.com/hyperstack-org/hyperstack/issues/82 in very limited cases, and breaks otherthings
+      #   sync_collection_with_parent
+      # end
       unless @collection
         @collection = []
         if ids = ReactiveRecord::Base.fetch_from_db([*@vector, "*all"])
           ids.each do |id|
-            @collection << @target_klass.find_by(@target_klass.primary_key => id)
+            @collection << ReactiveRecord::Base.find_by_id(@target_klass, id)
           end
         else
           @dummy_collection = ReactiveRecord::Base.load_from_db(nil, *@vector, "*all")
+          # this calls back to all now that the collection is initialized,
+          # so it has the side effect of creating a dummy value in collection[0]
           @dummy_record = self[0]
         end
       end
@@ -72,6 +77,8 @@ module ReactiveRecord
         (@collection.length..index).each do |i|
           new_dummy_record = ReactiveRecord::Base.new_from_vector(@target_klass, nil, *@vector, "*#{i}")
           new_dummy_record.attributes[@association.inverse_of] = @owner if @association && !@association.through_association?
+          # HMT-TODO: the above needs to be looked into... if we are a hmt then don't we need to create a dummy on the joins collection as well?
+          # or maybe this just does not work for HMT?
           @collection << new_dummy_record
         end
       end
@@ -80,8 +87,15 @@ module ReactiveRecord
 
     def ==(other_collection)
       observed
-      return !@collection unless other_collection.is_a? Collection
+      # handle special case of other_collection NOT being a collection (typically nil)
+      return (@collection || []) == other_collection unless other_collection.is_a? Collection
       other_collection.observed
+      # if either collection has not been created then compare the vectors
+      # https://github.com/hyperstack-org/hyperstack/issues/81
+      # TODO: if this works then remove the || [] below (2 of them)
+      if !@collection || !other_collection.collection
+        return @vector == other_collection.vector && unsaved_children == other_collection.unsaved_children
+      end
       my_children = (@collection || []).select { |target| target != @dummy_record }
       if other_collection
         other_children = (other_collection.collection || []).select { |target| target != other_collection.dummy_record }
@@ -93,7 +107,7 @@ module ReactiveRecord
     end
     # todo move following to a separate module related to scope updates ******************
     attr_reader   :vector
-    attr_writer   :scope_description
+    attr_accessor :scope_description
     attr_writer   :parent
     attr_reader   :pre_sync_related_records
 
@@ -127,7 +141,10 @@ To determine this sync_scopes first asks if the record being changed is in the s
 
 
 =end
+      attr_accessor :broadcast_updated_at
+
       def sync_scopes(broadcast)
+        self.broadcast_updated_at = broadcast.updated_at
         # record_with_current_values will return nil if data between
         # the broadcast record and the value on the client is out of sync
         # not running set_pre_sync_related_records will cause sync scopes
@@ -145,6 +162,8 @@ To determine this sync_scopes first asks if the record being changed is in the s
           )
           record.backing_record.sync_unscoped_collection! if record.destroyed? || broadcast.new?
         end
+      ensure
+        self.broadcast_updated_at = nil
       end
 
       def apply_to_all_collections(method, record, dont_gather)
@@ -200,7 +219,7 @@ To determine this sync_scopes first asks if the record being changed is in the s
       return [] unless attrs[@association.inverse_of] == @owner
       if !@association.through_association
         [record]
-      elsif (source = attrs[@association.source])
+      elsif (source = attrs[@association.source]) && source.is_a?(@target_klass)
         [source]
       else
         []
@@ -212,7 +231,6 @@ To determine this sync_scopes first asks if the record being changed is in the s
     end
 
     def filter_records(related_records)
-      # possibly we should never get here???
       scope_args = @vector.last.is_a?(Array) ? @vector.last[1..-1] : []
       @scope_description.filter_records(related_records, scope_args)
     end
@@ -221,16 +239,23 @@ To determine this sync_scopes first asks if the record being changed is in the s
       @live_scopes ||= Set.new
     end
 
+    def in_this_collection(related_records)
+      # HMT-TODO: I don't think we can get a set of related records here with a through association unless they are part of the collection
+      return related_records if !@association || @association.through_association?
+      related_records.select do |r|
+        r.backing_record.attributes[@association.inverse_of] == @owner
+      end
+    end
+
     def set_pre_sync_related_records(related_records, _record = nil)
-      #related_records = related_records.intersection([*@collection]) <- deleting this works
-      @pre_sync_related_records = related_records #in_this_collection related_records <- not sure if this works
+      @pre_sync_related_records = in_this_collection(related_records)
       live_scopes.each { |scope| scope.set_pre_sync_related_records(@pre_sync_related_records) }
     end
 
     # NOTE sync_scopes is overridden in scope_description.rb
     def sync_scopes(related_records, record, filtering = true)
       #related_records = related_records.intersection([*@collection])
-      #related_records = in_this_collection related_records
+      related_records = in_this_collection(related_records) if filtering
       live_scopes.each { |scope| scope.sync_scopes(related_records, record, filtering) }
       notify_of_change unless related_records.empty?
     ensure
@@ -261,11 +286,15 @@ To determine this sync_scopes first asks if the record being changed is in the s
     end
 
     def link_to_parent
-      return if @linked
+      # puts "#{self}.link_to_parent @linked = #{!!@linked}, collection? #{!!@collection}"
+      # always check that parent is synced  - fixes issue https://github.com/hyperstack-org/hyperstack/issues/82
+      # note that sync_collection_with_parent checks to make sure that is NOT a collection and that there IS a parent
+
+      return sync_collection_with_parent if @linked
       @linked = true
       if @parent
         @parent.link_child self
-        sync_collection_with_parent unless collection
+        sync_collection_with_parent
       else
         ReactiveRecord::Base.add_to_outer_scopes self
       end
@@ -278,14 +307,23 @@ To determine this sync_scopes first asks if the record being changed is in the s
     end
 
     def sync_collection_with_parent
+      # puts "#{self}.sync_collection_with_parent"
+      return if @collection || !@parent || @parent.dummy_collection # fixes issue https://github.com/hyperstack-org/hyperstack/issues/78 and supports /82
       if @parent.collection
+        # puts ">>> @parent.collection present"
         if @parent.collection.empty?
+          # puts ">>>>> @parent.collection is empty!"
           @collection = []
         elsif filter?
-          @collection = filter_records(@parent.collection)
+          # puts "#{self}.sync_collection_with_parent (@parent = #{@parent}) calling filter records on (#{@parent.collection})"
+          @collection = filter_records(@parent.collection).to_a
         end
-      elsif @parent._count_internal(false).zero?  # just changed this from count.zero?
+      elsif !@linked && @parent._count_internal(false).zero?
+        # don't check _count_internal if already linked as this cause an unnecessary rendering cycle
+        # puts ">>> @parent._count_internal(false).zero? is true!"
         @count = 0
+      else
+        # puts ">>> NOP"
       end
     end
 
@@ -303,31 +341,33 @@ To determine this sync_scopes first asks if the record being changed is in the s
     end
 
     def observed
-      return if @observing || ReactiveRecord::Base.data_loading?
+      return self if @observing || ReactiveRecord::Base.data_loading?
       begin
         @observing = true
         link_to_parent
         reload_from_db(true) if @out_of_date
         Hyperstack::Internal::State::Variable.get(self, :collection)
+        self
       ensure
         @observing = false
       end
     end
 
-    def set_count_state(val)
+    def count_state=(val)
       unless ReactiveRecord::WhileLoading.observed?
         Hyperstack::Internal::State::Variable.set(self, :collection, collection, true)
       end
+      @count_updated_at = ReactiveRecord::Operations::Base.last_response_sent_at
       @count = val
     end
 
-
-
     def _count_internal(load_from_client)
       # when count is called on a leaf, count_internal is called for each
       # ancestor.  Only the outermost count has load_from_client == true
       observed
-      if @collection
+      if @count && @dummy_collection
+        @count # fixes https://github.com/hyperstack-org/hyperstack/issues/79
+      elsif @collection
         @collection.count
       elsif @count ||= ReactiveRecord::Base.fetch_from_db([*@vector, "*count"])
         @count
@@ -366,7 +406,7 @@ To determine this sync_scopes first asks if the record being changed is in the s
       # child.test_model = 1
       # so... we go back starting at this collection and look for the first
       # collection with an owner... that is our guy
-      child = proxy_association.klass.find(id)
+      child = ReactiveRecord::Base.find_by_id(proxy_association.klass, id)
       push child
       set_belongs_to child
     end
@@ -374,7 +414,11 @@ To determine this sync_scopes first asks if the record being changed is in the s
     def set_belongs_to(child)
       if @owner
         # TODO this is major broken...current
-        child.send("#{@association.inverse_of}=", @owner) if @association && !@association.through_association
+        if (through_association = @association.through_association)
+          # HMT-TODO: create a new record with owner and child
+        else
+          child.send("#{@association.inverse_of}=", @owner) if @association && !@association.through_association
+        end
       elsif @parent
         @parent.set_belongs_to(child)
       end
@@ -389,36 +433,57 @@ To determine this sync_scopes first asks if the record being changed is in the s
 
     def update_child(item)
       backing_record = item.backing_record
-      if backing_record && @owner && @association && !@association.through_association? && item.attributes[@association.inverse_of] != @owner
+      # HMT TODO:  The following && !association.through_association was commented out, causing wrong class items to be added to
+      # associations
+      # Why was it commented out.
+      if backing_record && @owner && @association && item.attributes[@association.inverse_of] != @owner && !@association.through_association?
         inverse_of = @association.inverse_of
-        current_association = item.attributes[inverse_of]
+        current_association_value = item.attributes[inverse_of]
         backing_record.virgin = false unless backing_record.data_loading?
+        # next line was commented out and following line was active.
         backing_record.update_belongs_to(inverse_of, @owner)
-        if current_association && current_association.attributes[@association.attribute]
-          current_association.attributes[@association.attribute].delete(item)
-        end
+        #backing_record.set_belongs_to_via_has_many(@association, @owner)
+        # following is handled by update_belongs_to and is redundant
+        # unless current_association_value.nil?  # might be a dummy value which responds to nil
+        #   current_association = @association.inverse.inverse(current_association_value)
+        #   current_association_attribute = current_association.attribute
+        #   if current_association.collection? && current_association_value.attributes[current_association_attribute]
+        #     current_association.attributes[current_association_attribute].delete(item)
+        #   end
+        # end
         @owner.backing_record.sync_has_many(@association.attribute)
       end
     end
 
     def push(item)
-      item.itself # force get of at least the id
-      if collection
-        self.force_push item
+      if (through_association = @association&.through_association)
+        through_association.klass.create(@association.inverse_of => @owner, @association.source => item)
+        self
       else
-        unsaved_children << item
-        update_child(item)
-        @owner.backing_record.sync_has_many(@association.attribute) if @owner && @association
-        if !@count.nil?
-          @count += item.destroyed? ? -1 : 1
-          notify_of_change self
-        end
+        _internal_push(item)
       end
-      self
     end
 
     alias << push
 
+    def _internal_push(item)
+      insure_sync do
+        item.itself # force get of at least the id
+        if collection
+          self.force_push item
+        else
+          unsaved_children << item
+          update_child(item)
+          @owner.backing_record.sync_has_many(@association.attribute) if @owner && @association
+          if !@count.nil?
+            @count += (item.destroyed? ? -1 : 1)
+            notify_of_change self
+          end
+        end
+      end
+      self
+    end
+
     def sort!(*args, &block)
       replace(sort(*args, &block))
     end
@@ -438,13 +503,29 @@ To determine this sync_scopes first asks if the record being changed is in the s
       notify_of_change self
     end
 
-    [:first, :last].each do |method|
-      define_method method do |*args|
-        if args.count == 0
-          all.send(method)
-        else
-          apply_scope(method, *args)
-        end
+    # [:first, :last].each do |method|
+    #   define_method method do |*args|
+    #     if args.count == 0
+    #       all.send(method)
+    #     else
+    #       apply_scope(method, *args)
+    #     end
+    #   end
+    # end
+
+    def first(n = nil)
+      if n
+        apply_scope(:first, n)
+      else
+        self[0]
+      end
+    end
+
+    def last(n = nil)
+      if n
+        apply_scope(:__hyperstack_internal_scoped_last_n, n)
+      else
+        __hyperstack_internal_scoped_last
       end
     end
 
@@ -466,46 +547,73 @@ To determine this sync_scopes first asks if the record being changed is in the s
         @dummy_collection.notify
         array = new_array.is_a?(Collection) ? new_array.collection : new_array
         @collection.each_with_index do |r, i|
-          r.id = new_array[i].id if array[i] and array[i].id and !r.new? and r.backing_record.vector.last =~ /^\*[0-9]+$/
+          r.id = new_array[i].id if array[i] and array[i].id and !r.new_record? and r.backing_record.vector.last =~ /^\*[0-9]+$/
         end
       end
-
-      @collection.dup.each { |item| delete(item) } if @collection  # this line is a big nop I think
+      # the following makes sure that the existing elements are properly removed from the collection
+      @collection.dup.each { |item| delete(item) } if @collection
       @collection = []
       if new_array.is_a? Collection
         @dummy_collection = new_array.dummy_collection
         @dummy_record = new_array.dummy_record
-        new_array.collection.each { |item| self << item } if new_array.collection
+        new_array.collection.each { |item| _internal_push item } if new_array.collection
       else
         @dummy_collection = @dummy_record = nil
-        new_array.each { |item| self << item }
+        new_array.each { |item| _internal_push item }
       end
       notify_of_change new_array
     end
 
-    def delete(item)
-      unsaved_children.delete(item)
-      notify_of_change(
-        if @owner && @association && !@association.through_association?
+    def destroy_non_habtm(item)
+      Hyperstack::Internal::State::Mapper.bulk_update do
+        unsaved_children.delete(item)
+        if @owner && @association
           inverse_of = @association.inverse_of
-          if (backing_record = item.backing_record) && item.attributes[inverse_of] == @owner
+          if (backing_record = item.backing_record) && item.attributes[inverse_of] == @owner && !@association.through_association?
             # the if prevents double update if delete is being called from << (see << above)
             backing_record.update_belongs_to(inverse_of, nil)
           end
           delete_internal(item) { @owner.backing_record.sync_has_many(@association.attribute) }
         else
           delete_internal(item)
-        end
+        end.tap { Hyperstack::Internal::State::Variable.set(self, :collection, collection) }
+      end
+    end
+
+    def destroy(item)
+      return destroy_non_habtm(item) unless @association&.habtm?
+
+      ta = @association.through_association
+      item_foreign_key = @association.source_belongs_to_association.association_foreign_key
+      join_record = ta.klass.find_by(
+        ta.association_foreign_key => @owner.id,
+        item_foreign_key => item.id
       )
+      return destroy_non_habtm(item) if join_record.nil? ||
+                                        join_record.backing_record.being_destroyed
+
+      join_record&.destroy
     end
 
+    def insure_sync
+      if Collection.broadcast_updated_at && @count_updated_at && Collection.broadcast_updated_at < @count_updated_at
+        reload_from_db
+      else
+        yield
+      end
+    end
+
+    alias delete destroy
+
     def delete_internal(item)
-      if collection
-        all.delete(item)
-      elsif !@count.nil?
-        @count -= 1
+      insure_sync do
+        if collection
+          all.delete(item)
+        elsif !@count.nil?
+          @count -= 1
+        end
+        yield if block_given? # was yield item, but item is not used
       end
-      yield if block_given? # was yield item, but item is not used
       item
     end
 
@@ -514,23 +622,74 @@ To determine this sync_scopes first asks if the record being changed is in the s
       @dummy_collection.loading?
     end
 
+    def find_by(attrs)
+      attrs = @target_klass.__hyperstack_preprocess_attrs(attrs)
+      (r = __hyperstack_internal_scoped_find_by(attrs)) || return
+      r.backing_record.sync_attributes(attrs).set_ar_instance!
+    end
+
+    def find(*args)
+      args = args[0] if args[0].is_a? Array
+      return args.collect { |id| find(id) } if args.count > 1
+      find_by(@target_klass.primary_key => args[0])
+    end
+
+    def _find_by_initializer(scope, attrs)
+      found =
+        if scope.is_a? Collection
+          scope.parent.collection&.detect { |lr| !attrs.detect { |k, v| lr.attributes[k] != v } }
+        else
+          ReactiveRecord::Base.find_locally(@target_klass, attrs)&.ar_instance
+        end
+      return first unless found
+      @collection = [found]
+      found
+    end
+
+    # to avoid fetching the entire collection array we check empty and any against the count
+
     def empty?
-      # should be handled by method missing below, but opal-rspec does not deal well
-      # with method missing, so to test...
-      all.empty?
+      count.zero?
+    end
+
+    def any?(*args, &block)
+      # If there are any args passed in, then the collection is being used in the condition
+      #   and we must load it all into memory.
+      return all.any?(*args, &block) if args&.length&.positive? || block.present?
+
+      # Otherwise we can just check the count for efficiency
+      !empty?
+    end
+
+    def none?(*args, &block)
+      # If there are any args passed in, then the collection is being used in the condition
+      #   and we must load it all into memory.
+      return all.none?(*args, &block) if args&.length&.positive? || block.present?
+
+      # Otherwise we can just check the count for efficiency
+      empty?
     end
 
     def method_missing(method, *args, &block)
-      if [].respond_to? method
+      if args.count == 1 && method.start_with?('find_by_')
+        find_by(method.sub(/^find_by_/, '') => args[0])
+      elsif [].respond_to? method
         all.send(method, *args, &block)
       elsif ScopeDescription.find(@target_klass, method)
         apply_scope(method, *args)
-      elsif args.count == 1 && method.start_with?('find_by_')
-        apply_scope(:find_by, method.sub(/^find_by_/, '') => args.first)
-      elsif @target_klass.respond_to?(method) && ScopeDescription.find(@target_klass, "_#{method}")
+      elsif !@target_klass.respond_to?(method)
+        super
+      elsif ScopeDescription.find(@target_klass, "_#{method}")
         apply_scope("_#{method}", *args).first
       else
-        super
+        # create a subclass of the original target class that responds to all
+        # by returning our collection back
+        fake_class = Class.new(@target_klass)
+        fake_class.instance_variable_set("@all", self)
+        # Opal 0.11 does not handle overridding the original @target_klass
+        # with an accessor, so we define the accessor as a method.
+        fake_class.define_singleton_method(:all) { @all }
+        fake_class.send(method, *args, &block)
       end
     end
 
@@ -552,7 +711,6 @@ To determine this sync_scopes first asks if the record being changed is in the s
       Hyperstack::Internal::State::Variable.set(self, "collection", collection) unless ReactiveRecord::Base.data_loading?
       value
     end
-
   end
 
 end