glia-errors 0.3.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71d9c420c3a6350067f4f47cba98ebb07598c203951106c743e8d245938e4fb5
-  data.tar.gz: 2d74dd1fbe3272416010b8ee66b698484002baaf9f2786efde680d6a6292150e
+  metadata.gz: f938565ae0608918f0808c950e1d2621f7d8ef2d347cb9146a37fc1af461a519
+  data.tar.gz: 7d8d9672987fe83c77884532e052adee18e3e980462176b6482dd1a41fb755ec
 SHA512:
-  metadata.gz: 23120c8979c3ad4b4a9524a9ac61deb2a2452f8c44cd79a059099b201e5cc8e07357e102a20c74c2e1716e22154ce930096be2e8d45ceafa1006aacb643a28c6
-  data.tar.gz: 9f0848627646f37ee78b24cd3bf3dea1b193e5541f5302782ce891727cfaeb82b502a56103350de43e41ad284340f8e2cf8848d88febf00b30c1492f7bc74b65
+  metadata.gz: f09300cb765f7ce0fe8d57cce7f8259303acd5dec9ffd61a36307ba0afb9d89c17ca95eb8010526a442ab0028da8fc9c61821f7fbe3cd5727c5d0df2a33e3821
+  data.tar.gz: 8208ee1f6c9e00975df486a1d8fb3f1457f38a576970f15485191f9639340b0ff5247dbcf527f2474ef1f0696ff519994985e9917c91949c33c9e6bcbc9a3c42

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
@@ -62,7 +79,6 @@ url = URI('https://api.glia.com/engagement_requests')
 
 http = Net::HTTP.new(url.host, url.port)
 http.use_ssl = true
-http.verify_mode = OpenSSL::SSL::VERIFY_NONE
 request = Net::HTTP::Post.new(url)
 request["Accept"] = 'application/json'
 request["Content-Type"] = 'application/json'

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.3.0'
+  spec.version       = '0.7.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 || "#{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 || "#{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 || "#{humanize(field)} length is invalid"
         )
       end
     end
@@ -57,8 +57,8 @@ module Glia
           format ? "has invalid format, required format is #{format}" : 'has invalid format'
         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 || "#{humanize(field)} #{default_message}"
         )
       end
     end
@@ -76,8 +76,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 || "#{humanize(field)} must be of type #{type}",
+          error_details: { type: type }
         )
       end
     end
@@ -86,8 +87,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 || "#{humanize(field)} is missing"
         )
       end
     end
@@ -96,18 +97,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 || "#{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 || "#{humanize(resource)} not found",
           error_details: { resource: resource }
         )
       end
@@ -115,10 +118,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 || "#{humanize(resource)} is not verified",
           error_details: { resource: resource }
         )
       end
@@ -126,14 +131,17 @@ 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)
           }(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 || "#{humanize(resource)} #{default_message}",
           error_details: { resource: resource, associated_resource: associated_resource }
         )
       end
@@ -141,10 +149,12 @@ module Glia
 
     class LimitExceededError < 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 || "#{humanize(resource)} count must not exceed #{max}",
           error_details: { resource: resource, max: max }
         )
       end
@@ -152,10 +162,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 || "#{humanize(resource)} already exists",
           error_details: { resource: resource }
         )
       end
@@ -163,14 +175,37 @@ 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 || "#{humanize(resource)} is in invalid state: #{state}",
           error_details: { resource: resource, state: state }
         )
       end
     end
+
+    class AuthorizationError < Error
+      def initialize(message: nil)
+        super(
+          type: AUTHORIZATION_ERROR,
+          ref: create_ref(AUTHORIZATION_ERROR),
+          message: message || 'You do not have permissions to perform the action'
+        )
+      end
+    end
+
+    class RecipientOptedOutError < Error
+      def initialize(message: nil)
+        super(
+          type: RECIPIENT_OPTED_OUT_ERROR,
+          ref: create_ref(RECIPIENT_OPTED_OUT_ERROR),
+          message: message || 'Recipient has opted out'
+        )
+      end
+    end
     # rubocop:enable Style/Documentation
   end
 end

data/lib/glia/errors/error.rb

@@ -4,6 +4,7 @@ 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,7 +39,8 @@ 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
 
       # Converts from camel_case to capitalized more human readable value
@@ -46,6 +48,17 @@ module Glia
       def humanize(value)
         value.to_s.capitalize.gsub('_', ' ')
       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
+
+      def create_ref(type)
+        fragment = type.gsub('_', '-')
+        "https://docs.glia.com/glia-dev/reference/errors##{fragment}"
+      end
     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'
@@ -16,5 +17,11 @@ module Glia
     LIMIT_EXCEEDED_ERROR = 'limit_exceeded_error'
     RESOURCE_ALREADY_EXISTS_ERROR = 'resource_already_exists_error'
     INVALID_RESOURCE_STATE_ERROR = 'invalid_resource_state_error'
+    AUTHORIZATION_ERROR = 'authorization_error'
+    RECIPIENT_OPTED_OUT_ERROR = 'recipient_opted_out_error'
+
+    # Server errors
+    INTERNAL_SERVER_ERROR = 'internal_server_error'
+    SERVICE_UNAVAILABLE_ERROR = 'service_unavailable_error'
   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.3.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Glia TechMovers
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-02 00:00:00.000000000 Z
+date: 2021-03-05 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,7 @@ files:
 - lib/glia/errors/error.rb
 - lib/glia/errors/error_types.rb
 - lib/glia/errors/mapper.rb
+- lib/glia/errors/server_errors.rb
 homepage:
 licenses:
 - MIT
@@ -55,7 +57,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: Glia REST API errors