filter_param 0.1.0

data/lib/filter_param/transpiler.rb

@@ -0,0 +1,114 @@
+module FilterParam
+  class Transpiler
+    def initialize(ar_relation, definition)
+      @ar_relation = ar_relation
+      @definition = definition
+    end
+
+    def transpile!(string_expression)
+      return nil if string_expression.blank?
+
+      ast_root = parse(string_expression)
+
+      visit(ast_root)
+    end
+
+    private
+
+    attr_reader :ar_relation, :definition
+
+    def ar_model
+      @ar_relation.model
+    end
+
+    def parse(string_expression)
+      parse_tree = Parser.new.parse(string_expression, reporter: Parslet::ErrorReporter::Deepest.new)
+
+      Transformer.new.apply(parse_tree)
+    end
+
+    def field_for_name(name)
+      definition.find_field!(name)
+    end
+
+    def visit(node)
+      return node unless node.respond_to?(:accept)
+
+      node.accept(self)
+    end
+
+    def visit_group(group)
+      expression = visit(group.expression)
+
+      Operator.for(:group).sql(expression)
+    end
+
+    def visit_scope(scope)
+      actual_scope_name = definition.find_scope!(scope.name)
+                                    .actual_name
+      scope_args = scope.args.map { |arg| visit(arg) }
+
+      scope_sql = ar_model.send(actual_scope_name, *scope_args)
+                          .select(ar_model.primary_key)
+                          .to_sql
+
+      "(#{ar_model.primary_key} IN (#{scope_sql}))"
+    end
+
+    def visit_attribute(attribute)
+      field_for_name(attribute.name)
+    end
+
+    def visit_literal(literal)
+      literal.value
+    end
+
+    def visit_unary_expression(expression)
+      operator_symbol = expression.operator
+      operand = expression.operand
+      return transpile_negated_expression(operand) if operator_symbol == :not
+
+      operand = visit(operand)
+      Operator.for(operator_symbol).sql(operand)
+    end
+
+    def visit_binary_expression(expression)
+      operator_symbol = expression.operator
+      operator = Operator.for(operator_symbol)
+
+      if operator < Operators::FieldFilterOperator
+        field = visit(expression.left_operand)
+        literal = expression.right_operand
+        literal.value = field.transform_value(literal.value)
+
+        return operator.sql(field, literal.type_cast(field.type))
+      end
+
+      operator.sql(visit(expression.left_operand),
+                   visit(expression.right_operand))
+    end
+
+    def transpile_negated_expression(expression)
+      operator_tag = expression.operator
+      operator = Operator.for(operator_tag)
+      not_operator = Operator.for(:not)
+
+      if operator < Operators::FieldFilterOperator
+        # TODO: refactor
+        if operator.type == :binary
+          field = visit(expression.left_operand)
+          literal = expression.right_operand
+          literal.value = field.transform_value(literal.value)
+
+          return not_operator.sql(operator_tag, field, literal.type_cast(field.type))
+        else
+          return not_operator.sql(operator_tag, visit(expression.operand))
+        end
+      end
+
+      operands = expression.operands.map { |operand| visit(operand) }
+
+      not_operator.sql(operator_tag, *operands)
+    end
+  end
+end

data/lib/filter_param/version.rb

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

