statelydb 0.18.3 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e07b296b0a2f8dda95a010bd074b91c653f8a5c45cf2a6fc0418d7b158644ca8
-  data.tar.gz: cf3895a85a5090c62c87bda2d2bf75d0d6ae7a668c1f8dfb5bb2e4068399fdeb
+  metadata.gz: 48b92c6e1895bb7e7a5a27634f5012e9183b514a1210b25a54528000d8980e5d
+  data.tar.gz: ea786444657ea16320c913c115bac7f2cc17f3a9223d4ff53466504cac3930b3
 SHA512:
-  metadata.gz: 0644d032470017c1a692713fd1a9f06633e836af51c59a20bf4859c21d94e67031c58db6fa70e72ef5055594eb305cad2b961cd4437c280d8147d7ed9e8aefea
-  data.tar.gz: 64d33d0c37809b0a819014ea38cba6ec506d313a163e09286dbd20944291d9d49f34cfc21d042f80a85aeb2050bccc72d8b843061bbae5dc63e882b09802ca41
+  metadata.gz: 1fa6566c111cc334eb9015880f2d5feec32e10e571522a9609e1413ee5b7a455a7858ad599c5fcc8bc0e0ecb6a42175faf1a0aca7ecb6f402426915c7f9bba04
+  data.tar.gz: e4e5b788790d397ff220f28a78221c81a533bf0a8f8c58328dbe85d9085d3074fcce5b5f68fcf06b946c1858225b0ce8eabb7c84fe0641599244961dcc079f0b

data/lib/statelydb.rb

@@ -165,6 +165,66 @@ module StatelyDB
       process_list_response(resp)
     end
 
+    # Initiates a scan request which will scan over the entire store and apply
+    # the provided filters. This API returns a token that you can pass to
+    # continue_scan to paginate through the result set. This can fail if the
+    # caller does not have permission to read Items.
+    #
+    # WARNING: THIS API CAN BE EXTREMELY EXPENSIVE FOR STORES WITH A LARGE NUMBER
+    # OF ITEMS.
+    #
+    # @param limit [Integer] the maximum number of items to return
+    # @param item_types [Array<Class, String>] the item types to filter by. The returned
+    #   items will be instances of one of these types.
+    # @param total_segments [Integer] the total number of segments to divide the
+    #   scan into. Use this when you want to parallelize your operation.
+    # @param segment_index [Integer] the index of the segment to scan.
+    #   Use this when you want to parallelize your operation.
+    # @return [Array<StatelyDB::Item>, StatelyDB::Token] the list of Items and the token
+    #
+    # @example
+    #   client.data.begin_scan(limit: 10, item_types: [MyItem])
+    def begin_scan(limit: 100,
+                   item_types: [],
+                   total_segments: nil,
+                   segment_index: nil)
+      if total_segments.nil? != segment_index.nil?
+        raise StatelyDB::Error.new("total_segments and segment_index must both be set or both be nil",
+                                   code: GRPC::Core::StatusCodes::INVALID_ARGUMENT,
+                                   stately_code: "InvalidArgument")
+      end
+      req = Stately::Db::BeginScanRequest.new(
+        store_id: @store_id,
+        limit:,
+        filter_condition: item_types.map do |item_type|
+          Stately::Db::FilterCondition.new(item_type: item_type.respond_to?(:name) ? item_type.name.split("::").last : item_type)
+        end,
+        schema_version_id: @schema::SCHEMA_VERSION_ID
+      )
+      resp = @stub.begin_scan(req)
+      process_list_response(resp)
+    end
+
+    # continue_scan takes the token from a begin_scan call and returns more results
+    # based on the original request parameters and pagination options.
+    #
+    # WARNING: THIS API CAN BE EXTREMELY EXPENSIVE FOR STORES WITH A LARGE NUMBER OF ITEMS.
+    #
+    # @param token [StatelyDB::Token] the token to continue from
+    # @return [Array<StatelyDB::Item>, StatelyDB::Token] the list of Items and the token
+    #
+    # @example
+    #  (items, token) = client.data.begin_scan(limit: 10, item_types: [MyItem])
+    #  client.data.continue_scan(token)
+    def continue_scan(token)
+      req = Stately::Db::ContinueScanRequest.new(
+        token_data: token.token_data,
+        schema_version_id: @schema::SCHEMA_VERSION_ID
+      )
+      resp = @stub.continue_scan(req)
+      process_list_response(resp)
+    end
+
     # Sync a list of Items from a StatelyDB Store.
     #
     # @param token [StatelyDB::Token] the token to sync from

data/sig/statelydb.rbi

@@ -297,6 +297,53 @@ module StatelyDB
     sig { params(token: StatelyDB::Token).returns(T.any(T::Array[StatelyDB::Item], StatelyDB::Token)) }
     def continue_list(token); end
 
