pulumi-aws-kotlin/com.pulumi.aws.appsync.kotlin/Resolver

Resolver

class Resolver : KotlinCustomResource

Provides an AppSync Resolver.

Example Usage

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.appsync.GraphQLApi;
import com.pulumi.aws.appsync.GraphQLApiArgs;
import com.pulumi.aws.appsync.DataSource;
import com.pulumi.aws.appsync.DataSourceArgs;
import com.pulumi.aws.appsync.inputs.DataSourceHttpConfigArgs;
import com.pulumi.aws.appsync.Resolver;
import com.pulumi.aws.appsync.ResolverArgs;
import com.pulumi.aws.appsync.inputs.ResolverCachingConfigArgs;
import com.pulumi.aws.appsync.inputs.ResolverPipelineConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var testGraphQLApi = new GraphQLApi("testGraphQLApi", GraphQLApiArgs.builder()
            .authenticationType("API_KEY")
            .schema("""
type Mutation {
	putPost(id: ID!, title: String!): Post
}
type Post {
	id: ID!
	title: String!
}
type Query {
	singlePost(id: ID!): Post
}
schema {
	query: Query
	mutation: Mutation
}
            """)
            .build());
        var testDataSource = new DataSource("testDataSource", DataSourceArgs.builder()
            .apiId(testGraphQLApi.id())
            .name("my_example")
            .type("HTTP")
            .httpConfig(DataSourceHttpConfigArgs.builder()
                .endpoint("http://example.com")
                .build())
            .build());
        var testResolver = new Resolver("testResolver", ResolverArgs.builder()
            .apiId(testGraphQLApi.id())
            .field("singlePost")
            .type("Query")
            .dataSource(testDataSource.name())
            .requestTemplate("""
{
    "version": "2018-05-29",
    "method": "GET",
    "resourcePath": "/",
    "params":{
        "headers": $utils.http.copyheaders($ctx.request.headers)
    }
}
            """)
            .responseTemplate("""
#if($ctx.result.statusCode == 200)
    $ctx.result.body
#else
    $utils.appendError($ctx.result.body, $ctx.result.statusCode)
#end
            """)
            .cachingConfig(ResolverCachingConfigArgs.builder()
                .cachingKeys(
                    "$context.identity.sub",
                    "$context.arguments.id")
                .ttl(60)
                .build())
            .build());
        var mutationPipelineTest = new Resolver("mutationPipelineTest", ResolverArgs.builder()
            .type("Mutation")
            .apiId(testGraphQLApi.id())
            .field("pipelineTest")
            .requestTemplate("{}")
            .responseTemplate("$util.toJson($ctx.result)")
            .kind("PIPELINE")
            .pipelineConfig(ResolverPipelineConfigArgs.builder()
                .functions(
                    aws_appsync_function.test1().function_id(),
                    aws_appsync_function.test2().function_id(),
                    aws_appsync_function.test3().function_id())
                .build())
            .build());
    }
}

JS

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.appsync.Resolver;
import com.pulumi.aws.appsync.ResolverArgs;
import com.pulumi.aws.appsync.inputs.ResolverRuntimeArgs;
import com.pulumi.aws.appsync.inputs.ResolverPipelineConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new Resolver("example", ResolverArgs.builder()
            .type("Query")
            .apiId(aws_appsync_graphql_api.test().id())
            .field("pipelineTest")
            .kind("PIPELINE")
            .code(Files.readString(Paths.get("some-code-dir")))
            .runtime(ResolverRuntimeArgs.builder()
                .name("APPSYNC_JS")
                .runtimeVersion("1.0.0")
                .build())
            .pipelineConfig(ResolverPipelineConfigArgs.builder()
                .functions(aws_appsync_function.test().function_id())
                .build())
            .build());
    }
}

Import

aws_appsync_resolver can be imported with their api_id, a hyphen, type, a hypen and field e.g.,

$ pulumi import aws:appsync/resolver:Resolver example abcdef123456-exampleType-exampleField

Properties

apiId

val apiId: Output<String>

API ID for the GraphQL API.

arn

val arn: Output<String>

ARN

cachingConfig

val cachingConfig: Output<ResolverCachingConfig>?

The Caching Config. See Caching Config.

code

val code: Output<String>?

The function code that contains the request and response functions. When code is used, the runtime is required. The runtime value must be APPSYNC_JS.

dataSource

val dataSource: Output<String>?

Data source name.

field

val field: Output<String>

Field name from the schema defined in the GraphQL API.

val id: Output<String>

kind

val kind: Output<String>?

Resolver type. Valid values are UNIT and PIPELINE.

maxBatchSize

val maxBatchSize: Output<Int>?

Maximum batching size for a resolver. Valid values are between 0 and 2000.

pipelineConfig

val pipelineConfig: Output<ResolverPipelineConfig>?

The caching configuration for the resolver. See Pipeline Config.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

requestTemplate

val requestTemplate: Output<String>?

Request mapping template for UNIT resolver or 'before mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.

responseTemplate

val responseTemplate: Output<String>?

Response mapping template for UNIT resolver or 'after mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.

runtime

val runtime: Output<ResolverRuntime>?

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

syncConfig

val syncConfig: Output<ResolverSyncConfig>?

Describes a Sync configuration for a resolver. See Sync Config.

type

val type: Output<String>

Type name from the schema defined in the GraphQL API.

urn

val urn: Output<String>