statelydb 0.18.2 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4941dbcedad863419e89b458329da8f401120e6ed90178b8deb93d58f1ccc14
-  data.tar.gz: 7e2b761654d8d2ff89babd8660842e9918170055b927dc5867b8f3949d53b1f3
+  metadata.gz: 48b92c6e1895bb7e7a5a27634f5012e9183b514a1210b25a54528000d8980e5d
+  data.tar.gz: ea786444657ea16320c913c115bac7f2cc17f3a9223d4ff53466504cac3930b3
 SHA512:
-  metadata.gz: 4df0f564d243fc079a927a97c8c726ae91a05e6418936a8c9fa89aa130d76e888b1730306d5899beb6d914d8a1ba5146ccbac9ae05391d76a92c5e8cc23bc7bc
-  data.tar.gz: 3356be381f50a26a31daba88e89bd8f221c974dbb593546129366aced51f9c953ec01f12c8e226521a92d8415451d6a7533c5cfd286f8b8c0bc08a40df682189
+  metadata.gz: 1fa6566c111cc334eb9015880f2d5feec32e10e571522a9609e1413ee5b7a455a7858ad599c5fcc8bc0e0ecb6a42175faf1a0aca7ecb6f402426915c7f9bba04
+  data.tar.gz: e4e5b788790d397ff220f28a78221c81a533bf0a8f8c58328dbe85d9085d3074fcce5b5f68fcf06b946c1858225b0ce8eabb7c84fe0641599244961dcc079f0b

data/lib/common/error_interceptor.rb

@@ -7,33 +7,26 @@ module StatelyDB
   module Common
     # GRPC interceptor to convert errors to StatelyDB::Error
     class ErrorInterceptor < GRPC::ClientInterceptor
-      # client unary interceptor
-      def request_response(request:, call:, method:, metadata:) # rubocop:disable Lint/UnusedMethodArgument
-        yield
-      rescue Exception => e
-        raise StatelyDB::Error.from(e)
-      end
-
-      # client streaming interceptor
-      def client_streamer(requests:, call:, method:, metadata:) # rubocop:disable Lint/UnusedMethodArgument
-        yield
-      rescue Exception => e
-        raise StatelyDB::Error.from(e)
+      # Client and Server stream handling logic
+      %i[request_response client_streamer server_streamer bidi_streamer].each do |method_name|
+        define_method(method_name) do |*args, &block|
+          safe_yield(*args, &block)
+        end
       end
+    end
+  end
+end
 
-      # server streaming interceptor
-      def server_streamer(request:, call:, method:, metadata:) # rubocop:disable Lint/UnusedMethodArgument
-        yield
-      rescue Exception => e
-        raise StatelyDB::Error.from(e)
-      end
+def safe_yield(*, &block)
+  block.call(*)
+rescue Exception => e
+  raise StatelyDB::Error.from(e)
+end
 
-      # bidirectional streaming interceptor
-      def bidi_streamer(requests:, call:, method:, metadata:) # rubocop:disable Lint/UnusedMethodArgument
-        yield
-      rescue Exception => e
-        raise StatelyDB::Error.from(e)
-      end
-    end
+def safe_yield_stream(stream, &block)
+  stream.each do |msg|
+    safe_yield(msg, &block)
   end
+rescue Exception => e
+  raise StatelyDB::Error.from(e)
 end

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
@@ -331,7 +391,7 @@ module StatelyDB
     def process_list_response(resp)
       items = []
       token = nil
-      resp.each do |r|
+      safe_yield_stream(resp) do |r|
         case r.response
         when :result
           r.result.items.map do |result|
@@ -360,7 +420,7 @@ module StatelyDB
       updated_outside_list_window_paths = []
       token = nil
       is_reset = false
-      resp.each do |r|
+      safe_yield_stream(resp) do |r|
         case r.response
         when :result
           r.result.changed_items.each do |item|

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
@@ -757,49 +804,6 @@ module StatelyDB
 
     # GRPC interceptor to convert errors to StatelyDB::Error
     class ErrorInterceptor < GRPC::ClientInterceptor
-      # client unary interceptor
-      sig do
-        params(
-          request: T.untyped,
-          call: T.untyped,
-          method: T.untyped,
-          metadata: T.untyped
-        ).returns(T.untyped)
-      end
-      def request_response(request:, call:, method:, metadata:); end
-
-      # client streaming interceptor
-      sig do
-        params(
-          requests: T.untyped,
-          call: T.untyped,
-          method: T.untyped,
-          metadata: T.untyped
-        ).returns(T.untyped)
-      end
-      def client_streamer(requests:, call:, method:, metadata:); end
-
-      # server streaming interceptor
-      sig do
-        params(
-          request: T.untyped,
-          call: T.untyped,
-          method: T.untyped,
-          metadata: T.untyped
-        ).returns(T.untyped)
-      end
-      def server_streamer(request:, call:, method:, metadata:); end
-
-      # bidirectional streaming interceptor
-      sig do
-        params(
-          requests: T.untyped,
-          call: T.untyped,
-          method: T.untyped,
-          metadata: T.untyped
-        ).returns(T.untyped)
-      end
-      def bidi_streamer(requests:, call:, method:, metadata:); end
     end
   end
 

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
@@ -651,37 +694,6 @@ module StatelyDB
 
     # GRPC interceptor to convert errors to StatelyDB::Error
     class ErrorInterceptor < GRPC::ClientInterceptor
-      # client unary interceptor
-      def request_response: (
-                              request: untyped,
-                              call: untyped,
-                              method: untyped,
-                              metadata: untyped
-                            ) -> untyped
-
-      # client streaming interceptor
-      def client_streamer: (
-                             requests: untyped,
-                             call: untyped,
-                             method: untyped,
-                             metadata: untyped
-                           ) -> untyped
-
-      # server streaming interceptor
-      def server_streamer: (
-                             request: untyped,
-                             call: untyped,
-                             method: untyped,
-                             metadata: untyped
-                           ) -> untyped
-
-      # bidirectional streaming interceptor
-      def bidi_streamer: (
-                           requests: untyped,
-                           call: untyped,
-                           method: untyped,
-                           metadata: untyped
-                         ) -> untyped
     end
   end
 

metadata

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