statelydb 0.19.0 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48b92c6e1895bb7e7a5a27634f5012e9183b514a1210b25a54528000d8980e5d
-  data.tar.gz: ea786444657ea16320c913c115bac7f2cc17f3a9223d4ff53466504cac3930b3
+  metadata.gz: f2596e8fefad5c493ca74719bd8d88366196aa67060aa8bf7f235426b4042b76
+  data.tar.gz: 9a01f05434b629b8d7056fa9bf24b1e310d9377b8d853779a5a2402939ecb598
 SHA512:
-  metadata.gz: 1fa6566c111cc334eb9015880f2d5feec32e10e571522a9609e1413ee5b7a455a7858ad599c5fcc8bc0e0ecb6a42175faf1a0aca7ecb6f402426915c7f9bba04
-  data.tar.gz: e4e5b788790d397ff220f28a78221c81a533bf0a8f8c58328dbe85d9085d3074fcce5b5f68fcf06b946c1858225b0ce8eabb7c84fe0641599244961dcc079f0b
+  metadata.gz: d071adf0dba8e6981ec77346b80502a69c2424a9a165c55acbbacba62ca424df341efa5e36215294da76595666371c90c0575046d78eb4527039a6b75d4499dd
+  data.tar.gz: 0eda4f14edcf95b3f317e5b82a70b86e5502ac2c970a6940c592f5d3bfd0b1e93ab0d302de94bb47091d71b709f411576928a9e9ac50727e423e91083108688e

data/lib/common/auth/auth_token_provider.rb

@@ -41,6 +41,7 @@ module StatelyDB
 
         # Close the token provider and kill any background operations
         # This just invokes the close method on the actor which should do the cleanup
+        # @return [void]
         def close
           @actor.close
         end
@@ -81,6 +82,7 @@ module StatelyDB
 
           # Initialize the actor. This runs on the actor thread which means
           # we can dispatch async operations here.
+          # @return [void]
           def init
             # disable the async lib logger. We do our own error handling and propagation
             Console.logger.disable(Async::Task)
@@ -88,6 +90,7 @@ module StatelyDB
           end
 
           # Close the token provider and kill any background operations
+          # @return [void]
           def close
             @scheduled&.stop
             @token_fetcher&.close
@@ -117,7 +120,7 @@ module StatelyDB
           end
 
           # Refresh the access token
-          # @return [Task] A task that will resolve to the new access token
+          # @return [::Async::Task] A task that will resolve to the new access token
           def refresh_token
             Async do
               # we use an Async::Condition to dedupe multiple requests here
@@ -187,6 +190,11 @@ module StatelyDB
         end
 
         # Persistent state for the token provider
+        #
+        # @!attribute [r] token
+        #   @return [String] The token string.
+        # @!attribute [r] expires_at_unix_secs
+        #   @return [Integer] The expiration time in unix seconds.
         class TokenState
           attr_reader :token, :expires_at_unix_secs
 

data/lib/common/auth/interceptor.rb

@@ -20,7 +20,7 @@ module StatelyDB
         # gRPC client unary interceptor
         #
         # @param [Object] request The request object
-        # @param [GRPC::ActiveCall] call The active call object
+        # @param [::GRPC::ActiveCall] call The active call object
         # @param [Symbol] method The method being called
         # @param [Hash] metadata The metadata hash
         # @return [Object] The response object
@@ -33,7 +33,7 @@ module StatelyDB
         # gRPC client streaming interceptor
         #
         # @param [Enumerable] requests The list of requests
-        # @param [GRPC::ActiveCall] call The active call object
+        # @param [::GRPC::ActiveCall] call The active call object
         # @param [Symbol] method The method being called
         # @param [Hash] metadata The metadata hash
         # @return [Enumerator] The response enumerator
@@ -46,7 +46,7 @@ module StatelyDB
         # gRPC  server streaming interceptor
         #
         # @param [Object] request The request object
-        # @param [GRPC::ActiveCall] call The active call object
+        # @param [::GRPC::ActiveCall] call The active call object
         # @param [Symbol] method The method being called
         # @param [Hash] metadata The metadata hash
         # @return [Enumerator] The response enumerator
@@ -59,7 +59,7 @@ module StatelyDB
         # gRPC bidirectional streaming interceptor
         #
         # @param [Enumerable] requests The list of requests
-        # @param [GRPC::ActiveCall] call The active call object
+        # @param [::GRPC::ActiveCall] call The active call object
         # @param [Symbol] method The method being called
         # @param [Hash] metadata The metadata hash
         # @return [Enumerator] The response enumerator

data/lib/common/auth/token_fetcher.rb

@@ -10,6 +10,11 @@ module StatelyDB
     # A module for Stately Cloud auth code
     module Auth
       # Result from a token fetch operation
+      #
+      # @!attribute [r] token
+      #   @return [String] The token string.
+      # @!attribute [r] expires_in_secs
+      #   @return [Integer] The expiration time in seconds.
       class TokenResult
         attr_reader :token, :expires_in_secs
 
@@ -32,6 +37,7 @@ module StatelyDB
         end
 
         # Close the token provider and kill any background operations
+        # @return [void]
         def close
           raise "Not Implemented"
         end
@@ -39,6 +45,9 @@ module StatelyDB
 
       # StatelyAccessTokenFetcher is a TokenFetcher that fetches tokens from the StatelyDB API
       class StatelyAccessTokenFetcher < TokenFetcher
