convenient_service 0.5.0 → 0.7.0

data/lib/convenient_service/examples/standard/request_params/entities/tag.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Entities
+          class Tag
+            def initialize(value:)
+              @value = value
+            end
+
+            class << self
+              def cast(value)
+                case value
+                when ::String
+                  new(value: value.to_s)
+                end
+              end
+            end
+
+            def ==(other)
+              return unless other.instance_of?(self.class)
+
+              value == other.value
+            end
+
+            def to_s
+              value
+            end
+
+            protected
+
+            attr_reader :value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/entities/title.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Entities
+          class Title
+            def initialize(value:)
+              @value = value
+            end
+
+            class << self
+              def cast(value)
+                case value
+                when ::String
+                  new(value: value.to_s)
+                end
+              end
+            end
+
+            def ==(other)
+              return unless other.instance_of?(self.class)
+
+              value == other.value
+            end
+
+            def to_s
+              value
+            end
+
+            protected
+
+            attr_reader :value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "entities/logger"
+require_relative "entities/request"
+
+require_relative "entities/description"
+require_relative "entities/format"
+require_relative "entities/id"
+require_relative "entities/source"
+require_relative "entities/tag"
+require_relative "entities/title"

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

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

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Services
+          class CastParams
+            include ConvenientService::Standard::Config
+
+            attr_reader :params
+
+            def initialize(params:)
+              @params = params
+            end
+
+            def result
+              success(original_params: params, casted_params: casted_params)
+            end
+
+            private
+
+            def casted_params
+              {
+                id: Entities::ID.cast(params[:id]),
+                format: Entities::Format.cast(params[:format]),
+                title: Entities::Title.cast(params[:title]),
+                description: Entities::Description.cast(params[:description]),
+                tags: Utils::Array.wrap(params[:tags]).map { |tag| Entities::Tag.cast(tag) },
+                sources: Utils::Array.wrap(params[:sources]).map { |source| Entities::Source.cast(source) }
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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