glia-errors 0.0.1 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8336fd0b3da25f1ce3dd3e6b2f61ad4b9e736f391088e1824f6427b5619498b2
-  data.tar.gz: 79481e2446fb498d3f606c118fcbfb2e50df1e16e559e8136bd8a30c5cc84109
+  metadata.gz: d9f3f981c61ebf8676c66ee15e0b326d052978374f8099574d8f84370247e834
+  data.tar.gz: a4d50d5aabad297607ef9a8c3f2fef743ba1620212cde790e95547ee9559216d
 SHA512:
-  metadata.gz: 4ea9ab4f9b4e101ea50eb9813a28cc0ff0d221056447e91660e927d3579b531aafb8a1718706ca51ffb09c9bd2556c90c259670590d416b6e602cbbdbcc89389
-  data.tar.gz: e83dede85cf3a57e01066970fbfc653fd28414624fda32173b9397691338c8d5e32a200a4e3f4e36eb0d8f480e97bbab7d0588dc7cc50978c0a1cf9cc8a4e93e
+  metadata.gz: fcf46277d4d7f2368999acab163f89e192d76ca0db527e94c39fdbcefe6b4bdf83dd2e6a116eef2eb2568e0a4d005f86dc06729925aa50b1dc9e050564d62093
+  data.tar.gz: '04281d7946a62f546d3a2e4474336289a83142a2283a622a3abe13988f3d29bf24b66ff1e9aba02a5ce1043cd5232fc262138d1ee061a283e6d4b31a1f13ad98'

data/.ruby-version

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

data/Gemfile

@@ -2,7 +2,7 @@
 
 source 'https://rubygems.org'
 
-gem 'prettier', '~> 0.21'
+gem 'prettier', '~> 0.22'
 gem 'rake', '~> 13.0'
 gem 'rspec', '~> 3.10'
 gem 'rubocop', '~> 1.5'

data/Gemfile.lock

@@ -13,7 +13,7 @@ GEM
       ast (~> 2.4.1)
     patience_diff (1.1.0)
       trollop (~> 1.16)
-    prettier (0.21.0)
+    prettier (0.22.0)
     rainbow (3.0.0)
     rake (13.0.1)
     regexp_parser (2.0.0)
@@ -58,10 +58,11 @@ GEM
 
 PLATFORMS
   ruby
+  x86_64-darwin-19
 
 DEPENDENCIES
   appraisal
-  prettier (~> 0.21)
+  prettier (~> 0.22)
   rake (~> 13.0)
   rspec (~> 3.10)
   rubocop (~> 1.5)

data/README.md

@@ -1,25 +1,24 @@
-# glia-errors-ruby
-Glia REST API errors (WIP)
+# glia-errors
 
