convenient_service 0.5.0 → 0.6.0

data/lib/convenient_service/examples/standard/request_params/services/extract_params_from_body.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Services
+          class ExtractParamsFromBody
+            include ConvenientService::Standard::Config
+
+            attr_reader :request
+
+            step :parse_body, in: :request, out: :body
+            step :parse_json, in: :body, out: :json
+            step :extract_params, in: :json, out: :params
+            step :symbolize_keys, in: :params, out: reassign(:params)
+
+            def initialize(request:)
+              @request = request
+            end
+
+            private
+
+            def parse_body
+              body = Utils::HTTP::Request.parse_body(request.to_s)
+
+              return success(body: body) if body
+
+              error(
+                <<~MESSAGE
+                  Failed to resolve body since request is NOT HTTP parsable.
+
+                  Request:
+                  ---
+                  #{request}
+                  ---
+                MESSAGE
+              )
+            end
+
+            def parse_json
+              json = Utils::JSON.safe_parse(body)
+
+              return success(json: json) if json
+
+              error(
+                <<~MESSAGE
+                  Request body contains invalid json.
+
+                  Request:
+                  ---
+                  #{request}
+                  ---
+                MESSAGE
+              )
+            end
+
+            def extract_params
+              success(params: json)
+            end
+
+            def symbolize_keys
+              success(params: params.transform_keys(&:to_sym))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/services/extract_params_from_path.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Services
+          class ExtractParamsFromPath
+            include ConvenientService::Standard::Config
+
+            attr_reader :request, :pattern
+
+            step :parse_path, in: :request, out: :path
+            step :match_pattern, in: [:path, :pattern], out: :match_data
+            step :extract_params, in: :match_data, out: :params
+
+            def initialize(request:, pattern:)
+              @request = request
+              @pattern = pattern
+            end
+
+            private
+
+            def parse_path
+              path = Utils::HTTP::Request.parse_path(request.to_s)
+
+              return success(path: path) if path
+
+              error(
+                <<~MESSAGE
+                  Failed to resolve path since request is NOT HTTP parsable.
+
+                  Request:
+                  ---
+                  #{request}
+                  ---
+                MESSAGE
+              )
+            end
+
+            def match_pattern
+              match_data = path.match(pattern)
+
+              return success(match_data: match_data) if match_data
+
+              error("Path `#{path}` does NOT match pattern `#{pattern}`.")
+            end
+
+            def extract_params
+              params = {
+                id: match_data[:id],
+                format: match_data[:format]
+              }
+
+              success(params: params)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/services/filter_out_unpermitted_params.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Services
+          class FilterOutUnpermittedParams
+            include ConvenientService::Standard::Config
+
+            attr_reader :params, :permitted_keys
+
+            def initialize(params:, permitted_keys:)
+              @params = params
+              @permitted_keys = permitted_keys
+            end
+
+            def result
+              success(params: params.slice(*permitted_keys))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/services/log_request_params.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Services
+          class LogRequestParams
+            include ConvenientService::Standard::Config
+
+            attr_reader :request, :params, :tag
+
+            def initialize(request:, params:, tag: Constants::Tags::EMPTY)
+              @request = request
+              @params = params
+              @tag = tag
+            end
+
+            def result
+              Entities::Logger.log(message)
+
+              success
+            end
+
+            private
+
+            def message
+              <<~MESSAGE
+                #{prefix}:
+                {
+                #{content}
+                }
+              MESSAGE
+            end
+
+            def prefix
+              text = "[Thread##{Thread.current.object_id}]"
+
+              text += " [Request##{request.object_id}]"
+              text += " [Params]"
+              text += " [#{tag}]" unless tag.empty?
+
+              text
+            end
+
+            def content
+              params.map { |key, value| "  #{key}: #{value.inspect}" }.join(",\n")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/services/merge_params.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Services
+          class MergeParams
+            include ConvenientService::Standard::Config
+
+            attr_reader :params_from_path, :params_from_body
+
+            def initialize(params_from_path:, params_from_body:)
+              @params_from_path = params_from_path
+              @params_from_body = params_from_body
+            end
+
+            def result
+              success(params: params_from_path.merge(params_from_body))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/services/prepare.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Services
+          class Prepare
+            include ConvenientService::Standard::Config
+
+            attr_reader :request
+
+            step Services::ExtractParamsFromPath, \
+              in: [:request, {pattern: raw(/^\/rules\/(?<id>\d+)\.(?<format>\w+)$/)}],
+              out: {params: :params_from_path}
+
+            step Services::ExtractParamsFromBody, \
+              in: :request,
+              out: {params: :params_from_body}
+
+            step Services::MergeParams, \
+              in: [:params_from_path, :params_from_body],
+              out: :params
+
+            step Services::LogRequestParams, \
+              in: [:request, :params, tag: raw("Uncasted")]
+
+            step Services::FilterOutUnpermittedParams, \
+              in: [:params, {permitted_keys: raw([:id, :format, :title, :description, :tags, :sources])}],
+              out: reassign(:params)
+
+            step Services::ApplyDefaultParamValues, \
+              in: [:params, defaults: raw({format: "json", tags: [], sources: []})],
+              out: reassign(:params)
+
+            step Services::ValidateUncastedParams, \
+              in: :params
+
+            step Services::CastParams, \
+              in: :params,
+              out: [:original_params, {casted_params: reassign(:params)}]
+
+            step Services::LogRequestParams, \
+              in: [:request, :params, tag: raw("Casted")]
+
+            step Services::ValidateCastedParams, \
+              in: [:original_params, {casted_params: :params}]
+
+            step :result, \
+              in: :params,
+              out: reassign(:params)
+
+            def initialize(request:)
+              @request = request
+            end
+
+            def result
+              success(params: params)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/services/validate_casted_params.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Services
+          class ValidateCastedParams
+            include ConvenientService::Standard::Config
+
+            attr_reader \
+              :original_id,
+              :original_format,
+              :original_title,
+              :original_description,
+              :original_tags,
+              :original_sources
+
+            attr_reader \
+              :casted_id,
+              :casted_format,
+              :casted_title,
+              :casted_description,
+              :casted_tags,
+              :casted_sources
+
+            step :validate_id, in: [:original_id, :casted_id]
+            step :validate_format, in: [:original_format, :casted_format]
+            step :validate_title, in: [:original_title, :casted_title]
+            step :validate_description, in: [:original_description, :casted_description]
+            step :validate_tags, in: [:original_tags, :casted_tags]
+            step :validate_sources, in: [:original_sources, :casted_sources]
+
+            def initialize(original_params:, casted_params:)
+              @original_id = original_params[:id]
+              @original_format = original_params[:format]
+              @original_title = original_params[:title]
+              @original_description = original_params[:description]
+              @original_tags = original_params[:tags]
+              @original_sources = original_params[:sources]
+
+              @casted_id = casted_params[:id]
+              @casted_format = casted_params[:format]
+              @casted_title = casted_params[:title]
+              @casted_description = casted_params[:description]
+              @casted_tags = casted_params[:tags]
+              @casted_sources = casted_params[:sources]
+            end
+
+            private
+
+            def validate_id
+              return error("Failed to cast `#{original_id.inspect}` into `ID`") unless casted_id
+
+              success
+            end
+
+            def validate_format
+              return error("Failed to cast `#{original_format.inspect}` into `Format`") unless casted_format
+
+              success
+            end
+
+            def validate_title
+              return error("Failed to cast `#{original_title.inspect}` into `Title`") unless casted_title
+
+              success
+            end
+
+            def validate_description
+              return error("Failed to cast `#{original_description.inspect}` into `Description`") unless casted_description
+
+              success
+            end
+
+            ##
+            # TODO:
+            #
+            def validate_tags
+              success
+            end
+
+            ##
+            # TODO:
+            #
+            def validate_sources
+              success
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/services/validate_uncasted_params.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Services
+          class ValidateUncastedParams
+            include ConvenientService::Standard::Config
+
+            attr_reader :id, :format, :title, :description, :tags, :sources
+
+            step :validate_id, in: :id
+            step :validate_format, in: :format
+            step :validate_title, in: :title
+            step :validate_description, in: :description
+
+            def initialize(params:)
+              @id = params[:id]
+              @format = params[:format]
+              @title = params[:title]
+              @description = params[:description]
+              @tags = params[:tags]
+              @sources = params[:sources]
+            end
+
+            private
+
+            def validate_id
+              return error("ID is NOT present") if Utils::Object.present?(id)
+              return error("ID `#{id}` is NOT a valid integer") unless Utils::Integer.safe_parse(id)
+
+              success
+            end
+
+            def validate_format
+              return error("Format `#{format}` is NOT supported, only JSON is allowed") if format != "json"
+
+              success
+            end
+
+            def validate_title
+              return error("Title is NOT present") if Utils::Object.present?(title)
+
+              success
+            end
+
+            def validate_description
+              return error("Description is NOT present") if Utils::Object.present?(description)
+
+              success
+            end
+
+            ##
+            # TODO:
+            #
+            def validate_tags
+              success
+            end
+
+            ##
+            # TODO:
+            #
+            def validate_sources
+              success
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/services.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "services/apply_default_param_values"
+require_relative "services/cast_params"
+require_relative "services/extract_params_from_body"
+require_relative "services/extract_params_from_path"
+require_relative "services/filter_out_unpermitted_params"
+require_relative "services/log_request_params"
+require_relative "services/merge_params"
+require_relative "services/validate_casted_params"
+require_relative "services/validate_uncasted_params"
+
+require_relative "services/prepare"

