hyper-model 0.6.0 → 0.99.0

data/lib/reactive_record/active_record/reactive_record/column_types.rb

@@ -0,0 +1,75 @@
+module ReactiveRecord
+  # ActiveRecord column access and conversion helpers
+  class Base
+    def columns_hash
+      model.columns_hash
+    end
+
+    def self.column_type(column_hash)
+      column_hash && column_hash[:sql_type_metadata] && column_hash[:sql_type_metadata][:type]
+    end
+
+    def column_type(attr)
+      Base.column_type(columns_hash[attr])
+    end
+
+    def convert_datetime(val)
+      if val.is_a?(Numeric)
+        Time.at(val)
+      elsif val.is_a?(Time)
+        val
+      else
+        Time.parse(val)
+      end
+    end
+
+    alias convert_time convert_datetime
+    alias convert_timestamp convert_datetime
+
+    def convert_date(val)
+      if val.is_a?(Time)
+        Date.parse(val.strftime('%d/%m/%Y'))
+      elsif val.is_a?(Date)
+        val
+      else
+        Date.parse(val)
+      end
+    end
+
+    def convert_boolean(val)
+      !['false', false, nil, 0].include?(val)
+    end
+
+    def convert_integer(val)
+      Integer(`parseInt(#{val})`)
+    end
+
+    alias convert_bigint convert_integer
+
+    def convert_float(val)
+      Float(val)
+    end
+
+    alias convert_decimal convert_float
+
+    def convert_text(val)
+      val.to_s
+    end
+
+    alias convert_string convert_text
+
+    def self.serialized?
+      @serialized_attrs ||= Hash.new { |h, k| h[k] = Hash.new }
+    end
+
+    def convert(attr, val)
+      column_type = column_type(attr)
+      return val if self.class.serialized?[model][attr] ||
+                    !column_type || val.loading? ||
+                    (!val && column_type != :boolean)
+      conversion_method = "convert_#{column_type}"
+      return send(conversion_method, val) if respond_to? conversion_method
+      val
+    end
+  end
+end

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

