prato 0.1.0

data/lib/prato/query/parameters.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Prato
+  module Query
+    class Parameters
+      attr_reader :page, :per_page, :filters, :sorts, :fields
+
+      def initialize(page: nil, per_page: nil, filters: nil, sorts: nil, fields: nil)
+        @page = page
+        @per_page = per_page
+        @filters = filters
+        @sorts = sorts
+        @fields = fields
+      end
+    end
+  end
+end

data/lib/prato/query/sort.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Prato
+  module Query
+    class Sort
+      attr_reader :field, :is_desc
+
+      def initialize(field, is_desc)
+        @field = field
+        @is_desc = is_desc
+      end
+    end
+  end
+end

data/lib/prato/table.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Prato
+  class Table
+    def initialize(spec)
+      @spec = spec
+    end
+
+    def page(scope, params = nil)
+      Internal::QueryExecutor.execute(
+        scope,
+        @spec,
+        raw_params: params,
+        paginated: true
+      )
+    end
+
+    def full(scope, params = nil)
+      Internal::QueryExecutor.execute(
+        scope,
+        @spec,
+        raw_params: params,
+        paginated: false
+      )
+    end
+
+    def batches(scope, params = nil, batch_size: 1000, &block)
+      return enum_for(:batches, scope, params, batch_size: batch_size) unless block
+
+      Internal::QueryExecutor.execute_in_batches(
+        scope,
+        @spec,
+        raw_params: params,
+        batch_size: batch_size,
+        &block
+      )
+    end
+  end
+end

data/lib/prato/table_builder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Prato
+  class TableBuilder
+
+    attr_reader :spec_builder
+
+    def initialize
+      @spec_builder = Internal::SpecificationBuilder.new
+    end
+
+    def column(*args, **kwargs)
+      @spec_builder.inner_column(*args, **kwargs)
+    end
+
+    def ruby_column(*args, **kwargs, &block)
+      @spec_builder.inner_ruby_column(*args, **kwargs, &block)
+    end
+
+    def query_column(*args, **kwargs)
+      @spec_builder.inner_query_column(*args, **kwargs)
+    end
+
+    def section(id, &block)
+      raise ArgumentError, "Section requires a block" unless block_given?
+      raise ArgumentError, "Section block must not accept arguments" unless block.parameters.empty?
+
+      @spec_builder.inner_section(id, &block)
+    end
+
+    def ruby_loader(id, **kwargs, &block)
+      @spec_builder.inner_ruby_loader(id, **kwargs, &block)
+    end
+
+    def configure(config = nil, **overrides)
+      resolved_config = Configuration.with_settings(config, **overrides)
+      @spec_builder.inner_config(resolved_config)
+    end
+  end
+end

data/lib/prato/types/aggregate_column.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Prato
+  module Types
+    class AggregateColumn
+      attr_reader :arel_node, :format, :filter
+
+      def initialize(aggregate_function, aggregate_accessor, format: nil, filter: nil)
+        @accessor = Array(aggregate_accessor)
+        @aggregate_function = aggregate_function
+        @format = format
+        @filter = filter
+      end
+
+      def resolve_arel!(base_model, display_id)
+        association_path = @aggregate_function == :count ? @accessor : @accessor[0..-2]
+        aggregate_field = @aggregate_function == :count ? nil : @accessor[-1]
+
+        reflections = resolve_reflections(base_model, association_path)
+        base_table = base_model.arel_table
+        aliased_tables = reflections.each_with_index.map do |reflection, index|
+          Arel::Table.new(reflection.klass.table_name, as: "prato_agg_#{index}_#{reflection.klass.table_name}")
+        end
+        target_table = aliased_tables.last
+
+        subquery = target_table.project(aggregate_expression(target_table, @aggregate_function, aggregate_field))
+
+        (reflections.length - 1).downto(1) do |i|
+          ref = reflections[i]
+          source_table = aliased_tables[i - 1]
+          subquery = subquery.join(source_table).on(
+            association_condition(ref, source_table, aliased_tables[i])
+          )
+        end
+
+        first_ref = reflections.first
+        subquery = subquery.where(
+          association_condition(first_ref, base_table, aliased_tables.first)
+        )
+
+        @arel_node = Arel::Nodes::Grouping.new(subquery)
+        @sql_alias = display_id.to_s
+      end
+
+      def sql_node_for(_scope)
+        @arel_node
+      end
+
+      def select_node
+        Arel::Nodes::As.new(@arel_node, Arel.sql(@sql_alias))
+      end
+
+      def extract_value(record, _)
+        record[@sql_alias]
+      end
+
+      private
+
+      def resolve_reflections(base_model, path)
+        current_model = base_model
+        path.map do |assoc_name|
+          reflection = current_model.reflect_on_association(assoc_name)
+          raise ArgumentError, "Unknown association '#{assoc_name}' on #{current_model}" unless reflection
+
+          current_model = reflection.klass
+          reflection
+        end
+      end
+
+      def association_condition(reflection, source_table, target_table)
+        if reflection.macro == :belongs_to
+          source_table[reflection.foreign_key].eq(
+            target_table[reflection.active_record_primary_key]
+          )
+        else
+          target_table[reflection.foreign_key].eq(
+            source_table[reflection.active_record_primary_key]
+          )
+        end
+      end
+
+      def aggregate_expression(table, aggregate_function, aggregate_field)
+        case aggregate_function
+        when :count then Arel.star.count
+        when :sum   then Arel::Nodes::NamedFunction.new("COALESCE", [table[aggregate_field].sum, 0])
+        when :avg   then table[aggregate_field].average
+        when :min   then table[aggregate_field].minimum
+        when :max   then table[aggregate_field].maximum
+        end
+      end
+    end
+  end
+end

