aws-sdk-dynamodb 1.96.0 → 1.132.0

data/lib/aws-sdk-dynamodb/errors.rb

@@ -46,9 +46,11 @@ module Aws::DynamoDB
   # * {ItemCollectionSizeLimitExceededException}
   # * {LimitExceededException}
   # * {PointInTimeRecoveryUnavailableException}
+  # * {PolicyNotFoundException}
   # * {ProvisionedThroughputExceededException}
   # * {ReplicaAlreadyExistsException}
   # * {ReplicaNotFoundException}
+  # * {ReplicatedWriteConflictException}
   # * {RequestLimitExceeded}
   # * {ResourceInUseException}
   # * {ResourceNotFoundException}
@@ -355,6 +357,21 @@ module Aws::DynamoDB
       end
     end
 
+    class PolicyNotFoundException < ServiceError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      # @param [Aws::DynamoDB::Types::PolicyNotFoundException] data
+      def initialize(context, message, data = Aws::EmptyStructure.new)
+        super(context, message, data)
+      end
+
+      # @return [String]
+      def message
+        @message || @data[:message]
+      end
+    end
+
     class ProvisionedThroughputExceededException < ServiceError
 
       # @param [Seahorse::Client::RequestContext] context
@@ -400,6 +417,21 @@ module Aws::DynamoDB
       end
     end
 
+    class ReplicatedWriteConflictException < ServiceError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      # @param [Aws::DynamoDB::Types::ReplicatedWriteConflictException] data
+      def initialize(context, message, data = Aws::EmptyStructure.new)
+        super(context, message, data)
+      end
+
+      # @return [String]
+      def message
+        @message || @data[:message]
+      end
+    end
+
     class RequestLimitExceeded < ServiceError
 
       # @param [Seahorse::Client::RequestContext] context

data/lib/aws-sdk-dynamodb/plugins/endpoints.rb

@@ -14,35 +14,74 @@ module Aws::DynamoDB
       option(
         :endpoint_provider,
         doc_type: 'Aws::DynamoDB::EndpointProvider',
-        docstring: 'The endpoint provider used to resolve endpoints. Any '\
-                   'object that responds to `#resolve_endpoint(parameters)` '\
-                   'where `parameters` is a Struct similar to '\
-                   '`Aws::DynamoDB::EndpointParameters`'
-      ) do |cfg|
+        rbs_type: 'untyped',
+        docstring: <<~DOCS) do |_cfg|
+The endpoint provider used to resolve endpoints. Any object that responds to
+`#resolve_endpoint(parameters)` where `parameters` is a Struct similar to
+`Aws::DynamoDB::EndpointParameters`.
+        DOCS
         Aws::DynamoDB::EndpointProvider.new
       end
 
+      option(
+        :account_id_endpoint_mode,
+        doc_type: 'String',
+        docstring: <<~DOCS) do |cfg|
+The account ID endpoint mode to use. This can be one of the following values:
+* `preferred` - The default behavior. Use the account ID endpoint if
+  available, otherwise use the standard endpoint.
+* `disabled` - Never use the account ID endpoint. Only use the standard
+  endpoint.
+* `required` - Always use the account ID endpoint. If the account ID
+  cannot be retrieved from credentials, an error is raised.
+        DOCS
+        value = ENV['AWS_ACCOUNT_ID_ENDPOINT_MODE']
+        value ||= Aws.shared_config.account_id_endpoint_mode(profile: cfg.profile)
+        value || 'preferred'
+      end
+
       # @api private
       class Handler < Seahorse::Client::Handler
         def call(context)
-          # If endpoint was discovered, do not resolve or apply the endpoint.
           unless context[:discovered_endpoint]
-            params = parameters_for_operation(context)
+            params = Aws::DynamoDB::Endpoints.parameters_for_operation(context)
             endpoint = context.config.endpoint_provider.resolve_endpoint(params)
 
             context.http_request.endpoint = endpoint.url
             apply_endpoint_headers(context, endpoint.headers)