+    # Initiates a scan request which will scan over the entire store and apply
+    # the provided filters. This API returns a token that you can pass to
+    # continue_scan to paginate through the result set. This can fail if the
+    # caller does not have permission to read Items.
+    # 
+    # WARNING: THIS API CAN BE EXTREMELY EXPENSIVE FOR STORES WITH A LARGE NUMBER
+    # OF ITEMS.
+    # 
+    # _@param_ `limit` — the maximum number of items to return
+    # 
+    # _@param_ `item_types` — the item types to filter by. The returned items will be instances of one of these types.
+    # 
+    # _@param_ `total_segments` — the total number of segments to divide the scan into. Use this when you want to parallelize your operation.
+    # 
+    # _@param_ `segment_index` — the index of the segment to scan. Use this when you want to parallelize your operation.
+    # 
+    # _@return_ — the list of Items and the token
+    # 
+    # ```ruby
+    # client.data.begin_scan(limit: 10, item_types: [MyItem])
+    # ```
+    sig do
+      params(
+        limit: Integer,
+        item_types: T::Array[T.any(Class, String)],
+        total_segments: T.nilable(Integer),
+        segment_index: T.nilable(Integer)
+      ).returns(T.any(T::Array[StatelyDB::Item], StatelyDB::Token))
+    end
+    def begin_scan(limit: 100, item_types: [], total_segments: nil, segment_index: nil); end
+
+    # continue_scan takes the token from a begin_scan call and returns more results
+    # based on the original request parameters and pagination options.
+    # 
+    # WARNING: THIS API CAN BE EXTREMELY EXPENSIVE FOR STORES WITH A LARGE NUMBER OF ITEMS.
+    # 
+    # _@param_ `token` — the token to continue from
+    # 
+    # _@return_ — the list of Items and the token
+    # 
+    # ```ruby
+    # (items, token) = client.data.begin_scan(limit: 10, item_types: [MyItem])
+    # client.data.continue_scan(token)
+    # ```
+    sig { params(token: StatelyDB::Token).returns(T.any(T::Array[StatelyDB::Item], StatelyDB::Token)) }
+    def continue_scan(token); end
+
     # Sync a list of Items from a StatelyDB Store.
     # 
     # _@param_ `token` — the token to sync from

data/sig/statelydb.rbs

@@ -252,6 +252,49 @@ module StatelyDB
     # ```
     def continue_list: (StatelyDB::Token token) -> (::Array[StatelyDB::Item] | StatelyDB::Token)
 
+    # Initiates a scan request which will scan over the entire store and apply
+    # the provided filters. This API returns a token that you can pass to
+    # continue_scan to paginate through the result set. This can fail if the
+    # caller does not have permission to read Items.
+    # 
+    # WARNING: THIS API CAN BE EXTREMELY EXPENSIVE FOR STORES WITH A LARGE NUMBER
+    # OF ITEMS.
+    # 
+    # _@param_ `limit` — the maximum number of items to return
+    # 
+    # _@param_ `item_types` — the item types to filter by. The returned items will be instances of one of these types.
+    # 
+    # _@param_ `total_segments` — the total number of segments to divide the scan into. Use this when you want to parallelize your operation.
+    # 
+    # _@param_ `segment_index` — the index of the segment to scan. Use this when you want to parallelize your operation.
+    # 
+    # _@return_ — the list of Items and the token
+    # 
+    # ```ruby
+    # client.data.begin_scan(limit: 10, item_types: [MyItem])
+    # ```
+    def begin_scan: (
+                      ?limit: Integer,
+                      ?item_types: ::Array[(Class | String)],
+                      ?total_segments: Integer?,
+                      ?segment_index: Integer?
+                    ) -> (::Array[StatelyDB::Item] | StatelyDB::Token)
+
+    # continue_scan takes the token from a begin_scan call and returns more results
+    # based on the original request parameters and pagination options.
+    # 
+    # WARNING: THIS API CAN BE EXTREMELY EXPENSIVE FOR STORES WITH A LARGE NUMBER OF ITEMS.
+    # 
+    # _@param_ `token` — the token to continue from
+    # 
+    # _@return_ — the list of Items and the token
+    # 
+    # ```ruby
+    # (items, token) = client.data.begin_scan(limit: 10, item_types: [MyItem])
+    # client.data.continue_scan(token)
+    # ```
+    def continue_scan: (StatelyDB::Token token) -> (::Array[StatelyDB::Item] | StatelyDB::Token)
+
     # Sync a list of Items from a StatelyDB Store.
     # 
     # _@param_ `token` — the token to sync from

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statelydb
 version: !ruby/object:Gem::Version
-  version: 0.18.3
+  version: 0.19.0
 platform: ruby
 authors:
 - Stately Cloud, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-09 00:00:00.000000000 Z
+date: 2025-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async