isomorfeus-data 2.5.4 → 22.9.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 198fe12b353be42d725a63ccd4495052c19a20a24e1f4223c3a2d4ac9c39fe4a
-  data.tar.gz: bd01e302b472b1a1c847c5c49c5139edcb619faa48adfcdc3fd7e49996fcfaec
+  metadata.gz: 700fca91209424c5ecca86fe50ca2a5eec4edc824032dfd811bf354082b2d465
+  data.tar.gz: 3dcf6385c0894f78345aacb8872f83eeaed23409bddeaf0d3253afceabc60f23
 SHA512:
-  metadata.gz: 410185c046e6c116eeca7e87fc84813f1961e23fc822f487714ab367f7e0f4f8e2e9090206138d0a0de43813420b8c9efa351aa099c8e2582e41f4ae35aa9216
-  data.tar.gz: 7daa859033b8d5dd50d0dded8e3bcf3c2447ee825f0450358060ccee86ba32b55ea5a7cddad3e963d268db24c1545da9e7d56b1adc5e0ddca207d75c78d5ffc6
+  metadata.gz: 5811fe438c1ecd96f1f41da3352273c9d96c1b851e95e80496baacd9d9a905101b05288127aeaaf2b0fd458fdb989afa7de6dff200aa88e47c895428fd9f70a5
+  data.tar.gz: b283f5c47616218aa5c688418ff7e444e03346286a4f1968b527dd35d7de4d04bf548f17e3669f491c33f984944cb46ef19b31e259391d3e364c41f1e47d564c

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

data/lib/isomorfeus/data/object_accelerator.rb

@@ -11,7 +11,7 @@ module Isomorfeus
       def initialize(ruby_class)
         @object_class = ruby_class
         @object_class_name = ruby_class.name
-        @class_cache = Isomorfeus.production?
+        @class_cache = !Isomorfeus.development?
 
         @store_path = File.expand_path(File.join(Isomorfeus.data_documents_path, "#{@object_class_name.underscore}"))
         open_store
@@ -19,24 +19,16 @@ module Isomorfeus
         ObjectSpace.define_finalizer(self, self.class.finalize(self))
       end
 
-      def object_from_ref(ref, already_loaded)
-        _, iso, type_class_name, key = ref.split('---')
-        raise "not a valid object reference '#{ref}'" unless iso == "iso-object-reference"
-        raise "invalid data class #{type_class_name}" unless Isomorfeus.valid_data_class_name?(type_class_name)
-        type_class = Isomorfeus.cached_data_class(type_class_name)
-        type_class.load(key: key, _already_loaded: already_loaded)
+      def serialize(o)
+        Oj.dump(o, mode: :strict)
       end
 
-      def serialize(obj)
-        Oj.dump(obj, mode: :object, circular: true, class_cache: @class_cache)
-      end
-
-      def unserialize(v)
-        Oj.load(v, mode: :object, circular: true, class_cache: @class_cache)
+      def unserialize(s)
+        Oj.load(s, mode: :strict)
       end
 
       def destroy_store
-        close_store
+        close_store rescue nil
         FileUtils.rm_rf(@store_path)
       end
 
@@ -44,97 +36,113 @@ module Isomorfeus
         @store.close
       end
 
+      def exist?(sid_s:)
+        !!get_object_id(sid_s)
+      end
+
+      def exist_by_field?(field:, value:)
+        top_docs = @store.search("#{field}:\"#{serialize(value)}\"")
+        top_docs.total_hits > 0
+      end
+
       def search_each(query, options, &block)
         @store.search_each(query, options, &block)
+      rescue => e
+        return nil if e.message.include?('frt_sort.c')
+        raise e
       end
 
       def each(&block)
-        ft = @object_class.field_types
-        @store.each do |doc|
-          hash = doc.to_h do |k, v|
-            [k, unserialize_or_load(v, ft[k], {})]
-          end
-          block.call hash
-        end
+        @store.each { |doc| block.call(doc[:key]) }
       end
 
-      def create_object(key, fields, already_saved)
-        ft = @object_class.field_types
-        hash = fields.to_h do |k, v|
-          [k, serialize_or_save(v, ft[k], already_saved)]
+      def create(sid_s:, fields:, level: 10)
+        id = get_object_id(sid_s)
+        return false if id
+        data = fields.to_h do |k, v|
+          [k, serialize(v)]
         end
-        @store.add_document(hash.merge!({key: key}))
+        data[:_revision] = serialize(1)
+        data[:key] = sid_s
+        @store.add_document(data)
+        true
+      rescue => e
+        @store.flush
+        raise e if level < 1
+        create(sid_s: sid_s, fields: fields, level: level - 1)
       end
 