+
+            context[:endpoint_params] = params
+            context[:endpoint_properties] = endpoint.properties
           end
 
-          context[:endpoint_params] = params
           context[:auth_scheme] =
             Aws::Endpoints.resolve_auth_scheme(context, endpoint)
 
-          @handler.call(context)
+          with_metrics(context) { @handler.call(context) }
         end
 
         private
 
+        def with_metrics(context, &block)
+          metrics = []
+          metrics << 'ENDPOINT_OVERRIDE' unless context.config.regional_endpoint
+          if context[:auth_scheme] && context[:auth_scheme]['name'] == 'sigv4a'
+            metrics << 'SIGV4A_SIGNING'
+          end
+          case context.config.account_id_endpoint_mode
+          when 'preferred'
+            metrics << 'ACCOUNT_ID_MODE_PREFERRED'
+          when 'disabled'
+            metrics << 'ACCOUNT_ID_MODE_DISABLED'
+          when 'required'
+            metrics << 'ACCOUNT_ID_MODE_REQUIRED'
+          end
+          if context.config.credentials&.credentials&.account_id
+            metrics << 'RESOLVED_ACCOUNT_ID'
+          end
+          Aws::Plugins::UserAgent.metric(*metrics, &block)
+        end
+
         def apply_endpoint_headers(context, headers)
           headers.each do |key, values|
             value = values
@@ -53,117 +92,6 @@ module Aws::DynamoDB
             context.http_request.headers[key] = value
           end
         end