data/lib/prato/types/association_column.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Prato
+  module Types
+    class AssociationColumn
+      attr_reader :association_path, :format, :filter
+
+      def initialize(accessor, format: nil, filter: nil)
+        @association_path = accessor[0..-2].map(&:to_sym).freeze
+        @attribute_name = accessor[-1].to_sym
+        @format = format
+        @filter = filter
+      end
+
+      def resolve_arel!(base_model, _display_id)
+        current_model = base_model
+
+        @association_path.each do |assoc_name|
+          reflection = current_model.reflect_on_association(assoc_name)
+          raise ArgumentError, "Unknown association '#{assoc_name}' on #{current_model}" unless reflection
+
+          current_model = reflection.klass
+        end
+      end
+
+      def sql_node_for(scope)
+        table = Internal::SqlSupport.table_for(scope, @association_path)
+        table[@attribute_name]
+      end
+
+      def extract_value(record, _ruby_data)
+        target = @association_path.reduce(record) { |obj, assoc| obj&.public_send(assoc) }
+        target&.[](@attribute_name)
+      end
+    end
+  end
+end

data/lib/prato/types/direct_column.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Prato
+  module Types
+    class DirectColumn
+      attr_reader :format, :filter
+
+      def initialize(accessor, format: nil, filter: nil)
+        @attribute_name = accessor.is_a?(Array) ? accessor.first : accessor
+        @format = format
+        @filter = filter
+      end
+
+      def resolve_arel!(base_model, _display_id)
+        @arel_node = base_model.arel_table[@attribute_name]
+      end
+
+      def sql_node_for(_scope)
+        @arel_node
+      end
+
+      def extract_value(record, _ruby_data)
+        record[@attribute_name]
+      end
+    end
+  end
+end

data/lib/prato/types/expression_column.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Prato
+  module Types
+    class ExpressionColumn
+      attr_reader :arel_node, :format, :filter
+
+      def initialize(expression, format: nil, filter: nil)
+        @expression = expression
+        @format = format
+        @filter = filter
+      end
+
+      def resolve_arel!(base_model, display_id)
+        expression_sql = if @expression.is_a?(Symbol)
+                           base_model.public_send(@expression)
+                         else
+                           @expression
+                         end
+
+        @sql_alias = display_id.to_s
+        @arel_node = Arel::Nodes::Grouping.new(Arel.sql(expression_sql))
+      end
+
+      def sql_node_for(_scope)
+        @arel_node
+      end
+
+      def select_node
+        Arel::Nodes::As.new(@arel_node, Arel.sql(@sql_alias))
+      end
+
+      def extract_value(record, _)
+        record[@sql_alias]
+      end
+    end
+  end
+end

data/lib/prato/types/ruby_column.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Prato
+  module Types
+    class RubyColumn
+      attr_reader :loader, :filter, :includes
+
+      def initialize(loader, key:, filter: nil, includes: nil)
+        @loader = loader
+        @key = key || :id
+        @filter = filter
+        @includes = includes
+      end
+
+      def extract_value(record, ruby_data)
+        key_value = case @key
+                    when Proc
+                      @key.call(record)
+                    when Array
+                      @key.reduce(record) { |obj, method| obj.public_send(method) }
+                    when Symbol
+                      record.public_send(@key)
+                    else
+                      @key
+                    end
+
+        ruby_data[@loader]&.[](key_value)
+      end
+    end
+  end
+end

data/lib/prato/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Prato
+  VERSION = '0.1.0'
+end

data/lib/prato.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "prato/version"
+
+require_relative "prato/query/filter"
+require_relative "prato/query/sort"
+require_relative "prato/query/and_filter"
+require_relative "prato/query/or_filter"
+require_relative "prato/query/parameters"
+require_relative "prato/query/field_resolver"
+require_relative "prato/query/default_parser"
+
+require_relative "prato/configuration"
+
+require_relative "prato/types/association_column"
+require_relative "prato/types/direct_column"
+require_relative "prato/types/expression_column"
+require_relative "prato/types/aggregate_column"
+require_relative "prato/types/ruby_column"
+
+require_relative "prato/internal/active_record_version"
+require_relative "prato/internal/lazy_loader_cache"
+
+if Prato::Internal::ActiveRecordVersion.legacy?
+  require_relative "prato/internal/join_helper_legacy"
+else
+  require_relative "prato/internal/join_helper"
+end
+
+require_relative "prato/internal/sql_support"
+require_relative "prato/internal/query_state"
+require_relative "prato/internal/specification"
+require_relative "prato/internal/specification_builder"
+
+require_relative "prato/internal/pipeline/filtering"
+require_relative "prato/internal/pipeline/pagination"
+require_relative "prato/internal/pipeline/serializer"
+require_relative "prato/internal/pipeline/sorting"
+
+require_relative "prato/table"
+require_relative "prato/table_builder"
+require_relative "prato/internal/query_executor"
+
+module Prato
+  extend self
+
+  def table(base_model, &block)
+    raise ArgumentError, "Prato.table requires a block" unless block_given?
+    raise ArgumentError, "Prato.table block must not accept arguments" unless block.parameters.empty?
+
+    builder = TableBuilder.new
+    builder.instance_exec(&block)
+
+    spec = builder.spec_builder.build(base_model)
+
+    Table.new(spec)
+  end
+
+  def setup(&block)
+    if block_given?
+      Configuration.configure(&block)
+    else
+      Configuration.new
+    end
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: prato
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Valter Santos
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: "Prato is a library that simplifies the backend code required to support
+  queryable data, \nby mapping parameters onto a table structure, \nallowing Prato
+  to invoke Active Record methods like  `.where`, `.order`, `.joins`, `.pluck` and
+  others.\n\nThe immediate use case for this is fetching data for tables in the frontend,
+  \nand with a simple *Prato* table, it becomes trivial to provide any kind of filtering
+  / sorting / pagination operations \nover an Active Record relation.\n"
+email:
+- valter@trecitano.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/prato.rb
+- lib/prato/configuration.rb
+- lib/prato/internal/active_record_version.rb
+- lib/prato/internal/join_helper.rb
+- lib/prato/internal/join_helper_legacy.rb
+- lib/prato/internal/lazy_loader_cache.rb
+- lib/prato/internal/pipeline/filtering.rb
+- lib/prato/internal/pipeline/pagination.rb
+- lib/prato/internal/pipeline/serializer.rb
+- lib/prato/internal/pipeline/sorting.rb
+- lib/prato/internal/query_executor.rb
+- lib/prato/internal/query_state.rb
+- lib/prato/internal/specification.rb
+- lib/prato/internal/specification_builder.rb
+- lib/prato/internal/sql_support.rb
+- lib/prato/query/and_filter.rb
+- lib/prato/query/default_parser.rb
+- lib/prato/query/field_resolver.rb
+- lib/prato/query/filter.rb
+- lib/prato/query/or_filter.rb
+- lib/prato/query/parameters.rb
+- lib/prato/query/sort.rb
+- lib/prato/table.rb
+- lib/prato/table_builder.rb
+- lib/prato/types/aggregate_column.rb
+- lib/prato/types/association_column.rb
+- lib/prato/types/direct_column.rb
+- lib/prato/types/expression_column.rb
+- lib/prato/types/ruby_column.rb
+- lib/prato/version.rb
+homepage: https://prato.trecitano.com/
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://prato.trecitano.com/
+  source_code_uri: https://github.com/trecitano/prato
+  changelog_uri: https://github.com/trecitano/prato/releases
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Filter, sort, and paginate Active Record queries from a table definition.
+test_files: []