+        # Non-retryable errors that will not be retried.
+        #
+        # @return [Array<::GRPC::Core::StatusCodes>]
         NON_RETRYABLE_ERRORS = [
           GRPC::Core::StatusCodes::UNAUTHENTICATED,
           GRPC::Core::StatusCodes::PERMISSION_DENIED,
@@ -46,6 +55,10 @@ module StatelyDB
           GRPC::Core::StatusCodes::UNIMPLEMENTED,
           GRPC::Core::StatusCodes::INVALID_ARGUMENT
         ].freeze
+
+        # Number of retry attempts for requests.
+        #
+        # @return [Integer]
         RETRY_ATTEMPTS = 10
 
         # @param [String] endpoint The endpoint of the OAuth server
@@ -76,6 +89,8 @@ module StatelyDB
           end
         end
 
+        # Close the token provider and kill any background operations
+        # @return [void]
         def close
           @channel&.close
         end

data/lib/common/auth/token_provider.rb

@@ -15,6 +15,7 @@ module StatelyDB
         end
 
         # Close the token provider and kill any background operations
+        # @return [void]
         def close
           raise "Not Implemented"
         end

data/lib/common/net/conn.rb

@@ -9,7 +9,7 @@ module StatelyDB
     module Net
       # Create a new gRPC channel
       # @param [String] endpoint The endpoint to connect to
-      # @return [GRPC::Core::Channel] The new channel
+      # @return [::GRPC::Core::Channel] The new channel
       def self.new_channel(endpoint:)
         endpoint_uri = URI(endpoint)
         creds = GRPC::Core::ChannelCredentials.new

data/lib/key_path.rb

@@ -9,8 +9,8 @@ module StatelyDB
     end
 
     # Appends a new path segment.
-    # @param [String] namespace
-    # @param [String, StatelyDB::UUID, #to_s] identifier
+    # @param namespace [String]
+    # @param identifier [String, StatelyDB::UUID, #to_s]
     # @return [KeyPath]
     def with(namespace, identifier = nil)
       if identifier.nil?
@@ -37,8 +37,8 @@ module StatelyDB
     end
 
     # Appends a new path segment.
-    # @param [String] namespace
-    # @param [String, StatelyDB::UUID, #to_s] identifier
+    # @param namespace [String]
+    # @param identifier [String, StatelyDB::UUID, #to_s]
     # @return [KeyPath]
     #
     # @example
@@ -49,7 +49,7 @@ module StatelyDB
 
     # If the value is a binary string, encode it as a url-safe base64 string with padding removed.
     #
-    # @param [String, StatelyDB::UUID, #to_s] value The value to convert to a key id.
+    # @param value [String, StatelyDB::UUID, #to_s] The value to convert to a key id.
     # @return [String]
     def self.to_key_id(value)
       if value.is_a?(StatelyDB::UUID)

data/lib/stately_codes.rb

@@ -6,6 +6,7 @@ module StatelyCode
   #
   # - Retryable
   #     This error is immediately retryable.
+  # @return [String]
   CACHED_SCHEMA_TOO_OLD = "CachedSchemaTooOld"
 
   # ConcurrentModification indicates the current transaction was aborted
@@ -34,6 +35,7 @@ module StatelyCode
   #
   # - Retryable
   #     This error is immediately retryable.
+  # @return [String]
   CONCURRENT_MODIFICATION = "ConcurrentModification"
 
   # ConditionalCheckFailed indicates that conditions provided to perform an
@@ -45,6 +47,7 @@ module StatelyCode
   # - Not Retryable
   #     Typically a conditional check failure is not retryable
   #     unless the conditions for the operation are changed.
+  # @return [String]
   CONDITIONAL_CHECK_FAILED = "ConditionalCheckFailed"
 
   # ItemReusedWithDifferentKeyPath occurs when a client reads an Item, then
@@ -57,6 +60,7 @@ module StatelyCode
   # new instance of the Item rather than reusing the read result.
   #
   # - Not Retryable
+  # @return [String]
   ITEM_REUSED_WITH_DIFFERENT_KEY_PATH = "ItemReusedWithDifferentKeyPath"
 
   # NonRecoverableTransaction indicates that conditions required for the
@@ -68,6 +72,7 @@ module StatelyCode
   # independent records with aliases pointing to the same item.
   #
   # - Not Retryable
+  # @return [String]
   NON_RECOVERABLE_TRANSACTION = "NonRecoverableTransaction"
 
   # StoreInUse indicates that the underlying Store is currently in being
@@ -76,6 +81,7 @@ module StatelyCode
   #
   # - Retryable
   #     This can be retried with backoff.
+  # @return [String]
   STORE_IN_USE = "StoreInUse"
 
   # StoreRequestLimitExceeded indicates that an attempt to modify a Store has
@@ -85,6 +91,7 @@ module StatelyCode
   # please contact support.
   #
   # - Retryable
+  # @return [String]
   STORE_REQUEST_LIMIT_EXCEEDED = "StoreRequestLimitExceeded"
 
   # StoreThroughputExceeded indicates that the underlying Store does not have
@@ -94,5 +101,6 @@ module StatelyCode
   #
   # - Retryable
   #     With an exponential backoff.
+  # @return [String]
   STORE_THROUGHPUT_EXCEEDED = "StoreThroughputExceeded"
 end

data/lib/statelydb.rb

@@ -369,7 +369,7 @@ module StatelyDB
     # then the default endpoint will be returned.
     #
     # @param endpoint [String] the endpoint to connect to
-    # @param region [Region] the region to connect to
+    # @param region [String] the region to connect to
     # @return [String] the constructed endpoint
     def self.make_endpoint(endpoint: nil, region: nil)
       return endpoint unless endpoint.nil?
