hyper-model 1.0.alpha1.1 → 1.0.alpha1.6

data/lib/reactive_record/broadcast.rb

@@ -2,28 +2,39 @@ module ReactiveRecord
   class Broadcast
 
     def self.after_commit(operation, model)
+      # Calling public_columns_hash once insures all policies are loaded
+      # before the first broadcast.
+      @public_columns_hash ||= ActiveRecord::Base.public_columns_hash
       Hyperstack::InternalPolicy.regulate_broadcast(model) do |data|
+        puts "Broadcast aftercommit hook: #{data}" if Hyperstack::Connection.show_diagnostics
+
         if !Hyperstack.on_server? && Hyperstack::Connection.root_path
-          send_to_server(operation, data) rescue nil # server no longer running so ignore
+          send_to_server(operation, data, model.__synchromesh_update_time) rescue nil # fails if server no longer running so ignore
         else
-          SendPacket.run(data, operation: operation)
+          SendPacket.run(data, operation: operation, updated_at: model.__synchromesh_update_time)
         end
       end
     rescue ActiveRecord::StatementInvalid => e
       raise e unless e.message == "Could not find table 'hyperstack_connections'"
     end unless RUBY_ENGINE == 'opal'
 
-    def self.send_to_server(operation, data)
+    def self.send_to_server(operation, data, updated_at)
       salt = SecureRandom.hex
       authorization = Hyperstack.authorization(salt, data[:channel], data[:broadcast_id])
       raise 'no server running' unless Hyperstack::Connection.root_path
-      SendPacket.remote(
-        Hyperstack::Connection.root_path,
-        data,
-        operation: operation,
-        salt: salt,
-        authorization: authorization
-      ).tap { |p| raise p.error if p.rejected? }
+      Timeout::timeout(Hyperstack.send_to_server_timeout) do
+        SendPacket.remote(
+          Hyperstack::Connection.root_path,
+          data,
+          operation: operation,
+          updated_at: updated_at,
+          salt: salt,
+          authorization: authorization
+        ).tap { |p| raise p.error if p.rejected? }
+      end
+    rescue Timeout::Error
+      puts "\n********* FAILED TO RECEIVE RESPONSE FROM SERVER WITHIN #{Hyperstack.send_to_server_timeout} SECONDS. CHANGES WILL NOT BE SYNCED ************\n"
+      raise 'no server running'
     end unless RUBY_ENGINE == 'opal'
 
     class SendPacket < Hyperstack::ServerOp
@@ -37,6 +48,7 @@ module ReactiveRecord
       param :record
       param :operation
       param :previous_changes
+      param :updated_at
 
       unless RUBY_ENGINE == 'opal'
         validate do
@@ -60,11 +72,11 @@ module ReactiveRecord
           ReactiveRecord::Collection.sync_scopes broadcast.process_previous_changes
         end
       end
-    end
+    end if RUBY_ENGINE == 'opal'
 
     def self.to_self(record, data = {})
       # simulate incoming packet after a local save
-      operation = if record.new?
+      operation = if record.new_record?
                     :create
                   elsif record.destroyed?
                     :destroy
@@ -78,7 +90,7 @@ module ReactiveRecord
 
     def record_with_current_values
       ReactiveRecord::Base.load_data do
-        backing_record = @backing_record || klass.find(record[:id]).backing_record
+        backing_record = @backing_record || klass.find(record[klass.primary_key]).backing_record
         if destroyed?
           backing_record.ar_instance
         else
@@ -105,6 +117,10 @@ module ReactiveRecord
       @destroyed
     end
 
+    def local?
+      @is_local
+    end
+
     def klass
       Object.const_get(@klass)
     end
@@ -116,6 +132,7 @@ module ReactiveRecord
     # private
 
     attr_reader :record
+    attr_reader :updated_at
 
     def self.open_channels
       @open_channels ||= Set.new
@@ -125,7 +142,7 @@ module ReactiveRecord
       @in_transit ||= Hash.new { |h, k| h[k] = new(k) }
     end
 
-    def initialize(id)
+    def initialize(id = nil)
       @id = id
       @received = Set.new
       @record = {}
@@ -134,19 +151,15 @@ module ReactiveRecord
 
     def local(operation, record, data)
       @destroyed = operation == :destroy
