isomorfeus-data 2.5.5 → 22.9.0.rc1

data/lib/isomorfeus/data/generic_class_api.rb

@@ -1,127 +0,0 @@
-module Isomorfeus
-  module Data
-    module GenericClassApi
-      if RUBY_ENGINE == 'opal'
-        def destroy(key:)
-          promise_destroy(key: key)
-          true
-        end
-
-        def promise_destroy(key:)
-          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', self.name, :destroy, key: key).then do |agent|
-            agent.process do
-              Isomorfeus.store.dispatch(type: 'DATA_DESTROY', data: [self.name, key])
-              true
-            end
-          end
-        end
-
-        def load(key:)
-          instance = self.new(key: key, _loading: true)
-          promise_load(key: key, instance: instance) unless instance.loaded?
-          instance
-        end
-
-        def promise_load(key:, instance: nil)
-          instance = self.new(key: key, _loading: true) unless instance
-          if instance.loaded?
-            Promise.new.resolve(instance)
-          else
-            promise_load!(key: key, instance: instance)
-          end
-        end
-
-        def load!(key:)
-          instance = self.new(key: key, _loading: true)
-          promise_load!(key: key, instance: instance) unless instance.loaded?
-          instance
-        end
-
-        def promise_load!(key:, instance: nil)
-          instance = self.new(key: key, _loading: true) unless instance
-          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', self.name, :load, key: key).then do |agent|
-            agent.process do
-              instance._load_from_store!
-              Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.full_response[:data])
-              instance
-            end
-          end
-        end
-
-        # execute
-        def execute_create(_); end
-        def execute_destroy(_); end
-        def execute_load(_); end
-        def execute_save(_); end
-      else # RUBY_ENGINE
-        def destroy(key:)
-          !!instance_exec(key: key, &@_destroy_block)
-        end
-
-        def promise_destroy(key:)
-          Promise.new.resolve(destroy(key: key))
-        end
-
-        def load(key:, _already_loaded: {})
-          data = if @_load_block.arity == 1
-                   instance_exec(key: key, &@_load_block)
-                 else
-                   instance_exec(key: key, _already_loaded: _already_loaded, &@_load_block)
-                 end
-          return nil if data.nil?
-          return data if data.class.to_s == self.to_s
-          Isomorfeus.raise_error(message: "#{self}: execute_load must return a instance of #{self} or nil. Returned was: #{data.class}.")
-        end
-        alias load! load
-
-        def promise_load(key:)
-          instance = self.load(key: key)
-          result_promise = Promise.new
-          result_promise.resolve(instance)
-          result_promise
-        end
-        alias promise_load! promise_load
-
-        def execute_create(&block)
-          @_create_block = block
-        end
-
-        def execute_destroy(&block)
-          @_destroy_block = block
-        end
-
-        def execute_load(&block)
-          @_load_block = block
-        end
-
-        def execute_save(&block)
-          @_save_block = block
-        end
-      end  # RUBY_ENGINE
-
-      def gen_ref_s(key)
-        "---iso-object-reference---#{self.name}---#{key}---"
-      end
-
-      def gen_sid_s(key)
-        "[#{self.name}|#{key}]"
-      end
-
-      def create(key: nil, **things)
-        new(key: key, **things).create
-      end
-
-      def promise_create(key: nil, **things)
-        new(key: key, **things).promise_create
-      end
-
-      def current_user
-        Isomorfeus.current_user
-      end
-
-      def pub_sub_client
-        Isomorfeus.pub_sub_client
-      end
-    end
-  end
-end

data/lib/isomorfeus/data/generic_instance_api.rb

