dynamoid_advanced_where 1.0.0

data/lib/dynamoid_advanced_where/filter_builder.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative './nodes/null_node'
+
+module DynamoidAdvancedWhere
+  class FilterBuilder
+    VALID_COMPARETORS_FOR_RANGE_FILTER = [
+      Nodes::GreaterThanNode
+    ].freeze
+
+    attr_accessor :expression_node, :klass
+
+    def initialize(root_node:, klass:)
+      self.expression_node = root_node.child_node
+      self.klass = klass
+    end
+
+    def index_nodes
+      [
+        extract_query_filter_node,
+        extract_range_key_node
+      ].compact
+    end
+
+    def to_query_filter
+      {
+        key_condition_expression: key_condition_expression
+      }.merge!(expression_filters)
+    end
+
+    def to_scan_filter
+      expression_filters
+    end
+
+    def must_scan?
+      !extract_query_filter_node.is_a?(Nodes::BaseNode)
+    end
+
+    private
+
+    def key_condition_expression
+      @key_condition_expression ||= [
+        extract_query_filter_node,
+        extract_range_key_node
+      ].compact.map(&:to_expression).join(' AND ')
+    end
+
+    def expression_attribute_names
+      [
+        expression_node,
+        *index_nodes
+      ].map(&:expression_attribute_names).inject({}, &:merge!)
+    end
+
+    def expression_attribute_values
+      [
+        expression_node,
+        *index_nodes
+      ].map(&:expression_attribute_values).inject({}, &:merge!)
+    end
+
+    def expression_filters
+      {
+        filter_expression: expression_node.to_expression,
+        expression_attribute_names: expression_attribute_names,
+        expression_attribute_values: expression_attribute_values
+      }.delete_if { |_, v| v.nil? || v.empty? }
+    end
+
+    def extract_query_filter_node
+      @extract_query_filter_node ||=
+        case expression_node
+        when Nodes::EqualityNode
+          node = expression_node
+          if field_node_valid_for_key_filter(expression_node)
+            self.expression_node = Nodes::NullNode.new
+            node
+          end
+        when Nodes::AndNode
+          id_filters = expression_node.child_nodes.select do |i|
+            field_node_valid_for_key_filter(i)
+          end
+
+          if id_filters.length == 1
+            self.expression_node = Nodes::AndNode.new(
+              *(expression_node.child_nodes - id_filters)
+            )
+
+            id_filters.first
+          end
+        end
+    end
+
+    def field_node_valid_for_key_filter(node)
+      node.is_a?(Nodes::EqualityNode) &&
+        node.lh_operation.is_a?(Nodes::FieldNode) &&
+        node.lh_operation.field_path.length == 1 &&
+        node.lh_operation.field_path[0].to_s == hash_key
+    end
+
+    def extract_range_key_node
+      return unless extract_query_filter_node
+
+      @extract_range_key_node ||=
+        case expression_node
+        when Nodes::AndNode
+          id_filters = expression_node.child_nodes.select do |i|
+            field_node_valid_for_range_filter(i)
+          end
+
+          if id_filters.length == 1
+            self.expression_node = Nodes::AndNode.new(
+              *(expression_node.child_nodes - id_filters)
+            )
+
+            id_filters.first
+          end
+        end
+    end
+
+    def field_node_valid_for_range_filter(node)
+      node.lh_operation.is_a?(Nodes::FieldNode) &&
+        node.lh_operation.field_path.length == 1 &&
+        node.lh_operation.field_path[0].to_s == range_key &&
+        VALID_COMPARETORS_FOR_RANGE_FILTER.any? { |type| node.is_a?(type) }
+    end
+
+    def hash_key
+      @hash_key ||= klass.hash_key.to_s
+    end
+
+    def range_key
+      @range_key ||= klass.range_key.to_s
+    end
+  end
+end

data/lib/dynamoid_advanced_where/integrations/model.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'dynamoid_advanced_where/query_builder'
+
+module DynamoidAdvancedWhere
+  # Allows classes to be queried by where, all, first, and each and return criteria chains.
+  module Integrations
+    module Model
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def advanced_where(&blk)
+          DynamoidAdvancedWhere::QueryBuilder.new(klass: self, &blk)
+        end
+
+        def batch_update
+          advanced_where {}.batch_update
+        end
+
+        def where(*args, &blk)
+          if !args.empty?
+            raise ArgumentError, 'You may not specify where arguments and block' if blk
+
+            super(*args)
+          else
+            DynamoidAdvancedWhere::QueryBuilder.new(klass: self, &blk)
+          end
+        end
+      end
+    end
+  end
+end
+
+Dynamoid::Document.send(:include, DynamoidAdvancedWhere::Integrations::Model)

