1. Packages
  2. AWS Classic
  3. API Docs
  4. appsync
  5. Resolver

Try AWS Native preview for resources not in the classic version.

AWS Classic v6.41.0 published on Tuesday, Jun 18, 2024 by Pulumi

aws.appsync.Resolver

Explore with Pulumi AI

aws logo

Try AWS Native preview for resources not in the classic version.

AWS Classic v6.41.0 published on Tuesday, Jun 18, 2024 by Pulumi

    Provides an AppSync Resolver.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const test = new aws.appsync.GraphQLApi("test", {
        authenticationType: "API_KEY",
        name: "tf-example",
        schema: `type Mutation {
    \x09putPost(id: ID!, title: String!): Post
    }
    
    type Post {
    \x09id: ID!
    \x09title: String!
    }
    
    type Query {
    \x09singlePost(id: ID!): Post
    }
    
    schema {
    \x09query: Query
    \x09mutation: Mutation
    }
    `,
    });
    const testDataSource = new aws.appsync.DataSource("test", {
        apiId: test.id,
        name: "my_example",
        type: "HTTP",
        httpConfig: {
            endpoint: "http://example.com",
        },
    });
    // UNIT type resolver (default)
    const testResolver = new aws.appsync.Resolver("test", {
        apiId: test.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: {
            cachingKeys: [
                "$context.identity.sub",
                "$context.arguments.id",
            ],
            ttl: 60,
        },
    });
    // PIPELINE type resolver
    const mutationPipelineTest = new aws.appsync.Resolver("Mutation_pipelineTest", {
        type: "Mutation",
        apiId: test.id,
        field: "pipelineTest",
        requestTemplate: "{}",
        responseTemplate: "$util.toJson($ctx.result)",
        kind: "PIPELINE",
        pipelineConfig: {
            functions: [
                test1.functionId,
                test2.functionId,
                test3.functionId,
            ],
        },
    });
    
    import pulumi
    import pulumi_aws as aws
    
    test = aws.appsync.GraphQLApi("test",
        authentication_type="API_KEY",
        name="tf-example",
        schema="""type Mutation {
    \x09putPost(id: ID!, title: String!): Post
    }
    
    type Post {
    \x09id: ID!
    \x09title: String!
    }
    
    type Query {
    \x09singlePost(id: ID!): Post
    }
    
    schema {
    \x09query: Query
    \x09mutation: Mutation
    }
    """)
    test_data_source = aws.appsync.DataSource("test",
        api_id=test.id,
        name="my_example",
        type="HTTP",
        http_config=aws.appsync.DataSourceHttpConfigArgs(
            endpoint="http://example.com",
        ))
    # UNIT type resolver (default)
    test_resolver = aws.appsync.Resolver("test",
        api_id=test.id,
        field="singlePost",
        type="Query",
        data_source=test_data_source.name,
        request_template="""{
        "version": "2018-05-29",
        "method": "GET",
        "resourcePath": "/",
        "params":{
            "headers": $utils.http.copyheaders($ctx.request.headers)
        }
    }
    """,
        response_template="""#if($ctx.result.statusCode == 200)
        $ctx.result.body
    #else
        $utils.appendError($ctx.result.body, $ctx.result.statusCode)
    #end
    """,
        caching_config=aws.appsync.ResolverCachingConfigArgs(
            caching_keys=[
                "$context.identity.sub",
                "$context.arguments.id",
            ],
            ttl=60,
        ))
    # PIPELINE type resolver
    mutation_pipeline_test = aws.appsync.Resolver("Mutation_pipelineTest",
        type="Mutation",
        api_id=test.id,
        field="pipelineTest",
        request_template="{}",
        response_template="$util.toJson($ctx.result)",
        kind="PIPELINE",
        pipeline_config=aws.appsync.ResolverPipelineConfigArgs(
            functions=[
                test1["functionId"],
                test2["functionId"],
                test3["functionId"],
            ],
        ))
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/appsync"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		test, err := appsync.NewGraphQLApi(ctx, "test", &appsync.GraphQLApiArgs{
    			AuthenticationType: pulumi.String("API_KEY"),
    			Name:               pulumi.String("tf-example"),
    			Schema: pulumi.String(`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
    }
    `),
    		})
    		if err != nil {
    			return err
    		}
    		testDataSource, err := appsync.NewDataSource(ctx, "test", &appsync.DataSourceArgs{
    			ApiId: test.ID(),
    			Name:  pulumi.String("my_example"),
    			Type:  pulumi.String("HTTP"),
    			HttpConfig: &appsync.DataSourceHttpConfigArgs{
    				Endpoint: pulumi.String("http://example.com"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		// UNIT type resolver (default)
    		_, err = appsync.NewResolver(ctx, "test", &appsync.ResolverArgs{
    			ApiId:      test.ID(),
    			Field:      pulumi.String("singlePost"),
    			Type:       pulumi.String("Query"),
    			DataSource: testDataSource.Name,
    			RequestTemplate: pulumi.String(`{
        "version": "2018-05-29",
        "method": "GET",
        "resourcePath": "/",
        "params":{
            "headers": $utils.http.copyheaders($ctx.request.headers)
        }
    }
    `),
    			ResponseTemplate: pulumi.String(`#if($ctx.result.statusCode == 200)
        $ctx.result.body
    #else
        $utils.appendError($ctx.result.body, $ctx.result.statusCode)
    #end
    `),
    			CachingConfig: &appsync.ResolverCachingConfigArgs{
    				CachingKeys: pulumi.StringArray{
    					pulumi.String("$context.identity.sub"),
    					pulumi.String("$context.arguments.id"),
    				},
    				Ttl: pulumi.Int(60),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		// PIPELINE type resolver
    		_, err = appsync.NewResolver(ctx, "Mutation_pipelineTest", &appsync.ResolverArgs{
    			Type:             pulumi.String("Mutation"),
    			ApiId:            test.ID(),
    			Field:            pulumi.String("pipelineTest"),
    			RequestTemplate:  pulumi.String("{}"),
    			ResponseTemplate: pulumi.String("$util.toJson($ctx.result)"),
    			Kind:             pulumi.String("PIPELINE"),
    			PipelineConfig: &appsync.ResolverPipelineConfigArgs{
    				Functions: pulumi.StringArray{
    					test1.FunctionId,
    					test2.FunctionId,
    					test3.FunctionId,
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var test = new Aws.AppSync.GraphQLApi("test", new()
        {
            AuthenticationType = "API_KEY",
            Name = "tf-example",
            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
    }
    ",
        });
    
        var testDataSource = new Aws.AppSync.DataSource("test", new()
        {
            ApiId = test.Id,
            Name = "my_example",
            Type = "HTTP",
            HttpConfig = new Aws.AppSync.Inputs.DataSourceHttpConfigArgs
            {
                Endpoint = "http://example.com",
            },
        });
    
        // UNIT type resolver (default)
        var testResolver = new Aws.AppSync.Resolver("test", new()
        {
            ApiId = test.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 = new Aws.AppSync.Inputs.ResolverCachingConfigArgs
            {
                CachingKeys = new[]
                {
                    "$context.identity.sub",
                    "$context.arguments.id",
                },
                Ttl = 60,
            },
        });
    
        // PIPELINE type resolver
        var mutationPipelineTest = new Aws.AppSync.Resolver("Mutation_pipelineTest", new()
        {
            Type = "Mutation",
            ApiId = test.Id,
            Field = "pipelineTest",
            RequestTemplate = "{}",
            ResponseTemplate = "$util.toJson($ctx.result)",
            Kind = "PIPELINE",
            PipelineConfig = new Aws.AppSync.Inputs.ResolverPipelineConfigArgs
            {
                Functions = new[]
                {
                    test1.FunctionId,
                    test2.FunctionId,
                    test3.FunctionId,
                },
            },
        });
    
    });
    
    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 test = new GraphQLApi("test", GraphQLApiArgs.builder()
                .authenticationType("API_KEY")
                .name("tf-example")
                .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(test.id())
                .name("my_example")
                .type("HTTP")
                .httpConfig(DataSourceHttpConfigArgs.builder()
                    .endpoint("http://example.com")
                    .build())
                .build());
    
            // UNIT type resolver (default)
            var testResolver = new Resolver("testResolver", ResolverArgs.builder()
                .apiId(test.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());
    
            // PIPELINE type resolver
            var mutationPipelineTest = new Resolver("mutationPipelineTest", ResolverArgs.builder()
                .type("Mutation")
                .apiId(test.id())
                .field("pipelineTest")
                .requestTemplate("{}")
                .responseTemplate("$util.toJson($ctx.result)")
                .kind("PIPELINE")
                .pipelineConfig(ResolverPipelineConfigArgs.builder()
                    .functions(                
                        test1.functionId(),
                        test2.functionId(),
                        test3.functionId())
                    .build())
                .build());
    
        }
    }
    
    resources:
      test:
        type: aws:appsync:GraphQLApi
        properties:
          authenticationType: API_KEY
          name: tf-example
          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
            }        
      testDataSource:
        type: aws:appsync:DataSource
        name: test
        properties:
          apiId: ${test.id}
          name: my_example
          type: HTTP
          httpConfig:
            endpoint: http://example.com
      # UNIT type resolver (default)
      testResolver:
        type: aws:appsync:Resolver
        name: test
        properties:
          apiId: ${test.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:
            cachingKeys:
              - $context.identity.sub
              - $context.arguments.id
            ttl: 60
      # PIPELINE type resolver
      mutationPipelineTest:
        type: aws:appsync:Resolver
        name: Mutation_pipelineTest
        properties:
          type: Mutation
          apiId: ${test.id}
          field: pipelineTest
          requestTemplate: '{}'
          responseTemplate: $util.toJson($ctx.result)
          kind: PIPELINE
          pipelineConfig:
            functions:
              - ${test1.functionId}
              - ${test2.functionId}
              - ${test3.functionId}
    

    JS

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    import * as std from "@pulumi/std";
    
    const example = new aws.appsync.Resolver("example", {
        type: "Query",
        apiId: testAwsAppsyncGraphqlApi.id,
        field: "pipelineTest",
        kind: "PIPELINE",
        code: std.file({
            input: "some-code-dir",
        }).then(invoke => invoke.result),
        runtime: {
            name: "APPSYNC_JS",
            runtimeVersion: "1.0.0",
        },
        pipelineConfig: {
            functions: [test.functionId],
        },
    });
    
    import pulumi
    import pulumi_aws as aws
    import pulumi_std as std
    
    example = aws.appsync.Resolver("example",
        type="Query",
        api_id=test_aws_appsync_graphql_api["id"],
        field="pipelineTest",
        kind="PIPELINE",
        code=std.file(input="some-code-dir").result,
        runtime=aws.appsync.ResolverRuntimeArgs(
            name="APPSYNC_JS",
            runtime_version="1.0.0",
        ),
        pipeline_config=aws.appsync.ResolverPipelineConfigArgs(
            functions=[test["functionId"]],
        ))
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/appsync"
    	"github.com/pulumi/pulumi-std/sdk/go/std"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		invokeFile, err := std.File(ctx, &std.FileArgs{
    			Input: "some-code-dir",
    		}, nil)
    		if err != nil {
    			return err
    		}
    		_, err = appsync.NewResolver(ctx, "example", &appsync.ResolverArgs{
    			Type:  pulumi.String("Query"),
    			ApiId: pulumi.Any(testAwsAppsyncGraphqlApi.Id),
    			Field: pulumi.String("pipelineTest"),
    			Kind:  pulumi.String("PIPELINE"),
    			Code:  invokeFile.Result,
    			Runtime: &appsync.ResolverRuntimeArgs{
    				Name:           pulumi.String("APPSYNC_JS"),
    				RuntimeVersion: pulumi.String("1.0.0"),
    			},
    			PipelineConfig: &appsync.ResolverPipelineConfigArgs{
    				Functions: pulumi.StringArray{
    					test.FunctionId,
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    using Std = Pulumi.Std;
    
    return await Deployment.RunAsync(() => 
    {
        var example = new Aws.AppSync.Resolver("example", new()
        {
            Type = "Query",
            ApiId = testAwsAppsyncGraphqlApi.Id,
            Field = "pipelineTest",
            Kind = "PIPELINE",
            Code = Std.File.Invoke(new()
            {
                Input = "some-code-dir",
            }).Apply(invoke => invoke.Result),
            Runtime = new Aws.AppSync.Inputs.ResolverRuntimeArgs
            {
                Name = "APPSYNC_JS",
                RuntimeVersion = "1.0.0",
            },
            PipelineConfig = new Aws.AppSync.Inputs.ResolverPipelineConfigArgs
            {
                Functions = new[]
                {
                    test.FunctionId,
                },
            },
        });
    
    });
    
    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(testAwsAppsyncGraphqlApi.id())
                .field("pipelineTest")
                .kind("PIPELINE")
                .code(StdFunctions.file(FileArgs.builder()
                    .input("some-code-dir")
                    .build()).result())
                .runtime(ResolverRuntimeArgs.builder()
                    .name("APPSYNC_JS")
                    .runtimeVersion("1.0.0")
                    .build())
                .pipelineConfig(ResolverPipelineConfigArgs.builder()
                    .functions(test.functionId())
                    .build())
                .build());
    
        }
    }
    
    resources:
      example:
        type: aws:appsync:Resolver
        properties:
          type: Query
          apiId: ${testAwsAppsyncGraphqlApi.id}
          field: pipelineTest
          kind: PIPELINE
          code:
            fn::invoke:
              Function: std:file
              Arguments:
                input: some-code-dir
              Return: result
          runtime:
            name: APPSYNC_JS
            runtimeVersion: 1.0.0
          pipelineConfig:
            functions:
              - ${test.functionId}
    

    Create Resolver Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new Resolver(name: string, args: ResolverArgs, opts?: CustomResourceOptions);
    @overload
    def Resolver(resource_name: str,
                 args: ResolverArgs,
                 opts: Optional[ResourceOptions] = None)
    
    @overload
    def Resolver(resource_name: str,
                 opts: Optional[ResourceOptions] = None,
                 field: Optional[str] = None,
                 type: Optional[str] = None,
                 api_id: Optional[str] = None,
                 max_batch_size: Optional[int] = None,
                 data_source: Optional[str] = None,
                 kind: Optional[str] = None,
                 code: Optional[str] = None,
                 pipeline_config: Optional[ResolverPipelineConfigArgs] = None,
                 request_template: Optional[str] = None,
                 response_template: Optional[str] = None,
                 runtime: Optional[ResolverRuntimeArgs] = None,
                 sync_config: Optional[ResolverSyncConfigArgs] = None,
                 caching_config: Optional[ResolverCachingConfigArgs] = None)
    func NewResolver(ctx *Context, name string, args ResolverArgs, opts ...ResourceOption) (*Resolver, error)
    public Resolver(string name, ResolverArgs args, CustomResourceOptions? opts = null)
    public Resolver(String name, ResolverArgs args)
    public Resolver(String name, ResolverArgs args, CustomResourceOptions options)
    
    type: aws:appsync:Resolver
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    

    Parameters

    name string
    The unique name of the resource.
    args ResolverArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args ResolverArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args ResolverArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ResolverArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ResolverArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

    The following reference example uses placeholder values for all input properties.

    var resolverResource = new Aws.AppSync.Resolver("resolverResource", new()
    {
        Field = "string",
        Type = "string",
        ApiId = "string",
        MaxBatchSize = 0,
        DataSource = "string",
        Kind = "string",
        Code = "string",
        PipelineConfig = new Aws.AppSync.Inputs.ResolverPipelineConfigArgs
        {
            Functions = new[]
            {
                "string",
            },
        },
        RequestTemplate = "string",
        ResponseTemplate = "string",
        Runtime = new Aws.AppSync.Inputs.ResolverRuntimeArgs
        {
            Name = "string",
            RuntimeVersion = "string",
        },
        SyncConfig = new Aws.AppSync.Inputs.ResolverSyncConfigArgs
        {
            ConflictDetection = "string",
            ConflictHandler = "string",
            LambdaConflictHandlerConfig = new Aws.AppSync.Inputs.ResolverSyncConfigLambdaConflictHandlerConfigArgs
            {
                LambdaConflictHandlerArn = "string",
            },
        },
        CachingConfig = new Aws.AppSync.Inputs.ResolverCachingConfigArgs
        {
            CachingKeys = new[]
            {
                "string",
            },
            Ttl = 0,
        },
    });
    
    example, err := appsync.NewResolver(ctx, "resolverResource", &appsync.ResolverArgs{
    	Field:        pulumi.String("string"),
    	Type:         pulumi.String("string"),
    	ApiId:        pulumi.String("string"),
    	MaxBatchSize: pulumi.Int(0),
    	DataSource:   pulumi.String("string"),
    	Kind:         pulumi.String("string"),
    	Code:         pulumi.String("string"),
    	PipelineConfig: &appsync.ResolverPipelineConfigArgs{
    		Functions: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    	},
    	RequestTemplate:  pulumi.String("string"),
    	ResponseTemplate: pulumi.String("string"),
    	Runtime: &appsync.ResolverRuntimeArgs{
    		Name:           pulumi.String("string"),
    		RuntimeVersion: pulumi.String("string"),
    	},
    	SyncConfig: &appsync.ResolverSyncConfigArgs{
    		ConflictDetection: pulumi.String("string"),
    		ConflictHandler:   pulumi.String("string"),
    		LambdaConflictHandlerConfig: &appsync.ResolverSyncConfigLambdaConflictHandlerConfigArgs{
    			LambdaConflictHandlerArn: pulumi.String("string"),
    		},
    	},
    	CachingConfig: &appsync.ResolverCachingConfigArgs{
    		CachingKeys: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    		Ttl: pulumi.Int(0),
    	},
    })
    
    var resolverResource = new Resolver("resolverResource", ResolverArgs.builder()
        .field("string")
        .type("string")
        .apiId("string")
        .maxBatchSize(0)
        .dataSource("string")
        .kind("string")
        .code("string")
        .pipelineConfig(ResolverPipelineConfigArgs.builder()
            .functions("string")
            .build())
        .requestTemplate("string")
        .responseTemplate("string")
        .runtime(ResolverRuntimeArgs.builder()
            .name("string")
            .runtimeVersion("string")
            .build())
        .syncConfig(ResolverSyncConfigArgs.builder()
            .conflictDetection("string")
            .conflictHandler("string")
            .lambdaConflictHandlerConfig(ResolverSyncConfigLambdaConflictHandlerConfigArgs.builder()
                .lambdaConflictHandlerArn("string")
                .build())
            .build())
        .cachingConfig(ResolverCachingConfigArgs.builder()
            .cachingKeys("string")
            .ttl(0)
            .build())
        .build());
    
    resolver_resource = aws.appsync.Resolver("resolverResource",
        field="string",
        type="string",
        api_id="string",
        max_batch_size=0,
        data_source="string",
        kind="string",
        code="string",
        pipeline_config=aws.appsync.ResolverPipelineConfigArgs(
            functions=["string"],
        ),
        request_template="string",
        response_template="string",
        runtime=aws.appsync.ResolverRuntimeArgs(
            name="string",
            runtime_version="string",
        ),
        sync_config=aws.appsync.ResolverSyncConfigArgs(
            conflict_detection="string",
            conflict_handler="string",
            lambda_conflict_handler_config=aws.appsync.ResolverSyncConfigLambdaConflictHandlerConfigArgs(
                lambda_conflict_handler_arn="string",
            ),
        ),
        caching_config=aws.appsync.ResolverCachingConfigArgs(
            caching_keys=["string"],
            ttl=0,
        ))
    
    const resolverResource = new aws.appsync.Resolver("resolverResource", {
        field: "string",
        type: "string",
        apiId: "string",
        maxBatchSize: 0,
        dataSource: "string",
        kind: "string",
        code: "string",
        pipelineConfig: {
            functions: ["string"],
        },
        requestTemplate: "string",
        responseTemplate: "string",
        runtime: {
            name: "string",
            runtimeVersion: "string",
        },
        syncConfig: {
            conflictDetection: "string",
            conflictHandler: "string",
            lambdaConflictHandlerConfig: {
                lambdaConflictHandlerArn: "string",
            },
        },
        cachingConfig: {
            cachingKeys: ["string"],
            ttl: 0,
        },
    });
    
    type: aws:appsync:Resolver
    properties:
        apiId: string
        cachingConfig:
            cachingKeys:
                - string
            ttl: 0
        code: string
        dataSource: string
        field: string
        kind: string
        maxBatchSize: 0
        pipelineConfig:
            functions:
                - string
        requestTemplate: string
        responseTemplate: string
        runtime:
            name: string
            runtimeVersion: string
        syncConfig:
            conflictDetection: string
            conflictHandler: string
            lambdaConflictHandlerConfig:
                lambdaConflictHandlerArn: string
        type: string
    

    Resolver Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    The Resolver resource accepts the following input properties:

    ApiId string
    API ID for the GraphQL API.
    Field string
    Field name from the schema defined in the GraphQL API.
    Type string
    Type name from the schema defined in the GraphQL API.
    CachingConfig ResolverCachingConfig
    The Caching Config. See Caching Config.
    Code 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 string
    Data source name.
    Kind string
    Resolver type. Valid values are UNIT and PIPELINE.
    MaxBatchSize int
    Maximum batching size for a resolver. Valid values are between 0 and 2000.
    PipelineConfig ResolverPipelineConfig
    The caching configuration for the resolver. See Pipeline Config.
    RequestTemplate string
    Request mapping template for UNIT resolver or 'before mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    ResponseTemplate string
    Response mapping template for UNIT resolver or 'after mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    Runtime 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 ResolverSyncConfig
    Describes a Sync configuration for a resolver. See Sync Config.
    ApiId string
    API ID for the GraphQL API.
    Field string
    Field name from the schema defined in the GraphQL API.
    Type string
    Type name from the schema defined in the GraphQL API.
    CachingConfig ResolverCachingConfigArgs
    The Caching Config. See Caching Config.
    Code 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 string
    Data source name.
    Kind string
    Resolver type. Valid values are UNIT and PIPELINE.
    MaxBatchSize int
    Maximum batching size for a resolver. Valid values are between 0 and 2000.
    PipelineConfig ResolverPipelineConfigArgs
    The caching configuration for the resolver. See Pipeline Config.
    RequestTemplate string
    Request mapping template for UNIT resolver or 'before mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    ResponseTemplate string
    Response mapping template for UNIT resolver or 'after mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    Runtime ResolverRuntimeArgs
    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 ResolverSyncConfigArgs
    Describes a Sync configuration for a resolver. See Sync Config.
    apiId String
    API ID for the GraphQL API.
    field String
    Field name from the schema defined in the GraphQL API.
    type String
    Type name from the schema defined in the GraphQL API.
    cachingConfig ResolverCachingConfig
    The Caching Config. See Caching Config.
    code 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 String
    Data source name.
    kind String
    Resolver type. Valid values are UNIT and PIPELINE.
    maxBatchSize Integer
    Maximum batching size for a resolver. Valid values are between 0 and 2000.
    pipelineConfig ResolverPipelineConfig
    The caching configuration for the resolver. See Pipeline Config.
    requestTemplate String
    Request mapping template for UNIT resolver or 'before mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    responseTemplate String
    Response mapping template for UNIT resolver or 'after mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    runtime 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 ResolverSyncConfig
    Describes a Sync configuration for a resolver. See Sync Config.
    apiId string
    API ID for the GraphQL API.
    field string
    Field name from the schema defined in the GraphQL API.
    type string
    Type name from the schema defined in the GraphQL API.
    cachingConfig ResolverCachingConfig
    The Caching Config. See Caching Config.
    code 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 string
    Data source name.
    kind string
    Resolver type. Valid values are UNIT and PIPELINE.
    maxBatchSize number
    Maximum batching size for a resolver. Valid values are between 0 and 2000.
    pipelineConfig ResolverPipelineConfig
    The caching configuration for the resolver. See Pipeline Config.
    requestTemplate string
    Request mapping template for UNIT resolver or 'before mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    responseTemplate string
    Response mapping template for UNIT resolver or 'after mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    runtime 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 ResolverSyncConfig
    Describes a Sync configuration for a resolver. See Sync Config.
    api_id str
    API ID for the GraphQL API.
    field str
    Field name from the schema defined in the GraphQL API.
    type str
    Type name from the schema defined in the GraphQL API.
    caching_config ResolverCachingConfigArgs
    The Caching Config. See Caching Config.
    code str
    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.
    data_source str
    Data source name.
    kind str
    Resolver type. Valid values are UNIT and PIPELINE.
    max_batch_size int
    Maximum batching size for a resolver. Valid values are between 0 and 2000.
    pipeline_config ResolverPipelineConfigArgs
    The caching configuration for the resolver. See Pipeline Config.
    request_template str
    Request mapping template for UNIT resolver or 'before mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    response_template str
    Response mapping template for UNIT resolver or 'after mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    runtime ResolverRuntimeArgs
    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.
    sync_config ResolverSyncConfigArgs
    Describes a Sync configuration for a resolver. See Sync Config.
    apiId String
    API ID for the GraphQL API.
    field String
    Field name from the schema defined in the GraphQL API.
    type String
    Type name from the schema defined in the GraphQL API.
    cachingConfig Property Map
    The Caching Config. See Caching Config.
    code 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 String
    Data source name.
    kind String
    Resolver type. Valid values are UNIT and PIPELINE.
    maxBatchSize Number
    Maximum batching size for a resolver. Valid values are between 0 and 2000.
    pipelineConfig Property Map
    The caching configuration for the resolver. See Pipeline Config.
    requestTemplate String
    Request mapping template for UNIT resolver or 'before mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    responseTemplate String
    Response mapping template for UNIT resolver or 'after mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    runtime Property Map
    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 Property Map
    Describes a Sync configuration for a resolver. See Sync Config.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the Resolver resource produces the following output properties:

    Arn string
    ARN
    Id string
    The provider-assigned unique ID for this managed resource.
    Arn string
    ARN
    Id string
    The provider-assigned unique ID for this managed resource.
    arn String
    ARN
    id String
    The provider-assigned unique ID for this managed resource.
    arn string
    ARN
    id string
    The provider-assigned unique ID for this managed resource.
    arn str
    ARN
    id str
    The provider-assigned unique ID for this managed resource.
    arn String
    ARN
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing Resolver Resource

    Get an existing Resolver resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: ResolverState, opts?: CustomResourceOptions): Resolver
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            api_id: Optional[str] = None,
            arn: Optional[str] = None,
            caching_config: Optional[ResolverCachingConfigArgs] = None,
            code: Optional[str] = None,
            data_source: Optional[str] = None,
            field: Optional[str] = None,
            kind: Optional[str] = None,
            max_batch_size: Optional[int] = None,
            pipeline_config: Optional[ResolverPipelineConfigArgs] = None,
            request_template: Optional[str] = None,
            response_template: Optional[str] = None,
            runtime: Optional[ResolverRuntimeArgs] = None,
            sync_config: Optional[ResolverSyncConfigArgs] = None,
            type: Optional[str] = None) -> Resolver
    func GetResolver(ctx *Context, name string, id IDInput, state *ResolverState, opts ...ResourceOption) (*Resolver, error)
    public static Resolver Get(string name, Input<string> id, ResolverState? state, CustomResourceOptions? opts = null)
    public static Resolver get(String name, Output<String> id, ResolverState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    ApiId string
    API ID for the GraphQL API.
    Arn string
    ARN
    CachingConfig ResolverCachingConfig
    The Caching Config. See Caching Config.
    Code 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 string
    Data source name.
    Field string
    Field name from the schema defined in the GraphQL API.
    Kind string
    Resolver type. Valid values are UNIT and PIPELINE.
    MaxBatchSize int
    Maximum batching size for a resolver. Valid values are between 0 and 2000.
    PipelineConfig ResolverPipelineConfig
    The caching configuration for the resolver. See Pipeline Config.
    RequestTemplate string
    Request mapping template for UNIT resolver or 'before mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    ResponseTemplate string
    Response mapping template for UNIT resolver or 'after mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    Runtime 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 ResolverSyncConfig
    Describes a Sync configuration for a resolver. See Sync Config.
    Type string
    Type name from the schema defined in the GraphQL API.
    ApiId string
    API ID for the GraphQL API.
    Arn string
    ARN
    CachingConfig ResolverCachingConfigArgs
    The Caching Config. See Caching Config.
    Code 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 string
    Data source name.
    Field string
    Field name from the schema defined in the GraphQL API.
    Kind string
    Resolver type. Valid values are UNIT and PIPELINE.
    MaxBatchSize int
    Maximum batching size for a resolver. Valid values are between 0 and 2000.
    PipelineConfig ResolverPipelineConfigArgs
    The caching configuration for the resolver. See Pipeline Config.
    RequestTemplate string
    Request mapping template for UNIT resolver or 'before mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    ResponseTemplate string
    Response mapping template for UNIT resolver or 'after mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    Runtime ResolverRuntimeArgs
    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 ResolverSyncConfigArgs
    Describes a Sync configuration for a resolver. See Sync Config.
    Type string
    Type name from the schema defined in the GraphQL API.
    apiId String
    API ID for the GraphQL API.
    arn String
    ARN
    cachingConfig ResolverCachingConfig
    The Caching Config. See Caching Config.
    code 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 String
    Data source name.
    field String
    Field name from the schema defined in the GraphQL API.
    kind String
    Resolver type. Valid values are UNIT and PIPELINE.
    maxBatchSize Integer
    Maximum batching size for a resolver. Valid values are between 0 and 2000.
    pipelineConfig ResolverPipelineConfig
    The caching configuration for the resolver. See Pipeline Config.
    requestTemplate String
    Request mapping template for UNIT resolver or 'before mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    responseTemplate String
    Response mapping template for UNIT resolver or 'after mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    runtime 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 ResolverSyncConfig
    Describes a Sync configuration for a resolver. See Sync Config.
    type String
    Type name from the schema defined in the GraphQL API.
    apiId string
    API ID for the GraphQL API.
    arn string
    ARN
    cachingConfig ResolverCachingConfig
    The Caching Config. See Caching Config.
    code 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 string
    Data source name.
    field string
    Field name from the schema defined in the GraphQL API.
    kind string
    Resolver type. Valid values are UNIT and PIPELINE.
    maxBatchSize number
    Maximum batching size for a resolver. Valid values are between 0 and 2000.
    pipelineConfig ResolverPipelineConfig
    The caching configuration for the resolver. See Pipeline Config.
    requestTemplate string
    Request mapping template for UNIT resolver or 'before mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    responseTemplate string
    Response mapping template for UNIT resolver or 'after mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    runtime 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 ResolverSyncConfig
    Describes a Sync configuration for a resolver. See Sync Config.
    type string
    Type name from the schema defined in the GraphQL API.
    api_id str
    API ID for the GraphQL API.
    arn str
    ARN
    caching_config ResolverCachingConfigArgs
    The Caching Config. See Caching Config.
    code str
    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.
    data_source str
    Data source name.
    field str
    Field name from the schema defined in the GraphQL API.
    kind str
    Resolver type. Valid values are UNIT and PIPELINE.
    max_batch_size int
    Maximum batching size for a resolver. Valid values are between 0 and 2000.
    pipeline_config ResolverPipelineConfigArgs
    The caching configuration for the resolver. See Pipeline Config.
    request_template str
    Request mapping template for UNIT resolver or 'before mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    response_template str
    Response mapping template for UNIT resolver or 'after mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    runtime ResolverRuntimeArgs
    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.
    sync_config ResolverSyncConfigArgs
    Describes a Sync configuration for a resolver. See Sync Config.
    type str
    Type name from the schema defined in the GraphQL API.
    apiId String
    API ID for the GraphQL API.
    arn String
    ARN
    cachingConfig Property Map
    The Caching Config. See Caching Config.
    code 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 String
    Data source name.
    field String
    Field name from the schema defined in the GraphQL API.
    kind String
    Resolver type. Valid values are UNIT and PIPELINE.
    maxBatchSize Number
    Maximum batching size for a resolver. Valid values are between 0 and 2000.
    pipelineConfig Property Map
    The caching configuration for the resolver. See Pipeline Config.
    requestTemplate String
    Request mapping template for UNIT resolver or 'before mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    responseTemplate String
    Response mapping template for UNIT resolver or 'after mapping template' for PIPELINE resolver. Required for non-Lambda resolvers.
    runtime Property Map
    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 Property Map
    Describes a Sync configuration for a resolver. See Sync Config.
    type String
    Type name from the schema defined in the GraphQL API.

    Supporting Types

    ResolverCachingConfig, ResolverCachingConfigArgs

    CachingKeys List<string>
    The caching keys for a resolver that has caching activated. Valid values are entries from the $context.arguments, $context.source, and $context.identity maps.
    Ttl int
    The TTL in seconds for a resolver that has caching activated. Valid values are between 1 and 3600 seconds.
    CachingKeys []string
    The caching keys for a resolver that has caching activated. Valid values are entries from the $context.arguments, $context.source, and $context.identity maps.
    Ttl int
    The TTL in seconds for a resolver that has caching activated. Valid values are between 1 and 3600 seconds.
    cachingKeys List<String>
    The caching keys for a resolver that has caching activated. Valid values are entries from the $context.arguments, $context.source, and $context.identity maps.
    ttl Integer
    The TTL in seconds for a resolver that has caching activated. Valid values are between 1 and 3600 seconds.
    cachingKeys string[]
    The caching keys for a resolver that has caching activated. Valid values are entries from the $context.arguments, $context.source, and $context.identity maps.
    ttl number
    The TTL in seconds for a resolver that has caching activated. Valid values are between 1 and 3600 seconds.
    caching_keys Sequence[str]
    The caching keys for a resolver that has caching activated. Valid values are entries from the $context.arguments, $context.source, and $context.identity maps.
    ttl int
    The TTL in seconds for a resolver that has caching activated. Valid values are between 1 and 3600 seconds.
    cachingKeys List<String>
    The caching keys for a resolver that has caching activated. Valid values are entries from the $context.arguments, $context.source, and $context.identity maps.
    ttl Number
    The TTL in seconds for a resolver that has caching activated. Valid values are between 1 and 3600 seconds.

    ResolverPipelineConfig, ResolverPipelineConfigArgs

    Functions List<string>
    A list of Function objects.
    Functions []string
    A list of Function objects.
    functions List<String>
    A list of Function objects.
    functions string[]
    A list of Function objects.
    functions Sequence[str]
    A list of Function objects.
    functions List<String>
    A list of Function objects.

    ResolverRuntime, ResolverRuntimeArgs

    Name string
    The name of the runtime to use. Currently, the only allowed value is APPSYNC_JS.
    RuntimeVersion string
    The version of the runtime to use. Currently, the only allowed version is 1.0.0.
    Name string
    The name of the runtime to use. Currently, the only allowed value is APPSYNC_JS.
    RuntimeVersion string
    The version of the runtime to use. Currently, the only allowed version is 1.0.0.
    name String
    The name of the runtime to use. Currently, the only allowed value is APPSYNC_JS.
    runtimeVersion String
    The version of the runtime to use. Currently, the only allowed version is 1.0.0.
    name string
    The name of the runtime to use. Currently, the only allowed value is APPSYNC_JS.
    runtimeVersion string
    The version of the runtime to use. Currently, the only allowed version is 1.0.0.
    name str
    The name of the runtime to use. Currently, the only allowed value is APPSYNC_JS.
    runtime_version str
    The version of the runtime to use. Currently, the only allowed version is 1.0.0.
    name String
    The name of the runtime to use. Currently, the only allowed value is APPSYNC_JS.
    runtimeVersion String
    The version of the runtime to use. Currently, the only allowed version is 1.0.0.

    ResolverSyncConfig, ResolverSyncConfigArgs

    ConflictDetection string
    Conflict Detection strategy to use. Valid values are NONE and VERSION.
    ConflictHandler string
    Conflict Resolution strategy to perform in the event of a conflict. Valid values are NONE, OPTIMISTIC_CONCURRENCY, AUTOMERGE, and LAMBDA.
    LambdaConflictHandlerConfig ResolverSyncConfigLambdaConflictHandlerConfig
    Lambda Conflict Handler Config when configuring LAMBDA as the Conflict Handler. See Lambda Conflict Handler Config.
    ConflictDetection string
    Conflict Detection strategy to use. Valid values are NONE and VERSION.
    ConflictHandler string
    Conflict Resolution strategy to perform in the event of a conflict. Valid values are NONE, OPTIMISTIC_CONCURRENCY, AUTOMERGE, and LAMBDA.
    LambdaConflictHandlerConfig ResolverSyncConfigLambdaConflictHandlerConfig
    Lambda Conflict Handler Config when configuring LAMBDA as the Conflict Handler. See Lambda Conflict Handler Config.
    conflictDetection String
    Conflict Detection strategy to use. Valid values are NONE and VERSION.
    conflictHandler String
    Conflict Resolution strategy to perform in the event of a conflict. Valid values are NONE, OPTIMISTIC_CONCURRENCY, AUTOMERGE, and LAMBDA.
    lambdaConflictHandlerConfig ResolverSyncConfigLambdaConflictHandlerConfig
    Lambda Conflict Handler Config when configuring LAMBDA as the Conflict Handler. See Lambda Conflict Handler Config.
    conflictDetection string
    Conflict Detection strategy to use. Valid values are NONE and VERSION.
    conflictHandler string
    Conflict Resolution strategy to perform in the event of a conflict. Valid values are NONE, OPTIMISTIC_CONCURRENCY, AUTOMERGE, and LAMBDA.
    lambdaConflictHandlerConfig ResolverSyncConfigLambdaConflictHandlerConfig
    Lambda Conflict Handler Config when configuring LAMBDA as the Conflict Handler. See Lambda Conflict Handler Config.
    conflict_detection str
    Conflict Detection strategy to use. Valid values are NONE and VERSION.
    conflict_handler str
    Conflict Resolution strategy to perform in the event of a conflict. Valid values are NONE, OPTIMISTIC_CONCURRENCY, AUTOMERGE, and LAMBDA.
    lambda_conflict_handler_config ResolverSyncConfigLambdaConflictHandlerConfig
    Lambda Conflict Handler Config when configuring LAMBDA as the Conflict Handler. See Lambda Conflict Handler Config.
    conflictDetection String
    Conflict Detection strategy to use. Valid values are NONE and VERSION.
    conflictHandler String
    Conflict Resolution strategy to perform in the event of a conflict. Valid values are NONE, OPTIMISTIC_CONCURRENCY, AUTOMERGE, and LAMBDA.
    lambdaConflictHandlerConfig Property Map
    Lambda Conflict Handler Config when configuring LAMBDA as the Conflict Handler. See Lambda Conflict Handler Config.

    ResolverSyncConfigLambdaConflictHandlerConfig, ResolverSyncConfigLambdaConflictHandlerConfigArgs

    LambdaConflictHandlerArn string
    ARN for the Lambda function to use as the Conflict Handler.
    LambdaConflictHandlerArn string
    ARN for the Lambda function to use as the Conflict Handler.
    lambdaConflictHandlerArn String
    ARN for the Lambda function to use as the Conflict Handler.
    lambdaConflictHandlerArn string
    ARN for the Lambda function to use as the Conflict Handler.
    lambda_conflict_handler_arn str
    ARN for the Lambda function to use as the Conflict Handler.
    lambdaConflictHandlerArn String
    ARN for the Lambda function to use as the Conflict Handler.

    Import

    Using pulumi import, import aws_appsync_resolver using the api_id, a hyphen, type, a hypen and field. For example:

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

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    AWS Classic pulumi/pulumi-aws
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the aws Terraform Provider.
    aws logo

    Try AWS Native preview for resources not in the classic version.

    AWS Classic v6.41.0 published on Tuesday, Jun 18, 2024 by Pulumi