ree_lib 1.0.36 → 1.0.37

data/lib/ree_lib/packages/ree_roda/package/ree_roda/plugins/ree_actions.rb

@@ -0,0 +1,150 @@
+class Roda
+  module RodaPlugins
+    module ReeActions
+      def self.load_dependencies(app, opts = {})
+        package_require("ree_roda/services/build_swagger_from_actions")
+        package_require("ree_json/functions/to_json")
+        package_require("ree_hash/functions/transform_values")
+        package_require("ree_object/functions/not_blank")
+
+        app.plugin :all_verbs
+      end
+
+      def self.configure(app, opts = {})
+        app.opts[:ree_actions_before] = opts[:before] if opts[:before]
+      end
+
+      module ClassMethods
+        def ree_actions(actions, swagger_title: "", swagger_description: "",
+                        swagger_version: "", swagger_url: "", api_url: "")
+          @ree_actions ||= []
+          @ree_actions += actions
+
+          opts[:ree_actions_swagger_title] = swagger_title
+          opts[:ree_actions_swagger_description] = swagger_description
+          opts[:ree_actions_swagger_version] = swagger_version
+          opts[:ree_actions_swagger_url] = swagger_url
+          opts[:ree_actions_api_url] = api_url
+
+          opts[:ree_actions_swagger] = ReeRoda::BuildSwaggerFromActions.new.call(
+            @ree_actions,
+            opts[:ree_actions_swagger_title],
+            opts[:ree_actions_swagger_description],
+            opts[:ree_actions_swagger_version],
+            opts[:ree_actions_api_url]
+          )
+
+          build_actions_proc
+          nil
+        end
+
+        private
+
+        def build_actions_proc
+          list = []
+          context = self
+
+          return list if @ree_actions.nil? || @ree_actions.empty?
+
+          if context.opts[:ree_actions_swagger_url]
+            list << Proc.new do |r|
+              r.get context.opts[:ree_actions_swagger_url] do
+                r.json do
+                  response.status = 200
+                  ReeJson::ToJson.new.call(context.opts[:ree_actions_swagger])
+                end
+              end
+            end
+          end
+
+          @ree_actions.each do |action|
+            route = []
+            route_args = []
+
+            action.path.split("/").each do |part|
+              if part.start_with?(":")
+                route << String
+                route_args << part.gsub(":", "")
+              else
+                route << part
+              end
+            end
+
+            list << Proc.new do |r|
+              r.send(action.request_method, *route) do |*args|
+                r.send(action.respond_to) do
+                  env["warden"].authenticate!(scope: action.warden_scope)
+
+                  if context.opts[:ree_actions_before]
+                    self.instance_exec(@_request, action.warden_scope, &scope.opts[:ree_actions_before])
+                  end
+
+                  # TODO: implement me when migration to roda DSL happens
+                  # if action.before; end
+
+                  route_args.each_with_index do |arg, index|
+                    r.params["#{arg}"] = args[index]
+                  end
+
+                  params = r.params
+
+                  if r.body
+                    body = begin
+                      JSON.parse(r.body.read)
+                    rescue => e
+                      {}
+                    end
+
+                    params = params.merge(body)
+                  end
+
+                  not_blank = ReeObject::NotBlank.new
+
+                  filtered_params = ReeHash::TransformValues.new.call(params) do |k, v|
+                    v.is_a?(Array) ? v.select { not_blank.call(_1) } : v
+                  end
+
+                  accessor = env["warden"].user(action.warden_scope)
+                  action_result = action.action.klass.new.call(accessor, filtered_params)
+
+                  if action.serializer
+                    serialized_result = action.serializer.klass.new.serialize(action_result)
+                  else
+                    serialized_result = {}
+                  end
+
+                  case action.request_method
+                  when :post
+                    response.status = 201
+                    ReeJson::ToJson.new.call(serialized_result)
+                  when :put, :delete, :patch
+                    response.status = 204
+                    ""
+                  else
+                    response.status = 200
+                    ReeJson::ToJson.new.call(serialized_result)
+                  end
+                end
+              end
+            end
+          end
+
+          opts[:ree_actions_proc]  = list
+        end
+      end
+
+      module RequestMethods
+        def ree_actions
+          if scope.opts[:ree_actions_proc]
+            scope.opts[:ree_actions_proc].each do |request_proc|
+              self.instance_exec(self, &request_proc)
+            end
+          end
+          nil
+        end
+      end
+    end
+
+    register_plugin(:ree_actions, Roda::RodaPlugins::ReeActions)
+  end
+end

