aws_sdk_appsync

Module types

source
Expand description

Data structures used by operation inputs/outputs.

Modules§

  • builders
    Builders
  • error
    Error types that AWS AppSync can respond with.

Structs§

  • AdditionalAuthenticationProvider

    Describes an additional authentication provider.

  • ApiAssociation

    Describes an ApiAssociation object.

  • ApiCache

    The ApiCache object.

  • ApiKey

    Describes an API key.

    Customers invoke AppSync GraphQL API operations with API keys as an identity mechanism. There are two key versions:

    da1: We introduced this version at launch in November 2017. These keys always expire after 7 days. Amazon DynamoDB TTL manages key expiration. These keys ceased to be valid after February 21, 2018, and they should no longer be used.

    • ListApiKeys returns the expiration time in milliseconds.

    • CreateApiKey returns the expiration time in milliseconds.

    • UpdateApiKey is not available for this key version.

    • DeleteApiKey deletes the item from the table.

    • Expiration is stored in DynamoDB as milliseconds. This results in a bug where keys are not automatically deleted because DynamoDB expects the TTL to be stored in seconds. As a one-time action, we deleted these keys from the table on February 21, 2018.

    da2: We introduced this version in February 2018 when AppSync added support to extend key expiration.

    • ListApiKeys returns the expiration time and deletion time in seconds.

    • CreateApiKey returns the expiration time and deletion time in seconds and accepts a user-provided expiration time in seconds.

    • UpdateApiKey returns the expiration time and and deletion time in seconds and accepts a user-provided expiration time in seconds. Expired API keys are kept for 60 days after the expiration time. You can update the key expiration time as long as the key isn't deleted.

    • DeleteApiKey deletes the item from the table.

    • Expiration is stored in DynamoDB as seconds. After the expiration time, using the key to authenticate will fail. However, you can reinstate the key before deletion.

    • Deletion is stored in DynamoDB as seconds. The key is deleted after deletion time.

  • AppSyncRuntime

    Describes a runtime used by an Amazon Web Services AppSync pipeline resolver or Amazon Web Services AppSync function. Specifies the name and version of the runtime to use. Note that if a runtime is specified, code must also be specified.

  • AuthorizationConfig

    The authorization configuration in case the HTTP endpoint requires authorization.

  • AwsIamConfig

    The Identity and Access Management (IAM) configuration.

  • BadRequestDetail

    Provides further details for the reason behind the bad request. For reason type CODE_ERROR, the detail will contain a list of code errors.

  • CachingConfig

    The caching configuration for a resolver that has caching activated.

  • CodeError

    Describes an AppSync error.

  • CodeErrorLocation

    Describes the location of the error in a code sample.

  • CognitoUserPoolConfig

    Describes an Amazon Cognito user pool configuration.

  • DataSource

    Describes a data source.

  • DataSourceIntrospectionModel

    Contains the introspected data that was retrieved from the data source.

  • DataSourceIntrospectionModelField

    Represents the fields that were retrieved from the introspected data.

  • DataSourceIntrospectionModelFieldType

    Represents the type data for each field retrieved from the introspection.

  • DataSourceIntrospectionModelIndex

    The index that was retrieved from the introspected data.

  • DataSourceIntrospectionResult

    Represents the output of a DataSourceIntrospectionResult. This is the populated result of a GetDataSourceIntrospection operation.

  • DeltaSyncConfig

    Describes a Delta Sync configuration.

  • DomainNameConfig

    Describes a configuration for a custom domain.

  • DynamodbDataSourceConfig

    Describes an Amazon DynamoDB data source configuration.

  • ElasticsearchDataSourceConfig

    Describes an OpenSearch data source configuration.

    As of September 2021, Amazon Elasticsearch service is Amazon OpenSearch Service. This configuration is deprecated. For new data sources, use OpenSearchServiceDataSourceConfig to specify an OpenSearch data source.

  • EnhancedMetricsConfig

    Enables and controls the enhanced metrics feature. Enhanced metrics emit granular data on API usage and performance such as AppSync request and error counts, latency, and cache hits/misses. All enhanced metric data is sent to your CloudWatch account, and you can configure the types of data that will be sent.

    Enhanced metrics can be configured at the resolver, data source, and operation levels. EnhancedMetricsConfig contains three required parameters, each controlling one of these categories:

    1. resolverLevelMetricsBehavior: Controls how resolver metrics will be emitted to CloudWatch. Resolver metrics include:

      • GraphQL errors: The number of GraphQL errors that occurred.

      • Requests: The number of invocations that occurred during a request.

      • Latency: The time to complete a resolver invocation.

      • Cache hits: The number of cache hits during a request.

      • Cache misses: The number of cache misses during a request.

      These metrics can be emitted to CloudWatch per resolver or for all resolvers in the request. Metrics will be recorded by API ID and resolver name. resolverLevelMetricsBehavior accepts one of these values at a time:

      • FULL_REQUEST_RESOLVER_METRICS: Records and emits metric data for all resolvers in the request.

      • PER_RESOLVER_METRICS: Records and emits metric data for resolvers that have the metricsConfig value set to ENABLED.

    2. dataSourceLevelMetricsBehavior: Controls how data source metrics will be emitted to CloudWatch. Data source metrics include:

      • Requests: The number of invocations that occured during a request.

      • Latency: The time to complete a data source invocation.

      • Errors: The number of errors that occurred during a data source invocation.

      These metrics can be emitted to CloudWatch per data source or for all data sources in the request. Metrics will be recorded by API ID and data source name. dataSourceLevelMetricsBehavior accepts one of these values at a time:

      • FULL_REQUEST_DATA_SOURCE_METRICS: Records and emits metric data for all data sources in the request.

      • PER_DATA_SOURCE_METRICS: Records and emits metric data for data sources that have the metricsConfig value set to ENABLED.

    3. operationLevelMetricsConfig: Controls how operation metrics will be emitted to CloudWatch. Operation metrics include:

      • Requests: The number of times a specified GraphQL operation was called.

      • GraphQL errors: The number of GraphQL errors that occurred during a specified GraphQL operation.

      Metrics will be recorded by API ID and operation name. You can set the value to ENABLED or DISABLED.

  • ErrorDetail

    Contains the list of errors generated. When using JavaScript, this will apply to the request or response function evaluation.

  • EvaluateCodeErrorDetail

    Contains the list of errors from a code evaluation response.

  • EventBridgeDataSourceConfig

    Describes an Amazon EventBridge bus data source configuration.

  • FunctionConfiguration

    A function is a reusable entity. You can use multiple functions to compose the resolver logic.

  • GraphqlApi

    Describes a GraphQL API.

  • HttpDataSourceConfig

    Describes an HTTP data source configuration.

  • LambdaAuthorizerConfig

    A LambdaAuthorizerConfig specifies how to authorize AppSync API access when using the AWS_LAMBDA authorizer mode. Be aware that an AppSync API can have only one Lambda authorizer configured at a time.

  • LambdaConflictHandlerConfig

    The LambdaConflictHandlerConfig object when configuring LAMBDA as the Conflict Handler.

  • LambdaDataSourceConfig

    Describes an Lambda data source configuration.

  • LogConfig

    The Amazon CloudWatch Logs configuration.

  • OpenIdConnectConfig

    Describes an OpenID Connect (OIDC) configuration.

  • OpenSearchServiceDataSourceConfig

    Describes an OpenSearch data source configuration.

  • PipelineConfig

    The pipeline configuration for a resolver of kind PIPELINE.

  • RdsDataApiConfig

    Contains the metadata required to introspect the RDS cluster.

  • RdsHttpEndpointConfig

    The Amazon Relational Database Service (Amazon RDS) HTTP endpoint configuration.

  • RelationalDatabaseDataSourceConfig

    Describes a relational database data source configuration.

  • Resolver

    Describes a resolver.

  • SourceApiAssociation

    Describes the configuration of a source API. A source API is a GraphQL API that is linked to a merged API. There can be multiple source APIs attached to each merged API. When linked to a merged API, the source API's schema, data sources, and resolvers will be combined with other linked source API data to form a new, singular API.

    Source APIs can originate from your account or from other accounts via Amazon Web Services Resource Access Manager. For more information about sharing resources from other accounts, see What is Amazon Web Services Resource Access Manager? in the Amazon Web Services Resource Access Manager guide.

  • SourceApiAssociationConfig

    Describes properties used to specify configurations related to a source API.

  • SourceApiAssociationSummary

    Describes the ARNs and IDs of associations, Merged APIs, and source APIs.

  • SyncConfig

    Describes a Sync configuration for a resolver.

    Specifies which Conflict Detection strategy and Resolution strategy to use when the resolver is invoked.

  • Type

    Describes a type.

  • UserPoolConfig

    Describes an Amazon Cognito user pool configuration.