@@ -384,7 +384,7 @@ module StatelyDB
 
     # Process a list response from begin_list or continue_list
     #
-    # @param resp [Stately::Db::ListResponse] the response to process
+    # @param resp [::Stately::Db::ListResponse] the response to process
     # @return [(Array<StatelyDB::Item>, StatelyDB::Token)] the list of Items and the token
     # @api private
     # @!visibility private
@@ -410,7 +410,7 @@ module StatelyDB
 
     # Process a sync response from sync_list
     #
-    # @param resp [Stately::Db::SyncResponse] the response to process
+    # @param resp [::Stately::Db::SyncResponse] the response to process
     # @return [StatelyDB::SyncResult] the result of the sync operation
     # @api private
     # @!visibility private

data/lib/transaction/transaction.rb

@@ -42,9 +42,9 @@ module StatelyDB
 
       # Initialize a new Transaction
       #
-      # @param stub [Stately::Db::DatabaseService::Stub] a StatelyDB gRPC stub
+      # @param stub [::Stately::Db::DatabaseService::Stub] a StatelyDB gRPC stub
       # @param store_id [Integer] the StatelyDB Store to transact against
-      # @param schema [StatelyDB::Schema] the schema to use for marshalling and unmarshalling Items
+      # @param schema [::StatelyDB::Schema] the schema to use for marshalling and unmarshalling Items
       def initialize(stub:, store_id:, schema:)
         @stub = stub
         @store_id = store_id
@@ -57,8 +57,8 @@ module StatelyDB
 
       # Send a request and wait for a response
       #
-      # @param req [Stately::Db::TransactionRequest] the request to send
-      # @return [Stately::Db::TransactionResponse] the response
+      # @param req [::Stately::Db::TransactionRequest] the request to send
+      # @return [::Stately::Db::TransactionResponse] the response
       # @api private
       # @!visibility private
       def request_response(req)
@@ -78,7 +78,7 @@ module StatelyDB
 
       # Send a request and don't wait for a response
       #
-      # @param req [Stately::Db::TransactionRequest] the request to send
+      # @param req [::Stately::Db::TransactionRequest] the request to send
       # @return [void] nil
       # @api private
       # @!visibility private
@@ -91,9 +91,9 @@ module StatelyDB
       # Send a request and process all responses, until we receive a finished message. This is used for list operations.
       # Each response is processed by the block passed to this method, and the response for this method is a token.
       #
-      # @param req [Stately::Db::TransactionRequest] the request to send
-      # @yieldparam resp [Stately::Db::TransactionListResponse] the response
-      # @return [Stately::Db::ListToken] the token
+      # @param req [::Stately::Db::TransactionRequest] the request to send
+      # @yieldparam resp [::Stately::Db::TransactionListResponse] the response
+      # @return [::Stately::Db::ListToken] the token
       # @example
       #   request_list_responses(req) do |resp|
       #     resp.result.items.each do |result|
@@ -153,7 +153,7 @@ module StatelyDB
       end
 
       # Abort a transaction. Abort is called implicitly if an exception is raised within the block passed to transaction.
-      # @return [Stately::Db::TransactionResponse]
+      # @return [::Stately::Db::TransactionResponse]
       # @api private
       # @!visibility private
       def abort
@@ -333,7 +333,7 @@ module StatelyDB
       # @param limit [Integer] the maximum number of items to return
       # @param sort_property [String] the property to sort by
       # @param sort_direction [Symbol] the direction to sort by (:ascending or :descending)
-      # @return [(Array<StatelyDB::Item>, Stately::Db::ListToken)] the list of Items and the token
+      # @return [(Array<StatelyDB::Item>, ::Stately::Db::ListToken)] the list of Items and the token
       #
       # Example:
       #   client.data.transaction do |txn|
@@ -363,9 +363,9 @@ module StatelyDB
 
       # Continue listing Items from a StatelyDB Store using a token.
       #
-      # @param token [Stately::Db::ListToken] the token to continue from
+      # @param token [::Stately::Db::ListToken] the token to continue from
       # @param continue_direction [Symbol] the direction to continue by (:forward or :backward)
-      # @return [(Array<StatelyDB::Item>, Stately::Db::ListToken)] the list of Items and the token
+      # @return [(Array<StatelyDB::Item>, ::Stately::Db::ListToken)] the list of Items and the token
       #
       # Example:
       #   client.data.transaction do |txn|
@@ -388,8 +388,8 @@ module StatelyDB
 
       # Processes a list response from begin_list or continue_list
       #
-      # @param req [Stately::Db::TransactionRequest] the request to send
-      # @return [(Array<StatelyDB::Item>, Stately::Db::ListToken)] the list of Items and the token
+      # @param req [::Stately::Db::TransactionRequest] the request to send
+      # @return [(Array<StatelyDB::Item>, ::Stately::Db::ListToken)] the list of Items and the token
       # @api private
       # @!visibility private
       def do_list_request_response(req)
@@ -405,7 +405,7 @@ module StatelyDB
       # We are using a oneof inside the TransactionRequest to determine the type of request. The ruby
       # generated code does not have a helper for the internal request type so we need to infer it.
       #
-      # @param req [Stately::Db::TransactionRequest] the request
+      # @param req [::Stately::Db::TransactionRequest] the request
       # @return [Class] the response type
       # @api private
       # @!visibility private
@@ -422,7 +422,7 @@ module StatelyDB
       # We are using a oneof inside the TransactionResponse to determine the type of response. The ruby
       # generated code does not have a helper for the internal response type so we need to infer it.
       #
