activeitem 0.0.7 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0449e0de4aa951adcf2bdd085d145a0673439115fd8a51b7de275f60c461ecd9'
-  data.tar.gz: 5e580ffadfd8ee4b22fbd6f4c54b934330c832383baf07f9c601e64e3fd3a99a
+  metadata.gz: b243ed910a2d03058939e87540ae8db73306ce0b550497c9a2f7aab8cf4cb1b4
+  data.tar.gz: ebb28b886aa8f1e7fe45c0efe1dd760af15a729f434e5beb5075952bb059fee3
 SHA512:
-  metadata.gz: 4ad8dbfafc70f15ade76a5e030e505e8af3e7b3186d355ac5d16de97843f905f7789471bb04e706ef84fb012fa8de3d0c361973514c33ecc5f534efd9e4f8c3b
-  data.tar.gz: ddc7e4f5bf1ab8a814e2d3e58c103d01d2446f85599802925ff7e624d95ffd8ae559e66cc0b7c941adfd160a0f1c166cfac77104f5e84f48dd5dd7c570f58a58
+  metadata.gz: 18250436726865a0397d3db991a911356f41a59b7d5b0542e56d8e171e27094d3c19d43fb73a6c42b6d1b705544432cc3f928f7bbf70afdd69ae3dbc2c8f78b3
+  data.tar.gz: 17677be007f18965b1206c1fb8274835dc86b923b54a0f43bd48f20750edd2eb052f38412d86357e28ef614207f2a24fb614e3c9ecd4878149bd8aa5ab7c61a0

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.0.9
+
+### Fixed
+
+- **Pagination cursor loss in `paginated_query_with_index`** — when the 2x overfetch returned all remaining items in a single DynamoDB response (no `LastEvaluatedKey`), the method returned `has_more: false` despite having silently trimmed items. Now builds a synthetic `ExclusiveStartKey` from the last returned item's attributes (table PK + GSI partition/sort keys) to ensure correct pagination.
+
+## 0.0.8
+
+### Added
+
+- **Array partition key fan-out** — `where(partition_key: [val1, val2, ...])` now queries each partition in parallel and merges results, instead of raising `ArgumentError`
+- Works with `.to_a`, `.page(cursor, per_page:)`, `.count`, `.order(:desc)`, `.not(...)`, and all other chainable methods
+- Pagination uses a `sort_val|id` cursor format for cross-partition consistency
+- Thread-pooled execution (max 10 concurrent queries) matching existing `preload_has_many_counts` pattern
+
 ## 0.0.7
 
 ### Added

data/certs/stowzilla.pem

@@ -1,31 +1,26 @@
 -----BEGIN CERTIFICATE-----
