glia-errors 0.5.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf61f6be102a1651954298dacfe9e93cfeb27f81ad078e52ec7bf16542bf402b
-  data.tar.gz: 2c9d1373869e3f9525d9f01116ecff9b5a09396b855c7c8ce1e3d9fc96eb43d2
+  metadata.gz: 5c7f5990ad3700b39cf8e730592d7a0e1bb41968015c54c648f341e329679852
+  data.tar.gz: 56963475888904d6d252deb42667536caeb1a7ff96c7bbb35d5204395f60723d
 SHA512:
-  metadata.gz: ec694ade2f6c374c638832d8ad3a6d67523c218e296901b92560807dae34a29b173edc1eacde316c15c616ec063831886aec324da280b81fed6cc97840c435d4
-  data.tar.gz: d69081a24657b4647e7146d72c165e68b70698f548e7a0b2f1216ade437161a48d873a74b88adcb18f886f10d7fef4b60e0df589ce12466df707e40c7380d48f
+  metadata.gz: 7a09bd918e4be8fb7463523004703cf8d94e1a709f70f545f3b8f1d51384c5ba9a2be31c0a0b633042b9eec610003251b1fceb122d266c667ff18f4789487ef1
+  data.tar.gz: 4749bb8358fc6a1dc3f8940ae9ef5424cfdb65bef2361a529ea591890e86a8ec43a1b33207be110e7404c0ae270bd0cb197bfe11d744583ef698cce02cbbc3fe

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.7.2

data/README.md

@@ -18,7 +18,18 @@ require 'glia/errors'
 
 ### For Glia developers
 
