statelydb 0.25.0 → 0.28.0

data/rbi/db/list_pb.rbi

@@ -15,7 +15,9 @@ class Stately::Db::BeginListRequest
       sort_property: T.nilable(T.any(Symbol, String, Integer)),
       sort_direction: T.nilable(T.any(Symbol, String, Integer)),
       schema_version_id: T.nilable(Integer),
-      schema_id: T.nilable(Integer)
+      schema_id: T.nilable(Integer),
+      filter_conditions: T.nilable(T::Array[T.nilable(Stately::Db::FilterCondition)]),
+      key_conditions: T.nilable(T::Array[T.nilable(Stately::Db::KeyCondition)])
     ).void
   end
   def initialize(
@@ -26,7 +28,9 @@ class Stately::Db::BeginListRequest
     sort_property: :SORTABLE_PROPERTY_KEY_PATH,
     sort_direction: :SORT_ASCENDING,
     schema_version_id: 0,
-    schema_id: 0
+    schema_id: 0,
+    filter_conditions: [],
+    key_conditions: []
   )
   end
 
@@ -150,32 +154,26 @@ class Stately::Db::BeginListRequest
   def clear_sort_direction
   end
 
-  # schema_version_id refers to the item version to return.
-#
-# If the store's schema does not have this version, the operation
-# will error with SchemaVersionNotFound error. You should not have to
-# set this manually as your generated SDK should know its schema version
-# and wire this in for you.
+  # schema_version_id is the version of the store's schema to use to interpret
+# items. If there is no version with this ID, the operation will error with
+# SchemaVersionNotFound error. You should not have to set this manually as
+# your generated SDK should know its schema version and wire this in for you.
   sig { returns(Integer) }
   def schema_version_id
   end
 
-  # schema_version_id refers to the item version to return.
-#
-# If the store's schema does not have this version, the operation
-# will error with SchemaVersionNotFound error. You should not have to
-# set this manually as your generated SDK should know its schema version
-# and wire this in for you.
+  # schema_version_id is the version of the store's schema to use to interpret
+# items. If there is no version with this ID, the operation will error with
+# SchemaVersionNotFound error. You should not have to set this manually as
+# your generated SDK should know its schema version and wire this in for you.
   sig { params(value: Integer).void }
   def schema_version_id=(value)
   end
 
-  # schema_version_id refers to the item version to return.
-#
-# If the store's schema does not have this version, the operation
-# will error with SchemaVersionNotFound error. You should not have to
-# set this manually as your generated SDK should know its schema version
-# and wire this in for you.
+  # schema_version_id is the version of the store's schema to use to interpret
+# items. If there is no version with this ID, the operation will error with
+# SchemaVersionNotFound error. You should not have to set this manually as
+# your generated SDK should know its schema version and wire this in for you.
   sig { void }
   def clear_schema_version_id
   end
@@ -204,6 +202,123 @@ class Stately::Db::BeginListRequest
   def clear_schema_id
   end
 
