isomorfeus-data 2.5.4 → 22.9.0.rc1

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

data/lib/isomorfeus_data/lucid_file/mixin.rb

@@ -1,281 +0,0 @@
-module LucidFile
-  module Mixin
-    def self.included(base)
-      base.extend(Isomorfeus::Data::GenericClassApi)
-      base.include(Isomorfeus::Data::GenericInstanceApi)
-      base.include(LucidI18n::Mixin)
-
-      def changed!
-        @_changed = true
-      end
-
-      def to_transport
-        hash = {}
-        hash['revision'] = revision if revision
-        hash['data_uri'] = data_uri
-        result = { @class_name => { @key => hash }}
-        result.deep_merge!(@class_name => { @previous_key => { new_key: @key }}) if @previous_key
-        result
-      end
-
-      if RUBY_ENGINE == 'opal'
-        base.instance_exec do
-          def files_path
-          end
-
-          def files_path=(_)
-          end
-        end
-
-        def initialize(key: nil, content_type: nil, data: nil, data_uri: nil, revision: nil, _loading: false)
-          @key = key.nil? ? SecureRandom.uuid : key.to_s
-          @class_name = self.class.name
-          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
-          _update_paths
-          @_revision = revision ? revision : Redux.fetch_by_path(:data_state, :revision, @class_name, @key)
-          @_changed = false
-          @_reload = false
-          loaded = loaded?
-          @_data_uri_object = nil
-          @_data_uri_string = nil
-          if data_uri
-            self.data_uri = data_uri
-          elsif data
-            self.data = data
-            self.content_type = content_type if content_type
-          else
-            self._data('')
-            self._content_type(content_type) if content_type
-          end
-        end
-
-        def _load_from_store!
-          @_changed = false
-          @_reload = true
-        end
-
-        def _reload
-          return unless @_reload
-          @_reload = false
-          d = Redux.fetch_by_path(*@_store_path)
-          self._data_uri(d) if d
-        end
-
-        def _update_paths
-          @_store_path = [:data_state, @class_name, @key, :data_uri]
-        end
-
-        def content_type
-          _reload
-          return @_data_uri_object.content_type if @_data_uri_object
-          nil
-        end
-
-        def content_type=(c)
-          changed!
-          _content_type(c)
-        end
-
-        def _content_type(c)
-          _reload
-          @_data_uri_string = _format_data_uri(c, @_data_uri_object.data)
-          @_data_uri_object = URI::Data.new(@_data_uri_string)
-          c
-        end
-
-        def data
-          _reload
-          @_data_uri_object.data
-        end
-
-        def data=(d)
-          changed!
-          _data(d)
-        end
-
-        def _data(d)
-          _reload
-          @_data_uri_string = _format_data_uri(self.content_type, d)
-          @_data_uri_object = URI::Data.new(@_data_uri_string)
-          d
-        end
-
-        def data_uri
-          _reload
-          @_data_uri_string
-        end
-
-        def data_uri=(d)
-          changed!
-          _data_uri(d)
-        end
-
-        def _data_uri(d)
-          _reload
-          if d.class == URI::Data
-            @_data_uri_string = _format_data_uri(d.content_type, d.data)
-            @_data_uri_object = d
-          else
-            @_data_uri_string = d
-            @_data_uri_object = URI::Data.new(d)
-          end
-          @_data_uri_string
-        end
-
-        def data_uri_object
-          _reload
-          @_data_uri_object
-        end
-
-        def _format_data_uri(c, d)
-          "data:#{c};base64,#{Base64.encode64(d).chop}"
-        end
-      else # RUBY_ENGINE
-        Isomorfeus.add_valid_file_class(base) unless base == LucidFile::Base
-
-        base.instance_exec do
-          def instance_from_transport(instance_data, _included_items_data)
-            key = instance_data[self.name].keys.first
-            revision = instance_data[self.name][key].key?('revision') ? instance_data[self.name][key]['revision'] : nil
-            data_uri = instance_data[self.name][key].key?('data_uri') ? instance_data[self.name][key]['data_uri'] : nil
-            new(key: key, revision: revision, data_uri: data_uri)
-          end
-
-          def props_from_data(instance_data)
-            key = instance_data[self.name].keys.first
-            revision = instance_data[self.name][key].key?('revision') ? instance_data[self.name][key]['revision'] : nil
-            data_uri = instance_data[self.name][key].key?('data_uri') ? instance_data[self.name][key]['data_uri'] : nil
-            LucidProps.new({ key: key, revision: revision, data_uri: data_uri })
-          end
-
-          def files_path
-            @files_path ||= Isomorfeus.files_path
-          end
-
-          def files_path=(f)
-            @files_path = f
-          end
-
-          def check_and_prepare_path(key:)
-            Isomorfeus.raise_error(message: 'Invalid key (contains ".." or "\\")') if key.include?('..') || key.include?('\\')
-            elements = key.split('/')
-            Isomorfeus.raise_error(message: 'Invalid key (contains more than 2 slashes "/")') if elements.size > 3
-            file = elements.pop
-            if elements.size > 0
-              dir_path = ::File.expand_path(::File.join(files_path, *elements))
-              FileUtils.mkdir_p(dir_path) unless Dir.exist?(dir_path)
-              ::File.join(dir_path, file)
-            else
-              FileUtils.mkdir_p(files_path) unless Dir.exist?(files_path)
-              ::File.join(files_path, file)
-            end
-          end
-
-          execute_create do
-            self.save
-          end
-
-          execute_destroy do |key:|
-            file = check_and_prepare_path(key: key)
-            ::FileUtils.rm_f(file)
-            true
-          end
-
-          execute_load do |key:|
-            file = check_and_prepare_path(key: key)
-            if File.exist?(file)
-              d = ::File.binread(file)
-              instance = self.new(key: key, data: d)
-              instance
-            else
-              nil
-            end
-          end
-
-          execute_save do
-            file = self.class.check_and_prepare_path(key: self.key)
-            ::File.binwrite(file, self.data)
-            self
-          end
-        end
-
-        def initialize(key: nil, content_type: nil, data: nil, data_uri: nil, revision: nil)
-          @key = key.nil? ? SecureRandom.uuid : key.to_s
-          @class_name = self.class.name
-          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
-          @_revision = revision
-          if data_uri
-            self._data_uri(data_uri)
-          else
-            @_data = data
-            @_content_type = content_type
-          end
-          @_changed = false
-        end
-
-        def _unchange!
-          @_changed = false
-        end
-
-        def content_type
-          @_content_type = @_data_uri_object.content_type if !@_content_type && @_data_uri_object
-          @_content_type
-        end
-
-        def content_type=(c)
-          changed!
-          _content_type(c)
-        end
-
-        def _content_type(c)
-          if @_data_uri_string
-            @_data_uri_string = _format_data_uri(c, @_data_uri_object.data)
-            @_data_uri_object = URI::Data.new(@_data_uri_string)
-          end
-          @_content_type = c
-        end
-
-        def data
-          @_data = @_data_uri_object.data if !@_data && @_data_uri_object
-          @_data
-        end
-
-        def data=(d)
-          changed!
-          @_data = d
-        end
-
-        def data_uri
-          _data_uri(_format_data_uri(content_type, @_data)) if !@_data_uri_string && @_data
-          @_data_uri_string
-        end
-
-        def data_uri=(d)
-          changed!
-          _data_uri(d)
-        end
-
-        def _data_uri(d)
-          if d.class == URI::Data
-            d = '' if d.nil?
-            @_data_uri_string = _format_data_uri(d.content_type, d.data)
-            @_data_uri_object = d
-          else
-            @_data_uri_string = d
-            @_data_uri_object = URI::Data.new(d)
-          end
-          @_data_uri_string
-        end
-
-        def data_uri_object
-          _data_uri(@_data) if !@_data_uri_object && @_data
-          @_data_uri_object
-        end
-
-        def _format_data_uri(c, d)
-          "data:#{c};base64,#{Base64.encode64(d).chop}"
-        end
-      end # RUBY_ENGINE
-    end
-  end
-end

