pragma 2.1.1 → 2.2.0

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

@@ -1,30 +0,0 @@
-# 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.#{action || 'build'}"]
-      end
-
-      module Model
-      end
-    end
-  end
-end

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

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Pragma
-  module Operation
-    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
-              options['model'] = options['model'].order(order_column => order_direction(options))
-            end
-
-            true
-          end
-
-          private
-
-          def set_defaults(options)
-            default_column = if options['model.class']&.method_defined?(:created_at)
-              :created_at
-            end
-
-            {
-              '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'] = 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
-end

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

@@ -1,96 +0,0 @@
-# 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 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'] = 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

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-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