hanami-model 0.0.0 → 0.6.0

data/lib/hanami/model/adapters/implementation.rb

@@ -0,0 +1,111 @@
+module Hanami
+  module Model
+    module Adapters
+      # Shared implementation for SqlAdapter and MemoryAdapter
+      #
+      # @api private
+      # @since 0.1.0
+      module Implementation
+        # Creates or updates a record in the database for the given entity.
+        #
+        # @param collection [Symbol] the target collection (it must be mapped).
+        # @param entity [#id, #id=] the entity to persist
+        #
+        # @return [Object] the entity
+        #
+        # @api private
+        # @since 0.1.0
+        def persist(collection, entity)
+          if entity.id
+            update(collection, entity)
+          else
+            create(collection, entity)
+          end
+        end
+
+        # Returns all the records for the given collection
+        #
+        # @param collection [Symbol] the target collection (it must be mapped).
+        #
+        # @return [Array] all the records
+        #
+        # @api private
+        # @since 0.1.0
+        def all(collection)
+          # TODO consider to make this lazy (aka remove #all)
+          query(collection).all
+        end
+
+        # Returns a unique record from the given collection, with the given
+        # id.
+        #
+        # @param collection [Symbol] the target collection (it must be mapped).
+        # @param id [Object] the identity of the object.
+        #
+        # @return [Object] the entity
+        #
+        # @api private
+        # @since 0.1.0
+        def find(collection, id)
+          _first(
+            _find(collection, id)
+          )
+        end
+
+        # Returns the first record in the given collection.
+        #
+        # @param collection [Symbol] the target collection (it must be mapped).
+        #
+        # @return [Object] the first entity
+        #
+        # @api private
+        # @since 0.1.0
+        def first(collection)
+          _first(
+            query(collection).asc(_identity(collection))
+          )
+        end
+
+        # Returns the last record in the given collection.
+        #
+        # @param collection [Symbol] the target collection (it must be mapped).
+        #
+        # @return [Object] the last entity
+        #
+        # @api private
+        # @since 0.1.0
+        def last(collection)
+          _first(
+            query(collection).desc(_identity(collection))
+          )
+        end
+
+        private
+        def _collection(name)
+          raise NotImplementedError
+        end
+
+        def _mapped_collection(name)
+          @mapper.collection(name)
+        end
+
+        def _find(collection, id)
+          identity = _identity(collection)
+          query(collection).where(identity => _id(collection, identity, id))
+        end
+
+        def _first(query)
+          query.limit(1).first
+        end
+
+        def _identity(collection)
+          _mapped_collection(collection).identity
+        end
+
+        def _id(collection, column, value)
+          _mapped_collection(collection).deserialize_attribute(column, value)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/model/adapters/memory/collection.rb

