glia-errors 0.0.0

data/lib/glia/errors.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative './errors/error'
+require_relative './errors/error_types'
+require_relative './errors/validation_errors'
+require_relative './errors/mapper'
+
+module Glia
+  # Glia REST API errors
+  module Errors
+    def self.from_dry_validation_result(result, custom_error_map = {})
+      dry_validation_version = Gem.loaded_specs['dry-validation'].version
+      if dry_validation_version < Gem::Version.new('1.0')
+        Mapper.from_dry_validation_result(result.output, result.messages, custom_error_map)
+      elsif dry_validation_version <= Gem::Version.new('1.6')
+        Mapper.from_dry_validation_result(result.to_h, result.errors.to_h, custom_error_map)
+      else
+        raise 'Unsupported dry-validation version'
+      end
+    end
+  end
+end

data/lib/glia/errors/error.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Glia
+  module Errors
+    # Base error
+    class Error
+      attr_reader :type, :ref, :message, :error_details
+
+      def initialize(type:, ref:, message: nil, error_details: nil)
+        @type = type
+        @ref = ref
+        @message = message
+        @error_details = error_details
+      end
+
+      def to_h
+        {
+          type: type, ref: ref, message: message, error_details: error_details_to_h(@error_details)
+        }.compact
+      end
+
+      private
+
+      def error_details_to_h(details)
+        return details if primitive?(details)
+
+        if details.is_a?(Hash)
+          details.keys.each_with_object({}) do |field, hash|
+            hash[field] = error_details_to_h(details[field])
+          end
+        elsif details.is_a?(Array)
+          details.map { |error| error_details_to_h(error) }
+        elsif details.respond_to?(:to_h)
+          details.to_h
+        else
+          raise ArgumentError, "Unsupported details type: #{details.class}"
+        end
+      end
+
+      def primitive?(details)
+        details.nil? || [TrueClass, FalseClass, String, Integer, Float].include?(details.class)
+      end
+
+      # Converts from camel_case to capitalized more human readable value
+      # first_name => "First name"
+      def humanize(value)
+        value.to_s.capitalize.gsub('_', ' ')
+      end
+    end
+  end
+end

data/lib/glia/errors/error_types.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Glia
+  module Errors
+    INPUT_VALIDATION_ERROR = 'input_validation_error'
+    INVALID_TYPE_ERROR = 'invalid_type_error'
+    INVALID_NUMBER_ERROR = 'invalid_number_error'
+    INVALID_VALUE_ERROR = 'invalid_value_error'
+    INVALID_FORMAT_ERROR = 'invalid_format_error'
+    INVALID_LENGTH_ERROR = 'invalid_length_error'
+    MISSING_VALUE_ERROR = 'missing_value_error'
+    UNKNOWN_ERROR = 'unknown_error'
+  end
+end

data/lib/glia/errors/mapper.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Glia
+  module Errors
+    # Maps library specific errors to Glia public errors
+    module Mapper
+      INVALID_TYPE_ERROR =
+        lambda do |field, _value, message|
+          type =
+            case message
+            when 'must be an array'
+              InvalidTypeError::Types::ARRAY
+            when 'must be an integer'
+              InvalidTypeError::Types::INTEGER
+            when 'must be a number', 'must be a float', 'must be a decimal'
+              InvalidTypeError::Types::NUMBER
+            when 'must be a hash'
+              InvalidTypeError::Types::OBJECT
+            when 'must be boolean'
+              InvalidTypeError::Types::BOOLEAN
+            when 'must be a string'
+              InvalidTypeError::Types::STRING
+            end
+          InvalidTypeError.new(field: field, type: type)
+        end
+
+      INVALID_FORMAT_ERROR = ->(field, _value, _message) { InvalidFormatError.new(field: field) }
+      INVALID_UUID_ERROR =
+        lambda do |field, _value, _message|
+          InvalidFormatError.new(field: field, format: InvalidFormatError::Formats::UUID)
+        end
+      INVALID_NUMBER_ERROR = ->(field, _value, _message) { InvalidNumberError.new(field: field) }
+      INVALID_VALUE_ERROR = ->(field, _value, _message) { InvalidValueError.new(field: field) }
+      INVALID_LENGTH_ERROR = ->(field, _value, _message) { InvalidLengthError.new(field: field) }
+      MISSING_VALUE_ERROR = ->(field, _value, _message) { MissingValueError.new(field: field) }
+
+      # dry-validation shares the same message for `eql?` validation for string and number,
+      # so we are separating them ourselves
+      INVALID_NUMBER_OR_VALUE_ERROR =
+        lambda do |field, value, _message|
+          if value.is_a?(String)
+            InvalidValueError.new(field: field)
+          else
+            InvalidNumberError.new(field: field)
+          end
+        end
+
+      # dry-validation will return `must be a date/time` even if we provide a number or boolean,
+      # in which case `invalid_format_error` does not make sense, so instead we will return `invalid_type_error`
+      INVALID_DATE_FORMAT_OR_TYPE_ERROR =
+        lambda do |field, value, message|
+          if value.is_a?(String)
+            format =
+              case message
+              when 'must be a date'
+                InvalidFormatError::Formats::DATE
+              when 'must be a date time'
+                InvalidFormatError::Formats::DATE_TIME
+              when 'must be a time'
+                InvalidFormatError::Formats::TIME
+              end
+            InvalidFormatError.new(field: field, format: format)
+          else
+            InvalidTypeError.new(field: field, type: InvalidTypeError::Types::STRING)
+          end
+        end
+
+      ERROR_MAP = {
+        # InvalidTypeError
+        'must be an array' => INVALID_TYPE_ERROR,
+        'must be an integer' => INVALID_TYPE_ERROR,
+        'must be a number' => INVALID_TYPE_ERROR,
+        'must be a float' => INVALID_TYPE_ERROR,
+        'must be a decimal' => INVALID_TYPE_ERROR,
+        'must be a hash' => INVALID_TYPE_ERROR,
+        'must be boolean' => INVALID_TYPE_ERROR,
+        'must be a string' => INVALID_TYPE_ERROR,
+        'must be a date time' => INVALID_DATE_FORMAT_OR_TYPE_ERROR,
+        'must be a date' => INVALID_DATE_FORMAT_OR_TYPE_ERROR,
+        'must be a time' => INVALID_DATE_FORMAT_OR_TYPE_ERROR,
+        # InvalidFormatError
+        'is in invalid format' => INVALID_FORMAT_ERROR,
+        'is not a valid UUID' => INVALID_UUID_ERROR,
+        # InvalidNumberError
+        'must be less than' => INVALID_NUMBER_ERROR,
+        'must be less than or equal to' => INVALID_NUMBER_ERROR,
+        'must be greater than' => INVALID_NUMBER_ERROR,
+        'must be greater than or equal to' => INVALID_NUMBER_ERROR,
+        'must be even' => INVALID_NUMBER_ERROR,
+        'must be odd' => INVALID_NUMBER_ERROR,
+        # InvalidValueError
+        'must be true' => INVALID_VALUE_ERROR,
+        'must be false' => INVALID_VALUE_ERROR,
+        'must include' => INVALID_VALUE_ERROR,
+        'must not include' => INVALID_VALUE_ERROR,
+        'must be empty' => INVALID_VALUE_ERROR,
+        'must be filled' => INVALID_VALUE_ERROR,
+        'cannot be empty' => INVALID_VALUE_ERROR,
+        'cannot be defined' => INVALID_VALUE_ERROR,
+        # InvalidNumberError or InvalidValueError
+        'must be equal to' => INVALID_NUMBER_OR_VALUE_ERROR,
+        'must not be equal to' => INVALID_NUMBER_OR_VALUE_ERROR,
+        'must be one of' => INVALID_NUMBER_OR_VALUE_ERROR,
+        'must not be one of' => INVALID_NUMBER_OR_VALUE_ERROR,
+        # InvalidLengthError
+        'size cannot be greater than' => INVALID_LENGTH_ERROR,
+        'size cannot be less than' => INVALID_LENGTH_ERROR,
+        'size must be' => INVALID_LENGTH_ERROR,
+        'size must be within' => INVALID_LENGTH_ERROR,
+        'bytesize cannot be less than' => INVALID_LENGTH_ERROR,
+        'bytesize cannot be greater than' => INVALID_LENGTH_ERROR,
+        'bytes long' => INVALID_LENGTH_ERROR,
+        'length must be' => INVALID_LENGTH_ERROR,
+        'length must be within' => INVALID_LENGTH_ERROR,
+        # MissingValueError
+        'is missing' => MISSING_VALUE_ERROR,
+        # Custom format errors
+        'must be in E.164 format' => INVALID_FORMAT_ERROR,
+        'must be up to 7-digit string' => INVALID_FORMAT_ERROR,
+        'must be a valid email' => INVALID_FORMAT_ERROR
+      }.freeze
+
+      def self.from_dry_validation_result(output, messages, custom_error_map = {})
+        error_map = ERROR_MAP.merge(custom_error_map)
+        from_dry_validation_result_rec(output, messages, error_map)
+      end
+
+      def self.from_dry_validation_result_rec(output, messages, error_map)
+        error_details =
+          messages.keys.each_with_object({}) do |field, acc|
+            field_messages = messages[field]
+            field_value = output[field]
+            acc[field] =
+              if field_messages.is_a?(Hash)
+                from_dry_validation_result_rec(field_value, field_messages, error_map)
+              else
+                field_messages.map do |message|
+                  from_dry_validation_error(field, field_value, message, error_map)
+                end
+              end
+          end
+        InputValidationError.new(error_details: error_details)
+      end
+
+      def self.from_dry_validation_error(field, value, message, error_map)
+        key = error_map.keys.find { |k| message.include?(k) }
+        error_or_func = error_map[key]
+        if error_or_func.nil?
+          UnknownError.new(field: field)
+        elsif error_or_func.respond_to?(:call)
+          error_or_func.call(field, value, message)
+        else
+          error_or_func
+        end
+      end
+    end
+  end
+end

