dynamoid_advanced_where 1.0.0

data/lib/dynamoid_advanced_where/nodes/greater_than_node.rb

@@ -0,0 +1,25 @@
+module DynamoidAdvancedWhere
+  module Nodes
+    class GreaterThanNode < OperationNode
+      self.operator = '>'
+    end
+
+    module Concerns
+      module SupportsGreaterThan
+        def gt(other_value)
+          val = if respond_to?(:parse_right_hand_side)
+                  parse_right_hand_side(other_value)
+                else
+                  other_value
+                end
+
+          GreaterThanNode.new(
+            lh_operation: self,
+            rh_operation: LiteralNode.new(val)
+          )
+        end
+        alias > gt
+      end
+    end
+  end
+end

data/lib/dynamoid_advanced_where/nodes/includes.rb

@@ -0,0 +1,29 @@
+module DynamoidAdvancedWhere
+  module Nodes
+    class IncludesNode < OperationNode
+      def to_expression
+        "contains(
+          #{lh_operation.to_expression},
+          #{rh_operation.to_expression}
+        )"
+      end
+    end
+
+    module Concerns
+      module SupportsIncludes
+        def includes?(other_value)
+          val = if respond_to?(:parse_right_hand_side)
+                  parse_right_hand_side(other_value)
+                else
+                  other_value
+                end
+
+          IncludesNode.new(
+            lh_operation: self,
+            rh_operation: LiteralNode.new(val)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/dynamoid_advanced_where/nodes/less_than_node.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DynamoidAdvancedWhere
+  module Nodes
+    class LessThanNode < OperationNode
+      self.operator = '<'
+    end
+
+    module Concerns
+      module SupportsGreaterThan
+        def lt(other_value)
+          val = if respond_to?(:parse_right_hand_side)
+                  parse_right_hand_side(other_value)
+                else
+                  other_value
+                end
+
+          LessThanNode.new(
+            lh_operation: self,
+            rh_operation: LiteralNode.new(val)
+          )
+        end
+        alias < lt
+      end
+    end
+  end
+end

data/lib/dynamoid_advanced_where/nodes/literal_node.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module DynamoidAdvancedWhere
+  module Nodes
+    class LiteralNode
+      attr_accessor :value, :attr_prefix
+      def initialize(value)
+        self.value = value
+        self.attr_prefix = SecureRandom.hex
+        freeze
+      end
+
+      def to_expression
+        ":#{attr_prefix}"
+      end
+
+      def expression_attribute_names
+        {}
+      end
+
+      def expression_attribute_values
+        { ":#{attr_prefix}" => value }
+      end
+    end
+  end
+end

data/lib/dynamoid_advanced_where/nodes/not.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module DynamoidAdvancedWhere
+  module Nodes
+    class NotNode
+      extend Forwardable
+
+      attr_accessor :sub_node
+
+      def_delegators :@sub_node,
+                     :expression_attribute_names,
+                     :expression_attribute_values
+
+      def initialize(sub_node:)
+        self.sub_node = sub_node
+        freeze
+      end
+
+      def to_expression
+        "NOT(#{sub_node.to_expression})"
+      end
+    end
+
+    module Concerns
+      module Negatable
+        def negate
+          NotNode.new(sub_node: self)
+        end
+        alias ! negate
+      end
+    end
+  end
+end

data/lib/dynamoid_advanced_where/nodes/null_node.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module DynamoidAdvancedWhere
+  module Nodes
+    class NullNode
+      def initialize
+        freeze
+      end
+
+      def to_expression
+        ''
+      end
+
+      def expression_attribute_names
+        {}
+      end
+
+      def expression_attribute_values
+        {}
+      end
+    end
+  end
+end

data/lib/dynamoid_advanced_where/nodes/operation_node.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative './not'
+require_relative './and_node'
+require_relative './or_node'
+
+module DynamoidAdvancedWhere
+  module Nodes
+    class OperationNode < BaseNode
+      include Concerns::Negatable
+      include Concerns::SupportsLogicalAnd
+      include Concerns::SupportsLogicalOr
+
+      class << self
+        attr_accessor :operator
+      end
+
+      attr_accessor :lh_operation, :rh_operation
+
+      def initialize(lh_operation:, rh_operation:)
+        self.lh_operation = lh_operation
+        self.rh_operation = rh_operation
+        freeze
+      end
+
+      def to_expression
+        "#{lh_operation.to_expression} #{self.class.operator} " \
+          "#{rh_operation.to_expression} "
+      end
+
+      def expression_attribute_names
+        lh_operation.expression_attribute_names.merge(
+          rh_operation.expression_attribute_names
+        )
+      end
+
+      def expression_attribute_values
+        lh_operation.expression_attribute_values.merge(
+          rh_operation.expression_attribute_values
+        )
+      end
+    end
+  end
+end

data/lib/dynamoid_advanced_where/nodes/or_node.rb

@@ -0,0 +1,41 @@
+module DynamoidAdvancedWhere
+  module Nodes
+    class OrNode < 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(') or (')})"
+      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 or(other_value)
+        OrNode.new(other_value, *child_nodes)
+      end
+      alias | or
+    end
+
+    module Concerns
+      module SupportsLogicalOr
+        def or(other_value)
+          OrNode.new(self, other_value)
+        end
+        alias | or
+      end
+    end
+  end
+end