-MIIFaTCCA1GgAwIBAgIUax444kioC0RHJ7r5iympSbt4GOEwDQYJKoZIhvcNAQEL
-BQAwRDESMBAGA1UEAwwJc3Rvd3ppbGxhMRkwFwYKCZImiZPyLGQBGRYJc3Rvd3pp
-bGxhMRMwEQYKCZImiZPyLGQBGRYDY29tMB4XDTI2MDUyNjE1MDMzMloXDTI3MDUy
-NjE1MDMzMlowRDESMBAGA1UEAwwJc3Rvd3ppbGxhMRkwFwYKCZImiZPyLGQBGRYJ
-c3Rvd3ppbGxhMRMwEQYKCZImiZPyLGQBGRYDY29tMIICIjANBgkqhkiG9w0BAQEF
-AAOCAg8AMIICCgKCAgEAmLd7XtS7QkSvRl7eHVJwwvUTWG4Rk/uHRGZR09Cb/Hr3
-ehCdHQvcVxyotmg3qZh4yyf7jZfiESMlm3iXqPsjm7IyVKHBky0n9WB7xFDZe5fh
-gZwXAA5OXA0RGCaqMSnps3WJIzvUZkOZ2dnSH+oF2mK/7i4SUMN1nVMXdzu1bM3b
-jwhMbhsYztQSuypugDKV/87RitsHHN+1qDFP6DJRhSgXy9tFzYconRJBgIag/Kyy
-PQmAOTPfCoZeMmNllOJsd3F2W2u++bSKIGCJ2JD86lmggLwI+8kT1b9nOD8ULEGu
-GcPrqHWShn3lVDXCQHJVU1pGN2DybtCVO88+Sf4UxT61TPKAYj/dMYMyYta1aYfK
-u4RtgGkUD7eJYzJ4QSpNJgr+eUQXMirwn7xPRhBIWIZx4QbnAmZRfNpLjoPRiC9k
-V6/rjMYAeJU6z2jnOySZGN97cTbTNK7m9QyR5U0U5WQi0IBpB+0xe6c8ihKyPOeC
-hsLkZ7VxuO0gqfUDKG9DqX4/+xSqNKO8bwYa+nbBtZPjPWFyHQGQWKXOLLFK/VHk
-0+6V6HosjoaRW4M1gVlu+vGWHcpmdPOmfPShkqNgZQkvhhrdg2U/xyFzLrHoRTG3
-9JsjpfIGO+PAK3LPNy3YjZJcLnk8rLaaksUt691d1KH0y6e411vKoqxmZ3pHeu8C
-AwEAAaNTMFEwHQYDVR0OBBYEFJdJFQTOcHjR+03ZWZ7p9nnCVRBRMB8GA1UdIwQY
-MBaAFJdJFQTOcHjR+03ZWZ7p9nnCVRBRMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZI
-hvcNAQELBQADggIBAFVHepD8diydFHg62HRWf7lETEoupJC7bUvSamgWi9r5svKK
-AhhRErJu5JJIcFsS0tQQNVucbJXbaEVfuQ0jHpIT1TnVQGKALE9nIFt90epjAlzB
-IrWWn4CgEWG8ek/81vvJZ7nBBq+BS11/yi2sx/j/eSArY/5ElM6rEnKrG/E7YnZD
-eCnF794rc17PdbNmLkjUWK99EA/v0424L7l8RU/2FvgHXa57xuZcY7LqpQIwaKIU
-uDBvSASNCzuBe+XXx5eEIpvEpBysDrGtIZ99IkJe+6XtAXnJRefq3fEJCaEzUPky
-qoZFv1pK+U+ziCXTVH33+daPpDa+UqUAfhX+qGj7ZyKKP5i3tHi76DtVAqA4rkHE
-riNRHVNH6TJnvBA9MPDNGy1AzgccqwKlWNz9l0WoMxkP8xfJbsTlc2AKjNOjx/RB
-Xv+HRgTnsHUgDEIFx23dsFsl71ULMii8GrarJf0GfCAYv8WNJWchWMhSaNpZGBPa
-+4NJEsWBK1Rof5oTH3SS8FyWdbt1hbQ2XW5BQ94xCtsybxJYlfEkYflIg6ROlCZO
-mR0ObwJ14vsQVbJibq0eRHIg8G4yV19pvEdJCli02eLl1+451M63HZAqBNuyJ9Ny
-I1fxbbEBAzf7WHfoKdwFMuRZq7hpdLykCA8YQJFlLLFoXT0g41ug9iOKBtGg
+MIIEdDCCAtygAwIBAgIBATANBgkqhkiG9w0BAQsFADBAMQ4wDAYDVQQDDAVhZ2Vu
+dDEZMBcGCgmSJomT8ixkARkWCXN0b3d6aWxsYTETMBEGCgmSJomT8ixkARkWA2Nv
+bTAeFw0yNjA2MDgxOTExNTlaFw0yNzA2MDgxOTExNTlaMEAxDjAMBgNVBAMMBWFn
+ZW50MRkwFwYKCZImiZPyLGQBGRYJc3Rvd3ppbGxhMRMwEQYKCZImiZPyLGQBGRYD
+Y29tMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAupBquKI/4WvXOgND
+pXyqH2GllZs1wG4TWWdn/DoMg45UoCwD+AWEuGrIdInBCpPN8vEJNJWPoM/RrU+b
+xRBZT4uUk00bnZRW2SYh5GJSqBoBR+rWc2DGkXyGfdRU2sQvkB0+is6ChgQ61WMM
+33LE9+loBlVsZ6EVtrc18Uh2OW0mJpe0hN2nmBrxZqqOZigxC4DKRMFHvpRkxSb6
+mD4kit1AcwX9NEWJsXxrPaetL/SB/VbXaEZX93XAvp6USaXvCWt4slkDS2mIvqtn
+9DtGC43LFC7SDGbnsG9PVenQgVCi8UWFPUAab0PqZSlmi3Qlbhw8qTGPp5Cbv4vz
+qjC2UGPOQigA/7lbbGRhCohMrjOVHMAQwkcgiIqtolUoYlnvPMIy+m3pdvgDv/PH
+bsZGvXQ7i0458xsmp1vaKthZocVAR+GboHbuIiYPUnO45ccXUQ00x6365tTe7mZi
+NvmUYdAGbQmVvFqyxF7IYA6sF74L2Lstu0knSfss557bAe1HAgMBAAGjeTB3MAkG
+A1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBSnxTL/lNBCeLqpeVIX6AUY
+kel4zjAeBgNVHREEFzAVgRNhZ2VudEBzdG93emlsbGEuY29tMB4GA1UdEgQXMBWB
+E2FnZW50QHN0b3d6aWxsYS5jb20wDQYJKoZIhvcNAQELBQADggGBACm9Fjit/UCv
+FxlKqeiCTIG94cIx+QrWAOJSx9knKydwUec1u04D/DbfZjTn3C2Bj227QgxeUn+6
+if3e2v7zAk1896hLmGYzML0+nxQPb0vmtdLR7HETUlSKTVabcv1fbwLyjsuGrBvk
+y51vOEzUEZ508a9yepLYqrQu1kOju4d57c9oA5l3H0mMKWz7av9tFj0B+STvuaWk
+HRYDWc5HgOEVTyV+w0uFt2Kw4OCb8C42uSvC5RfYYtw78MSP+5Ru+LXJ7XOtmuN0
+E6GVmofQ17ig9O3rgfFbMendSInrRmvPIGswvM1yivq9NOllFbdck2OJKPx6FCJF
+7SJIkXQfc9P4B5iASIV1d1FsE0YX+g3jHXPJK/4mGL5bAyBKzpMfQB/mg6vQBzkh
+aOKPwcreFj7TznBl89R5tNS9wZQfPVR98zgPyocddWhK18eQNMSBUnv4eeJ8PPbk
+DovL+G8ajHDZ9fjH/+GVYHEMuiVdLarXrKJpHC1VfGTTUAp4NSEpUQ==
 -----END CERTIFICATE-----

