reso_api 1.8.13 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58fe7ec4d146147d271a0d45ac51c93c63a859657a2e490f13154cb2544d7c5c
-  data.tar.gz: 61e76715b6167377f8ada506a1009a0d17ba4cf7de1137ef0292182b1e64315a
+  metadata.gz: d07a8c664cda837a170e4faa1f7e038d50bac47d7f7a8364f46d29255d06c1a8
+  data.tar.gz: a5ec6e603fe65f5c66e59032de39a4f44edfef1ea05d0ae4e92036d626e00e6e
 SHA512:
-  metadata.gz: e7f18a11f9d0a9097c5a2283faa8143af934d9a9ddc2061573d36c29e9f5890874320923dc6a39a99e5d66e53160a17c2af8002c2a95c78b288310a39b66a9ec
-  data.tar.gz: 985cf3cb78aff919b99cb8c23668bb58a8e95e6a9b5a4f33466480894285adeab861be59315e0d1154484fffafded483a221be5dd61a1eca45142d414ee02129
+  metadata.gz: f52bcb068fc30aa51687e087a66171f6d52c79a8e5c786650b5dfed17c9b8a28ef8f8dd68ca03a2be503b1fab61db655a02b039bf840c28c1771bfcfa8920ae6
+  data.tar.gz: 820f3d1a47c2c9fbc2336d170a50203806a671ac883bd2d4ed3d5968b73e31359e96a339facaf792cd2ffc88fa185cafaa928a8f6ed00b1129246b163c45c352

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.1)
       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

@@ -72,6 +72,14 @@ You pass these two pieces of information to create an instance of an API client:
 client = RESO::API::Client.new(access_token: access_token, base_url: base_url)
 ```
 
+#### Base URL for Replication
+
+Some systems, like Bridge Interactive, provide replication endpoints that differ from the ones for normal search requests by including an additional path segment *following* the resource segment. For example:
+
+    https://api.bridgedataoutput.com/api/v2/OData/{dataset_id}/Property/replication
+
+To accommodate this, the `base_url` parameter may contain a `/$resource$` segment which will be replaced for each API call with the appropriate resource segment.
+
 
 ### Resources
 
@@ -94,19 +102,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:
 
-The simplest query is simply to call `properties` on the initialized client: 
+| 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
 
 ```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')
@@ -195,7 +375,7 @@ client.properties(ignorenulls: true)
 
 #### Automatically iterate over all results
 
-By passing a block to Media, Member, Office, and Property resource calls, subsequent paginated calls will automatically be made until the whole result set has been traversed. The block provided is executed for each returned object hash. The `batch` option can be used to return the full array of results. 
+By passing a block to Media, Member, Office, and Property resource calls, subsequent paginated calls will automatically be made until the whole result set has been traversed. The block provided is executed for each returned object hash. The `batch` option can be used to return the full array of results.
 
 Here are a couple of examples of how that can be used:
 

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

@@ -57,10 +57,15 @@ 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
-          if !filter.include?('OriginatingSystemName') && osn.present?
+          filter = hash[:filter]
+          if !filter.to_s.include?('OriginatingSystemName') && osn.present?
             osn_filter = format("OriginatingSystemName eq '%s'", osn.to_s)
             filter = [filter.presence, osn_filter].compact.join(' and ')
           end
@@ -227,7 +232,12 @@ module RESO
       end
 
       def uri_for_endpoint endpoint
-        return URI(endpoint).host ? URI(endpoint) : URI([base_url, endpoint].join)
+        uri = URI(endpoint)
+        return uri if uri.host
+        uri = URI(base_url)
+        path = uri.path
+        uri.path = path.include?("/$resource$") ? path.sub("/$resource$", endpoint) : [path, endpoint].join
+        return uri
       end
 
       def perform_call(endpoint, params, max_retries = 5, debug = false)
@@ -237,7 +247,7 @@ 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
@@ -270,7 +280,7 @@ module RESO
             fresh_oauth2_payload
             raise StandardError
           elsif response.is_a?(Hash) && response.has_key?("error")
-            error_msg = response.inspect
+            error_msg = "#{@last_request_url} => #{response.inspect}"
             puts "Error: #{error_msg}" if debug
             raise StandardError, error_msg
           elsif response.is_a?(Hash) && response.has_key?("retry-after")

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.13"
+  VERSION = "2.0.1"
 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.13
+  version: 2.0.1
 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