+      @is_local = true
       @is_new = operation == :create
       @klass = record.class.name
       @record = data
       record.backing_record.destroyed = false
-      @record[:id] = record.id if record.id
+      @record[record.primary_key] = record.id if record.id
       record.backing_record.destroyed = @destroyed
       @backing_record = record.backing_record
       @previous_changes = record.changes
-      # attributes = record.attributes
-      # data.each do |k, v|
-      #   next if klass.reflect_on_association(k) || attributes[k] == v
-      #   @previous_changes[k] = [attributes[k], v]
-      # end
       self
     end
 
@@ -157,10 +170,35 @@ module ReactiveRecord
       @klass ||= params.klass
       @record.merge! params.record
       @previous_changes.merge! params.previous_changes
+      @updated_at = params.updated_at
       ReactiveRecord::Base.when_not_saving(klass) do
-        @backing_record = ReactiveRecord::Base.exists?(klass, params.record[:id])
-        @is_new = params.operation == :create && !@backing_record
-        yield complete! if @channels == @received
+        @backing_record = ReactiveRecord::Base.exists?(klass, params.record[klass.primary_key])
+
+        # first check to see if we already destroyed it and if so exit the block
+        break if @backing_record&.destroyed
+
+        # We ignore whether the record is being created or not, and just check and see if in our
+        # local copy we have ever loaded this id before.  If we have then its not new to us.
+        # BUT if we are destroying a record then it can't be treated as new regardless.
+        # This is because we might be just doing a count on a scope and so no actual records will
+        # exist.  Treating a destroyed record as "new" would cause us to first increment the
+        # scope counter and then decrement for the destroy, resulting in a nop instead of a -1 on
+        # the scope count.
+        @is_new = !@backing_record&.id_loaded? && !@destroyed
+
+        # it is possible that we are recieving data on a record for which we are also waiting
+        # on an an inital data load in which case we have not yet set the loaded id, so we
+        # set if now.
+        @backing_record&.loaded_id = params.record[klass.primary_key]
+
+        # once we have received all the data from all the channels (applies to create and update only)
+        # we yield and process the record
+
+        # pusher fake can send duplicate records which will result in a nil broadcast
+        # so we also check that before yielding
+        if @channels == @received && (broadcast = complete!)
+          yield broadcast
+        end
       end
     end
 
@@ -205,7 +243,7 @@ module ReactiveRecord
 
     def merge_current_values(br)
       current_values = Hash[*@previous_changes.collect do |attr, values|
-        value = attr == :id ? record[:id] : values.first
+        value = attr == klass.primary_key ? record[klass.primary_key] : values.first
         if br.attributes.key?(attr) &&
            br.attributes[attr] != br.convert(attr, value) &&
            br.attributes[attr] != br.convert(attr, values.last)
@@ -216,7 +254,6 @@ module ReactiveRecord
         end
         [attr, value]
       end.compact.flatten(1)]
-      # TODO: verify - it used to be current_values.merge(br.attributes)
       klass._react_param_conversion(br.attributes.merge(current_values))
     end
   end

data/lib/reactive_record/interval.rb

@@ -168,12 +168,12 @@ end
 module Kernel
   # (see Browser::Window#after)
   def after(time, &block)
-    `setTimeout(#{block.to_n}, time * 1000)`
+    $window.after(time, &block)
   end
 
   # (see Browser::Window#after!)
   def after!(time, &block)
-    `setTimeout(#{block.to_n}, time * 1000)`
+    $window.after!(time, &block)
   end
 end
 
@@ -187,4 +187,4 @@ class Proc
   def after!(time)
     $window.after!(time, &self)
   end
-end
+end

data/lib/reactive_record/permissions.rb

@@ -90,7 +90,7 @@ class ActiveRecord::Base
     def belongs_to(attr_name, *args)
       belongs_to_without_reactive_record_add_is_method(attr_name, *args).tap do
         define_method "#{attr_name}_is?".to_sym do |model|
-          self.class.reflections[attr_name].foreign_key == model.id
+          attributes[self.class.reflections[attr_name.to_s].foreign_key] == model.id
         end
       end
     end
@@ -103,7 +103,19 @@ class ActiveRecord::Base
       self.acting_user = old
       self
     else
