pragma 2.1.1 → 2.2.0

data/lib/pragma/macro/contract/validate.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'trailblazer/operation/validate'
+
+module Pragma
+  module Macro
+    module Contract
+      def self.Validate(name: 'default', **args)
+        step = lambda do |input, options|
+          Trailblazer::Operation::Pipetree::Step.new(
+            Trailblazer::Operation::Contract::Validate(**args).first
+          ).call(input, options).tap do |result|
+            unless result
+              options['result.response'] = Pragma::Operation::Response::UnprocessableEntity.new(
+                errors: options["contract.#{name}"].errors.messages
+              ).decorate_with(Pragma::Decorator::Error)
+            end
+          end
+        end
+
+        [step, name: "contract.#{name}.validate"]
+      end
+    end
+  end
+end

data/lib/pragma/macro/decorator.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Pragma
+  module Macro
+    def self.Decorator(name: :instance)
+      step = ->(input, options) { Decorator.for(input, name, options) }
+      [step, name: "decorator.#{name}"]
+    end
+
+    module Decorator
+      class << self
+        def for(_input, name, options)
+          set_defaults(options)
+
+          return false unless validate_params(options)
+
+          options["result.decorator.#{name}"] = options["decorator.#{name}.class"].new(
+            options['model']
+          )
+
+          validate_expansion(options, name)
+        end
+
+        private
+
+        def set_defaults(options)
+          hash_options = options.to_hash
+
+          {
+            'expand.enabled' => true
+          }.each_pair do |key, value|
+            options[key] = value unless hash_options.key?(key.to_sym)
+          end
+        end
+
+        def validate_params(options)
+          options['contract.expand'] = Dry::Validation.Schema do
+            optional(:expand) do
+              if options['expand.enabled']
+                array? do
+                  each(:str?) &
+                    # This is the ugliest, only way I found to define a dynamic validation tree.
+                    (options['expand.limit'] ? max_size?(options['expand.limit']) : array?)
+                end
+              else
+                none? | empty?
+              end
+            end
+          end
+
+          options['result.contract.expand'] = options['contract.expand'].call(options['params'])
+
+          if options['result.contract.expand'].errors.any?
+            options['result.response'] = Operation::Response::UnprocessableEntity.new(
+              errors: options['result.contract.expand'].errors
+            ).decorate_with(Pragma::Decorator::Error)
+
+            return false
+          end
+
+          true
+        end
+
+        def validate_expansion(options, name)
+          return true unless options["result.decorator.#{name}"].respond_to?(:validate_expansion)
+          options["result.decorator.#{name}"].validate_expansion(options['params'][:expand])
+          true
+        rescue Pragma::Decorator::Association::ExpansionError => e
+          options['result.response'] = Operation::Response::BadRequest.new(
+            entity: Pragma::Operation::Error.new(
+              error_type: :expansion_error,
+              error_message: e.message
+            )
+          ).decorate_with(Pragma::Decorator::Error)
+          false
+        end
+      end
+    end
+  end
+end

data/lib/pragma/macro/filtering.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Pragma
+  module Macro
+    def self.Filtering
+      step = ->(input, options) { Filtering.for(input, options) }
+      [step, name: 'filtering']
+    end
+
+    module Filtering
+      class << self
+        def for(_input, options)
+          set_defaults(options)
+
+          options['model'] = apply_filtering(options)
+
+          true
+        end
+
+        private
+
+        def set_defaults(options)
+          {
+            'filtering.filters' => []
+          }.each_pair do |key, value|
+            options[key] = value unless options[key]
+          end
+        end
+
+        def apply_filtering(options)
+          relation = options['model']
+
+          options['filtering.filters'].each do |filter|
+            value = options['params'][filter.param]
+            next unless value.present?
+
+            relation = filter.apply(relation: options['model'], value: value)
+          end
+
+          relation
+        end
+      end
+    end
+  end
+end

data/lib/pragma/macro/model.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'trailblazer/operation/model'
+
+module Pragma
+  module Macro
+    def self.Model(action = nil)
+      step = lambda do |input, options|
+        Trailblazer::Operation::Pipetree::Step.new(
+          Trailblazer::Operation::Model.for(options['model.class'], action),
+          'model.class' => options['model.class'],
+          'model.action' => action
+        ).call(input, options).tap do |result|
+          unless result
+            options['result.response'] = Pragma::Operation::Response::NotFound.new.decorate_with(
+              Pragma::Decorator::Error
+            )
+          end
+        end
+      end
+
+      [step, name: "model.#{action || 'build'}"]
+    end
+
+    module Model
+    end
+  end
+end

data/lib/pragma/macro/ordering.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Pragma
+  module Macro
+    def self.Ordering
+      step = ->(input, options) { Ordering.for(input, options) }
+      [step, name: 'ordering']
+    end
+
+    module Ordering
+      class << self
+        def for(_input, options)
+          set_defaults(options)
+
+          unless validate_params(options)
+            handle_invalid_contract(options)
+            return false
+          end
+
+          order_column = order_column(options)
+
+          if order_column
+            direction = order_direction(options)
+            options['model'] = options['model'].order("#{order_column} #{direction}")
+          end
+
+          true
+        end
+
+        private
+
+        def set_defaults(options)
+          default_column = (:created_at if options['model.class']&.method_defined?(:created_at))
+
+          {
+            'ordering.columns' => [default_column].compact,
+            'ordering.default_column' => default_column,
+            'ordering.default_direction' => :desc,
+            'ordering.column_param' => :order_property,
+            'ordering.direction_param' => :order_direction
+          }.each_pair do |key, value|
+            options[key] = value unless options[key]
+          end
+        end
+
+        def validate_params(options)
+          options['contract.ordering'] = Dry::Validation.Schema do
+            optional(options['ordering.column_param']).filled do
+              str? & included_in?(options['ordering.columns'].map(&:to_s))
+            end
+            optional(options['ordering.direction_param']).filled do
+              str? & included_in?(%w[asc desc ASC DESC])
+            end
+          end
+
+          options['result.contract.ordering'] = options['contract.ordering'].call(
+            options['params']
+          )
+
+          options['result.contract.ordering'].errors.empty?
+        end
+
+        def handle_invalid_contract(options)
+          options['result.response'] = Operation::Response::UnprocessableEntity.new(
+            errors: options['result.contract.ordering'].errors
+          ).decorate_with(Pragma::Decorator::Error)
+        end
+
+        def order_column(options)
+          params = options['params']
+          params[options['ordering.column_param']] || options['ordering.default_column']
+        end
+
+        def order_direction(options)
+          params = options['params']
+          params[options['ordering.direction_param']] || options['ordering.default_direction']
+        end
+      end
+    end
+  end
+end

