aws.appsync.Resolver

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={
        "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"],
        ],
    })

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}

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={
        "name": "APPSYNC_JS",
        "runtime_version": "1.0.0",
    },
    pipeline_config={
        "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:  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
	})
}

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}

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={
        "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,
    })

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