prato 0.1.0

data/lib/prato/internal/pipeline/serializer.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Prato
+  module Internal
+    module Pipeline
+      module Serializer
+        extend self
+
+        def serialize_query(query_state, spec, raw_fields)
+          fields = raw_fields || spec.visible_fields
+
+          if query_state.unmaterialized? && spec.sql_only?(fields)
+            optimized_serialization(query_state, spec, fields)
+          else
+            normal_serialization(query_state, spec, fields)
+          end
+        end
+
+        private
+
+        def optimized_serialization(query_state, spec, fields)
+          columns = spec.columns
+          scope = query_state.dataset
+          association_paths = []
+
+          fields.each do |field|
+            column = columns[field]
+            association_paths << column.association_path if column.is_a?(Types::AssociationColumn)
+          end
+
+          scope = Internal::JoinHelper.ensure_left_joins(scope, association_paths.uniq)
+
+          selects = fields.map do |field|
+            column = columns[field]
+
+            case column
+            when Types::DirectColumn, Types::AssociationColumn, Types::AggregateColumn, Types::ExpressionColumn
+              column.sql_node_for(scope)
+            else
+              raise "Assertion error: Trying to serialize with unknown column type: #{column.class}"
+            end
+          end
+
+          rows = scope.pluck(*selects)
+
+          rows.map do |data|
+            fields.each_with_object({}).with_index do |(field, hash), idx|
+              column = columns[field]
+
+              value = Array(data)[idx]
+              value = column.format.call(value) if column.format
+
+              assign_value(hash, spec, field, value)
+            end
+          end
+        end
+
+        def normal_serialization(query_state, spec, fields)
+          records, ruby_loaded_data = query_state.materialized_dataset(spec)
+          columns = spec.columns
+
+          records.map do |record|
+            fields.each_with_object({}) do |field, hash|
+              column = columns[field]
+
+              value = if column.is_a?(Types::RubyColumn)
+                        column.extract_value(record, ruby_loaded_data)
+                      else
+                        value = column.extract_value(record, nil)
+                        column.format ? column.format.call(value) : value
+                      end
+
+              assign_value(hash, spec, field, value)
+            end
+          end
+        end
+
+        def assign_value(hash, spec, field, value)
+          output_path = spec.field_mapping(field)
+          current = hash
+          output_path[0..-2].each { |key| current = (current[key] ||= {}) }
+          current[output_path.last] = value
+        end
+      end
+    end
+  end
+end

