isomorfeus-data 2.5.5 → 22.9.0.rc1

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

data/lib/lucid_object.rb

@@ -0,0 +1,431 @@
+class LucidObject < LucidDataGeneric
+  include LucidI18nMixin
+
+  class SearchResultProxy
+    attr_reader :query_json
+
+    def initialize(class_name, query, params)
+      @store_path = [:data_state, :queries, class_name, query, JSON.dump(params)]
+    end
+
+    def method_missing(method, *args, &block)
+      all.send(method, *args, &block)
+    end
+
+    def loaded?
+      !!as_sid_s
+    end
+
+    def as_sid_s
+      Isomorfeus.store.dig(*@store_path)
+    end
+
+    def as_keys
+      a = as_sid_s
+      return [] unless a
+      a.map do |sid_s|
+        SID.from_s(sid_s).key
+      end
+    end
+
+    def [](idx)
+      sid_s = as_sid_s&.fetch(idx)
+      LucidObject.instance_from_sid_s(sid_s) if sid_s
+    end
+
+    def all
+      a = as_sid_s
+      return [] unless a
+      a.map do |sid_s|
+        LucidObject.instance_from_sid_s(sid_s)
+      end
+    end
+
+    def dig(*identifiers)
+      all.dig(*identifiers)
+    end
+
+    def length
+      as_sid_s&.size
+    end
+    alias size length
+  end
+
+  OBJECT_VALIDATION_PROC = proc do |v|
+    fail = false
+    if v.is_a?(SID)
+      # yes, a sid
+    elsif v.is_a?(Array)
+      v.each do |e|
+        fail = true unless (e.nil? || e.is_a?(LucidDataGeneric) || e.is_a?(SID) || (e.is_a?(String) && SID.is?(e)))
+      end
+    elsif v.is_a?(String)
+      fail = true unless SID.is?(v)
+    elsif !v.nil? && !v.is_a?(LucidObject)
+      fail = true
+    end
+    raise "must be nil, a LucidObject or a Array of LucidObjects, a SID or a Array of SIDs" if fail
+  end
+
+  ATTRIBUTE_VALIDATION_PROC = proc do |v|
+    fail = false
+    if v.is_a?(SID) || (v.is_a?(String) && SID.is?(v)) || v.is_a?(LucidDataGeneric)
+      fail = true
+    elsif v.is_a?(Array)
+      v.each do |e|
+        fail = true if e.is_a?(SID) || (e.is_a?(String) && SID.is?(e)) || e.is_a?(LucidDataGeneric)
+      end
+    end
+    raise "LucidObjects or LucidFiles are not allowed as attributes!" if fail
+  end
+
+  class << self
+    def search(query, params = nil)
+      proxy_instance = LucidObject::SearchResultProxy.new(self.name, query, params)
+      Isomorfeus.something_loading!
+      Isomorfeus.store.deferred_dispatch(type: 'DATA_SEARCH', class_name: self.name, query: query, params: params)
+      proxy_instance
+    end
+
+    def load!(key:, instance: nil)
+      instance = self.new(key: key, _loading: true) unless instance
+      Isomorfeus.something_loading!
+      Isomorfeus.store.deferred_dispatch(type: 'DATA_LOAD', class_name: self.name, key: key)
+      instance
+    end
+
+    def destroy(key:)
+      Isomorfeus.store.deferred_dispatch(type: 'DATA_DESTROY', class_name: self.name, key: key)
+      true
+    end
+
+    def escape_string(s)
+      s.gsub(/([\\\&\:\(\)\[\]\{\}\!\"\~\^\|\<\>\=\*\?\+\-\s])/, '\\\\\1')
+    end
+
+    def instance_from_sid_s(sid_s)
+      sid = SID.from_s(sid_s)
+      data_class = Isomorfeus.cached_data_class(sid.class_name)
+      data_class.load(key: sid.key)
+    end
+
+    def query(name, query_string, options = nil)
+      queries[name] = { query_string: query_string, options: options }
+    end
+
+    def queries
+      @queries ||= {}
+    end
+
+    def field_types
+      # determines how the item is stored in the index
+      @field_types ||= {}
+    end
+
+    def field_options
+      # options for the index
+      @field_options ||= {}
+    end
+
+    def field_conditions
+      # conditions for validating the field data
+      @field_conditions ||= {}
+    end
+
+    def _register_field(name, type, options)
+      field_options[name] = {}
+      field_options[name][:default_boost] = options.delete(:default_boost) if options.key?(:default_boost)
+      field_options[name][:default_boost] = options.delete(:default_boost) if options.key?(:boost)
+      field_options[name][:index] = options.delete(:index) { :no }
+      field_options[name][:store] = options.delete(:store) { :yes }
+      field_options[name][:compress] = options.delete(:compress) if options.key?(:compress)
+      if field_options[name][:index] == :yes
+        field_options[name][:term_vector] = options.delete(:term_vector) { type == :text_field ? :with_positions_offsets : :no }
+      elsif field_options[name][:index] == :no
+        field_options[name][:term_vector] = :no
+      end
+      field_conditions[name] = options
+      field_types[name] = type
+    end
+
+    def field(name, type, options)
+      _register_field(name, type, options)
+    end
+
+    def text_field(name, options = {})
+      default_options = { is_a: String, allow_nil: true, cast: true }
+      field(name, :text_field, default_options.merge(options))
+    end
+
+    def attribute(name, options = {})
+      default_options = { validate_block: ATTRIBUTE_VALIDATION_PROC }
+      field(name, :attribute, default_options.merge(options))
+    end
+
+    def object(name, options = {})
+      default_options = { validate_block: OBJECT_VALIDATION_PROC }
+      field(name, :object, default_options.merge(options))
+    end
+
+    def validate_field!(field_name, val)
+      raise "no such field" unless field_options.key?(field_name)
+      Isomorfeus::Props::Validator.new(self.name, field_name, val, field_conditions[field_name]).validate!
+    end
+
+    def valid_field?(field_name, val)
+      validate_field!(field_name, val)
+    rescue
+      false
+    end
+
+    def valid_text_field?(field_name, val)
+      return valid_field?(field_name, val) if field_types[field_name] == :text_field
+      false
+    rescue
+      false
+    end
+
+    def valid_attribute?(attr_name, val)
+      return valid_field?(attr_name, val) if field_types[attr_name] == :attribute
+      false
+    rescue
+      false
+    end
+    alias valid_embed? valid_attribute?
+
+    def valid_object?(obj_name, val)
+      return valid_field?(obj_name, val) if field_types[obj_name] == :object
+      false
+    rescue
+      false
+    end
+    alias valid_reference? valid_object?
+
+    def validate
+      Isomorfeus::Props::ValidateHashProxy.new
+    end
+
+    def _validate_field(field_name, val)
+      Isomorfeus.raise_error(message: "#{self.name}: No such text_field, attribute or object declared: '#{field_name}'!") unless field_conditions.key?(field_name)
+      Isomorfeus::Props::Validator.new(self.name, field_name, val, field_conditions[field_name]).validated_value
+    end
+
+    def _validate_fields(fields)
+      field_names = (fields.keys + field_conditions.keys).uniq
+      field_names.each do |field_name|
+        if field_conditions[field_name].key?(:required) && field_conditions[field_name][:required] && !fields.key?(field_name)
+          Isomorfeus.raise_error(message: "Required #{field_types[field_name]} #{field_name} not given!")
+        end
+        fields[field_name] = _validate_field(field_name, fields[field_name])
+      end
+    end
+  end
+
+  def initialize(key: nil, fields: nil, attributes: nil, _loading: false)
+    super(key: key)
+    _update_paths
+    @objects = {}
+    @field_types = @self_class.field_types
+    loaded = loaded?
+    fields = attributes if attributes
+    if loaded
+      raw_fields = Isomorfeus.store.dig(*@store_path)
+      if raw_fields.nil?
+        if fields
+          _validate_fields(fields)
+          @changed_fields = fields
+        else
+          @changed_fields = {}
+        end
+      elsif raw_fields && fields && 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 create
+    raise 'Already created!' if revision > 0
+    @last_revision = 0
+    f = _get_fields
+    unchange!
+    Isomorfeus.something_loading!
+    Isomorfeus.store.deferred_dispatch(type: "DATA_CREATE", class_name: @class_name, key: @key, fields: f, instance_uuid: instance_uuid, revision: 0)
+    self
+  end
+
+  def save
+    @last_revision = revision
+    return create if @last_revision == 0
+    f = _get_fields
+    unchange!
+    Isomorfeus.something_loading!
+    Isomorfeus.store.deferred_dispatch(type: "DATA_SAVE", class_name: @class_name, key: @key, fields: f, instance_uuid: instance_uuid, revision: @last_revision)
+    self
+  end
+
+  def _update_paths
+    @store_path = [:data_state, @class_name, @key, :fields]
+  end
+
+  def _get_object(name)
+    return @changed_fields[name] if @changed_fields.key?(name)
+    return @objects[name] if @objects.key?(name)
+    sid_or_array = Isomorfeus.store.dig(*@store_path)&.fetch(name, nil)
+    return nil unless sid_or_array
+    if sid_or_array.is_a?(String)
+      @objects[name] = @self_class.instance_from_sid_s(sid_or_array)
+    elsif sid_or_array.is_a?(Array)
+      a = sid_or_array.map do |sid_s|
+        @self_class.instance_from_sid_s(sid_s)
+      end
+      a.compact!
+      @objects[name] = a
+    end
+    @objects[name]
+  end
+
+  def _validate_field(field_name, val)
+    @self_class._validate_field(field_name, val)
+  end
+
+  def _validate_fields(fields)
+    @self_class._validate_fields(fields)
+  end
+
+  def [](name)
+    return key if name == :key
+    type = @field_types[name]
+    case type
+    when :text_field then _get_field(name) || ''
+    when :attribute then _get_field(name)
+    when :object then _get_object(name)
+    else
+      raise "No such field '#{name}' declared!"
+    end
+  end
+  alias_method :fetch, :[]
+
+  def []=(name, val)
+    return self.key = name if name == :key
+    val = _validate_field(name, val)
+    changed!
+    @changed_fields[name] = val
+  end
+  alias_method :store, :[]=
+
+  def dig(name, *more_names)
+    value = self[name]
+    if value.respond_to?(:dig)
+      value.dig(*more_names) rescue nil
+    else
+      value
+    end
+  end
+
+  def fields
+    raw_fields = Isomorfeus.store.dig(*@store_path)
+    hash = raw_fields ? raw_fields.dup : {}
+    hash.merge!(@changed_fields) if @changed_fields
+    hash
+  end
+
+  def _get_fields
+    sel_fields = fields.dup
+    @self_class.field_types.each do |field, type|
+      if type == :object
+        v = self[field]
+        sel_fields[field] = if v.is_a?(SID)
+                                v.to_s
+                              elsif v.is_a?(Array)
+                                v.map do |o|
+                                  if o.is_a?(SID)
+                                    o.to_s
+                                  elsif o.is_a?(LucidObject)
+                                    o.sid.to_s
+                                  elsif o.is_a?(String)
+                                    o
+                                  end
+                                end
+                              elsif v.is_a?(LucidObject)
+                                v.sid.to_s
+                              elsif v.is_a?(String)
+                                v
+                              end
+      end
+    end
+    sel_fields
+  end
+
+  def unchange!
+    @changed_fields = {}
+    super
+  end
+
+  def each(&block)
+    fields.each(&block)
+  end
+
+  if RUBY_ENGINE == 'opal'
+    def _get_field(name)
+      return @changed_fields[name] if @changed_fields.key?(name)
+      Isomorfeus.store.dig(*@store_path)&.fetch(name) { |n| @self_class.field_conditions[n][:default] }
+    end
+  else # RUBY_ENGINE
+    class << self
+      def inherited(base)
+        Isomorfeus.add_valid_data_class(base) unless %w[LucidObject LucidUser].include?(base.name)
+      end
+
+      def exist?(key:)
+        raise "Not authorized!" unless current_user.authorized?(self, :load, key: key)
+        object_accelerator.exist?(sid_s: SID.new(self.name, key).to_s)
+      end
+
+      def exist_by_field?(field:, value:)
+        raise "Not authorized!" unless current_user.authorized?(self, :search, { query: :exist_by_field , params: { field: field, value: value }})
+        object_accelerator.exist_by_field?(field: field, value: value)
+      end
+
+      def field_by_key(key:, field:)
+        sid_s = SID.new(self.name, key).to_s
+        object_accelerator.field(sid_s: sid_s, field: field)
+      end
+
+      def object_accelerator
+        @object_accelerator ||= Isomorfeus::Data::ObjectAccelerator.new(self)
+      end
+
+      def each(&block)
+        if block_given?
+          object_accelerator.each do |sid_s|
+            sid = SID.from_s(sid_s)
+            block.call self.load(key: sid.key)
+          end
+        else
+          Enumerator.new do |yielder|
+            object_accelerator.each do |sid_s|
+              sid = SID.from_s(sid_s)
+              yielder << self.load(key: sid.key)
+            end
+          end
+        end
+      end
+      alias to_enum each
+    end
+
+    def _get_field(name)
+      return @changed_fields[name] if @changed_fields.key?(name)
+      if @self_class.field_conditions[name][:server_only]
+        return @self_class.object_accelerator.field(sid_s: sid.to_s, field: name)
+      end
+      Isomorfeus.store.dig(*@store_path)&.fetch(name) { |n| @self_class.field_conditions[n][:default] }
+    end
+  end # RUBY_ENGINE
+end