-      # @param resp [Stately::Db::TransactionResponse] the response
+      # @param resp [::Stately::Db::TransactionResponse] the response
       # @return [Class] the response type
       # @api private
       # @!visibility private

data/{sig → rbi}/statelydb.rbi

@@ -434,7 +434,7 @@ module StatelyDB
     # _@param_ `region` — the region to connect to
     # 
     # _@return_ — the constructed endpoint
-    sig { params(endpoint: T.nilable(String), region: T.nilable(Region)).returns(String) }
+    sig { params(endpoint: T.nilable(String), region: T.nilable(String)).returns(String) }
     def self.make_endpoint(endpoint: nil, region: nil); end
 
     # Process a list response from begin_list or continue_list
@@ -442,7 +442,7 @@ module StatelyDB
     # _@param_ `resp` — the response to process
     # 
     # _@return_ — the list of Items and the token
-    sig { params(resp: Stately::Db::ListResponse).returns([T::Array[StatelyDB::Item], StatelyDB::Token]) }
+    sig { params(resp: ::Stately::Db::ListResponse).returns([T::Array[StatelyDB::Item], StatelyDB::Token]) }
     def process_list_response(resp); end
 
     # Process a sync response from sync_list
@@ -450,7 +450,7 @@ module StatelyDB
     # _@param_ `resp` — the response to process
     # 
     # _@return_ — the result of the sync operation
-    sig { params(resp: Stately::Db::SyncResponse).returns(StatelyDB::SyncResult) }
+    sig { params(resp: ::Stately::Db::SyncResponse).returns(StatelyDB::SyncResult) }
     def process_sync_response(resp); end
   end
 
@@ -521,7 +521,7 @@ module StatelyDB
       # _@param_ `endpoint` — The endpoint to connect to
       # 
       # _@return_ — The new channel
-      sig { params(endpoint: String).returns(GRPC::Core::Channel) }
+      sig { params(endpoint: String).returns(::GRPC::Core::Channel) }
       def self.new_channel(endpoint:); end
     end
 
@@ -547,7 +547,7 @@ module StatelyDB
         sig do
           params(
             request: Object,
-            call: GRPC::ActiveCall,
+            call: ::GRPC::ActiveCall,
             method: Symbol,
             metadata: T::Hash[T.untyped, T.untyped]
           ).returns(Object)
@@ -568,7 +568,7 @@ module StatelyDB
         sig do
           params(
             requests: T::Enumerable[T.untyped],
-            call: GRPC::ActiveCall,
+            call: ::GRPC::ActiveCall,
             method: Symbol,
             metadata: T::Hash[T.untyped, T.untyped]
           ).returns(T::Enumerator[T.untyped])
@@ -589,7 +589,7 @@ module StatelyDB
         sig do
           params(
             request: Object,
-            call: GRPC::ActiveCall,
+            call: ::GRPC::ActiveCall,
             method: Symbol,
             metadata: T::Hash[T.untyped, T.untyped]
           ).returns(T::Enumerator[T.untyped])
@@ -610,7 +610,7 @@ module StatelyDB
         sig do
           params(
             requests: T::Enumerable[T.untyped],
-            call: GRPC::ActiveCall,
+            call: ::GRPC::ActiveCall,
             method: Symbol,
             metadata: T::Hash[T.untyped, T.untyped]
           ).returns(T::Enumerator[T.untyped])
@@ -625,6 +625,11 @@ module StatelyDB
       end
 
       # Result from a token fetch operation
+      # 
+      # @!attribute [r] token
+      #   @return [String] The token string.
+      # @!attribute [r] expires_in_secs
+      #   @return [Integer] The expiration time in seconds.
       class TokenResult
         # Create a new TokenResult
         # 
@@ -634,12 +639,12 @@ module StatelyDB
         sig { params(token: String, expires_in_secs: Integer).void }
         def initialize(token:, expires_in_secs:); end
 
-        # Returns the value of attribute token.
-        sig { returns(T.untyped) }
+        # _@return_ — The token string.
+        sig { returns(String) }
         attr_reader :token
 
-        # Returns the value of attribute expires_in_secs.
-        sig { returns(T.untyped) }
+        # _@return_ — The expiration time in seconds.
+        sig { returns(Integer) }
         attr_reader :expires_in_secs
       end
 
@@ -653,7 +658,7 @@ module StatelyDB
         def fetch; end
 
         # Close the token provider and kill any background operations
-        sig { returns(T.untyped) }
+        sig { void }
         def close; end
       end
 
@@ -682,7 +687,8 @@ module StatelyDB
         sig { returns(TokenResult) }
         def fetch; end
 
-        sig { returns(T.untyped) }
+        # Close the token provider and kill any background operations
+        sig { void }
         def close; end
 
         # Check if an error is retryable
@@ -706,7 +712,7 @@ module StatelyDB
         def get_token(force: false); end
 
         # Close the token provider and kill any background operations
-        sig { returns(T.untyped) }
+        sig { void }
         def close; end
       end
 
@@ -725,7 +731,7 @@ module StatelyDB
 
         # Close the token provider and kill any background operations
         # This just invokes the close method on the actor which should do the cleanup
-        sig { returns(T.untyped) }
+        sig { void }
         def close; end
 
         # Get the current access token
@@ -747,11 +753,11 @@ module StatelyDB
 
           # Initialize the actor. This runs on the actor thread which means
           # we can dispatch async operations here.
-          sig { returns(T.untyped) }
+          sig { void }
           def init; end
 
           # Close the token provider and kill any background operations