data/lib/glia/errors/validation_errors.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Glia
+  module Errors
+    # InputValidationError
+    class InputValidationError < Error
+      def initialize(error_details:, message: nil)
+        super(
+          type: INPUT_VALIDATION_ERROR,
+          ref: "https://example.com/errors/#{INPUT_VALIDATION_ERROR}.html",
+          message: message,
+          error_details: error_details
+        )
+      end
+    end
+
+    # InvalidNumberError
+    class InvalidNumberError < Error
+      def initialize(field:)
+        super(
+          type: INVALID_NUMBER_ERROR,
+          ref: "https://example.com/errors/#{INVALID_NUMBER_ERROR}.html",
+          message: "#{humanize(field)} is invalid"
+        )
+      end
+    end
+
+    # InvalidValueError
+    class InvalidValueError < Error
+      def initialize(field:)
+        super(
+          type: INVALID_VALUE_ERROR,
+          ref: "https://example.com/errors/#{INVALID_VALUE_ERROR}.html",
+          message: "#{humanize(field)} is invalid"
+        )
+      end
+    end
+
+    # InvalidLengthError
+    class InvalidLengthError < Error
+      def initialize(field:)
+        super(
+          type: INVALID_LENGTH_ERROR,
+          ref: "https://example.com/errors/#{INVALID_LENGTH_ERROR}.html",
+          message: "#{humanize(field)} length is invalid"
+        )
+      end
+    end
+
+    # InvalidFormatError
+    class InvalidFormatError < Error
+      class Formats
+        DATE_TIME = 'date_time'
+        DATE = 'date'
+        TIME = 'time'
+        UUID = 'uuid'
+      end
+
+      def initialize(field:, format: nil)
+        super(
+          type: INVALID_FORMAT_ERROR,
+          ref: "https://example.com/errors/#{INVALID_FORMAT_ERROR}.html",
+          message:
+            if format
+              "#{humanize(field)} has invalid format, required format is #{format}"
+            else
+              "#{humanize(field)} has invalid format"
+            end
+        )
+      end
+    end
+
+    # InvalidTypeError
+    class InvalidTypeError < Error
+      class Types
+        STRING = 'string'
+        INTEGER = 'integer'
+        NUMBER = 'number'
+        BOOLEAN = 'boolean'
+        ARRAY = 'array'
+        OBJECT = 'object'
+      end
+
+      def initialize(field:, type:)
+        super(
+          type: INVALID_TYPE_ERROR,
+          ref: "https://example.com/errors/#{INVALID_TYPE_ERROR}.html",
+          message: "#{humanize(field)} must be of type #{type}"
+        )
+      end
+    end
+
+    # MissingValueError
+    class MissingValueError < Error
+      def initialize(field:)
+        super(
+          type: MISSING_VALUE_ERROR,
+          ref: "https://example.com/errors/#{MISSING_VALUE_ERROR}.html",
+          message: "#{humanize(field)} is missing"
+        )
+      end
+    end
+
+    # UnknownError
+    class UnknownError < Error
+      def initialize(field:)
+        super(
+          type: UNKNOWN_ERROR,
+          ref: "https://example.com/errors/#{UNKNOWN_ERROR}.html",
+          message: "#{humanize(field)} validation failed with unknown error"
+        )
+      end
+    end
+  end
+end