data/lib/dynamoid_advanced_where/nodes.rb

@@ -0,0 +1,15 @@
+require_relative './nodes/base_node'
+require_relative './nodes/field_node'
+require_relative './nodes/literal_node'
+require_relative './nodes/operation_node'
+require_relative './nodes/root_node'
+require_relative './nodes/and_node'
+require_relative './nodes/or_node'
+
+require_relative './nodes/equality_node'
+require_relative './nodes/exists_node'
+require_relative './nodes/includes'
+
+require_relative './nodes/greater_than_node'
+
+require_relative './nodes/less_than_node'

data/lib/dynamoid_advanced_where/nodes/and_node.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module DynamoidAdvancedWhere
+  module Nodes
+    class AndNode < BaseNode
+      include Concerns::Negatable
+      attr_accessor :child_nodes
+
+      def initialize(*child_nodes)
+        self.child_nodes = child_nodes.freeze
+        freeze
+      end
+
+      def to_expression
+        return if child_nodes.empty?
+
+        "(#{child_nodes.map(&:to_expression).join(') and (')})"
+      end
+
+      def expression_attribute_names
+        child_nodes.map(&:expression_attribute_names).inject({}, &:merge!)
+      end
+
+      def expression_attribute_values
+        child_nodes.map(&:expression_attribute_values).inject({}, &:merge!)
+      end
+
+      def and(other_value)
+        AndNode.new(other_value, *child_nodes)
+      end
+      alias & and
+    end
+
+    module Concerns
+      module SupportsLogicalAnd
+        def and(other_value)
+          AndNode.new(self, other_value)
+        end
+        alias & and
+      end
+    end
+  end
+end

data/lib/dynamoid_advanced_where/nodes/base_node.rb

@@ -0,0 +1,18 @@
+require 'securerandom'
+
+module DynamoidAdvancedWhere
+  module Nodes
+    class BaseNode
+      attr_accessor :expression_prefix
+
+      def expression_attribute_names
+        {}
+      end
+
+      def expression_attribute_values
+        {}
+      end
+    end
+  end
+end
+

data/lib/dynamoid_advanced_where/nodes/equality_node.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative './operation_node'
+require_relative './not'
+
+module DynamoidAdvancedWhere
+  module Nodes
+    class EqualityNode < OperationNode
+      include Concerns::Negatable
+
+      self.operator = '='
+    end
+
+    module Concerns
+      module SupportsEquality
+        def eq(other_value)
+          val = if respond_to?(:parse_right_hand_side)
+                  parse_right_hand_side(other_value)
+                else
+                  other_value
+                end
+
+          EqualityNode.new(
+            lh_operation: self,
+            rh_operation: LiteralNode.new(val)
+          )
+        end
+        alias == eq
+
+        def not_eq(other_value)
+          eq(other_value).negate
+        end
+        alias != not_eq
+      end
+    end
+  end
+end

data/lib/dynamoid_advanced_where/nodes/exists_node.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module DynamoidAdvancedWhere
+  module Nodes
+    class ExistsNode < BaseNode
+      include Concerns::Negatable
+
+      attr_accessor :field_node, :prefix
+      def initialize(field_node:)
+        self.field_node = field_node
+        self.prefix = SecureRandom.hex
+        freeze
+      end
+
+      def to_expression
+        "NOT(
+          attribute_not_exists(#{field_node.to_expression})
+          or #{field_node.to_expression} = :#{prefix}
+        )"
+      end
+
+      def expression_attribute_names
+        field_node.expression_attribute_names
+      end
+
+      def expression_attribute_values
+        {
+          ":#{prefix}" => nil
+        }
+      end
+    end
+
+    module Concerns
+      module SupportsExistance
+        def exists?
+          ExistsNode.new(field_node: self)
+        end
+        alias present? exists?
+      end
+    end
+  end
+end

