convenient_service 0.12.0 → 0.14.0

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module V1
+        class RequestParams
+          module Entities
+            ##
+            # TODO: https://ruby-doc.org/3.1.3/stdlibs/yaml/YAML/DBM.html
+            #
+            class ID
+              def initialize(value:)
+                @value = value
+              end
+
+              class << self
+                def cast(value)
+                  case value
+                  when ::String, ::Integer
+                    new(value: value.to_s)
+                  end
+                end
+              end
+
+              def ==(other)
+                return unless other.instance_of?(self.class)
+
+                value == other.value
+              end
+
+              def to_i
+                value.to_i
+              end
+
+              def to_s
+                value
+              end
+
+              protected
+
+              attr_reader :value
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module V1
+        class RequestParams
+          module Entities
+            class Logger
+              class << self
+                def log(message, out: $stdout)
+                  out.puts message
+
+                  message
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module V1
+        class RequestParams
+          module Entities
+            class Request
+              attr_reader :http_string
+
+              def initialize(http_string:)
+                @http_string = http_string
+              end
+
+              def to_s
+                http_string
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module V1
+        class RequestParams
+          module Entities
+            class Source
+              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
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module V1
+        class 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
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module V1
+        class 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
+end

data/lib/convenient_service/examples/standard/v1/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/v1/request_params/services/apply_default_param_values.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module V1
+        class RequestParams
+          module Services
+            class ApplyDefaultParamValues
+              include ConvenientService::Standard::V1::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
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module V1
+        class RequestParams
+          module Services
+            class CastParams
+              include ConvenientService::Standard::V1::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
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module V1
+        class RequestParams
+          module Services
+            class ExtractParamsFromBody
+              include ConvenientService::Standard::V1::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
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module V1
+        class RequestParams
+          module Services
+            class ExtractParamsFromPath
+              include ConvenientService::Standard::V1::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
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module V1
+        class RequestParams
+          module Services
+            class FilterOutUnpermittedParams
+              include ConvenientService::Standard::V1::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
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module V1
+        class RequestParams
+          module Services
+            class LogRequestParams
+              include ConvenientService::Standard::V1::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
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module V1
+        class RequestParams
+          module Services
+            class MergeParams
+              include ConvenientService::Standard::V1::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
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module V1
+        class RequestParams
+          module Services
+            class Prepare
+              include ConvenientService::Standard::V1::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
+end