-      Hyperstack::InternalPolicy.raise_operation_access_violation(:crud_access_violation, "for #{self} - #{permission}(#{args}) acting_user: #{user}")
+      acting_user_string =
+        if acting_user
+          id = user.respond_to?(:id) ? user.id : user
+          "not allowed for acting_user: <##{user.class} id: #{user}>"
+        else
+          "not allowed without acting_user (acting_user = nil)"
+        end
+
+      message = "CRUD access violation: <##{self.class} id: #{self.id}> - #{permission}(#{args}) #{acting_user_string}"
+      if permission == :view_permitted?
+        details = Hyperstack::PolicyDiagnostics.policy_dump_for(self, user)
+      end
+      Hyperstack::InternalPolicy.raise_operation_access_violation(message, details || '')
     end
   end
 

data/lib/reactive_record/scope_description.rb

@@ -93,8 +93,9 @@ module ReactiveRecord
         vector = []
         path.split('.').inject(@model) do |model, attribute|
           association = model.reflect_on_association(attribute)
-          raise build_error(path, model, attribute) unless association
-          vector = [association.inverse_of, *vector]
+          inverse_of = association.inverse_of if association
+          raise build_error(path, model, attribute) unless inverse_of
+          vector = [inverse_of, *vector]
           @joins[association.klass] << vector
           association.klass
         end

data/lib/reactive_record/server_data_cache.rb

@@ -229,6 +229,26 @@ module ReactiveRecord
             @db_cache.add_item_to_cache self
           end
 
+          def to_s
+            acting_user_string =
+              if acting_user
+                " - with acting user: <#{acting_user.class.name} id: #{acting_user.id}>"
+              else
+                ' - with no acting user'
+              end
+            vector.collect do |e|
+              if e.is_a? String
+                e
+              elsif e.is_a? Array
+                e.length > 1 ? "#{e.first}(#{e[1..-1].join(', ')})" : e.first
+              else
+                e.name
+              end
+            end.join('.') + acting_user_string
+          rescue
+            vector.to_s + acting_user_string
+          end
+
           def start_timing(&block)
             ServerDataCache.class.start_timing(&block)
           end
@@ -240,45 +260,54 @@ module ReactiveRecord
           def apply_method_to_cache(method)
             @db_cache.cache.inject(nil) do |representative, cache_item|
               if cache_item.vector == vector
-                if method == "*"
-                  # apply_star does the security check if value is present
-                  cache_item.apply_star || representative
-                elsif method == "*all"
-                  # if we secure the collection then we assume its okay to read the ids
-                  secured_value = cache_item.value.__secure_collection_check(@acting_user)
-                  cache_item.build_new_cache_item(timing(:active_record) { secured_value.collect { |record| record.id } }, method, method)
-                elsif method == "*count"
-                  secured_value = cache_item.value.__secure_collection_check(@acting_user)
-                  cache_item.build_new_cache_item(timing(:active_record) { cache_item.value.__secure_collection_check(@acting_user).count }, method, method)
-                elsif preloaded_value = @preloaded_records[cache_item.absolute_vector + [method]]
-                  # no security check needed since we already evaluated this
-                  cache_item.build_new_cache_item(preloaded_value, method, method)
-                elsif aggregation = cache_item.aggregation?(method)
-                  # aggregations are not protected
-                  cache_item.build_new_cache_item(aggregation.mapping.collect { |attribute, accessor| cache_item.value[attribute] }, method, method)
-                else
-                  if !cache_item.value || cache_item.value.is_a?(Array)
-                    # seeing as we just returning representative, no check is needed (its already checked)
-                    representative
+                begin
+                  # error_recovery_method holds the current method that we are attempting to apply
+                  # in case we throw an exception, and need to give the developer a meaningful message.
+                  if method == "*"
+                    # apply_star does the security check if value is present
+                    cache_item.apply_star || representative
+                  elsif method == "*all"
+                    # if we secure the collection then we assume its okay to read the ids
+                    error_recovery_method = [:all]
+                    secured_value = cache_item.value.__secure_collection_check(cache_item)
+                    cache_item.build_new_cache_item(timing(:active_record) { secured_value.collect { |record| record.id } }, method, method)
+                  elsif method == "*count"
+                    error_recovery_method = [:count]
+                    secured_value = cache_item.value.__secure_collection_check(cache_item)
+                    cache_item.build_new_cache_item(timing(:active_record) { cache_item.value.__secure_collection_check(cache_item).count }, method, method)
+                  elsif preloaded_value = @preloaded_records[cache_item.absolute_vector + [method]]
+                    # no security check needed since we already evaluated this
+                    cache_item.build_new_cache_item(preloaded_value, method, method)
+                  elsif aggregation = cache_item.aggregation?(method)
+                    # aggregations are not protected
+                    error_recovery_method = [method, :mapping, :all]
+                    cache_item.build_new_cache_item(aggregation.mapping.collect { |attribute, accessor| cache_item.value[attribute] }, method, method)
                   else
