isomorfeus-data 2.5.4 → 22.9.0.rc1

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.4'
+    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

data/lib/lucid_file.rb

@@ -0,0 +1,137 @@
+class LucidFile < LucidDataGeneric
+  include LucidI18nMixin
+
+  VALID_METHODS = %i[key data data_uri content_type]
+
+  class << self
+    def api_path(key:)
+      "#{Isomorfeus.api_files_path}#{self.name}/#{key}"
+    end
+
+    def format_data_uri(c, d)
+      "data:#{c};base64,#{Base64.strict_encode64(d)}"
+    end
+
+    def destroy(key:)
+      Isomorfeus.store.deferred_dispatch(type: 'FILE_DESTROY', class_name: self.name, key: key)
+      true
+    end
+
+    def load!(key:, instance: nil)
+      instance = self.new(key: key, _loading: true) unless instance
+      Isomorfeus.something_loading!
+      Isomorfeus.store.deferred_dispatch(type: 'FILE_LOAD', class_name: self.name, key: key)
+      instance
+    end
+  end
+
+  def initialize(key: nil, content_type: nil, data: nil, data_uri: nil, _loading: false)
+    super(key: key)
+    _update_paths
+    loaded = loaded?
+    @changed_uri_string = nil
+    if data_uri
+      @changed_uri_string = data_uri
+    elsif data || content_type
+      data = data.to_s unless data.is_a?(String)
+      if RUBY_ENGINE != 'opal'
+        content_type = Marcel::MimeType.for(data) unless content_type
+      end
+      @changed_uri_string = self.class.format_data_uri(content_type, data)
+    end
+  end
+
+  def create
+    raise 'Already created!' if revision > 0
+    @last_revision = 0
+    d = data_uri
+    unchange!
+    Isomorfeus.something_loading!
+    Isomorfeus.store.deferred_dispatch(type: "FILE_CREATE", class_name: @class_name, key: @key, data_uri: d, instance_uuid: instance_uuid, revision: 0)
+    self
+  end
+
+  def save
+    @last_revision = revision
+    return create if @last_revision == 0
+    d = data_uri
+    unchange!
+    Isomorfeus.something_loading!
+    Isomorfeus.store.deferred_dispatch(type: "FILE_SAVE", class_name: @class_name, key: @key, data_uri: d, instance_uuid: instance_uuid, revision: @last_revision)
+    self
+  end
+
+  def [](name)
+    self.send(name) if VALID_METHODS.include?(name)
+  end
+
+  def []=(name, value)
+    self.send("#{name}=".to_sym, value) if VALID_METHODS.include?(name)
+  end
+
+  def unchange!
+    super
+    @changed_uri_string = nil
+  end
+
+  def _update_paths
+    @store_path = [:data_state, @class_name, @key, :data_uri]
+  end
+
+  def content_type
+    data_uri_object&.content_type
+  end
+
+  def content_type=(c)
+    changed!
+    uri_string = @changed_uri_string ? @changed_uri_string : Isomorfeus.store.dig(*@store_path)
+    @changed_uri_string = self.class.format_data_uri(c, URI::Data.new(uri_string).data)
+    c
+  end
+
+  def data_uri
+    @changed_uri_string ? @changed_uri_string : Isomorfeus.store.dig(*@store_path)
+  end
+
+  def data_uri=(d)
+    changed!
+    @changed_uri_string = d
+  end
+
+  def data_uri_object
+    du = data_uri
+    URI::Data.new(du) if du
+  end
+
+  def data
+    data_uri_object&.data
+  end
+
+  def data=(d)
+    changed!
+    d = d.to_s unless d.is_a?(String)
+    if RUBY_ENGINE == 'opal'
+      ct = content_type
+    else
+      ct = Marcel::MimeType.for(d)
+    end
+    @changed_uri_string = self.class.format_data_uri(ct, d)
+  end
+
+  if RUBY_ENGINE != 'opal'
+    class << self
+      def inherited(base)
+        Isomorfeus.add_valid_data_class(base) unless 'LucidFile' == base.name
+      end
+
+      def file_accelerator
+        @file_accelerator ||= Isomorfeus::Data::FileAccelerator.new(self)
+      end
+
+      def exist?(key:)
+        raise "Not authorized!" unless current_user.authorized?(self, :load, key: key)
+        file_accelerator.exist?(sid: SID.new(self.name, key))
+      end
+    end
+  end # RUBY_ENGINE
+end