eluvia-base 3.37.1

data/lib/eluvia/handlers/pagination_handler.rb

@@ -0,0 +1,25 @@
+module Eluvia
+  module PaginationHandler
+    extend ::ActiveSupport::Concern
+
+    def set_pagination(default_limit: 20, default_offset: 0, default_order_by: 'created_at:asc', fallback_order_by: 'created_at:asc', force_order_by: false)
+
+      # Pagination
+      @limit = params[:limit] ? params[:limit].to_i : default_limit
+      @offset = params[:offset] ? params[:offset].to_i : default_offset
+      @page = (@offset / @limit) + 1
+      @padding = @offset % @limit
+
+      # Order by
+      @order_by = {}
+      order_by_param = Eluvia::Base::Config.api_case == 'camel_case' ? :orderBy : :order_by
+      order_by = "#{!force_order_by && params.key?(order_by_param) ? params[order_by_param] : default_order_by},#{fallback_order_by}"
+      order_by.to_s.split(',').each do |o|
+        s = o.to_s.split(':')
+        @order_by[s.first] = s.length >= 2 && s[1].downcase == 'desc' ? :desc : :asc
+      end
+
+    end
+
+  end
+end

data/lib/eluvia/handlers/params_handler.rb

@@ -0,0 +1,43 @@
+module Eluvia
+  module ParamsHandler
+    extend ::ActiveSupport::Concern
+
+    def parse_json_param(value)
+      unless value.blank?
+        if value.is_a?(String)
+          JSON.parse(value) # This can produce JSON::ParserError which is translated to Eluvia::Errors::StandardError
+        elsif value.is_a?(ActionController::Parameters)
+          value.to_unsafe_h
+        elsif value.is_a?(Array)
+          result = []
+          value.each do |item|
+            if item.is_a?(String)
+              result << (JSON.parse(item) rescue item) # This can produce JSON::ParserError which is translated to Eluvia::Errors::StandardError
+            elsif item.is_a?(ActionController::Parameters)
+              result << item.to_unsafe_h
+            end
+          end
+          result
+        end
+      end
+    end
+
+    def disassemble_filters(params)
+      result = {}
+      params.each do |key, value|
+        split_key = key.to_s.split('__')
+        result_component = result
+        split_key.each_with_index do |key_component, index|
+          if index + 1 == split_key.length # last component
+            result_component[key_component.to_sym] = value
+          else
+            result_component[key_component.to_sym] = {} if result_component[key_component.to_sym].nil?
+            result_component = result_component[key_component.to_sym]
+          end
+        end
+      end
+      result
+    end
+
+  end
+end

data/lib/eluvia/helpers/attachment_helper.rb

@@ -0,0 +1,37 @@
+module Eluvia
+  module AttachmentHelper
+    extend ::ActiveSupport::Concern
+
+    def attachment_url(attachment, skip_check: false, expires_in: nil)
+      unless skip_check
+        return nil unless attachment.attached?
+      end
+      if Rails.application.config.active_storage.service == :local
+        Rails.application.routes.url_helpers.rails_blob_path(attachment, only_path: true)
+      elsif expires_in
+        attachment.url(expires_in: expires_in)
+      else
+        attachment.url
+      end
+      # NOTE: class method can't be called from instance method because of controller / view helpers, so we need to
+      # duplicate the code here.
+    end
+
+    class_methods do
+
+      def attachment_url(attachment, skip_check: false, expires_in: nil)
+        unless skip_check
+          return nil unless attachment.attached?
+        end
+        if Rails.application.config.active_storage.service == :local
+          Rails.application.routes.url_helpers.rails_blob_path(attachment, only_path: true)
+        elsif expires_in
+          attachment.url(expires_in: expires_in)
+        else
+          attachment.url
+        end
+      end
+
+    end
+  end
+end

data/lib/eluvia/integrations/eluvia_integration.rb

