hyper-model 1.0.alpha1.3 → 1.0.alpha1.8

data/lib/reactive_record/active_record/reactive_record/dummy_polymorph.rb

@@ -0,0 +1,22 @@
+module ReactiveRecord
+  class DummyPolymorph
+    def initialize(vector)
+      @vector = vector
+      puts "VECTOR: #{@vector.inspect}"
+      Base.load_from_db(nil, *vector, 'id')
+      Base.load_from_db(nil, *vector, 'model_name')
+    end
+
+    def nil?
+      true
+    end
+
+    def method_missing(*)
+      self
+    end
+
+    def self.reflect_on_all_associations(*)
+      []
+    end
+  end
+end

data/lib/reactive_record/active_record/reactive_record/dummy_value.rb

@@ -1,4 +1,4 @@
-# add mehods to Object to determine if this is a dummy object or not
+# add methods to Object to determine if this is a dummy object or not
 class Object
   def loaded?
     !loading?
@@ -7,10 +7,6 @@ class Object
   def loading?
     false
   end
-
-  def present?
-    !!self
-  end
 end
 
 module ReactiveRecord
@@ -36,6 +32,12 @@ module ReactiveRecord
         @column_hash[:default] || nil
       end
 
+      def build_default_value_for_json
+        ::JSON.parse(@column_hash[:default]) if @column_hash[:default]
+      end
+
+      alias build_default_value_for_jsonb build_default_value_for_json
+
       def build_default_value_for_datetime
         if @column_hash[:default]
           ::Time.parse(@column_hash[:default].gsub(' ','T')+'+00:00')
@@ -55,23 +57,26 @@ module ReactiveRecord
         end
       end
 