data/lib/isomorfeus_data/lucid_object/base.rb

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

data/lib/isomorfeus_data/lucid_object/mixin.rb

@@ -1,236 +0,0 @@
-module LucidObject
-  module Mixin
-    def self.included(base)
-      base.include(Isomorfeus::Data::FieldSupport)
-      base.extend(Isomorfeus::Data::GenericClassApi)
-      base.include(Isomorfeus::Data::GenericInstanceApi)
-      base.include(LucidI18n::Mixin)
-
-      base.instance_exec do
-        def escape_string(s)
-          s.gsub(/([\\\&\:\(\)\[\]\{\}\!\"\~\^\|\<\>\=\*\?\+\-\s])/, '\\\\\1')
-        end
-      end
-
-      def [](name)
-        send(name)
-      end
-
-      def []=(name, val)
-        send("#{name}=".to_sym, val)
-      end
-
-      def changed!
-        @_changed = true
-      end
-
-      def to_transport
-        hash = { 'fields' => _get_selected_fields }
-        hash['revision'] = revision if revision
-        result = { @class_name => { @key => hash }}
-        result.deep_merge!(@class_name => { @previous_key => { new_key: @key }}) if @previous_key
-        result
-      end
-
-      def included_items_to_transport
-        f = fields
-        data_hash = {}
-        self.class.field_types.each do |field, type|
-          if type == :object
-            v = f[field]
-            if v
-              data_hash.deep_merge!(v.to_transport)
-              if v.respond_to?(:included_items_to_transport)
-                data_hash.deep_merge!(v.included_items_to_transport)
-              end
-            end
-          end
-        end
-        data_hash
-      end
-
-      if RUBY_ENGINE == 'opal'
-        def initialize(key: nil, revision: nil, fields: nil, _loading: false, attributes: nil)
-          @key = key.nil? ? SecureRandom.uuid : key.to_s
-          @class_name = self.class.name
-          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
-          _update_paths
-          @_revision = revision ? revision : Redux.fetch_by_path(:data_state, :revision, @class_name, @key)
-          @_objects = {}
-          @_changed = false
-          loaded = loaded?
-          fields = attributes if attributes
-          if loaded
-            raw_fields = Redux.fetch_by_path(*@_store_path)
-            if `raw_fields === null`
-              if fields
-                _validate_fields(fields)
-                @_changed_fields = fields
-              else
-                @_changed_fields = {}
-              end
-            elsif raw_fields && fields && ::Hash.new(raw_fields) != fields
-              _validate_fields(fields)
-              @_changed_fields = fields
-            else
-              @_changed_fields = {}
-            end
-          else
-            fields = {} unless fields
-            _validate_fields(fields) unless _loading
-            @_changed_fields = fields
-          end
-        end
-
-        def _load_from_store!
-          @_changed_fields = {}
-          @_objects = {}
-          @_changed = false
-        end
-
-        def _update_paths
-          @_store_path = [:data_state, @class_name, @key, :fields]
-        end
-
-        def each(&block)
-          fields.each(&block)
-        end
-      else # RUBY_ENGINE
-        Isomorfeus.add_valid_data_class(base) unless base == LucidObject::Base
-
-        base.instance_exec do
-          def instance_from_transport(instance_data, included_items_data, _already_loaded = {})
-            key = instance_data[self.name].keys.first
-            ref_s = gen_ref_s(key)
-            return _already_loaded[ref_s] if _already_loaded.key?(ref_s)
-            revision = instance_data[self.name][key].key?('revision') ? instance_data[self.name][key]['revision'] : nil
-            data_obj = new(key: key, revision: revision)
-            _already_loaded[ref_s] = data_obj
-            fields = instance_data[self.name][key].key?('fields') ? instance_data[self.name][key]['fields'].transform_keys(&:to_sym) : nil
-            if fields
-              field_types.each do |field, type|
-                if type == :object
-                  sid = fields[field]
-                  if sid
-                    o_class_name = sid[0]
-                    raise "invalid data class #{type_class_name}" unless Isomorfeus.valid_data_class_name?(o_class_name)
-                    o_class = Isomorfeus.cached_data_class(o_class_name)
-                    o_data = { o_class_name => { sid[1] => included_items_data[o_class_name][sid[1]] }}
-                    if included_items_data && !included_items_data[self.name]&.key?(key)
-                      included_items_data.deep_merge!(instance_data)
-                    end
-                    fields[field] = o_class.instance_from_transport(o_data, included_items_data, _already_loaded)
-                  end
-                end
-              end
-            end
-            data_obj._validate_fields(fields)
-            data_obj.fields.merge!(fields)
-            data_obj
-          end
-
-          def props_from_data(instance_data)
-            key = instance_data[self.name].keys.first
-            revision = instance_data[self.name][key].key?('revision') ? instance_data[self.name][key]['revision'] : nil
-            fields = instance_data[self.name][key].key?('fields') ? instance_data[self.name][key]['fields'].transform_keys!(&:to_sym) : nil
-            LucidProps.new({ key: key, revision: revision }.merge!(fields))
-          end
-
-          def object_accelerator
-            @object_accelerator ||= Isomorfeus::Data::ObjectAccelerator.new(self)
-          end
-
-          def each(&block)
-            if block_given?
-              self.object_accelerator.each do |fields|
-                block.call self.new(key: fields.delete(:key), fields: fields)
-              end
-            else
-              Enumerator.new do |yielder|
-                self.object_accelerator.each do |fields|
-                  yielder << self.new(key: fields.delete(:key), fields: fields)
-                end
-              end
-            end
-          end
-          alias to_enum each
-
-          def search(field = nil, val = nil, options = {}, query: nil)
-            if field && !self.field_options[field]&.fetch(:index) == :yes
-              raise "Can only search indexed #{self.field_types{field}}s, but #{self.field_types{field}} :#{field} is not indexed!"
-            end
-            objs = []
-            query = query ? query : "#{field}:#{val}"
-            self.object_accelerator.search_each(query, options) do |id|
-              fields = self.object_accelerator.load_object(id: id)
-              objs << self.new(key: fields.delete(:key), fields: fields)
-            end
-            objs
-          end
-
-          execute_create do |_already_saved: {}|
-            self.key = SecureRandom.uuid unless self.key
-            unless _already_saved.key?(self.ref_s)
-              _already_saved[self.ref_s] = self
-              self.class.object_accelerator.create_object(self.key, fields, _already_saved)
-            end
-            self
-          end
-
-          execute_destroy do |key:|
-            self.object_accelerator.destroy_object(key.to_s)
-            true
-          end
-
-          execute_load do |key:, _already_loaded: {}|
-            ref_s = self.gen_ref_s(@key)
-            if _already_loaded.key?(ref_s)
-              _already_loaded[ref_s]
-            else
-              _already_loaded[ref_s] = true
-              fields = self.object_accelerator.load_object(key: key.to_s, already_loaded: _already_loaded)
-              obj = fields ? self.new(key: fields.delete(:key), fields: fields) : nil
-              _already_loaded[ref_s] = obj
-            end
-          end
-
-          execute_save do |_already_saved: {}|
-            self.key = SecureRandom.uuid unless self.key
-            unless _already_saved.key?(self.ref_s)
-              _already_saved[self.ref_s] = true
-              self.class.object_accelerator.save_object(self.key, fields, _already_saved)
-            end
-            self
-          end
-        end
-
-        def initialize(key: nil, revision: nil, fields: nil, attributes: nil)
-          @key = key.nil? ? SecureRandom.uuid : key.to_s
-          @class_name = self.class.name
-          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
-          @_revision = revision
-          @_changed = false
-          fields = attributes if attributes
-          fields = {} unless fields
-          _validate_fields(fields) if fields
-          @_raw_fields = fields
-        end
-
-        def _unchange!
-          @_changed = false
-        end
-
-        def each(&block)
-          @_raw_fields.each(&block)
-        end
-
-        def reload
-          new_instance = self.class.load(key: @key)
-          @_raw_fields = new_instance.fields
-          _unchange!
-          self
-        end
-      end # RUBY_ENGINE
-    end
-  end
-end

data/lib/isomorfeus_data/lucid_query/base.rb

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