+  # filter_conditions are a set of conditions to filter the list result by.
+# If no conditions are provided, all items in the store will be returned.
+# Filter conditions are combined with OR.
+  sig { returns(T::Array[T.nilable(Stately::Db::FilterCondition)]) }
+  def filter_conditions
+  end
+
+  # filter_conditions are a set of conditions to filter the list result by.
+# If no conditions are provided, all items in the store will be returned.
+# Filter conditions are combined with OR.
+  sig { params(value: ::Google::Protobuf::RepeatedField).void }
+  def filter_conditions=(value)
+  end
+
+  # filter_conditions are a set of conditions to filter the list result by.
+# If no conditions are provided, all items in the store will be returned.
+# Filter conditions are combined with OR.
+  sig { void }
+  def clear_filter_conditions
+  end
+
+  # key_conditions are a set of conditions to apply to the list operation.
+# Wherever possible, Stately will apply these key conditions at the DB layer
+# to optimize the list operation cost.
+#
+# A maximum of two key conditions are allowed: one with a GREATER_THAN (or equal to)
+# operator and one with a LESS_THAN (or equal to) operator. Together these amount to
+# a "between" condition on the key path.
+#
+# If these conditions are provided they must share the same prefix as the
+# key_path_prefix. For example, the following is valid:
+#
+#   key_path_prefix: "/group-:groupID/namespace"
+#   key_conditions:
+#     - key_path: "/group-:groupID/namespace-44"
+#       operator: GREATER_THAN_OR_EQUAL
+#     - key_path: "/group-:groupID/namespace-100"
+#       operator: LESS_THAN_OR_EQUAL
+#
+# A key_path_prefix of "/group-:groupID" would also be valid above, as the prefix is shared
+# with the key conditions.
+#
+# The following is NOT valid because the key_path_prefix does not
+# share the same prefix as the key conditions:
+#
+#   key_path_prefix: "/group-:groupID/namespace"
+#   key_conditions:
+#     - key_path: "/group-:groupID/beatles-1984"
+#       operator: GREATER_THAN_OR_EQUAL
+  sig { returns(T::Array[T.nilable(Stately::Db::KeyCondition)]) }
+  def key_conditions
+  end
+
+  # key_conditions are a set of conditions to apply to the list operation.
+# Wherever possible, Stately will apply these key conditions at the DB layer
+# to optimize the list operation cost.
+#
+# A maximum of two key conditions are allowed: one with a GREATER_THAN (or equal to)
+# operator and one with a LESS_THAN (or equal to) operator. Together these amount to
+# a "between" condition on the key path.
+#
+# If these conditions are provided they must share the same prefix as the
+# key_path_prefix. For example, the following is valid:
+#
+#   key_path_prefix: "/group-:groupID/namespace"
+#   key_conditions:
+#     - key_path: "/group-:groupID/namespace-44"
+#       operator: GREATER_THAN_OR_EQUAL
+#     - key_path: "/group-:groupID/namespace-100"
+#       operator: LESS_THAN_OR_EQUAL
+#
+# A key_path_prefix of "/group-:groupID" would also be valid above, as the prefix is shared
+# with the key conditions.
+#
+# The following is NOT valid because the key_path_prefix does not
+# share the same prefix as the key conditions:
+#
+#   key_path_prefix: "/group-:groupID/namespace"
+#   key_conditions:
+#     - key_path: "/group-:groupID/beatles-1984"
+#       operator: GREATER_THAN_OR_EQUAL
+  sig { params(value: ::Google::Protobuf::RepeatedField).void }
+  def key_conditions=(value)
+  end
+
+  # key_conditions are a set of conditions to apply to the list operation.
+# Wherever possible, Stately will apply these key conditions at the DB layer
+# to optimize the list operation cost.
+#
+# A maximum of two key conditions are allowed: one with a GREATER_THAN (or equal to)
+# operator and one with a LESS_THAN (or equal to) operator. Together these amount to
+# a "between" condition on the key path.
+#
+# If these conditions are provided they must share the same prefix as the
+# key_path_prefix. For example, the following is valid:
+#
+#   key_path_prefix: "/group-:groupID/namespace"
+#   key_conditions:
+#     - key_path: "/group-:groupID/namespace-44"
+#       operator: GREATER_THAN_OR_EQUAL
+#     - key_path: "/group-:groupID/namespace-100"
+#       operator: LESS_THAN_OR_EQUAL
+#
+# A key_path_prefix of "/group-:groupID" would also be valid above, as the prefix is shared
+# with the key conditions.
+#
+# The following is NOT valid because the key_path_prefix does not
+# share the same prefix as the key conditions:
+#
+#   key_path_prefix: "/group-:groupID/namespace"
+#   key_conditions:
+#     - key_path: "/group-:groupID/beatles-1984"
+#       operator: GREATER_THAN_OR_EQUAL
+  sig { void }
+  def clear_key_conditions
+  end
+
   sig { params(field: String).returns(T.untyped) }
   def [](field)
   end