-
-        def parameters_for_operation(context)
-          case context.operation_name
-          when :batch_execute_statement
-            Aws::DynamoDB::Endpoints::BatchExecuteStatement.build(context)
-          when :batch_get_item
-            Aws::DynamoDB::Endpoints::BatchGetItem.build(context)
-          when :batch_write_item
-            Aws::DynamoDB::Endpoints::BatchWriteItem.build(context)
-          when :create_backup
-            Aws::DynamoDB::Endpoints::CreateBackup.build(context)
-          when :create_global_table
-            Aws::DynamoDB::Endpoints::CreateGlobalTable.build(context)
-          when :create_table
-            Aws::DynamoDB::Endpoints::CreateTable.build(context)
-          when :delete_backup
-            Aws::DynamoDB::Endpoints::DeleteBackup.build(context)
-          when :delete_item
-            Aws::DynamoDB::Endpoints::DeleteItem.build(context)
-          when :delete_table
-            Aws::DynamoDB::Endpoints::DeleteTable.build(context)
-          when :describe_backup
-            Aws::DynamoDB::Endpoints::DescribeBackup.build(context)
-          when :describe_continuous_backups
-            Aws::DynamoDB::Endpoints::DescribeContinuousBackups.build(context)
-          when :describe_contributor_insights
-            Aws::DynamoDB::Endpoints::DescribeContributorInsights.build(context)
-          when :describe_endpoints
-            Aws::DynamoDB::Endpoints::DescribeEndpoints.build(context)
-          when :describe_export
-            Aws::DynamoDB::Endpoints::DescribeExport.build(context)
-          when :describe_global_table
-            Aws::DynamoDB::Endpoints::DescribeGlobalTable.build(context)
-          when :describe_global_table_settings
-            Aws::DynamoDB::Endpoints::DescribeGlobalTableSettings.build(context)
-          when :describe_import
-            Aws::DynamoDB::Endpoints::DescribeImport.build(context)
-          when :describe_kinesis_streaming_destination
-            Aws::DynamoDB::Endpoints::DescribeKinesisStreamingDestination.build(context)
-          when :describe_limits
-            Aws::DynamoDB::Endpoints::DescribeLimits.build(context)
-          when :describe_table
-            Aws::DynamoDB::Endpoints::DescribeTable.build(context)
-          when :describe_table_replica_auto_scaling
-            Aws::DynamoDB::Endpoints::DescribeTableReplicaAutoScaling.build(context)
-          when :describe_time_to_live
-            Aws::DynamoDB::Endpoints::DescribeTimeToLive.build(context)
-          when :disable_kinesis_streaming_destination
-            Aws::DynamoDB::Endpoints::DisableKinesisStreamingDestination.build(context)
-          when :enable_kinesis_streaming_destination
-            Aws::DynamoDB::Endpoints::EnableKinesisStreamingDestination.build(context)
-          when :execute_statement
-            Aws::DynamoDB::Endpoints::ExecuteStatement.build(context)
-          when :execute_transaction
-            Aws::DynamoDB::Endpoints::ExecuteTransaction.build(context)
-          when :export_table_to_point_in_time
-            Aws::DynamoDB::Endpoints::ExportTableToPointInTime.build(context)
-          when :get_item
-            Aws::DynamoDB::Endpoints::GetItem.build(context)
-          when :import_table
-            Aws::DynamoDB::Endpoints::ImportTable.build(context)
-          when :list_backups
-            Aws::DynamoDB::Endpoints::ListBackups.build(context)
-          when :list_contributor_insights
-            Aws::DynamoDB::Endpoints::ListContributorInsights.build(context)
-          when :list_exports
-            Aws::DynamoDB::Endpoints::ListExports.build(context)
-          when :list_global_tables
-            Aws::DynamoDB::Endpoints::ListGlobalTables.build(context)
-          when :list_imports
-            Aws::DynamoDB::Endpoints::ListImports.build(context)
-          when :list_tables
-            Aws::DynamoDB::Endpoints::ListTables.build(context)
-          when :list_tags_of_resource
-            Aws::DynamoDB::Endpoints::ListTagsOfResource.build(context)
-          when :put_item
-            Aws::DynamoDB::Endpoints::PutItem.build(context)
-          when :query
-            Aws::DynamoDB::Endpoints::Query.build(context)
-          when :restore_table_from_backup
-            Aws::DynamoDB::Endpoints::RestoreTableFromBackup.build(context)
-          when :restore_table_to_point_in_time
-            Aws::DynamoDB::Endpoints::RestoreTableToPointInTime.build(context)
-          when :scan
-            Aws::DynamoDB::Endpoints::Scan.build(context)
-          when :tag_resource
-            Aws::DynamoDB::Endpoints::TagResource.build(context)
-          when :transact_get_items
-            Aws::DynamoDB::Endpoints::TransactGetItems.build(context)
-          when :transact_write_items
-            Aws::DynamoDB::Endpoints::TransactWriteItems.build(context)
-          when :untag_resource
-            Aws::DynamoDB::Endpoints::UntagResource.build(context)
-          when :update_continuous_backups
-            Aws::DynamoDB::Endpoints::UpdateContinuousBackups.build(context)
-          when :update_contributor_insights
-            Aws::DynamoDB::Endpoints::UpdateContributorInsights.build(context)
-          when :update_global_table
-            Aws::DynamoDB::Endpoints::UpdateGlobalTable.build(context)
-          when :update_global_table_settings
-            Aws::DynamoDB::Endpoints::UpdateGlobalTableSettings.build(context)
-          when :update_item
-            Aws::DynamoDB::Endpoints::UpdateItem.build(context)
-          when :update_table
-            Aws::DynamoDB::Endpoints::UpdateTable.build(context)
-          when :update_table_replica_auto_scaling
-            Aws::DynamoDB::Endpoints::UpdateTableReplicaAutoScaling.build(context)
-          when :update_time_to_live
-            Aws::DynamoDB::Endpoints::UpdateTimeToLive.build(context)
-          end
-        end
       end
 
       def add_handlers(handlers, _config)

data/lib/aws-sdk-dynamodb/plugins/simple_attributes.rb

@@ -13,6 +13,30 @@ module Aws
       #
       #     ddb = Aws::DynamoDB::Client.new(simple_attributes: false)
       #
