isomorfeus-data 1.0.0.zeta10 → 1.0.0.zeta11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f806c11706bdf321a3522be0c3fbf727695d65b6c8b8f8897158c4d136e593b2
-  data.tar.gz: 462e6635a0c19080fba47e06bd076b15955e109c11b090175197e227e7c2d2db
+  metadata.gz: dd049fd338445d10e197978101c5a05f02a30640666e4096bebbe75fc18d28df
+  data.tar.gz: d34b607a5f86824905a11b9283102db0698091eb8ecf028e57d9e0fcee78dac0
 SHA512:
-  metadata.gz: 10645fb7608b96f4f2b2e6a5a3d8f89de7d28ef1aef47920a4566b486a73ee4992a09c61b1290008d60b4129e0fa8d9b2acd7447bec4e4d0daba54d95da92686
-  data.tar.gz: 55e236b32fb9c8b1432ae7c18f5e16b1f50432e70d7e5691f8367ad1578aa8af84f570562d8484e7fb8a6b1e1c17ce4a9e93bbe0e8adee607e9ed30dbc8f00cb
+  metadata.gz: 45ca03236e53607fb90bc7ddef14f614a01db6bc43afae81a25da3f5283cdbfa182d7400608ca7a80267cb648ec461776a2104b882af86b8c14a21f77711bcd5
+  data.tar.gz: 9120881d8116d9ded40da8228fd3da9d8f28c552282f509ef9a8fd934ea9c6cf3addb4acffc046823f323e7cb8a071be14d045fbf5a27ccd8f3d97821d851075

data/lib/isomorfeus-data.rb

@@ -1,25 +1,9 @@
 require 'isomorfeus-transport'
 require 'isomorfeus/data/config'
-require 'isomorfeus/data/props'
 require 'isomorfeus/data/attribute_support'
 require 'isomorfeus/data/generic_class_api'
 require 'isomorfeus/data/generic_instance_api'
 require 'isomorfeus/data/element_validator'
-#require 'lucid_arango/node/mixin'
-#require 'lucid_arango/node/base'
-#require 'lucid_arango/document/mixin'
-#require 'lucid_arango/document/base'
-#require 'lucid_arango/vertex/mixin'
-#require 'lucid_arango/vertex/base'
-#require 'lucid_arango/edge/mixin'
-#require 'lucid_arango/edge/base'
-#require 'lucid_arango/collection/mixin'
-#require 'lucid_arango/collection/base'
-#require 'lucid_arango/edge_collection/mixin'
-#require 'lucid_arango/edge_collection/base'
-#require 'lucid_arango/graph/mixin'
-#require 'lucid_arango/graph/base'
-
 
 if RUBY_ENGINE == 'opal'
   require 'isomorfeus/data/reducer'
@@ -31,9 +15,8 @@ else
   require 'oj'
   require 'active_support'
   require 'active_support/core_ext/hash'
-  #require 'arango-driver'
-  #require 'isomorfeus/data/handler/arango'
 
+  require 'isomorfeus_data/lucid_data/query_result'
   require 'isomorfeus_data/lucid_data/array/mixin'
   require 'isomorfeus_data/lucid_data/array/base'
   require 'isomorfeus_data/lucid_data/hash/mixin'
@@ -59,16 +42,10 @@ else
   require 'isomorfeus_data/lucid_data/graph/finders'
   require 'isomorfeus_data/lucid_data/graph/mixin'
   require 'isomorfeus_data/lucid_data/graph/base'
-  require 'isomorfeus_data/lucid_data/object/mixin'
-  require 'isomorfeus_data/lucid_data/object/base'
-  require 'isomorfeus_data/lucid_data/remote_object/mixin'
-  require 'isomorfeus_data/lucid_data/remote_object/base'
   require 'isomorfeus_data/lucid_data/composition/mixin'
   require 'isomorfeus_data/lucid_data/composition/base'
 
   require 'isomorfeus/data/handler/generic'
-  require 'isomorfeus/data/handler/object_call'
-  require 'isomorfeus/data/handler/object_store'
 
   Opal.append_path(__dir__.untaint) unless Opal.paths.include?(__dir__.untaint)
 

data/lib/isomorfeus/data/attribute_support.rb

@@ -16,11 +16,28 @@ module Isomorfeus
           def validate
             Isomorfeus::Props::ValidateHashProxy.new
           end
