trailblazer-finder 0.1.4 → 0.2.5

data/Rakefile

@@ -1,29 +1,29 @@
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-require 'rubocop/rake_task'
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
 
 RSpec::Core::RakeTask.new(:spec) do |t|
-  t.rspec_opts = '--format documentation --format RspecJunitFormatter --out test-reports/spec.xml'
+  t.rspec_opts = "--format documentation --format RspecJunitFormatter --out test-reports/spec.xml"
 end
 RSpec::Core::RakeTask.new(:tests) do |t|
-  t.rspec_opts = '--format progress --format documentation'
+  t.rspec_opts = "--format progress --format documentation"
 end
 RSpec::Core::RakeTask.new(:spec_report) do |t|
-  t.rspec_opts = '--format html --out reports/rspec_results.html'
+  t.rspec_opts = "--format html --out reports/rspec_results.html"
 end
 
 RuboCop::RakeTask.new(:rubocop)
 
-desc 'Remove temporary files'
+desc "Remove temporary files"
 task :clean do
-  %x{rm -rf *.gem doc pkg coverage test-reports}
-  %x{rm -f `find . -name '*.rbc'`}
+  `rm -rf *.gem doc pkg coverage test-reports`
+  %x(rm -f `find . -name '*.rbc'`)
 end
 
 desc "Build the gem"
 task :gem do
-  %x{gem build trailblazer-finder.gemspec}
+  `gem build trailblazer-finder.gemspec`
 end
 
-desc 'Running Tests'
-task default: %i[clean spec rubocop]
+desc "Running Tests"
+task default: %i[spec]

data/lib/trailblazer/finder.rb

@@ -1,32 +1,57 @@
-require 'trailblazer/finder/version'
-require 'trailblazer/finder/errors/block_ignored'
-require 'trailblazer/finder/errors/invalid_defined_by_value'
-require 'trailblazer/finder/errors/invalid_number'
-require 'trailblazer/finder/errors/missing_entity_type'
-require 'trailblazer/finder/errors/with_ignored'
-require 'trailblazer/finder'
-require 'trailblazer/finder/utils/params'
-require 'trailblazer/finder/utils/parse'
-require 'trailblazer/finder/utils/string'
-require 'trailblazer/finder/utils/extra'
-require 'trailblazer/finder/utils/splitter'
-require 'trailblazer/finder/utils/deep_locate'
-require 'trailblazer/finder/base'
-require 'trailblazer/finder/find'
-require 'trailblazer/finder/filter'
-require 'trailblazer/finder/features'
-require 'trailblazer/finder/adapters'
-require 'trailblazer/finder/predicates'
+# frozen_string_literal: true
+
+require "forwardable"
+require "trailblazer-activity"
+require "dry-types"
+require "ostruct"
+
+require "trailblazer/finder/utils/array"
+require "trailblazer/finder/utils/hash"
+require "trailblazer/finder/utils/string"
+require "trailblazer/finder/utils/splitter"
+require "trailblazer/finder/utils/extra"
+require "trailblazer/finder/adapters/active_record/predicates"
+require "trailblazer/finder/adapters/active_record/paging"
+require "trailblazer/finder/adapters/active_record/sorting"
+require "trailblazer/finder/adapters/kaminari/paging"
+require "trailblazer/finder/adapters/will_paginate/paging"
+require "trailblazer/finder/adapters/sequel/predicates"
+require "trailblazer/finder/adapters/sequel/paging"
+require "trailblazer/finder/adapters/sequel/sorting"
+require "trailblazer/finder/adapters/basic/predicates"
+require "trailblazer/finder/adapters/basic/paging"
+require "trailblazer/finder/adapters/basic/sorting"
+require "trailblazer/finder/activity/prepare/entity"
+require "trailblazer/finder/activity/prepare/properties"
+require "trailblazer/finder/activity/prepare/filters"
+require "trailblazer/finder/activity/prepare/params"
+require "trailblazer/finder/activity/prepare/adapters"
+require "trailblazer/finder/activity/prepare/paging"
+require "trailblazer/finder/activity/prepare/sorting"
+require "trailblazer/finder/activity/prepare"
+require "trailblazer/finder/activity/process/adapters"
+require "trailblazer/finder/activity/process/predicates"
+require "trailblazer/finder/activity/process/paging"
+require "trailblazer/finder/activity/process/sorting"
+require "trailblazer/finder/activity/process/filters"
+require "trailblazer/finder/activity/process"
+require "trailblazer/finder/activity/find"
+require "trailblazer/finder/helpers/basic"
+require "trailblazer/finder/helpers/sorting"
+require "trailblazer/finder/dsl"
+require "trailblazer/finder/find"
+require "trailblazer/finder/base"
 
 # :nocov:
-require 'trailblazer/operation/finder' if Gem.loaded_specs.key?('trailblazer')
+require "trailblazer/operation/finder" if Gem.loaded_specs.key?("trailblazer")
 # :nocov:
 
 module Trailblazer
   class Finder
+    module Types
+      include Dry::Types.module
+    end
+
     include Base
-    include Filter
-    include Features
-    include Adapters
   end
 end

