glia-errors 0.6.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65d627db5f7496b55539268de587762316d8d138ea0548ecd7abb5c7968fb4b1
-  data.tar.gz: f0894efd36f5e3013d9f3892e922ea5b7007e3a271595a262e9e97534d90923f
+  metadata.gz: 110bf7c1b2d1b5855f92c842563f59fe6b93157b5bee67af2e446b212dc2b108
+  data.tar.gz: e99a9338aa7995f17865a25ac6dc4c60fbfc0aa883d507add47043b0ec9f448a
 SHA512:
-  metadata.gz: 03af1bfefb0087f78f4ddfabe4575980167f03df92fc0aba83052a1aaed18a936b60b53b3d442deb1676f85007b47a9c86772f0581fc63e425417ec3c22235d7
-  data.tar.gz: dac6e22cc50535689a445ae0616c73b362bfdf75af9daf81c4d11f54034f7233da72e3bf00f1c4a203e649227b223e2d37025db91aa83d8e3dd22ca8474b1be3
+  metadata.gz: 74b6285d294a404baa2d59e3406d1f021c2319aab4bb73f7f4cda571dce46eb55250347bfd8c66dddab43404357c5e6a6c996a1bc936857498f3b148e50c185a
+  data.tar.gz: 96ef53cbee527e3e64606223c81a0335954a40187bd830231fc0d07160ce82554894c2be1d38e51cc2f271c661affd301b0640ac4b3339045574c4c944d02170

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.6.0'
+  spec.version       = '0.10.1'
   spec.authors       = ['Glia TechMovers']
   spec.email         = ['techmovers@glia.com']
 

data/lib/glia/errors/client_errors.rb

@@ -5,10 +5,16 @@ module Glia
     # rubocop:disable Style/Documentation
     class InputValidationError < Error
       def initialize(error_details:, message: nil)
+        raise ArgumentError, 'At least 1 error detail is required' if error_details.keys.count.zero?
+
+        error_details.each_value do |value|
+          raise ArgumentError, 'error_details values must be lists' unless value.is_a?(Array)
+        end
+
         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 +24,8 @@ module Glia
       def initialize(field:, message: nil)
         super(
           type: INVALID_NUMBER_ERROR,
-          ref: "https://example.com/errors/#{INVALID_NUMBER_ERROR}.html",
-          message: message || "#{humanize(field)} value is invalid"
+          ref: create_ref(INVALID_NUMBER_ERROR),
+          message: message || "#{Naming.humanize(field)} value is invalid"
         )
       end
     end
@@ -28,8 +34,8 @@ module Glia
       def initialize(field:, message: nil)
         super(
           type: INVALID_VALUE_ERROR,
-          ref: "https://example.com/errors/#{INVALID_VALUE_ERROR}.html",
-          message: message || "#{humanize(field)} value is invalid"
+          ref: create_ref(INVALID_VALUE_ERROR),
+          message: message || "#{Naming.humanize(field)} value is invalid"
         )
       end
     end
@@ -38,8 +44,8 @@ module Glia
       def initialize(field:, message: nil)
         super(
           type: INVALID_LENGTH_ERROR,
-          ref: "https://example.com/errors/#{INVALID_LENGTH_ERROR}.html",
-          message: message || "#{humanize(field)} length is invalid"
+          ref: create_ref(INVALID_LENGTH_ERROR),
+          message: message || "#{Naming.humanize(field)} length is invalid"
         )
       end
     end