+
+          def _validate_attribute(attr_name, attr_val)
+            raise "#{self.name}: No such attribute declared: '#{attr_name}'!" unless attribute_conditions.key?(attr_name)
+            Isomorfeus::Props::Validator.new(self.name, attr_name, attr_val, attribute_conditions[attr_name]).validate!
+          end
+
+          def _validate_attributes(attrs)
+            attribute_conditions.each_key do |attr|
+              if attribute_conditions[attr].key?(:required) && attribute_conditions[attr][:required] && !attrs.key?(attr)
+                raise "Required attribute #{attr} not given!"
+              end
+            end
+            attrs.each { |attr, val| _validate_attribute(attr, val) }
+          end
+        end
+
+        def _validate_attribute(attr_name, value)
+          self.class._validate_attribute(attr_name, value)
         end
 
-        def _validate_attribute(attr_name, attr_val)
-          raise "#{@class_name} No such attribute declared: '#{attr_name}'!" unless self.class.attribute_conditions.key?(attr_name)
-          Isomorfeus::Props::Validator.new(@class_name, attr_name, attr_val, self.class.attribute_conditions[attr_name]).validate!
+        def _validate_attributes(attrs)
+          self.class._validate_attributes(attrs)
         end
 
         def exclude_attributes(*attrs)
@@ -37,12 +54,7 @@ module Isomorfeus
               attribute_conditions[name] = options
 
               define_method(name) do
-                v = _get_attribute(name)
-                %x{
-                  if (v instanceof Object && !(v instanceof Array)) {
-                    return Opal.Hash.$new(v);
-                  } else { return v; }
-                }
+                _get_attribute(name)
               end
 
               define_method("#{name}=") do |val|
@@ -57,8 +69,12 @@ module Isomorfeus
             return @_changed_attributes[name] if @_changed_attributes.key?(name)
             path = @_store_path + [name]
             result = Redux.fetch_by_path(*path)
-            return nil if `result === null`
-            result
+            %x{
+              if (result === null) { return nil; }
+              else if (result instanceof Object && !(result instanceof Array)) {
+                return Opal.Hash.$new(result);
+              } else { return result; }
+            }
           end
 
           def _get_attributes

data/lib/isomorfeus/data/generic_class_api.rb

@@ -57,20 +57,21 @@ module Isomorfeus
           end
         end
 
-        def promise_load_once(key:, instance: nil)
-          instance = self.new(key: key) unless instance
-          if instance.loaded?
-            Promise.new.resolve(instance)
-          else
-            promise_load(key: key, instance: instance)
-          end
+        def query(props:)
+          query_result_instance = LucidData::QueryResult.new
+          promise_query(props: props, query_result_instance: query_result_instance) unless query_result_instance.loaded?
+          query_result_instance
         end
 
-        def promise_query(props = {})
+        def promise_query(props:, query_result_instance: nil)
+          query_result_instance = LucidData::QueryResult.new unless query_result_instance
+          props.each_key do |prop_name|
+            raise "#{self.to_s} No such query prop declared: '#{prop_name}'!" unless declared_props.key?(prop_name)
+          end
           validate_props(props)
-          props_json = props.to_json
-          instance = self.new(key) unless instance
-          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', self.name, 'query', props_json).then do |agent|
+          data_props = { props: props, query_result_instance_key: query_result_instance.key }
+          props_json = data_props.to_json
+          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', self.name, :query, props_json).then do |agent|
             if agent.processed
               agent.result
             else
@@ -79,8 +80,9 @@ module Isomorfeus
                 `console.error(#{agent.response[:error].to_n})`
                 raise agent.response[:error]
               end
+              query_result_instance._load_from_store!
               Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.full_response[:data])
-              agent.result = instance
+              agent.result = query_result_instance
             end
           end
         end
@@ -90,12 +92,6 @@ module Isomorfeus
         def execute_load(_); end
         def execute_query(_); end
         def execute_save(_); end
-
-        # callbacks
-        def on_destroy(_); end
-        def on_load(_); end
-        def on_query(_); end
-        def on_save(_); end
       else
         def promise_create(key:, **things)
           instance = self.create(key: key, **things)
@@ -105,12 +101,16 @@ module Isomorfeus
         end
 
         def promise_destroy(key:)
-          self.destroy(key: key)
+          sid = self.destroy(key: key)
           result_promise = Promise.new
-          result_promise.resolve(true)
+          result_promise.resolve(sid)
           result_promise
         end
 