data/lib/ree_lib/packages/ree_roda/package/ree_roda/plugins/ree_logger.rb

@@ -0,0 +1,66 @@
+package_require "ree_logger/beans/logger"
+
+class Roda
+  module RodaPlugins
+    # The ree_logger plugin adds ReeLogger support to Roda
+    #
+    # Example:
+    #
+    #   plugin :ree_logger
+    #   plugin :ree_logger, log_params: true, filter: -> { request.path.include?("health") }
+    module ReeLogger
+      REE_LOGGER_DEFAULTS = {
+        method: :info,
+        log_params: true
+      }
+
+      def self.configure(app, **opts)
+        opts = REE_LOGGER_DEFAULTS.merge(opts)
+        app.opts[:ree_logger] = ::ReeLogger::Logger.new
+        app.opts[:ree_logger_filter] = opts[:filter] if opts[:filter]
+        app.opts[:ree_logger_log_params] = !!opts[:log_params]
+      end
+
+      def self.start_timer
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      module InstanceMethods
+        private
+
+        # Log request/response information in common log format to logger.
+        def _roda_after_90__ree_logger(result)
+          return unless result && result[0] && result[1]
+
+          if opts[:ree_logger_filter]
+            return if self.instance_exec(&opts[:ree_logger_filter])
+          end
+
+          elapsed_time = if timer = @_request_timer
+            "%0.4f" % (ReeLogger.start_timer - timer)
+          else
+            "-"
+          end
+
+          env = @_request.env
+
+          message = <<~DOC
+            Request/Response details:
+              Request: #{env["REQUEST_METHOD"]} #{env["QUERY_STRING"] && !env["QUERY_STRING"].empty? ? env["SCRIPT_NAME"].to_s + env["PATH_INFO"] + "?#{env["QUERY_STRING"]}": env["SCRIPT_NAME"].to_s + env["PATH_INFO"]} #{opts[:ree_logger_log_params] ? "\n  Params: " + request.params.inspect : ""}
+              Response status: #{response.status || "-"}#{(400..499).include?(response.status) ? "\n  Response body: " + response.body[0] : ""}
+              Time Taken: #{elapsed_time}
+          DOC
+
+          opts[:ree_logger].info(message)
+        end
+
+        # Create timer instance used for timing
+        def _roda_before_05__ree_logger
+          @_request_timer = ReeLogger.start_timer
+        end
+      end
+    end
+
+    register_plugin(:ree_logger, ReeLogger)
+  end
+end

data/lib/ree_lib/packages/ree_roda/package/ree_roda/services/build_action_errors.rb

@@ -0,0 +1,76 @@
+class ReeRoda::BuildActionErrors
+  include Ree::FnDSL
+
+  fn :build_action_errors do
+    link "ree_swagger/dto/error_dto", -> { ErrorDto }
+  end
+
+  contract(ReeActions::Action => ArrayOf[ErrorDto])
+  def call(action)
+    ree_object = action.action
+    errors = recursively_extract_errors(ree_object)
+
+    errors
+      .select {
+        _1.ancestors.include?(ReeErrors::Error) && status_from_error(_1)
+      }
+      .map {
+        e = _1.new
+        description = "type: **#{e.type}**, code: **#{e.code}**, message: **#{e.message}**"
+
+        ErrorDto.new(
+          status: status_from_error(_1),
+          description: description
+        )
+      }
+      .uniq { [_1.status, _1.description] }
+  end
+
+  private
+
+  def recursively_extract_errors(ree_object)
+    errors = extract_errors(ree_object)
+
+    ree_object.links.each do |link|
+      obj = Ree.container.packages_facade.get_object(
+        link.package_name, link.object_name
+      )
+
+      if obj.fn?
+        errors += recursively_extract_errors(obj)
+      end
+    end
+
+    errors
+  end
+
+  def extract_errors(ree_object)
+    klass = ree_object.klass
+    return [] if ree_object.object?
+
+    method_decorator = Ree::Contracts.get_method_decorator(
+      klass, :call, scope: :instance
+    )
+
+    method_decorator&.errors || []
+  end
+
+  def status_from_error(error)
+    case error.instance_variable_get(:@type)
+    when :not_found
+      404
+    when :invalid_param
+      400
+    when :conflict
+      405
+    when :auth
+      401
+    when :permission
+      403
+    when :payment
+      402
+    when :validation
+      422
+    end
+  end
+end