@@ -0,0 +1,281 @@
+module Eluvia
+  module EluviaIntegration
+    extend ::ActiveSupport::Concern
+
+    protected
+
+    def compose_url(endpoint)
+      raise Eluvia::Errors::StandardError.new('External service URL not defined.') if @service_url.blank?
+      "#{@service_url.to_s.rtrim('/')}/#{endpoint.trim('/')}"
+    end
+
+    def compose_headers_private(params = nil)
+      if Eluvia::Base::Config.authorization_method == 'jwt'
+        {
+          params: params,
+          'x-authorization' => "Private #{Eluvia::Jwt.encode_private_jwt_token}",
+          'content-type' => 'application/json'
+        }
+      elsif Eluvia::Base::Config.authorization_method == 'session_id'
+        {
+          params: params,
+          'x-private-api-key' => Eluvia::Base::Config.private_api_key,
+          'content-type' => 'application/json'
+        }
+      else
+        raise Eluvia::Errors::StandardError.new('Unknown authorization method.')
+      end
+    end
+
+    def compose_headers_public(session_id_or_user, params = nil)
+      if Eluvia::Base::Config.authorization_method == 'jwt'
+        {
+          params: params,
+          'x-authorization' => "Bearer #{Eluvia::Jwt.encode_public_jwt_token(session_id_or_user)}",
+          'content-type' => 'application/json'
+        }
+      elsif Eluvia::Base::Config.authorization_method == 'session_id'
+        {
+          params: params,
+          'x-public-api-key' => Eluvia::Base::Config.public_api_key,
+          'session-id' => session_id_or_user,
+          'content-type' => 'application/json'
+        }
+      else
+        raise Eluvia::Errors::StandardError.new('Unknown authorization method.')
+      end
+    end
+
+    def compose_headers_both(session_id_or_user, params = nil)
+      if Eluvia::Base::Config.authorization_method == 'jwt'
+        compose_headers_public(session_id_or_user, params)
+      elsif Eluvia::Base::Config.authorization_method == 'session_id'
+        compose_headers_private(params).merge(compose_headers_public(session_id_or_user, params))
+      else
+        raise Eluvia::Errors::StandardError.new('Unknown authorization method.')
+      end
+    end
+
+    def perform_get_request(url, headers)
+      RestClient::Request.execute(
+        method: :get,
+        url: url,
+        headers: headers
+      )
+    rescue RestClient::NotFound => e
+      m = parse_error_message(e)
+      raise Eluvia::Errors::NotFound.new(m || 'Not found response from external service.')
+    rescue RestClient::BadRequest => e
+      m = parse_error_message(e)
+      raise Eluvia::Errors::BadRequest.new(m || 'Bad response from external service.')
+    rescue RestClient::UnprocessableEntity => e
+      raise Eluvia::Errors::UnprocessableEntity.new(parse_error_messages(e))
+    rescue RestClient::Exception => e
+      m = parse_error_message(e)
+      raise Eluvia::Errors::StandardError.new(m || 'Standard error from external service.')
+    end
+
+    def parse_get_request(url, headers)
+      response = perform_get_request(url, headers)
+      if response && response.code == 204
+        true
+      elsif response && response.code < 300
+        data = JSON.parse(response.body) rescue nil
+        raise Eluvia::Errors::StandardError.new('Unable to parse response from external service.') if data.nil?
+        normalize_data(data)
+      end
+    end
+
+    def perform_post_request(url, headers, data = nil)
+      RestClient::Request.execute(
+        method: :post,
+        url: url,
+        headers: headers,
+        payload: data.to_json
+      )
+    rescue RestClient::NotFound => e
+      m = parse_error_message(e)
+      raise Eluvia::Errors::NotFound.new(m || 'Not found response from external service.')
+    rescue RestClient::BadRequest => e
+      m = parse_error_message(e)
+      raise Eluvia::Errors::BadRequest.new(m || 'Bad response from external service.')
+    rescue RestClient::UnprocessableEntity => e
+      raise Eluvia::Errors::UnprocessableEntity.new(parse_error_messages(e))
+    rescue RestClient::Exception => e
+      m = parse_error_message(e)
+      raise Eluvia::Errors::StandardError.new(m || 'Standard error from external service.')
+    end
+
+    def parse_post_request(url, headers, data = nil)
+      response = perform_post_request(url, headers, data)
+      if response && response.code == 204
+        true
+      elsif response && response.code < 300
+        data = JSON.parse(response.body) rescue nil
+        raise Eluvia::Errors::StandardError.new('Unable to parse response from external service.') if data.nil?
+        normalize_data(data)
+      end
+    end
+
+    def perform_put_request(url, headers, data = nil)
+      RestClient::Request.execute(
+        method: :put,
+        url: url,
+        headers: headers,
+        payload: data.to_json
+      )
+    rescue RestClient::NotFound => e
+      m = parse_error_message(e)
+      raise Eluvia::Errors::NotFound.new(m || 'Not found response from external service.')
+    rescue RestClient::BadRequest => e
+      m = parse_error_message(e)
+      raise Eluvia::Errors::BadRequest.new(m || 'Bad response from external service.')
+    rescue RestClient::UnprocessableEntity => e
+      raise Eluvia::Errors::UnprocessableEntity.new(parse_error_messages(e))
+    rescue RestClient::Exception => e
+      m = parse_error_message(e)
+      raise Eluvia::Errors::StandardError.new(m || 'Standard error from external service.')
+    end
+
+    def parse_put_request(url, headers, data = nil)
+      response = perform_put_request(url, headers, data)
+      if response && response.code == 204
+        true
+      elsif response && response.code < 300
+        data = JSON.parse(response.body) rescue nil
+        raise Eluvia::Errors::StandardError.new('Unable to parse response from external service.') if data.nil?
+        normalize_data(data)
+      end
+    end
+
+    def perform_patch_request(url, headers, data = nil)
+      RestClient::Request.execute(
+        method: :patch,
+        url: url,
+        headers: headers,
+        payload: data.to_json
+      )
+    rescue RestClient::NotFound => e
+      m = parse_error_message(e)
+      raise Eluvia::Errors::NotFound.new(m || 'Not found response from external service.')
+    rescue RestClient::BadRequest => e
+      m = parse_error_message(e)
+      raise Eluvia::Errors::BadRequest.new(m || 'Bad response from external service.')
+    rescue RestClient::UnprocessableEntity => e
+      raise Eluvia::Errors::UnprocessableEntity.new(parse_error_messages(e))
+    rescue RestClient::Exception => e
+      m = parse_error_message(e)
+      raise Eluvia::Errors::StandardError.new(m || 'Standard error from external service.')
+    end
+
+    def parse_patch_request(url, headers, data = nil)
+      response = perform_patch_request(url, headers, data)
+      if response && response.code == 204
+        true
+      elsif response && response.code < 300
+        data = JSON.parse(response.body) rescue nil
+        raise Eluvia::Errors::StandardError.new('Unable to parse response from external service.') if data.nil?
+        normalize_data(data)
+      end
+    end
+
+    def perform_delete_request(url, headers)
+      RestClient::Request.execute(
+        method: :delete,
+        url: url,
+        headers: headers
+      )
+    rescue RestClient::NotFound => e
+      m = parse_error_message(e)
+      raise Eluvia::Errors::NotFound.new(m || 'Not found response from external service.')
+    rescue RestClient::BadRequest => e
+      m = parse_error_message(e)
+      raise Eluvia::Errors::BadRequest.new(m || 'Bad response from external service.')
+    rescue RestClient::UnprocessableEntity => e
+      raise Eluvia::Errors::UnprocessableEntity.new(parse_error_messages(e))
+    rescue RestClient::Exception => e
+      m = parse_error_message(e)
+      raise Eluvia::Errors::StandardError.new(m || 'Standard error from external service.')
+    end
+
+    def parse_delete_request(url, headers)
+      response = perform_delete_request(url, headers)
+      if response && response.code == 204
+        true
+      elsif response && response.code < 300
+        data = JSON.parse(response.body) rescue nil
+        raise Eluvia::Errors::StandardError.new('Unable to parse response from external service.') if data.nil?
+        normalize_data(data)
+      end
+    end
+
+    def parse_error_message(e)
+      response_data = JSON.parse(e.response.to_s) rescue nil
+      if response_data.is_a?(Hash) && response_data['errors']
+        response_data['errors'].first&.[]('message')
+      end
+    end
+
+    def parse_error_messages(e)
+      result = {}
+      response_data = JSON.parse(e.response.to_s) rescue nil
+      if response_data.is_a?(Hash) && response_data['errors']
+        response_data['errors'].each do |error|
+          result[error['source']] = error['message']
+        end
+      end
+      result
+    end
+
+    def paginate_with_offset(limit = 20, &block)
+      offset = 0
+      not_empty = true
+      result = []
+      while not_empty
+        data = block.call(limit, offset)
+        if data.is_a?(Array) && !data.empty?
+          result += data
+          offset += limit
+        else
+          not_empty = false
+        end
+      end
+      result
+    end
+
+    def paginate_with_page(&block)
+      page = 1
+      not_empty = true
+      result = []
+      while not_empty
+        data = block.call(page)
+        if data.is_a?(Array) && !data.empty?
+          result += data
+          page += 1
+        else
+          not_empty = false
+        end
+      end
+      result
+    end
+
+    def calculate_limit_and_offset(page, per)
+      page = 1 if page.to_i < 1
+      {
+        limit: per,
+        offset: (page.to_i - 1) * per.to_i
+      }
+    end
+
+    def normalize_data(data)
+      if data.is_a?(Hash)
+        return data.deep_symbolize_keys
+      end
+      if data.is_a?(Array)
+        return data.map { |item| normalize_data(item) }
+      end
+      data
+    end
+
+  end
+end