data/lib/active_item/relation.rb

@@ -507,10 +507,20 @@ module ActiveItem
       return [[], nil] if conditions[:_empty]
 
       normalized_conditions = normalize_conditions(conditions)
-      exclusive_start_key = decode_cursor(cursor)
 
       effective_index = index_name || resolved_model.send(:detect_index_for_conditions, normalized_conditions)
 
+      # Array partition key fan-out uses a simple string cursor (sort_val|id), not DynamoDB LastEvaluatedKey
+      if effective_index && normalized_conditions.any? && normalized_conditions.values.first.is_a?(Array)
+        index_config = resolved_model.indexes[effective_index] || {}
+        ruby_partition_key = normalized_conditions.keys.first.to_s
+        dynamo_partition_key = index_config[:partition_key]&.to_s || resolved_model.to_dynamo_key(ruby_partition_key)
+        return fanout_paginated_query(effective_index, normalized_conditions, index_config, dynamo_partition_key,
+                                      normalized_conditions.values.first, cursor, per_page)
+      end
+
+      exclusive_start_key = decode_cursor(cursor)
+
       if effective_index && normalized_conditions.any?
         paginated_query_with_index(effective_index, normalized_conditions, exclusive_start_key, per_page)
       else
@@ -651,12 +661,24 @@ module ActiveItem
 
       # Trim to requested page size and determine next cursor
       if collected_items.length > per_page
-        [collected_items.take(per_page), encode_cursor(last_evaluated_key || current_cursor)]
+        next_cursor = last_evaluated_key || build_synthetic_cursor(collected_items[per_page - 1], idx_name, index_config)
+        [collected_items.take(per_page), encode_cursor(next_cursor)]
       else
         [collected_items, encode_cursor(last_evaluated_key)]
       end
     end
 
+    # Build a synthetic ExclusiveStartKey from an item when DynamoDB didn't paginate
+    # but we have more items than per_page (overfetch returned everything in one shot).
+    # For GSI queries, DynamoDB requires: table PK + index partition key + index sort key (if any).
+    def build_synthetic_cursor(item, _idx_name, index_config)
+      pk_dynamo = resolved_model.to_dynamo_key(resolved_model.primary_key.to_s)
+      cursor = { pk_dynamo => item.id }
+      cursor[index_config[:partition_key].to_s] = item.send(resolved_model.from_dynamo_key(index_config[:partition_key].to_s)) if index_config[:partition_key]
+      cursor[index_config[:sort_key].to_s] = item.send(resolved_model.from_dynamo_key(index_config[:sort_key].to_s)) if index_config[:sort_key]
+      cursor
+    end
+
     # Execute paginated scan
     # Keeps fetching until we have per_page items that pass the filter
     def paginated_scan_with_conditions(normalized_conditions, exclusive_start_key, per_page)