-          sig { returns(T.untyped) }
+          sig { void }
           def close; end
 
           # Get the current access token
@@ -771,7 +777,7 @@ module StatelyDB
           # Refresh the access token
           # 
           # _@return_ — A task that will resolve to the new access token
-          sig { returns(Task) }
+          sig { returns(::Async::Task) }
           def refresh_token; end
 
           # Refresh the access token implementation
@@ -782,6 +788,11 @@ module StatelyDB
         end
 
         # Persistent state for the token provider
+        # 
+        # @!attribute [r] token
+        #   @return [String] The token string.
+        # @!attribute [r] expires_at_unix_secs
+        #   @return [Integer] The expiration time in unix seconds.
         class TokenState
           # Create a new TokenState
           # 
@@ -791,12 +802,12 @@ module StatelyDB
           sig { params(token: String, expires_at_unix_secs: Integer).void }
           def initialize(token:, expires_at_unix_secs:); end
 
-          # Returns the value of attribute token.
-          sig { returns(T.untyped) }
+          # _@return_ — The token string.
+          sig { returns(String) }
           attr_reader :token
 
-          # Returns the value of attribute expires_at_unix_secs.
-          sig { returns(T.untyped) }
+          # _@return_ — The expiration time in unix seconds.
+          sig { returns(Integer) }
           attr_reader :expires_at_unix_secs
         end
       end
@@ -852,7 +863,7 @@ module StatelyDB
       # _@param_ `store_id` — the StatelyDB Store to transact against
       # 
       # _@param_ `schema` — the schema to use for marshalling and unmarshalling Items
-      sig { params(stub: Stately::Db::DatabaseService::Stub, store_id: Integer, schema: StatelyDB::Schema).void }
+      sig { params(stub: ::Stately::Db::DatabaseService::Stub, store_id: Integer, schema: ::StatelyDB::Schema).void }
       def initialize(stub:, store_id:, schema:); end
 
       # Send a request and wait for a response
@@ -860,7 +871,7 @@ module StatelyDB
       # _@param_ `req` — the request to send
       # 
       # _@return_ — the response
-      sig { params(req: Stately::Db::TransactionRequest).returns(Stately::Db::TransactionResponse) }
+      sig { params(req: ::Stately::Db::TransactionRequest).returns(::Stately::Db::TransactionResponse) }
       def request_response(req); end
 
       # Send a request and don't wait for a response
@@ -868,7 +879,7 @@ module StatelyDB
       # _@param_ `req` — the request to send
       # 
       # _@return_ — nil
-      sig { params(req: Stately::Db::TransactionRequest).void }
+      sig { params(req: ::Stately::Db::TransactionRequest).void }
       def request_only(req); end
 
       # Send a request and process all responses, until we receive a finished message. This is used for list operations.
@@ -884,7 +895,7 @@ module StatelyDB
       #     puts result.item.key_path
       #   end
       # ```
-      sig { params(req: Stately::Db::TransactionRequest, blk: T.proc.params(resp: Stately::Db::TransactionListResponse).void).returns(Stately::Db::ListToken) }
+      sig { params(req: ::Stately::Db::TransactionRequest, blk: T.proc.params(resp: ::Stately::Db::TransactionListResponse).void).returns(::Stately::Db::ListToken) }
       def request_list_responses(req, &blk); end
 
       # Begin a transaction. Begin is called implicitly when the block passed to transaction is called.
@@ -898,7 +909,7 @@ module StatelyDB
       def commit; end
 
       # Abort a transaction. Abort is called implicitly if an exception is raised within the block passed to transaction.
-      sig { returns(Stately::Db::TransactionResponse) }
+      sig { returns(::Stately::Db::TransactionResponse) }
       def abort; end
 
       # Check if a transaction is open. A transaction is open if begin has been called and commit or abort has not been called.
@@ -1021,7 +1032,7 @@ module StatelyDB
           limit: Integer,
           sort_property: T.nilable(String),
           sort_direction: Symbol
-        ).returns([T::Array[StatelyDB::Item], Stately::Db::ListToken])
+        ).returns([T::Array[StatelyDB::Item], ::Stately::Db::ListToken])
       end
       def begin_list(prefix, limit: 100, sort_property: nil, sort_direction: :ascending); end
 
@@ -1038,7 +1049,7 @@ module StatelyDB
       # _@param_ `continue_direction` — the direction to continue by (:forward or :backward)
       # 
       # _@return_ — the list of Items and the token
-      sig { params(token: Stately::Db::ListToken, continue_direction: Symbol).returns([T::Array[StatelyDB::Item], Stately::Db::ListToken]) }
+      sig { params(token: ::Stately::Db::ListToken, continue_direction: Symbol).returns([T::Array[StatelyDB::Item], ::Stately::Db::ListToken]) }
       def continue_list(token, continue_direction: :forward); end
 
       # Processes a list response from begin_list or continue_list
@@ -1046,7 +1057,7 @@ module StatelyDB
       # _@param_ `req` — the request to send
       # 
       # _@return_ — the list of Items and the token
-      sig { params(req: Stately::Db::TransactionRequest).returns([T::Array[StatelyDB::Item], Stately::Db::ListToken]) }
+      sig { params(req: ::Stately::Db::TransactionRequest).returns([T::Array[StatelyDB::Item], ::Stately::Db::ListToken]) }
       def do_list_request_response(req); end
 
       # We are using a oneof inside the TransactionRequest to determine the type of request. The ruby
@@ -1055,7 +1066,7 @@ module StatelyDB
       # _@param_ `req` — the request
       # 
       # _@return_ — the response type
-      sig { params(req: Stately::Db::TransactionRequest).returns(Class) }
+      sig { params(req: ::Stately::Db::TransactionRequest).returns(Class) }
       def infer_response_type_from_request(req); end
 
       # We are using a oneof inside the TransactionResponse to determine the type of response. The ruby
@@ -1064,7 +1075,7 @@ module StatelyDB
       # _@param_ `resp` — the response
       # 
       # _@return_ — the response type
-      sig { params(resp: Stately::Db::TransactionResponse).returns(Class) }
+      sig { params(resp: ::Stately::Db::TransactionResponse).returns(Class) }
       def infer_response_type_from_response(resp); end
 
       # Result represents the results of a transaction

data/sig/statelydb.rbs

@@ -380,21 +380,21 @@ module StatelyDB
     # _@param_ `region` — the region to connect to
     # 
     # _@return_ — the constructed endpoint
-    def self.make_endpoint: (?endpoint: String?, ?region: Region?) -> String
+    def self.make_endpoint: (?endpoint: String?, ?region: String?) -> String
 
     # Process a list response from begin_list or continue_list
     # 
     # _@param_ `resp` — the response to process
     # 
     # _@return_ — the list of Items and the token
-    def process_list_response: (Stately::Db::ListResponse resp) -> [::Array[StatelyDB::Item], StatelyDB::Token]
+    def process_list_response: (::Stately::Db::ListResponse resp) -> [::Array[StatelyDB::Item], StatelyDB::Token]
 
     # Process a sync response from sync_list
     # 
     # _@param_ `resp` — the response to process
     # 
     # _@return_ — the result of the sync operation
-    def process_sync_response: (Stately::Db::SyncResponse resp) -> StatelyDB::SyncResult
+    def process_sync_response: (::Stately::Db::SyncResponse resp) -> StatelyDB::SyncResult
   end
 
   # SyncResult represents the results of a sync operation.
@@ -456,7 +456,7 @@ module StatelyDB
       # _@param_ `endpoint` — The endpoint to connect to
       # 
       # _@return_ — The new channel
-      def self.new_channel: (endpoint: String) -> GRPC::Core::Channel
+      def self.new_channel: (endpoint: String) -> ::GRPC::Core::Channel
     end
 
     # A module for Stately Cloud auth code
@@ -479,7 +479,7 @@ module StatelyDB
         # _@return_ — The response object
         def request_response: (
                                 request: Object,
-                                call: GRPC::ActiveCall,
+                                call: ::GRPC::ActiveCall,
                                 method: Symbol,
                                 metadata: ::Hash[untyped, untyped]
                               ) -> Object
@@ -497,7 +497,7 @@ module StatelyDB
         # _@return_ — The response enumerator
         def client_streamer: (
                                requests: ::Enumerable[untyped],
-                               call: GRPC::ActiveCall,
+                               call: ::GRPC::ActiveCall,
                                method: Symbol,
                                metadata: ::Hash[untyped, untyped]
                              ) -> ::Enumerator[untyped]
@@ -515,7 +515,7 @@ module StatelyDB
         # _@return_ — The response enumerator
         def server_streamer: (
                                request: Object,
-                               call: GRPC::ActiveCall,
+                               call: ::GRPC::ActiveCall,
                                method: Symbol,
                                metadata: ::Hash[untyped, untyped]
                              ) -> ::Enumerator[untyped]
@@ -533,7 +533,7 @@ module StatelyDB
         # _@return_ — The response enumerator
         def bidi_streamer: (
                              requests: ::Enumerable[untyped],
-                             call: GRPC::ActiveCall,
+                             call: ::GRPC::ActiveCall,
                              method: Symbol,
                              metadata: ::Hash[untyped, untyped]
                            ) -> ::Enumerator[untyped]
@@ -545,6 +545,11 @@ module StatelyDB
       end
 
       # Result from a token fetch operation
+      # 
+      # @!attribute [r] token
+      #   @return [String] The token string.
+      # @!attribute [r] expires_in_secs
+      #   @return [Integer] The expiration time in seconds.
       class TokenResult
         # Create a new TokenResult
         # 
@@ -553,11 +558,11 @@ module StatelyDB
         # _@param_ `expires_in_secs` — The number of seconds until the token expires
         def initialize: (token: String, expires_in_secs: Integer) -> void
 
-        # Returns the value of attribute token.
-        attr_reader token: untyped
+        # _@return_ — The token string.
+        attr_reader token: String
 
-        # Returns the value of attribute expires_in_secs.
-        attr_reader expires_in_secs: untyped
+        # _@return_ — The expiration time in seconds.
+        attr_reader expires_in_secs: Integer
       end
 
       # TokenFetcher is an abstract base class that should be extended
@@ -569,13 +574,13 @@ module StatelyDB
         def fetch: () -> TokenResult
 
         # Close the token provider and kill any background operations
-        def close: () -> untyped
+        def close: () -> void
       end
 
       # StatelyAccessTokenFetcher is a TokenFetcher that fetches tokens from the StatelyDB API
       class StatelyAccessTokenFetcher < StatelyDB::Common::Auth::TokenFetcher
-        NON_RETRYABLE_ERRORS: untyped
-        RETRY_ATTEMPTS: untyped
+        NON_RETRYABLE_ERRORS: ::Array[::GRPC::Core::StatusCodes]
+        RETRY_ATTEMPTS: Integer
 
         # _@param_ `endpoint` — The endpoint of the OAuth server
         # 