data/lib/convenient_service/examples/standard/request_params/utils/array/wrap.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Utils
+          module Array
+            class Wrap < Support::Command
+              ##
+              # @!attribute [r] pad
+              #   @return [Object] Can be any type.
+              #
+              attr_reader :object
+
+              ##
+              # @param object [Object] Can be any type.
+              # @return [void]
+              #
+              def initialize(object)
+                @object = object
+              end
+
+              ##
+              # @return [Array]
+              #
+              # @internal
+              #   Copied without any modifications from:
+              #   https://api.rubyonrails.org/classes/Array.html#method-c-wrap
+              #
+              def call
+                if object.nil?
+                  []
+                elsif object.respond_to?(:to_ary)
+                  object.to_ary || [object]
+                else
+                  [object]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/utils/array.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "array/wrap"
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Utils
+          module Array
+            class << self
+              def wrap(object)
+                Wrap.call(object)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/utils/http/request/parse_body.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Utils
+          module HTTP
+            module Request
+              ##
+              # TODO: Specs.
+              #
+              class ParseBody < Support::Command
+                attr_reader :http_string
+
+                def initialize(http_string:)
+                  @http_string = http_string
+                end
+
+                ##
+                # IMPORTANT: Make sure length is set in `http_string`.
+                #
+                # - https://stackoverflow.com/a/17599778/12201472
+                # - https://github.com/ruby/webrick/blob/v1.7.0/lib/webrick/httprequest.rb
+                #
+                def call
+                  webrick_request = ::WEBrick::HTTPRequest.new(::WEBrick::Config::HTTP)
+
+                  webrick_request.parse(::StringIO.new(http_string))
+
+                  webrick_request.body
+                rescue ::WEBrick::HTTPStatus::BadRequest
+                  nil
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/utils/http/request/parse_path.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Utils
+          module HTTP
+            module Request
+              ##
+              # TODO: Specs.
+              #
+              class ParsePath < Support::Command
+                attr_reader :http_string
+
+                def initialize(http_string:)
+                  @http_string = http_string
+                end
+
+                ##
+                # - https://stackoverflow.com/a/17599778/12201472
+                # - https://github.com/ruby/webrick/blob/v1.7.0/lib/webrick/httprequest.rb
+                #
+                def call
+                  webrick_request = ::WEBrick::HTTPRequest.new(::WEBrick::Config::HTTP)
+
+                  webrick_request.parse(::StringIO.new(http_string))
+
+                  webrick_request.path
+                rescue ::WEBrick::HTTPStatus::BadRequest
+                  nil
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/utils/http/request.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "request/parse_body"
+require_relative "request/parse_path"
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Utils
+          module HTTP
+            module Request
+              class << self
+                def parse_body(http_string)
+                  ParseBody.call(http_string: http_string)
+                end
+
+                def parse_path(http_string)
+                  ParsePath.call(http_string: http_string)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/utils/http.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "http/request"