+        def destroy(key:, pub_sub_client: nil, current_user: nil)
+          instance_exec(key: key, pub_sub_client: pub_sub_client, current_user: current_user, &@_destroy_block)
+        end
+
         def promise_load(key:)
           instance = self.load(key: key)
           result_promise = Promise.new
@@ -118,13 +118,24 @@ module Isomorfeus
           result_promise
         end
 
-        def promise_query(props)
-          instance = self.query(props)
+        def promise_query(props:)
+          instance = self.query(props: props)
           result_promise = Promise.new
           result_promise.resolve(instance)
           result_promise
         end
 
+        def query(props:, query_result_instance_key: nil, pub_sub_client: nil, current_user: nil)
+          props.each_key do |prop_name|
+            raise "#{self.to_s} No such query prop declared: '#{prop_name}'!" unless declared_props.key?(prop_name)
+          end
+          validate_props(props)
+          query_result = LucidData::QueryResult.new(key: query_result_instance_key)
+          query_result.result_set = instance_exec(props: Isomorfeus::Transport::PropsProxy.new(props),
+                                                  pub_sub_client: pub_sub_client, current_user: current_user, &@_query_block)
+          query_result
+        end
+
         # execute
         def execute_destroy(&block)
           @_destroy_block = block
@@ -141,23 +152,6 @@ module Isomorfeus
         def execute_save(&block)
           @_save_block = block
         end
-
-        # callbacks
-        def on_destroy(&block)
-          @_on_destroy_block = block
-        end
-
-        def on_load(&block)
-          @_on_load_block = block
-        end
-
-        def on_query(&block)
-          @_on_query_block = block
-        end
-
-        def on_save(&block)
-          @_on_save_block = block
-        end
       end
     end
   end

data/lib/isomorfeus/data/generic_instance_api.rb

@@ -36,10 +36,6 @@ module Isomorfeus
           self
         end
 
-        def promise_load_once
-          self.class.promise_load_once(key: key, instance: self)
-        end
-        
         def promise_reload
           self.class.promise_load(@key, self)
         end
@@ -51,7 +47,11 @@ module Isomorfeus
         alias create save
 
         def promise_save
-          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', self.name, 'save', to_transport).then do |agent|
+          data_hash = to_transport
+          if self.respond_to?(:included_changed_items)
+            data_hash.deep_merge!(self.included_changed_items)
+          end
+          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', self.name, 'save', data_hash).then do |agent|
             if agent.processed
               agent.result
             else

data/lib/isomorfeus/data/handler/generic.rb

@@ -5,11 +5,14 @@ module Isomorfeus
     module Handler
       class Generic < LucidHandler::Base
         # responsible for loading:
-        # LucidArray
-        # LucidHash
+        # LucidData::Array
+        # LucidData::Hash
         # LucidData::Edge
         # LucidData::Document
         # LucidData::Collection
+        # LucidData::EdgeCollection
+        # LucidData::Graph
+        # LucidData::Composition
 
         def process_request(pub_sub_client, current_user, response_agent)
           # promise_send_path('Isomorfeus::Data::Handler::Generic', self.to_s, action, props_hash)
@@ -19,8 +22,10 @@ module Isomorfeus
               if type_class
                 response_agent.request[type_class_name].each_key do |action|
                   case action
-                  when 'load' then process_load(pub_sub_client, current_user, response_agent, type_class, type_class_name, action)
-                  when 'store' then process_store(pub_sub_client, current_user, response_agent, type_class, type_class_name, action)
+                  when 'load' then process_load(pub_sub_client, current_user, response_agent, type_class, type_class_name)
+                  when 'query' then process_query(pub_sub_client, current_user, response_agent, type_class, type_class_name)
+                  when 'save' then process_save(pub_sub_client, current_user, response_agent, type_class, type_class_name)
+                  when 'destroy' then process_destroy(pub_sub_client, current_user, response_agent, type_class, type_class_name)
                   else response_agent.error = { error: { action => 'No such thing!' }}
                   end
                 end
@@ -35,17 +40,13 @@ module Isomorfeus
                                  end
         end
 