+      # Members are marshalled using the following objects:
+      #
+      # * `Hash` or `#to_h` => `:m`
+      # * `Array` => `:l`
+      # * `String` or `Symbol` or `#to_str` => `:s`
+      # * `Numeric` => `:n`
+      # * `StringIO` or `IO` => `:b`
+      # * `Set<Object>` => `:ss` or `:ns` or `:bs`
+      # * `true` or `false` => `:bool`
+      # * `nil` => `:null`
+      #
+      # Members are unmarshalled into the following objects:
+      #
+      # * `:m` => `Hash`
+      # * `:l` => `Array`
+      # * `:s` => `String`
+      # * `:n` => `BigDecimal`
+      # * `:b` => `StringIO`
+      # * `:null` => `nil`
+      # * `:bool` => `true` or `false`
+      # * `:ss` => `Set<String>`
+      # * `:ns` => `Set<BigDecimal>`
+      # * `:bs` => `Set<StringIO>`
+      #
       # ## Input Examples
       #
       # With this plugin **enabled**, `simple_attributes: true`:
@@ -101,6 +125,8 @@ hashes, arrays, sets, integers, floats, booleans, and nil.
 Disabling this option requires that all attribute values have
 their types specified, e.g. `{ s: 'abc' }` instead of simply
 `'abc'`.
+
+See {Aws::DynamoDB::Plugins::SimpleAttributes} for more information.
         DOCS
         ) do |config|
           !config.simple_json

data/lib/aws-sdk-dynamodb/resource.rb

@@ -39,7 +39,7 @@ module Aws::DynamoDB
     #
     #   dynamo_db.batch_get_item({
     #     request_items: { # required
-    #       "TableName" => {
+    #       "TableArn" => {
     #         keys: [ # required
     #           {
     #             "AttributeName" => "value", # value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
@@ -57,9 +57,9 @@ module Aws::DynamoDB
     #   })
     # @param [Hash] options ({})
     # @option options [required, Hash<String,Types::KeysAndAttributes>] :request_items
-    #   A map of one or more table names and, for each table, a map that
-    #   describes one or more items to retrieve from that table. Each table
-    #   name can be used only once per `BatchGetItem` request.
+    #   A map of one or more table names or table ARNs and, for each table, a
+    #   map that describes one or more items to retrieve from that table. Each
+    #   table name or ARN can be used only once per `BatchGetItem` request.
     #
     #   Each element in the map of items to retrieve consists of the
     #   following:
@@ -79,31 +79,27 @@ module Aws::DynamoDB
     #
     #     * To prevent special characters in an attribute name from being
     #       misinterpreted in an expression.
-    #
     #     Use the **#** character in an expression to dereference an attribute
     #     name. For example, consider the following attribute name:
     #
     #     * `Percentile`
     #
     #     ^
-    #
     #     The name of this attribute conflicts with a reserved word, so it
     #     cannot be used directly in an expression. (For the complete list of
     #     reserved words, see [Reserved Words][1] in the *Amazon DynamoDB
     #     Developer Guide*). To work around this, you could specify the
     #     following for `ExpressionAttributeNames`:
     #
-    #     * `\{"#P":"Percentile"\}`
+    #     * `{"#P":"Percentile"}`
     #
     #     ^
-    #
     #     You could then use this substitution in an expression, as in this
     #     example:
     #
     #     * `#P = :val`
     #
     #     ^
-    #
     #     <note markdown="1"> Tokens that begin with the **\:** character are *expression
     #     attribute values*, which are placeholders for the actual value at
     #     runtime.
@@ -160,7 +156,7 @@ module Aws::DynamoDB
     #   * `NONE` - No `ConsumedCapacity` details are included in the response.
     # @return [Types::BatchGetItemOutput]
     def batch_get_item(options = {})
-      resp = Aws::Plugins::UserAgent.feature('resource') do
+      resp = Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
         @client.batch_get_item(options)
       end
       resp.data