data/test_cases/invalid_format_error_case.json

@@ -0,0 +1,74 @@
+{
+  "input": {
+    "invalid_format_abc_regex": "defg",
+    "invalid_format_date": "not date",
+    "invalid_format_date_time": "not date time",
+    "invalid_format_time": "not time",
+    "invalid_format_uuid": "not uuid",
+    "invalid_format_e164": "not phone number",
+    "invalid_format_phone_extension": "not phone extension",
+    "invalid_format_email": "not email"
+  },
+  "expectation": {
+    "type": "input_validation_error",
+    "ref": "https://example.com/errors/input_validation_error.html",
+    "error_details": {
+      "invalid_format_abc_regex": [
+        {
+          "type": "invalid_format_error",
+          "ref": "https://example.com/errors/invalid_format_error.html",
+          "message": "Invalid format abc regex has invalid format"
+        }
+      ],
+      "invalid_format_date": [
+        {
+          "type": "invalid_format_error",
+          "ref": "https://example.com/errors/invalid_format_error.html",
+          "message": "Invalid format date has invalid format, required format is date"
+        }
+      ],
+      "invalid_format_date_time": [
+        {
+          "type": "invalid_format_error",
+          "ref": "https://example.com/errors/invalid_format_error.html",
+          "message": "Invalid format date time has invalid format, required format is date_time"
+        }
+      ],
+      "invalid_format_time": [
+        {
+          "type": "invalid_format_error",
+          "ref": "https://example.com/errors/invalid_format_error.html",
+          "message": "Invalid format time has invalid format, required format is time"
+        }
+      ],
+      "invalid_format_uuid": [
+        {
+          "type": "invalid_format_error",
+          "ref": "https://example.com/errors/invalid_format_error.html",
+          "message": "Invalid format uuid has invalid format, required format is uuid"
+        }
+      ],
+      "invalid_format_e164": [
+        {
+          "type": "invalid_format_error",
+          "ref": "https://example.com/errors/invalid_format_error.html",
+          "message": "Invalid format e164 has invalid format"
+        }
+      ],
+      "invalid_format_phone_extension": [
+        {
+          "type": "invalid_format_error",
+          "ref": "https://example.com/errors/invalid_format_error.html",
+          "message": "Invalid format phone extension has invalid format"
+        }
+      ],
+      "invalid_format_email": [
+        {
+          "type": "invalid_format_error",
+          "ref": "https://example.com/errors/invalid_format_error.html",
+          "message": "Invalid format email has invalid format"
+        }
+      ]
+    }
+  }
+}

data/test_cases/invalid_length_error_case.json