-      def destroy_object(key)
-        id = get_object_id(key)
+      def destroy(sid_s:)
+        id = get_object_id(sid_s)
         @store.delete(id) if id
       end
 
-      def load_object(key: nil, id: nil, already_loaded: {})
-        hash = nil
-        id = get_object_id(key) if key
-        if id
-          ft = @object_class.field_types
-          hash = @store.doc(id)&.to_h do |k, v|
-            [k, unserialize_or_load(v, ft[k], already_loaded)]
+      def load(sid_s: nil, id: nil)
+        id = get_object_id(sid_s) if sid_s
+        return nil unless id
+        data = @store.doc(id)&.to_h
+        if data
+          data.delete(:key)
+          data = data.to_h do |k, v|
+            [k, unserialize(v)]
           end
         end
-        hash
+        data
       end
 
-      def save_object(key, fields, already_saved)
-        id = get_object_id(key)
-        return create_object(key, fields, already_saved) unless id
-        ft = @object_class.field_types
-        hash = fields.to_h do |k, v|
-          [k, serialize_or_save(v, ft[k], already_saved)]
-        end
-        @store.update(id, hash.merge!({key: key}))
-        true
+      def field(sid_s:, field:)
+        id = get_object_id(sid_s) if sid_s
+        return nil unless id
+        doc = @store.doc(id)
+        v = doc[field]
+        unserialize(v) if v
       end
 
-      private
-
-      def unserialize_or_load(v, t, already_loaded)
-        return unserialize(v) if t == :attribute
-        if t == :object && v
-          return nil if v.empty?
-          return object_from_ref(v, already_loaded)
-        end
-        v
+      def load_sid_s(id:)
+        doc = @store.doc(id)
+        return doc[:key] if doc
       end
 
-      def serialize_or_save(v, t, already_saved)
-        return serialize(v) if t == :attribute
-        return create_or_save(v, already_saved) if t == :object && v
-        v
+      def revision(sid_s:)
+        id = get_object_id(sid_s)
+        doc = @store.doc(id) if id
+        return unserialize(doc[:_revision]) if doc
       end
 
-      def create_or_save(v, already_saved)
-        if get_object_id(v.key)
-          v.save(_already_saved: already_saved)
-        else
-          v.create
+      def save(sid_s:, fields:, revision:, id: nil, level: 10)
+        id = get_object_id(sid_s) unless id
+        return false unless id
+        data = fields.to_h do |k, v|
+          [k, serialize(v)]
         end
-        v.ref_s
+        data[:key] = sid_s
+        data[:_revision] = serialize(revision)
+        @store.update(id, data)
+        true
+      rescue => e
+        @store.flush
+        raise e if level < 1
+        save(sid_s: sid_s, fields: fields, revision: revision, id: id, level: level - 1)
       end
 
-      def get_object_id(key)
+      def escape(string)
         # special characters must be escaped, characters taken from the ferret query parser documentation
-        escaped_key = key.gsub(/([\\\&\:\(\)\[\]\{\}\!\"\~\^\|\<\>\=\*\?\+\-\s])/, '\\\\\1')
-        top_docs = @store.search("key:\"#{escaped_key}\"", limit: 1)
-        id = top_docs.hits[0].doc if top_docs.total_hits == 1
+        string.gsub(/([\\\&\:\(\)\[\]\{\}\!\"\~\^\|\<\>\=\*\?\+\-\s])/, '\\\\\1')
+      end
+
+      private
+
+      def get_object_id(sid_s)
+        top_docs = @store.search("key:\"#{sid_s}\"", limit: 1)
+        top_docs.hits[0].doc if top_docs.total_hits == 1
       end
 
       def open_store
         FileUtils.mkdir_p(Isomorfeus.data_documents_path) unless Dir.exist?(Isomorfeus.data_documents_path)
-        field_infos = Isomorfeus::Ferret::Index::FieldInfos.new(store: :yes, index: :yes, term_vector: :no)
+        field_infos = Isomorfeus::Ferret::Index::FieldInfos.new(store: :yes, index: :no, term_vector: :no)
+        @object_class.field_options.each { |field, options| field_infos.add_field(field, options) }
+        field_infos.add_field(:key, store: :yes, index: :yes, term_vector: :yes)
         @store = Isomorfeus::Ferret::Index::Index.new(path: @store_path, key: :key, auto_flush: true, lock_retry_time: 5, field_infos: field_infos)
-        @store.field_infos.add_field(:key, store: :yes, index: :yes, term_vector: :yes) unless @store.field_infos[:key]
-        @object_class.field_options.each do |field, options|
-          @store.field_infos.add_field(field, options) unless @store.field_infos[field]
-        end
       end
     end
   end