@@ -170,7 +166,7 @@ module Aws::DynamoDB
     #
     #   dynamo_db.batch_write_item({
     #     request_items: { # required
-    #       "TableName" => [
+    #       "TableArn" => [
     #         {
     #           put_request: {
     #             item: { # required
@@ -190,9 +186,9 @@ module Aws::DynamoDB
     #   })
     # @param [Hash] options ({})
     # @option options [required, Hash<String,Array>] :request_items
-    #   A map of one or more table names and, for each table, a list of
-    #   operations to be performed (`DeleteRequest` or `PutRequest`). Each
-    #   element in the map consists of the following:
+    #   A map of one or more table names or table ARNs and, for each table, a
+    #   list of operations to be performed (`DeleteRequest` or `PutRequest`).
+    #   Each element in the map consists of the following:
     #
     #   * `DeleteRequest` - Perform a `DeleteItem` operation on the specified
     #     item. The item to be deleted is identified by a `Key` subelement:
@@ -206,7 +202,6 @@ module Aws::DynamoDB
     #       *both* the partition key and the sort key.
     #
     #     ^
-    #
     #   * `PutRequest` - Perform a `PutItem` operation on the specified item.
     #     The item to be put is identified by an `Item` subelement:
     #
@@ -243,7 +238,7 @@ module Aws::DynamoDB
     #   response. If set to `NONE` (the default), no statistics are returned.
     # @return [Types::BatchWriteItemOutput]
     def batch_write_item(options = {})
-      resp = Aws::Plugins::UserAgent.feature('resource') do
+      resp = Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
         @client.batch_write_item(options)
       end
       resp.data
@@ -258,7 +253,7 @@ module Aws::DynamoDB
     #         attribute_type: "S", # required, accepts S, N, B
     #       },
     #     ],
-    #     table_name: "TableName", # required
+    #     table_name: "TableArn", # required
     #     key_schema: [ # required
     #       {
     #         attribute_name: "KeySchemaAttributeName", # required
@@ -297,6 +292,14 @@ module Aws::DynamoDB
     #           read_capacity_units: 1, # required
     #           write_capacity_units: 1, # required
     #         },
+    #         on_demand_throughput: {
+    #           max_read_request_units: 1,
+    #           max_write_request_units: 1,
+    #         },
+    #         warm_throughput: {
+    #           read_units_per_second: 1,
+    #           write_units_per_second: 1,
+    #         },
     #       },
     #     ],
     #     billing_mode: "PROVISIONED", # accepts PROVISIONED, PAY_PER_REQUEST
@@ -321,13 +324,23 @@ module Aws::DynamoDB
     #     ],
     #     table_class: "STANDARD", # accepts STANDARD, STANDARD_INFREQUENT_ACCESS
     #     deletion_protection_enabled: false,
+    #     warm_throughput: {
+    #       read_units_per_second: 1,
+    #       write_units_per_second: 1,
+    #     },
+    #     resource_policy: "ResourcePolicy",
+    #     on_demand_throughput: {
+    #       max_read_request_units: 1,
+    #       max_write_request_units: 1,
+    #     },
     #   })
     # @param [Hash] options ({})
     # @option options [required, Array<Types::AttributeDefinition>] :attribute_definitions
     #   An array of attributes that describe the key schema for the table and
     #   indexes.
     # @option options [required, String] :table_name
-    #   The name of the table to create.
+    #   The name of the table to create. You can also provide the Amazon
+    #   Resource Name (ARN) of the table in this parameter.
     # @option options [required, Array<Types::KeySchemaElement>] :key_schema
     #   Specifies the attributes that make up the primary key for a table or
     #   an index. The attributes in `KeySchema` must also be defined in the
@@ -404,7 +417,6 @@ module Aws::DynamoDB
     #
     #       * `ALL` - All of the table attributes are projected into the
     #         index.