-#### Map from `dry-validation` result
+#### Create Glia error manually
+
+1. Select error from the [error list](https://internal-docs.at.samo.io/glia-errors/elixir/api-reference.html#modules)
+  - Documentation is for Elixir, however, the errors are the same and their initiation is very similar
+2. Initialize the error according to the error documentation
+
+Example:
+```
+glia_error = Glia::Errors::ResourceNotFoundError.new(resource: :engagement)
+```
+
+#### Create Glia error from `dry-validation` result
 
 Currently 2 `dry-validation` versions are supported:
 * `v0` up to `0.13`
@@ -29,11 +40,10 @@ schema = Dry::Validation.Schema do
   # ...
 end
 result = schema.(input)
-error = Glia::Errors.from_dry_validation_result(result)
-response = error.to_h
+glia_error = Glia::Errors.from_dry_validation_result(result)
 ```
 
-#### Specifying mapping for custom error message
+#### Create Glia error from `dry-validation` that contains custom errors
 
 If you have custom `dry-validation` predicates and error messages you can specify a custom error map.
 Custom error map takes priority over standard error mapping.
@@ -46,8 +56,15 @@ ERROR_MAP = {
     Glia::Errors::InvalidFormatError.new(field: field)
   end
 }
-error = Glia::Errors.from_dry_validation_result(result, ERROR_MAP)
-response = error.to_h
+glia_error = Glia::Errors.from_dry_validation_result(result, ERROR_MAP)
+```
+
+#### Convert Glia error to a hash
+
+You can use this to convert Glia error to hash, so that later it can be converted to JSON.
+
+```ruby
+glia_error.to_h
 ```
 
 ### For REST API integrators

data/glia-errors.gemspec

@@ -5,7 +5,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = 'glia-errors'
-  spec.version       = '0.5.0'
+  spec.version       = '0.8.0'
   spec.authors       = ['Glia TechMovers']
   spec.email         = ['techmovers@glia.com']
 

data/lib/glia/errors.rb

@@ -3,6 +3,7 @@
 require_relative './errors/error'
 require_relative './errors/error_types'
 require_relative './errors/client_errors'
+require_relative './errors/server_errors'
 require_relative './errors/mapper'
 
 module Glia

data/lib/glia/errors/client_errors.rb

@@ -7,8 +7,8 @@ module Glia
       def initialize(error_details:, message: nil)
         super(
           type: INPUT_VALIDATION_ERROR,
-          ref: "https://example.com/errors/#{INPUT_VALIDATION_ERROR}.html",
-          message: message,
+          ref: create_ref(INPUT_VALIDATION_ERROR),
+          message: message || 'Input is invalid',
           error_details: error_details
         )
       end
@@ -18,8 +18,8 @@ module Glia
       def initialize(field:, message: nil)
         super(
           type: INVALID_NUMBER_ERROR,
-          ref: "https://example.com/errors/#{INVALID_NUMBER_ERROR}.html",
-          message: "#{humanize(field)} " + (message || 'is invalid')
+          ref: create_ref(INVALID_NUMBER_ERROR),
+          message: message || "#{Naming.humanize(field)} value is invalid"
         )
       end
     end
@@ -28,8 +28,8 @@ module Glia
       def initialize(field:, message: nil)
         super(
           type: INVALID_VALUE_ERROR,
-          ref: "https://example.com/errors/#{INVALID_VALUE_ERROR}.html",
-          message: "#{humanize(field)} " + (message || 'is invalid')
+          ref: create_ref(INVALID_VALUE_ERROR),
+          message: message || "#{Naming.humanize(field)} value is invalid"
         )
       end
     end
@@ -38,8 +38,8 @@ module Glia
       def initialize(field:, message: nil)
         super(
           type: INVALID_LENGTH_ERROR,
-          ref: "https://example.com/errors/#{INVALID_LENGTH_ERROR}.html",
-          message: "#{humanize(field)} " + (message || 'length is invalid')
+          ref: create_ref(INVALID_LENGTH_ERROR),
+          message: message || "#{Naming.humanize(field)} length is invalid"
         )
       end
     end
@@ -54,13 +54,34 @@ module Glia
 
       def initialize(field:, format: nil, message: nil)
         default_message =
-          format ? "has invalid format, required format is #{format}" : 'has invalid format'
+          if format
+            "has invalid format, required format is #{humanize_format(format)}"
+          else
+            'has invalid format'
+          end
         super(
           type: INVALID_FORMAT_ERROR,
-          ref: "https://example.com/errors/#{INVALID_FORMAT_ERROR}.html",
-          message: "#{humanize(field)} " + (message || default_message)
+          ref: create_ref(INVALID_FORMAT_ERROR),
+          message: message || "#{Naming.humanize(field)} #{default_message}"
         )
       end
+
+      private
+
+      def humanize_format(format)
+        case format
+        when Formats::DATE
+          'ISO-8601 date'
+        when Formats::TIME
+          'ISO-8601 time'
+        when Formats::DATE_TIME
+          'ISO-8601 date and time'
+        when Formats::UUID
+          'UUID'
+        else
+          raise 'Unexpected InvalidFormatError format'
+        end
+      end
     end
 
     class InvalidTypeError < Error
@@ -76,8 +97,9 @@ module Glia
       def initialize(field:, type:, message: nil)
         super(
           type: INVALID_TYPE_ERROR,
-          ref: "https://example.com/errors/#{INVALID_TYPE_ERROR}.html",
-          message: "#{humanize(field)} " + (message || "must be of type #{type}")
+          ref: create_ref(INVALID_TYPE_ERROR),
+          message: message || "#{Naming.humanize(field)} must be of type #{type}",
+          error_details: { type: type }
         )
       end
     end
@@ -86,8 +108,8 @@ module Glia
       def initialize(field:, message: nil)
         super(
           type: MISSING_VALUE_ERROR,
-          ref: "https://example.com/errors/#{MISSING_VALUE_ERROR}.html",
-          message: "#{humanize(field)} " + (message || 'is missing')
+          ref: create_ref(MISSING_VALUE_ERROR),
+          message: message || "#{Naming.humanize(field)} is missing"
         )
       end
     end
@@ -96,18 +118,20 @@ module Glia
       def initialize(field:, message: nil)
         super(
           type: UNKNOWN_ERROR,
-          ref: "https://example.com/errors/#{UNKNOWN_ERROR}.html",
-          message: "#{humanize(field)} " + (message || 'validation failed with unknown error')
+          ref: create_ref(UNKNOWN_ERROR),
+          message: message || "#{Naming.humanize(field)} validation failed with unknown error"
         )
       end
     end
 
     class ResourceNotFoundError < Error
       def initialize(resource:, message: nil)
+        assert_snake_case(resource)
+
         super(
           type: RESOURCE_NOT_FOUND_ERROR,
-          ref: "https://example.com/errors/#{RESOURCE_NOT_FOUND_ERROR}.html",
-          message: "#{humanize(resource)} " + (message || 'not found'),
+          ref: create_ref(RESOURCE_NOT_FOUND_ERROR),
+          message: message || "#{Naming.humanize(resource)} not found",
           error_details: { resource: resource }
         )
       end
@@ -115,10 +139,12 @@ module Glia
 
     class NotVerifiedError < Error
       def initialize(resource:, message: nil)
+        assert_snake_case(resource)
+
         super(
           type: NOT_VERIFIED_ERROR,
-          ref: "https://example.com/errors/#{NOT_VERIFIED_ERROR}.html",
-          message: "#{humanize(resource)} " + (message || 'is not verified'),
+          ref: create_ref(NOT_VERIFIED_ERROR),
+          message: message || "#{Naming.humanize(resource)} is not verified",
           error_details: { resource: resource }
         )
       end
@@ -126,25 +152,30 @@ module Glia
 
     class RemainingAssociationError < Error
       def initialize(resource:, associated_resource:, message: nil)
+        assert_snake_case(resource)
+        assert_snake_case(associated_resource)
+
         default_message =
           "cannot be modified/deleted because it is associated to one or more #{
-            humanize(associated_resource)
+            Naming.humanize(associated_resource)
           }(s)"
         super(
           type: REMAINING_ASSOCIATION_ERROR,
-          ref: "https://example.com/errors/#{REMAINING_ASSOCIATION_ERROR}.html",
-          message: "#{humanize(resource)} " + (message || default_message),
+          ref: create_ref(REMAINING_ASSOCIATION_ERROR),
+          message: message || "#{Naming.humanize(resource)} #{default_message}",
           error_details: { resource: resource, associated_resource: associated_resource }
         )
       end
     end
 