-        def process_load(pub_sub_client, current_user, response_agent, type_class, type_class_name, action)
-          props = response_agent.request[type_class_name][action]
-          # STDERR.puts "PROPS_JSON #{props_json}"
-          # props = Oj.load(props_json, mode: :strict)
+        def process_load(pub_sub_client, current_user, response_agent, type_class, type_class_name)
+          props = response_agent.request[type_class_name]['load']
           props.transform_keys!(&:to_sym)
           props.merge!(pub_sub_client: pub_sub_client, current_user: current_user)
           if current_user.authorized?(type_class, :load, props)
             loaded_type = type_class.load(**props)
             if loaded_type
-              on_load_block = type_class.instance_variable_get(:@_on_load_block)
-              loaded_type.instance_exec(pub_sub_client, current_user, &on_load_block) if on_load_block
               response_agent.outer_result = { data: loaded_type.to_transport }
               if loaded_type.respond_to?(:included_items_to_transport)
                 response_agent.outer_result.deep_merge!(data: loaded_type.included_items_to_transport)
@@ -57,35 +58,73 @@ module Isomorfeus
           end
         end
 
-        def process_store(pub_sub_client, current_user, response_agent, type_class, type_class_name, action)
-          props_json = response_agent.request[type_class_name][action]
+        def process_query(pub_sub_client, current_user, response_agent, type_class, type_class_name)
+          props_json = response_agent.request[type_class_name]['query']
           props = Oj.load(props_json, mode: :strict)
-          props.merge!(pub_sub_client: pub_sub_client, current_user: current_user)
-          if current_user.authorized?(type_class, :store, props)
-            stored_type = type_class.new(**props).store
-            on_store_block = type_class.instance_variable_get(:@_on_store_block)
-            stored_type.instance_exec(pub_sub_client, current_user, &on_store_block) if on_store_block
-            response_agent.outer_result = { data: stored_type.to_transport }
+          props.transform_keys!(&:to_sym)
+          props[:props].transform_keys!(&:to_sym)
+          props.deep_merge!({ pub_sub_client: pub_sub_client, current_user: current_user })
+          if current_user.authorized?(type_class, :query, props[:props])
+            queried_type = type_class.query(**props)
+            if queried_type
+              response_agent.outer_result = { data: queried_type.to_transport }
+              if queried_type.respond_to?(:included_items_to_transport)
+                response_agent.outer_result.deep_merge!(data: queried_type.included_items_to_transport)
+              end
+              response_agent.agent_result = { success: 'ok' }
+            else response_agent.error = { error: { type_class_name => 'No such thing!' }}
+            end
+          else response_agent.error = { error: 'Access denied!' }
+          end
+        end
+
+        def process_save(pub_sub_client, current_user, response_agent, type_class, type_class_name)
+          data_hash_json = response_agent.request[type_class_name]['save']
+          data_hash = Oj.load(data_hash_json, mode: :strict)
+          response_agent.outer_result = {}
+          if current_user.authorized?(type_class, :save, { pub_sub_client: pub_sub_client, current_user: current_user })
+            data_hash.each_key do |data_class_name|
+              data_hash[data_class_name].each_key do |key|
+                if Isomorfeus.valid_data_class_name?(type_class_name)
+                  data_class = Isomorfeus.cached_data_class(data_class_name)
+                  if data_class
+                    item_data_hash = data_hash[data_class_name][key]
+                    item_data_hash = item_data_hash.merge({ pub_sub_client: pub_sub_client, current_user: current_user })
+                    if current_user.authorized?(data_class, :save, item_data_hash)
+                      saved_type = data_class.save(**item_data_hash)
+                      if saved_type
+                        response_agent.outer_result.deep_merge!({ data: saved_type.to_transport })
+                      end
+                    else
+                      response_agent.error = { error: 'Access denied!' }
+                      break
+                    end
+                  else
+                    response_agent.error = { error: 'Access denied!' }
+                    break
+                  end
+                end
+              end
+            end
             response_agent.agent_result = { success: 'ok' }
           else response_agent.error = { error: 'Access denied!' }
           end
         end
 