data/lib/prato/internal/pipeline/sorting.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Prato
+  module Internal
+    module Pipeline
+      module Sorting
+        extend self
+
+        def sort_query(query_state, spec, raw_sorts)
+          return query_state if raw_sorts.nil?
+
+          sorts = Array(raw_sorts)
+
+          any_ruby = sorts.any? { |s| spec.columns[s.field].is_a?(Types::RubyColumn) }
+
+          if any_ruby || !query_state.unmaterialized?
+            apply_ruby_sorts(query_state, spec, sorts)
+          else
+            apply_sql_sorts(query_state, spec, sorts)
+          end
+        end
+
+        private
+
+        def apply_sql_sorts(query_state, spec, sorts)
+          scope = query_state.dataset
+
+          sorts.each do |sort|
+            column = spec.columns[sort.field]
+            scope = Internal::JoinHelper.ensure_join(scope, column, left_outer: true)
+            node = column.sql_node_for(scope)
+            order = build_order_node(node, sort.is_desc)
+            scope = scope.order(order)
+          end
+
+          query_state.with_dataset(scope)
+        end
+
+        def apply_ruby_sorts(query_state, spec, sorts)
+          records, ruby_data = query_state.materialized_dataset(spec)
+
+          sorted = records.sort do |a, b|
+            sorts.reduce(0) do |cmp, sort|
+              next cmp unless cmp.zero?
+
+              column = spec.columns[sort.field]
+              val_a = column.extract_value(a, ruby_data)
+              val_b = column.extract_value(b, ruby_data)
+
+              result = safe_compare(val_a, val_b)
+              sort.is_desc  ? -result : result
+            end
+          end
+
+          query_state.with_dataset(sorted)
+        end
+
+        def safe_compare(a, b)
+          return 0 if a.nil? && b.nil?
+          return 1 if a.nil?
+          return -1 if b.nil?
+
+          a <=> b
+        end
+
+        if ActiveRecordVersion.supports_arel_desc?
+          def build_order_node(node, is_desc)
+            is_desc ? node.desc : node.asc
+          end
+        else
+          def build_order_node(node, is_desc)
+            is_desc ? Arel::Nodes::Descending.new(node) : Arel::Nodes::Ascending.new(node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prato/internal/query_executor.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Prato
+  module Internal
+    module QueryExecutor
+      extend self
+
+      def execute(scope, spec, raw_params:, paginated: true)
+        config = spec.config
+        params = resolve_parameters(raw_params, config, spec)
+
+        materialization_fields = spec.validate_and_extract_materialization_fields(params)
+        return invalid_input_result(config, paginated) if materialization_fields.nil?
+
+        base_query_state = QueryState.create(scope, materialization_fields)
+
+        filtered_query = Pipeline::Filtering.filter_query(base_query_state, spec, params&.filters)
+        sorted_query = Pipeline::Sorting.sort_query(filtered_query, spec, params&.sorts)
+
+        if paginated
+          paginated_query = Pipeline::Pagination.paginate_query(sorted_query, config, params&.page, params&.per_page)
+          data = Pipeline::Serializer.serialize_query(paginated_query, spec, params&.fields)
+
+          { entries: data, totalCount: total_count(sorted_query) }
+        else
+          Pipeline::Serializer.serialize_query(sorted_query, spec, params&.fields)
+        end
+      end
+
+      def execute_in_batches(scope, spec, raw_params:, batch_size:)
+        config = spec.config
+        params = resolve_parameters(raw_params, config, spec)
+
+        materialization_fields = spec.validate_and_extract_materialization_fields(params)
+        if materialization_fields.nil?
+          raise ArgumentError if config.on_invalid_input == :raise
+
+          return
+        end
+
+        base_query_state = QueryState.create(scope, materialization_fields)
+        filtered_query = Pipeline::Filtering.filter_query(base_query_state, spec, params&.filters)
+        sorted_query = Pipeline::Sorting.sort_query(filtered_query, spec, params&.sorts)
+
+        is_materialized = !sorted_query.unmaterialized?
+        has_sort = !Array(params&.sorts).empty?
+
+        if is_materialized
+          sorted_query.dataset.each_slice(batch_size) do |slice|
+            batch_state = sorted_query.with_dataset(slice)
+            yield Pipeline::Serializer.serialize_query(batch_state, spec, params&.fields)
+          end
+        elsif has_sort
+          offset = 0
+          loop do
+            relation = sorted_query.dataset.offset(offset).limit(batch_size)
+            batch_state = sorted_query.with_dataset(relation)
+            serialized = Pipeline::Serializer.serialize_query(batch_state, spec, params&.fields)
+            break if serialized.empty?
+
+            yield serialized
+            break if serialized.size < batch_size
+
+            offset += batch_size
+          end
+        else
+          sorted_query.dataset.in_batches(of: batch_size) do |relation|
+            batch_state = sorted_query.with_dataset(relation)
+            yield Pipeline::Serializer.serialize_query(batch_state, spec, params&.fields)
+          end
+        end
+      end
+
+      private
+
+      def resolve_parameters(input, config, spec)
+        return nil if input.nil?
+        return input if input.is_a?(Query::Parameters)
+
+        config.parameter_parser.parse_parameters(input, Prato::Query::FieldResolver.resolve_context(spec.field_lookup))
+      end
+
+      def invalid_input_result(configuration, paginated)
+        raise ArgumentError if configuration.on_invalid_input == :raise
+
+        if paginated
+          {
+            entries: [],
+            totalCount: 0
+          }
+        else
+          []
+        end
+      end
+
+      def total_count(query_state)
+        if query_state.unmaterialized?
+          query_state.dataset.except(:select).count
+        else
+          query_state.dataset.count
+        end
+      end
+    end
+  end
+end

data/lib/prato/internal/query_state.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Prato
+  module Internal
+    class QueryState
+      attr_reader :dataset
+
+      def self.create(base_scope, materialization_fields)
+        dataset = base_scope.dup
+
+        new(dataset, nil, materialization_fields)
+      end
+
+      def with_dataset(dataset)
+        self.class.new(dataset, @ruby_loaded_data, @materialization_fields)
+      end
+
+      def unmaterialized?
+        !dataset.is_a?(Array)
+      end
+
+      def materialized_dataset(spec)
+        return [@dataset, @ruby_loaded_data] unless unmaterialized?
+
+        columns = spec.columns
+        scope = dataset
+        selects = Set.new([Arel.sql("#{scope.model.table_name}.*")])
+        association_load_values = []
+
+        @materialization_fields.each do |field|
+          column = columns[field]
+
+          case column
+          when Types::AggregateColumn, Types::ExpressionColumn
+            selects << column.select_node
+          when Types::AssociationColumn
+            association_load_values << association_path_to_association_load(column.association_path)
+          when Types::RubyColumn
+            association_load_values << column.includes if column.includes
+
+            loader = spec.ruby_loaders&.[](column.loader)
+            association_load_values << loader[:includes] if loader && loader[:includes]
+          end
+        end
+
+        if association_load_values.any?
+          scope = apply_association_loading(scope, association_load_values)
+        end
+
+        scope = scope.select(selects.to_a)
+        records = scope.to_a
+
+        ruby_loaded_data = nil
+        if spec.ruby_loaders&.any?
+          ruby_loaded_data = LazyLoaderCache.new(records)
+          spec.ruby_loaders.each { |key, loader| ruby_loaded_data[key] = loader[:block] }
+        end
+
+        @records = records
+        @ruby_loaded_data = ruby_loaded_data
+        [records, ruby_loaded_data]
+      end
+
+      private
+
+      if ActiveRecordVersion.legacy?
+        def apply_association_loading(scope, association_load_values)
+          scope.preload(*association_load_values)
+        end
+      else
+        def apply_association_loading(scope, association_load_values)
+          scope.includes(*association_load_values)
+        end
+      end
+
+      def association_path_to_association_load(path)
+        head, *tail = path
+        return head if tail.empty?
+
+        { head => association_path_to_association_load(tail) }
+      end
+
+      def initialize(dataset, ruby_loaded_data, materialization_fields)
+        @dataset = dataset
+        @ruby_loaded_data = ruby_loaded_data
+        @materialization_fields = materialization_fields
+      end
+    end
+  end
+end

data/lib/prato/internal/specification.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Prato
+  module Internal
+    class Specification
+      attr_reader :columns, :visible_fields, :ruby_loaders, :field_lookup, :config
+
+      def initialize(columns:,
+                     visible_fields:,
+                     filterable_fields:,
+                     sortable_fields:,
+                     output_paths:,
+                     field_lookup:,
+                     ruby_loaders:,
+                     config:)
+        @columns = columns
+        @visible_fields = visible_fields
+        @filterable_fields = filterable_fields
+        @sortable_fields = sortable_fields
+        @output_paths = output_paths
+        @field_lookup = field_lookup
+        @ruby_loaders = ruby_loaders
+        @config = config
+      end
+
+      def validate_and_extract_materialization_fields(params)
+        return @visible_fields if params.nil?
+
+        fields = []
+
+        return nil unless collect_filter_fields(params.filters, fields)
+        return nil unless collect_sort_fields(params.sorts, fields)
+        return nil unless collect_display_fields(params.fields, fields)
+
+        fields.uniq
+      end
+
+      def field_mapping(field_name)
+        @output_paths[field_name]
+      end
+
+      def sql_only?(display_fields)
+        display_fields.none? { |f| @columns[f].is_a?(Types::RubyColumn) }
+      end
+
+      private
+
+      def collect_filter_fields(filters, fields)
+        return true if filters.nil?
+
+        Array(filters).all? do |filter|
+          case filter
+          when Query::Filter
+            if @filterable_fields.include?(filter.field) && valid_filter_operator?(filter)
+              fields << filter.field
+              true
+            else
+              false
+            end
+          when Query::AndFilter, Query::OrFilter
+            collect_filter_fields(filter.filters, fields)
+          end
+        end
+      end
+
+      def collect_sort_fields(sorts, fields)
+        return true if sorts.nil?
+
+        Array(sorts).all? do |sort|
+          if @sortable_fields.include?(sort.field)
+            fields << sort.field
+            true
+          else
+            false
+          end
+        end
+      end
+
+      def collect_display_fields(display, fields)
+        if display.nil?
+          fields.concat(@visible_fields)
+          return true
+        end
+
+        Array(display).all? do |field|
+          if @visible_fields.include?(field)
+            fields << field
+            true
+          else
+            false
+          end
+        end
+      end
+
+      def valid_filter_operator?(filter)
+        column_filter = @columns[filter.field].filter
+        !column_filter.is_a?(Array) || column_filter.include?(filter.operator)
+      end
+    end
+  end
+end