Enums§

  • ApiCacheStatus
    When writing a match expression against ApiCacheStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ApiCacheType
    When writing a match expression against ApiCacheType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ApiCachingBehavior
    When writing a match expression against ApiCachingBehavior, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • AssociationStatus
    When writing a match expression against AssociationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • AuthenticationType
    When writing a match expression against AuthenticationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • AuthorizationType
    When writing a match expression against AuthorizationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • BadRequestReason
    When writing a match expression against BadRequestReason, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • CacheHealthMetricsConfig
    When writing a match expression against CacheHealthMetricsConfig, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ConflictDetectionType
    When writing a match expression against ConflictDetectionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ConflictHandlerType
    When writing a match expression against ConflictHandlerType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • DataSourceIntrospectionStatus
    When writing a match expression against DataSourceIntrospectionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • DataSourceLevelMetricsBehavior
    When writing a match expression against DataSourceLevelMetricsBehavior, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • DataSourceLevelMetricsConfig
    When writing a match expression against DataSourceLevelMetricsConfig, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • DataSourceType
    When writing a match expression against DataSourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • DefaultAction
    When writing a match expression against DefaultAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • FieldLogLevel
    When writing a match expression against FieldLogLevel, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • GraphQlApiIntrospectionConfig
    When writing a match expression against GraphQlApiIntrospectionConfig, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • GraphQlApiType
    When writing a match expression against GraphQlApiType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • GraphQlApiVisibility
    When writing a match expression against GraphQlApiVisibility, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • MergeType
    When writing a match expression against MergeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • OperationLevelMetricsConfig
    When writing a match expression against OperationLevelMetricsConfig, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • OutputType
    When writing a match expression against OutputType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • Ownership
    When writing a match expression against Ownership, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • RelationalDatabaseSourceType
    When writing a match expression against RelationalDatabaseSourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ResolverKind
    When writing a match expression against ResolverKind, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ResolverLevelMetricsBehavior
    When writing a match expression against ResolverLevelMetricsBehavior, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ResolverLevelMetricsConfig
    When writing a match expression against ResolverLevelMetricsConfig, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • RuntimeName
    When writing a match expression against RuntimeName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • SchemaStatus
    When writing a match expression against SchemaStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • SourceApiAssociationStatus
    When writing a match expression against SourceApiAssociationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • TypeDefinitionFormat
    When writing a match expression against TypeDefinitionFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.