data/lib/ree_lib/packages/ree_roda/package/ree_roda/services/build_swagger_from_actions.rb

@@ -0,0 +1,55 @@
+class ReeRoda::BuildSwaggerFromActions
+  include Ree::FnDSL
+
+  fn :build_swagger_from_actions do
+    link :build_action_errors
+    link :build_schema, from: :ree_swagger
+    link "ree_swagger/dto/endpoint_dto", -> { EndpointDto }
+  end
+
+  contract(ArrayOf[ReeActions::Action], String, String, String, String => Hash)
+  def call(actions, title, description, version, api_url)
+    endpoints = actions.map do |action|
+      method_decorator = Ree::Contracts.get_method_decorator(
+        action.action.klass, :call, scope: :instance
+      )
+
+      response_status = case action.request_method
+      when :post
+        201
+      when :put, :delete, :patch
+        204
+      else
+        200
+      end
+
+      caster = if action.action.klass.const_defined?(:ActionCaster)
+        action.action.klass.const_get(:ActionCaster)
+      end
+
+      EndpointDto.new(
+        method: action.request_method,
+        sections: action.sections,
+        respond_to: action.respond_to,
+        path: action.path.start_with?("/") ? action.path : "/#{action.path}",
+        caster: caster,
+        serializer: action.serializer&.klass&.new,
+        summary: action.summary,
+        authenticate: action.warden_scope != :visitor,
+        description: method_decorator&.doc || "",
+        response_status: response_status,
+        response_description: nil,
+        errors: build_action_errors(action)
+      )
+    end
+
+    build_schema(
+      title: title,
+      description: description,
+      version: version,
+      api_url: api_url,
+      endpoints: endpoints
+    )
+  end
+end
+

data/lib/ree_lib/packages/ree_roda/package/ree_roda/services/status_from_error.rb

@@ -0,0 +1,25 @@
+class ReeRoda::StatusFromError
+  include Ree::FnDSL
+
+  fn :status_from_error
+
+  contract(Symbol => Nilor[Integer])
+  def call(error_type)
+    case error_type
+    when :not_found
+      404
+    when :invalid_param
+      400
+    when :conflict
+      405
+    when :auth
+      401
+    when :permission
+      403
+    when :payment
+      402
+    when :validation
+      422
+    end
+  end
+end

data/lib/ree_lib/packages/ree_roda/package/ree_roda.rb

@@ -0,0 +1,19 @@
+require "roda"
+
+module ReeRoda
+  include Ree::PackageDSL
+
+  package do
+    depends_on :ree_actions
+    depends_on :ree_logger
+    depends_on :ree_json
+    depends_on :ree_hash
+    depends_on :ree_object
+    depends_on :ree_swagger
+    depends_on :ree_errors
+  end
+end
+
+package_require "ree_roda/plugins/ree_logger"
+package_require "ree_roda/plugins/ree_actions"
+package_require "ree_roda/app"

data/lib/ree_lib/packages/ree_roda/schemas/ree_roda/services/build_action_errors.schema.json