@@ -0,0 +1,236 @@
+# add mehods to Object to determine if this is a dummy object or not
+class Object
+  def loaded?
+    !loading?
+  end
+
+  def loading?
+    false
+  end
+
+  def present?
+    !!self
+  end
+end
+
+module ReactiveRecord
+  class Base
+    # A DummyValue stands in for actual value while waiting for load from
+    # server.  when value is accessed by most methods it notifies hyper-react
+    # so when the actual value loads react will update.
+
+    # DummyValue uses the ActiveRecord type info to act like an appropriate
+    # loaded value.
+    class DummyValue < BasicObject
+      def initialize(column_hash = nil)
+        column_hash ||= {}
+        notify
+        @column_hash = column_hash
+        column_type = Base.column_type(@column_hash) || 'nil'
+        default_value_method = "build_default_value_for_#{column_type}"
+        @object = __send__ default_value_method
+      rescue ::Exception
+      end
+
+      def build_default_value_for_nil
+        @column_hash[:default] || nil
+      end
+
+      def build_default_value_for_datetime
+        if @column_hash[:default]
+          ::Time.parse(@column_hash[:default].gsub(' ','T')+'+00:00')
+        else
+          ::ReactiveRecord::Base::DummyValue.dummy_time
+        end
+      end
+
+      alias build_default_value_for_time build_default_value_for_datetime
+      alias build_default_value_for_timestamp build_default_value_for_datetime
+
+      def build_default_value_for_date
+        if @column_hash[:default]
+          ::Date.parse(@column_hash[:default])
+        else
+          ::ReactiveRecord::Base::DummyValue.dummy_date
+        end
+      end
+
+      def build_default_value_for_boolean
+        @column_hash[:default] || false
+      end
+
+      def build_default_value_for_float
+        @column_hash[:default] || 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)
+      end
+
+      alias build_default_value_for_bigint build_default_value_for_integer
+
+      def build_default_value_for_string
+        @column_hash[:default] || ''
+      end
+
+      alias build_default_value_for_text build_default_value_for_string
+
+      def notify
+        return if ::ReactiveRecord::Base.data_loading?
+        ::ReactiveRecord.loads_pending!
+        ::ReactiveRecord::WhileLoading.loading!
+      end
+
+      def loading?
+        true
+      end
+
+      def loaded?
+        false
+      end
+
+      def present?
+        false
+      end
+
+      def nil?
+        true
+      end
+
+      def !
+        true
+      end
+
+      def method_missing(method, *args, &block)
+        if method.start_with?("build_default_value_for_")
+          nil
+        elsif @object || @object.respond_to?(method)
+          notify
+          @object.send method, *args, &block
+        elsif 0.respond_to? method
+          notify
+          0.send(method, *args, &block)
+        elsif ''.respond_to? method
+          notify
+          ''.send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      def coerce(s)
+        # notify # why are we not notifying here
+        return @object.coerce(s) if @object
+        [__send__("to_#{s.class.name.downcase}"), s]
+      end
+
+      def ==(other)
+        # notify # why are we not notifying here
+        other.object_id == object_id
+      end
+
+      def object_id
+        `self.$$id`
+      end
+
+      def is_a?(klass)
+        klass == ::ReactiveRecord::Base::DummyValue
+      end
+
+      def zero?
+        return @object.zero? if @object
+        false
+      end
+
+      def to_s
+        notify
+        return @object.to_s if @object
+        ''
+      end
+
+      def tap
+        yield self
+        self
+      end
+
+      alias inspect to_s
+
+      `#{self}.$$proto.toString = Opal.Object.$$proto.toString`
+
+      def to_f
+        notify
+        return @object.to_f if @object
+        0.0
+      end
+
+      def to_i
+        notify
+        return @object.to_i if @object
+        0
+      end
+
+      def to_numeric
+        notify
+        return @object.to_numeric if @object
+        0
+      end
+
+      def to_number
+        notify
+        return @object.to_number if @object
+        0
+      end
+
+      def self.dummy_time
+        @dummy_time ||= ::Time.parse('2001-01-01T00:00:00.000-00:00')
+      end
+
+      def self.dummy_date
+        @dummy_date ||= ::Date.parse('1/1/2001')
+      end
+
+      def to_date
+        notify
+        return @object.to_date if @object
+        ::ReactiveRecord::Base::DummyValue.dummy_date
+      end
+
+      def to_time
+        notify
+        return @object.to_time if @object
+        ::ReactiveRecord::Base::DummyValue.dummy_time
+      end
+
+      def acts_as_string?
+        return true if @object.is_a? ::String
+        return @object.acts_as_string? if @object && @object.respond_to?(:acts_as_string?)
+        true
+      end
+
+      # this is a hackish way and compatible with any other rendered object
+      # to identify a DummyValue during render
+      # in ReactRenderingContext.run_child_block() and
+      # 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)
+        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
+        false
+      end
+
+      def try(*args, &b)
+        if args.empty? && block_given?
+          yield self
+        else
+          __send__(*args, &b)
+        end
+      rescue ::Exception
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+module ReactiveRecord
+  # creates getters for various method types
+  # TODO replace sync_attribute calls with direct logic
+  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)
+        sync_ignore_dummy attr, value, has_key
+      end&.cast_to_current_sti_type
+    end
+
+    def get_has_many(assoc, reload = nil)
+      getter_common(assoc.attribute, reload) do |_has_key, attr|
+        if new?
+          @attributes[attr] = Collection.new(assoc.klass, @ar_instance, assoc)
+        else
+          sync_attribute attr, Collection.new(assoc.klass, @ar_instance, assoc, *vector, attr)
+        end
+      end
+    end
+
+    def get_attr_value(attr, reload = nil)
+      non_relationship_getter_common(attr, reload) do
+        sync_attribute attr, convert(attr, model.columns_hash[attr][:default])
+      end
+    end
+
+    def get_primary_key_value
+      non_relationship_getter_common(model.primary_key, false)
+    end
+
+    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
+      end
+    end
+
+    def get_ar_aggregate(aggr, reload = nil)
+      getter_common(aggr.attribute, reload) do |has_key, attr|
+        if new?
+          @attributes[attr] = aggr.klass.new.backing_record.link_aggregate(attr, self)
+        else
+          sync_ignore_dummy attr, new_from_vector(aggr.klass, self, *vector, attr), has_key
+        end
+      end
+    end
+
+    def get_non_ar_aggregate(attr, reload = nil)
+      non_relationship_getter_common(attr, reload)
+    end
+
+    private
+
+    def virtual_fetch_on_server_warning(attr)
+      log(
+        "Warning fetching virtual attributes (#{model.name}.#{attr}) during prerendering "\
+        'on a changed or new model is not implemented.',
+        :warning
+      )
+    end
+
+    def sync_ignore_dummy(attr, value, has_key)
+      # ignore the value if its a Dummy value and there is already a value present
+      # this is used to implement reloading.  During the reload while we are waiting we
+      # want the current attribute (if its present) to not change.  Once the fetch
+      # is complete the fetch process will reload the attribute
+      value = @attributes[attr] if has_key && value.is_a?(Base::DummyValue)
+      sync_attribute(attr, value)
+    end
+
+    def non_relationship_getter_common(attr, reload, &block)
+      getter_common(attr, reload) do |has_key|
+        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
+        elsif id.present?
+          sync_attribute attr, Base.fetch_from_db([@model, [:find, id], attr])
+        else
+          sync_attribute attr, Base.fetch_from_db([*vector, attr])
+        end
+      end
+    end
+
+    def getter_common(attribute, reload)
+      @virgin = false unless data_loading?
+      return if @destroyed
+      if @attributes.key? attribute
+        current_value = @attributes[attribute]
+        current_value.notify if current_value.is_a? Base::DummyValue
+        if reload
+          virtual_fetch_on_server_warning(attribute) if on_opal_server? && changed?
+          yield true, attribute
+        else
+          current_value
+        end
+      else
+        virtual_fetch_on_server_warning(attribute) if on_opal_server? && changed?
+        yield false, attribute
+      end.tap { |value| React::State.get_state(self, attribute) unless data_loading? }
+    end
+
+    def find_association(association, id)
+      inverse_of = association.inverse_of
+      instance = if id
+        find(association.klass, association.klass.primary_key => id)
+      else
+        new_from_vector(association.klass, nil, *vector, association.attribute)
+      end
+      instance_backing_record_attributes = instance.attributes
+      inverse_association = association.klass.reflect_on_association(inverse_of)
+      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)
+        else
+          Collection.new(@model, instance, inverse_association, *vector, association.attribute, inverse_of)
+        end unless instance_backing_record_attributes[inverse_of]
+        instance_backing_record_attributes[inverse_of].replace [@ar_instance]
+      else
+        instance_backing_record_attributes[inverse_of] = @ar_instance
+      end unless association.through_association? || instance_backing_record_attributes.key?(inverse_of)
+      instance
+    end
+
+    def link_aggregate(attr, parent)
+      self.aggregate_owner = parent
+      self.aggregate_attribute = attr
+      @ar_instance
+    end
+  end
+end

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