-                    begin
-                      secured_method = "__secure_remote_access_to_#{[*method].first}"
-
-                      # order is important.  This check must be first since scopes can have same name as attributes!
-                      if cache_item.value.respond_to? secured_method
-                        cache_item.build_new_cache_item(timing(:active_record) { cache_item.value.send(secured_method, cache_item.value, @acting_user, *([*method][1..-1])) }, method, method)
-                      elsif (cache_item.value.class < ActiveRecord::Base) && cache_item.value.attributes.has_key?(method) # TODO: second check is not needed, its built into  check_permmissions,  check should be does class respond to check_permissions...
-                        cache_item.value.check_permission_with_acting_user(@acting_user, :view_permitted?, method)
-                        cache_item.build_new_cache_item(timing(:active_record) { cache_item.value.send(*method) }, method, method)
-                      else
-                        raise "method missing"
+                    if !cache_item.value || cache_item.value.is_a?(Array)
+                      # seeing as we just returning representative, no check is needed (its already checked)
+                      representative
+                    elsif method == 'model_name'
+                      error_recovery_method = [:model_name]
+                      cache_item.build_new_cache_item(timing(:active_record) { cache_item.value.model_name }, method, method)
+                    else
+                      begin
+                        secured_method = "__secure_remote_access_to_#{[*method].first}"
+                        error_recovery_method = [*method]
+                        # order is important.  This check must be first since scopes can have same name as attributes!
+                        if cache_item.value.respond_to? secured_method
+                          cache_item.build_new_cache_item(timing(:active_record) { cache_item.value.send(secured_method, cache_item.value, @acting_user, *([*method][1..-1])) }, method, method)
+                        elsif (cache_item.value.class < ActiveRecord::Base) && cache_item.value.attributes.has_key?(method) # TODO: second check is not needed, its built into  check_permmissions,  check should be does class respond to check_permissions...
+                          cache_item.value.check_permission_with_acting_user(@acting_user, :view_permitted?, method)
+                          cache_item.build_new_cache_item(timing(:active_record) { cache_item.value.send(*method) }, method, method)
+                        else
+                          raise "Method missing while fetching data: \`#{[*method].first}\` "\
+                          'was expected to be an attribute or a method defined using the server_method of finder_method macros.'
+                        end
                       end
-                    rescue Exception => e # this check may no longer be needed as we are quite explicit now on which methods we apply
-                      # ReactiveRecord::Pry::rescued(e)
-                      ::Rails.logger.debug "\033[0;31;1mERROR: HyperModel exception caught when applying #{method} to db object #{cache_item.value}: #{e}\033[0;30;21m"
-                      raise e, "HyperModel fetching records failed, exception caught when applying #{method} to db object #{cache_item.value}: #{e}", e.backtrace
                     end
                   end
+                rescue StandardError => e
+                  raise e.class, form_error_message(e, cache_item.vector + error_recovery_method), e.backtrace
                 end
               else
                 representative
@@ -286,6 +315,15 @@ module ReactiveRecord
             end
           end
 
+          def form_error_message(original_error, vector)
+            expression = vector.collect do |exp|
+              next exp unless exp.is_a? Array
+              next exp.first if exp.length == 1
+              "#{exp.first}(#{exp[1..-1].join(', ')})"
+            end.join('.')
+            "raised when evaluating #{expression}\n#{original_error}"
+          end
+
           def aggregation?(method)
             if method.is_a?(String) && @value.class.respond_to?(:reflect_on_aggregation)
               aggregation = @value.class.reflect_on_aggregation(method.to_sym)
@@ -296,7 +334,7 @@ module ReactiveRecord
           end
 
           def apply_star
-            if @value && @value.__secure_collection_check(@acting_user) && @value.length > 0
+            if @value && @value.__secure_collection_check(self) && @value.length > 0
               i = -1
               @value.inject(nil) do |representative, current_value|
                 i += 1