-    #
     #     * `NonKeyAttributes` - A list of one or more non-key attribute names
     #       that are projected into the secondary index. The total count of
     #       attributes provided in `NonKeyAttributes`, summed across all of
@@ -440,14 +452,12 @@ module Aws::DynamoDB
     #
     #       * `ALL` - All of the table attributes are projected into the
     #         index.
-    #
     #     * `NonKeyAttributes` - A list of one or more non-key attribute names
     #       that are projected into the secondary index. The total count of
     #       attributes provided in `NonKeyAttributes`, summed across all of
     #       the secondary indexes, must not exceed 100. If you project the
     #       same attribute into two different indexes, this counts as two
     #       distinct attributes when determining the total.
-    #
     #   * `ProvisionedThroughput` - The provisioned throughput settings for
     #     the global secondary index, consisting of read and write capacity
     #     units.
@@ -457,16 +467,16 @@ module Aws::DynamoDB
     #
     #   * `PROVISIONED` - We recommend using `PROVISIONED` for predictable
     #     workloads. `PROVISIONED` sets the billing mode to [Provisioned
-    #     Mode][1].
+    #     capacity mode][1].
     #
     #   * `PAY_PER_REQUEST` - We recommend using `PAY_PER_REQUEST` for
     #     unpredictable workloads. `PAY_PER_REQUEST` sets the billing mode to
-    #     [On-Demand Mode][2].
+    #     [On-demand capacity mode][2].
     #
     #
     #
-    #   [1]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html#HowItWorks.ProvisionedThroughput.Manual
-    #   [2]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html#HowItWorks.OnDemand
+    #   [1]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/provisioned-capacity-mode.html
+    #   [2]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/on-demand-capacity-mode.html
     # @option options [Types::ProvisionedThroughput] :provisioned_throughput
     #   Represents the provisioned throughput settings for a specified table
     #   or index. The settings can be modified using the `UpdateTable`
@@ -520,9 +530,38 @@ module Aws::DynamoDB
     # @option options [Boolean] :deletion_protection_enabled
     #   Indicates whether deletion protection is to be enabled (true) or
     #   disabled (false) on the table.
+    # @option options [Types::WarmThroughput] :warm_throughput
+    #   Represents the warm throughput (in read units per second and write
+    #   units per second) for creating a table.
+    # @option options [String] :resource_policy
+    #   An Amazon Web Services resource-based policy document in JSON format
+    #   that will be attached to the table.
+    #
+    #   When you attach a resource-based policy while creating a table, the
+    #   policy application is *strongly consistent*.
+    #
+    #   The maximum size supported for a resource-based policy document is 20
+    #   KB. DynamoDB counts whitespaces when calculating the size of a policy
+    #   against this limit. For a full list of all considerations that apply
+    #   for resource-based policies, see [Resource-based policy
+    #   considerations][1].
+    #
+    #   <note markdown="1"> You need to specify the `CreateTable` and `PutResourcePolicy` IAM
+    #   actions for authorizing a user to create a table with a resource-based
+    #   policy.
+    #
+    #    </note>
+    #
+    #
+    #
+    #   [1]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/rbac-considerations.html
+    # @option options [Types::OnDemandThroughput] :on_demand_throughput
+    #   Sets the maximum number of read and write units for the specified
+    #   table in on-demand capacity mode. If you use this parameter, you must
+    #   specify `MaxReadRequestUnits`, `MaxWriteRequestUnits`, or both.
     # @return [Table]
     def create_table(options = {})
-      resp = Aws::Plugins::UserAgent.feature('resource') do
+      resp = Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
         @client.create_table(options)
       end
       Table.new(
@@ -550,7 +589,7 @@ module Aws::DynamoDB
     # @return [Table::Collection]
     def tables(options = {})
       batches = Enumerator.new do |y|
-        resp = Aws::Plugins::UserAgent.feature('resource') do
+        resp = Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
           @client.list_tables(options)
         end
         resp.each_page do |page|