isomorfeus-data 2.5.5 → 22.9.0.rc1

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,25 +19,16 @@ module Isomorfeus
         ObjectSpace.define_finalizer(self, self.class.finalize(self))
       end
 
-      def object_from_ref(ref, already_loaded)
-        return nil if !ref || ref.empty?
-        _, 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
 
@@ -45,112 +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 load_sid_s(id:)
+        doc = @store.doc(id)
+        return doc[:key] if doc
+      end
 
-      def unserialize_or_load(v, t, already_loaded)
-        return unserialize(v) if t == :attribute
-        if t == :object && v
-          if v.is_a?(Array)
-            v = v.map { |e| object_from_ref(e, already_loaded) }
-            v.compact!
-            return v
-          else
-            return nil if v.empty?
-            return object_from_ref(v, already_loaded)
-          end
-        end
-        v
-      end
-
-      def serialize_or_save(v, t, already_saved)
-        return serialize(v) if t == :attribute
-        if t == :object && v
-          if v.is_a?(Array)
-            v = v.compact
-            v.map! { |e| create_or_save(e, already_saved) }
-            v.compact!
-            return v
-          else
-            return create_or_save(v, already_saved)
-          end
-        end
-        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

data/lib/isomorfeus/data/rack_middleware.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Isomorfeus
+  module Data
+    class RackMiddleware
+      NOT_FOUND = [404, {}, ['Not found!']].freeze
+      NOT_AUTHORIZED = [401, {}, ['Not authorized!']].freeze
+
+      FILES_REGEXP = /\A\/files\/([A-Za-z\:]+)\/([A-Za-z0-9\-\/_]+)\z/
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        unless env['isomorfeus_store_initialized']
+          Isomorfeus.init_store
+          Isomorfeus.store.clear!
+          env['isomorfeus_store_initialized'] = true
+        end
+
+        path_info = env['PATH_INFO']
+
+        if path_info.start_with?(Isomorfeus.api_files_path)
+          begin
+            m = FILES_REGEXP.match(path_info)
+            return NOT_FOUND unless m
+            type_class_name = m[1]
+            key = m[2]
+
+            return NOT_FOUND unless Isomorfeus.valid_data_class_name?(type_class_name)
+
+            type_class = Isomorfeus.cached_data_class(type_class_name)
+            return NOT_FOUND unless type_class.ancestors.include?(LucidFile)
+
+            env['isomorfeus_user_session'] = Isomorfeus::Transport::RackMiddleware.user_from_env(env) unless env.key?('isomorfeus_user_session')
+            user, session_id = env['isomorfeus_user_session']
+
+            authorized = false
+            begin
+              Thread.current[:isomorfeus_user] = user
+              Thread.current[:isomorfeus_session_id] = session_id
+              authorized = true if user.authorized?(type_class, :load, key: key)
+            ensure
+              Thread.current[:isomorfeus_user] = nil
+              Thread.current[:isomorfeus_session_id] = nil
+            end
+            return NOT_AUTHORIZED unless authorized
+            data = type_class.file_accelerator.load_data(sid: SID.new(type_class_name, key))
+
+            return NOT_FOUND unless data
+
+            mime_type = Marcel::MimeType.for(data)
+            headers = { Rack::CONTENT_TYPE => mime_type }
+
+            return [200, headers, [data]]
+          rescue
+            return NOT_FOUND
+          end
+        else
+          @app.call(env)
+        end
+      end
+
+      def check_and_prepare_path(class_name:, key:)
+        # '..', '.' and other critical characters are already excluded by the FILES_REGEXP
+        elements = key.split('/')
+        Isomorfeus.raise_error(message: 'Invalid key (contains more than 2 slashes "/")') if elements.size > 3
+        ::File.expand_path(::File.join(Isomorfeus.files_path, class_name, *elements))
+      end
+    end
+  end
+end

data/lib/isomorfeus/data/reducer.rb

@@ -1,30 +1,60 @@
 module Isomorfeus
   module Data
     module Reducer
-      def self.add_reducer_to_store
-        data_reducer = Redux.create_reducer do |prev_state, action|
+      if RUBY_ENGINE == 'opal'
+        CLIENT_REDUCER = proc do |prev_state, action|
           action_type = action[:type]
-          if action_type.JS.startsWith('DATA_')
-            case action_type
-            when 'DATA_STATE'
-              if action.key?(:set_state)
-                action[:set_state]
-              else
-                prev_state
-              end
-            when 'DATA_LOAD'
-              prev_state.deep_merge(action[:data])
+          if action_type == 'DATA_STATE' && action.key?(:set_state)
+            action[:set_state]
+          elsif action_type == 'REDUX_MERGE'
+            red_state = action.dig(:state, :data_state)
+            if red_state
+              new_state = prev_state ? prev_state.deep_dup : {}
+              new_state.deep_merge!(red_state)
             else
-              prev_state
+              prev_state || {}
             end