@@ -755,6 +777,9 @@ module ActiveItem
 
       effective_index = (index_name || resolved_model.send(:detect_index_for_conditions, normalized_conditions) if normalized_conditions.any?)
 
+      # Array partition key: fan-out count queries in parallel
+      return fanout_count_query(effective_index, normalized_conditions) if effective_index && normalized_conditions.any? && normalized_conditions.values.first.is_a?(Array)
+
       total = 0
       exclusive_start_key = nil
 
@@ -1034,7 +1059,7 @@ module ActiveItem
       index_config = resolved_model.indexes[idx_name] || {}
       dynamo_partition_key = index_config[:partition_key]&.to_s || resolved_model.to_dynamo_key(ruby_partition_key)
 
-      raise ArgumentError, 'Array values not supported for partition key queries. Use scan instead.' if partition_value.is_a?(Array)
+      return fanout_query(idx_name, normalized_conditions, index_config, dynamo_partition_key, partition_value) if partition_value.is_a?(Array)
 
       raise ArgumentError, 'Range values not supported for partition key queries. Use scan instead.' if partition_value.is_a?(Range)
 
@@ -1120,6 +1145,281 @@ module ActiveItem
       all_items
     end
 
+    # Fan-out parallel queries when partition key is an Array.
+    # Queries each partition key in parallel, merges and optionally sorts results.
+    def fanout_query(idx_name, _normalized_conditions, index_config, dynamo_partition_key, partition_values)
+      return [] if partition_values.empty?
+
+      sort_key = index_config[:sort_key]&.to_s
+      remaining_conditions = conditions.to_a[1..]
+      filter_parts, filter_names, filter_values = build_fanout_filters(sort_key, remaining_conditions)
+
+      all_items = []
+      mutex = Mutex.new
+      max_concurrency = 10
+
+      partition_values.each_slice(max_concurrency) do |batch|
+        threads = batch.map do |pk_val|
+          Thread.new do
+            params = {
+              table_name: resolved_model.table_name,
+              index_name: idx_name,
+              key_condition_expression: '#pk = :pk_val',
+              expression_attribute_names: { '#pk' => dynamo_partition_key }.merge(filter_names),
+              expression_attribute_values: { ':pk_val' => pk_val }.merge(filter_values)
+            }
+
+            apply_sort_key_to_params!(params, sort_key, remaining_conditions)
+            params[:filter_expression] = filter_parts.join(' AND ') if filter_parts.any?
+            params[:limit] = limit_value if limit_value
+            params[:scan_index_forward] = (order_direction != :desc) unless order_direction.nil?
+            apply_projection_expression!(params)
+
+            items = []
+            exclusive_start_key = nil
+            loop do
+              params[:exclusive_start_key] = exclusive_start_key if exclusive_start_key
+              response = resolved_model.dynamodb.query(params)
+              items.concat(response.items.map { |item| resolved_model.instantiate(item) })
+              exclusive_start_key = response.last_evaluated_key
+              break unless exclusive_start_key
+              break if limit_value && items.length >= limit_value
+            end
+            mutex.synchronize { all_items.concat(items) }
+          end
+        end
+        threads.each(&:join)
+      end
+
+      all_items = apply_ilike_filter(all_items)
+      all_items = sort_fanout_results(all_items, sort_key)
+      all_items = all_items.first(limit_value) if limit_value
+      all_items
+    end
+
+    # Fan-out paginated query across multiple partition keys.
+    # Uses a composite cursor that encodes sort_key|id position for cross-partition pagination.
+    def fanout_paginated_query(idx_name, _normalized_conditions, index_config, dynamo_partition_key, partition_values,
+                               cursor, per_page)
+      return [[], nil] if partition_values.empty?
+
+      sort_key = index_config[:sort_key]&.to_s
+      remaining_conditions = conditions.to_a[1..]
+      filter_parts, filter_names, filter_values = build_fanout_filters(sort_key, remaining_conditions)
+      cursor_sort_val, cursor_id = decode_fanout_cursor(cursor)
+
+      all_items = []
+      mutex = Mutex.new
+      max_concurrency = 10
+
+      partition_values.each_slice(max_concurrency) do |batch|
+        threads = batch.map do |pk_val|
+          Thread.new do
+            params = {
+              table_name: resolved_model.table_name,
+              index_name: idx_name,
+              key_condition_expression: '#pk = :pk_val',
+              expression_attribute_names: { '#pk' => dynamo_partition_key }.merge(filter_names),
+              expression_attribute_values: { ':pk_val' => pk_val }.merge(filter_values)
+            }
+
+            apply_sort_key_to_params!(params, sort_key, remaining_conditions)
+
+            # Apply cursor range condition to skip already-seen items
+            if cursor_sort_val && sort_key
+              sk_placeholder = '#fanout_sk'
+              val_placeholder = ':fanout_sk_val'
+              op = order_direction == :desc ? '<=' : '>='
+              params[:key_condition_expression] += " AND #{sk_placeholder} #{op} #{val_placeholder}"
+              params[:expression_attribute_names][sk_placeholder] = sort_key
+              params[:expression_attribute_values][val_placeholder] = cursor_sort_val
+            end
+
+            params[:filter_expression] = filter_parts.join(' AND ') if filter_parts.any?
+            params[:scan_index_forward] = (order_direction != :desc) unless order_direction.nil?
+            # Fetch enough to fill a page after merge
+            params[:limit] = per_page + 1
+
+            items = []
+            exclusive_start_key = nil
+            loop do
+              params[:exclusive_start_key] = exclusive_start_key if exclusive_start_key
+              response = resolved_model.dynamodb.query(params)
+              items.concat(response.items.map { |item| resolved_model.instantiate(item) })
+              exclusive_start_key = response.last_evaluated_key
+              break unless exclusive_start_key
+              break if items.length >= per_page + 1
+            end
+            mutex.synchronize { all_items.concat(items) }
+          end
+        end
+        threads.each(&:join)
+      end
+
+      all_items = apply_ilike_filter(all_items)
+      all_items = sort_fanout_results(all_items, sort_key)
+
+      # Skip items at or before the cursor position
+      if cursor_sort_val && cursor_id
+        all_items = all_items.drop_while do |item|
+          sk_val = if sort_key
+                     item.respond_to?(sort_key) ? item.send(sort_key) : item.send(underscore(sort_key))
+                   end
+          sk_val ||= item.respond_to?(:created_at) ? item.created_at : nil
+          cmp = compare_with_nil(sk_val, cursor_sort_val)
+          if order_direction == :desc
+            cmp.positive? || (cmp.zero? && item.id >= cursor_id)
+          else
+            cmp.negative? || (cmp.zero? && item.id <= cursor_id)
+          end
+        end
+      end
+
+      page_items = all_items.first(per_page)
+      next_cursor = (encode_fanout_cursor(page_items.last, sort_key) if all_items.length > per_page && page_items.last)
+
+      [page_items, next_cursor]
+    end
+
+    def build_fanout_filters(sort_key, remaining_conditions)
+      filter_parts = []
+      filter_names = {}
+      filter_values = {}
+
+      # Exclude sort key conditions — those go into key_condition_expression
+      non_sort_conditions = remaining_conditions.reject do |k, _|
+        sort_key && (resolved_model.to_dynamo_key(k.to_s) == sort_key || k.to_s == sort_key)
+      end
+
+      non_sort_conditions.each_with_index do |(attr, val), idx|
+        expr, names, values = resolved_model.send(:build_condition_expression, attr, val, idx, ilike: ilike)
+        filter_parts << expr
+        filter_names.merge!(names)
+        filter_values.merge!(values) if values.any?
+      end
+
+      not_conditions.each_with_index do |(attr, val), idx|
+        expr, names, values = build_not_condition_expression(attr, val, "not#{idx}")
+        filter_parts << expr
+        filter_names.merge!(names)
+        filter_values.merge!(values) if values.any?
+      end
+
+      [filter_parts, filter_names, filter_values]
+    end
+
+    def apply_sort_key_to_params!(params, sort_key, remaining_conditions)
+      return unless sort_key && remaining_conditions.any?
+
+      sort_condition = remaining_conditions.find do |k, _|
+        resolved_model.to_dynamo_key(k.to_s) == sort_key || k.to_s == sort_key
+      end
+      return unless sort_condition
+
+      _, sort_value = sort_condition
+      if sort_value.is_a?(Range)
+        range_condition = resolved_model.send(:build_sort_key_range_condition, sort_key, sort_value)
+        params[:key_condition_expression] += " AND #{range_condition[:expression]}"
+        params[:expression_attribute_names].merge!(range_condition[:names])
+        params[:expression_attribute_values].merge!(range_condition[:values])
+      else
+        params[:key_condition_expression] += ' AND #sk = :sk_val'
+        params[:expression_attribute_names]['#sk'] = sort_key
+        params[:expression_attribute_values][':sk_val'] = sort_value
+      end
+    end
+
+    def sort_fanout_results(items, sort_key)
+      return items unless sort_key
+
+      sorted = items.sort_by do |item|
+        sk_val = item.respond_to?(sort_key) ? item.send(sort_key) : item.send(underscore(sort_key))
+        sk_val ||= ''
+        if order_direction == :desc
+          [sk_val, item.id].map { |v| v.is_a?(String) ? v : v.to_s }
+        else
+          [sk_val, item.id]
+        end
+      end
+
+      order_direction == :desc ? sorted.reverse : sorted
+    end
+
+    def decode_fanout_cursor(cursor)
+      return [nil, nil] if cursor.nil? || cursor.empty?
+
+      sort_val, id = cursor.split('|', 2)
+      [sort_val, id]
+    rescue StandardError
+      [nil, nil]
+    end
+
+    def encode_fanout_cursor(item, sort_key)
+      sk_val = if sort_key
+                 item.respond_to?(sort_key) ? item.send(sort_key) : item.send(underscore(sort_key))
+               end
+      sk_val ||= item.respond_to?(:created_at) ? item.created_at : nil
+      "#{sk_val}|#{item.id}"
+    end
+
+    def compare_with_nil(left, right)
+      return 0 if left.nil? && right.nil?
+      return -1 if left.nil?
+      return 1 if right.nil?
+
+      left <=> right
+    end
+
+    def underscore(str)
+      str.gsub(/([A-Z])/, '_\1').sub(/^_/, '').downcase
+    end
+
+    def fanout_count_query(idx_name, normalized_conditions)
+      partition_values = normalized_conditions.values.first
+      index_config = resolved_model.indexes[idx_name] || {}
+      ruby_partition_key = normalized_conditions.keys.first.to_s
+      dynamo_partition_key = index_config[:partition_key]&.to_s || resolved_model.to_dynamo_key(ruby_partition_key)
+      sort_key = index_config[:sort_key]&.to_s
+      remaining_conditions = conditions.to_a[1..]
+      filter_parts, filter_names, filter_values = build_fanout_filters(sort_key, remaining_conditions)
+
+      total = 0
+      mutex = Mutex.new
+      max_concurrency = 10
+
+      partition_values.each_slice(max_concurrency) do |batch|
+        threads = batch.map do |pk_val|
+          Thread.new do
+            params = {
+              table_name: resolved_model.table_name,
+              index_name: idx_name,
+              select: 'COUNT',
+              key_condition_expression: '#pk = :pk_val',
+              expression_attribute_names: { '#pk' => dynamo_partition_key }.merge(filter_names),
+              expression_attribute_values: { ':pk_val' => pk_val }.merge(filter_values)
+            }
+
+            apply_sort_key_to_params!(params, sort_key, remaining_conditions)
+            params[:filter_expression] = filter_parts.join(' AND ') if filter_parts.any?
+
+            count = 0
+            exclusive_start_key = nil
+            loop do
+              params[:exclusive_start_key] = exclusive_start_key if exclusive_start_key
+              response = resolved_model.dynamodb.query(params)
+              count += response.count
+              exclusive_start_key = response.last_evaluated_key
+              break unless exclusive_start_key
+            end
+            mutex.synchronize { total += count }
+          end
+        end
+        threads.each(&:join)
+      end
+
+      limit_value ? [total, limit_value].min : total
+    end
+
     def scan_with_conditions_normalized(normalized_conditions)
       filter_parts = []
       filter_values = {}

