pragma 1.2.6 → 2.0.0

data/lib/pragma/operation/macro/classes.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Pragma
+  module Operation
+    module Macro
+      def self.Classes
+        step = ->(input, options) { Classes.for(input, options) }
+        [step, name: 'classes']
+      end
+
+      module Classes
+        class << self
+          def for(input, options)
+            {
+              'model.class' => expected_model_class(input, options),
+              'policy.default.class' => expected_policy_class(input, options),
+              'policy.default.scope.class' => expected_policy_scope_class(input, options),
+              'decorator.instance.class' => expected_instance_decorator_class(input, options),
+              'decorator.collection.class' => expected_collection_decorator_class(input, options),
+              'contract.default.class' => expected_contract_class(input, options)
+            }.each_pair do |key, value|
+              next if options[key]
+
+              # FIXME: This entire block is required to trigger Rails autoloading. Ugh.
+              begin
+                Object.const_get(value)
+              rescue NameError => e
+                # We check the error message to avoid silently ignoring other NameErrors
+                # thrown while initializing the constant.
+                if e.message.start_with?('uninitialized constant')
+                  # Required instead of a simple equality check because loading
+                  # API::V1::Post::Contract::Index might throw "uninitialized constant
+                  # API::V1::Post::Contract" if the resource has no contracts at all.
+                  error_constant = e.message.split.last
+                  raise e unless value.sub(/\A::/, '').start_with?(error_constant)
+                end
+              end
+
+              options[key] = if Object.const_defined?(value)
+                Object.const_get(value)
+              end
+            end
+          end
+
+          private
+
+          def resource_namespace(input, _options)
+            input.class.name.split('::')[0..-3]
+          end
+
+          def expected_model_class(input, options)
+            [
+              nil,
+              resource_namespace(input, options).last
+            ].join('::')
+          end
+
+          def expected_policy_class(input, options)
+            [
+              resource_namespace(input, options),
+              'Policy'
+            ].join('::')
+          end
+
+          def expected_policy_scope_class(input, options)
+            "#{expected_policy_class(input, options)}::Scope"
+          end
+
+          def expected_instance_decorator_class(input, options)
+            [
+              resource_namespace(input, options),
+              'Decorator',
+              'Instance'
+            ].join('::')
+          end
+
+          def expected_collection_decorator_class(input, options)
+            [
+              resource_namespace(input, options),
+              'Decorator',
+              'Collection'
+            ].join('::')
+          end
+
+          def expected_contract_class(input, options)
+            [
+              resource_namespace(input, options),
+              'Contract',
+              input.class.name.split('::').last
+            ].join('::')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pragma/operation/macro/contract/build.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'trailblazer/operation/contract'
+
+module Pragma
+  module Operation
+    module Macro
+      module Contract
+        def self.Build(name: 'default', constant: nil, builder: nil)
+          step = lambda do |input, options|
+            Trailblazer::Operation::Contract::Build.for(
+              input,
+              options,
+              name: name,
+              constant: constant,
+              builder: builder
+            ).tap do |contract|
+              contract.current_user = options['current_user']
+            end
+          end
+
+          [step, name: 'contract.build']
+        end
+      end
+    end
+  end
+end

data/lib/pragma/operation/macro/contract/persist.rb

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

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'trailblazer/operation/validate'
+
+module Pragma
+  module Operation
+    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.default'].errors.messages
+                ).decorate_with(Pragma::Decorator::Error)
+              end
+            end
+          end
+
+          [step, name: "contract.#{name}.validate"]
+        end
+      end
+    end
+  end
+end

data/lib/pragma/operation/macro/decorator.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Pragma
+  module Operation
+    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)
+            unless validate_params(options)
+              handle_invalid_contract(options)
+              return false
+            end
+
+            options["result.decorator.#{name}"] = options["decorator.#{name}.class"].new(
+              options['model']
+            )
+
+            validate_expansion(options, name)
+          end
+
+          private
+
+          def validate_params(options)
+            options['contract.expand'] = Dry::Validation.Schema do
+              optional(:expand).each(:str?)
+            end
+
+            options['result.contract.expand'] = options['contract.expand'].call(options['params'])
+
+            options['result.contract.expand'].errors.empty?
+          end
+
+          def handle_invalid_contract(options)
+            options['result.response'] = Response::UnprocessableEntity.new(
+              errors: options['result.contract.expand'].errors
+            ).decorate_with(Pragma::Decorator::Error)
+          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'] = 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
+end

data/lib/pragma/operation/macro/model.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'trailblazer/operation/model'
+
+module Pragma
+  module Operation
+    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.build']
+      end
+    end
+  end
+end

data/lib/pragma/operation/macro/pagination.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Pragma
+  module Operation
+    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
+            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 { int? & (gteq?(1) & lteq?(options['pagination.max_per_page'])) }
+            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'] = 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
+end

data/lib/pragma/operation/macro/policy.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'trailblazer/operation/pundit'
+
+module Pragma
+  module Operation
+    module Macro
+      def self.Policy(name: :default)
+        step = ->(input, options) { Policy.for(input, name, options) }
+        [step, name: "policy.#{name}"]
+      end
+
+      module Policy
+        class << self
+          def for(input, name, options)
+            policy = options["policy.#{name}.class"].new(options['current_user'], options['model'])
+
+            options["result.policy.#{name}"] = Trailblazer::Operation::Result.new(
+              policy.send("#{input.class.operation_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
+end

data/lib/pragma/operation/show.rb

@@ -1,26 +1,19 @@
 # frozen_string_literal: true
+
 module Pragma
   module Operation
     # Finds the requested record, authorizes it and decorates it.
     #
     # @author Alessandro Desantis
     class Show < Pragma::Operation::Base
-      include Pragma::Operation::Defaults
-
-      def call
-        context.record = find_record
-        authorize! context.record
-
-        respond_with resource: decorate(context.record), status: :ok
-      end
-
-      protected
+      step Macro::Classes()
+      step Macro::Model(:find_by), fail_fast: true
+      step Macro::Policy(), fail_fast: true
+      step Macro::Decorator()
+      step :respond!
 
-      # Finds the requested record.
-      #
-      # @return [Object]
-      def find_record
-        self.class.model_klass.find(params[:id])
+      def respond!(options)
+        options['result.response'] = Response::Ok.new(entity: options['result.decorator.instance'])
       end
     end
   end

data/lib/pragma/operation/update.rb

@@ -1,33 +1,22 @@
 # frozen_string_literal: true
+
 module Pragma
   module Operation
-    # Finds the requested record, authorizes it, updates it accordingly to the parameters and
-    # responds with the decorated record.
+    # Finds an existing record, updates it and responds with the decorated record.
     #
     # @author Alessandro Desantis
     class Update < Pragma::Operation::Base
-      include Pragma::Operation::Defaults
-
-      def call
-        context.record = find_record
-        context.contract = build_contract(context.record)
-
-        validate! context.contract
-        authorize! context.contract
-
-        context.contract.save
-        context.record.save!
-
-        respond_with resource: decorate(context.record), status: :ok
-      end
-
-      protected
+      step Macro::Classes()
+      step Macro::Model(:find_by), fail_fast: true
+      step Macro::Policy(), fail_fast: true
+      step Macro::Contract::Build()
+      step Macro::Contract::Validate(), fail_fast: true
+      step Macro::Contract::Persist(), fail_fast: true
+      step Macro::Decorator()
+      step :respond!
 
-      # Finds the requested record.
-      #
-      # @return [Object]
-      def find_record
-        self.class.model_klass.find(params[:id])
+      def respond!(options)
+        options['result.response'] = Response::Ok.new(entity: options['result.decorator.instance'])
       end
     end
   end