data/lib/trailblazer/finder/activity/find.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Activity
+      # Find Activity
+      module Find
+        PREDICATES = %w[eq not_eq blank not_blank lt lte gt gte sw not_sw ew not_ew cont not_cont].freeze
+
+        extend Trailblazer::Activity::Railway()
+
+        module_function
+
+        def fetch_filters(ctx, result, attribute)
+          filter_attribute = ctx[:filters][attribute]
+          result[:filter] = {}
+          result[:name] = attribute
+          result[:filter][:handler] = filter_attribute[:with] || filter_attribute[:block]
+        end
+
+        def fetch_properties(result, attribute, value, properties)
+          splitter = Utils::Splitter.new attribute, value
+          PREDICATES.each do |predicate|
+            next unless splitter.split_key predicate
+            next unless properties.include?(splitter.field.to_sym)
+
+            result[:name] = splitter.field
+            result[:predicate] = predicate
+          end
+        end
+
+        def process_params(ctx, **)
+          ctx[:params].each do |attribute, value|
+            result = {}
+
+            fetch_filters(ctx, result, attribute) || result if ctx[:filters].include?(attribute)
+            fetch_properties(result, attribute, value, ctx[:properties]) || result
+            next ctx[:params].delete(attribute) if result.empty?
+
+            ctx[:process] ||= {}
+            ctx[:process][attribute] = result.merge!(value: value)
+          end
+          true
+        end
+
+        def set_finder(ctx, **)
+          ctx[:finder] = Finder::Find.new(ctx[:entity], ctx[:params], ctx[:process], ctx[:paging], ctx[:sorting], ctx[:config])
+        end
+
+        step Subprocess(Prepare), id: :prepare_finder
+        step method(:process_params), id: :process_params
+        step Subprocess(Process), id: :process_finder
+        step method(:set_finder), id: :set_finder
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/activity/prepare.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Activity
+      # Prepare Activity
+      module Prepare
+        extend Trailblazer::Activity::Railway()
+
+        module_function
+
+        def clean_ctx((ctx, flow_options), **)
+          # ctx.delete(:config)
+          ctx.delete(:options)
+          [Trailblazer::Activity::Right, [ctx, flow_options]]
+        end
+
+        step Subprocess(Prepare::Adapters), id: :prepare_adapters
+        step Subprocess(Prepare::Entity), id: :prepare_entity
+        step Subprocess(Prepare::Properties), id: :prepare_properties
+        step Subprocess(Prepare::Filters), id: :prepare_filters
+        step Subprocess(Prepare::Params), id: :prepare_params
+        step Subprocess(Prepare::Paging), id: :prepare_paging
+        step Subprocess(Prepare::Sorting), id: :prepare_sorting
+        step method(:clean_ctx), id: :clean_ctx
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/activity/prepare/adapters.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Activity
+      module Prepare
+        # Adapters Activity
+        module Adapters
+          extend Trailblazer::Activity::Railway()
+
+          module_function
+
+          def check_for_adapters(ctx, **)
+            adapters = ctx[:config][:adapters]
+            return true if adapters.empty?
+
+            adapters.each do |adapter|
+              return true if Finder::Adapters.constants.include?(adapter.to_sym)
+            end
+            false
+          end
+
+          def validate_adapters(ctx, **)
+            adapters = ctx[:config][:adapters]
+            return true if adapters.empty?
+
+            adapters.each do |adapter|
+              if ORM_ADAPTERS.include?(adapter)
+                return false if (adapters & (ORM_ADAPTERS - [adapter])).any?
+              end
+            end
+          end
+
+          def invalid_adapters_error(ctx, **)
+            (ctx[:errors] ||= []) << {adapters: "One or more of the specified adapters are invalid"}
+          end
+
+          def multiple_orm_error(ctx, **)
+            (ctx[:errors] ||= []) << {adapters: "More then one ORM adapter specified"}
+          end
+
+          def set_adapters(ctx, **)
+            adapters = ctx[:config][:adapters]
+            ctx[:adapters] = (ORM_ADAPTERS & adapters).any? ? adapters : ["Basic"] + adapters
+          end
+
+          step method(:check_for_adapters),
+               Output(:success) => Track(:valid),
+               Output(:failure) => Track(:invalid_adapters)
+          step method(:validate_adapters), magnetic_to: [:valid],
+            Output(:success) => Track(:valid),
+            Output(:failure) => Track(:multiple_orm)
+          fail method(:invalid_adapters_error), magnetic_to: [:invalid_adapters],
+            Output(:success) => Track(:failure),
+            Output(:failure) => Track(:failure)
+          fail method(:multiple_orm_error), magnetic_to: [:multiple_orm],
+            Output(:success) => Track(:failure),
+            Output(:failure) => Track(:failure)
+          step method(:set_adapters), magnetic_to: [:valid],
+            Output(:success) => Track(:success),
+            Output(:failure) => Track(:failure)
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/activity/prepare/entity.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Activity
+      module Prepare
+        # Prepare Entity Activity
+        module Entity
+          extend Trailblazer::Activity::Railway()
+
+          module_function
+
+          def validate_entity(ctx, **)
+            ctx[:options][:entity] || ctx[:config][:entity]
+          end
+
+          def invalid_entity_error(ctx, **)
+            (ctx[:errors] ||= []) << {entity: "Invalid entity specified"}
+          end
+
+          def set_entity(ctx, **)
+            ctx[:entity] = ctx[:options][:entity] || instance_eval(&ctx[:config][:entity])
+          end
+
+          step method(:validate_entity), id: :validate_entity
+          fail method(:invalid_entity_error), id: :invalid_entity_error
+          step method(:set_entity), id: :set_entity
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/activity/prepare/filters.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Activity
+      module Prepare
+        # Filters Activity
+        module Filters
+          extend Trailblazer::Activity::Railway()
+
+          module_function
+
+          def validate_filters(ctx, **)
+            filters = ctx[:config][:filters]
+            filters.each do |key, _value|
+              return false if !filters[key][:with].nil? && !filters[key][:with].is_a?(Symbol)
+            end
+            true
+          end
+
+          def invalid_filters_error(ctx, **)
+            (ctx[:errors] ||= []) << {filters: "One or more filters are missing a with method definition"}
+          end
+
+          def set_filters(ctx, **)
+            ctx[:filters] = ctx[:config][:filters]
+          end
+
+          step method(:validate_filters), id: :validate_filters
+          fail method(:invalid_filters_error), id: :invalid_filters_error
+          step method(:set_filters), id: :set_filters
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/activity/prepare/paging.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Activity
+      module Prepare
+        # Paging Activity
+        module Paging
+          extend Trailblazer::Activity::Railway()
+
+          module_function
+
+          def check_paging(ctx, **)
+            paging = ctx[:config][:paging] || nil
+            return false if ctx[:config][:paging].empty? || paging.nil?
+
+            true
+          end
+
+          def set_paging(ctx, **)
+            ctx[:paging] = ctx[:config][:paging] || {}
+            ctx[:paging][:current_page] = ctx[:params][:page] || 1
+            return true unless ctx[:params][:per_page]
+
+            ctx[:paging][:per_page] = ctx[:params][:per_page].to_i || ctx[:paging][:per_page]
+            ctx[:paging][:per_page] = ctx[:paging][:max_per_page] if ctx[:params][:per_page] > ctx[:paging][:max_per_page]
+            ctx[:paging][:per_page] = ctx[:paging][:min_per_page] if ctx[:params][:per_page] < ctx[:paging][:min_per_page]
+            true
+          end
+
+          def clear_paging(ctx, **)
+            ctx[:params].delete(:page) unless ctx[:params][:page].nil?
+            true
+          end
+
+          step method(:check_paging), id: :check_paging,
+            Output(:success) => Track(:paging),
+            Output(:failure) => Track(:end_paging)
+          step method(:set_paging), id: :set_paging, magnetic_to: [:paging],
+            Output(:success) => Track(:end_paging),
+            Output(:failure) => Track(:failure)
+          step method(:clear_paging), id: :clear_paging, magnetic_to: [:end_paging],
+            Output(:success) => Track(:success),
+            Output(:failure) => Track(:failure)
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/activity/prepare/params.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Activity
+      module Prepare
+        # Params Activity
+        module Params
+          extend Trailblazer::Activity::Railway()
+
+          module_function
+
+          def validate_params(_ctx, **)
+            # Should probably validate some things here at some point
+            true
+          end
+
+          def invalid_params_error(ctx, **)
+            # (ctx[:errors] ||= []) << {params: "One or more parameters are invalid"}
+          end
+
+          def set_params(ctx, **)
+            ctx[:params] = ctx[:options][:params] || {}
+          end
+
+          step method(:validate_params), id: :validate_params
+          fail method(:invalid_params_error), id: :invalid_params_error
+          step method(:set_params), id: :set_params
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/finder/activity/prepare/properties.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Trailblazer
+  class Finder
+    module Activity
+      module Prepare
+        # Prepare Properties Activity
+        module Properties
+          extend Trailblazer::Activity::Railway()
+
+          module_function
+
+          def check_property_types(ctx, **)
+            properties = ctx[:config][:properties] || {}
+            return true if properties.empty?
+
+            properties.each do |key, _value|
+              return !properties[key][:type].nil?
+            end
+          end
+
+          def validate_property_types(ctx, **)
+            properties = ctx[:config][:properties] || {}
+            return true if properties.empty?
+
+            properties.each do |key, _value|
+              return properties[key][:type].class.ancestors.include?(Dry::Types::Definition)
+            end
+          end
+
+          def invalid_properties_error(ctx, **)
+            (ctx[:errors] ||= []) << {properties: "One or more properties are missing a valid type"}
+          end
+
+          def set_properties(ctx, **)
+            ctx[:properties] = ctx[:config][:properties]
+          end
+
+          step method(:check_property_types), id: :check_property_types
+          step method(:validate_property_types), id: :validate_property_types
+          fail method(:invalid_properties_error), id: :invalid_properties_error
+          step method(:set_properties), id: :set_properties
+        end
+      end
+    end
+  end
+end