-        #def process_destroy(pub_sub_client, current_user, response_agent, type_class, type_class_name, action)
-        #  props_json = response_agent.request[type_class_name][action]
-        #  props = Oj.load(props_json, mode: :strict)
-        #  props.merge!(pub_sub_client: pub_sub_client, current_user: current_user)
-        #  if current_user.authorized?(type_class, :store, *props)
-        #    # TODO
-        #    stored_type.instance_exec do
-        #      type_class.on_store_block.call(pub_sub_client, current_user) if type_class.on_store_block
-        #    end
-        #    destroyed = type_class.destroy(**props)
-        #    response_agent.outer_result = { data: stored_type.to_transport }
-        #    response_agent.agent_result = { success: 'ok' }
-        #  else response_agent.error = { error: 'Access denied!' }
-        #  end
-        #end
+        def process_destroy(pub_sub_client, current_user, response_agent, type_class, type_class_name)
+          props_json = response_agent.request[type_class_name]['destroy']
+          props = Oj.load(props_json, mode: :strict)
+          props.merge!(pub_sub_client: pub_sub_client, current_user: current_user)
+          if current_user.authorized?(type_class, :destroy, props)
+            destroyed_type = type_class.destroy(**props)
+            if destroyed_type
+              response_agent.outer_result = { data: destroyed_type }
+              response_agent.agent_result = { success: 'ok' }
+            else response_agent.error = { error: { type_class_name => 'No such thing!' }}
+            end
+          else response_agent.error = { error: 'Access denied!' }
+          end
+        end
       end
     end
   end

data/lib/isomorfeus/data/version.rb

@@ -1,5 +1,5 @@
 module Isomorfeus
   module Data
-    VERSION = '1.0.0.zeta10'
+    VERSION = '1.0.0.zeta11'
   end
 end

data/lib/isomorfeus_data/lucid_data/array/mixin.rb

@@ -14,15 +14,23 @@ module LucidData
           alias element elements
 
           def element_conditions
-            @element_conditions
+            @element_conditions ||= {}
           end
 
           def valid_element?(element)
-            return true unless @element_conditions
-            Isomorfeus::Data::ElementValidator.new(self.name, element, @element_conditions).validate!
+            return true unless element_conditions.any?
+            _validate_element(element)
           rescue
             false
           end
+
+          def _validate_element(element)
+            Isomorfeus::Data::ElementValidator.new(self.to_s, element, element_conditions).validate!
+          end
+
+          def _validate_elements(many_els)
+            many_els.each { |e| _validate_element(e) } if element_conditions.any?
+          end
         end
 
         def composition
@@ -38,8 +46,12 @@ module LucidData
           @_changed = true
         end
 
-        def _validate_element(el)
-          Isomorfeus::Data::ElementValidator.new(@class_name, el, @_el_con).validate!
+        def _validate_element(element)
+          self.class._validate_element(element)
+        end
+
+        def _validate_elements(many_elements)
+          self.class._validate_elements(many_elements)
         end
 
         if RUBY_ENGINE == 'opal'
@@ -52,11 +64,8 @@ module LucidData
             @_changed_array = nil
             @_composition = composition
             @_changed = false
-            @_el_con = self.class.element_conditions
-            @_validate_elements = @_el_con ? true : false
-            if @_validate_elements && elements
-              elements.each { |e| _validate_element(e) }
-            end
+            @_validate_elements = self.class.element_conditions.any?
+            _validate_elements(elements)
             raw_array = Redux.fetch_by_path(*@_store_path)
             if `raw_array === null`
               @_changed_array = elements ? elements : []
@@ -343,9 +352,17 @@ module LucidData
 
           base.instance_exec do
             def load(key:, pub_sub_client: nil, current_user: nil)
-              data = instance_exec(key: key, &@_load_block)
-              revision = nil
-              revision = data.delete(:revision) if data.key?(:revision)
+              data = instance_exec(key: key, pub_sub_client: pub_sub_client, current_user: current_user, &@_load_block)
+              revision = data.delete(:revision)
+              elements = data.delete(:elements)
+              self.new(key: key, revision: revision, elements: elements)
+            end
+
+            def save(key:, revision: nil, elements: nil, pub_sub_client: nil, current_user: nil)
+              _validate_elements(elements)
+              data = instance_exec(key: key, revision: revision, elements: elements,
+                                   pub_sub_client: pub_sub_client, current_user: current_user, &@_save_block)
+              revision = data.delete(:revision)
               elements = data.delete(:elements)
               self.new(key: key, revision: revision, elements: elements)
             end
@@ -358,12 +375,9 @@ module LucidData
             @_revision = revision
             @_changed = false
             @_composition = composition
-            @_el_con = self.class.element_conditions
-            @_validate_elements = @_el_con ? true : false
             elements = [] unless elements
-            if @_validate_elements
-              elements.each { |e| _validate_element(e) }
-            end
+            @_validate_elements = self.class.element_conditions.any?
+            _validate_elements(elements)
             @_raw_array = elements
           end