-    class LimitExceededError < Error
+    class ResourceLimitExceededError < Error
       def initialize(resource:, max:, message: nil)
+        assert_snake_case(resource)
+
         super(
           type: LIMIT_EXCEEDED_ERROR,
-          ref: "https://example.com/errors/#{LIMIT_EXCEEDED_ERROR}.html",
-          message: "#{humanize(resource)} " + (message || "count must not exceed #{max}"),
+          ref: create_ref(LIMIT_EXCEEDED_ERROR),
+          message: message || "#{Naming.humanize(resource)} count must not exceed #{max}",
           error_details: { resource: resource, max: max }
         )
       end
@@ -152,10 +183,12 @@ module Glia
 
     class ResourceAlreadyExistsError < Error
       def initialize(resource:, message: nil)
+        assert_snake_case(resource)
+
         super(
           type: RESOURCE_ALREADY_EXISTS_ERROR,
-          ref: "https://example.com/errors/#{RESOURCE_ALREADY_EXISTS_ERROR}.html",
-          message: "#{humanize(resource)} " + (message || 'already exists'),
+          ref: create_ref(RESOURCE_ALREADY_EXISTS_ERROR),
+          message: message || "#{Naming.humanize(resource)} already exists",
           error_details: { resource: resource }
         )
       end
@@ -163,10 +196,13 @@ module Glia
 
     class InvalidResourceStateError < Error
       def initialize(resource:, state:, message: nil)
+        assert_snake_case(resource)
+        assert_snake_case(state)
+
         super(
           type: INVALID_RESOURCE_STATE_ERROR,
-          ref: "https://example.com/errors/#{INVALID_RESOURCE_STATE_ERROR}.html",
-          message: "#{humanize(resource)} " + (message || "is in invalid state: #{state}"),
+          ref: create_ref(INVALID_RESOURCE_STATE_ERROR),
+          message: message || "#{Naming.humanize(resource)} is in invalid state: #{state}",
           error_details: { resource: resource, state: state }
         )
       end
@@ -176,7 +212,7 @@ module Glia
       def initialize(message: nil)
         super(
           type: AUTHORIZATION_ERROR,
-          ref: "https://example.com/errors/#{AUTHORIZATION_ERROR}.html",
+          ref: create_ref(AUTHORIZATION_ERROR),
           message: message || 'You do not have permissions to perform the action'
         )
       end
@@ -186,11 +222,31 @@ module Glia
       def initialize(message: nil)
         super(
           type: RECIPIENT_OPTED_OUT_ERROR,
-          ref: "https://example.com/errors/#{RECIPIENT_OPTED_OUT_ERROR}.html",
+          ref: create_ref(RECIPIENT_OPTED_OUT_ERROR),
           message: message || 'Recipient has opted out'
         )
       end
     end
+
+    class RouteNotFoundError < Error
+      def initialize(message: nil)
+        super(
+          type: ROUTE_NOT_FOUND_ERROR,
+          ref: create_ref(ROUTE_NOT_FOUND_ERROR),
+          message: message || 'Route not found'
+        )
+      end
+    end
+
+    class MalformedInputError < Error
+      def initialize(message: nil)
+        super(
+          type: MALFORMED_INPUT_ERROR,
+          ref: create_ref(MALFORMED_INPUT_ERROR),
+          message: message || 'Request is malformed'
+        )
+      end
+    end
     # rubocop:enable Style/Documentation
   end
 end

data/lib/glia/errors/error.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
+require_relative './naming'
+
 module Glia
   module Errors
     # Base error
     class Error
