Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. AWS
  3. API Docs
  4. appsync
  5. Resolver
AWS v6.77.1 published on Friday, Apr 18, 2025 by Pulumi
pulumi/pulumi-aws

aws.appsync.Resolver

Explore with Pulumi AI

AWS v6.77.1 published on Friday, Apr 18, 2025 by Pulumi
pulumi/pulumi-aws

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,
        ],
    },
});
Copy
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={
        "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={
        "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={
        "functions": [
            test1["functionId"],
            test2["functionId"],
            test3["functionId"],
        ],
    })
Copy
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
	})
}
Copy
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,
            },
        },
    });

});
Copy
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());

    }
}
Copy
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}
Copy

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],
    },
});
Copy
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={
        "name": "APPSYNC_JS",
        "runtime_version": "1.0.0",
    },
    pipeline_config={
        "functions": [test["functionId"]],
    })
Copy
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:  pulumi.String(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
	})
}
Copy
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,
            },
        },
    });

});
Copy
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 com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.FileArgs;
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());

    }
}
Copy
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}
Copy

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 This property is required. string
The unique name of the resource.
args This property is required. ResolverArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
resource_name This property is required. str
The unique name of the resource.
args This property is required. 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 This property is required. string
The unique name of the resource.
args This property is required. ResolverArgs
The arguments to resource properties.
opts ResourceOption
Bag of options to control resource's behavior.
name This property is required. string
The unique name of the resource.
args This property is required. ResolverArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
name This property is required. String
The unique name of the resource.
args This property is required. ResolverArgs
The arguments to resource properties.
options CustomResourceOptions
Bag of options to control resource's behavior.

Constructor 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,
    },
});
Copy
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),
	},
})
Copy
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());
Copy
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={
        "functions": ["string"],
    },
    request_template="string",
    response_template="string",
    runtime={
        "name": "string",
        "runtime_version": "string",
    },
    sync_config={
        "conflict_detection": "string",
        "conflict_handler": "string",
        "lambda_conflict_handler_config": {
            "lambda_conflict_handler_arn": "string",
        },
    },
    caching_config={
        "caching_keys": ["string"],
        "ttl": 0,
    })
Copy
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,
    },
});
Copy
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
Copy

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

In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

The Resolver resource accepts the following input properties:

ApiId
This property is required.
Changes to this property will trigger replacement.
string
API ID for the GraphQL API.
Field
This property is required.
Changes to this property will trigger replacement.
string
Field name from the schema defined in the GraphQL API.
Type
This property is required.
Changes to this property will trigger replacement.
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
This property is required.
Changes to this property will trigger replacement.
string
API ID for the GraphQL API.
Field
This property is required.
Changes to this property will trigger replacement.
string
Field name from the schema defined in the GraphQL API.
Type
This property is required.
Changes to this property will trigger replacement.
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
This property is required.
Changes to this property will trigger replacement.
String
API ID for the GraphQL API.
field
This property is required.
Changes to this property will trigger replacement.
String
Field name from the schema defined in the GraphQL API.
type
This property is required.
Changes to this property will trigger replacement.
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
This property is required.
Changes to this property will trigger replacement.
string
API ID for the GraphQL API.
field
This property is required.
Changes to this property will trigger replacement.
string
Field name from the schema defined in the GraphQL API.
type
This property is required.
Changes to this property will trigger replacement.
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
This property is required.
Changes to this property will trigger replacement.
str
API ID for the GraphQL API.
field
This property is required.
Changes to this property will trigger replacement.
str
Field name from the schema defined in the GraphQL API.
type
This property is required.
Changes to this property will trigger replacement.
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
This property is required.
Changes to this property will trigger replacement.
String
API ID for the GraphQL API.
field
This property is required.
Changes to this property will trigger replacement.
String
Field name from the schema defined in the GraphQL API.
type
This property is required.
Changes to this property will trigger replacement.
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)
resources:  _:    type: aws:appsync:Resolver    get:      id: ${id}
name This property is required.
The unique name of the resulting resource.
id This property is required.
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 This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
name This property is required.
The unique name of the resulting resource.
id This property is required.
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 This property is required.
The unique name of the resulting resource.
id This property is required.
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 This property is required.
The unique name of the resulting resource.
id This property is required.
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 Changes to this property will trigger replacement. 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 Changes to this property will trigger replacement. 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 Changes to this property will trigger replacement. string
Type name from the schema defined in the GraphQL API.
ApiId Changes to this property will trigger replacement. 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 Changes to this property will trigger replacement. 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 Changes to this property will trigger replacement. string
Type name from the schema defined in the GraphQL API.
apiId Changes to this property will trigger replacement. 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 Changes to this property will trigger replacement. 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 Changes to this property will trigger replacement. String
Type name from the schema defined in the GraphQL API.
apiId Changes to this property will trigger replacement. 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 Changes to this property will trigger replacement. 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 Changes to this property will trigger replacement. string
Type name from the schema defined in the GraphQL API.
api_id Changes to this property will trigger replacement. 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 Changes to this property will trigger replacement. 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 Changes to this property will trigger replacement. str
Type name from the schema defined in the GraphQL API.
apiId Changes to this property will trigger replacement. 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 Changes to this property will trigger replacement. 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 Changes to this property will trigger replacement. 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 This property is required. string
The name of the runtime to use. Currently, the only allowed value is APPSYNC_JS.
RuntimeVersion This property is required. string
The version of the runtime to use. Currently, the only allowed version is 1.0.0.
Name This property is required. string
The name of the runtime to use. Currently, the only allowed value is APPSYNC_JS.
RuntimeVersion This property is required. string
The version of the runtime to use. Currently, the only allowed version is 1.0.0.
name This property is required. String
The name of the runtime to use. Currently, the only allowed value is APPSYNC_JS.
runtimeVersion This property is required. String
The version of the runtime to use. Currently, the only allowed version is 1.0.0.
name This property is required. string
The name of the runtime to use. Currently, the only allowed value is APPSYNC_JS.
runtimeVersion This property is required. string
The version of the runtime to use. Currently, the only allowed version is 1.0.0.
name This property is required. str
The name of the runtime to use. Currently, the only allowed value is APPSYNC_JS.
runtime_version This property is required. str
The version of the runtime to use. Currently, the only allowed version is 1.0.0.
name This property is required. String
The name of the runtime to use. Currently, the only allowed value is APPSYNC_JS.
runtimeVersion This property is required. 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
Copy

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 v6.77.1 published on Friday, Apr 18, 2025 by Pulumi
pulumi/pulumi-aws