+          elsif action_type == 'DATA_MERGE'
+            new_state = prev_state ? prev_state.deep_dup : {}
+            new_state.deep_merge!(action[:data])
+            new_state
           else
-            prev_state.nil? ? {} : prev_state
+            prev_state || {}
           end
         end
 
-        Redux::Store.preloaded_state_merge!(data_state: {})
-        Redux::Store.add_reducer(data_state: data_reducer)
-      end
+        def self.add_reducer_to_store
+          ::Redux::Store.preloaded_state_merge!(data_state: {})
+          ::Redux::Store.add_reducers(data_state: CLIENT_REDUCER)
+        end
+      else # RUBY_ENGINE
+        SERVER_REDUCER = proc do |prev_state, action|
+          action_type = action[:type]
+          if action_type == 'DATA_STATE' && action.key?(:set_state)
+            action[:set_state]
+          elsif action_type == 'DATA_MERGE'
+            new_state = prev_state ? prev_state.deep_dup : {}
+            new_state.deep_merge!(action[:data])
+            new_state
+          elsif action_type == 'DATA_SET'
+            new_state = prev_state ? prev_state.deep_dup : {}
+            if !new_state[action[:class_name]]
+              new_state[action[:class_name]] = {}
+            else
+              new_state[action[:class_name]].delete(action[:key])
+            end
+            new_state[action[:class_name]][action[:key]] = action[:data]
+            new_state
+          else
+            prev_state || {}
+          end
+        end
+
+        def self.add_reducer_to_store
+          ::Redux::Store.preloaded_state_merge!(data_state: {})
+          ::Redux::Store.add_reducers(data_state: SERVER_REDUCER)
+        end
+      end # RUBY_ENGINE
     end
   end
 end

data/lib/isomorfeus/data/sid.rb

@@ -0,0 +1,34 @@
+class SID
+  SID_S_RE = /\ASID__([a-zA-Z0-9:]+)__([\w\/\-]+)__\z/ # must use this way for compatiblity
+
+  class << self
+    def from_s(sid_s)
+      m = SID_S_RE.match(sid_s)
+      self.new(m[1], m[2]) if m
+    end
+
+    def is?(string)
+      SID_S_RE.match?(string)
+    end
+  end
+
+  attr_reader :class_name
+  attr_reader :key
+
+  if RUBY_ENGINE == 'opal'
+    def initialize(class_name, key)
+      @class_name = class_name
+      @key = key
+    end
+  else
+    def initialize(class_name, key)
+      raise "Invalid class name '#{class_name}!" unless Isomorfeus.valid_data_class_name?(class_name)
+      @class_name = class_name
+      @key = key
+    end
+  end
+
+  def to_s
+    "SID__#{@class_name}__#{@key}__"
+  end
+end

data/lib/isomorfeus/data/version.rb

@@ -1,5 +1,5 @@
 module Isomorfeus
   module Data
-    VERSION = '2.5.5'
+    VERSION = '22.9.0.rc1'
   end
 end

data/lib/isomorfeus-data.rb

@@ -1,50 +1,45 @@
-require 'base64'
-require 'stringio'
-if RUBY_ENGINE == 'opal'
-  require 'iso_uri'
-end
-require 'data_uri'
-require 'securerandom'
-require 'isomorfeus-policy'
 require 'isomorfeus-transport'
+require 'isomorfeus-redux'
 require 'isomorfeus-i18n'
+require 'isomorfeus-preact'
+require 'isomorfeus-policy'
 require 'isomorfeus/data/config'
-require 'isomorfeus/data/field_support'
-require 'isomorfeus/data/generic_class_api'
-require 'isomorfeus/data/generic_instance_api'
+require 'isomorfeus/data/sid'
 
-if RUBY_ENGINE == 'opal'
-  require 'isomorfeus/data/reducer'
-  Isomorfeus::Data::Reducer.add_reducer_to_store
-  Isomorfeus.zeitwerk.push_dir('isomorfeus_data')
-  require_tree 'isomorfeus_data', autoload: true
-  Isomorfeus.zeitwerk.push_dir('data')
-else
+if RUBY_ENGINE != 'opal'
   require 'fileutils'
   require 'uri'
   require 'oj'
   require 'active_support'
   require 'active_support/core_ext/hash'
-
+  require 'marcel'
   require 'isomorfeus-ferret'
   require 'isomorfeus/data/object_accelerator'
+  require 'isomorfeus/data/file_accelerator'
+end
+
+require 'lucid_data_generic'
+require 'lucid_object'
+require 'lucid_file'
+
+require 'isomorfeus/data/reducer'
+Isomorfeus::Data::Reducer.add_reducer_to_store
 