-[![Build Status](https://travis-ci.org/salemove/glia-errors-ruby.svg?branch=master)](https://travis-ci.org/salemove/glia-errors-ruby)
+Implements Glia errors in Ruby and provides utilities to easily construct them.
 
-The library provides a list of errors that are used in Glia REST API and utilities to easily construct them.
+# Installation
 
-It is used by Glia developers to map application specific errors to one of standardized Glia errors.
-Glia REST API integrators can use the library as a collection of constants to match Glia error response with the error
-type, see the example below.
+```
+$ gem install glia-errors
+```
 
-# Usage
+## Usage
 
-## Require library
+### Require library
 
 ```ruby
 require 'glia/errors'
 ```
 
-## For Glia developers
+### For Glia developers
 
-### Map from `dry-validation` result
+#### Map from `dry-validation` result
 
 Currently 2 `dry-validation` versions are supported:
 * `v0` up to `0.13`
@@ -51,7 +50,7 @@ error = Glia::Errors.from_dry_validation_result(result, ERROR_MAP)
 response = error.to_h
 ```
 
-## For REST API integrators
+### For REST API integrators
 
 ```ruby
 require 'uri'
@@ -63,7 +62,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'
@@ -91,9 +89,9 @@ else
 end
 ```
 
-# Contributing
+## Contributing
 
-## Testing
+### Testing
 
 Glia errors support multiple versions of `dry-validation` and tests are run against each supported major version.
 Under the hood we use `Appraisal` gem which generals additional gemfiles for each of the versions.
@@ -116,7 +114,7 @@ To run tests only for `dry-validation` v0:
 bundle exec rake test_dry_validation_v0
 ```
 
-## Formatting
+### Formatting
 
 ```
 bundle exec rake format

data/gemfiles/dry_validation_v0.gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "prettier", "~> 0.21"
+gem "prettier", "~> 0.22"
 gem "rake", "~> 13.0"
 gem "rspec", "~> 3.10"
 gem "rubocop", "~> 1.5"

data/gemfiles/dry_validation_v1.gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "prettier", "~> 0.21"
+gem "prettier", "~> 0.22"
 gem "rake", "~> 13.0"
 gem "rspec", "~> 3.10"
 gem "rubocop", "~> 1.5"

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

data/lib/glia/errors.rb

@@ -2,7 +2,8 @@
 
 require_relative './errors/error'
 require_relative './errors/error_types'
-require_relative './errors/validation_errors'
+require_relative './errors/client_errors'
+require_relative './errors/server_errors'
 require_relative './errors/mapper'
 
 module Glia

data/lib/glia/errors/client_errors.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module Glia
+  module Errors
+    # rubocop:disable Style/Documentation
+    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
+
+    class InvalidNumberError < Error
+      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"
+        )
+      end
+    end
+
+    class InvalidValueError < Error
+      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"
+        )
+      end
+    end
+
+    class InvalidLengthError < Error
+      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"
+        )
+      end
+    end
+
+    class InvalidFormatError < Error
+      class Formats
+        DATE_TIME = 'date_time'
+        DATE = 'date'
+        TIME = 'time'
+        UUID = 'uuid'
+      end
+
+      def initialize(field:, format: nil, message: nil)
+        default_message =
+          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: message || "#{humanize(field)} #{default_message}"
+        )
+      end
+    end
+
+    class InvalidTypeError < Error
+      class Types
+        STRING = 'string'
+        INTEGER = 'integer'
+        NUMBER = 'number'
+        BOOLEAN = 'boolean'
+        ARRAY = 'array'
+        OBJECT = 'object'
+      end
+
+      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}",
+          error_details: { type: type }
+        )
+      end
+    end
+
+    class MissingValueError < Error
+      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"
+        )
+      end
+    end
+
+    class UnknownError < Error
+      def initialize(field:, message: nil)
+        super(
+          type: UNKNOWN_ERROR,
+          ref: "https://example.com/errors/#{UNKNOWN_ERROR}.html",
+          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: message || "#{humanize(resource)} not found",
+          error_details: { resource: resource }
+        )
+      end
+    end
+
+    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: message || "#{humanize(resource)} is not verified",
+          error_details: { resource: resource }
+        )
+      end
+    end
+
+    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: message || "#{humanize(resource)} #{default_message}",
+          error_details: { resource: resource, associated_resource: associated_resource }
+        )
+      end
+    end
+
+    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: message || "#{humanize(resource)} count must not exceed #{max}",
+          error_details: { resource: resource, max: max }
+        )
+      end
+    end
+
+    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: message || "#{humanize(resource)} already exists",
+          error_details: { resource: resource }
+        )
+      end
+    end
+
+    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: 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: "https://example.com/errors/#{AUTHORIZATION_ERROR}.html",
+          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:
+            'https://docs.glia.com/glia-dev/reference/webhooks#example-engagementrequestfailure-event-with-fail_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,12 @@ 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
     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'
@@ -10,5 +11,17 @@ module Glia
     INVALID_LENGTH_ERROR = 'invalid_length_error'
     MISSING_VALUE_ERROR = 'missing_value_error'
     UNKNOWN_ERROR = 'unknown_error'
+    RESOURCE_NOT_FOUND_ERROR = 'resource_not_found_error'
+    NOT_VERIFIED_ERROR = 'not_verified_error'
+    REMAINING_ASSOCIATION_ERROR = 'remaining_association_error'
+    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/mapper.rb

@@ -46,24 +46,18 @@ module Glia
           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', 'must be Date'
-                InvalidFormatError::Formats::DATE
-              when 'must be a date time', 'must be DateTime'
-                InvalidFormatError::Formats::DATE_TIME
-              when 'must be a time', 'must be Time'
-                InvalidFormatError::Formats::TIME
-              end
-            InvalidFormatError.new(field: field, format: format)
-          else
-            InvalidTypeError.new(field: field, type: InvalidTypeError::Types::STRING)
-          end
+      INVALID_DATE_FORMAT =
+        lambda do |field, _value, message|
+          format =
+            case message
+            when 'must be a date', 'must be Date'
+              InvalidFormatError::Formats::DATE
+            when 'must be a date time', 'must be DateTime'
+              InvalidFormatError::Formats::DATE_TIME
+            when 'must be a time', 'must be Time'
+              InvalidFormatError::Formats::TIME
+            end
+          InvalidFormatError.new(field: field, format: format)
         end
 
       ERROR_MAP = {
@@ -83,13 +77,13 @@ module Glia
         'must be Boolean' => INVALID_TYPE_ERROR,
         'must be a string' => INVALID_TYPE_ERROR,
         'must be String' => INVALID_TYPE_ERROR,
-        'must be a date time' => INVALID_DATE_FORMAT_OR_TYPE_ERROR,
-        'must be DateTime' => INVALID_DATE_FORMAT_OR_TYPE_ERROR,
-        'must be a date' => INVALID_DATE_FORMAT_OR_TYPE_ERROR,
-        'must be Date' => INVALID_DATE_FORMAT_OR_TYPE_ERROR,
-        'must be a time' => INVALID_DATE_FORMAT_OR_TYPE_ERROR,
-        'must be Time' => INVALID_DATE_FORMAT_OR_TYPE_ERROR,
         # InvalidFormatError
+        'must be a date time' => INVALID_DATE_FORMAT,
+        'must be DateTime' => INVALID_DATE_FORMAT,
+        'must be a date' => INVALID_DATE_FORMAT,
+        'must be Date' => INVALID_DATE_FORMAT,
+        'must be a time' => INVALID_DATE_FORMAT,
+        'must be Time' => INVALID_DATE_FORMAT,
         'is in invalid format' => INVALID_FORMAT_ERROR,
         'is not a valid UUID' => INVALID_UUID_ERROR,
         # InvalidNumberError
@@ -104,9 +98,11 @@ module Glia
         '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,
+        'must be filled' =>
+          lambda do |field, value, _message|
+            # Consider `nil` as invalid value error, but empty string or array as invalid length error
+            value.nil? ? InvalidValueError.new(field: field) : InvalidLengthError.new(field: field)
+          end,
         'cannot be defined' => INVALID_VALUE_ERROR,
         # InvalidNumberError or InvalidValueError
         'must be equal to' => INVALID_NUMBER_OR_VALUE_ERROR,
@@ -123,6 +119,8 @@ module Glia
         'bytes long' => INVALID_LENGTH_ERROR,
         'length must be' => INVALID_LENGTH_ERROR,
         'length must be within' => INVALID_LENGTH_ERROR,
+        'must be empty' => INVALID_LENGTH_ERROR,
+        'cannot be empty' => INVALID_LENGTH_ERROR,
         # MissingValueError
         'is missing' => MISSING_VALUE_ERROR,
         # Custom format errors