data/lib/dynamoid_advanced_where/nodes/root_node.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require_relative './null_node'
+
+module DynamoidAdvancedWhere
+  module Nodes
+    class RootNode < BaseNode
+      extend Forwardable
+      attr_accessor :klass, :child_node
+
+      def initialize(klass:, &blk)
+        self.klass = klass
+        evaluate_block(blk) if blk
+        self.child_node ||= NullNode.new
+        freeze
+      end
+
+      def method_missing(method, *args, &blk)
+        if allowed_field?(method)
+          FieldNode.create_node(attr_config: klass.attributes[method], field_path: method)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, _i)
+        allowed_field?(method)
+      end
+
+      def allowed_field?(method)
+        klass.attributes.key?(method.to_sym)
+      end
+
+      private
+
+      def evaluate_block(blk)
+        self.child_node = if blk.arity.zero?
+                            Dynamoid.logger.warn 'Using DynamoidAdvancedWhere builder without an argument is now deprecated'
+                            instance_eval(&blk)
+                          else
+                            blk.call(self)
+                       end
+      end
+    end
+  end
+end

data/lib/dynamoid_advanced_where/nodes/subfield.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module DynamoidAdvancedWhere
+  module Nodes
+    module Concerns
+      module SupportsSubFields
+        def sub_field(*path, options)
+          Nodes::FieldNode.create_node(
+            field_path: field_path + path,
+            attr_config: options
+          )
+        end
+        alias dig sub_field
+      end
+    end
+  end
+end

data/lib/dynamoid_advanced_where/query_builder.rb

@@ -0,0 +1,47 @@
+require_relative './nodes'
+require_relative './query_materializer'
+require_relative './batched_updater'
+
+module DynamoidAdvancedWhere
+  class QueryBuilder
+    attr_accessor :klass, :root_node
+
+    delegate :all, :each, to: :query_materializer
+
+    def initialize(klass:, &blk)
+      self.klass = klass
+      self.root_node = Nodes::RootNode.new(klass: klass, &blk)
+    end
+
+    def query_materializer
+      QueryMaterializer.new(query_builder: self)
+    end
+
+    def batch_update
+      BatchedUpdater.new(query_builder: self)
+    end
+
+    def upsert(*args)
+      update_fields = args.extract_options!
+      batch_update.set_values(update_fields).apply(*args)
+    end
+
+    def where(other_builder = nil, &blk)
+      raise 'cannot use a block and an argument' if other_builder && blk
+
+      other_builder = self.class.new(klass: klass, &blk) if blk
+
+      raise 'passed argument must be a query builder' unless other_builder.is_a?(self.class)
+
+      local_root_node = root_node
+      self.class.new(klass: klass) do
+        Nodes::AndNode.new(
+          other_builder.root_node.child_node,
+          local_root_node.child_node
+        )
+      end
+    end
+    alias and where
+
+  end
+end

data/lib/dynamoid_advanced_where/query_materializer.rb

@@ -0,0 +1,73 @@
+require_relative './filter_builder'
+
+module DynamoidAdvancedWhere
+  class QueryMaterializer
+    include Enumerable
+    attr_accessor :query_builder
+
+
+    delegate :klass, to: :query_builder
+    delegate :table_name, to: :klass
+    delegate :to_a, :first, to: :each
+
+    delegate :must_scan?, to: :filter_builder
+
+    def initialize(query_builder:)
+      self.query_builder = query_builder
+    end
+
+    def all
+      each.to_a
+    end
+
+    def each(&blk)
+      return enum_for(:each) unless blk
+
+      if must_scan?
+        each_via_scan(&blk)
+      else
+        each_via_query(&blk)
+      end
+    end
+
+    def each_via_query
+      query = {
+        table_name: table_name,
+      }.merge(filter_builder.to_query_filter)
+
+      results = client.query(query)
+
+      if results.items
+        results.items.each do |item|
+          yield klass.from_database(item.symbolize_keys)
+        end
+      end
+    end
+
+    def each_via_scan
+      query = {
+        table_name: table_name
+      }.merge(filter_builder.to_scan_filter)
+
+      results = client.scan(query)
+
+      if results.items
+        results.items.each do |item|
+          yield klass.from_database(item.symbolize_keys)
+        end
+      end
+    end
+
+    def filter_builder
+      @filter_builder ||= FilterBuilder.new(
+        root_node: query_builder.root_node,
+        klass: klass,
+      )
+    end
+
+    private
+    def client
+      Dynamoid.adapter.client
+    end
+  end
+end