@@ -0,0 +1,132 @@
+module Hanami
+  module Model
+    module Adapters
+      module Memory
+        # Acts like a SQL database table.
+        #
+        # @api private
+        # @since 0.1.0
+        class Collection
+          # A counter that simulates autoincrement primary key of a SQL table.
+          #
+          # @api private
+          # @since 0.1.0
+          class PrimaryKey
+            # Initialize
+            #
+            # @return [Hanami::Model::Adapters::Memory::Collection::PrimaryKey]
+            #
+            # @api private
+            # @since 0.1.0
+            def initialize
+              @current = 0
+            end
+
+            # Increment the current count by 1 and yields the given block
+            #
+            # @return [Fixnum] the incremented counter
+            #
+            # @api private
+            # @since 0.1.0
+            def increment!
+              yield(@current += 1)
+              @current
+            end
+          end
+
+          # @attr_reader name [Symbol] the name of the collection (eg. `:users`)
+          #
+          # @since 0.1.0
+          # @api private
+          attr_reader :name
+
+          # @attr_reader identity [Symbol] the primary key of the collection
+          #   (eg. `:id`)
+          #
+          # @since 0.1.0
+          # @api private
+          attr_reader :identity
+
+          # @attr_reader records [Hash] a set of records
+          #
+          # @since 0.1.0
+          # @api private
+          attr_reader :records
+
+          # Initialize a collection
+          #
+          # @param name [Symbol] the name of the collection (eg. `:users`).
+          # @param identity [Symbol] the primary key of the collection
+          #   (eg. `:id`).
+          #
+          # @api private
+          # @since 0.1.0
+          def initialize(name, identity)
+            @name, @identity = name, identity
+            clear
+          end
+
+          # Creates a record for the given entity and assigns an id.
+          #
+          # @param entity [Object] the entity to persist
+          #
+          # @see Hanami::Model::Adapters::Memory::Command#create
+          #
+          # @return the primary key of the created record
+          #
+          # @api private
+          # @since 0.1.0
+          def create(entity)
+            @primary_key.increment! do |id|
+              entity[identity] = id
+              records[id] = entity
+            end
+          end
+
+          # Updates the record corresponding to the given entity.
+          #
+          # @param entity [Object] the entity to persist
+          #
+          # @see Hanami::Model::Adapters::Memory::Command#update
+          #
+          # @api private
+          # @since 0.1.0
+          def update(entity)
+            records[entity.fetch(identity)] = entity
+          end
+
+          # Deletes the record corresponding to the given entity.
+          #
+          # @param entity [Object] the entity to delete
+          #
+          # @see Hanami::Model::Adapters::Memory::Command#delete
+          #
+          # @api private
+          # @since 0.1.0
+          def delete(entity)
+            records.delete(entity.id)
+          end
+
+          # Returns all the raw records
+          #
+          # @return [Array<Hash>]
+          #
+          # @api private
+          # @since 0.1.0
+          def all
+            records.values
+          end
+
+          # Deletes all the records and resets the identity counter.
+          #
+          # @api private
+          # @since 0.1.0
+          def clear
+            @records     = {}
+            @primary_key = PrimaryKey.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/model/adapters/memory/command.rb

@@ -0,0 +1,113 @@
+module Hanami
+  module Model
+    module Adapters
+      module Memory
+        # Execute a command for the given collection.
+        #
+        # @see Hanami::Model::Adapters::Memory::Collection
+        # @see Hanami::Model::Mapping::Collection
+        #
+        # @api private
+        # @since 0.1.0
+        class Command
+          # Initialize a command
+          #
+          # @param dataset [Hanami::Model::Adapters::Memory::Collection]
+          # @param collection [Hanami::Model::Mapping::Collection]
+          #
+          # @api private
+          # @since 0.1.0
+          def initialize(dataset, collection)
+            @dataset    = dataset
+            @collection = collection
+          end
+
+          # Creates a record for the given entity.
+          #
+          # @param entity [Object] the entity to persist
+          #
+          # @see Hanami::Model::Adapters::Memory::Collection#insert
+          #
+          # @return the primary key of the just created record.
+          #
+          # @api private
+          # @since 0.1.0
+          def create(entity)
+            serialized_entity            = _serialize(entity)
+            serialized_entity[_identity] = @dataset.create(serialized_entity)
+
+            _deserialize(serialized_entity)
+          end
+
+          # Updates the corresponding record for the given entity.
+          #
+          # @param entity [Object] the entity to persist
+          #
+          # @see Hanami::Model::Adapters::Memory::Collection#update
+          #
+          # @api private
+          # @since 0.1.0
+          def update(entity)
+            serialized_entity = _serialize(entity)
+            @dataset.update(serialized_entity)
+
+            _deserialize(serialized_entity)
+          end
+
+          # Deletes the corresponding record for the given entity.
+          #
+          # @param entity [Object] the entity to delete
+          #
+          # @see Hanami::Model::Adapters::Memory::Collection#delete
+          #
+          # @api private
+          # @since 0.1.0
+          def delete(entity)
+            @dataset.delete(entity)
+          end
+
+          # Deletes all the records from the table.
+          #
+          # @see Hanami::Model::Adapters::Memory::Collection#clear
+          #
+          # @api private
+          # @since 0.1.0
+          def clear
+            @dataset.clear
+          end
+
+          private
+          # Serialize the given entity before to persist in the database.
+          #
+          # @return [Hash] the serialized entity
+          #
+          # @api private
+          # @since 0.1.0
+          def _serialize(entity)
+            @collection.serialize(entity)
+          end
+
+          # Deserialize the given entity after it was persisted in the database.
+          #
+          # @return [Hanami::Entity] the deserialized entity
+          #
+          # @api private
+          # @since 0.2.2
+          def _deserialize(entity)
+            @collection.deserialize([entity]).first
+          end
+
+          # Name of the identity column in database
+          #
+          # @return [Symbol] the identity name
+          #
+          # @api private
+          # @since 0.2.2
+          def _identity
+            @collection.identity
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/model/adapters/memory/query.rb

@@ -0,0 +1,653 @@
+require 'forwardable'
+require 'ostruct'
+require 'hanami/utils/kernel'
+
+module Hanami
+  module Model
+    module Adapters
+      module Memory
+        # Query the in-memory database with a powerful API.
+        #
+        # All the methods are chainable, it allows advanced composition of
+        # conditions.
+        #
+        # This works as a lazy filtering mechanism: the records are fetched from
+        # the database only when needed.
+        #
+        # @example
+        #
+        #   query.where(language: 'ruby')
+        #        .and(framework: 'hanami')
+        #        .reverse_order(:users_count).all
+        #
+        #   # the records are fetched only when we invoke #all
+        #
+        # It implements Ruby's `Enumerable` and borrows some methods from `Array`.
+        # Expect a query to act like them.
+        #
+        # @since 0.1.0
+        class Query
+          include Enumerable
+          extend  Forwardable
+
+          def_delegators :all, :each, :to_s, :empty?
+
+          # @attr_reader conditions [Array] an accumulator for the conditions
+          #
+          # @since 0.1.0
+          # @api private
+          attr_reader :conditions
+
+          # @attr_reader modifiers [Array] an accumulator for the modifiers
+          #
+          # @since 0.1.0
+          # @api private
+          attr_reader :modifiers
+
+          # Initialize a query
+          #
+          # @param dataset [Hanami::Model::Adapters::Memory::Collection]
+          # @param collection [Hanami::Model::Mapping::Collection]
+          # @param blk [Proc] an optional block that gets yielded in the
+          #   context of the current query
+          #
+          # @since 0.1.0
+          # @api private
+          def initialize(dataset, collection, &blk)
+            @dataset    = dataset
+            @collection = collection
+            @conditions = []
+            @modifiers  = []
+            instance_eval(&blk) if block_given?
+          end
+
+          # Resolves the query by fetching records from the database and
+          # translating them into entities.
+          #
+          # @return [Array] a collection of entities
+          #
+          # @since 0.1.0
+          def all
+            @collection.deserialize(run)
+          end
+
+          # Adds a condition that behaves like SQL `WHERE`.
+          #
+          # It accepts a `Hash` with only one pair.
+          # The key must be the name of the column expressed as a `Symbol`.
+          # The value is the one used by the internal filtering logic.
+          #
+          # @param condition [Hash]
+          #
+          # @return self
+          #
+          # @since 0.1.0
+          #
+          # @example Fixed value
+          #
+          #   query.where(language: 'ruby')
+          #
+          # @example Array
+          #
+          #   query.where(id: [1, 3])
+          #
+          # @example Range
+          #
+          #   query.where(year: 1900..1982)
+          #
+          # @example Using block
+          #
+          #   query.where { age > 31 }
+          #
+          # @example Multiple conditions
+          #
+          #   query.where(language: 'ruby')
+          #        .where(framework: 'hanami')
+          #
+          # @example Multiple conditions with blocks
+          #
+          #   query.where { language == 'ruby' }
+          #        .where { framework == 'hanami' }
+          #
+          # @example Mixed hash and block conditions
+          #
+          #   query.where(language: 'ruby')
+          #        .where { framework == 'hanami' }
+          def where(condition = nil, &blk)
+            if blk
+              _push_evaluated_block_condition(:where, blk, :find_all)
+            elsif condition
+              _push_to_expanded_condition(:where, condition) do |column, value|
+                Proc.new {
+                  find_all { |r|
+                    case value
+                    when Array,Set,Range
+                      value.include?(r.fetch(column, nil))
+                    else
+                      r.fetch(column, nil) == value
+                    end
+                  }
+                }
+              end
+            end
+
+            self
+          end
+
+          alias_method :and, :where
+
+          # Adds a condition that behaves like SQL `OR`.
+          #
+          # It accepts a `Hash` with only one pair.
+          # The key must be the name of the column expressed as a `Symbol`.
+          # The value is the one used by the SQL query
+          #
+          # This condition will be ignored if not used with WHERE.
+          #
+          # @param condition [Hash]
+          #
+          # @return self
+          #
+          # @since 0.1.0
+          #
+          # @example Fixed value
+          #
+          #   query.where(language: 'ruby').or(framework: 'hanami')
+          #
+          # @example Array
+          #
+          #   query.where(id: 1).or(author_id: [15, 23])
+          #
+          # @example Range
+          #
+          #   query.where(country: 'italy').or(year: 1900..1982)
+          #
+          # @example Using block
+          #
+          #   query.where { age == 31 }.or { age == 32 }
+          #
+          # @example Mixed hash and block conditions
+          #
+          #   query.where(language: 'ruby')
+          #        .or { framework == 'hanami' }
+          def or(condition = nil, &blk)
+            if blk
+              _push_evaluated_block_condition(:or, blk, :find_all)
+            elsif condition
+              _push_to_expanded_condition(:or, condition) do |column, value|
+                Proc.new { find_all { |r| r.fetch(column) == value} }
+              end
+            end
+
+            self
+          end
+
+          # Logical negation of a #where condition.
+          #
+          # It accepts a `Hash` with only one pair.
+          # The key must be the name of the column expressed as a `Symbol`.
+          # The value is the one used by the internal filtering logic.
+          #
+          # @param condition [Hash]
+          #
+          # @since 0.1.0
+          #
+          # @return self
+          #
+          # @example Fixed value
+          #
+          #   query.exclude(language: 'java')
+          #
+          # @example Array
+          #
+          #   query.exclude(id: [4, 9])
+          #
+          # @example Range
+          #
+          #   query.exclude(year: 1900..1982)
+          #
+          # @example Multiple conditions
+          #
+          #   query.exclude(language: 'java')
+          #        .exclude(company: 'enterprise')
+          #
+          # @example Using block
+          #
+          #   query.exclude { age > 31 }
+          #
+          # @example Multiple conditions with blocks
+          #
+          #   query.exclude { language == 'java' }
+          #        .exclude { framework == 'spring' }
+          #
+          # @example Mixed hash and block conditions
+          #
+          #   query.exclude(language: 'java')
+          #        .exclude { framework == 'spring' }
+          def exclude(condition = nil, &blk)
+            if blk
+              _push_evaluated_block_condition(:where, blk, :reject)
+            elsif condition
+              _push_to_expanded_condition(:where, condition) do |column, value|
+                Proc.new { reject { |r| r.fetch(column) == value} }
+              end
+            end
+
+            self
+          end
+
+          alias_method :not, :exclude
+
+          # Select only the specified columns.
+          #
+          # By default a query selects all the mapped columns.
+          #
+          # @param columns [Array<Symbol>]
+          #
+          # @return self
+          #
+          # @since 0.1.0
+          #
+          # @example Single column
+          #
+          #   query.select(:name)
+          #
+          # @example Multiple columns
+          #
+          #   query.select(:name, :year)
+          def select(*columns)
+            columns = Hanami::Utils::Kernel.Array(columns)
+            modifiers.push(Proc.new{ flatten!; each {|r| r.delete_if {|k,_| !columns.include?(k)} } })
+          end
+
+          # Specify the ascending order of the records, sorted by the given
+          # columns.
+          #
+          # @param columns [Array<Symbol>] the column names
+          #
+          # @return self
+          #
+          # @since 0.1.0
+          #
+          # @see Hanami::Model::Adapters::Memory::Query#reverse_order
+          #
+          # @example Single column
+          #
+          #   query.order(:name)
+          #
+          # @example Multiple columns
+          #
+          #   query.order(:name, :year)
+          #
+          # @example Multiple invokations
+          #
+          #   query.order(:name).order(:year)
+          def order(*columns)
+            Hanami::Utils::Kernel.Array(columns).each do |column|
+              modifiers.push(Proc.new{ sort_by!{|r| r.fetch(column)} })
+            end
+
+            self
+          end
+
+          # Alias for order
+          #
+          # @since 0.1.0
+          #
+          # @see Hanami::Model::Adapters::Memory::Query#order
+          #
+          # @example Single column
+          #
+          #   query.asc(:name)
+          #
+          # @example Multiple columns
+          #
+          #   query.asc(:name, :year)
+          #
+          # @example Multiple invokations
+          #
+          #   query.asc(:name).asc(:year)
+          alias_method :asc, :order
+
+          # Specify the descending order of the records, sorted by the given
+          # columns.
+          #
+          # @param columns [Array<Symbol>] the column names
+          #
+          # @return self
+          #
+          # @since 0.3.1
+          #
+          # @see Hanami::Model::Adapters::Memory::Query#order
+          #
+          # @example Single column
+          #
+          #   query.reverse_order(:name)
+          #
+          # @example Multiple columns
+          #
+          #   query.reverse_order(:name, :year)
+          #
+          # @example Multiple invokations
+          #
+          #   query.reverse_order(:name).reverse_order(:year)
+          def reverse_order(*columns)
+            Hanami::Utils::Kernel.Array(columns).each do |column|
+              modifiers.push(Proc.new{ sort_by!{|r| r.fetch(column)}.reverse! })
+            end
+
+            self
+          end
+
+          # Alias for reverse_order
+          #
+          # @since 0.1.0
+          #
+          # @see Hanami::Model::Adapters::Memory::Query#reverse_order
+          #
+          # @example Single column
+          #
+          #   query.desc(:name)
+          #
+          # @example Multiple columns
+          #
+          #   query.desc(:name, :year)
+          #
+          # @example Multiple invokations
+          #
+          #   query.desc(:name).desc(:year)
+          alias_method :desc, :reverse_order
+
+          # Limit the number of records to return.
+          #
+          # @param number [Fixnum]
+          #
+          # @return self
+          #
+          # @since 0.1.0
+          #
+          # @example
+          #
+          #   query.limit(1)
+          def limit(number)
+            modifiers.push(Proc.new{ replace(flatten.first(number)) })
+            self
+          end
+
+          # Simulate an `OFFSET` clause, without the need of specify a limit.
+          #
+          # @param number [Fixnum]
+          #
+          # @return self
+          #
+          # @since 0.1.0
+          #
+          # @example
+          #
+          #   query.offset(10)
+          def offset(number)
+            modifiers.unshift(Proc.new{ replace(flatten.drop(number)) })
+            self
+          end
+
+          # Returns the sum of the values for the given column.
+          #
+          # @param column [Symbol] the column name
+          #
+          # @return [Numeric]
+          #
+          # @since 0.1.0
+          #
+          # @example
+          #
+          #    query.sum(:comments_count)
+          def sum(column)
+            result = all
+
+            if result.any?
+              result.inject(0.0) do |acc, record|
+                if value = record.public_send(column)
+                  acc += value
+                end
+
+                acc
+              end
+            end
+          end
+
+          # Returns the average of the values for the given column.
+          #
+          # @param column [Symbol] the column name
+          #
+          # @return [Numeric]
+          #
+          # @since 0.1.0
+          #
+          # @example
+          #
+          #    query.average(:comments_count)
+          def average(column)
+            if s = sum(column)
+              s / _all_with_present_column(column).count.to_f
+            end
+          end
+
+          alias_method :avg, :average
+
+          # Returns the maximum value for the given column.
+          #
+          # @param column [Symbol] the column name
+          #
+          # @return result
+          #
+          # @since 0.1.0
+          #
+          # @example
+          #
+          #    query.max(:comments_count)
+          def max(column)
+            _all_with_present_column(column).max
+          end
+
+          # Returns the minimum value for the given column.
+          #
+          # @param column [Symbol] the column name
+          #
+          # @return result
+          #
+          # @since 0.1.0
+          #
+          # @example
+          #
+          #    query.min(:comments_count)
+          def min(column)
+            _all_with_present_column(column).min
+          end
+
+          # Returns the difference between the MAX and MIN for the given column.
+          #
+          # @param column [Symbol] the column name
+          #
+          # @return [Numeric]
+          #
+          # @since 0.1.0
+          #
+          # @see Hanami::Model::Adapters::Memory::Query#max
+          # @see Hanami::Model::Adapters::Memory::Query#min
+          #
+          # @example
+          #
+          #    query.interval(:comments_count)
+          def interval(column)
+            max(column) - min(column)
+          rescue NoMethodError
+          end
+
+          # Returns a range of values between the MAX and the MIN for the given
+          # column.
+          #
+          # @param column [Symbol] the column name
+          #
+          # @return [Range]
+          #
+          # @since 0.1.0
+          #
+          # @see Hanami::Model::Adapters::Memory::Query#max
+          # @see Hanami::Model::Adapters::Memory::Query#min
+          #
+          # @example
+          #
+          #    query.range(:comments_count)
+          def range(column)
+            min(column)..max(column)
+          end
+
+          # Checks if at least one record exists for the current conditions.
+          #
+          # @return [TrueClass,FalseClass]
+          #
+          # @since 0.1.0
+          #
+          # @example
+          #
+          #    query.where(author_id: 23).exists? # => true
+          def exist?
+            !count.zero?
+          end
+
+          # Returns a count of the records for the current conditions.
+          #
+          # @return [Fixnum]
+          #
+          # @since 0.1.0
+          #
+          # @example
+          #
+          #    query.where(author_id: 23).count # => 5
+          def count
+            run.count
+          end
+
+          # This method is defined in order to make the interface of
+          # `Memory::Query` identical to `Sql::Query`, but this feature is NOT
+          # implemented
+          #
+          # @raise [NotImplementedError]
+          #
+          # @since 0.1.0
+          #
+          # @see Hanami::Model::Adapters::Sql::Query#negate!
+          def negate!
+            raise NotImplementedError
+          end
+
+          # This method is defined in order to make the interface of
+          # `Memory::Query` identical to `Sql::Query`, but this feature is NOT
+          # implemented
+          #
+          # @raise [NotImplementedError]
+          #
+          # @since 0.5.0
+          #
+          # @see Hanami::Model::Adapters::Sql::Query#group!
+          def group
+            raise NotImplementedError
+          end
+
+          protected
+          def method_missing(m, *args, &blk)
+            if @context.respond_to?(m)
+              apply @context.public_send(m, *args, &blk)
+            else
+              super
+            end
+          end
+
+          private
+          # Apply all the conditions and returns a filtered collection.
+          #
+          # This operation is idempotent, but the records are actually fetched
+          # from the memory store.
+          #
+          # @return [Array]
+          #
+          # @api private
+          # @since 0.1.0
+          def run
+            result = @dataset.all.dup
+
+            if conditions.any?
+              prev_result = nil
+              conditions.each do |(type, condition)|
+                case type
+                when :where
+                  prev_result = result
+                  result = prev_result.instance_exec(&condition)
+                when :or
+                  result |= prev_result.instance_exec(&condition)
+                end
+              end
+            end
+
+            modifiers.map do |modifier|
+              result.instance_exec(&modifier)
+            end
+
+            Hanami::Utils::Kernel.Array(result)
+          end
+
+          def _all_with_present_column(column)
+            all.map {|record| record.public_send(column) }.compact
+          end
+
+          # Expands and yields keys and values of a query hash condition and
+          # stores the result and condition type in the conditions array.
+          #
+          # It yields condition's keys and values to allow the caller to create a proc
+          # object to be stored and executed later performing the actual query.
+          #
+          # @param condition_type [Symbol] the condition type. (eg. `:where`, `:or`)
+          # @param condition [Hash] the query condition to be expanded.
+          #
+          # @return [Array<Array>] the conditions array itself.
+          #
+          # @api private
+          # @since 0.3.1
+          def _push_to_expanded_condition(condition_type, condition)
+            proc = yield Array(condition).flatten(1)
+            conditions.push([condition_type, proc])
+          end
+
+          # Evaluates a block condition of a specified type and stores it in the
+          # conditions array.
+          #
+          # @param condition_type [Symbol] the condition type. (eg. `:where`, `:or`)
+          # @param condition [Proc] the query condition to be evaluated and stored.
+          # @param strategy [Symbol] the iterator method to be executed.
+          #   (eg. `:find_all`, `:reject`)
+          #
+          # @return [Array<Array>] the conditions array itself.
+          #
+          # @raise [Hanami::Model::InvalidQueryError] if block raises error when
+          # evaluated.
+          #
+          # @api private
+          # @since 0.3.1
+          def _push_evaluated_block_condition(condition_type, condition, strategy)
+            conditions.push([condition_type, Proc.new {
+              send(strategy) { |r|
+                begin
+                  OpenStruct.new(r).instance_eval(&condition)
+                rescue NoMethodError
+                  # TODO improve the error message, informing which
+                  # attributes are invalid
+                  raise Hanami::Model::InvalidQueryError.new
+                end
+              }
+            }])
+          end
+        end
+      end
+    end
+  end
+end