@@ -1,171 +0,0 @@
-module Isomorfeus
-  module Data
-    module GenericInstanceApi
-      def key
-        @key
-      end
-
-      def key=(k)
-        @key = k.to_s
-      end
-
-      def changed?
-        @_changed
-      end
-
-      def revision
-        @_revision
-      end
-
-      def sid
-        [@class_name, @key]
-      end
-
-      def sid_s
-        "[#{@class_name}|#{@key}]"
-      end
-
-      def ref_s
-        self.class.gen_ref_s(@key)
-      end
-
-      if RUBY_ENGINE == 'opal'
-        def loaded?
-          Redux.fetch_by_path(*@_store_path) ? true : false
-        end
-
-        def create
-          promise_create
-          self
-        end
-
-        def promise_create
-          data_hash = { instance: to_transport }
-          data_hash.deep_merge!(included_items: included_items_to_transport) if respond_to?(:included_items_to_transport)
-          class_name = self.class.name
-          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', class_name, :create, data_hash).then do |agent|
-            agent.process do |agnt|
-              data = agnt.full_response[:data]
-              if data.key?(class_name) && data[class_name].key?(@key) && data[class_name][@key].key?('new_key')
-                @key = data[class_name][@key]['new_key']
-                @revision = data[class_name][@key]['revision'] if data[class_name][@key].key?('revision')
-                _update_paths
-              end
-              _load_from_store!
-              Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: data)
-              self
-            end
-          end
-        end
-
-        def destroy
-          promise_destroy
-          nil
-        end
-
-        def promise_destroy
-          self.class.promise_destroy(key: @key)
-        end
-
-        def reload
-          self.class.promise_load!(key: @key, instance: self)
-          self
-        end
-
-        def promise_reload
-          self.class.promise_load!(key: @key, instance: self)
-        end
-
-        def save
-          promise_save
-          self
-        end
-
-        def promise_save
-          data_hash = { instance: to_transport }
-          data_hash.deep_merge!(included_items: included_items_to_transport) if respond_to?(:included_items_to_transport)
-          class_name = self.class.name
-          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', class_name, :save, data_hash).then do |agent|
-            agent.process do |agnt|
-              data = agnt.full_response[:data]
-              if data.key?(class_name) && data[class_name].key?(@key) && data[class_name][@key].key?('new_key')
-                @key = data[class_name][@key]['new_key']
-                @revision = data[class_name][@key]['revision'] if data[class_name][@key].key?('revision')
-                _update_paths
-              end
-              _load_from_store!
-              Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: data)
-              self
-            end
-          end
-        end
-      else # RUBY_ENGINE
-        def loaded?
-          true
-        end
-
-        def create(_already_saved: {})
-          previous_key = self.key
-          create_block = self.class.instance_variable_get(:@_create_block)
-          instance = if create_block.arity == 0
-                       instance_exec(&create_block)
-                     else
-                       instance_exec(_already_saved: _already_saved, &create_block)
-                     end
-          return nil unless instance
-          Isomorfeus.raise_error(message: "#{self.to_s}: execute_create must return self or nil. Returned was: #{instance.class}.") if instance != self
-          instance_variable_set(:@previous_key, previous_key) if key != previous_key
-          _unchange!
-          self
-        end
-
-        def promise_create
-          promise = Promise.new
-          promise.resolve(create)
-        end
-
-        def destroy
-          self.class.destroy(key: @key)
-        end
-
-        def promise_destroy
-          self.class.promise_destroy(key: @key)
-        end
-
-        # reload must be implemented by mixin
-
-        def promise_reload
-          Promise.new.resolve(reload)
-        end
-
-        def save(_already_saved: {})
-          previous_key = self.key
-          save_block = self.class.instance_variable_get(:@_save_block)
-          instance = if save_block.arity == 0
-                       instance_exec(&save_block)
-                     else
-                       instance_exec(_already_saved: _already_saved, &save_block)
-                     end
-          return nil unless instance
-          Isomorfeus.raise_error(message: "#{self.to_s}: execute_save must return self or nil. Returned was: #{instance.class}.") if instance != self
-          instance_variable_set(:@previous_key, previous_key) if key != previous_key
-          _unchange!
-          self
-        end
-
-        def promise_save
-          promise = Promise.new
-          promise.resolve(save)
-        end
-      end # RUBY_ENGINE
-
-      def current_user
-        Isomorfeus.current_user
-      end
-
-      def pub_sub_client
-        Isomorfeus.pub_sub_client
-      end
-    end
-  end
-end

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

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-module Isomorfeus
-  module Data
-    module Handler
-      class Generic < LucidHandler::Base
-        # responsible for loading:
-        # LucidObject
-        # LucidFile
-        # LucidQuery
-
-        def process_request(response_agent)
-          # promise_send_path('Isomorfeus::Data::Handler::Generic', self.to_s, action, props_hash)
-          response_agent.request.each_key do |type_class_name|
-            if Isomorfeus.valid_data_class_name?(type_class_name)
-              type_class = Isomorfeus.cached_data_class(type_class_name)
-              if type_class
-                response_agent.request[type_class_name].each_key do |action|
-                  case action
-                  when 'load' then process_load(response_agent, type_class, type_class_name)
-                  when 'execute' then process_execute(response_agent, type_class, type_class_name)
-                  when 'create' then process_create(response_agent, type_class, type_class_name)
-                  when 'save' then process_save(response_agent, type_class, type_class_name)
-                  when 'destroy' then process_destroy(response_agent, type_class, type_class_name)
-                  else response_agent.error = { error: { action => 'No such thing!' }}
-                  end
-                end
-              else response_agent.error = { error: { type_class_name => 'No such class!' }}
-              end
-            else response_agent.error = { error: { type_class_name => 'Not a valid LucidData class!' }}
-            end
-          end
-        rescue Exception => e
-          response_agent.error = { error: "Isomorfeus::Data::Handler::Generic: #{e.message}\n#{e.backtrace.join("\n")}" }
-        end
-
-        def process_create(response_agent, type_class, type_class_name)
-          # 'Isomorfeus::Data::Handler::Generic', self.name, :create, data_hash
-          data = response_agent.request[type_class_name]['create']
-          instance_data = data['instance']
-          included_items_data = data.key?('included_items') ? data['included_items'] : nil
-          if Isomorfeus.current_user.authorized?(type_class, :create, type_class.props_from_data(instance_data))
-            instance = type_class.instance_from_transport(instance_data, included_items_data)
-            created_type = instance.create
-            if created_type
-              response_agent.outer_result = {} unless response_agent.outer_result
-              response_agent.outer_result.deep_merge!(data: created_type.to_transport)
-              if created_type.respond_to?(:included_items_to_transport)
-                response_agent.outer_result.deep_merge!(data: created_type.included_items_to_transport)
-              end
-              response_agent.agent_result = { success: 'ok' }
-            else response_agent.error = { error: { type_class_name => 'Create returned nothing!' }}
-            end
-          else response_agent.error = { error: 'Access denied!' }
-          end
-        end
-
-        def process_execute(response_agent, type_class, type_class_name)
-          # 'Isomorfeus::Data::Handler::Generic', self.name, :execute, props_json
-          props = response_agent.request[type_class_name]['execute']
-          props.transform_keys!(&:to_sym)
-          if Isomorfeus.current_user.authorized?(type_class, :execute, props)
-            queried_type = type_class.execute(**props)
-            if queried_type
-              response_agent.outer_result = {} unless response_agent.outer_result
-              response_agent.outer_result.deep_merge!(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 => 'Query returned nothing!' }}
-            end
-          else response_agent.error = { error: 'Access denied!' }
-          end
-        end
-
-        def process_load(response_agent, type_class, type_class_name)
-          # 'Isomorfeus::Data::Handler::Generic', self.name, :load, key: key
-          props = response_agent.request[type_class_name]['load']
-          props.transform_keys!(&:to_sym)
-          if Isomorfeus.current_user.authorized?(type_class, :load, props)
-            loaded_type = type_class.load(**props)
-            if loaded_type
-              response_agent.outer_result = {} unless response_agent.outer_result
-              response_agent.outer_result.deep_merge!(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)
-              end
-              response_agent.agent_result = { success: 'ok' }
-            else response_agent.error = { error: { type_class_name => 'Load returned nothing!' }}
-            end
-          else response_agent.error = { error: 'Access denied!' }
-          end
-        end
-
-        def process_save(response_agent, type_class, type_class_name)
-          # 'Isomorfeus::Data::Handler::Generic', self.name, :save, data_hash
-          data = response_agent.request[type_class_name]['save']
-          instance_data = data['instance']
-          included_items_data = data.key?('included_items') ? data['included_items'] : nil
-          if Isomorfeus.current_user.authorized?(type_class, :save, type_class.props_from_data(instance_data))
-            instance = type_class.instance_from_transport(instance_data, included_items_data)
-            saved_type = instance.save
-            if saved_type
-              response_agent.outer_result = {} unless response_agent.outer_result
-              response_agent.outer_result.deep_merge!(data: saved_type.to_transport)
-              if saved_type.respond_to?(:included_items_to_transport)
-                response_agent.outer_result.deep_merge!(data: saved_type.included_items_to_transport)
-              end
-              response_agent.agent_result = { success: 'ok' }
-            else response_agent.error = { error: { type_class_name => 'Save returned nothing!' }}
-            end
-          else response_agent.error = { error: 'Access denied!' }
-          end
-        end
-
-        def process_destroy(response_agent, type_class, type_class_name)
-          props = response_agent.request[type_class_name]['destroy']
-          props.transform_keys!(&:to_sym)
-          if Isomorfeus.current_user.authorized?(type_class, :destroy, props)
-            result = type_class.destroy(**props)
-            if result
-              response_agent.agent_result = { success: 'ok' }
-            else
-              response_agent.error = { error: { type_class_name => 'Destroy failed!' }}
-            end
-          else response_agent.error = { error: 'Access denied!' }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/isomorfeus_data/lucid_file/base.rb

@@ -1,10 +0,0 @@
-module LucidFile
-  class Base
-    def self.inherited(base)
-      base.include LucidFile::Mixin
-      if RUBY_ENGINE != 'opal'
-        Isomorfeus.add_valid_data_class(base)
-      end
-    end
-  end
-end