+      SNAKE_CASE_REGEX = /^[a-z0-9]+(_[a-z0-9]+)*$/.freeze
       attr_reader :type, :ref, :message, :error_details
 
       def initialize(type:, ref:, message: nil, error_details: nil)
@@ -38,13 +41,19 @@ module Glia
       end
 
       def primitive?(details)
-        details.nil? || [TrueClass, FalseClass, String, Integer, Float].include?(details.class)
+        details.nil? ||
+          [TrueClass, FalseClass, String, Integer, Float, Symbol].include?(details.class)
+      end
+
+      def assert_snake_case(value)
+        return if value.to_s.match(SNAKE_CASE_REGEX)
+
+        raise ArgumentError, "Expected '#{value}' to be in snake case"
       end
 
-      # Converts from camel_case to capitalized more human readable value
-      # first_name => "First name"
-      def humanize(value)
-        value.to_s.capitalize.gsub('_', ' ')
+      def create_ref(type)
+        fragment = type.gsub('_', '-')
+        "https://docs.glia.com/glia-dev/reference/errors##{fragment}"
       end
     end
   end

data/lib/glia/errors/error_types.rb

@@ -2,6 +2,7 @@
 
 module Glia
   module Errors
+    # Client errors
     INPUT_VALIDATION_ERROR = 'input_validation_error'
     INVALID_TYPE_ERROR = 'invalid_type_error'
     INVALID_NUMBER_ERROR = 'invalid_number_error'
@@ -18,5 +19,11 @@ module Glia
     INVALID_RESOURCE_STATE_ERROR = 'invalid_resource_state_error'
     AUTHORIZATION_ERROR = 'authorization_error'
     RECIPIENT_OPTED_OUT_ERROR = 'recipient_opted_out_error'
+    ROUTE_NOT_FOUND_ERROR = 'route_not_found_error'
+    MALFORMED_INPUT_ERROR = 'malformed_input_error'
+
+    # Server errors
+    INTERNAL_SERVER_ERROR = 'internal_server_error'
+    SERVICE_UNAVAILABLE_ERROR = 'service_unavailable_error'
   end
 end

data/lib/glia/errors/naming.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Glia
+  module Errors
+    # Utilities for variable and resouce names
+    module Naming
+      # Converts from camel_case to more human readable value
+      # first_name => "First name"
+      # site_id => "Site ID"
+      def self.humanize(value)
+        result = value.to_s.split('_').map { |word| upcase_if_abbreviation(word) }.join(' ')
+
+        upcase_first(result)
+      end
+
+      ABBREVIATIONS = %w[id uuid saml sip sms mms].freeze
+      PLURAL_ABBREVIATIONS = %w[ids uuids].freeze
+
+      private_class_method def self.upcase_if_abbreviation(value)
+        if ABBREVIATIONS.include?(value)
+          value.upcase
+        elsif PLURAL_ABBREVIATIONS.include?(value)
+          value[0..-2].upcase.concat('s')
+        else
+          value
+        end
+      end
+
+      private_class_method def self.upcase_first(value)
+        value[0].upcase.concat(value[1..-1])
+      end
+    end
+  end
+end

data/lib/glia/errors/server_errors.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Glia
+  module Errors
+    # rubocop:disable Style/Documentation
+    class InternalServerError < Error
+      def initialize(message: nil)
+        super(
+          type: INTERNAL_SERVER_ERROR,
+          ref: create_ref(INTERNAL_SERVER_ERROR),
+          message: message || 'Internal server error'
+        )
+      end
+    end
+
+    class ServiceUnavailableError < Error
+      def initialize(message: nil)
+        super(
+          type: SERVICE_UNAVAILABLE_ERROR,
+          ref: create_ref(SERVICE_UNAVAILABLE_ERROR),
+          message: message || 'Service unavailable'
+        )
+      end
+    end
+    # rubocop:enable Style/Documentation
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glia-errors
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Glia TechMovers
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-22 00:00:00.000000000 Z
+date: 2021-03-12 00:00:00.000000000 Z
 dependencies: []
 description: ''
 email:
@@ -22,6 +22,7 @@ files:
 - ".prettierrc"
 - ".rspec"
 - ".rubocop.yml"
+- ".ruby-version"
 - ".travis.yml"
 - Appraisals
 - Gemfile
@@ -36,6 +37,8 @@ files:
 - lib/glia/errors/error.rb
 - lib/glia/errors/error_types.rb
 - lib/glia/errors/mapper.rb
+- lib/glia/errors/naming.rb
+- lib/glia/errors/server_errors.rb
 homepage:
 licenses:
 - MIT
@@ -55,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: Glia REST API errors