-  require 'isomorfeus_data/lucid_query_result'
-  require 'isomorfeus_data/lucid_object/mixin'
-  require 'isomorfeus_data/lucid_object/base'
-  require 'isomorfeus_data/lucid_query/mixin'
-  require 'isomorfeus_data/lucid_query/base'
-  require 'isomorfeus_data/lucid_file/mixin'
-  require 'isomorfeus_data/lucid_file/base'
+require 'isomorfeus/data/enhancer'
+Isomorfeus::Data::Enhancer.add_enhancer_to_store
+
+if RUBY_ENGINE == 'opal'
+  Isomorfeus.zeitwerk.push_dir('isomorfeus_data')
+  require_tree 'isomorfeus_data', autoload: true
+  Isomorfeus.zeitwerk.push_dir('data')
+else
+  require 'isomorfeus/data/rack_middleware'
 
-  require 'isomorfeus/data/handler/generic'
+  Isomorfeus.add_middleware(Isomorfeus::Data::RackMiddleware)
 
   require 'iso_opal'
-  Opal.append_path(__dir__.untaint) unless IsoOpal.paths.include?(__dir__.untaint)
-  uri_path = File.expand_path(File.join(__dir__.untaint, '..', 'opal'))
-  Opal.append_path(uri_path) unless IsoOpal.paths.include?(uri_path)
+  Opal.append_path(__dir__.untaint) unless IsoOpal.paths_include?(__dir__.untaint)
 
   path = File.expand_path(File.join('app', 'data'))
-
-  Isomorfeus.zeitwerk.push_dir(path)
+  Isomorfeus.zeitwerk.push_dir(path) if Dir.exist?(path)
 end

data/lib/lucid_data_generic.rb

@@ -0,0 +1,163 @@
+class LucidDataGeneric
+  class << self
+    def create(key: nil, **things)
+      new(key: key, **things).create
+    end
+
+    def load(key:)
+      instance = self.new(key: key, _loading: true)
+      instance.loaded? ? instance : load!(key: key, instance: instance)
+    end
+
+    def destroyed?(key:)
+      Isomorfeus.store.dig(:data_state, self.name, key, :revision) == -1
+    end
+
+    def current_user
+      Isomorfeus.current_user
+    end
+  end
+
+  if RUBY_ENGINE == 'opal'
+    class << self
+      # callbacks
+      def before_load(&block); end
+      def after_load(&block); end
+      def before_create(&block); end
+      def after_create(&block); end
+      def before_save(&block); end
+      def after_save(&block); end
+      def before_destroy(&block); end
+      def after_destroy(&block); end
+    end
+  else # RUBY_ENGINE
+    class << self
+      # callbacks
+
+      def before_create(&block)
+        @before_create_block = block
+      end
+
+      def after_create(&block)
+        @after_create_block = block
+      end
+
+      def before_load(&block)
+        @before_load_block = block
+      end
+
+      def after_load(&block)
+        @after_load_block = block
+      end
+
+      def before_save(&block)
+        @before_save_block = block
+      end
+
+      def after_save(&block)
+        @after_save_block = block
+      end
+
+      def before_destroy(&block)
+        @before_destroy_block = block
+      end
+
+      def after_destroy(&block)
+        @after_destroy_block = block
+      end
+
+      # callback readers
+
+      attr_reader :before_create_block, :after_create_block
+      attr_reader :before_load_block, :after_load_block
+      attr_reader :before_save_block, :after_save_block
+      attr_reader :before_destroy_block, :after_destroy_block
+    end
+
+    def pub_sub_client
+      Isomorfeus.pub_sub_client
+    end
+  end # RUBY_ENGINE
+
+  def initialize(key: nil)
+    @key = key.nil? ? SecureRandom.uuid : key.to_s
+    @self_class = self.class
+    @class_name = @self_class.name
+    @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
+    @changed = false
+  end
+
+  def loaded?
+    revision > 0
+  end
+
+  def instance_uuid
+    @instance_uuid ||= SecureRandom.uuid
+  end
+
+  def state_instance_uuid
+    Isomorfeus.store.dig(:data_state, @class_name, @key, :instance_uuid)
+  end
+
+  def revision
+    Isomorfeus.store.dig(:data_state, @class_name, @key, :revision) || 0
+  end
+
+  def created?
+    (state_instance_uuid == instance_uuid) && (revision == 1)
+  end
+
+  def saved?
+    (state_instance_uuid == instance_uuid) && (revision == (@last_revision + 1))
+  end
+
+  def reload
+    unchange!
+    @self_class.load!(key: @key, instance: self)
+    self
+  end
+
+  def destroy
+    @self_class.destroy(key: @key)
+  end
+
+  def destroyed?
+    @self_class.destroyed?(key: @key)
+  end
+
+  def changed!
+    @changed = true
+  end
+
+  def unchange!
+    @changed = false
+  end
+
+  def key
+    @key
+  end
+
+  def key=(k)
+    @key = k.to_s
+  end
+
+  def changed?
+    @changed
+  end
+
+  def sid
+    SID.new(@class_name, @key)
+  end
+
+  def to_n
+    sid.to_s
+  end
+
+  def current_user
+    Isomorfeus.current_user
+  end
+
+  def pub_sub_client
+    Isomorfeus.pub_sub_client
+  end
+end