@@ -0,0 +1,576 @@
+require 'json'
+
+module ReactiveRecord
+
+  class Base
+
+    include React::IsomorphicHelpers
+
+    before_first_mount do |context|
+      if RUBY_ENGINE != 'opal'
+        @server_data_cache = ReactiveRecord::ServerDataCache.new(context.controller.acting_user, {})
+      else
+        @public_columns_hash = get_public_columns_hash
+        define_attribute_methods
+        @outer_scopes = Set.new
+        @fetch_scheduled = nil
+        initialize_lookup_tables
+        if on_opal_client?
+          @pending_fetches = []
+          @pending_records = []
+          #@current_fetch_id = nil
+          unless `typeof window.ReactiveRecordInitialData === 'undefined'`
+            log(["Reactive record prerendered data being loaded: %o", `window.ReactiveRecordInitialData`])
+            JSON.from_object(`window.ReactiveRecordInitialData`).each do |hash|
+              load_from_json hash
+            end
+          end
+        end
+      end
+    end
+
+    def self.deprecation_warning(model, message)
+      @deprecation_messages ||= []
+      message = "Warning: Deprecated feature used in #{model}. #{message}"
+      unless @deprecation_messages.include? message
+        @deprecation_messages << message
+        log message, :warning
+      end
+    end
+
+    def deprecation_warning(message)
+      self.class.deprecation_warning(model, message)
+    end
+
+    def records
+      self.class.instance_variable_get(:@records)
+    end
+
+    # Prerendering db access (returns nil if on client):
+    # at end of prerendering dumps all accessed records in the footer
+
+    isomorphic_method(:fetch_from_db) do |f, vector|
+      # vector must end with either "*all", or be a simple attribute
+      f.send_to_server [vector.shift.name, *vector] if RUBY_ENGINE == 'opal'
+      f.when_on_server { @server_data_cache[*vector] }
+    end
+
+    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'] }
+    end
+
+    class << self
+      attr_reader :public_columns_hash
+    end
+
+    def self.define_attribute_methods
+      public_columns_hash.keys.each do |model|
+        Object.const_get(model).define_attribute_methods rescue nil
+      end
+    end
+
+    isomorphic_method(:get_public_columns_hash) do |f|
+      f.when_on_client { JSON.parse(`JSON.stringify(window.ReactiveRecordPublicColumnsHash)`) }
+      f.send_to_server
+      f.when_on_server { ActiveRecord::Base.public_columns_hash }
+    end
+
+    prerender_footer do
+      if @server_data_cache
+        json = @server_data_cache.as_json.to_json  # can this just be to_json?
+        @server_data_cache.clear_requests
+      else
+        json = {}.to_json
+      end
+      "<script type='text/javascript'>\n"+
+        "if (typeof window.ReactiveRecordPublicColumnsHash === 'undefined') { \n" +
+        "  window.ReactiveRecordPublicColumnsHash = #{ActiveRecord::Base.public_columns_hash_as_json}}\n" +
+        "if (typeof window.ReactiveRecordInitialData === 'undefined') { window.ReactiveRecordInitialData = [] }\n" +
+        "window.ReactiveRecordInitialData.push(#{json})\n"+
+      "</script>\n"
+    end if RUBY_ENGINE != 'opal'
+
+    # Client side db access (never called during prerendering):
+
+    # Always returns an object of class DummyValue which will act like most standard AR field types
+    # Whenever a dummy value is accessed it notify React that there are loads pending so appropriate rerenders
+    # will occur when the value is eventually loaded.
+
+    # queue up fetches, and at the end of each rendering cycle fetch the records
+    # notify that loads are pending
+
+    def self.load_from_db(record, *vector)
+      return nil unless on_opal_client? # this can happen when we are on the server and a nil value is returned for an attribute
+      # only called from the client side
+      # pushes the value of vector onto the a list of vectors that will be loaded from the server when the next
+      # rendering cycle completes.
+      # takes care of informing react that there are things to load, and schedules the loader to run
+      # Note there is no equivilent to find_in_db, because each vector implicitly does a find.
+      raise "attempt to do a find_by_id of nil.  This will return all records, and is not allowed" if vector[1] == ["find_by_id", nil]
+      vector = [record.model.model_name.to_s, ["new", record.object_id]]+vector[1..-1] if vector[0].nil?
+      unless data_loading?
+        @pending_fetches << vector
+        @pending_records << record if record
+        schedule_fetch
+      end
+      DummyValue.new(record && record.get_columns_info_for_vector(vector))
+    end
+
+    def get_columns_info_for_vector(vector)
+      method_name = vector.last
+      method_name = method_name.first if method_name.is_a? Array
+      model.columns_hash[method_name] || model.server_methods[method_name]
+    end
+
+
+    class << self
+
+      attr_reader :pending_fetches
+      attr_reader :current_fetch_id
+
+    end
+
+    def self.schedule_fetch
+      React::State.set_state(WhileLoading, :quiet, false) # moved from while loading module see loading! method
+      return if @fetch_scheduled
+      @current_fetch_id = Time.now
+      @fetch_scheduled = after(0) do
+        # Skip the fetch if there are no pending_fetches. This would never normally happen
+        # but during testing we might reset the context while there are pending fetches
+        next unless @pending_fetches.count > 0
+        saved_current_fetch_id = @current_fetch_id
+        saved_pending_fetches = @pending_fetches.uniq
+        models, associations = gather_records(@pending_records, false, nil)
+        log(["Server Fetching: %o", saved_pending_fetches.to_n])
+        start_time = `Date.now()`
+        Operations::Fetch.run(models: models, associations: associations, pending_fetches: saved_pending_fetches)
+        .then do |response|
+          begin
+            fetch_time = `Date.now()`
+            log("       Fetched in:   #{`(fetch_time - start_time)/ 1000`}s")
+            timer = after(0) do
+              log("       Processed in: #{`(Date.now() - fetch_time) / 1000`}s")
+              log(['       Returned: %o', response.to_n])
+            end
+            begin
+              ReactiveRecord::Base.load_from_json(response)
+            rescue Exception => e
+              `clearTimeout(#{timer})`
+              log("Unexpected exception raised while loading json from server: #{e}", :error)
+            end
+            ReactiveRecord.run_blocks_to_load saved_current_fetch_id
+          ensure
+            ReactiveRecord::WhileLoading.loaded_at saved_current_fetch_id
+            ReactiveRecord::WhileLoading.quiet! if @pending_fetches.empty?
+          end
+        end
+        .fail do |response|
+          log("Fetch failed", :error)
+          begin
+            ReactiveRecord.run_blocks_to_load(saved_current_fetch_id, response)
+          ensure
+            ReactiveRecord::WhileLoading.quiet! if @pending_fetches.empty?
+          end
+        end
+        @pending_fetches = []
+        @pending_records = []
+        @fetch_scheduled = nil
+      end
+    end
+
+    def self.get_type_hash(record)
+      {record.class.inheritance_column => record[record.class.inheritance_column]}
+    end
+
+    if RUBY_ENGINE == 'opal'
+
+      def self.gather_records(records_to_process, force, record_being_saved)
+        # we want to pass not just the model data to save, but also enough information so that on return from the server
+        # we can update the models on the client
+
+        # input
+        # list of records to process, will grow as we chase associations
+        # outputs
+        models = [] # the actual data to save {id: record.object_id, model: record.model.model_name.to_s, attributes: changed_attributes}
+        associations = [] # {parent_id: record.object_id, attribute: attribute, child_id: assoc_record.object_id}
+
+        # used to keep track of records that have been processed for effeciency
+        # for quick lookup of records that have been or will be processed [record.object_id] => record
+        records_to_process = records_to_process.uniq
+        backing_records = Hash[*records_to_process.collect { |record| [record.object_id, record] }.flatten(1)]
+
+        add_new_association = lambda do |record, attribute, assoc_record|
+          unless backing_records[assoc_record.object_id]
+            records_to_process << assoc_record
+            backing_records[assoc_record.object_id] = assoc_record
+          end
+          associations << {parent_id: record.object_id, attribute: attribute, child_id: assoc_record.object_id}
+        end
+
+        record_index = 0
+        while(record_index < records_to_process.count)
+          record = records_to_process[record_index]
+          if record.id.loading? and record_being_saved
+            raise "Attempt to save a model while it or an associated model is still loading: model being saved: #{record_being_saved.model}:#{record_being_saved.id}#{', associated model: '+record.model.to_s if record != record_being_saved}"
+          end
+          output_attributes = {record.model.primary_key => record.id.loading? ? nil : record.id}
+          vector = record.vector || [record.model.model_name.to_s, ["new", record.object_id]]
+          models << {id: record.object_id, model: record.model.model_name.to_s, attributes: output_attributes, vector: vector}
+          record.attributes.each do |attribute, value|
+            if association = record.model.reflect_on_association(attribute)
+              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?
+                end
+              elsif record.new? || record.changed?(attribute) || (record == record_being_saved && force)
+                if value.nil?
+                  output_attributes[attribute] = nil
+                else
+                  add_new_association.call record, attribute, value.backing_record
+                end
+              end
+            elsif aggregation = record.model.reflect_on_aggregation(attribute) and (aggregation.klass < ActiveRecord::Base)
+              add_new_association.call record, attribute, value.backing_record unless value.nil?
+            elsif aggregation
+              new_value = aggregation.serialize(value)
+              output_attributes[attribute] = new_value if record.changed?(attribute) or new_value != aggregation.serialize(record.synced_attributes[attribute])
+            elsif record.new? or record.changed?(attribute)
+              output_attributes[attribute] = value
+            end
+          end if record.new? || record.changed? || (record == record_being_saved && force)
+          record_index += 1
+        end
+        [models, associations, backing_records]
+      end
+
+      def save_or_validate(save, validate, force, &block)
+        if data_loading?
+          sync!
+        elsif force || changed? || (validate && new?)
+          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
+          promise = Promise.new
+          yield true, nil, [] if block
+          promise.resolve({success: true})
+          promise
+        end
+      end
+
+      def send_save_to_server(save, validate, force, &block)
+        models, associations, backing_records = self.class.gather_records([self], force, self)
+
+        begin
+          backing_records.each { |id, record| record.saving! } if save
+
+          promise = Promise.new
+          Operations::Save.run(models: models, associations: associations, save: save, validate: validate)
+          .then do |response|
+            begin
+              response[:models] = response[:saved_models].collect do |item|
+                backing_records[item[0]].ar_instance
+              end
+
+              if save
+                if response[:success]
+                  response[:saved_models].each do |item|
+                    Broadcast.to_self backing_records[item[0]].ar_instance, item[2]
+                  end
+                else
+                  log(response[:message], :error)
+                  response[:saved_models].each do |item|
+                    log("  Model: #{item[1]}[#{item[0]}]  Attributes: #{item[2]}  Errors: #{item[3]}", :error) if item[3]
+                  end
+                end
+              end
+
+              response[:saved_models].each do | item |
+                backing_records[item[0]].sync_unscoped_collection! if save
+                backing_records[item[0]].errors! item[3]
+              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
+            end
+          end
+          promise
+        rescue Exception => e
+          backing_records.each { |_id, record| record.saved!(true) rescue nil } if save
+        end
+      rescue Exception => e
+        debugger
+        log("Exception raised while saving - #{e}", :error)
+        yield false, e.message, [] if block
+        promise.resolve({success: false, message: e.message, models: []})
+        promise
+      end
+
+    else
+
+      def self.find_record(model, id, vector, save)
+        if !save
+          found = vector[1..-1].inject(vector[0]) do |object, method|
+            if object.nil? # happens if you try to do an all on empty scope followed by more scopes
+              object
+            elsif method.is_a? Array
+              if method[0] == 'new'
+                object.new
+              else
+                object.send(*method)
+              end
+            elsif method.is_a? String and method[0] == '*'
+              object[method.gsub(/^\*/,'').to_i]
+            else
+              object.send(method)
+            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}]"
+          end
+          found
+        elsif id
+          model.find(id)
+        else
+          model.new
+        end
+      end
+
+
+      def self.is_enum?(record, key)
+        record.class.respond_to?(:defined_enums) && record.class.defined_enums[key]
+      end
+
+      def self.save_records(models, associations, acting_user, validate, save)
+        reactive_records = {}
+        vectors = {}
+        new_models = []
+        saved_models = []
+        dont_save_list = []
+
+        models.each do |model_to_save|
+          attributes = model_to_save[:attributes]
+          model = Object.const_get(model_to_save[:model])
+          id = attributes.delete(model.primary_key) if model.respond_to? :primary_key # if we are saving existing model primary key value will be present
+          vector = model_to_save[:vector]
+          vector = [vector[0].constantize] + vector[1..-1].collect do |method|
+            if method.is_a?(Array) and method.first == "find_by_id"
+              ["find", method.last]
+            else
+              method
+            end
+          end
+          reactive_records[model_to_save[:id]] = vectors[vector] = record = find_record(model, id, vector, save) # ??? || validate ???
+          next unless record
+          if attributes.empty?
+            dont_save_list << record unless save
+          elsif record.respond_to?(:id) && record.id
+            # we have an already exising activerecord model
+            keys = record.attributes.keys
+            attributes.each do |key, value|
+              if is_enum?(record, key)
+                record.send("#{key}=", value)
+              elsif keys.include? key
+                record[key] = value
+              elsif value && (aggregation = record.class.reflect_on_aggregation(key.to_sym)) && !(aggregation.klass < ActiveRecord::Base)
+                aggregation.mapping.each_with_index do |pair, i|
+                  record[pair.first] = value[i]
+                end
+              elsif record.respond_to? "#{key}="
+                record.send("#{key}=", value)
+              else
+                # TODO once reading schema.rb on client is implemented throw an error here
+              end
+            end
+          else
+            # either the model is new, or its not even an active record model
+            dont_save_list << record unless save
+            keys = record.attributes.keys
+            attributes.each do |key, value|
+              if is_enum?(record, key)
+                record.send("#{key}=",value)
+              elsif keys.include? key
+                record[key] = value
+              elsif !value.nil? and aggregation = record.class.reflect_on_aggregation(key) and !(aggregation.klass < ActiveRecord::Base)
+                aggregation.mapping.each_with_index do |pair, i|
+                  record[pair.first] = value[i]
+                end
+              elsif key.to_s != "id" and record.respond_to?("#{key}=")  # server side methods can get included and we won't be able to write them...
+                # for example if you have a server side method foo, that you "get" on a new record, then later that value will get sent to the server
+                # we should track better these server side methods so this does not happen
+                record.send("#{key}=",value)
+              end
+            end
+            new_models << record
+          end
+        end
+
+        #puts "!!!!!!!!!!!!!!attributes updated"
+        ActiveRecord::Base.transaction do
+          associations.each do |association|
+            parent = reactive_records[association[:parent_id]]
+            next unless parent
+            #parent.instance_variable_set("@reactive_record_#{association[:attribute]}_changed", true) remove this????
+            if parent.class.reflect_on_aggregation(association[:attribute].to_sym)
+              #puts ">>>>>>AGGREGATE>>>> #{parent.class.name}.send('#{association[:attribute]}=', #{reactive_records[association[:child_id]]})"
+              aggregate = reactive_records[association[:child_id]]
+              dont_save_list << aggregate
+              current_attributes = parent.send(association[:attribute]).attributes
+              #puts "current parent attributes = #{current_attributes}"
+              new_attributes = aggregate.attributes
+              #puts "current child attributes = #{new_attributes}"
+              merged_attributes = current_attributes.merge(new_attributes) { |k, current_attr, new_attr| aggregate.send("#{k}_changed?") ? new_attr : current_attr}
+              #puts "merged attributes = #{merged_attributes}"
+              aggregate.assign_attributes(merged_attributes)
+              #puts "aggregate attributes after merge = #{aggregate.attributes}"
+              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?"
+            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
+            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"
+            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.)
+
+          reactive_records.keep_if do |reactive_record_id, record|
+            next false unless record # throw out items where we couldn't find a record
+            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
+            # 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
+          end
+
+          # if called from ServerDataCache then save and validate are both false, and we just return the
+          # vectors.  ServerDataCache has its own transaction which it will rollback when its done
+
+          return vectors unless save || validate
+
+          # otherwise either save or validate or both are true, so we convert the remaining react_records into
+          # arrays with the id, model name, legal attributes, and any error messages.  We also accumulate
+          # the all the error messages during a save so we can dump them to the server log.
+
+          all_messages = []
+
+          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.__hyperloop_secure_attributes(acting_user)
+            [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
+
+          # if there are error messages then we dump them to the server log, and raise an error
+          # to roll back the transaction and set success to false.
+
+          unless all_messages.empty?
+            ::Rails.logger.debug "\033[0;31;1mERROR: HyperModel saving records failed:\033[0;30;21m"
+            all_messages.each do |model, message|
+              ::Rails.logger.debug "\033[0;31;1m\t#{model}: #{message}\033[0;30;21m"
+            end
+            raise 'HyperModel saving records failed!'
+          end
+
+        end
+
+        { success: true, saved_models: saved_models }
+
+      rescue Exception => e
+        if save || validate
+          {success: false, saved_models: saved_models, message: e}
+        else
+          {}
+        end
+      end
+
+    end
+
+    # destroy records
+
+    if RUBY_ENGINE == 'opal'
+
+      def destroy(&block)
+
+        return if @destroyed
+
+        #destroy_associations
+
+        promise = Promise.new
+
+        if !data_loading? and (id or vector)
+          Operations::Destroy.run(model: ar_instance.model_name.to_s, id: id, vector: vector)
+          .then do |response|
+            Broadcast.to_self ar_instance
+            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
+          yield true, nil if block
+          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
+        # sure to find them.  We may want to change this, and provide a separate flag called not_found.  In this case you
+        # would put these lines here:
+        # @attributes = {}
+        # sync!
+        # and modify server_data_cache so that it does NOT call destroy
+
+        @destroyed = true
+
+        promise
+      end
+
+    else
+
+      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: {}}
+
+      rescue Exception => e
+        #ReactiveRecord::Pry.rescued(e)
+        {success: false, record: record, message: e}
+      end
+    end
+  end
+
+end