data/lib/eluvia/models/file.rb

@@ -0,0 +1,44 @@
+module Eluvia
+  class File
+    include ::ActiveModel::Model
+    include Eluvia::ActiveModel::Attributes
+    include Eluvia::AttachmentHelper
+
+    # ***********************************************************************
+    # Attributes
+    # ***********************************************************************
+
+    # MIME type of the file
+    string_attr :type
+
+    # URL to access the file
+    string_attr :url
+
+    # File name with extension
+    string_attr :filename
+
+    # Size of the file in bytes
+    integer_attr :size
+
+    # Base64 encoded content of the file, used for uploads
+    string_attr :content
+
+    # Key identifying a previously uploaded (chunked/direct) temp object, used as an alternative to
+    # `content` for finalizing large uploads via `Eluvia::Uploads.finalizer`
+    string_attr :upload_key
+
+    # ***********************************************************************
+    # Constructor from attachment
+    # ***********************************************************************
+
+    def self.from_active_storage_attachment(attachment, **options)
+      new(
+        type: attachment.content_type,
+        url: attachment_url(attachment, **options),
+        filename: attachment.filename,
+        size: attachment.byte_size
+      )
+    end
+
+  end
+end

data/lib/eluvia/models/file_wrapper.rb

@@ -0,0 +1,38 @@
+module Eluvia
+  class FileWrapper
+    include ::ActiveModel::Model
+    include Eluvia::ActiveModel::Attributes
+    include Eluvia::ActiveRecord::FileAttribute
+
+    # ***********************************************************************
+    # Attributes
+    # ***********************************************************************
+
+    file_attr :file, nature: :file, declare: true
+
+    string_attr :id
+
+    def id
+      @id ||= (self.url ? Eluvia::Uuid.str_to_uuid("File-#{self.url}") : nil)
+    end
+
+    string_attr :type
+
+    def type
+      file&.type
+    end
+
+    string_attr :url
+
+    def url
+      file&.url
+    end
+
+    string_attr :filename
+
+    def filename
+      file&.filename
+    end
+
+  end
+end