@@ -0,0 +1,106 @@
+{
+  "input": {
+    "invalid_length_array_max_length_3": [1, 2, 3, 4],
+    "invalid_length_array_min_length_3": [1, 2],
+    "invalid_length_array_exact_length_3": [1, 2],
+    "invalid_length_array_range_length_1_2": [1, 2, 3],
+    "invalid_length_string_max_length_3": "abcd",
+    "invalid_length_string_min_length_3": "ab",
+    "invalid_length_string_exact_length_3": "ab",
+    "invalid_length_string_range_length_1_2": "abc",
+    "invalid_length_string_max_bytesize_3": "abcd",
+    "invalid_length_string_min_bytesize_3": "a",
+    "invalid_length_string_exact_bytesize_3": "ab",
+    "invalid_length_string_range_bytesize_1_2": "abc"
+  },
+  "expectation": {
+    "type": "input_validation_error",
+    "ref": "https://example.com/errors/input_validation_error.html",
+    "error_details": {
+      "invalid_length_array_max_length_3": [
+        {
+          "type": "invalid_length_error",
+          "ref": "https://example.com/errors/invalid_length_error.html",
+          "message": "Invalid length array max length 3 length is invalid"
+        }
+      ],
+      "invalid_length_array_min_length_3": [
+        {
+          "type": "invalid_length_error",
+          "ref": "https://example.com/errors/invalid_length_error.html",
+          "message": "Invalid length array min length 3 length is invalid"
+        }
+      ],
+      "invalid_length_array_exact_length_3": [
+        {
+          "type": "invalid_length_error",
+          "ref": "https://example.com/errors/invalid_length_error.html",
+          "message": "Invalid length array exact length 3 length is invalid"
+        }
+      ],
+      "invalid_length_array_range_length_1_2": [
+        {
+          "type": "invalid_length_error",
+          "ref": "https://example.com/errors/invalid_length_error.html",
+          "message": "Invalid length array range length 1 2 length is invalid"
+        }
+      ],
+      "invalid_length_string_max_length_3": [
+        {
+          "type": "invalid_length_error",
+          "ref": "https://example.com/errors/invalid_length_error.html",
+          "message": "Invalid length string max length 3 length is invalid"
+        }
+      ],
+      "invalid_length_string_min_length_3": [
+        {
+          "type": "invalid_length_error",
+          "ref": "https://example.com/errors/invalid_length_error.html",
+          "message": "Invalid length string min length 3 length is invalid"
+        }
+      ],
+      "invalid_length_string_exact_length_3": [
+        {
+          "type": "invalid_length_error",
+          "ref": "https://example.com/errors/invalid_length_error.html",
+          "message": "Invalid length string exact length 3 length is invalid"
+        }
+      ],
+      "invalid_length_string_range_length_1_2": [
+        {
+          "type": "invalid_length_error",
+          "ref": "https://example.com/errors/invalid_length_error.html",
+          "message": "Invalid length string range length 1 2 length is invalid"
+        }
+      ],
+      "invalid_length_string_max_bytesize_3": [
+        {
+          "type": "invalid_length_error",
+          "ref": "https://example.com/errors/invalid_length_error.html",
+          "message": "Invalid length string max bytesize 3 length is invalid"
+        }
+      ],
+      "invalid_length_string_min_bytesize_3": [
+        {
+          "type": "invalid_length_error",
+          "ref": "https://example.com/errors/invalid_length_error.html",
+          "message": "Invalid length string min bytesize 3 length is invalid"
+        }
+      ],
+      "invalid_length_string_exact_bytesize_3": [
+        {
+          "type": "invalid_length_error",
+          "ref": "https://example.com/errors/invalid_length_error.html",
+          "message": "Invalid length string exact bytesize 3 length is invalid"
+        }
+      ],
+      "invalid_length_string_range_bytesize_1_2": [
+        {
+          "type": "invalid_length_error",
+          "ref": "https://example.com/errors/invalid_length_error.html",
+          "message": "Invalid length string range bytesize 1 2 length is invalid"
+        }
+      ]
+    }
+  }
+}