@@ -454,6 +569,126 @@ class Stately::Db::ListFinished
   end
 end
 
+# A KeyCondition is an additional constraint to be applied to the list
+# operation. It is used to filter the results based on a specific key path
+# and an operator.
+# Wherever possible, stately will apply these key conditions at the DB layer
+# to optimize the list operation latency and cost.
+# Key conditions may be combined with a key_path_prefix to further
+# optimize the list operation. HOWEVER Key conditions must share the
+# same prefix as the key_path_prefix.
+class Stately::Db::KeyCondition
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      key_path: T.nilable(String),
+      operator: T.nilable(T.any(Symbol, String, Integer))
+    ).void
+  end
+  def initialize(
+    key_path: "",
+    operator: :OPERATOR_UNSPECIFIED
+  )
+  end
+
+  # key_path is a valid key prefix (or full key) used to filter or optimize the list
+# operation based on the operator specified below.
+  sig { returns(String) }
+  def key_path
+  end
+
+  # key_path is a valid key prefix (or full key) used to filter or optimize the list
+# operation based on the operator specified below.
+  sig { params(value: String).void }
+  def key_path=(value)
+  end
+
+  # key_path is a valid key prefix (or full key) used to filter or optimize the list
+# operation based on the operator specified below.
+  sig { void }
+  def clear_key_path
+  end
+
+  # Operator indicates how to apply key_path condition to the list operation.
+# Valid options are:
+# - GREATER_THAN: key_path must be greater than the specified value
+# - GREATER_THAN_OR_EQUAL: key_path must be greater than or equal to the specified value
+# - LESS_THAN: key_path must be less than the specified value
+# - LESS_THAN_OR_EQUAL: key_path must be less than or equal to the specified value
+#
+# Note: Operators are strictly evaluated they do not change meaning based on sort direction.
+# For example, regardless of sort direction, a GREATER_THAN operator
+# will still mean that a key_path must be greater than the specified value in order
+# to be included in the result set.
+  sig { returns(T.any(Symbol, Integer)) }
+  def operator
+  end
+
+  # Operator indicates how to apply key_path condition to the list operation.
+# Valid options are:
+# - GREATER_THAN: key_path must be greater than the specified value
+# - GREATER_THAN_OR_EQUAL: key_path must be greater than or equal to the specified value
+# - LESS_THAN: key_path must be less than the specified value
+# - LESS_THAN_OR_EQUAL: key_path must be less than or equal to the specified value
+#
+# Note: Operators are strictly evaluated they do not change meaning based on sort direction.
+# For example, regardless of sort direction, a GREATER_THAN operator
+# will still mean that a key_path must be greater than the specified value in order
+# to be included in the result set.
+  sig { params(value: T.any(Symbol, String, Integer)).void }
+  def operator=(value)
+  end
+
+  # Operator indicates how to apply key_path condition to the list operation.
+# Valid options are:
+# - GREATER_THAN: key_path must be greater than the specified value
+# - GREATER_THAN_OR_EQUAL: key_path must be greater than or equal to the specified value
+# - LESS_THAN: key_path must be less than the specified value
+# - LESS_THAN_OR_EQUAL: key_path must be less than or equal to the specified value
+#
+# Note: Operators are strictly evaluated they do not change meaning based on sort direction.
+# For example, regardless of sort direction, a GREATER_THAN operator
+# will still mean that a key_path must be greater than the specified value in order
+# to be included in the result set.
+  sig { void }
+  def clear_operator
+  end
+
+  sig { params(field: String).returns(T.untyped) }
+  def [](field)
+  end
+
+  sig { params(field: String, value: T.untyped).void }
+  def []=(field, value)
+  end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def to_h
+  end
+
+  sig { params(str: String).returns(Stately::Db::KeyCondition) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Stately::Db::KeyCondition).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Stately::Db::KeyCondition) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Stately::Db::KeyCondition, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
 module Stately::Db::SortDirection
   self::SORT_ASCENDING = T.let(0, Integer)
   self::SORT_DESCENDING = T.let(1, Integer)