@@ -358,6 +396,8 @@ module ReactiveRecord
               if method == "*"
                 if @value.is_a? Array  # this happens when a scope is empty there is test case, but
                   @parent.as_hash({})  # does it work for all edge cases?
+                elsif (@value.class < ActiveRecord::Base) && children.is_a?(Hash)
+                  @parent.as_hash({@value.id => merge_inheritance_column(children)})
                 else
                   @parent.as_hash({@value.id => children})
                 end
@@ -411,17 +451,30 @@ keys:
     if value is a hash
 =end
 
-
       def self.load_from_json(tree, target = nil)
-
         # have to process *all before any other items
         # we leave the "*all" key in just for debugging purposes, and then skip it below
 
         if sorted_collection = tree["*all"]
-          target.replace sorted_collection.collect { |id| target.proxy_association.klass.find(id) }
+          loaded_collection = sorted_collection.collect do |id|
+            ReactiveRecord::Base.find_by_id(target.proxy_association.klass, id)
+          end
+          if loaded_collection[0] && target.scope_description&.name == '___hyperstack_internal_scoped_find_by'
+            primary_key = target.proxy_association.klass.primary_key
+            attrs = target.vector[-1][1].reject { |key, _| key == primary_key }
+            loaded_collection[0].backing_record.sync_attributes(attrs)
+          end
+          target.replace loaded_collection
+          # we need to notify any observers of the collection.  collection#replace
+          # will not notify if we are data_loading (which we are) so we will do it
+          # here.  BUT we want the notification to occur after the current event
+          # completes so we wrap it a bulk_update
+          Hyperstack::Internal::State::Mapper.bulk_update do
+            Hyperstack::Internal::State::Variable.set(target, :collection, target.collection)
+          end
         end
 
-        if id_value = tree["id"] and id_value.is_a? Array
+        if (id_value = tree[target.class.try(:primary_key)] || tree[:id]) && id_value.is_a?(Array)
           target.id = id_value.first
         end
         tree.each do |method, value|
@@ -433,17 +486,16 @@ keys:
           elsif !target
             load_from_json(value, Object.const_get(method))
           elsif method == "*count"
-            target.set_count_state(value.first)
+            target.count_state = value.first
           elsif method.is_a? Integer or method =~ /^[0-9]+$/
             new_target = target.push_and_update_belongs_to(method)
-            #target << (new_target = target.proxy_association.klass.find(method))
           elsif method.is_a? Array
             if method[0] == "new"
               new_target = ReactiveRecord::Base.lookup_by_object_id(method[1])
             elsif !(target.class < ActiveRecord::Base)
               new_target = target.send(*method)
               # value is an array if scope returns nil, so we destroy the bogus record
-              new_target.destroy and new_target = nil if value.is_a? Array
+              new_target.destroy && (new_target = nil) if value.is_a? Array
             else
               target.backing_record.update_simple_attribute([method], target.backing_record.convert(method, value.first))
             end
@@ -454,12 +506,11 @@ keys:
 
             target.send "#{method}=", value.first
           elsif value.is_a? Array
-            # we cannot use target.send "#{method}=" here because it might be a server method, which does not have a setter
-            # a better fix might be something like target._internal_attribute_hash[method] =  ...
-            target.backing_record.set_attr_value(method, value.first) unless method == :id
-          elsif value.is_a? Hash and value[:id] and value[:id].first and association = target.class.reflect_on_association(method)
+            target.send("_hyperstack_internal_setter_#{method}", value.first) unless method == target.class.primary_key
+          elsif value.is_a?(Hash) && value[:id] && value[:id].first && (association = target.class.reflect_on_association(method))
             # not sure if its necessary to check the id above... is it possible to for the method to be an association but not have an id?
-            new_target = association.klass.find(value[:id].first)
+            klass = value[:model_name] ? Object.const_get(value[:model_name].first) : association.klass
+            new_target = ReactiveRecord::Base.find_by_id(klass, value[:id].first)
             target.send "#{method}=", new_target
           elsif !(target.class < ActiveRecord::Base)
             new_target = target.send(*method)
@@ -471,7 +522,6 @@ keys:
           load_from_json(value, new_target) if new_target
         end
       rescue Exception => e
-        # debugger
         raise e
       end
     end