data/lib/pragma/macro/pagination.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Pragma
+  module Macro
+    def self.Pagination
+      step = ->(input, options) { Pagination.for(input, options) }
+      [step, name: 'pagination']
+    end
+
+    module Pagination
+      class << self
+        def for(_input, options)
+          set_defaults(options)
+          normalize_params(options)
+
+          unless validate_params(options)
+            handle_invalid_contract(options)
+            return false
+          end
+
+          options['model'] = options['model'].paginate(
+            page: page(options, **options),
+            per_page: per_page(options, **options)
+          )
+        end
+
+        private
+
+        def set_defaults(options)
+          {
+            'pagination.page_param' => :page,
+            'pagination.per_page_param' => :per_page,
+            'pagination.default_per_page' => 30,
+            'pagination.max_per_page' => 100
+          }.each_pair do |key, value|
+            options[key] = value unless options[key]
+          end
+        end
+
+        def normalize_params(options)
+          # This is required because Rails treats all incoming parameters as strings, since it
+          # can't distinguish. Maybe there's a better way to do it?
+          options['params'].tap do |p|
+            %w[pagination.page_param pagination.per_page_param].each do |key|
+              if p[options[key]] && p[options[key]].respond_to?(:to_i)
+                p[options[key]] = p[options[key]].to_i
+              end
+            end
+          end
+        end
+
+        def validate_params(options)
+          options['contract.pagination'] = Dry::Validation.Schema do
+            optional(options['pagination.page_param']).filled { int? & gteq?(1) }
+            optional(options['pagination.per_page_param']).filled do
+              int? & (gteq?(1) & lteq?(options['pagination.max_per_page']))
+            end
+          end
+
+          options['result.contract.pagination'] = options['contract.pagination'].call(
+            options['params']
+          )
+
+          options['result.contract.pagination'].errors.empty?
+        end
+
+        def handle_invalid_contract(options)
+          options['result.response'] = Operation::Response::UnprocessableEntity.new(
+            errors: options['result.contract.pagination'].errors
+          ).decorate_with(Pragma::Decorator::Error)
+        end
+
+        def page(options, params:, **)
+          return 1 if
+            !params[options['pagination.page_param']] ||
+            params[options['pagination.page_param']].blank?
+
+          params[options['pagination.page_param']].to_i
+        end
+
+        def per_page(options, params:, **)
+          return options['pagination.default_per_page'] if
+            !params[options['pagination.per_page_param']] ||
+            params[options['pagination.per_page_param']].blank?
+
+          [
+            params[options['pagination.per_page_param']].to_i,
+            options['pagination.max_per_page']
+          ].min
+        end
+      end
+    end
+  end
+end

data/lib/pragma/macro/policy.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Pragma
+  module Macro
+    def self.Policy(name: :default, action: nil)
+      step = ->(input, options) { Policy.for(input, name, options, action) }
+      [step, name: "policy.#{name}"]
+    end
+
+    module Policy
+      class << self
+        def for(input, name, options, action = nil)
+          policy = options["policy.#{name}.class"].new(options['current_user'], options['model'])
+
+          action_name = action.is_a?(Proc) ? action.call(options) : action
+          action_name ||= input.class.operation_name
+
+          options["result.policy.#{name}"] = Trailblazer::Operation::Result.new(
+            policy.send("#{action_name}?"),
+            'policy' => policy
+          )
+
+          unless options["result.policy.#{name}"].success?
+            handle_unauthorized!(options)
+            return false
+          end
+
+          true
+        end
+
+        private
+
+        def handle_unauthorized!(options)
+          options['result.response'] = Pragma::Operation::Response::Forbidden.new.decorate_with(
+            Pragma::Decorator::Error
+          )
+        end
+      end
+    end
+  end
+end

data/lib/pragma/operation/create.rb

@@ -13,7 +13,7 @@ module Pragma
       step Macro::Contract::Validate()
       step Macro::Contract::Persist()
       step Macro::Decorator()
-      step :respond!
+      step :respond!, name: 'respond'
 
       def respond!(options)
         options['result.response'] = Response::Created.new(

data/lib/pragma/operation/destroy.rb

@@ -9,8 +9,8 @@ module Pragma
       step Macro::Classes()
       step Macro::Model(:find_by)
       step Macro::Policy()
-      step :destroy!
-      step :respond!
+      step :destroy!, name: 'destroy'
+      step :respond!, name: 'respond'
 
       def destroy!(_options, model:, **)
         unless model.destroy

data/lib/pragma/operation/filter.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Pragma
+  module Operation
+    Filter = Pragma::Filter
+  end
+end

data/lib/pragma/operation/index.rb

@@ -8,13 +8,13 @@ module Pragma
     # @author Alessandro Desantis
     class Index < Pragma::Operation::Base
       step Macro::Classes()
-      step :retrieve!
-      step :scope!
+      step :retrieve!, name: 'retrieve'
+      step :scope!, name: 'scope'
       step Macro::Filtering()
       step Macro::Ordering()
       step Macro::Pagination()
       step Macro::Decorator(name: :collection)
-      step :respond!
+      step :respond!, name: 'respond'
 
       def retrieve!(options)
         options['model'] = options['model.class'].all