@@ -0,0 +1,28 @@
+{
+  "schema_type": "object",
+  "schema_version": "1.1",
+  "name": "build_action_errors",
+  "path": "packages/ree_roda/package/ree_roda/services/build_action_errors.rb",
+  "mount_as": "fn",
+  "class": "ReeRoda::BuildActionErrors",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "ArrayOf[ReeSwagger::ErrorDto]",
+      "args": [
+        {
+          "arg": "action",
+          "arg_type": "req",
+          "type": "ReeActions::Action"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_roda/schemas/ree_roda/services/build_swagger_from_actions.schema.json

@@ -0,0 +1,63 @@
+{
+  "schema_type": "object",
+  "schema_version": "1.1",
+  "name": "build_swagger_from_actions",
+  "path": "packages/ree_roda/package/ree_roda/services/build_swagger_from_actions.rb",
+  "mount_as": "fn",
+  "class": "ReeRoda::BuildSwaggerFromActions",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "Hash",
+      "args": [
+        {
+          "arg": "actions",
+          "arg_type": "req",
+          "type": "ArrayOf[ReeActions::Action]"
+        },
+        {
+          "arg": "title",
+          "arg_type": "req",
+          "type": "String"
+        },
+        {
+          "arg": "description",
+          "arg_type": "req",
+          "type": "String"
+        },
+        {
+          "arg": "version",
+          "arg_type": "req",
+          "type": "String"
+        },
+        {
+          "arg": "api_url",
+          "arg_type": "req",
+          "type": "String"
+        }
+      ]
+    }
+  ],
+  "links": [
+    {
+      "target": "build_action_errors",
+      "package_name": "ree_roda",
+      "as": "build_action_errors",
+      "imports": [
+
+      ]
+    },
+    {
+      "target": "build_schema",
+      "package_name": "ree_swagger",
+      "as": "build_schema",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_roda/schemas/ree_roda/services/status_from_error.schema.json

@@ -0,0 +1,28 @@
+{
+  "schema_type": "object",
+  "schema_version": "1.1",
+  "name": "status_from_error",
+  "path": "packages/ree_roda/package/ree_roda/services/status_from_error.rb",
+  "mount_as": "fn",
+  "class": "ReeRoda::StatusFromError",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "Nilor[Integer]",
+      "args": [
+        {
+          "arg": "error_type",
+          "arg_type": "req",
+          "type": "Symbol"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_roda/spec/package_schema_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe "ReeRoda" do
+  it "generates package schema" do
+    require "fileutils"
+
+    packages_schema_path = Ree.locate_packages_schema(__dir__)
+    packages_schema_dir = Pathname.new(packages_schema_path).dirname.to_s
+
+    FileUtils.cd packages_schema_dir do
+      expect(
+        system("REE_SKIP_ENV_VARS_CHECK=true bundle exec ree gen.package_json ree_roda --silence")
+      ).to eq(true)
+    end
+  end
+end

data/lib/ree_lib/packages/ree_roda/spec/ree_roda/app_spec.rb

@@ -0,0 +1,84 @@
+require "rack/test"
+
+package_require("ree_roda/app")
+package_require("ree_actions/dsl")
+package_require("ree_roda/plugins/ree_actions")
+
+RSpec.describe ReeRoda::App do
+  include Rack::Test::Methods
+
+  before :all do
+    Ree.enable_irb_mode
+
+    module ReeRodaTest
+      include Ree::PackageDSL
+
+      package
+    end
+
+    class ReeRodaTest::Cmd
+      include ReeActions::ActionDSL
+
+      action :cmd
+
+      ActionCaster = build_mapper.use(:cast) do
+        integer :id
+      end
+
+      def call(access, attrs)
+      end
+    end
+
+    class ReeRodaTest::TestActions
+      include ReeActions::DSL
+
+      actions :test_actions do
+        default_warden_scope :identity
+        opts = {from: :ree_roda_test}
+
+        get "api/action/:id" do
+          summary "Some action"
+          warden_scope :visitor
+          sections "some_action"
+          action :cmd, **opts
+        end
+      end
+    end
+
+    class TestApp < ReeRoda::App
+      plugin :ree_actions
+
+      ree_actions ReeRodaTest::TestActions.new,
+        api_url: "http://some.api.url:1337",
+        swagger_url: "swagger"
+
+      route do |r|
+        r.get "health" do
+          "success"
+        end
+
+        r.ree_actions
+      end
+    end
+  end
+
+  after :all do
+    Ree.disable_irb_mode
+  end
+
+  let(:app) { TestApp.app }
+
+  it {
+    get "health"
+    expect(last_response.body).to eq("success")
+    expect(last_response.status).to eq(200)
+  }
+
+  it {
+    get "swagger"
+    expect(last_response.status).to eq(200)
+
+    get "api/v1/swagger"
+    expect(last_response.status).to eq(404)
+  }
+end

data/lib/ree_lib/packages/ree_roda/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |config|
+  config.extend Ree::RSpecLinkDSL
+end

data/lib/ree_lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ReeLib
-  VERSION = "1.0.36"
+  VERSION = "1.0.37"
 end