+      FALSY_VALUES = [false, nil, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"]
+
       def build_default_value_for_boolean
-        @column_hash[:default] || false
+        !FALSY_VALUES.include?(@column_hash[:default])
       end
 
       def build_default_value_for_float
-        @column_hash[:default] || Float(0.0)
+        @column_hash[:default]&.to_f || Float(0.0)
       end
 
       alias build_default_value_for_decimal build_default_value_for_float
 
       def build_default_value_for_integer
-        @column_hash[:default] || Integer(0)
+        @column_hash[:default]&.to_i || Integer(0)
       end
 
       alias build_default_value_for_bigint build_default_value_for_integer
 
       def build_default_value_for_string
+        return @column_hash[:default] if @column_hash[:serialized?]
         @column_hash[:default] || ''
       end
 
@@ -91,10 +96,6 @@ module ReactiveRecord
         false
       end
 
-      def present?
-        false
-      end
-
       def nil?
         true
       end
@@ -103,6 +104,11 @@ module ReactiveRecord
         true
       end
 
+      def class
+        notify
+        @object.class
+      end
+
       def method_missing(method, *args, &block)
         if method.start_with?("build_default_value_for_")
           nil
@@ -157,7 +163,13 @@ module ReactiveRecord
 
       alias inspect to_s
 
-      `#{self}.$$proto.toString = Opal.Object.$$proto.toString`
+      %x{
+        if (Opal.Object.$$proto) {
+          #{self}.$$proto.toString = Opal.Object.$$proto.toString
+        } else {
+          #{self}.$$prototype.toString = Opal.Object.$$prototype.toString
+        }
+       }
 
       def to_f
         notify
@@ -215,10 +227,10 @@ module ReactiveRecord
       # to convert it to a string, for rendering
       # advantage over a try(:method) is, that it doesnt raise und thus is faster
       # which is important during render
-      def respond_to?(method)
+      def respond_to?(method, all = false)
         return true if method == :acts_as_string?
         return true if %i[inspect to_date to_f to_i to_numeric to_number to_s to_time].include? method
-        return @object.respond_to? if @object
+        return @object.respond_to?(method, all) if @object
         false
       end
 

data/lib/reactive_record/active_record/reactive_record/getters.rb

@@ -4,9 +4,13 @@ module ReactiveRecord
   module Getters
     def get_belongs_to(assoc, reload = nil)
       getter_common(assoc.attribute, reload) do |has_key, attr|
-        return if new?
-        value = Base.fetch_from_db([@model, [:find, id], attr, @model.primary_key]) if id.present?
-        value = find_association(assoc, value)
+        next if new?
+        if id.present?
+          value = fetch_by_id(attr, @model.primary_key)
+          klass = fetch_by_id(attr, 'model_name')
+          klass &&= Object.const_get(klass)
+        end
+        value = find_association(assoc, value, klass)
         sync_ignore_dummy attr, value, has_key
       end&.cast_to_current_sti_type
     end
@@ -33,7 +37,8 @@ module ReactiveRecord
 
     def get_server_method(attr, reload = nil)
       non_relationship_getter_common(attr, reload) do |has_key|
-        sync_ignore_dummy attr, Base.load_from_db(self, *(vector ? vector : [nil]), attr), has_key
+        # SPLAT BUG: was sync_ignore_dummy attr, Base.load_from_db(self, *(vector ? vector : [nil]), attr), has_key
+        sync_ignore_dummy attr, Base.load_from_db(self, *(vector || [nil]), *attr), has_key
       end
     end
 
@@ -75,10 +80,16 @@ module ReactiveRecord
         if new?
           yield has_key if block
         elsif on_opal_client?
-          sync_ignore_dummy attr, Base.load_from_db(self, *(vector ? vector : [nil]), attr), has_key
+          # SPLAT BUG: was sync_ignore_dummy attr, Base.load_from_db(self, *(vector ? vector : [nil]), attr), has_key
+          sync_ignore_dummy attr, Base.load_from_db(self, *(vector || [nil]), *attr), has_key
         elsif id.present?
-          sync_attribute attr, Base.fetch_from_db([@model, [:find, id], attr])
+          sync_attribute attr, fetch_by_id(attr)
         else
+          # Not sure how to test this branch, it may never execute this line?
+          # If we are on opal_server then we should always be getting an id before getting here
+          # but if we do vector might not be set up properly to fetch the attribute
+          puts "*** Syncing attribute in getters.rb without an id. This may cause problems. ***"
+          puts "*** Report this to hyperstack.org if you see this message: vector =  #{[*vector, attr]}"
           sync_attribute attr, Base.fetch_from_db([*vector, attr])
         end
       end
@@ -99,18 +110,26 @@ module ReactiveRecord
       else
         virtual_fetch_on_server_warning(attribute) if on_opal_server? && changed?
         yield false, attribute
-      end.tap { |value| Hyperstack::Internal::State::Variable.get(self, attribute) unless data_loading? }
+      end.tap { Hyperstack::Internal::State::Variable.get(self, attribute) unless data_loading? }
     end
 
-    def find_association(association, id)
-      inverse_of = association.inverse_of
+    def find_association(association, id, klass)
       instance = if id
-        find(association.klass, association.klass.primary_key => id)
+        find(klass, klass.primary_key => id)
+      elsif association.polymorphic?
+        new_from_vector(nil, nil, *vector, association.attribute)
       else
         new_from_vector(association.klass, nil, *vector, association.attribute)
       end
+      return instance if instance.is_a? DummyPolymorph
+      inverse_of = association.inverse_of(instance)
       instance_backing_record_attributes = instance.attributes
       inverse_association = association.klass.reflect_on_association(inverse_of)
+      # HMT-TODO: don't we need to do something with the through association case.
+      # perhaps we never hit this point...
+      if association.through_association?
+        IsomorphicHelpers.log "*********** called #{ar_instance}.find_association(#{association.attribute}) which is has many through!!!!!!!", :error
+      end
       if inverse_association.collection?
         instance_backing_record_attributes[inverse_of] = if id and id != ""
           Collection.new(@model, instance, inverse_association, association.klass, ["find", id], inverse_of)
@@ -129,5 +148,9 @@ module ReactiveRecord
       self.aggregate_attribute = attr
       @ar_instance
     end
+
+    def fetch_by_id(*vector)
+      Base.fetch_from_db([@model, *find_by_vector(@model.primary_key => id), *vector])
+    end
   end
 end

data/lib/reactive_record/active_record/reactive_record/isomorphic_base.rb

@@ -1,5 +1,3 @@
-require 'json'
-
 module ReactiveRecord
 
   class Base
@@ -47,6 +45,15 @@ module ReactiveRecord
       self.class.instance_variable_get(:@records)
     end
 
+    # constructs vector for find_by
+    def self.find_by_vector(attrs)
+      [:all, [:___hyperstack_internal_scoped_find_by, attrs], '*0']
+    end
+
+    def find_by_vector(attrs)
+      self.class.find_by_vector(attrs)
+    end
+
     # Prerendering db access (returns nil if on client):
     # at end of prerendering dumps all accessed records in the footer
 
@@ -58,7 +65,9 @@ module ReactiveRecord
 
     isomorphic_method(:find_in_db) do |f, klass, attrs|
       f.send_to_server klass.name, attrs if RUBY_ENGINE == 'opal'
-      f.when_on_server { @server_data_cache[klass, ['find_by', attrs], 'id'] }
+      f.when_on_server do
+        @server_data_cache[klass, *find_by_vector(attrs), 'id']
+      end
     end
 
     class << self
@@ -124,7 +133,6 @@ module ReactiveRecord
       model.columns_hash[method_name] || model.server_methods[method_name]
     end
 
-
     class << self
 
       attr_reader :pending_fetches
@@ -223,7 +231,7 @@ module ReactiveRecord
               if association.collection?
                 # following line changed from .all to .collection on 10/28
                 [*value.collection, *value.unsaved_children].each do |assoc|
-                  add_new_association.call(record, attribute, assoc.backing_record) if assoc.changed?(association.inverse_of) or assoc.new?
+                  add_new_association.call(record, attribute, assoc.backing_record) if assoc.changed?(association.inverse_of(assoc)) or assoc.new_record?
                 end
               elsif record.new? || record.changed?(attribute) || (record == record_being_saved && force)
                 if value.nil?
@@ -232,7 +240,7 @@ module ReactiveRecord
                   add_new_association.call record, attribute, value.backing_record
                 end
               end
-            elsif aggregation = record.model.reflect_on_aggregation(attribute) and (aggregation.klass < ActiveRecord::Base)
+            elsif (aggregation = record.model.reflect_on_aggregation(attribute)) && (aggregation.klass < ActiveRecord::Base)
               add_new_association.call record, attribute, value.backing_record unless value.nil?
             elsif aggregation
               new_value = aggregation.serialize(value)
@@ -253,8 +261,17 @@ module ReactiveRecord
           HyperMesh.load do
             ReactiveRecord.loads_pending! unless self.class.pending_fetches.empty?
           end.then { send_save_to_server(save, validate, force, &block) }
-          #save_to_server(validate, force, &block)
         else
+          if validate
+            # Handles the case where a model is valid, then some attribute is
+            # updated, and model.validate is called updating the error data.
+            # Now lets say the attribute changes back to the last synced value.  In
+            # this case we need to revert the error records.
+            models, _, backing_records = self.class.gather_records([self], true, self)
+            models.each do |item|
+              backing_records[item[:id]].revert_errors!
+            end
+          end
           promise = Promise.new
           yield true, nil, [] if block
           promise.resolve({success: true})
@@ -291,14 +308,13 @@ module ReactiveRecord
 
               response[:saved_models].each do | item |
                 backing_records[item[0]].sync_unscoped_collection! if save
-                backing_records[item[0]].errors! item[3]
+                backing_records[item[0]].errors! item[3], save
               end
 
               yield response[:success], response[:message], response[:models]  if block
               promise.resolve response  # TODO this could be problematic... there was no .json here, so .... what's to do?
 
             rescue Exception => e
-              # debugger
               log("Exception raised while saving - #{e}", :error)
             ensure
               backing_records.each { |_id, record| record.saved! rescue nil } if save
@@ -325,8 +341,6 @@ module ReactiveRecord
             elsif method.is_a? Array #__secure_remote_access_to_
               if method[0] == 'new'
                 object.new
-              elsif method[0] == 'find_by'
-                object.send(*method)
               else
                 object.send(:"__secure_remote_access_to_#{method[0]}", object, acting_user, *method[1..-1])
               end
@@ -337,7 +351,11 @@ module ReactiveRecord
             end
           end
           if id and (found.nil? or !(found.class <= model) or (found.id and found.id.to_s != id.to_s))
-            raise "Inconsistent data sent to server - #{model.name}.find(#{id}) != [#{vector}]"
+            # TODO: the one case that this is okay is when we are doing a find(some_id) which
+            # does not exist.  So the above check needs to deal with that if possible,
+            # otherwise we can just skip this check, as it was put in sometime back for
+            # debugging purposes, and is perhaps not necessary anymore
+            #raise "Inconsistent data sent to server - #{model.name}.find(#{id}) != [#{vector}]"
           end
           found
         elsif id
@@ -437,24 +455,29 @@ module ReactiveRecord
               parent.send("#{association[:attribute]}=", aggregate)
               #puts "updated  is frozen? #{aggregate.frozen?}, parent attributes = #{parent.send(association[:attribute]).attributes}"
             elsif parent.class.reflect_on_association(association[:attribute].to_sym).nil?
-              raise "Missing association :#{association[:attribute]} for #{parent.class.name}.  Was association defined on opal side only?"
+               raise "Missing association :#{association[:attribute]} for #{parent.class.name}.  Was association defined on opal side only?"
             elsif parent.class.reflect_on_association(association[:attribute].to_sym).collection?
               #puts ">>>>>>>>>> #{parent.class.name}.send('#{association[:attribute]}') << #{reactive_records[association[:child_id]]})"
               dont_save_list.delete(parent)
-              #if false and parent.new?
-                #parent.send("#{association[:attribute]}") << reactive_records[association[:child_id]]
-                # puts "updated"
-              #else
-                #puts "skipped"
-              #end
+
+              # if reactive_records[association[:child_id]]&.new_record?
+              #   dont_save_list << reactive_records[association[:child_id]]
+              # end
+
+              if parent.new_record?
+                parent.send("#{association[:attribute]}") << reactive_records[association[:child_id]]
+              end
             else
               #puts ">>>>ASSOCIATION>>>> #{parent.class.name}.send('#{association[:attribute]}=', #{reactive_records[association[:child_id]]})"
               parent.send("#{association[:attribute]}=", reactive_records[association[:child_id]])
               dont_save_list.delete(parent)
-              #puts "updated"
+
+              # if parent.class.reflect_on_association(association[:attribute].to_sym).macro == :has_one &&
+              #    reactive_records[association[:child_id]]&.new_record?
+              #   dont_save_list << reactive_records[association[:child_id]]
+              # end
             end
           end if associations
-
           # get rid of any records that don't require further processing, as a side effect
           # we also save any records that need to be saved (these may be rolled back later.)
 
@@ -463,10 +486,13 @@ module ReactiveRecord
             next true  if record.frozen?  # skip (but process later) frozen records
             next true  if dont_save_list.include?(record) # skip if the record is on the don't save list
             next true  if record.changed.include?(record.class.primary_key)  # happens on an aggregate
-            next false if record.id && !record.changed? # throw out any existing records with no changes
+            #next true  if record.persisted? # record may be have been saved as result of has_one assignment
+            # next false if record.id && !record.changed? # throw out any existing records with no changes
+            next record.persisted? if record.id && !record.changed?
             # if we get to here save the record and return true to keep it
             op = new_models.include?(record) ? :create_permitted? : :update_permitted?
-            record.check_permission_with_acting_user(acting_user, op).save(validate: false) || true
+
+            record.check_permission_with_acting_user(acting_user, op).save(validate: validate) || true
           end
 
           # if called from ServerDataCache then save and validate are both false, and we just return the
@@ -479,14 +505,15 @@ module ReactiveRecord
           # the all the error messages during a save so we can dump them to the server log.
 
           all_messages = []
+          attributes = nil
 
           saved_models = reactive_records.collect do |reactive_record_id, model|
             messages = model.errors.messages if validate && !model.valid?
             all_messages << [model, messages] if save && messages
             attributes = model.__hyperstack_secure_attributes(acting_user)
+            attributes[model.class.primary_key] = model[model.class.primary_key]
             [reactive_record_id, model.class.name, attributes, messages]
           end
-
           # if we are not saving (i.e. just validating) then we rollback the transaction
 
           raise ActiveRecord::Rollback, 'This Rollback is intentional!' unless save
@@ -501,7 +528,6 @@ module ReactiveRecord
             end
             raise 'HyperModel saving records failed!'
           end
-
         end
 
         { success: true, saved_models: saved_models }
@@ -521,25 +547,31 @@ module ReactiveRecord
     if RUBY_ENGINE == 'opal'
 
       def destroy(&block)
+        return if @destroyed || @being_destroyed
 
-        return if @destroyed
-
-        #destroy_associations
+        # destroy_associations
 
         promise = Promise.new
-
-        if !data_loading? and (id or vector)
+        if !data_loading? && (id || vector)
           Operations::Destroy.run(model: ar_instance.model_name.to_s, id: id, vector: vector)
           .then do |response|
-            Broadcast.to_self ar_instance
+            #[reactive_record_id, model.class.name, attributes, messages] model.errors.messages
+
+            if response[:success]
+              @destroyed = true
+              Broadcast.to_self ar_instance
+            else
+              errors! response[:messages]
+            end
             yield response[:success], response[:message] if block
             promise.resolve response
           end
         else
           destroy_associations
           # sync_unscoped_collection! # ? should we do this here was NOT being done before hypermesh integration
+          @destroyed = true
           yield true, nil if block
-          promise.resolve({success: true})
+          promise.resolve(success: true)
         end
 
         # DO NOT CLEAR ATTRIBUTES.  Records that are not found, are destroyed, and if they are searched for again, we want to make
@@ -549,8 +581,6 @@ module ReactiveRecord
         # sync!
         # and modify server_data_cache so that it does NOT call destroy
 
-        @destroyed = true
-
         promise
       end
 
@@ -559,18 +589,15 @@ module ReactiveRecord
       def self.destroy_record(model, id, vector, acting_user)
         model = Object.const_get(model)
         record = if id
-          model.find(id)
-        else
-          ServerDataCache.new(acting_user, {})[*vector]
-        end
-
-
-        record.check_permission_with_acting_user(acting_user, :destroy_permitted?).destroy
-        {success: true, attributes: {}}
+                   model.find(id)
+                 else
+                   ServerDataCache.new(acting_user, {})[*vector].value
+                 end
 
+        success = record.check_permission_with_acting_user(acting_user, :destroy_permitted?).destroy
+        { success: success, attributes: {}, messages: record.errors.messages }
       rescue Exception => e
-        #ReactiveRecord::Pry.rescued(e)
-        {success: false, record: record, message: e}
+        { success: false, record: record, message: e }
       end
     end
   end