@@ -470,3 +705,23 @@ module Stately::Db::SortDirection
   def self.descriptor
   end
 end
+
+module Stately::Db::Operator
+  self::OPERATOR_UNSPECIFIED = T.let(0, Integer)
+  self::OPERATOR_GREATER_THAN = T.let(4, Integer)
+  self::OPERATOR_GREATER_THAN_OR_EQUAL = T.let(5, Integer)
+  self::OPERATOR_LESS_THAN = T.let(6, Integer)
+  self::OPERATOR_LESS_THAN_OR_EQUAL = T.let(7, Integer)
+
+  sig { params(value: Integer).returns(T.nilable(Symbol)) }
+  def self.lookup(value)
+  end
+
+  sig { params(value: Symbol).returns(T.nilable(Integer)) }
+  def self.resolve(value)
+  end
+
+  sig { returns(::Google::Protobuf::EnumDescriptor) }
+  def self.descriptor
+  end
+end

data/rbi/db/put_pb.rbi

@@ -40,47 +40,41 @@ class Stately::Db::PutRequest
   def clear_store_id
   end
 
-  # puts is up to 50 items to be put into the Store.
+  # items to put into the store.
   sig { returns(T::Array[T.nilable(Stately::Db::PutItem)]) }
   def puts
   end
 
-  # puts is up to 50 items to be put into the Store.
+  # items to put into the store.
   sig { params(value: ::Google::Protobuf::RepeatedField).void }
   def puts=(value)
   end
 
-  # puts is up to 50 items to be put into the Store.
+  # items to put into the store.
   sig { void }
   def clear_puts
   end
 
-  # schema_version_id refers to the item version to return.
-#
-# If the store's schema does not have this version, the operation will error
-# with SchemaVersionNotFound error. You should not have to set this manually
-# as your generated SDK should know its schema version and wire this in for
-# you.
+  # schema_version_id is the version of the store's schema to use to interpret
+# items. If there is no version with this ID, the operation will error with
+# SchemaVersionNotFound error. You should not have to set this manually as
+# your generated SDK should know its schema version and wire this in for you.
   sig { returns(Integer) }
   def schema_version_id
   end
 
-  # schema_version_id refers to the item version to return.
-#
-# If the store's schema does not have this version, the operation will error
-# with SchemaVersionNotFound error. You should not have to set this manually
-# as your generated SDK should know its schema version and wire this in for
-# you.
+  # schema_version_id is the version of the store's schema to use to interpret
+# items. If there is no version with this ID, the operation will error with
+# SchemaVersionNotFound error. You should not have to set this manually as
+# your generated SDK should know its schema version and wire this in for you.
   sig { params(value: Integer).void }
   def schema_version_id=(value)
   end
 
-  # schema_version_id refers to the item version to return.
-#
-# If the store's schema does not have this version, the operation will error
-# with SchemaVersionNotFound error. You should not have to set this manually
-# as your generated SDK should know its schema version and wire this in for
-# you.
+  # schema_version_id is the version of the store's schema to use to interpret
+# items. If there is no version with this ID, the operation will error with
+# SchemaVersionNotFound error. You should not have to set this manually as
+# your generated SDK should know its schema version and wire this in for you.
   sig { void }
   def clear_schema_version_id
   end

data/rbi/db/scan_pb.rbi

@@ -2,72 +2,6 @@
 # source: db/scan.proto
 # typed: strict
 