data/lib/active_item/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveItem
-  VERSION = '0.0.7'
+  VERSION = '0.0.9'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activeitem
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.9
 platform: ruby
 authors:
 - Andy Davis
@@ -11,37 +11,32 @@ bindir: bin
 cert_chain:
 - |
   -----BEGIN CERTIFICATE-----
-  MIIFaTCCA1GgAwIBAgIUax444kioC0RHJ7r5iympSbt4GOEwDQYJKoZIhvcNAQEL
-  BQAwRDESMBAGA1UEAwwJc3Rvd3ppbGxhMRkwFwYKCZImiZPyLGQBGRYJc3Rvd3pp
-  bGxhMRMwEQYKCZImiZPyLGQBGRYDY29tMB4XDTI2MDUyNjE1MDMzMloXDTI3MDUy
-  NjE1MDMzMlowRDESMBAGA1UEAwwJc3Rvd3ppbGxhMRkwFwYKCZImiZPyLGQBGRYJ
-  c3Rvd3ppbGxhMRMwEQYKCZImiZPyLGQBGRYDY29tMIICIjANBgkqhkiG9w0BAQEF
-  AAOCAg8AMIICCgKCAgEAmLd7XtS7QkSvRl7eHVJwwvUTWG4Rk/uHRGZR09Cb/Hr3
-  ehCdHQvcVxyotmg3qZh4yyf7jZfiESMlm3iXqPsjm7IyVKHBky0n9WB7xFDZe5fh
-  gZwXAA5OXA0RGCaqMSnps3WJIzvUZkOZ2dnSH+oF2mK/7i4SUMN1nVMXdzu1bM3b
-  jwhMbhsYztQSuypugDKV/87RitsHHN+1qDFP6DJRhSgXy9tFzYconRJBgIag/Kyy
-  PQmAOTPfCoZeMmNllOJsd3F2W2u++bSKIGCJ2JD86lmggLwI+8kT1b9nOD8ULEGu
-  GcPrqHWShn3lVDXCQHJVU1pGN2DybtCVO88+Sf4UxT61TPKAYj/dMYMyYta1aYfK
-  u4RtgGkUD7eJYzJ4QSpNJgr+eUQXMirwn7xPRhBIWIZx4QbnAmZRfNpLjoPRiC9k
-  V6/rjMYAeJU6z2jnOySZGN97cTbTNK7m9QyR5U0U5WQi0IBpB+0xe6c8ihKyPOeC
-  hsLkZ7VxuO0gqfUDKG9DqX4/+xSqNKO8bwYa+nbBtZPjPWFyHQGQWKXOLLFK/VHk
-  0+6V6HosjoaRW4M1gVlu+vGWHcpmdPOmfPShkqNgZQkvhhrdg2U/xyFzLrHoRTG3
-  9JsjpfIGO+PAK3LPNy3YjZJcLnk8rLaaksUt691d1KH0y6e411vKoqxmZ3pHeu8C
-  AwEAAaNTMFEwHQYDVR0OBBYEFJdJFQTOcHjR+03ZWZ7p9nnCVRBRMB8GA1UdIwQY
-  MBaAFJdJFQTOcHjR+03ZWZ7p9nnCVRBRMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZI
-  hvcNAQELBQADggIBAFVHepD8diydFHg62HRWf7lETEoupJC7bUvSamgWi9r5svKK
-  AhhRErJu5JJIcFsS0tQQNVucbJXbaEVfuQ0jHpIT1TnVQGKALE9nIFt90epjAlzB
-  IrWWn4CgEWG8ek/81vvJZ7nBBq+BS11/yi2sx/j/eSArY/5ElM6rEnKrG/E7YnZD
-  eCnF794rc17PdbNmLkjUWK99EA/v0424L7l8RU/2FvgHXa57xuZcY7LqpQIwaKIU
-  uDBvSASNCzuBe+XXx5eEIpvEpBysDrGtIZ99IkJe+6XtAXnJRefq3fEJCaEzUPky
-  qoZFv1pK+U+ziCXTVH33+daPpDa+UqUAfhX+qGj7ZyKKP5i3tHi76DtVAqA4rkHE
-  riNRHVNH6TJnvBA9MPDNGy1AzgccqwKlWNz9l0WoMxkP8xfJbsTlc2AKjNOjx/RB
-  Xv+HRgTnsHUgDEIFx23dsFsl71ULMii8GrarJf0GfCAYv8WNJWchWMhSaNpZGBPa
-  +4NJEsWBK1Rof5oTH3SS8FyWdbt1hbQ2XW5BQ94xCtsybxJYlfEkYflIg6ROlCZO
-  mR0ObwJ14vsQVbJibq0eRHIg8G4yV19pvEdJCli02eLl1+451M63HZAqBNuyJ9Ny
-  I1fxbbEBAzf7WHfoKdwFMuRZq7hpdLykCA8YQJFlLLFoXT0g41ug9iOKBtGg
+  MIIEdDCCAtygAwIBAgIBATANBgkqhkiG9w0BAQsFADBAMQ4wDAYDVQQDDAVhZ2Vu
+  dDEZMBcGCgmSJomT8ixkARkWCXN0b3d6aWxsYTETMBEGCgmSJomT8ixkARkWA2Nv
+  bTAeFw0yNjA2MDgxOTExNTlaFw0yNzA2MDgxOTExNTlaMEAxDjAMBgNVBAMMBWFn
+  ZW50MRkwFwYKCZImiZPyLGQBGRYJc3Rvd3ppbGxhMRMwEQYKCZImiZPyLGQBGRYD
+  Y29tMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAupBquKI/4WvXOgND
+  pXyqH2GllZs1wG4TWWdn/DoMg45UoCwD+AWEuGrIdInBCpPN8vEJNJWPoM/RrU+b
+  xRBZT4uUk00bnZRW2SYh5GJSqBoBR+rWc2DGkXyGfdRU2sQvkB0+is6ChgQ61WMM
+  33LE9+loBlVsZ6EVtrc18Uh2OW0mJpe0hN2nmBrxZqqOZigxC4DKRMFHvpRkxSb6
+  mD4kit1AcwX9NEWJsXxrPaetL/SB/VbXaEZX93XAvp6USaXvCWt4slkDS2mIvqtn
+  9DtGC43LFC7SDGbnsG9PVenQgVCi8UWFPUAab0PqZSlmi3Qlbhw8qTGPp5Cbv4vz
+  qjC2UGPOQigA/7lbbGRhCohMrjOVHMAQwkcgiIqtolUoYlnvPMIy+m3pdvgDv/PH
+  bsZGvXQ7i0458xsmp1vaKthZocVAR+GboHbuIiYPUnO45ccXUQ00x6365tTe7mZi
+  NvmUYdAGbQmVvFqyxF7IYA6sF74L2Lstu0knSfss557bAe1HAgMBAAGjeTB3MAkG
+  A1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBSnxTL/lNBCeLqpeVIX6AUY
+  kel4zjAeBgNVHREEFzAVgRNhZ2VudEBzdG93emlsbGEuY29tMB4GA1UdEgQXMBWB
+  E2FnZW50QHN0b3d6aWxsYS5jb20wDQYJKoZIhvcNAQELBQADggGBACm9Fjit/UCv
+  FxlKqeiCTIG94cIx+QrWAOJSx9knKydwUec1u04D/DbfZjTn3C2Bj227QgxeUn+6
+  if3e2v7zAk1896hLmGYzML0+nxQPb0vmtdLR7HETUlSKTVabcv1fbwLyjsuGrBvk
+  y51vOEzUEZ508a9yepLYqrQu1kOju4d57c9oA5l3H0mMKWz7av9tFj0B+STvuaWk
+  HRYDWc5HgOEVTyV+w0uFt2Kw4OCb8C42uSvC5RfYYtw78MSP+5Ru+LXJ7XOtmuN0
+  E6GVmofQ17ig9O3rgfFbMendSInrRmvPIGswvM1yivq9NOllFbdck2OJKPx6FCJF
+  7SJIkXQfc9P4B5iASIV1d1FsE0YX+g3jHXPJK/4mGL5bAyBKzpMfQB/mg6vQBzkh
+  aOKPwcreFj7TznBl89R5tNS9wZQfPVR98zgPyocddWhK18eQNMSBUnv4eeJ8PPbk
+  DovL+G8ajHDZ9fjH/+GVYHEMuiVdLarXrKJpHC1VfGTTUAp4NSEpUQ==
   -----END CERTIFICATE-----
-date: 2026-06-01 00:00:00.000000000 Z
+date: 2026-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -188,7 +183,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/stowzilla/activeitem
-  source_code_uri: https://github.com/stowzilla/activeitem
+  source_code_uri: https://github.com/stowzilla/activeitem/tree/master
   changelog_uri: https://github.com/stowzilla/activeitem/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 post_install_message: