reso_api 1.8.12 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3cb2e251bb0012fb425337a94a97c8015cc478687ac72f8d7915598c75eed53
-  data.tar.gz: 8670d59a706aa895795e8ff03d180dd2ddec49c5d882b8ed46eafa7c35f7af5a
+  metadata.gz: 3a24486d919c84b2bd716ce37c8b37ee62fca566624f3434acb475dfd2de462b
+  data.tar.gz: 0e0cdc536424944953720bfe4947b99dc2333c672aab55c6d4cb42908785e7a7
 SHA512:
-  metadata.gz: 24bf2687c88bd99184ee1e341a3378c19e91385ad025e8dd9a46d35d3e6d8593bf32125a4d9ab06be2a789bd34c894aeeafbab524547b05156c2d8f1267b24dd
-  data.tar.gz: e3ad4b195f9b690d2b40faf18c4fdefbf747eb9ed4f9fc8cf083a152d3a345512a21212a4eb67c8750e08ddbef1364f7df435c6dcf64506b7bf70fe1c21384c0
+  metadata.gz: 56c4522468e00c7891a244ae8efa9de68ea5b7575d72a61c373bd01e616c17a3cac7de8f84912cbd349e1bcb07e397b08c05db81ae34c6136fd07e3156c60385
+  data.tar.gz: 32c65364cce709339eaabe46a0e165efdfcbc54d7cca45d2cdd99e858af63df1b69adc5813c63fc4980ceb647821648186fcb41df20f8f0465313fc006a656da

data/Gemfile

@@ -4,3 +4,11 @@ git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in reso_api.gemspec
 gemspec
+
+# Required for Ruby 3.4+ compatibility with older activesupport
+gem "bigdecimal"
+gem "mutex_m"
+gem "drb"
+gem "benchmark"
+gem "logger"
+gem "base64"

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    reso_api (0.5.0)
+    reso_api (2.0.0)
       activesupport
+      jwt
       oauth2
 
 GEM
@@ -13,8 +14,12 @@ GEM
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
+    base64 (0.3.0)
+    benchmark (0.5.0)
+    bigdecimal (4.0.1)
     concurrent-ruby (1.1.10)
     diff-lcs (1.5.0)
+    drb (2.2.3)
     faraday (2.3.0)
       faraday-net_http (~> 2.0)
       ruby2_keywords (>= 0.0.4)
@@ -22,9 +27,11 @@ GEM
     i18n (1.10.0)
       concurrent-ruby (~> 1.0)
     jwt (2.3.0)
+    logger (1.7.0)
     minitest (5.15.0)
     multi_json (1.15.0)
     multi_xml (0.6.0)
+    mutex_m (0.3.0)
     oauth2 (1.4.9)
       faraday (>= 0.17.3, < 3.0)
       jwt (>= 1.0, < 3.0)
@@ -52,13 +59,20 @@ GEM
 
 PLATFORMS
   arm64-darwin-21
+  arm64-darwin-25
   x86_64-linux
 
 DEPENDENCIES
-  bundler (>= 2.2.10)
+  base64
+  benchmark
+  bigdecimal
+  bundler (>= 2.3.15)
+  drb
+  logger
+  mutex_m
   rake (>= 12.3.3)
   reso_api!
   rspec (~> 3.0)
 
 BUNDLED WITH
-   2.3.7
+  4.0.6

data/README.md

@@ -94,19 +94,191 @@ The response will be an EDMX xml schema document that matches the [RESO Data Dic
 
 [RESO Data Dictionary standard]: https://www.reso.org/data-dictionary/
 
-### Listing Requests
+### Query Builder (ActiveRecord-style)
+
+Calling a resource method with no arguments returns a query builder that supports chainable, ActiveRecord-style queries. Results are returned as unwrapped arrays (the contents of `value` from the OData response).
+
+For properties, a default scope of `StandardStatus in ('Active','Pending')` is automatically applied unless you specify `StandardStatus` yourself or call `.unscoped`.
+
+#### Basic queries
+
+```ruby
+# Returns array of listing hashes (default scope: Active + Pending)
+listings = client.properties.where(City: "Seattle")
+
+# Chained conditions (joined with 'and')
+listings = client.properties
+  .where(City: "Seattle")
+  .where(["ListPrice >= ?", 500_000])
+
+# Single record lookup
+listing = client.properties.find_by(ListingId: "123456")
+
+# Lookup by primary key (uses detail endpoint)
+listing = client.properties.find("3yd-BINDER-5508272")
+
+# First record
+listing = client.properties.where(City: "Seattle").first
+
+# Count
+total = client.properties.where(City: "Seattle").count
+```
+
+#### Where conditions
+
+**Hash conditions** — equality, IN, ranges, and string matching:
+
+```ruby
+.where(City: "Seattle")                          # City eq 'Seattle'
+.where(StandardStatus: ['Active', 'Pending'])     # StandardStatus in ('Active','Pending')
+.where(ListPrice: 300_000..500_000)               # ListPrice ge 300000 and ListPrice le 500000
+.where(ListPrice: 300_000..)                      # ListPrice ge 300000
+.where(ListPrice: ..500_000)                      # ListPrice le 500000
+```
+
+**String matching** — use `%` wildcards like SQL `LIKE`:
+
+```ruby
+.where(ListOfficeName: "Slifer%")                 # startswith(ListOfficeName,'Slifer')
+.where(ListOfficeName: "%Frampton")               # endswith(ListOfficeName,'Frampton')
+.where(ListOfficeName: "%Smith%")                 # contains(ListOfficeName,'Smith')
+.where(ListOfficeName: "Slifer Smith & Frampton") # exact match (no %)
+```
+
+Only `%` at the first and/or last position is treated as a wildcard. A `%` in the middle of the string (e.g. `"100% Pure"`) is treated literally. To match a literal `%` at the start or end, escape it with `\%`.
+
+**Note:** Not all MLS servers support all string functions. `startswith` has the widest support. Some servers silently return empty results for `endswith` and `contains` rather than an error.
+
+**Array conditions** — comparison operators with `?` placeholders:
+
+```ruby
+.where(["CloseDate > ?", 1.week.ago])             # CloseDate gt 2026-02-04T00:00:00Z
+.where(["ListPrice >= ?", 500_000])               # ListPrice ge 500000
+.where(["ListPrice >= ? and ListPrice <= ?", 300_000, 500_000])
+```
+
+Supported operators: `>`, `>=`, `<`, `<=`, `=`, `!=`
+
+**Named placeholders:**
+
+```ruby
+.where(["ListPrice >= :min and ListPrice <= :max", min: 300_000, max: 500_000])
+```
+
+**Negation** — call `.where` with no arguments, then `.not`:
+
+```ruby
+.where.not(City: "Seattle")                       # City ne 'Seattle'
+.where.not(StandardStatus: ['Closed', 'Expired']) # StandardStatus ne 'Closed' and ...
+```
+
+#### Value formatting
+
+Ruby values are automatically formatted for OData:
+
+| Ruby Type          | OData Output                       |
+|--------------------|------------------------------------|
+| `String`           | `'Seattle'` (single-quoted)        |
+| `Integer`, `Float` | `500000` (bare)                    |
+| `Time`, `DateTime` | `2026-02-04T12:00:00Z` (ISO 8601) |
+| `Date`             | `2026-02-04`                       |
+| `true` / `false`   | `true` / `false`                   |
+| `nil`              | `null`                             |
+
+#### Select, order, limit, offset
 
-The simplest query is simply to call `properties` on the initialized client: 
+```ruby
+client.properties
+  .where(City: "Seattle")
+  .select(:ListingKey, :City, :ListPrice)   # $select
+  .order(ListPrice: :desc)                  # $orderby
+  .limit(25)                                # $top
+  .offset(50)                               # $skip
+```
+
+#### Includes (eager loading)
+
+`.includes` maps to OData `$expand` for joining related resources:
 
 ```ruby
 client.properties
+  .where(City: "Seattle")
+  .includes(:Media, :OpenHouses)
+```
+
+#### Default scope and unscoped
+
+Properties automatically filter to `StandardStatus in ('Active','Pending')`:
+
+```ruby
+# Default applied
+client.properties.where(City: "Seattle")
+# → StandardStatus in ('Active','Pending') and City eq 'Seattle'
+
+# Overridden when you specify StandardStatus
+client.properties.where(StandardStatus: 'Closed')
+# → StandardStatus eq 'Closed'
+
+# Explicitly removed
+client.properties.unscoped.where(City: "Seattle")
+# → City eq 'Seattle'
+```
+
+No default scope is applied for members, offices, open_houses, or media.
+
+#### Iteration and execution
+
+Queries execute lazily — the API call fires when you access the results:
+
+```ruby
+listings = client.properties.where(City: "Seattle")
+listings.each { |l| puts l["ListPrice"] }   # triggers API call
+listings.length                               # uses cached results
+listings[0]                                   # uses cached results
+```
+
+For large datasets, `.each` and `.find_each` auto-paginate through `@odata.nextLink`:
+
+```ruby
+client.properties.where(["ModificationTimestamp > ?", 1.day.ago]).each do |listing|
+  process(listing)
+end
+
+client.properties.find_each(batch_size: 200) do |listing|
+  process(listing)
+end
+```
+
+#### Immutability
+
+Each chainable method returns a new builder, so you can safely branch queries:
+
+```ruby
+base = client.properties.where(City: "Seattle")
+active = base.where(StandardStatus: "Active")
+closed = base.where(StandardStatus: "Closed")
+# base, active, and closed are independent queries
+```
+
+---
+
+### OData Queries (Direct)
+
+The query builder above is the recommended way to query resources. You can also query resources directly using OData parameters. When called with arguments, the raw OData response hash is returned (you unwrap `value` yourself).
+
+### Listing Requests
+
+The simplest query is simply to call `properties` on the initialized client:
+
+```ruby
+client.properties(filter: "StandardStatus eq 'Active'")
 ```
 
 The API will return a JSON response with an array of listing JSON objects.
 
 ### Getting a single listing
 
-You can look up a single listing by sending a query with the listing's unique id (ListingKey). 
+You can look up a single listing by sending a query with the listing's unique id (ListingKey).
 
 ```ruby
 client.property('3yd-BINDER-5508272')

data/lib/reso_api/app/models/reso/api/client.rb

@@ -9,6 +9,7 @@ module RESO
       require 'tmpdir'
 
       attr_accessor :access_token, :client_id, :client_secret, :auth_url, :base_url, :scope, :osn
+      attr_reader :last_request_url
 
       def initialize(**opts)
         @access_token, @client_id, @client_secret, @auth_url, @base_url, @scope, @osn = opts.values_at(:access_token, :client_id, :client_secret, :auth_url, :base_url, :scope, :osn)
@@ -56,6 +57,11 @@ module RESO
 
       FILTERABLE_ENDPOINTS.keys.each do |method_name|
         define_method method_name do |*args, &block|
+          # No-arg call returns a QueryBuilder for ActiveRecord-style chaining
+          if args.empty? && block.nil?
+            return QueryBuilder.new(client: self, resource: method_name)
+          end
+
           hash = args.first.is_a?(Hash) ? args.first : {}
 
           filter = hash[:filter].to_s
@@ -236,9 +242,12 @@ module RESO
         if params.present?
           query = params.present? ? URI.encode_www_form(params).gsub("+", " ") : ""
           uri.query && uri.query.length > 0 ? uri.query += '&' + query : uri.query = query
-          return URI::decode(uri.request_uri) if params.dig(:$debug).present?
+          return URI::DEFAULT_PARSER.unescape(uri.request_uri) if params.dig(:$debug).present?
         end
 
+        # Store the full request URL for debugging
+        @last_request_url = uri.to_s
+
         begin
           req = Net::HTTP::Get.new(uri.request_uri)
           req['Authorization'] = "Bearer #{auth_token}"
@@ -282,6 +291,13 @@ module RESO
             raise
           end
         end
+
+        # Add metadata to response hash (if response is a hash)
+        if response.is_a?(Hash)
+          response['@reso_request_url'] = @last_request_url
+          response['@reso_auth_scope'] = scope
+        end
+
         return response
       end
 

data/lib/reso_api/app/models/reso/api/query_builder.rb

@@ -0,0 +1,261 @@
+module RESO
+  module API
+    class QueryBuilder
+      include Enumerable
+
+      DEFAULT_PROPERTIES_SCOPE = "StandardStatus in ('Active','Pending')"
+
+      def initialize(client:, resource:)
+        @client = client
+        @resource = resource
+        @conditions = []
+        @select_fields = nil
+        @order_clauses = nil
+        @limit_value = nil
+        @offset_value = nil
+        @includes_values = nil
+        @count_flag = false
+        @unscoped_flag = false
+        @loaded = false
+        @records = nil
+      end
+
+      # --- Chainable methods ---
+
+      def where(conditions = nil)
+        if conditions.nil?
+          return WhereChain.new(clone_builder)
+        end
+
+        builder = clone_builder
+        fragments = QueryConditions.parse(conditions)
+        fragments.each { |f| builder.add_condition(f) }
+        builder
+      end
+
+      def select(*fields)
+        if fields.first.is_a?(Proc) || (fields.empty? && block_given?)
+          return super
+        end
+
+        builder = clone_builder
+        builder.instance_variable_set(:@select_fields, fields.flatten.map(&:to_s))
+        builder
+      end
+
+      def order(*args)
+        builder = clone_builder
+        clauses = args.flat_map do |arg|
+          case arg
+          when Hash
+            arg.map { |field, dir| "#{field} #{dir}" }
+          when String
+            [arg]
+          else
+            [arg.to_s]
+          end
+        end
+        builder.instance_variable_set(:@order_clauses, clauses)
+        builder
+      end
+
+      def limit(value)
+        builder = clone_builder
+        builder.instance_variable_set(:@limit_value, value)
+        builder
+      end
+
+      def offset(value)
+        builder = clone_builder
+        builder.instance_variable_set(:@offset_value, value)
+        builder
+      end
+
+      def includes(*names)
+        builder = clone_builder
+        builder.instance_variable_set(:@includes_values, names.flatten.map(&:to_s))
+        builder
+      end
+
+      def unscoped
+        builder = clone_builder
+        builder.instance_variable_set(:@unscoped_flag, true)
+        builder
+      end
+
+      # --- Terminal methods ---
+
+      def find(key)
+        endpoint = Client::DETAIL_ENDPOINTS[@resource.to_s.singularize.to_sym]
+        raise ArgumentError, "Unknown resource: #{@resource}" unless endpoint
+        @client.send(:perform_call, "#{endpoint}('#{key}')", nil)
+      end
+
+      def find_by(conditions)
+        builder = where(conditions).limit(1)
+        builder.load
+        builder.records.first
+      end
+
+      def first(n = nil)
+        if n
+          builder = limit(n)
+          builder.load
+          builder.records
+        else
+          builder = limit(1)
+          builder.load
+          builder.records.first
+        end
+      end
+
+      def count
+        builder = clone_builder
+        builder.instance_variable_set(:@count_flag, true)
+        builder.instance_variable_set(:@limit_value, 1)
+        response = builder.execute_raw
+        response['@odata.totalCount'].to_i
+      end
+
+      def each(&block)
+        if block_given?
+          execute_with_pagination(&block)
+        else
+          to_a.each
+        end
+      end
+
+      def find_each(batch_size: 200, &block)
+        builder = clone_builder
+        builder.instance_variable_set(:@limit_value, batch_size)
+        builder.execute_with_pagination(&block)
+      end
+
+      def to_a
+        load
+        @records
+      end
+
+      def to_ary
+        to_a
+      end
+
+      def reload
+        @loaded = false
+        @records = nil
+        self
+      end
+
+      def inspect
+        load
+        @records.inspect
+      end
+
+      def size
+        to_a.size
+      end
+
+      def length
+        to_a.length
+      end
+
+      def empty?
+        to_a.empty?
+      end
+
+      def [](index)
+        to_a[index]
+      end
+
+      # --- Internal ---
+
+      def add_condition(fragment)
+        @conditions << fragment
+        @loaded = false
+        @records = nil
+        self
+      end
+
+      protected
+
+      attr_reader :records
+
+      def load
+        return if @loaded
+        response = execute_raw
+        @records = response['value'].is_a?(Array) ? response['value'] : []
+        @loaded = true
+      end
+
+      def execute_raw
+        endpoint = Client::FILTERABLE_ENDPOINTS[@resource]
+        raise ArgumentError, "Unknown resource: #{@resource}" unless endpoint
+
+        params = build_params
+        @client.send(:perform_call, endpoint, params)
+      end
+
+      def execute_with_pagination(&block)
+        endpoint = Client::FILTERABLE_ENDPOINTS[@resource]
+        raise ArgumentError, "Unknown resource: #{@resource}" unless endpoint
+
+        params = build_params
+        response = @client.send(:perform_call, endpoint, params)
+        if response['value'].is_a?(Array)
+          response['value'].each(&block)
+        end
+
+        while (next_link = response['@odata.nextLink']).present?
+          response = @client.send(:perform_call, next_link, nil)
+          if response['value'].is_a?(Array)
+            response['value'].each(&block)
+          end
+        end
+      end
+
+      def build_params
+        params = {}
+        params[:"$filter"] = build_filter
+        params[:"$select"] = @select_fields.join(',') if @select_fields
+        params[:"$orderby"] = @order_clauses.join(',') if @order_clauses
+        params[:"$top"] = @limit_value if @limit_value
+        params[:"$skip"] = @offset_value if @offset_value
+        params[:"$expand"] = @includes_values.join(',') if @includes_values
+        params[:"$count"] = 'true' if @count_flag
+        params.compact
+      end
+
+      def build_filter
+        filters = @conditions.dup
+
+        # Apply OSN filter if configured and not already present
+        if @client.osn.present? && filters.none? { |f| f.include?('OriginatingSystemName') }
+          filters.unshift("OriginatingSystemName eq '#{@client.osn}'")
+        end
+
+        # Apply default scope for properties unless overridden
+        if @resource == :properties && !@unscoped_flag
+          unless filters.any? { |f| f.include?('StandardStatus') }
+            filters << DEFAULT_PROPERTIES_SCOPE
+          end
+        end
+
+        filter_string = filters.join(' and ')
+        filter_string.presence
+      end
+
+      def clone_builder
+        builder = QueryBuilder.new(client: @client, resource: @resource)
+        builder.instance_variable_set(:@conditions, @conditions.dup)
+        builder.instance_variable_set(:@select_fields, @select_fields&.dup)
+        builder.instance_variable_set(:@order_clauses, @order_clauses&.dup)
+        builder.instance_variable_set(:@limit_value, @limit_value)
+        builder.instance_variable_set(:@offset_value, @offset_value)
+        builder.instance_variable_set(:@includes_values, @includes_values&.dup)
+        builder.instance_variable_set(:@count_flag, @count_flag)
+        builder.instance_variable_set(:@unscoped_flag, @unscoped_flag)
+        builder
+      end
+    end
+  end
+end

data/lib/reso_api/app/models/reso/api/query_conditions.rb

@@ -0,0 +1,141 @@
+module RESO
+  module API
+    class QueryConditions
+      class << self
+        def parse(args, negate: false)
+          case args
+          when Hash
+            from_hash(args, negate: negate)
+          when Array
+            from_array(args, negate: negate)
+          else
+            raise ArgumentError, "Unsupported where argument type: #{args.class}"
+          end
+        end
+
+        private
+
+        def from_hash(hash, negate: false)
+          hash.map do |field, value|
+            fragment = case value
+            when Array
+              format_in(field, value)
+            when Range
+              format_range(field, value)
+            else
+              format_eq(field, value)
+            end
+
+            negate ? negate_fragment(field, value, fragment) : fragment
+          end
+        end
+
+        def from_array(array, negate: false)
+          template = array.first
+          bindings = array[1..]
+
+          if bindings.first.is_a?(Hash)
+            result = substitute_named_placeholders(template, bindings.first)
+          else
+            result = substitute_positional_placeholders(template, bindings)
+          end
+
+          negate ? ["not (#{result})"] : [result]
+        end
+
+        def format_eq(field, value)
+          if value.is_a?(String)
+            leading = value.start_with?('%') && !value.start_with?('\%')
+            trailing = value.end_with?('%') && !value.end_with?('\%')
+
+            if leading || trailing
+              return format_string_match(field, value, leading, trailing)
+            end
+
+            # Unescape literal \% at boundaries for exact match
+            if value.start_with?('\%') || value.end_with?('\%')
+              value = value.sub(/\A\\%/, '%').sub(/\\%\z/, '%')
+            end
+          end
+
+          "#{field} eq #{QueryFormatter.format_value(value)}"
+        end
+
+        def format_string_match(field, value, leading, trailing)
+          inner = value.dup
+          inner = inner[1..] if leading
+          inner = inner[0..-2] if trailing
+
+          # Unescape literal \% at boundaries
+          inner = inner.sub(/\A\\%/, '%')
+          inner = inner.sub(/\\%\z/, '%')
+
+          formatted = QueryFormatter.format_value(inner)
+
+          if leading && trailing
+            "contains(#{field},#{formatted})"
+          elsif leading
+            "endswith(#{field},#{formatted})"
+          else
+            "startswith(#{field},#{formatted})"
+          end
+        end
+
+        def format_in(field, values)
+          formatted = values.map { |v| QueryFormatter.format_value(v) }.join(',')
+          "#{field} in (#{formatted})"
+        end
+
+        def format_range(field, range)
+          parts = []
+          parts << "#{field} ge #{QueryFormatter.format_value(range.begin)}" if range.begin
+          if range.end
+            op = range.exclude_end? ? 'lt' : 'le'
+            parts << "#{field} #{op} #{QueryFormatter.format_value(range.end)}"
+          end
+          parts.join(' and ')
+        end
+
+        def negate_fragment(field, value, fragment)
+          case value
+          when Array
+            # Expand NOT IN to individual ne conditions
+            value.map { |v| "#{field} ne #{QueryFormatter.format_value(v)}" }.join(' and ')
+          when String
+            if fragment.start_with?('contains(', 'startswith(', 'endswith(')
+              "not #{fragment}"
+            else
+              "#{field} ne #{QueryFormatter.format_value(value)}"
+            end
+          else
+            "#{field} ne #{QueryFormatter.format_value(value)}"
+          end
+        end
+
+        def substitute_positional_placeholders(template, values)
+          result = template.dup
+          values.each do |value|
+            result.sub!(QueryFormatter::OPERATOR_PATTERN) do |match|
+              op = match.strip
+              " #{QueryFormatter.translate_operator(op)} "
+            end
+            result.sub!('?', QueryFormatter.format_value(value))
+          end
+          result
+        end
+
+        def substitute_named_placeholders(template, bindings)
+          result = template.dup
+          result.gsub!(QueryFormatter::OPERATOR_PATTERN) do |match|
+            op = match.strip
+            " #{QueryFormatter.translate_operator(op)} "
+          end
+          bindings.each do |name, value|
+            result.gsub!(":#{name}", QueryFormatter.format_value(value))
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/reso_api/app/models/reso/api/query_formatter.rb

@@ -0,0 +1,33 @@
+module RESO
+  module API
+    class QueryFormatter
+      OPERATOR_MAP = {
+        '>'  => 'gt',
+        '>=' => 'ge',
+        '<'  => 'lt',
+        '<=' => 'le',
+        '='  => 'eq',
+        '!=' => 'ne'
+      }.freeze
+
+      OPERATOR_PATTERN = /\s*(>=|<=|!=|>|<|=)\s*/
+
+      def self.format_value(value)
+        case value
+        when String         then "'#{value.gsub("'", "''")}'"
+        when Integer        then value.to_s
+        when Float          then value.to_s
+        when Time, DateTime then value.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
+        when Date           then value.strftime('%Y-%m-%d')
+        when TrueClass, FalseClass then value.to_s
+        when NilClass       then 'null'
+        else value.to_s
+        end
+      end
+
+      def self.translate_operator(op)
+        OPERATOR_MAP[op.strip] || raise(ArgumentError, "Unknown operator: #{op}")
+      end
+    end
+  end
+end

data/lib/reso_api/app/models/reso/api/where_chain.rb

@@ -0,0 +1,15 @@
+module RESO
+  module API
+    class WhereChain
+      def initialize(query_builder)
+        @query_builder = query_builder
+      end
+
+      def not(conditions)
+        fragments = QueryConditions.parse(conditions, negate: true)
+        fragments.each { |f| @query_builder.add_condition(f) }
+        @query_builder
+      end
+    end
+  end
+end

data/lib/reso_api/version.rb

@@ -1,3 +1,3 @@
 module ResoApi
-  VERSION = "1.8.12"
+  VERSION = "2.0.0"
 end

data/lib/reso_api.rb

@@ -4,6 +4,10 @@ require "reso_api/version"
 require "reso_api/config/inflections.rb"
 require "reso_api/app/models/reso.rb"
 require "reso_api/app/models/reso/api.rb"
+require "reso_api/app/models/reso/api/query_formatter.rb"
+require "reso_api/app/models/reso/api/query_conditions.rb"
+require "reso_api/app/models/reso/api/where_chain.rb"
+require "reso_api/app/models/reso/api/query_builder.rb"
 require "reso_api/app/models/reso/api/client.rb"
 
 module ResoApi

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reso_api
 version: !ruby/object:Gem::Version
-  version: 1.8.12
+  version: 2.0.0
 platform: ruby
 authors:
 - Michael Edlund
@@ -114,6 +114,10 @@ files:
 - lib/reso_api/app/models/reso.rb
 - lib/reso_api/app/models/reso/api.rb
 - lib/reso_api/app/models/reso/api/client.rb
+- lib/reso_api/app/models/reso/api/query_builder.rb
+- lib/reso_api/app/models/reso/api/query_conditions.rb
+- lib/reso_api/app/models/reso/api/query_formatter.rb
+- lib/reso_api/app/models/reso/api/where_chain.rb
 - lib/reso_api/config/inflections.rb
 - lib/reso_api/version.rb
 - license.md