-class Stately::Db::FilterCondition
-  include ::Google::Protobuf::MessageExts
-  extend ::Google::Protobuf::MessageExts::ClassMethods
-
-  sig do
-    params(
-      item_type: T.nilable(String)
-    ).void
-  end
-  def initialize(
-    item_type: ""
-  )
-  end
-
-  # item_type is the type of item to filter by.
-  sig { returns(String) }
-  def item_type
-  end
-
-  # item_type is the type of item to filter by.
-  sig { params(value: String).void }
-  def item_type=(value)
-  end
-
-  # item_type is the type of item to filter by.
-  sig { void }
-  def clear_item_type
-  end
-
-  sig { returns(T.nilable(Symbol)) }
-  def value
-  end
-
-  sig { params(field: String).returns(T.untyped) }
-  def [](field)
-  end
-
-  sig { params(field: String, value: T.untyped).void }
-  def []=(field, value)
-  end
-
-  sig { returns(T::Hash[Symbol, T.untyped]) }
-  def to_h
-  end
-
-  sig { params(str: String).returns(Stately::Db::FilterCondition) }
-  def self.decode(str)
-  end
-
-  sig { params(msg: Stately::Db::FilterCondition).returns(String) }
-  def self.encode(msg)
-  end
-
-  sig { params(str: String, kw: T.untyped).returns(Stately::Db::FilterCondition) }
-  def self.decode_json(str, **kw)
-  end
-
-  sig { params(msg: Stately::Db::FilterCondition, kw: T.untyped).returns(String) }
-  def self.encode_json(msg, **kw)
-  end
-
-  sig { returns(::Google::Protobuf::Descriptor) }
-  def self.descriptor
-  end
-end
-
 class Stately::Db::BeginScanRequest
   include ::Google::Protobuf::MessageExts
   extend ::Google::Protobuf::MessageExts::ClassMethods
@@ -188,29 +122,26 @@ class Stately::Db::BeginScanRequest
   def clear_segmentation_params
   end
 
-  # schema_version_id refers to the item version to return.
-# If the store's schema does not have this version, the operation
-# will error with SchemaVersionNotFound error. You should not have to
-# set this manually as your generated SDK should know its schema version
-# and wire this in for you.
+  # schema_version_id is the version of the store's schema to use to interpret
+# items. If there is no version with this ID, the operation will error with
+# SchemaVersionNotFound error. You should not have to set this manually as
+# your generated SDK should know its schema version and wire this in for you.
   sig { returns(Integer) }
   def schema_version_id
   end
 
-  # schema_version_id refers to the item version to return.
-# If the store's schema does not have this version, the operation
-# will error with SchemaVersionNotFound error. You should not have to
-# set this manually as your generated SDK should know its schema version
-# and wire this in for you.
+  # schema_version_id is the version of the store's schema to use to interpret
+# items. If there is no version with this ID, the operation will error with
+# SchemaVersionNotFound error. You should not have to set this manually as
+# your generated SDK should know its schema version and wire this in for you.
   sig { params(value: Integer).void }
   def schema_version_id=(value)
   end
 
-  # schema_version_id refers to the item version to return.
-# If the store's schema does not have this version, the operation
-# will error with SchemaVersionNotFound error. You should not have to
-# set this manually as your generated SDK should know its schema version
-# and wire this in for you.
+  # schema_version_id is the version of the store's schema to use to interpret
+# items. If there is no version with this ID, the operation will error with
+# SchemaVersionNotFound error. You should not have to set this manually as
+# your generated SDK should know its schema version and wire this in for you.
   sig { void }
   def clear_schema_version_id
   end

data/rbi/db/service_services_pb.rbi

@@ -167,18 +167,5 @@ module Stately::Db::DatabaseService
     end
     def transaction(request)
     end
-
-    # ScanRootPaths lists root paths (Groups) in the Store. This is a very
-# expensive operation, as it must consult multiple partitions and it reads
-# and ignores a lot of data. It is provided for use in the web console's data
-# browser and is not exposed to customers. This operation will fail if the
-# caller does not have permission to read Items.
-    sig do
-      params(
-        request: Stately::Db::ScanRootPathsRequest
-      ).returns(Stately::Db::ScanRootPathsResponse)
-    end
-    def scan_root_paths(request)
-    end
   end
 end