@@ -54,13 +60,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: message || "#{humanize(field)} #{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 +103,8 @@ module Glia
       def initialize(field:, type:, message: nil)
         super(
           type: INVALID_TYPE_ERROR,
-          ref: "https://example.com/errors/#{INVALID_TYPE_ERROR}.html",
-          message: message || "#{humanize(field)} 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
@@ -87,30 +114,35 @@ module Glia
       def initialize(field:, message: nil)
         super(
           type: MISSING_VALUE_ERROR,
-          ref: "https://example.com/errors/#{MISSING_VALUE_ERROR}.html",
-          message: message || "#{humanize(field)} is missing"
+          ref: create_ref(MISSING_VALUE_ERROR),
+          message: message || "#{Naming.humanize(field)} is missing"
         )
       end
     end
 
     class UnknownError < Error
-      def initialize(field:, message: nil)
+      def initialize(field: nil, message: nil)
         super(
           type: UNKNOWN_ERROR,
-          ref: "https://example.com/errors/#{UNKNOWN_ERROR}.html",
-          message: message || "#{humanize(field)} validation failed with unknown error"
+          ref: create_ref(UNKNOWN_ERROR),
+          message:
+            if field
+              message || "#{Naming.humanize(field)} validation failed with unknown error"
+            else
+              message || 'Failed with unknown error'
+            end
         )
       end
     end
 
     class ResourceNotFoundError < Error
       def initialize(resource:, message: nil)
-        assert_snake_case(resource)
+        Naming.assert_snake_case(resource)
 
         super(
           type: RESOURCE_NOT_FOUND_ERROR,
-          ref: "https://example.com/errors/#{RESOURCE_NOT_FOUND_ERROR}.html",
-          message: message || "#{humanize(resource)} not found",
+          ref: create_ref(RESOURCE_NOT_FOUND_ERROR),
+          message: message || "#{Naming.humanize(resource)} not found",
           error_details: { resource: resource }
         )
       end
@@ -118,12 +150,12 @@ module Glia
 
     class NotVerifiedError < Error
       def initialize(resource:, message: nil)
-        assert_snake_case(resource)
+        Naming.assert_snake_case(resource)
 
         super(
           type: NOT_VERIFIED_ERROR,
-          ref: "https://example.com/errors/#{NOT_VERIFIED_ERROR}.html",
-          message: message || "#{humanize(resource)} is not verified",
+          ref: create_ref(NOT_VERIFIED_ERROR),
+          message: message || "#{Naming.humanize(resource)} is not verified",
           error_details: { resource: resource }
         )
       end
@@ -131,30 +163,30 @@ module Glia
 
     class RemainingAssociationError < Error
       def initialize(resource:, associated_resource:, message: nil)
-        assert_snake_case(resource)
-        assert_snake_case(associated_resource)
+        Naming.assert_snake_case(resource)
+        Naming.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: message || "#{humanize(resource)} #{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)
+        Naming.assert_snake_case(resource)
 
         super(
           type: LIMIT_EXCEEDED_ERROR,
-          ref: "https://example.com/errors/#{LIMIT_EXCEEDED_ERROR}.html",
-          message: message || "#{humanize(resource)} 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
@@ -162,12 +194,12 @@ module Glia
 
     class ResourceAlreadyExistsError < Error
       def initialize(resource:, message: nil)
-        assert_snake_case(resource)
+        Naming.assert_snake_case(resource)
 
         super(
           type: RESOURCE_ALREADY_EXISTS_ERROR,
-          ref: "https://example.com/errors/#{RESOURCE_ALREADY_EXISTS_ERROR}.html",
-          message: message || "#{humanize(resource)} already exists",
+          ref: create_ref(RESOURCE_ALREADY_EXISTS_ERROR),
+          message: message || "#{Naming.humanize(resource)} already exists",
           error_details: { resource: resource }
         )
       end
@@ -175,13 +207,13 @@ module Glia
 
     class InvalidResourceStateError < Error
       def initialize(resource:, state:, message: nil)
-        assert_snake_case(resource)
-        assert_snake_case(state)
+        Naming.assert_snake_case(resource)
+        Naming.assert_snake_case(state)
 
         super(
           type: INVALID_RESOURCE_STATE_ERROR,
-          ref: "https://example.com/errors/#{INVALID_RESOURCE_STATE_ERROR}.html",
-          message: message || "#{humanize(resource)} 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
@@ -191,7 +223,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
@@ -201,12 +233,120 @@ module Glia
       def initialize(message: nil)
         super(
           type: RECIPIENT_OPTED_OUT_ERROR,
-          ref:
-            'https://docs.glia.com/glia-dev/reference/webhooks#example-engagementrequestfailure-event-with-fail_error',
+          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
+
+    class CarrierError < Error
+      def initialize(message: nil)
+        super(
+          type: CARRIER_ERROR,
+          ref: create_ref(CARRIER_ERROR),
+          message: message || 'Downstream carrier issue occurred'
+        )
+      end
+    end
+
+    class GeographicPermissionError < Error
+      def initialize(message: nil)
+        super(
+          type: GEOGRAPHIC_PERMISSION_ERROR,
+          ref: create_ref(GEOGRAPHIC_PERMISSION_ERROR),
+          message: message || 'Insufficient permissions for geographic region'
+        )
+      end
+    end
+
+    class MessageBlockedError < Error
+      def initialize(message: nil)
+        super(
+          type: MESSAGE_BLOCKED_ERROR,
+          ref: create_ref(MESSAGE_BLOCKED_ERROR),
+          message: message || 'Message blocked or filtered'
+        )
+      end
+    end
+
+    class TelephonyProviderRateLimitExceededError < Error
+      def initialize(message: nil)
+        super(
+          type: TELEPHONY_PROVIDER_RATE_LIMIT_EXCEEDED_ERROR,
+          ref: create_ref(TELEPHONY_PROVIDER_RATE_LIMIT_EXCEEDED_ERROR),
+          message: message || 'Telephony provider message send rate limit exceeded'
+        )
+      end
+    end
+
+    class TelephonyProviderQueueLimitExceededError < Error
+      def initialize(message: nil)
+        super(
+          type: TELEPHONY_PROVIDER_QUEUE_LIMIT_EXCEEDED_ERROR,
+          ref: create_ref(TELEPHONY_PROVIDER_QUEUE_LIMIT_EXCEEDED_ERROR),
+          message: message || 'Telephony provider message send queue is full'
+        )
+      end
+    end
+
+    class TwilioMessagingServiceConfigurationError < Error
+      def initialize(message: nil)
+        super(
+          type: TWILIO_MESSAGING_SERVICE_CONFIGURATION_ERROR,
+          ref: create_ref(TWILIO_MESSAGING_SERVICE_CONFIGURATION_ERROR),
+          message: message || 'Invalid Twilio Messaging Service configuration'
+        )
+      end
+    end
+
+    class UnreachableDestinationError < Error
+      def initialize(message: nil)
+        super(
+          type: UNREACHABLE_DESTINATION_ERROR,
+          ref: create_ref(UNREACHABLE_DESTINATION_ERROR),
+          message: message || 'Destination is unreachable'
+        )
+      end
+    end
+
+    class HeadersValidationError < Error
+      def initialize(error_details:, message: nil)
+        raise ArgumentError, 'At least 1 error detail is required' if error_details.keys.count.zero?
+
+        error_details.each_value do |value|
+          raise ArgumentError, 'error_details values must be lists' unless value.is_a?(Array)
+        end
+
+        error_details.each_key { |key| Naming.assert_header(key) }
+
+        super(
+          type: HEADERS_VALIDATION_ERROR,
+          ref: create_ref(HEADERS_VALIDATION_ERROR),
+          message: message || 'Headers are invalid',
+          error_details: error_details
+        )
+      end
+    end
     # rubocop:enable Style/Documentation
   end
 end

data/lib/glia/errors/error.rb

@@ -1,10 +1,11 @@
 # 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)
@@ -39,19 +40,13 @@ module Glia
       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('_', ' ')
+        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"
+      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

@@ -19,6 +19,16 @@ 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'
+    CARRIER_ERROR = 'carrier_error'
+    GEOGRAPHIC_PERMISSION_ERROR = 'geographic_permission_error'
+    MESSAGE_BLOCKED_ERROR = 'message_blocked_error'
+    TELEPHONY_PROVIDER_RATE_LIMIT_EXCEEDED_ERROR = 'telephony_provider_rate_limit_exceeded_error'
+    TELEPHONY_PROVIDER_QUEUE_LIMIT_EXCEEDED_ERROR = 'telephony_provider_queue_limit_exceeded_error'
+    TWILIO_MESSAGING_SERVICE_CONFIGURATION_ERROR = 'twilio_messaging_service_configuration_error'
+    UNREACHABLE_DESTINATION_ERROR = 'unreachable_destination_error'
+    HEADERS_VALIDATION_ERROR = 'headers_validation_error'
 
     # Server errors
     INTERNAL_SERVER_ERROR = 'internal_server_error'

data/lib/glia/errors/naming.rb

@@ -0,0 +1,50 @@
+# 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
+
+      SNAKE_CASE_REGEX = /\A[a-z0-9]+(_[a-z0-9]+)*\z/.freeze
+
+      def self.assert_snake_case(value)
+        return if value.to_s.match(SNAKE_CASE_REGEX)
+
+        raise ArgumentError, "Expected '#{value}' to be in snake case"
+      end
+
+      HEADER_REGEX = /\A[A-Z0-9]+[a-z0-9]*(-[A-Z0-9]+[a-zz0-9]*)*\z/.freeze
+
+      def self.assert_header(value)
+        return if value.to_s.match(HEADER_REGEX)
+
+        raise ArgumentError, "Expected '#{value}' to be a valid header"
+      end
+    end
+  end
+end

data/lib/glia/errors/server_errors.rb

@@ -7,7 +7,7 @@ module Glia
       def initialize(message: nil)
         super(
           type: INTERNAL_SERVER_ERROR,
-          ref: "https://example.com/errors/#{INTERNAL_SERVER_ERROR}.html",
+          ref: create_ref(INTERNAL_SERVER_ERROR),
           message: message || 'Internal server error'
         )
       end
@@ -17,7 +17,7 @@ module Glia
       def initialize(message: nil)
         super(
           type: SERVICE_UNAVAILABLE_ERROR,
-          ref: "https://example.com/errors/#{SERVICE_UNAVAILABLE_ERROR}.html",
+          ref: create_ref(SERVICE_UNAVAILABLE_ERROR),
           message: message || 'Service unavailable'
         )
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glia-errors
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Glia TechMovers
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-04 00:00:00.000000000 Z
+date: 2021-03-31 00:00:00.000000000 Z
 dependencies: []
 description: ''
 email:
@@ -37,6 +37,7 @@ 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: