isomorfeus-data 2.5.5 → 22.9.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73175d7dc425cc54e235ee9719bacaaebe93b60753794949506cb044d05a5599
-  data.tar.gz: 1af87ebf47618289399a3cdf7539e533577f09ae0757cae9e5f7b873e3f05b59
+  metadata.gz: 87cf7029a092f0aaf3f834a6b87a2f4650883b79c4f4ee64bbf6aaff64f076c2
+  data.tar.gz: 1a1f38dfcf62726729633ed055f5dfc2026bd75498720a4cd83109bbcd67d5f2
 SHA512:
-  metadata.gz: 4fe59f656951f87f9382f4dfd2b86b00ba835644e69b729d51cc1eef6dbec9ca13a05e683d655cb085e536d1f13d0e738c42b15309e4ba681102e1d54bbca5ad
-  data.tar.gz: c2403b92cb3c88e1f38d05270afef98610694d8edd8cfca274735e4b456cfae2d2902db9512737dbd7316427dd7579d8f2275c691e64d6ac31e4c77affb725c4
+  metadata.gz: 9595255f9ed1739bcc8b67d2541d685ce1588285c4b5efc06c87ef781311c05e6b2f78f79d2fbe449bcb8e465e5209480b97fef3439c8d5162a22120020a8b90
+  data.tar.gz: 6d28028f95ee4d1f7e9f733698cd2f7e4baeab3dc4df516c30c5f9433956b496ac1f63abd7d85a1be5c939861b525be67164982a70087c3a52377811abd8cbe8

data/lib/isomorfeus/data/config.rb

@@ -1,12 +1,9 @@
 module Isomorfeus
   # available settings
-  class << self
     if RUBY_ENGINE == 'opal'
-      def instance_from_sid(sid)
-        data_class = cached_data_class(sid[0])
-        data_class.new(key: sid[1], _loading: true)
-      end
+    add_client_option(:api_files_path)
 
+    class << self
       def cached_data_classes
         @cached_data_classes ||= `{}`
       end
@@ -16,12 +13,9 @@ module Isomorfeus
         return cached_data_classes.JS[class_name] if cached_data_classes.JS[class_name]
         cached_data_classes.JS[class_name] = "::#{class_name}".constantize
       end
-    else
-      def instance_from_sid(sid)
-        data_class = cached_data_class(sid[0])
-        data_class.new(key: sid[1])
-      end
-
+    end
+  else
+    class << self
       def cached_data_classes
         @cached_data_classes ||= {}
       end
@@ -44,18 +38,6 @@ module Isomorfeus
         valid_data_classes[raw_class_name(klass)] = true
       end
 
-      def valid_file_classes
-        @valid_file_classes ||= {}
-      end
-
-      def valid_file_class_name?(class_name)
-        valid_file_classes.key?(class_name)
-      end
-
-      def add_valid_file_class(klass)
-        valid_file_classes[raw_class_name(klass)] = true
-      end
-
       attr_accessor :storage_path
       attr_accessor :files_path
 
@@ -64,10 +46,9 @@ module Isomorfeus
 
       attr_accessor :data_object_envs_path
       attr_accessor :data_object_idxs_path
+      attr_accessor :api_files_path
     end
-  end
 
-  if RUBY_ENGINE != 'opal'
     self.storage_path = File.expand_path(File.join(Isomorfeus.root, 'storage', Isomorfeus.env))
     self.files_path = File.expand_path(File.join(self.storage_path, 'files'))
 
@@ -75,4 +56,6 @@ module Isomorfeus
     self.ferret_path = File.expand_path(File.join(self.storage_path, 'ferret'))
     self.data_documents_path = File.expand_path(File.join(self.ferret_path, 'documents'))
   end
+
+  self.api_files_path = '/files/'
 end

data/lib/isomorfeus/data/enhancer.rb

@@ -0,0 +1,291 @@
+module Isomorfeus
+  module Data
+    module Enhancer
+      if RUBY_ENGINE == 'opal'
+        OBJECT_ACTION_TYPES = %w[DATA_LOAD DATA_SAVE DATA_CREATE DATA_SEARCH DATA_DESTROY]
+        OBJECT_MERGE_TYPES = %w[DATA_SAVE DATA_CREATE]
+
+        CLIENT_OBJECT_ENHANCER = proc do |action, next_enh|
+          if OBJECT_ACTION_TYPES.include?(action[:type])
+            Isomorfeus.store.promise_action(action)
+            if OBJECT_MERGE_TYPES.include?(action[:type])
+              action = { type: 'DATA_MERGE', data: { action[:class_name] => { action[:key] => { fields: action[:fields], revision: action[:revision] }}}} # optimistic
+            end
+          end
+          next_enh.call(action)
+        end
+
+        FILE_ACTION_TYPES = %w[FILE_LOAD FILE_SAVE FILE_CREATE FILE_DESTROY]
+        FILE_MERGE_TYPES = %w[FILE_SAVE FILE_CREATE]
+
+        CLIENT_FILE_ENHANCER = proc do |action, next_enh|
+          if FILE_ACTION_TYPES.include?(action[:type])
+            Isomorfeus.store.promise_action(action)
+            if FILE_MERGE_TYPES.include?(action[:type])
+              action = { type: 'DATA_MERGE', data: { action[:class_name] => { action[:key] => { data_uri: action[:data_uri], revision: action[:revision] }}}} # optimistic
+            end
+          end
+          next_enh.call(action)
+        end
+
+        def self.add_enhancer_to_store
+          ::Redux::Store.add_middleware(CLIENT_OBJECT_ENHANCER)
+          ::Redux::Store.add_middleware(CLIENT_FILE_ENHANCER)
+        end
+      else # RUBY_ENGINE
+        SERVER_OBJECT_ENHANCER = proc do |action, next_enh|
+          action_type = action[:type]
+          begin
+            if action_type == 'DATA_LOAD'
+              item_class_name = action[:class_name]
+              item_key = action[:key]
+              item_class = get_verified_class(item_class_name)
+              authorization_error!(action) unless Isomorfeus.current_user.authorized?(item_class, :load, key: item_key)
+              sid_s = SID.new(item_class_name, item_key).to_s
+              loaded_data = item_class.object_accelerator.load(sid_s: sid_s) || {}
+              revision = loaded_data.delete(:_revision)
+              item_class.field_conditions.each do |field, options|
+                loaded_data.delete(field) if options[:server_only]
+              end
+              action = { type: 'DATA_MERGE', data: { item_class_name => { item_key => { fields: loaded_data, revision: revision }}}}
+            elsif action_type == 'DATA_SAVE'
+              item_class_name = action[:class_name]
+              item_key = action[:key]
+              item_class = get_verified_class(item_class_name)
+              item_fields = action[:fields]
+              item_fields.transform_keys!(&:to_sym)
+              authorization_error!(action) unless Isomorfeus.current_user.authorized?(item_class, :save, { key: item_key, fields: item_fields })
+              sid_s = SID.new(item_class_name, item_key).to_s
+              stored_revision = item_class.object_accelerator.revision(sid_s: sid_s)
+              if stored_revision == action[:revision]
+                revision = stored_revision + 1
+                instance_uuid = action[:instance_uuid]
+                if item_class.before_save_block
+                  res = item_class.before_save_block.call(key: item_key, fields: item_fields)
+                  if res.is_a?(Hash)
+                    item_fields = res
+                    item_fields.transform_keys!(&:to_sym)
+                    convert_sids(item_class, item_fields)
+                  end
+                end
+                if item_class.object_accelerator.save(sid_s: sid_s, fields: item_fields, revision: revision)
+                  item_class.after_save_block.call(key: item_key, fields: item_fields) if item_class.after_save_block
+                else
+                  instance_uuid = nil
+                end
+              else
+                revision = 0
+                instance_uuid = nil
+              end
+              loaded_data = item_class.object_accelerator.load(sid_s: sid_s)
+              revision = loaded_data.delete(:_revision)
+              item_class.field_conditions.each do |field, options|
+                loaded_data.delete(field) if options[:server_only]
+              end
+              action = { type: 'DATA_MERGE', data: { item_class_name => { item_key => { fields: loaded_data, revision: revision, instance_uuid: instance_uuid }}}}
+            elsif action_type == 'DATA_CREATE'
+              item_class_name = action[:class_name]
+              item_key = action[:key]
+              item_class = get_verified_class(item_class_name)
+              item_fields = action[:fields]
+              item_fields.transform_keys!(&:to_sym)
+              authorization_error!(action) unless Isomorfeus.current_user.authorized?(item_class, :create, { key: item_key, fields: item_fields })
+              sid_s = SID.new(item_class_name, item_key).to_s
+              stored_revision = item_class.object_accelerator.revision(sid_s: sid_s)
+              if stored_revision.nil?
+                revision = 1
+                instance_uuid = action[:instance_uuid]
+                if item_class.before_create_block
+                  res = item_class.before_create_block.call(key: item_key, fields: item_fields)
+                  if res.is_a?(Hash)
+                    item_fields = res
+                    item_fields.transform_keys!(&:to_sym)
+                    convert_sids(item_class, item_fields)
+                  end
+                end
+                if item_class.object_accelerator.create(sid_s: sid_s, fields: item_fields)
+                  item_class.after_create_block.call(key: item_key, fields: item_fields) if item_class.after_create_block
+                else
+                  stored_revision = 0
+                  instance_uuid = nil
+                end
+              else
+                revision = stored_revision
+                instance_uuid = nil
+              end
+              loaded_data = item_class.object_accelerator.load(sid_s: sid_s)
+              revision = loaded_data.delete(:_revision)
+              item_class.field_conditions.each do |field, options|
+                loaded_data.delete(field) if options[:server_only]
+              end
+              action = { type: 'DATA_MERGE', data: { item_class_name => { item_key => { fields: loaded_data, revision: revision, instance_uuid: instance_uuid }}}}
+            elsif action_type == 'DATA_SEARCH'
+              item_class_name = action[:class_name]
+              item_class = get_verified_class(item_class_name)
+              query = action[:query].to_sym
+              params = action[:params]
+              raise "Invalid params #{params}!" unless params.nil? || params.is_a?(Hash)
+              authorization_error!(action) unless Isomorfeus.current_user.authorized?(item_class, :search, { query: query, params: params })
+              result = []
+              query_string = item_class.queries.dig(query, :query_string)
+              raise "Invalid query '#{query}'!" unless query_string
+              options = item_class.queries[query][:options] || {}
+              oa = item_class.object_accelerator
+              full_query =  if params.is_a?(Hash)
+                              if options[:escape_params]
+                                escaped_params = params.to_h do |k,v|
+                                  [k, oa.escape(v)]
+                                end
+                                query_string % escaped_params
+                              else
+                                query_string % params
+                              end
+                            else
+                              query_string
+                            end
+              oa.search_each(full_query, options) do |id|
+                sid_s = oa.load_sid_s(id: id)
+                result << sid_s if sid_s
+              end
+              action = { type: 'DATA_MERGE', data: { queries: { item_class_name => { query => { Oj.dump(params, mode: :strict) => result }}}}}
+            elsif action_type == 'DATA_DESTROY'
+              item_class_name = action[:class_name]
+              item_key = action[:key]
+              item_class = get_verified_class(item_class_name)
+              authorization_error!(action) unless Isomorfeus.current_user.authorized?(item_class, :destroy, key: item_key)
+              item_class.before_destroy_block.call(key: item_key) if item_class.before_destroy_block
+              item_class.object_accelerator.destroy(sid_s: SID.new(item_class_name, item_key).to_s)
+              item_class.after_destroy_block.call(key: item_key) if item_class.after_destroy_block
+              action = { type: 'DATA_SET', class_name: item_class_name, key: item_key, data: { revision: -1 }}
+            end
+          rescue => e
+            STDERR.puts "#{e.message}\n#{e.backtrace&.join("\n")}"
+            # do nothing
+          end
+          next_enh.call(action)
+        end
+
+        SERVER_FILE_ENHANCER = proc do |action, next_enh|
+          action_type = action[:type]
+          begin
+            if action_type == 'FILE_LOAD'
+              item_class_name = action[:class_name]
+              item_key = action[:key]
+              item_class = get_verified_class(item_class_name)
+              authorization_error!(action) unless Isomorfeus.current_user.authorized?(item_class, :load, key: item_key)
+              sid = SID.new(item_class_name, item_key)
+              data, meta = item_class.file_accelerator.load(sid: sid)
+              item_hash = {}
+              if data
+                content_type = Marcel::MimeType.for(data)
+                data_uri = item_class.format_data_uri(content_type, data)
+                revision = meta[:revision]
+                item_hash = { data_uri: data_uri, revision: revision }
+              end
+              action = { type: 'DATA_MERGE', data: { item_class_name => { item_key => item_hash }}}
+            elsif action_type == 'FILE_SAVE'
+              item_class_name = action[:class_name]
+              item_key = action[:key]
+              item_class = get_verified_class(item_class_name)
+              data_uri = action[:data_uri]
+              authorization_error!(action) unless Isomorfeus.current_user.authorized?(item_class, :save, { key: item_key, data_uri: data_uri })
+              revision = action[:revision]
+              sid = SID.new(item_class_name, item_key)
+              meta = item_class.file_accelerator.meta(sid: sid)
+              stored_revision = meta[:revision]
+              if stored_revision == action[:revision]
+                revision = stored_revision + 1
+                instance_uuid = action[:instance_uuid]
+                if item_class.before_save_block
+                  res = item_class.before_save_block.call(key: item_key, data_uri: data_uri)
+                  data_uri = res[:data_uri] if res.is_a?(Hash) && res.key?(:data_uri)
+                end
+                if item_class.file_accelerator.save(sid: sid, data: URI::Data.new(data_uri).data, meta: { revision: revision })
+                  item_class.after_save_block.call(key: item_key, data_uri: data_uri) if item_class.after_save_block
+                else
+                  instance_uuid = nil
+                end
+              else
+                revision = 0
+                instance_uuid = nil
+              end
+              action = { type: 'DATA_MERGE', data: { item_class_name => { item_key => { data_uri: data_uri, revision: revision, instance_uuid: instance_uuid }}}}
+            elsif action_type == 'FILE_CREATE'
+              item_class_name = action[:class_name]
+              item_key = action[:key]
+              item_class = get_verified_class(item_class_name)
+              data_uri = action[:data_uri]
+              authorization_error!(action) unless Isomorfeus.current_user.authorized?(item_class, :create, { key: item_key, data_uri: data_uri })
+              sid = SID.new(item_class_name, item_key)
+              meta = item_class.file_accelerator.meta(sid: sid)
+              stored_revision = meta ? meta[:revision] : nil
+              if stored_revision.nil?
+                revision = 1
+                instance_uuid = action[:instance_uuid]
+                if item_class.before_create_block
+                  res = item_class.before_create_block.call(key: item_key, data_uri: data_uri)
+                  data_uri = res[:data_uri] if res.is_a?(Hash) && res.key?(:data_uri)
+                end
+                if item_class.file_accelerator.create(sid: sid, data: URI::Data.new(data_uri).data, meta: { revision: revision })
+                  item_class.after_create_block.call(key: item_key, data_uri: data_uri) if item_class.after_create_block
+                else
+                  stored_revision = 0
+                  instance_uuid = nil
+                end
+              else
+                revision = stored_revision
+                instance_uuid = nil
+              end
+              action = { type: 'DATA_MERGE', data: { item_class_name => { item_key => { data_uri: data_uri, revision: revision, instance_uuid: instance_uuid }}}}
+            elsif action_type == 'FILE_DESTROY'
+              item_class_name = action[:class_name]
+              item_key = action[:key]
+              item_class = get_verified_class(item_class_name)
+              authorization_error!(action) unless Isomorfeus.current_user.authorized?(item_class, :destroy, key: item_key)
+              item_class.before_destroy_block.call(key: item_key) if item_class.before_destroy_block
+              item_class.file_accelerator.destroy(sid: SID.new(item_class_name, item_key))
+              item_class.after_destroy_block.call(key: item_key) if item_class.after_destroy_block
+              action = { type: 'DATA_SET', class_name: item_class_name, key: item_key, data: { revision: -1 }}
+            end
+          rescue => e
+            STDERR.puts "#{e.message}\n#{e.backtrace&.join("\n")}"
+            # do nothing
+          end
+          next_enh.call(action)
+        end
+
+        class << self
+          def convert_sids(item_class, item_fields)
+            item_class.field_types.each do |field, type|
+              if type == :object
+                field_s = field.to_s
+                v = item_fields[field_s]
+                if v.is_a?(SID)
+                  item_fields[field_s] = v.to_s
+                elsif v.is_a?(Array)
+                  item_fields[field_s].map! do |o|
+                    o.is_a?(SID) ? o.to_s : o
+                  end
+                end
+              end
+            end
+          end
+
+          def get_verified_class(item_class_name)
+            raise "Invalid data class!" unless Isomorfeus.valid_data_class_name?(item_class_name)
+            item_class = Isomorfeus.cached_data_class(item_class_name)
+          end
+
+          def authorization_error!(action)
+            raise "Not authorized!#{" (action: #{action})" if Isomorfeus.development?}"
+          end
+
+          def add_enhancer_to_store
+            ::Redux::Store.add_middleware(SERVER_OBJECT_ENHANCER)
+            ::Redux::Store.add_middleware(SERVER_FILE_ENHANCER)
+          end
+        end
+      end # RUBY_ENGINE
+    end
+  end
+end

data/lib/isomorfeus/data/file_accelerator.rb

@@ -0,0 +1,95 @@
+module Isomorfeus
+  module Data
+    class FileAccelerator
+      attr_reader :object_class, :object_class_name
+
+      def initialize(ruby_class)
+        @object_class = ruby_class
+        @object_class_name = ruby_class.name
+        @store_path = File.expand_path(File.join(Isomorfeus.files_path, "#{@object_class_name.underscore}"))
+        FileUtils.mkdir_p(@store_path) unless Dir.exist?(@store_path)
+      end
+
+      def serialize(o)
+        Oj.dump(o, mode: :strict)
+      end
+
+      def unserialize(s)
+        Oj.load(s, mode: :strict)
+      end
+
+      def destroy_store
+        close_store
+        FileUtils.rm_rf(@store_path)
+      end
+
+      def meta(sid:)
+        _path, meta_path = check_and_prepare_paths(key: sid.key)
+        if File.exist?(meta_path)
+          meta = unserialize(File.binread(meta_path))
+          meta.transform_keys!(&:to_sym)
+        end
+      end
+
+      def exist?(sid:)
+        path, meta_path = check_and_prepare_paths(key: sid.key)
+        File.exist?(path)
+      end
+
+      def create(sid:, data:, meta:)
+        path, meta_path = check_and_prepare_paths(key: sid.key)
+        File.binwrite(path, data)
+        File.binwrite(meta_path, serialize(meta))
+        true
+      end
+      alias save create
+
+      def destroy(sid:)
+        path, meta_path = check_and_prepare_paths(key: sid.key)
+        FileUtils.rm_f([path, meta_path])
+        true
+      end
+
+      def load(sid:)
+        path, meta_path = check_and_prepare_paths(key: sid.key)
+        begin
+          if File.exist?(meta_path)
+            meta = unserialize(File.binread(meta_path))
+            meta.transform_keys!(&:to_sym)
+          else
+            meta = {}
+          end
+          [File.binread(path), meta]
+        rescue Errno::ENOENT
+          [nil, nil]
+        end
+      end
+
+      def load_data(sid:)
+        path, _meta_path = check_and_prepare_paths(key: sid.key)
+        begin
+          File.binread(path)
+        rescue Errno::ENOENT
+          nil
+        end
+      end
+
+      private
+
+      def check_and_prepare_paths(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
+        path = if elements.size > 0
+                 dir_path = ::File.expand_path(::File.join(@store_path, *elements))
+                 FileUtils.mkdir_p(dir_path) unless Dir.exist?(dir_path)
+                 File.join(dir_path, file)
+               else
+                 File.join(@store_path, file)
+               end
+        [path, "#{path}__meta__"]
+      end
+    end
+  end
+end