data/rbi/db/transaction_pb.rbi

@@ -559,17 +559,17 @@ class Stately::Db::TransactionGet
   )
   end
 
-  # gets is up to 100 requests to get an item its key path.
+  # key paths to of each item to get.
   sig { returns(T::Array[T.nilable(Stately::Db::GetItem)]) }
   def gets
   end
 
-  # gets is up to 100 requests to get an item its key path.
+  # key paths to of each item to get.
   sig { params(value: ::Google::Protobuf::RepeatedField).void }
   def gets=(value)
   end
 
-  # gets is up to 100 requests to get an item its key path.
+  # key paths to of each item to get.
   sig { void }
   def clear_gets
   end
@@ -618,14 +618,16 @@ class Stately::Db::TransactionBeginList
       key_path_prefix: T.nilable(String),
       limit: T.nilable(Integer),
       sort_property: T.nilable(T.any(Symbol, String, Integer)),
-      sort_direction: T.nilable(T.any(Symbol, String, Integer))
+      sort_direction: T.nilable(T.any(Symbol, String, Integer)),
+      filter_conditions: T.nilable(T::Array[T.nilable(Stately::Db::FilterCondition)])
     ).void
   end
   def initialize(
     key_path_prefix: "",
     limit: 0,
     sort_property: :SORTABLE_PROPERTY_KEY_PATH,
-    sort_direction: :SORT_ASCENDING
+    sort_direction: :SORT_ASCENDING,
+    filter_conditions: []
   )
   end
 
@@ -707,6 +709,27 @@ class Stately::Db::TransactionBeginList
   def clear_sort_direction
   end
 
+  # filter_conditions are a set of conditions to filter the list result by.
+# If no conditions are provided, all items in the store will be returned.
+# Filter conditions are combined with OR.
+  sig { returns(T::Array[T.nilable(Stately::Db::FilterCondition)]) }
+  def filter_conditions
+  end
+
+  # filter_conditions are a set of conditions to filter the list result by.
+# If no conditions are provided, all items in the store will be returned.
+# Filter conditions are combined with OR.
+  sig { params(value: ::Google::Protobuf::RepeatedField).void }
+  def filter_conditions=(value)
+  end
+
+  # filter_conditions are a set of conditions to filter the list result by.
+# If no conditions are provided, all items in the store will be returned.
+# Filter conditions are combined with OR.
+  sig { void }
+  def clear_filter_conditions
+  end
+
   sig { params(field: String).returns(T.untyped) }
   def [](field)
   end
@@ -845,17 +868,17 @@ class Stately::Db::TransactionPut
   )
   end
 
-  # puts is up to 50 items to be put into the Store.
+  # items to put into the store.
   sig { returns(T::Array[T.nilable(Stately::Db::PutItem)]) }
   def puts
   end
 
-  # puts is up to 50 items to be put into the Store.
+  # items to put into the store.
   sig { params(value: ::Google::Protobuf::RepeatedField).void }
   def puts=(value)
   end
 
-  # puts is up to 50 items to be put into the Store.
+  # items to put into the store.
   sig { void }
   def clear_puts
   end
@@ -910,17 +933,17 @@ class Stately::Db::TransactionDelete
   )
   end
 
-  # deletes is up to 50 to be deleted from the Group.
+  # key paths of items to delete.
   sig { returns(T::Array[T.nilable(Stately::Db::DeleteItem)]) }
   def deletes
   end
 
-  # deletes is up to 50 to be deleted from the Group.
+  # key paths of items to delete.
   sig { params(value: ::Google::Protobuf::RepeatedField).void }
   def deletes=(value)
   end
 
-  # deletes is up to 50 to be deleted from the Group.
+  # key paths of items to delete.
   sig { void }
   def clear_deletes
   end