@@ -589,7 +594,8 @@ module StatelyDB
         # _@return_ — The fetched TokenResult
         def fetch: () -> TokenResult
 
-        def close: () -> untyped
+        # Close the token provider and kill any background operations
+        def close: () -> void
 
         # Check if an error is retryable
         # 
@@ -610,7 +616,7 @@ module StatelyDB
         def get_token: (?force: bool) -> String
 
         # Close the token provider and kill any background operations
-        def close: () -> untyped
+        def close: () -> void
       end
 
       # AuthTokenProvider is an implementation of the TokenProvider abstract base class
@@ -627,7 +633,7 @@ module StatelyDB
 
         # Close the token provider and kill any background operations
         # This just invokes the close method on the actor which should do the cleanup
-        def close: () -> untyped
+        def close: () -> void
 
         # Get the current access token
         # 
@@ -646,10 +652,10 @@ module StatelyDB
 
           # Initialize the actor. This runs on the actor thread which means
           # we can dispatch async operations here.
-          def init: () -> untyped
+          def init: () -> void
 
           # Close the token provider and kill any background operations
-          def close: () -> untyped
+          def close: () -> void
 
           # Get the current access token
           # 
@@ -666,7 +672,7 @@ module StatelyDB
           # Refresh the access token
           # 
           # _@return_ — A task that will resolve to the new access token
-          def refresh_token: () -> Task
+          def refresh_token: () -> ::Async::Task
 
           # Refresh the access token implementation
           # 
@@ -675,6 +681,11 @@ module StatelyDB
         end
 
         # Persistent state for the token provider
+        # 
+        # @!attribute [r] token
+        #   @return [String] The token string.
+        # @!attribute [r] expires_at_unix_secs
+        #   @return [Integer] The expiration time in unix seconds.
         class TokenState
           # Create a new TokenState
           # 
@@ -683,11 +694,11 @@ module StatelyDB
           # _@param_ `expires_at_unix_secs` — The unix timestamp when the token expires
           def initialize: (token: String, expires_at_unix_secs: Integer) -> void
 
-          # Returns the value of attribute token.
-          attr_reader token: untyped
+          # _@return_ — The token string.
+          attr_reader token: String
 
-          # Returns the value of attribute expires_at_unix_secs.
-          attr_reader expires_at_unix_secs: untyped
+          # _@return_ — The expiration time in unix seconds.
+          attr_reader expires_at_unix_secs: Integer
         end
       end
     end
@@ -737,21 +748,21 @@ module StatelyDB
       # _@param_ `store_id` — the StatelyDB Store to transact against
       # 
       # _@param_ `schema` — the schema to use for marshalling and unmarshalling Items
-      def initialize: (stub: Stately::Db::DatabaseService::Stub, store_id: Integer, schema: StatelyDB::Schema) -> void
+      def initialize: (stub: ::Stately::Db::DatabaseService::Stub, store_id: Integer, schema: ::StatelyDB::Schema) -> void
 
       # Send a request and wait for a response
       # 
       # _@param_ `req` — the request to send
       # 
       # _@return_ — the response
-      def request_response: (Stately::Db::TransactionRequest req) -> Stately::Db::TransactionResponse
+      def request_response: (::Stately::Db::TransactionRequest req) -> ::Stately::Db::TransactionResponse
 
       # Send a request and don't wait for a response
       # 
       # _@param_ `req` — the request to send
       # 
       # _@return_ — nil
-      def request_only: (Stately::Db::TransactionRequest req) -> void
+      def request_only: (::Stately::Db::TransactionRequest req) -> void
 
       # Send a request and process all responses, until we receive a finished message. This is used for list operations.
       # Each response is processed by the block passed to this method, and the response for this method is a token.
@@ -766,7 +777,7 @@ module StatelyDB
       #     puts result.item.key_path
       #   end
       # ```
-      def request_list_responses: (Stately::Db::TransactionRequest req) ?{ (Stately::Db::TransactionListResponse resp) -> void } -> Stately::Db::ListToken
+      def request_list_responses: (::Stately::Db::TransactionRequest req) ?{ (::Stately::Db::TransactionListResponse resp) -> void } -> ::Stately::Db::ListToken
 
       # Begin a transaction. Begin is called implicitly when the block passed to transaction is called.
       # 
@@ -777,7 +788,7 @@ module StatelyDB
       def commit: () -> StatelyDB::Transaction::Transaction::Result
 
       # Abort a transaction. Abort is called implicitly if an exception is raised within the block passed to transaction.
-      def abort: () -> Stately::Db::TransactionResponse
+      def abort: () -> ::Stately::Db::TransactionResponse
 
       # Check if a transaction is open. A transaction is open if begin has been called and commit or abort has not been called.
       # 
@@ -892,7 +903,7 @@ module StatelyDB
                         ?limit: Integer,
                         ?sort_property: String?,
                         ?sort_direction: Symbol
-                      ) -> [::Array[StatelyDB::Item], Stately::Db::ListToken]
+                      ) -> [::Array[StatelyDB::Item], ::Stately::Db::ListToken]
 
       # Continue listing Items from a StatelyDB Store using a token.
       # 
@@ -907,14 +918,14 @@ module StatelyDB
       # _@param_ `continue_direction` — the direction to continue by (:forward or :backward)
       # 
       # _@return_ — the list of Items and the token