data/lib/filter_param.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "parslet"
+require "active_record"
+require "active_support"
+require "active_support/core_ext/object/inclusion"
+require_relative "filter_param/ast/node"
+require_relative "filter_param/ast/attribute"
+require_relative "filter_param/ast/expressions"
+require_relative "filter_param/ast/group"
+require_relative "filter_param/ast/scope"
+require_relative "filter_param/ast/literal"
+require_relative "filter_param/ast/literals/null"
+require_relative "filter_param/ast/literals/string"
+require_relative "filter_param/ast/literals/boolean"
+require_relative "filter_param/ast/literals/integer"
+require_relative "filter_param/ast/literals/decimal"
+require_relative "filter_param/ast/literals/date"
+require_relative "filter_param/ast/literals/date_time"
+require_relative "filter_param/operator"
+require_relative "filter_param/operators/group"
+require_relative "filter_param/operators/field_filter_operator"
+require_relative "filter_param/operators/and"
+require_relative "filter_param/operators/or"
+require_relative "filter_param/operators/not"
+require_relative "filter_param/operators/equal"
+require_relative "filter_param/operators/not_equal"
+require_relative "filter_param/operators/case_insensitive_equal"
+require_relative "filter_param/operators/less_than"
+require_relative "filter_param/operators/less_than_equal"
+require_relative "filter_param/operators/greater_than"
+require_relative "filter_param/operators/greater_than_equal"
+require_relative "filter_param/operators/starts_with"
+require_relative "filter_param/operators/ends_with"
+require_relative "filter_param/operators/contains"
+require_relative "filter_param/operators/present"
+require_relative "filter_param/transformer"
+require_relative "filter_param/parser"
+require_relative "filter_param/transpiler"
+require_relative "filter_param/field"
+require_relative "filter_param/scope"
+require_relative "filter_param/definition"
+require_relative "filter_param/version"
+
+module FilterParam
+  class BaseError < StandardError; end
+  class UnknownType < BaseError; end
+  class ExpressionError < BaseError; end
+  class UnknownField < BaseError; end
+  class UnknownScope < BaseError; end
+  class InvalidLiteral < ExpressionError; end
+  class ParseError < ExpressionError; end
+
+  # Creates a new FilterParam definition that whitelists the columns that are allowed to
+  # be filtered (i.e. used in SQL WHERE).
+  #
+  # @param [Proc] block Field definition block
+  #
+  # @example
+  #  FilterParam.define do
+  #    fields :first_name, :last_name
+  #    field :birth_date, rename: bdate
+  #  end
+  #
+  # @return [Definition] Filter param definition
+  #
+  def self.define(&block)
+    Definition.new.define(&block)
+  end
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: filter_param
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Uy Jayson B
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-05-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+description: Filter records using a SCIM inspired filter expression
+email:
+- uy.json.dev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/filter_param.rb
+- lib/filter_param/ast/attribute.rb
+- lib/filter_param/ast/expressions.rb
+- lib/filter_param/ast/group.rb
+- lib/filter_param/ast/literal.rb
+- lib/filter_param/ast/literals/boolean.rb
+- lib/filter_param/ast/literals/date.rb
+- lib/filter_param/ast/literals/date_time.rb
+- lib/filter_param/ast/literals/decimal.rb
+- lib/filter_param/ast/literals/integer.rb
+- lib/filter_param/ast/literals/null.rb
+- lib/filter_param/ast/literals/string.rb
+- lib/filter_param/ast/node.rb
+- lib/filter_param/ast/scope.rb
+- lib/filter_param/definition.rb
+- lib/filter_param/field.rb
+- lib/filter_param/operator.rb
+- lib/filter_param/operators/and.rb
+- lib/filter_param/operators/case_insensitive_equal.rb
+- lib/filter_param/operators/contains.rb
+- lib/filter_param/operators/ends_with.rb
+- lib/filter_param/operators/equal.rb
+- lib/filter_param/operators/field_filter_operator.rb
+- lib/filter_param/operators/greater_than.rb
+- lib/filter_param/operators/greater_than_equal.rb
+- lib/filter_param/operators/group.rb
+- lib/filter_param/operators/less_than.rb
+- lib/filter_param/operators/less_than_equal.rb
+- lib/filter_param/operators/not.rb
+- lib/filter_param/operators/not_equal.rb
+- lib/filter_param/operators/or.rb
+- lib/filter_param/operators/present.rb
+- lib/filter_param/operators/starts_with.rb
+- lib/filter_param/parser.rb
+- lib/filter_param/scope.rb
+- lib/filter_param/transformer.rb
+- lib/filter_param/transpiler.rb
+- lib/filter_param/version.rb
+homepage: https://github.com/jsonb-uy/filter_param
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jsonb-uy/filter_param
+  source_code_uri: https://github.com/jsonb-uy/filter_param
+  changelog_uri: https://github.com/jsonb-uy/filter_param/blob/main/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/github/jsonb-uy/filter_param/main
+  bug_tracker_uri: https://github.com/jsonb-uy/filter_param/issues
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.6
+signing_key:
+specification_version: 4
+summary: SCIM-style API filter for ActiveRecord-based apps
+test_files: []