data/lib/eluvia/models/image_wrapper.rb

@@ -0,0 +1,38 @@
+module Eluvia
+  class ImageWrapper
+    include ::ActiveModel::Model
+    include Eluvia::ActiveModel::Attributes
+    include Eluvia::ActiveRecord::FileAttribute
+
+    # ***********************************************************************
+    # Attributes
+    # ***********************************************************************
+
+    file_attr :file, nature: :image, declare: true
+
+    string_attr :id
+
+    def id
+      @id ||= (self.url ? Eluvia::Uuid.str_to_uuid("Image-#{self.url}") : nil)
+    end
+
+    string_attr :type
+
+    def type
+      file&.type
+    end
+
+    string_attr :url
+
+    def url
+      file&.url
+    end
+
+    string_attr :filename
+
+    def filename
+      file&.filename
+    end
+
+  end
+end

data/lib/eluvia/serializers/error_serializer.rb

@@ -0,0 +1,21 @@
+module Eluvia
+  class ErrorSerializer
+
+    attr_reader :error
+
+    def initialize(error)
+      @error = error
+    end
+
+    def to_h
+      {
+        errors: Array.wrap(error.to_h).flatten
+      }
+    end
+
+    def to_json(_payload)
+      to_h.to_json
+    end
+
+  end
+end

data/lib/eluvia/serializers/fieldset_serializer.rb