-      def continue_list: (Stately::Db::ListToken token, ?continue_direction: Symbol) -> [::Array[StatelyDB::Item], Stately::Db::ListToken]
+      def continue_list: (::Stately::Db::ListToken token, ?continue_direction: Symbol) -> [::Array[StatelyDB::Item], ::Stately::Db::ListToken]
 
       # Processes a list response from begin_list or continue_list
       # 
       # _@param_ `req` — the request to send
       # 
       # _@return_ — the list of Items and the token
-      def do_list_request_response: (Stately::Db::TransactionRequest req) -> [::Array[StatelyDB::Item], Stately::Db::ListToken]
+      def do_list_request_response: (::Stately::Db::TransactionRequest req) -> [::Array[StatelyDB::Item], ::Stately::Db::ListToken]
 
       # We are using a oneof inside the TransactionRequest to determine the type of request. The ruby
       # generated code does not have a helper for the internal request type so we need to infer it.
@@ -922,7 +933,7 @@ module StatelyDB
       # _@param_ `req` — the request
       # 
       # _@return_ — the response type
-      def infer_response_type_from_request: (Stately::Db::TransactionRequest req) -> Class
+      def infer_response_type_from_request: (::Stately::Db::TransactionRequest req) -> Class
 
       # We are using a oneof inside the TransactionResponse to determine the type of response. The ruby
       # generated code does not have a helper for the internal response type so we need to infer it.
@@ -930,7 +941,7 @@ module StatelyDB
       # _@param_ `resp` — the response
       # 
       # _@return_ — the response type
-      def infer_response_type_from_response: (Stately::Db::TransactionResponse resp) -> Class
+      def infer_response_type_from_response: (::Stately::Db::TransactionResponse resp) -> Class
 
       # Result represents the results of a transaction
       # 
@@ -1036,12 +1047,12 @@ module Stately
 end
 
 module StatelyCode
-  CACHED_SCHEMA_TOO_OLD: untyped
-  CONCURRENT_MODIFICATION: untyped
-  CONDITIONAL_CHECK_FAILED: untyped
-  ITEM_REUSED_WITH_DIFFERENT_KEY_PATH: untyped
-  NON_RECOVERABLE_TRANSACTION: untyped
-  STORE_IN_USE: untyped
-  STORE_REQUEST_LIMIT_EXCEEDED: untyped
-  STORE_THROUGHPUT_EXCEEDED: untyped
+  CACHED_SCHEMA_TOO_OLD: String
+  CONCURRENT_MODIFICATION: String
+  CONDITIONAL_CHECK_FAILED: String
+  ITEM_REUSED_WITH_DIFFERENT_KEY_PATH: String
+  NON_RECOVERABLE_TRANSACTION: String
+  STORE_IN_USE: String
+  STORE_REQUEST_LIMIT_EXCEEDED: String
+  STORE_THROUGHPUT_EXCEEDED: String
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statelydb
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.20.0
 platform: ruby
 authors:
 - Stately Cloud, Inc.
@@ -107,8 +107,7 @@ files:
 - lib/transaction/queue.rb
 - lib/transaction/transaction.rb
 - lib/uuid.rb
-- sig/grpc.rbs
-- sig/statelydb.rbi
+- rbi/statelydb.rbi
 - sig/statelydb.rbs
 homepage: https://docs.stately.cloud/clients/ruby/
 licenses:

data/sig/grpc.rbs

@@ -1,80 +0,0 @@
-module GRPC
-  class ActiveCall
-  end
-
-  class Interceptor
-  end
-  class ClientInterceptor < Interceptor
-    # gRPC client unary interceptor
-    #
-    # _@param_ `request` — The request object
-    #
-    # _@param_ `call` — The active call object
-    #
-    # _@param_ `method` — The method being called
-    #
-    # _@param_ `metadata` — The metadata hash
-    #
-    # _@return_ — The response object
-    def request_response: (
-                            request: Object,
-                            call: GRPC::ActiveCall,
-                            method: Symbol,
-                            metadata: ::Hash[untyped, untyped]
-                          ) -> Object
-
-    # gRPC client streaming interceptor
-    #
-    # _@param_ `requests` — The list of requests
-    #
-    # _@param_ `call` — The active call object
-    #
-    # _@param_ `method` — The method being called
-    #
-    # _@param_ `metadata` — The metadata hash
-    #
-    # _@return_ — The response enumerator
-    def client_streamer: (
-                            requests: ::Enumerable[untyped],
-                            call: GRPC::ActiveCall,
-                            method: Symbol,
-                            metadata: ::Hash[untyped, untyped]
-                          ) -> ::Enumerator[untyped]
-
-    # gRPC  server streaming interceptor
-    #
-    # _@param_ `request` — The request object
-    #
-    # _@param_ `call` — The active call object
-    #
-    # _@param_ `method` — The method being called
-    #
-    # _@param_ `metadata` — The metadata hash
-    #
-    # _@return_ — The response enumerator
-    def server_streamer: (
-                            request: Object,
-                            call: GRPC::ActiveCall,
-                            method: Symbol,
-                            metadata: ::Hash[untyped, untyped]
-                          ) -> ::Enumerator[untyped]
-
-    # gRPC bidirectional streaming interceptor
-    #
-    # _@param_ `requests` — The list of requests
-    #
-    # _@param_ `call` — The active call object
-    #
-    # _@param_ `method` — The method being called
-    #
-    # _@param_ `metadata` — The metadata hash
-    #
-    # _@return_ — The response enumerator
-    def bidi_streamer: (
-                          requests: ::Enumerable[untyped],
-                          call: GRPC::ActiveCall,
-                          method: Symbol,
-                          metadata: ::Hash[untyped, untyped]
-                        ) -> ::Enumerator[untyped]
-  end
-end