data/lib/dynamoid_advanced_where/nodes/field_node.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require_relative './equality_node'
+require_relative './greater_than_node'
+require_relative './exists_node'
+require_relative './includes'
+require_relative './subfield'
+
+module DynamoidAdvancedWhere
+  module Nodes
+    class FieldNode < BaseNode
+      include Concerns::SupportsEquality
+      include Concerns::SupportsExistance
+
+      attr_accessor :field_path, :attr_prefix
+
+      class << self
+        def create_node(field_path:, attr_config:)
+          specific_klass = FIELD_MAPPING.detect do |config, _type|
+            config.respond_to?(:call) ? config.call(attr_config) : config <= attr_config
+          end&.last
+
+          unless specific_klass
+            raise ArgumentError, "unable to find field type for `#{attr_config}`"
+          end
+
+          specific_klass.new(field_path: field_path)
+        end
+      end
+
+      def initialize(field_path:)
+        self.field_path = field_path.is_a?(Array) ? field_path : [field_path]
+        self.attr_prefix = SecureRandom.hex
+        freeze
+      end
+
+      def to_expression
+        String.new.tap do |s|
+          field_path.collect.with_index do |segment, i|
+            if segment.is_a?(Integer)
+              s << "[#{segment}]"
+            else
+              s << '.' unless s.blank?
+              s << "##{attr_prefix}#{i}"
+            end
+          end
+        end
+      end
+
+      def expression_attribute_names
+        field_path.each_with_object({}).with_index do |(segment, hsh), i|
+          next if segment.is_a?(Integer)
+
+          hsh["##{attr_prefix}#{i}"] = segment
+        end
+      end
+
+      def expression_attribute_values
+        {}
+      end
+    end
+
+    class StringAttributeNode < FieldNode
+      include Concerns::SupportsIncludes
+    end
+    class NativeBooleanAttributeNode < FieldNode; end
+
+    class StringBooleanAttributeNode < FieldNode
+      def parse_right_hand_side(val)
+        val ? 't' : 'f'
+      end
+    end
+
+    class NumberAttributeNode < FieldNode
+      include Concerns::SupportsGreaterThan
+
+      ALLOWED_COMPARISON_TYPES = [
+        Numeric
+      ].freeze
+
+      def parse_right_hand_side(val)
+        unless ALLOWED_COMPARISON_TYPES.detect { |k| val.is_a?(k) }
+          raise ArgumentError, "unable to compare number to `#{val.class}`"
+        end
+
+        val
+      end
+    end
+
+    class NumericDatetimeAttributeNode < FieldNode
+      include Concerns::SupportsGreaterThan
+
+      def parse_right_hand_side(val)
+        if val.is_a?(Date)
+          val.to_time.to_i
+        elsif val.is_a?(Time)
+          val.to_f
+        else
+          raise ArgumentError, "unable to compare datetime to type #{val.class}"
+        end
+      end
+    end
+
+    class NumericDateAttributeNode < FieldNode
+      include Concerns::SupportsGreaterThan
+
+      def parse_right_hand_side(val)
+        if !val.is_a?(Date) || val.is_a?(DateTime)
+          raise ArgumentError, "unable to compare date to type #{val.class}"
+        end
+
+        (val - Dynamoid::Persistence::UNIX_EPOCH_DATE).to_i
+      end
+    end
+
+    class StringSetAttributeNode < FieldNode
+      include Concerns::SupportsIncludes
+
+      def parse_right_hand_side(val)
+        unless val.is_a?(String)
+          raise ArgumentError, "unable to compare date to type #{val.class}"
+        end
+
+        val
+      end
+    end
+
+    class IntegerSetAttributeNode < FieldNode
+      include Concerns::SupportsIncludes
+
+      def parse_right_hand_side(val)
+        unless val.is_a?(Integer)
+          raise ArgumentError, "unable to compare date to type #{val.class}"
+        end
+
+        val
+      end
+    end
+
+    class MapAttributeNode < FieldNode
+      include Concerns::SupportsSubFields
+    end
+
+    class RawAttributeNode < FieldNode
+      include Concerns::SupportsSubFields
+    end
+
+    class CustomClassAttributeNode < FieldNode
+      include Concerns::SupportsSubFields
+    end
+
+    FIELD_MAPPING = {
+      { type: :string } => StringAttributeNode,
+      { type: :number } => NumberAttributeNode,
+
+      # Boolean Fields
+      { type: :boolean, store_as_native_boolean: true } =>
+        NativeBooleanAttributeNode,
+      { type: :boolean, store_as_native_boolean: false } =>
+        StringBooleanAttributeNode,
+
+      # Datetime fields
+      { type: :datetime, store_as_string: true } => nil,
+      { type: :datetime, store_as_string: false } => NumericDatetimeAttributeNode,
+      { type: :datetime } => NumericDatetimeAttributeNode,
+
+      # Date fields
+      { type: :date, store_as_string: true } => nil,
+      { type: :date, store_as_string: false } => NumericDateAttributeNode,
+      { type: :date } => NumericDateAttributeNode,
+
+      # Set Types
+      { type: :set, of: :string } => StringSetAttributeNode,
+      { type: :set, of: :integer } => IntegerSetAttributeNode,
+
+      # Map Types
+      { type: :map } => MapAttributeNode,
+
+      # Raw Types
+      { type: :raw } => RawAttributeNode,
+
+      # Custom Object
+      ->(c) { c[:type].is_a?(Class) } => CustomClassAttributeNode
+    }.freeze
+  end
+end