@@ -0,0 +1,63 @@
+module Eluvia
+  module Serializers
+    module FieldsetSerializer
+
+      def serialize(record, fields: nil)
+        read_fieldset(fields).to_h do |rest_field|
+          [rest_field.name, read_attribute(record, rest_field.name)]
+        end
+      end
+
+      def read_fieldset(fields = nil)
+        @read_fieldsets ||= {}
+        @read_fieldsets[fields] ||= resolve_read_fieldset(fields)
+      end
+
+      def readable_fields
+        raise NotImplementedError, "#{self.class} must implement #readable_fields"
+      end
+
+      def default_read_fields
+        nil
+      end
+
+      def read_attribute(record, field_name)
+        raise NotImplementedError, "#{self.class} must implement #read_attribute"
+      end
+
+      private
+
+      def resolve_read_fieldset(fields)
+        readable = readable_fields.map(&:to_s)
+        defaults = (default_read_fields || readable_fields).map(&:to_s)
+
+        requested =
+          if fields.present?
+            Eluvia::Fieldset::RFS.create_from_string(fields.to_s, default_field_fieldset_string: Eluvia::Fieldset::DEFAULT_FIELDS)
+          else
+            Eluvia::Fieldset::RFS.create_from_list(defaults, default_field_fieldset_string: Eluvia::Fieldset::DEFAULT_FIELDS)
+          end
+
+        if requested.include?(Eluvia::Fieldset::ALL_FIELDS)
+          # Wildcard `__all__` replaces the whole request - anything else next to it is discarded
+          requested = Eluvia::Fieldset::RFS.create_from_list(readable, default_field_fieldset_string: Eluvia::Fieldset::ALL_FIELDS)
+        elsif requested.include?(Eluvia::Fieldset::DEFAULT_FIELDS)
+          # Wildcard `__default__` is replaced by the default fields and joined with whatever else was requested
+          requested.delete(Eluvia::Fieldset::DEFAULT_FIELDS)
+          requested |= Eluvia::Fieldset::RFS.create_from_list(defaults, default_field_fieldset_string: Eluvia::Fieldset::DEFAULT_FIELDS)
+        end
+
+        invalid_fields = requested.reject { |rf| readable.include?(rf.name) }.map(&:name)
+        if invalid_fields.any?
+          messages = invalid_fields.to_h do |field_name|
+            [field_name, I18n.t('eluvia.errors.fieldset.unknown_field', default: 'Unknown field.')]
+          end
+          raise Eluvia::Errors::UnprocessableEntity.new(messages)
+        end
+
+        requested & Eluvia::Fieldset::RFS.create_from_list(readable)
+      end
+
+    end
+  end
+end

data/lib/eluvia/services/health_service.rb

@@ -0,0 +1,56 @@
+module Eluvia
+  class HealthService
+    include Singleton
+
+    CHECKS = [:databases].freeze
+    CHECKED_DATABASES = [:default].freeze
+
+    def check
+      result_content = {}
+      result_content[:checks] = {}
+      result_ok = true
+      CHECKS.each do |check|
+        if check == :databases
+          check_content, check_ok = check_databases
+        else
+          raise Eluvia::Errors::StandardError.new("Unknown check #{check}.")
+        end
+        result_content[:checks][check] = check_content
+        result_ok &&= check_ok
+      end
+      if result_ok
+        result_content[:message] = 'I am alive.'
+      else
+        result_content[:message] = 'One of the checks failed.'
+      end
+      [result_content, result_ok]
+    end
+
+    private
+
+    def check_databases
+      result_content = []
+      result_ok = true
+      CHECKED_DATABASES.each do |database|
+        ok = check_database(database)
+        result_ok &&= ok
+        result_content << {
+          database => {
+            ok: ok
+          }
+        }
+      end
+      [result_content, result_ok]
+    end
+
+    def check_database(_database)
+
+      ::ActiveRecord::Base.connection.execute('SELECT 1')
+      true
+    rescue StandardError
+      false
+
+    end
+
+  end
+end

data/lib/eluvia/uploads.rb

@@ -0,0 +1,13 @@
+module Eluvia
+  module Uploads
+
+    # Extension point for finalizing chunked/direct uploads (identified by `Eluvia::File#upload_key`)
+    # into the underlying ActiveStorage attachment. Left unset by default so that eluvia-base has no
+    # dependency on any specific storage provider (e.g. aws-sdk-s3) or on habarico.
+    #
+    # Consumers register a callable of the form:
+    #   ->(attachment_record, upload_key, filename) { ... }
+    mattr_accessor :finalizer
+
+  end
+end